jsqlparser(二):实现基于SQL语法分析的SQL注入攻击检查

已于 2024-01-05 17:02:21 修改
阅读量2.3k 收藏 10
点赞数 5
分类专栏： java sql 文章标签： sql jsqlparser 注入攻击
于 2022-11-09 12:53:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/10km/article/details/127767358
版权
java 同时被 2 个专栏收录
234 篇文章 4 订阅
订阅专栏
sql
4 篇文章 0 订阅
订阅专栏

之前写过一篇博客：《java:正则表达式检查SQL WHERE条件语句防止注入攻击和常量表达式》,当前时通过正则表达式来检查SQL语句中是否有危险关键字和常量表达式实现SQL语句的注入攻击检查。坦率的说，这个办法是有漏洞的，误判，漏判的概率很大，基于当前我的知识能力，也只能做到这样。
最近学习了jsqlparser,我知道我找到了更好的办法来解决SQL注入攻击检查问题。
jsqlparser是一个java的SQL语句解析器，在上一篇博客：《jsqlparser:基于抽象语法树(AST)遍历SQL语句的语法元素》介绍了如何通过jsqlparser来遍历SQL语句中所有的字段和表名引用。
其实它可以用来进行更复杂的工作，jsqlparser会将一条SQL语句的各种语法元素以抽象语法树(AST，abstract syntax tree)形式解析为很多不同类型对象，通过对AST的遍历就可以对SQL语句进行分析。采用这种方式做SQL注入攻击检查不会有误判，漏判的问题。

SqlInjectionAnalyzer

SqlInjectionAnalyzer SQL注入攻击分析器
jsqlparse提供了两种式遍历SQL语句解析对象，一种是基于TablesNamesFinder，TablesNamesFinder其实是实现jsqparser很多对象访问接口的一个基类
一种是基于CCJSqlParserDefaultVisitor接口。

/**
 * SQL注入攻击分析器
 * @author guyadong
 *
 */
public class SqlInjectionAnalyzer {
    private boolean injectCheckEnable = true;
    private final InjectionSyntaxObjectAnalyzer injectionChecker;
    private final InjectionAstNodeVisitor injectionVisitor;
    public SqlInjectionAnalyzer() {
        this.injectionChecker = new InjectionSyntaxObjectAnalyzer(); 
        this.injectionVisitor = new InjectionAstNodeVisitor();
    }
    /**
     * 启用/关闭注入攻击检查,默认启动
     * @param enable
     * @return
     */
    public SqlInjectionAnalyzer injectCheckEnable(boolean enable){
        injectCheckEnable = enable;
        return this;
    }
    /**
     * 对解析后的SQL对象执行注入攻击分析，有注入攻击的危险则抛出异常{@link InjectionAttackException}
     * @param sqlParserInfo
     * @throws InjectionAttackException 
     */
    public SqlParserInfo injectAnalyse(SqlParserInfo sqlParserInfo) throws InjectionAttackException{

        if(null != sqlParserInfo && injectCheckEnable){
            /** SQL注入攻击检查 */
            sqlParserInfo.statement.accept(injectionChecker);
            sqlParserInfo.simpleNode.jjtAccept(injectionVisitor, null);             
        }
        return sqlParserInfo;
    }
}

InjectionSyntaxObjectAnalyzer

InjectionSyntaxObjectAnalyzer 为基于SQL语法对象的SQL注入攻击分析实现
TablesNamesFinder是jsqlparser提供的一个语法元素遍历对象，继承这个对象可以实现对需要的语法元素的访问，当遇到有注入攻击危险的表达式，语句时抛出InjectionAttackException异常，就是这个类做的工作


import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.Function;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.ComparisonOperator;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.select.Join;
import net.sf.jsqlparser.statement.select.OrderByElement;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.SelectItem;
import net.sf.jsqlparser.statement.select.SubSelect;
import net.sf.jsqlparser.statement.select.WithItem;
import net.sf.jsqlparser.util.TablesNamesFinder;

/**
 * 基于SQL语法对象的SQL注入攻击分析实现
 * @author guyadong
 *
 */
public class InjectionSyntaxObjectAnalyzer  extends TablesNamesFinder{
    /** 危险函数名 */
	private static final String DANGROUS_FUNCTIONS = "(sleep|benchmark|extractvalue|updatexml|ST_LatFromGeoHash|ST_LongFromGeoHash|GTID_SUBSET|GTID_SUBTRACT|floor|ST_Pointfromgeohash"
			+ "|geometrycollection|multipoint|polygon|multipolygon|linestring|multilinestring)";
	
	private static ThreadLocal<Boolean> disableSubselect = new ThreadLocal<Boolean>(){
        @Override
        protected Boolean initialValue() {
            return true;
        }};
	private ConstAnalyzer constAnalyzer = new ConstAnalyzer();
    public InjectionSyntaxObjectAnalyzer() {
		super();
		init(true);
		
	}
	@Override
    public void visitBinaryExpression(BinaryExpression binaryExpression) {
	    if(binaryExpression instanceof ComparisonOperator){
	        if(isConst(binaryExpression.getLeftExpression()) && isConst(binaryExpression.getRightExpression())){
	            /** 禁用恒等式 */
	            throw new InjectionAttackException("DISABLE IDENTICAL EQUATION " + binaryExpression);
	        }
	    }
	    super.visitBinaryExpression(binaryExpression);
    }

    @Override
    public void visit(AndExpression andExpression) {
        super.visit(andExpression);
        checkConstExpress(andExpression.getLeftExpression());
        checkConstExpress(andExpression.getRightExpression());
    }
    @Override
    public void visit(OrExpression orExpression) {
        super.visit(orExpression);
        checkConstExpress(orExpression.getLeftExpression());
        checkConstExpress(orExpression.getRightExpression());
    }
    @Override
    public void visit(Function function) {
    	if(function.getName().matches(DANGROUS_FUNCTIONS)){
    		/** 禁用危险函数 */
    		throw new InjectionAttackException("DANGROUS FUNCTION: "+function.getName());
    	}
    	super.visit(function);
    }
    @Override
    public void visit(WithItem withItem) {
        try {
            /** 允许 WITH 语句中的子查询 */
            disableSubselect.set(false);
            super.visit(withItem);
        } finally {
            disableSubselect.set(true);
        }
    }
    @Override
    public void visit(SubSelect subSelect) {
        if(disableSubselect.get()){
        	// 禁用子查询
            throw new InjectionAttackException("DISABLE subselect " + subSelect);
        }
    }
    @Override
    public void visit(Column tableColumn) {
        if(ParserSupport.isBoolean(tableColumn)){
            throw new InjectionAttackException("DISABLE CONST BOOL " + tableColumn);
        }
        super.visit(tableColumn);
    }
    @Override
    public void visit(PlainSelect plainSelect) {
        if (plainSelect.getSelectItems() != null) {
            for (SelectItem item : plainSelect.getSelectItems()) {
                item.accept(this);
            }
        }

        if (plainSelect.getFromItem() != null) {
            plainSelect.getFromItem().accept(this);
        }

        if (plainSelect.getJoins() != null) {
            for (Join join : plainSelect.getJoins()) {
                join.getRightItem().accept(this);
                for(Expression e:join.getOnExpressions()){
                    e.accept(this);
                }
            }
        }
        if (plainSelect.getWhere() != null) {
            plainSelect.getWhere().accept(this);
            checkConstExpress(plainSelect.getWhere());
        }

        if (plainSelect.getHaving() != null) {
            plainSelect.getHaving().accept(this);
        }

        if (plainSelect.getOracleHierarchical() != null) {
            plainSelect.getOracleHierarchical().accept(this);
        }
        if(plainSelect.getOrderByElements() != null){
            for( OrderByElement orderByElement : plainSelect.getOrderByElements()){
                orderByElement.getExpression().accept(this);
            }
        }
        if(plainSelect.getGroupBy() != null){
            for(Expression expression : plainSelect.getGroupBy().getGroupByExpressionList().getExpressions()){
                expression.accept(this);
            }
        }
    }

    private boolean isConst(Expression expression){
        return constAnalyzer.isConstExpression(expression);
    }
    private void checkConstExpress(Expression expression){
        if(constAnalyzer.isConstExpression(expression)){
            /** 禁用常量表达式 */
            throw new InjectionAttackException("DISABLE CONST EXPRESSION " + expression);
        }
    }
}

InjectionAstNodeVisitor

InjectionAstNodeVisitor 为基于抽象语法树(AST)的注入攻击分析实现
这部分代码很少，实现禁用用UNION语句

import net.sf.jsqlparser.parser.CCJSqlParserDefaultVisitor;
import net.sf.jsqlparser.parser.SimpleNode;
import net.sf.jsqlparser.statement.select.UnionOp;

/**
 * 基于抽象语法树(AST)的注入攻击分析实现
 * @author guyadong
 *
 */
public class InjectionAstNodeVisitor extends CCJSqlParserDefaultVisitor{
    public InjectionAstNodeVisitor() {
    }
    @Override
    public Object visit(SimpleNode node, Object data) {
        Object value = node.jjtGetValue();
        if(value instanceof UnionOp){
            throw new InjectionAttackException("DISABLE UNION");
        }
        return super.visit(node, data);
    }
}

单元测试

InjectAttackCheckerTest SQL注入攻击检查测试

import static org.junit.Assert.*;

import org.junit.BeforeClass;
import org.junit.Test;

import gu.sql2java.parser.InjectionAttackException;
import gu.sql2java.parser.ParserSupport;
import gu.sql2java.parser.SqlInjectionAnalyzer;
import gu.sql2java.parser.ParserSupport.SqlParserInfo;
import net.sf.jsqlparser.JSQLParserException;

import static gu.sql2java.SimpleLog.log;

/**
 * SQL注入攻击检查测试
 * @author guyadong
 *
 */
public class InjectAttackCheckerTest {

    private static SqlInjectionAnalyzer analyser;
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        analyser= new SqlInjectionAnalyzer();
    }
    private boolean injectAnalyse(String sql) throws JSQLParserException{
        SqlParserInfo sqlParserInfo = ParserSupport.parse0(sql, null);
        try {
            analyser.injectAnalyse(sqlParserInfo);
            return true;
        } catch (InjectionAttackException e) {
            log("{}",e.getMessage());
            //log(e);
            return false;
        }
    }
    @Test
    public void test() throws JSQLParserException {
        assertFalse(injectAnalyse("select * from dc_device where id in (select id from other)"));
        assertFalse(injectAnalyse("select * from dc_device where 2=2.0 or 2 != 4"));
        assertFalse(injectAnalyse("select * from dc_device where 1!=2.0"));
        assertFalse(injectAnalyse("select * from dc_device where id=floor(2.0)"));
        assertFalse(injectAnalyse("select * from dc_device where not true"));
        assertFalse(injectAnalyse("select * from dc_device where 1 or id > 0"));
        assertFalse(injectAnalyse("select * from dc_device where 'tom' or id > 0"));
        assertFalse(injectAnalyse("select * from dc_device where '-2.3' "));
        assertFalse(injectAnalyse("select * from dc_device where 2 "));
        assertFalse(injectAnalyse("select * from dc_device where (3+2) "));
        assertFalse(injectAnalyse("select * from dc_device where  -1 IS TRUE"));
        assertFalse(injectAnalyse("select * from dc_device where 'hello' is null "));
        assertFalse(injectAnalyse("select * from dc_device where '2022-10-31' and id > 0"));
        assertFalse(injectAnalyse("select * from dc_device where id > 0 or 1!=2.0 "));
        assertFalse(injectAnalyse("select * from dc_device where id > 0 or 1 in (1,3,4) "));
        assertFalse(injectAnalyse("select * from dc_device  UNION select name from other"));
        assertTrue(injectAnalyse("WITH SUB1 AS (SELECT user FROM t1) SELECT * FROM T2 WHERE id > 123 "));
    }

}

完整代码参见码云仓库：
https://gitee.com/l0km/sql2java/tree/dev/sql2java-manager/src/main/java/gu/sql2java/parser

jsqlparser系列文章

《jsqlparser(一):基于抽象语法树(AST)遍历SQL语句的语法元素》
《jsqlparser(二):实现基于SQL语法分析的SQL注入攻击检查》
《jsqlparser(三):基于语法分析实现SQL中的CAST函数替换》
《jsqlparser(四):实现MySQL 函数DATE_FORMAT到Phoenix函数TO_CHAR的替换》
《jsqlparser(五):修改语法定义(JSqlParserCC.jjt)实现UPSERT支持Phoenix语法ON DUPLICATE KEY IGNORE》

10km
关注
专栏目录
基于SQL 语法解释器JSqlParser实现的SQL解析工具
04-06
NULL 博文链接：https://lxy19791111.iteye.com/blog/1543223
利用 JSqlParser 防止 SQL 注入
zhangxin09的专栏
10-28 992
高手文章介绍了利用 JSqlParser 防止 SQL 注入，写得很好，只不过有两个问题，代码比较复杂，我于是作了简化，只有两个类；其次检测比较严格，连子查询都禁止，我把它开放了。
推荐项目：SQL Parser CST——精准解析SQL的利器
最新发布
gitblog_01041的博客
09-11 628
推荐项目：SQL Parser CST——精准解析SQL的利器 sql-parser-cst Parses SQL into Concrete Syntax Tree (CST) 项目地址: https://gitcode.com...
jsqlparser
05-28
jsqlparser
JSqlParser
OWMBL的博客
05-15 1万+
1.定义：JSqlParser是一个SQL语句解析器。它将SQL转换为Java类的可遍历层次结构。2.工具地址：目前在github上开源。3.支持的数据库类型：支持Oracle，SqlServer，MySQL，PostgreSQL等常用数据库。但各种数据库系统的SQL语法都在动态变化，可以解析大部分（不是全部）。Github 官网截图：4.支持的语法类型：目前，JSqlParser最新版本为4.6（2023-2-24），支持的语法已在官网上做了全部列举（部分截图展示：）
JSQLParser 解析复杂SQL 2.0
m0_54892309的博客
03-17 6045
JSQLParser解析复杂嵌套SQL
JSqlParser的使用
qq_39203337的博客
03-22 3814
JSqlParse是一款很精简的sql解析工具，它可以将常用的sql文本解析成具有层级结构的语法树，我们可以针对解析后的节点进行处理(增加、移除、修改等操作),从而生成符合我们业务要求的sql，比如添加过滤条件等等JSqlParse采用访问者模式项目结构非常简单，从截图上看就5个包。如果对源码感兴趣的可以直接从github上下载源码包调试。其中expression包包含了所有的sql表达式的抽象对象：statement包含了所有sql语句的类型，比如：增删改查，ddl语句,rollback语句等等。
JSQLParser 解析 复杂sql （表别名、字段与表对应关系）
m0_54892309的博客
03-13 1万+
个人代码分享- 使用Java的JSqlParser工具来解析复杂SQL（SQL的基本结构、表|别名、字段|别名|关联表）
JSqlParser开源SQL解析库jar
04-04
SQL解析与验证：可以用来检查用户输入的SQL语句是否符合预定义的规范，防止SQL注入攻击。 动态SQL生成：在应用程序中，根据业务逻辑动态构造SQL查询时非常有用。 SQL优化与转换：在数据库中间件或者ORM框架中，...
JSqlParser:JSqlParser解析一条SQL语句并将其转换为Java类的层次结构。 可以使用“访问者模式”浏览生成的层次结构
05-10
的JSqlParser 在此处查找更多信息和示例： : 。 执照 JSqlParser具有LGPL V2.1或Apache软件许可2.0版的双重许可。 讨论 ... 看起来很不错，具有扩展SQL语法（如PL / SQL和T-SQL）和Java + .NET AP
jsqlparser sql解析器
01-15
jsqlparser sql解析器 JSqlParser is a SQL statement parser. It translates SQLs in a traversable hierarchy of Java classes. JSqlParser is not limited to one database but provides support for a lot of specials of Oracle, SqlServer, MySQL, PostgreSQL ...
PageHelper.jar,jsqlparser.jar
05-23
mybatis分页插件所需jar包，pagehelper-5.0，pagehelper-5.1以及jsqlparser-0.9.5.jar
jsqlparser1.1和1.2
05-10
包括 jsqlparser-1.1.jar、jsqlparser-1.1-javadoc.jar、jsqlparser-1.1-sources.jar、jsqlparser-1.2.jar、jsqlparser-1.2-sources.jar 从http://search.maven.org/上下载。 考虑到这个网站下载十分不稳定，所以分享。
JSqlParser——SQL语法解释器：SQL解析样例
热门推荐
Gigaplant的博客
05-25 2万+
解析SELECT语句 String sql = &amp;amp;quot;SELECT DISTINCT t1.ID,t1.NAME,t1.TIME FROM TEST_SCHEMA.TEST_TABLE1 t1 LEFT JOIN TEST_SCHEMA.TEST_TABLE2 t2 ON t1.ID=t2.ID WHERE t1.ID='123' AND t2.ID='456' OR t1.NAME='abc' O...
JSQLParser
点点滴滴
07-20 786
待定
webshell大马
03-16
Webshell大马是一种常见的网络攻击工具，它可以在受害者的服务器上创建一个后门，使攻击者可以远程控制服务器并执行恶意操作。这种攻击方式对于网站管理员来说是非常危险的，因为攻击者可以窃取敏感信息、篡改网站内容、传播恶意软件等。因此，网站管理员需要采取一系列措施来保护自己的服务器，如加强密码安全、定期更新软件补丁、限制文件上传等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

10km

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值