MyBatis中SQL注入攻击和防护——掌握技巧保护应用安全
作者：禅与计算机程序设计艺术
1.简介
伴随着互联网的信息化进程以及云计算技术的进步，在Web开发领域中常用一种称为基于OR（Object Relational Mapping）的技术体系来处理网站业务的数据管理问题。该体系通过使用预定义的数据接口与数据库直接交互，并提供了一系列的应用编程接口（API），从而实现了对数据库操作的封装和自动化管理。基于OR体系的应用程序通常会生成大量与具体事务无关的数据绑定代码（如插入记录、删除记录等），这些代码由OR工具自动处理并生成相应的驱动代码以供应用程序调用。然而，在OR框架自身具备的一些特性下（如弱类型检查机制），很容易受到一种称为"OR注入"的安全威胁影响。OR注入是指通过向服务器端发送非法的OR语句指令而非合法的数据查询条件来实现对数据库的直接访问操作从而获取不合法的数据内容或者执行其他危险行为
MyBatis 是一个开源组件，在mybatis框架中提供支持。它是一个轻量级的ORM框架工具或模块，并且支持自定义的SQL语句、存储过程以及高级映射功能。该组件的主要特点包括使用简单易懂的方式配置应用仅需少量配置文件即可完成设置，并且能够降低学习成本和复杂度同时显著提升应用程序的整体性能和可维护性水平其核心思想在于将复杂的 JDBC 数据库操作转化为简单的XML配置文件从而极大地简化了应用程序开发流程
2.核心概念
2.1 SQL注入漏洞形成原因
在Web开发领域中，默认使用的技术手段是基于SQL的后端处理。通过ORM工具实现数据持久化存储，并提供便捷的查询功能。然而，在这种设计模式下存在潜在的安全隐患——即可能遭受SQL注入攻击（英语：SQL injection）。这种攻击并非简单地向服务器发送非法命令（虽然理论上这会引发安全问题），而是通过特殊的方式绕过正常的认证机制或权限控制流程，在数据库层面执行未经授权的操作。
攻击发生的根本原因主要包括以下几点
根据攻击手段的不同类型大致可分为
目前较为常见的攻击模式主要包括
当一个恶意构造的SQL指令被成功注入到数据库系统时
针对这种情况
2.2 SQL注入防护机制
目前，SQL注入防护的主要手段有三种：
- 对用户的输入数据执行有效性检查，并设定允许的字符范围。
- 在编码过程中应用预编译技术以实现数据转换。
- 动态引用机制确保在运行时正确解析用户的输入数据。
2.2.1 参数校验和白名单策略
一般而言而言，在实际应用中难以实现对用户的输入数据进行合法验证。因为攻击者往往能够规避现有的安全措施。因此，在这种情况下采用白名单的方式限制用户的合法字符集合是一个较为合理的方法。例如我们可以利用MySQL提供的正则表达式功能来确保用户的用户名和密码符合相应的安全规范
CREATE TABLE users (
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
password VARCHAR(50),
email VARCHAR(50)
);
INSERT INTO users (username,password,email) VALUES ('admin','admin@123',NULL);
SELECT * FROM users WHERE username = 'admin' AND password REGEXP '^[a-zA-Z0-9]{4,}$'; // 使用正则表达式检查密码长度2.2.2 预编译
precompiled statements are prepared by assembling a complete SQL statement before execution. Once the statement is ready, all parameters are provided in sequence. This approach avoids SQL injection vulnerabilities because parameters cannot be automatically escaped, thus ensuring data integrity and preventing data tampering. By utilizing different strategies, the MyBatis framework offers two primary approaches for precompiling statements: one using placeholders and another employing the #{} syntax for dynamic value insertion.
By utilizing placeholder syntax, Mybatis represents parameters with the ? symbol. When executing SQL statements, one can employ PredefinedStatements to assign actual parameter values. owing to its architecture, the Mybatis framework employs Statement interfaces for these operations. PredefinedStatements are restricted to SELECT and UPDATE operations only.
String sql="insert into user values(?,?)";
PreparedStatement pstmt=conn.prepareStatement(sql);
try{
pstmt.setString(1,"zhangsan");
pstmt.setInt(2,18);
pstmt.executeUpdate();
}catch(SQLException e){
throw new RuntimeException("insert error",e);
}finally{
if(pstmt!=null){
try {
pstmt.close();
} catch (SQLException e) {
// ignore
}
}
}- Mybatis采用#{}语法：与占位符一样，但使用#{}语法代替?占位符。
<insert id="insertUser">
insert into user values(#{},#{})
</insert>
<select id="getUserById" parameterType="int">
select * from user where id=#{id}
</select>通过上面的两种预编译方式，就可以确保输入的数据不会被拦截。
2.2.3 绑定变量
转义处理（binding variable）是一种用于将用户的输入数据进行编码处理的技术，在运行时避免潜在的SQL注入漏洞。其功能在于将用户的输入数据进行转义处理，在运行时规避SQL注入漏洞，并通过这种方式确保应用程序的安全性。在Mybatis框架中，默认情况下并未提供绑定变量的功能。
public void test() throws Exception {
SqlSession session = getSqlSessionFactory().openSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User user = new User("zhangsan#", "123456", "<EMAIL>");
int rows = mapper.insert(user);
System.out.println("rows: "+rows);
session.commit();
session.close();
}在当前环境中，在这里输入的用户名字段值被赋值为'zhangsan#'；Mybatis框架会自动地将#符号替换为空格字符，并采取其他安全措施以避免SQL注入攻击。
2.2.4 其他防护措施
除此之外，在现有的基础上还有一些其他的防护手段可供采用：例如输入检测、输出过滤和错误处理等技术手段。这些技术手段虽然能够一定程度上防止SQL注入攻击的发生范围扩大到某种程度上仍有风险存在。因此，在实际应用中建议根据具体情况选择合适的防御策略以确保系统的安全性得到最大化保护。
3.核心算法原理及操作步骤
潜在威胁者可以通过制造并注入有害的SQL语句来执行未经授权的操作或修改数据内容；为了应对此类威胁应在数据库设计中应用合理结构、参数化查询和事务处理等技术以提高安全性；深入探讨MyBatis SQL注入漏洞防护的核心算法及操作步骤
3.1 mybatis 源码分析
通过org.apache.ibatis.executor.statement.BaseStatementHandler类中的parameterize方法实现了MyBatis提供的参数绑定功能。该方法首先会检查当前线程中是否已经有了ParameterHandler实例；若无，则会生成新的ParameterHandler实例并调用setParameters方法。该逻辑依据不同的SQL语句类型将输入的java.lang.Object实例转换为相应的JDBC数据类型并将这些参数赋值给预设好的PreparedStatement实例。系统会在设置这些参数前对输入数据进行字符串转义处理以防止SQL注入攻击。
@Override
protected ParameterHandler prepareParameterHandler(MappedStatement mappedStatement, Object parameterObject) {
ParameterHandler parameterHandler = mappedStatement.getParameterHandler(parameterObject);
if (parameterHandler == null) {
parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, RowBounds.DEFAULT, boundSql);
setParameters(parameterHandler);
} else {
setParameters((BoundSql) parameterHandler.getParameterObject());
}
return parameterHandler;
}
/** * 设置Parameters。如果使用PreparedStatement, 此处对Parameters的值进行转义处理，如果使用 Statement ，则直接使用原始值
*/
private void setParameters(ParameterHandler parameterHandler) {
MetaObject metaObject = parameterHandler.getMetaObject();
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode()!= ParameterMode.OUT) {//判断是否是输出参数
Object value;
String propertyName = parameterMapping.getProperty();//获得property名称
PropertyTokenizer prop = new PropertyTokenizer(propertyName);//得到属性名称中各个元素
if (prop.hasNext()) {//如果有下一级属性
value = metaObject.getValue(propertyName);//获得当前对象的该属性的值
while (prop.hasNext()) {
metaObject = metaObject.metaObjectForProperty(prop.getName());//获得下一级对象的元信息
prop.next();//获得下一级属性名
}
} else {//如果是最后一级属性
value = parameterObject;//直接使用传入的参数值
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();//获得类型处理器
if (typeHandler == null) {//如果类型处理器不存在，则按照jdbcType查找默认的类型处理器
MappedStatement ms = mappedStatement.getConfiguration().getMappedStatement(mappedStatement.getId());
resultMaps = ms.getResultMaps();//获得查询结果对应的ResultMap集合
ResultMap resultMap = resultMaps.get(ms.getResultMaps().size()-1);//获得最后一个resultMap
Class<?> parameterTypeClass = parameterObject==null? null : parameterObject.getClass();
if (!resultMap.getTypeHandler().equals(VoidTypeHandler.INSTANCE)) {//如果有默认的类型处理器，则使用默认的类型处理器
TypeHandlerRegistry registry = ms.getConfiguration().getTypeHandlerRegistry();
if (registry.hasTypeHandler(parameterTypeClass, parameterMapping.getJdbcType())) {//如果有默认的类型处理器，则使用默认的类型处理器
typeHandler = resultMap.getTypeHandler();
}
}
}
if (value == null &&!typeHandler.isNullable()) {//如果参数值为空且类型处理器不允许为空，则抛出异常
throw new ExecutorException("The argument '" + propertyName + "' cannot be null.");
}
String jdbcTypeName = parameterMapping.getJdbcType();//获得jdbc类型
Integer sqlType = resolveJdbcType(jdbcTypeName);//获得jdbc类型对应的sql类型
if (typeHandler instanceof BlobTypeHandler || typeHandler instanceof ClobTypeHandler) {//Blob/Clob参数类型需要特殊处理
Blob blob = (value == null)? null : convertToJavaType(typeHandler, value);
metaObject.setValue(propertyName, blob);
continue;
}
// 设置参数值
if (value == null) {
metaObject.setValue(propertyName, JDBCType.VARCHAR.getDefaultValue());
parameterHandler.setParameters(null, new JdbcTypeSetter(sqlType));
} else {
metaObject.setValue(propertyName, typeHandler.setParameter(ps, i + 1, value, JDBCType.forCode(resolve JdbcType by type or result map).getVendorTypeNumber()));
}
}
}
}
/** * 根据jdbc类型获取jdbcTypeSetter对象。每个jdbcType对应一个JdbcTypeSetter对象，该对象封装了jdbc驱动的PreparedStatement setValue方法以及该参数在PreparedStatement中对应的序号。
*/
private static final Map<Integer, JdbcTypeSetter> TYPE_SETTERS = new HashMap<>();
static {
TYPE_SETTERS.put(Types.BIT, new JdbcTypeSetter(JdbcType.BIT.getVendorTypeNumber(), BitsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.TINYINT, new JdbcTypeSetter(JdbcType.TINYINT.getVendorTypeNumber(), BytesetterImpl.getInstance()));
TYPE_SETTERS.put(Types.SMALLINT, new JdbcTypeSetter(JdbcType.SMALLINT.getVendorTypeNumber(), ShortsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.INTEGER, new JdbcTypeSetter(JdbcType.INTEGER.getVendorTypeNumber(), IntsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.BIGINT, new JdbcTypeSetter(JdbcType.BIGINT.getVendorTypeNumber(), LongsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.REAL, new JdbcTypeSetter(JdbcType.REAL.getVendorTypeNumber(), FloatsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.FLOAT, new JdbcTypeSetter(JdbcType.FLOAT.getVendorTypeNumber(), DoublesetterImpl.getInstance()));
TYPE_SETTERS.put(Types.DOUBLE, new JdbcTypeSetter(JdbcType.DOUBLE.getVendorTypeNumber(), DoublesetterImpl.getInstance()));
TYPE_SETTERS.put(Types.NUMERIC, new JdbcTypeSetter(JdbcType.NUMERIC.getVendorTypeNumber(), BigDecimalsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.DECIMAL, new JdbcTypeSetter(JdbcType.DECIMAL.getVendorTypeNumber(), BigDecimalsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.CHAR, new JdbcTypeSetter(JdbcType.CHAR.getVendorTypeNumber(), StringsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.VARCHAR, new JdbcTypeSetter(JdbcType.VARCHAR.getVendorTypeNumber(), StringsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.LONGNVARCHAR, new JdbcTypeSetter(JdbcType.LONGNVARCHAR.getVendorTypeNumber(), NStringsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.DATE, new JdbcTypeSetter(JdbcType.DATE.getVendorTypeNumber(), DatesetterImpl.getInstance()));
TYPE_SETTERS.put(Types.TIME, new JdbcTypeSetter(JdbcType.TIME.getVendorTypeNumber(), TimesetterImpl.getInstance()));
TYPE_SETTERS.put(Types.TIMESTAMP, new JdbcTypeSetter(JdbcType.TIMESTAMP.getVendorTypeNumber(), TimestampsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.BINARY, new JdbcTypeSetter(JdbcType.BINARY.getVendorTypeNumber(), ByteArraysetterImpl.getInstance()));
TYPE_SETTERS.put(Types.VARBINARY, new JdbcTypeSetter(JdbcType.VARBINARY.getVendorTypeNumber(), ByteArraysetterImpl.getInstance()));
TYPE_SETTERS.put(Types.LONGVARBINARY, new JdbcTypeSetter(JdbcType.LONGVARBINARY.getVendorTypeNumber(), ByteArraysetterImpl.getInstance()));
TYPE_SETTERS.put(Types.JAVA_OBJECT, new JdbcTypeSetter(JdbcType.JAVA_OBJECT.getVendorTypeNumber(), ObjectTypesetterImpl.getInstance()));
TYPE_SETTERS.put(Types.OTHER, new JdbcTypeSetter(JdbcType.OTHER.getVendorTypeNumber(), DefaultsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.BLOB, new JdbcTypeSetter(JdbcType.BLOB.getVendorTypeNumber(), BlobsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.CLOB, new JdbcTypeSetter(JdbcType.CLOB.getVendorTypeNumber(), ClobsetterImpl.getInstance()));
TYPE_SETTERS.put(Types.BOOLEAN, new JdbcTypeSetter(JdbcType.BOOLEAN.getVendorTypeNumber(), BooleansetterImpl.getInstance()));
// Add custom types here...
}
/** * 根据jdbc类型编号获取jdbcTypeSetter对象。
*/
private JdbcTypeSetter resolveJdbcType(String jdbcTypeName) {
return resolveJdbcType(JDBCType.valueOf(jdbcTypeName));
}
private JdbcTypeSetter resolveJdbcType(JDBCType jdbcType) {
Integer code = jdbcType.getVendorTypeNumber();
if (code == null) {
return DEFAULT_TYPE_SETTER;
}
JdbcTypeSetter setter = TYPE_SETTERS.get(code);
return (setter!= null)? setter : DEFAULT_TYPE_SETTER;
}
/** * 将类型处理器类型转换成java类型。
*/
private static final TypeHandlerRegistry registry = TypeHandlerRegistry.getInstance();
private static final TypeHandlerAdapter adapter = new DefaultTypeHandlerAdapater(registry);
private Blob convertToJavaType(TypeHandler typeHandler, Object value) {
String propertyClassname = typeHandler.getClass().getName();
JavaType javaType = adapter.adapt(value.getClass());
return convertFromWrapperToPrimitive(javaType, registry.getTypeHandler(javaType, propertyClassname), value);
}
/** * 把java包装类型转换成基础类型。
*/
private static <T> T convertFromWrapperToPrimitive(JavaType javaType, TypeHandler<? extends T> handler, Object value) {
Class<T> primitiveType = javaType.primitiveOf(handler.getClass());
if (primitiveType == null) {
return (T) value;
}
if (handler instanceof BooleanTypeHandler) {
boolean boolVal = ((Boolean) value).booleanValue();
return PrimitiveUtils.convertFromWrapperToPrimitive(boolVal, primitiveType);
}
Number numberVal = (Number) value;
return PrimitiveUtils.convertFromWrapperToPrimitive(numberVal, primitiveType);
}通过源码分析可知, Mybatis 通过 MetaObject 实现了对输入参数的绑定机制, 每个参数均会配置一个对应类型的 Handler. 若未定义对应的 Handler, 则系统将依据 jdbcType 和 参数类型 查找预设的默认 Handler 配置. 当传入字段值为空且 Handler 设定不允许为空时, 系统将强制抛出异常处理.
3.2 参数化查询原理
在myBatis中采用参数化查询的方式能够有效地防止SQL注入攻击
3.3 输入检测
在正常的处理流程中，在进行操作时所涉及的所有参数都会被系统性地审查和评估。
为了防止出现SQL注入漏洞的问题通常都是通过严格的数据验证和过滤措施来实现。
常见的输入验证方法主要包括但不限于前端表单校验、后端数据库约束以及利用特定的安全库函数来进行全方位的风险控制。
- 黑名单机制：将可能导致sql注入的关键字预先排除在外；当接收的请求参数包含这些关键字时，则立即触发异常响应。
- 白名单检查：列出所有合法的输入字符；只有当接收的数据项包含这些允许值时才会被接受。
- 输入控制措施包括但不限于以下几点：
- 设定最大值和最小值约束
- 规定接受的数据类型
- 在处理表单数据时；所有的html实体字符会被自动转换为可读的安全字符串。
- 敏感信息防护措施主要是通过加密手段对用户的原始输入内容进行编码处理
3.4 输入转义
对用户的输入数据进行编码处理以防止SQL注入攻击是一种安全措施，在mybatis框架中完成这一编码操作的任务是通过JDBC API提供的PreparedStatement类中的setXXX方法来实现的。当在设置预 preparedStatement参数的过程中 MyBatis 会对传入的数据进行字符串的转义处理以确保安全。
public void setParameter(PreparedStatement ps, int index, String parameter, JdbcType jdbcType) throws SQLException {
if (parameter == null) {
setNull(ps, index, jdbcType);
} else {
ps.setString(index, parameter);
}
}可以观察到，在设置参数给 PreparedStatement 对象时, MyBatis 执行转义操作于输入的字符串.
3.5 检测输入是否为正常查询语句
当使用mybatis处理数据时，在构建映射之前
当确认传递的数据符合预期时
3.6 其他安全机制
MyBatis框架还提供了一些其他安全机制，如下：
- 不允許動態SQL：MyBatis不允許在��置 文件 中生成或插入/更新/刪除 SQL statements。這將有效防止 SQL 注入 攻擊。
- 配置 文件 分隔：不同環境之間采用不同的配置 文件策略來保障數據庫連線的安全性。
- 拒絕讀取外部資源：MyBatis design principles 堵塞讀取外部資源以保障數據庫連線的安全性。
- 參數 映射限制：每一個 參數 映射 唯一 一個 POJO field以確保數據庫連線的安全性。
4.具体代码实例及解释说明
下面，我们结合源码和实例，详细地介绍如何使用mybatis实现SQL注入攻击防护的具体步骤。
（1）POJO实体类定义
public class User {
private Integer id;
private String username;
private String password;
// getter and setter
}（2）mybatis xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--mybatis的配置文件-->
<configuration>
<!-- 别名定义 -->
<typeAliases>
<typeAlias alias="User" type="com.example.dao.entity.User"/>
</typeAliases>
<!-- 数据库连接信息 -->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="${mysql.username}"/>
<property name="password" value="${mysql.password}"/>
</dataSource>
</environment>
</environments>
<!-- sql映射文件 -->
<mappers>
<mapper resource="com/example/dao/mapper/UserDao.xml"/>
</mappers>
</configuration>（3）mybatis Mapper XML文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--user表的dao-->
<mapper namespace="com.example.dao.UserDao">
<!-- 查询用户信息 -->
<select id="findUserByName" parameterType="string">
SELECT * FROM user WHERE username = #{name}
</select>
<!-- 添加用户信息 -->
<insert id="addUser" parameterType="User">
INSERT INTO user (username, password) VALUES (#{username}, #{password})
</insert>
<!-- 更新用户信息 -->
<update id="updateUser" parameterType="User">
UPDATE user SET password = #{password} WHERE id = #{id}
</update>
<!-- 删除用户信息 -->
<delete id="removeUser" parameterType="integer">
DELETE FROM user WHERE id = #{id}
</delete>
</mapper>（4）UserService代码实现
import com.example.dao.entity.User;
import com.example.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Autowired
private UserDao userDao;
public User findUserByName(String name) {
return userDao.findUserByName(name);
}
public int addUser(User user) {
return userDao.addUser(user);
}
public int updateUser(User user) {
return userDao.updateUser(user);
}
public int removeUser(int id) {
return userDao.removeUser(id);
}
}（5）TestService单元测试代码
import com.example.dao.entity.User;
import com.example.service.UserService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
@ContextConfiguration(locations={"classpath:/applicationContext.xml"})
public class TestService {
@Autowired
private UserService userService;
private User user = new User(null, "zhangsan#", "123456");
@Before
public void setUp() throws Exception {
Assert.assertNotNull(userService);
Assert.assertNotNull(user);
}
@Test
public void testAddUser() {
int ret = userService.addUser(user);
Assert.assertEquals(1, ret);
}
@Test
public void testFindUserByName() {
User u = userService.findUserByName("zhangsan#");
Assert.assertNotNull(u);
}
@Test
public void testUpdateUser() {
user.setId(1);
int ret = userService.updateUser(user);
Assert.assertEquals(1, ret);
}
@Test
public void testRemoveUser() {
int ret = userService.removeUser(1);
Assert.assertEquals(1, ret);
}
}在以下提供的代码中，我们实现了UserService类，并通过注解机制将UserDao作为依赖注入到该类中。该服务类包含三个主要功能的方法：实现用户信息添加、删除以及修改的操作；同时提供查找用户信息的功能。在服务层定义好了相关接口后，在测试类中创建了一个User实体模型，并实例化了一个UserService对象实例并赋值给变量。随后调用 UserService 对应的功能测试模块的方法进行验证工作。为了确保系统的健壮性，在上述操作均未触发SQL注入漏洞的情况下，则所有功能测试均应顺利通过。这些代码片段生动地展示了MyBatis的技术实现思路及其数据库操作防护的具体应用情况。