深入源码，探究#、$号替换符的区别

🕗 发布于 2024-07-09 07:00 java mybatis

在Mybatis的日常使用过程中以及在一些技术论坛上我们都能常常听到，不要使用$符号来进行SQL的编写，要使用#符号，否则会有SQL注入的风险。那么，为什么在使用$符号时会有注入的风险呢，以及#号为什么不会有风险呢？这一期我们来从源码分析一下。

$号占位符

在Mybatis替换SQL占位符时，会针对$和#号进行解析替换操作。然而对于$号来说，仅仅只会将该参数对应的值拼接在SQL中而已。

前置知识

在Mybatis中，SQL会被解析成一个个的SqlNode，对于不同的SqlNodeMybatis的解析处理都是不一样的。
一般情况来说，SQL中存在$号的话，都会被解析成TextSqlNode。

解析并替换

Mybatis中，解析TextSqlNode的占位符主要使用到两个类

GenericTokenParser：用于查找SQL中具体的占位符以及占位符代表的属性名
TokenHandler：根据占位符的属性名获取对应的值

public String parse(String text) {
    if (text == null || text.isEmpty()) {
      return "";
    }
    // search open token
    // 找到$号所在的位置
    int start = text.indexOf(openToken);
    if (start == -1) {
      return text;
    }
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    // 占位符中的变量名
    StringBuilder expression = null;
    do {
      if (start > 0 && src[start - 1] == '\\') {
        // this open token is escaped. remove the backslash and continue.
        builder.append(src, offset, start - offset - 1).append(openToken);
        offset = start + openToken.length();
      } else {
        // found open token. let's search close token.
        if (expression == null) {
          expression = new StringBuilder();
        } else {
          expression.setLength(0);
        }
        builder.append(src, offset, start - offset);
        offset = start + openToken.length();
        int end = text.indexOf(closeToken, offset);
        while (end > -1) {
          if ((end <= offset) || (src[end - 1] != '\\')) {
            expression.append(src, offset, end - offset);
            break;
          }
          // this close token is escaped. remove the backslash and continue.
          expression.append(src, offset, end - offset - 1).append(closeToken);
          offset = end + closeToken.length();
          end = text.indexOf(closeToken, offset);
        }
        if (end == -1) {
          // close token was not found.
          builder.append(src, start, src.length - start);
          offset = src.length;
        } else {
          // 从TokenHandler中解析出变量名对应的参数值
          builder.append(handler.handleToken(expression.toString()));
          offset = end + closeToken.length();
        }
      }
      start = text.indexOf(openToken, offset);
    } while (start > -1);
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }

在这个parse方法中，最终的解析方法在47行：

builder.append(handler.handleToken(expression.toString()));

在这一行代码会调用TokenHandler这个类的handleToken方法，获取参数名对应的结果。

public String handleToken(String content) {
    Object parameter = context.getBindings().get("_parameter");
    if (parameter == null) {
        context.getBindings().put("value", null);
    } else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
        context.getBindings().put("value", parameter);
    }
    Object value = OgnlCache.getValue(content, context.getBindings());
    String srtValue = value == null ? "" : String.valueOf(value); // issue #274 return "" instead of "null"
    checkInjection(srtValue);
    return srtValue;
}

这个方法主要涉及几个操作

使用Ognl获取该参数名对应的值。

该结果值是直接使用String.valueOf进行解析，那么在这一步中，就有可能导致SQL注入的问题了。

检查结果是否有注入风险。

这个方法名checkInjection看起来就像是用于检查解析后的结果是否有注入SQL的风险的。但是呢，这个方法并不会起任何作用。因为这个方法起作用的前提是injectionFilter得不为null，但是在Mybatis中，并没有对这个属性进行任何的赋值行为，所以也就没有任何用处了。

private void checkInjection(String value) {
    if (injectionFilter != null && !injectionFilter.matcher(value).matches()) {
        throw new ScriptingException("Invalid input. Please conform to regex" + injectionFilter.pattern());
    }
}

解析例子

现在有一条使用了$号的SQL：

SELECT * FROM log WHERE content='${id}'

当content为哈哈哈时，经过Mybatis的解析后，会变成什么样呢？

SELECT * FROM log WHERE content='哈哈哈'

这样的SQL并没有任何问题，但是如果此时content的值为哈哈哈'; DROP TABLE log --的话，SQL解析后的结果就长这样了：

SELECT * FROM log WHERE content='哈哈哈'; DROP TABLE log --'

就会导致整个log表的数据被清除了，而这正是不当使用**$**号的问题了。

#号占位符

既然$号有这么多的问题，为什么#号却不会有SQL注入的问题呢？我们来从实际例子来逐步展开。
现在有一个简单的SQL语句：

SELECT * FROM log WHERE content=#{id}

这个语句唯一不同的点就是将'${id}'换成了#{id}，但是在Mybatis中的解析却是天差地别了。

初始化解析

与$号不一样的是，在初始化Mybatis的MappedStatement时，检测到#号时，会提前初始化该SQL语句。无论是在注解中写SQL还是在Xml文件中写SQL，解析#号的方法最终都会进入到org.apache.ibatis.builder.SqlSourceBuilder#parse这个方法中。

public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType,
                                                                            additionalParameters);
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
    String sql;
    if (configuration.isShrinkWhitespacesInSql()) {
        sql = parser.parse(removeExtraWhitespaces(originalSql));
    } else {
        sql = parser.parse(originalSql);
    }
    return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

这个解析与$号的解析类似，也是由TokenHandler类进行参数名与对象之间的转换。
在#号的替换中，则是ParameterMappingTokenHandler来进行参数名与对象之间的转换。
但是这个类的handleToken方法比较特别，返回值居然是一个**?**号。并且在返回结果之前，还有一步操作

public String handleToken(String content) {
    parameterMappings.add(buildParameterMapping(content));
    return "?";
}

这个buildParameterMapping方法太长了，还是来看看具体返回了啥吧。

可以看到，这个方法的作用似乎是给SQL中的每一个占位符进行参数解析，将占位符对应的参数的类型、数据库类型、填充类型等都进行了解析。
这个初始化解析结束后，这一条SQL就变成了下面的样子了：

SELECT * FROM log WHERE content=?

并且还有一个集合parameterMappings装载了SQL中占位符的属性。

实际替换参数

初始化后，Mybatis在真正查询就会将利用PreparedStatement进行?占位符的替换了。

// org.apache.ibatis.scripting.defaults.DefaultParameterHandler#setParameters
public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    // 这个parameterMappings正是出事话解析SQL得到的参数映射集合
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
        MetaObject metaObject = null;
        // 遍历每一个参数映射
        for (int i = 0; i < parameterMappings.size(); i++) {
            ParameterMapping parameterMapping = parameterMappings.get(i);
            if (parameterMapping.getMode() != ParameterMode.OUT) {
                // 获取参数对应的值
                Object value;
                String propertyName = parameterMapping.getProperty();
                if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
                    value = boundSql.getAdditionalParameter(propertyName);
                } else if (parameterObject == null) {
                    value = null;
                } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                    value = parameterObject;
                } else {
                    if (metaObject == null) {
                        metaObject = configuration.newMetaObject(parameterObject);
                    }
                    value = metaObject.getValue(propertyName);
                }
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                JdbcType jdbcType = parameterMapping.getJdbcType();
                if (value == null && jdbcType == null) {
                    jdbcType = configuration.getJdbcTypeForNull();
                }
                try {
                    // 设置每个?号对应的值
                    typeHandler.setParameter(ps, i + 1, value, jdbcType);
                } catch (TypeException | SQLException e) {
                    throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
                }
            }
        }
    }
}

typeHandler.setParameter这个方法则是利用了PreparedStatement类的方法，将?替换成传入的参数。

PreparedStatement在填充具体值会对参数进行转义，比如上述的SQL以及参数在查询时则会变成：

SELECT * FROM log WHERE content='哈哈哈''; DROP TABLE log --'

则不会有SQL注入的风险了。

总结

$号：直接替换占位符中的内容，在不对参数进行校验的情况下，易出现SQL注入问题。
#号：在预编译SQL的前提下，将参数名替换成?号，并利用PreparedStatement进行占位符的替换，在替换过程中，会对注入值进行转义避免SQL注入。

原文地址：https://blog.csdn.net/Azir_/article/details/140260343

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：安全防御第三天（笔记持续更新）
下一篇：Python开发—— 异常处理：详细指南

反向代理模块
反向代理是指以代理服务器来接收客户端的请求，然后将请求转发给内部网络上的服务器，将从服务器上得到的结果返回给客户端，此时代理服务器对外表现为一个反向代理服务器。不适用代理的情况下，外网不能访问企业内网
阅读更多2024-11-18
C++：模板（2）
带你再次了解模板的奥妙
阅读更多2024-11-18
使用python自制桌面宠物,好玩!——枫原万叶桌宠，可以直接打包成exe去跟朋友炫耀。。。
使用python自制桌面宠物,好玩!——枫原万叶桌宠，可以直接打包成exe去跟朋友炫耀。。。
阅读更多2024-11-18
K210学习总结
本人用的是01科技的K210模块，感觉非常棒。
阅读更多2024-11-18
C/C++：指针数组与数组指针
指针数组：数组中的每个元素都是指针。，表示一个数组，数组内有 5 个指针，每个指针指向int类型的数据。数组指针：一个指向数组的指针。，表示一个指向含有 5 个int类型元素的数组的指针。
阅读更多2024-11-18
【Android】setLayoutParams Sometimes Not Working
【代码】【Android】setLayoutParams Sometimes Not Working。
阅读更多2024-11-18
sql数据库增删改数据（DML）
【代码】sql数据库增删改数据（DML）
阅读更多2024-11-18
【Linux】内核中申请内存的方法
都是用于内核空间申请内存都是以字节为单位进行分配所分配的内存，在虚拟地址上连续kzalloc是强制清零的kmalloc操作kmalloc和kzalloc分配的内存大小有限制（128KB），而vmall
阅读更多2024-11-18
【C++ 算法进阶】算法提升十六
据说著名犹太历史学家Josephus（弗拉维奥·约瑟夫斯）有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决
阅读更多2024-11-18
构建SSH僵尸网络
第一种：终端控制：python your_script.py --host IP1 IP2 --user user1 user2 --password password1 password2。# 为每
阅读更多2024-11-18