警惕！铭飞CMS5.2.9重大SQL漏洞曝光及修复指南

后端小肥肠

于 2024-12-19 15:30:39 发布

阅读量1.4k

点赞数 63

分类专栏：实战项目文章标签： sql 数据库 spring boot java 后端

本文链接：https://blog.youkuaiyun.com/c18213590220/article/details/144455632

版权

实战项目专栏收录该内容

5 篇文章

订阅专栏

作者：后端小肥肠

🍇 我写过的文章中的相关代码放到了gitee，地址：xfc-fdw-cloud: 公共解决方案

🍊 有疑问可私信或评论区联系我。

🥑 创作不易未经允许严禁转载。

1. 前言

因为项目需求，需要搭建一个门户网站，经过一番技术选型，最终选择了 铭飞CMS。

铭飞官网：

铭软・铭飞官网・低代码开发平台・免费开源Java Cms

铭飞源码：

MCMS: 🌈🌈🌈祝开发者国庆节快乐！免费可商用的开源Java CMS内容管理系统/基于SpringBoot 2/前端Vue3/element plus/提供上百套模板,同时提供实用的插件/每两个月收集issues问题并更新版本/一套简单好用开源免费的Java CMS内容管理系/一整套优质的开源生态内容体系。我们的使命就是降低开发成本提高开发效率，提供全方位的企业级开发解决方案。

然而，系统上线后被安全扫描发现存在 SQL注入漏洞，向铭飞客服咨询后，对方建议升级系统。

于系统已上线，升级版本有一定的代价（配置成本），因此我选择了通过 源码改造 来解决问题。幸运的是，最终成功修复了漏洞。

如果你也遇到类似问题，接下来这篇文章将带你一步步解决！

2.什么是SQL注入漏洞

SQL注入（SQL Injection） 是一种常见的网络安全漏洞，主要发生在应用程序与数据库交互的过程中。攻击者通过构造恶意的SQL语句，将其注入到应用程序的输入参数中，从而达到执行未授权操作的目的，如篡改数据、泄露敏感信息，甚至破坏整个数据库系统。

2.1 SQL注入的原理

SQL注入的根本原因在于 应用程序没有对用户输入进行有效的过滤和校验，导致攻击者能够通过输入框、URL参数、表单等途径向数据库执行恶意SQL语句。

攻击示例：

假设有一个登录查询：

SELECT * FROM users WHERE username = 'user_input' AND password = 'pass_input';

如果攻击者输入如下内容：

用户名：admin' --
密码：任意内容

则查询变为：

SELECT * FROM users WHERE username = 'admin' --' AND password = '任意内容';

-- 表示SQL中的注释符，后面的部分被忽略。这使得SQL语句仅验证 username = 'admin'，绕过了密码校验，直接登录成功。

2.2 SQL注入的危害

SQL注入漏洞的危害极大，包括但不限于：

数据泄露：攻击者可以查询数据库中的敏感数据，比如用户密码、信用卡信息等。
数据篡改：攻击者可以修改数据库中的数据，如篡改用户权限、删除数据记录等。
服务器破坏：攻击者可以通过恶意SQL语句执行系统命令，甚至控制整个服务器。
业务逻辑破坏：攻击者可利用SQL注入绕过权限验证，导致系统业务逻辑失效。
导致数据持久化损坏：破坏或删除数据库，造成严重的业务数据丢失。

2.3 SQL注入的类型

根据SQL注入的攻击方式，可以分为以下几种类型：

基于错误回显的注入
攻击者通过在输入中构造错误语句，利用数据库返回的错误信息来判断SQL执行情况。
基于联合查询的注入（Union-based）
利用SQL的 UNION 语句，合并查询结果，达到数据窃取的目的。
基于盲注的注入（Blind SQL Injection）
数据库不返回具体错误信息，攻击者通过布尔条件或时间延迟等方式判断注入结果。
基于时间的注入（Time-based）
通过构造带有 SLEEP() 等时间延迟函数的语句，根据响应时间判断注入成功与否。
堆叠查询注入
攻击者利用数据库支持的多条查询执行能力，通过分号 ; 执行多个SQL语句。

2.4 常见的SQL注入入口

SQL注入通常发生在以下几种输入位置：

表单输入：如登录表单、搜索框、评论输入框等。
URL参数：如 id=123、name='test' 等。
Cookie数据：攻击者可以在Cookie中注入SQL语句。
HTTP请求头：如 User-Agent、Referer 等头信息中隐藏恶意SQL代码。
JSON请求体：在前后端分离项目中，POST/PUT请求的JSON体中存在注入风险。

2.5 SQL注入的预防方法

为了防止SQL注入漏洞，开发者可以采取以下安全措施：

使用预编译的SQL语句
使用 PreparedStatement 或ORM框架（如MyBatis、Hibernate）提供的参数化查询，确保SQL与用户输入分离。

String sql = "SELECT * FROM users WHERE username = ? AND password = ?"; PreparedStatement stmt = connection.prepareStatement(sql); stmt.setString(1, username); stmt.setString(2, password);

对输入数据进行严格校验与过滤
通过正则表达式限制输入的内容，禁止特殊字符（如 --、'、/* 等）。
最小化数据库权限
为数据库用户设置最小权限，防止攻击者执行敏感操作。
使用Web应用防火墙（WAF）
通过安全工具拦截SQL注入攻击请求。
日志与监控
记录异常SQL执行日志，及时发现并阻止潜在攻击。

3. SQL注入漏洞修复代码实现

铭飞的源码我就不拆解了，就是一个SpringBoot项目，直接贴修复代码：

1.编写SqlInjectionInterceptor

@Component
public class SqlInjectionInterceptor implements HandlerInterceptor {

    private static final Logger log = LoggerFactory.getLogger(SqlInjectionInterceptor.class);

    private static final String SQL_INJECTION_PATTERN =
            "(?i)\\b(and|or)\\b.{1,6}?(=|>|<|\\bin\\b|\\blike\\b)|\\/\\*.+?\\*\\/|<\\s*script\\b|\\bEXEC\\b|UNION.+?SELECT|UPDATE.+?SET|INSERT\\s+INTO.+?VALUES|(SELECT|DELETE).+?FROM|(CREATE|ALTER|DROP|TRUNCATE)\\s+(TABLE|DATABASE)";

    private static final Pattern URL_REQUEST_CHAR_PATTERN = Pattern.compile("[<>%;()&'\"]");

    private static final Pattern[] XSS_PATTERNS = {
            Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE),
            Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
            Pattern.compile("</script>", Pattern.CASE_INSENSITIVE),
            Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
            Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
            Pattern.compile("expression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
            Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE),
            Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE),
            Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL)
    };

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 检查请求参数
        if (!checkParameters(request)) {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid input detected");
            return false;
        }

        // 检查请求体（对于POST和PUT请求）
        if ("POST".equalsIgnoreCase(request.getMethod()) || "PUT".equalsIgnoreCase(request.getMethod())) {
            if (!checkRequestBody(request)) {
                response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid input detected in request body");
                return false;
            }
        }

        return true;
    }

    private boolean checkParameters(HttpServletRequest request) {
        for (String paramName : request.getParameterMap().keySet()) {
            String[] values = request.getParameterValues(paramName);
            if (values != null) {
                for (String value : values) {
                    try {
                        // 对 URL 编码后的参数进行解码再检查
                        String decodedValue = URLDecoder.decode(value, StandardCharsets.UTF_8.name());
                        if (!isValidInput(decodedValue)) {
                            log.warn("Potentially malicious input detected in parameter '{}': {}", paramName, decodedValue);
                            return false;
                        }
                    } catch (Exception e) {
                        log.error("Error decoding parameter: {}", paramName, e);
                        return false;
                    }
                }
            }
        }
        return true;
    }

    private boolean checkRequestBody(HttpServletRequest request) throws IOException {
        String body = getRequestBody(request);
        if (StringUtils.isNotBlank(body)) {
            try {
                JSONObject json = JSONObject.parseObject(body);
                for (String key : json.keySet()) {
                    if (!isValidInput(json.getString(key))) {
                        log.warn("Potentially malicious input detected in request body for key '{}': {}", key, json.getString(key));
                        return false;
                    }
                }
            } catch (Exception e) {
                // 不是JSON格式时，直接检查整个body
                if (!isValidInput(body)) {
                    log.warn("Potentially malicious input detected in raw body: {}", body);
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isValidInput(String input) {
        return !containsXSS(input) && !containsSQLInjection(input) && !containsIllegalURLCharacters(input);
    }

    private boolean containsXSS(String value) {
        if (StringUtils.isBlank(value)) {
            return false;
        }
        for (Pattern pattern : XSS_PATTERNS) {
            if (pattern.matcher(value).find()) {
                log.warn("XSS attack detected: {}", value);
                return true;
            }
        }
        return false;
    }

    private boolean containsSQLInjection(String value) {
        if (StringUtils.isBlank(value)) {
            return false;
        }
        if (Pattern.compile(SQL_INJECTION_PATTERN, Pattern.CASE_INSENSITIVE).matcher(value).find()) {
            log.warn("SQL Injection attack detected: {}", value);
            return true;
        }
        return false;
    }

    private boolean containsIllegalURLCharacters(String value) {
        if (StringUtils.isBlank(value)) {
            return false;
        }
        if (URL_REQUEST_CHAR_PATTERN.matcher(value).find()) {
            log.warn("Illegal URL character detected: {}", value);
            return true;
        }
        return false;
    }

    private String getRequestBody(HttpServletRequest request) throws IOException {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        }
        return sb.toString();
    }
}

这段代码实现了一个基于 Spring 的拦截器，用于防止 SQL 注入和 XSS 攻击。在每个 HTTP 请求到达控制器之前，通过拦截请求参数和请求体内容，利用正则表达式检测常见的 SQL 注入特征（如 UNION SELECT、DROP TABLE 等）和 XSS 攻击特征（如 <script> 标签、javascript: 协议等）。一旦检测到恶意输入，立即阻止请求并返回 HTTP 400 错误，从而有效提升系统的安全性。

2. WebMvcConfigurer配置SqlInjectionInterceptor

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 排除配置
        registry.addInterceptor(actionInterceptor()).excludePathPatterns("/static/**", "/app/**", "/webjars/**",
                "/*.html", "/*.htm");
        // 添加新的 SQL 注入防护拦截器
        registry.addInterceptor(sqlInjectionInterceptor)
                .addPathPatterns("/**");
    }

这段代码通过 addInterceptors 方法将两个拦截器注册到 Spring 的拦截器链中，其中 actionInterceptor 拦截器对部分静态资源路径（如 /static/**、/*.html 等）进行排除，而 sqlInjectionInterceptor 则对所有请求路径（/**）启用 SQL 注入防护拦截器，用于检测并阻止潜在的恶意请求，保障系统安全性。