- Ruilin

2018年二月月发布的文章

PreparedStatement防止sql注入

二月 14, 2018
0 条评论

今天测试一个demo发现里面有点小问题，代码很规范，其中操作jdbc使用PreparedStatement也很正常，可是测试时候突然发现其采用了字符串追加形式来生产sql语句，这样使用其实直接绕开了PreparedStatement的优点[参数化的查询]，从而可以轻易的造成sql注入。

首先我们先认识三个重要的对象

1.Connection

代表着Java程序与数据库建立的连接。

2.Statement

代表SQL发送器，用于发送和执行SQL语句。

3.ResultSet

代表封装的数据库返回的结果集，用于获取查询结果。

上面是demo中的初始化方法和对象的使用，还有读取DbConfig.properties配置文件

什么是sql注入

简单来说就是黑客通过与服务器交互时在创建者没有有效的进行过滤的情况下的一种拼装sql命令来达到改变sql语义进而获取其敏感数据的行为.

那么如何进行有效的防御？我们还是在java中围绕这个demo说

它其中判断登陆用户是否成功的方法是这样写的

当我们尝试登陆一个错误用户，flag返回false，正确时返回true

可以看到，这时数据库执行的命令为

select * from student where name='admin' and password='123456'

1	select * from student where name='admin' and password='123456'

因为没有符合的返回，所以flag依然为false

可是当遇到别有用心的人时登陆就不会是这么简单的操作，比如我们执行下面的sql命令，数据库会回应怎样的数据呢？

select * from student where name='admin' and password='aaa' or '1'='1'

1	select * from student where name='admin' and password='aaa' or '1'='1'

可以看一下

返回了两个用户的信息，这也不用怎么解释,前面两个值与and返回为false而之后配一个or 1=1 也就相当于执行了

select * from student where TRUE

1	select * from student where TRUE

所以攻击者可以配合这样的语法来进行任意用户登陆，如密码输入为

aaa' or '1'='1

1	aaa' or '1'='1

rs next了两次自然返回true

所以如何避免呢，在java中，Java提供了 Statement、PreparedStatement 和 CallableStatement三种方式来执行查询语句，其中 Statement 用于通用查询，PreparedStatement 用于执行参数化查询，而 CallableStatement则是用于存储过程。

其中PreparedStatement就是可以有效防止常见的sql注入的一种方法

PreparedStatement是java.sql包下面的一个接口，用来执行SQL语句查询，通过调用 connection.preparedStatement(sql) 方法可以获得PreparedStatment对象。数据库系统会对sql语句进行预编译处理（如果JDBC驱动支持的话），预处理语句将被预先编译好，这条预编译的sql查询语句能在将来的查询中重用，这样一来，它比Statement对象生成的查询速度更快。

PreparedStatement与Statement区别

Statement是PreparedStatement的父类,作为 Statement 的子类，PreparedStatement 继承了 Statement 的所有功能。

Statement不对sql语句作处理而直接交给数据库；而PreparedStatement支持预编译，对于多次重复执行的sql语句，使用PreparedStament使代码的执行效率，代码的可读性和可维护性更高，PreparedStament提高了代码的安全性，防止sql注入。

安全性效率开销可读性维护性

prepareStatement
高高，预编译大好容易

Statement
容易发生sql注入低，每一次编译小差不容易

如何使用PreparedStatement

1:字符串追加形式的PreparedStatement

String sql = "select * from " + table + " where " + condition;
prestmt = conn.prepareStatement(sql);
rs = prestmt.executeQuery();

				1
2
3

						String sql = "select * from " + table + " where " + condition;
prestmt = conn.prepareStatement(sql);
rs = prestmt.executeQuery();

2：使用参数化查询的PreparedStatement

String sql="select * from userinfo where name=? and password=?";
prestmt = conn.prepareStatement(sql);
prestmt.setString(1,name);
prestmt.setString(2,password);
rs = prestmt.executeQuery();

String sql="select * from userinfo where name=? and password=?";

prestmt = conn.prepareStatement(sql);

prestmt.setString(1,name);

prestmt.setString(2,password);

rs = prestmt.executeQuery();

使用PreparedStatement的参数化的查询可以阻止大部分的SQL注入。在使用参数化查询的情况下，数据库系统（eg:MySQL）不会将参数的内容视为SQL指令的一部分来处理，而是在数据库完成SQL指令的编译后，才套用参数运行，因此就算参数中含有破坏性的指令，也不会被数据库所运行。

对于刚才的例子，可以看到它使用的是第一种方式这样其实就跟使用了Statement一样，这样的优点是代码少打几行可是代价也是很高的。如果我们改成第二种，PreparedStatement会对’进行转义,sql将其作为一个参数一个字段的属性值来处理，从而使得注入攻击失败

简单来说预编译会给你外面加引号并且过滤特殊字符

public void setString(int parameterIndex, String x) throws SQLException {
        // if the passed string is null, then set this column to null
        if (x == null) {
            setNull(parameterIndex, Types.CHAR);
        } else {
            StringBuffer buf = new StringBuffer((int) (x.length() * 1.1));
            buf.append('\'');

            int stringLength = x.length();

            //
            // Note: buf.append(char) is _faster_ than
            // appending in blocks, because the block
            // append requires a System.arraycopy()....
            // go figure...
            //
            for (int i = 0; i < stringLength; ++i) {
                char c = x.charAt(i);

                switch (c) {
                case 0: /* Must be escaped for 'mysql' */
                    buf.append('\\');
                    buf.append('0');

                    break;

                case '\n': /* Must be escaped for logs */
                    buf.append('\\');
                    buf.append('n');

                    break;

                case '\r':
                    buf.append('\\');
                    buf.append('r');

                    break;

                case '\\':
                    buf.append('\\');
                    buf.append('\\');

                    break;

                case '\'':
                    buf.append('\\');
                    buf.append('\'');

                    break;

                case '"': /* Better safe than sorry */
                    if (this.usingAnsiMode) {
                        buf.append('\\');
                    }

                    buf.append('"');

                    break;

                case '\032': /* This gives problems on Win32 */
                    buf.append('\\');
                    buf.append('Z');

                    break;

                default:
                    buf.append(c);
                }
            }

            buf.append('\'');

            String parameterAsString = buf.toString();

            byte[] parameterAsBytes = null;

            if (!this.isLoadDataQuery) {
                parameterAsBytes = StringUtils.getBytes(parameterAsString,
                        this.charConverter, this.charEncoding, this.connection
                                .getServerCharacterEncoding(), this.connection
                                .parserKnowsUnicode());
            } else {
                // Send with platform character encoding
                parameterAsBytes = parameterAsString.getBytes();
            }

            setInternal(parameterIndex, parameterAsBytes);
        }
    }

public void setString(int parameterIndex, String x) throws SQLException {

// if the passed string is null, then set this column to null

if (x == null) {

setNull(parameterIndex, Types.CHAR);

} else {

StringBuffer buf = new StringBuffer((int) (x.length() * 1.1));

buf.append('\'');

int stringLength = x.length();

// Note: buf.append(char) is _faster_ than

// appending in blocks, because the block

// append requires a System.arraycopy()....

// go figure...

for (int i = 0; i < stringLength; ++i) {

char c = x.charAt(i);

switch (c) {

case 0: /* Must be escaped for 'mysql' */

buf.append('\\');

buf.append('0');

break;

case '\n': /* Must be escaped for logs */

buf.append('\\');

buf.append('n');

break;

case '\r':

buf.append('\\');

buf.append('r');

break;

case '\\':

buf.append('\\');

break;

case '\'':

buf.append('\\');

buf.append('\'');

break;

case '"': /* Better safe than sorry */

if (this.usingAnsiMode) {

buf.append('\\');

}

buf.append('"');

break;

case '\032': /* This gives problems on Win32 */

buf.append('\\');

buf.append('Z');

break;

default:

buf.append(c);

}

buf.append('\'');

String parameterAsString = buf.toString();

byte[] parameterAsBytes = null;

if (!this.isLoadDataQuery) {

parameterAsBytes = StringUtils.getBytes(parameterAsString,

this.charConverter, this.charEncoding, this.connection

.getServerCharacterEncoding(), this.connection

.parserKnowsUnicode());

} else {

// Send with platform character encoding

parameterAsBytes = parameterAsString.getBytes();

}

setInternal(parameterIndex, parameterAsBytes);

}

补充：避免SQL注入的第二种方式：
在组合SQL字符串的时候，先对所传入的参数做字符取代（将单引号字符取代为连续2个单引号字符，因为连续2个单引号字符在SQL数据库中会视为字符中的一个单引号字符。)

可以看出使用拼凑字符追加型的sql生成形式能更方便灵活的自定义控制sql语句，但如果没有进行有效的过滤很容易造成sql注入，所以建议使用参数化查询的PreparedStatement，用PreparedStatement代替Statement。

【注意】占位符只能占位SQL语句中的普通值，决不能占位表名、列名、SQL关键字（select、insert等)。所以如果使用动态表名，字段，就只能向上面案例那样使用非预编译方法，不过这样显然很容易导致注入。

参考：

http://www.importnew.com/5006.html

http://blog.csdn.net/changyinling520/article/details/71159652

http://blog.csdn.net/daijin888888/article/details/50965232

Jinja2 笔记

二月 5, 2018
0 条评论

大部分摘自网上，方便平时查阅【更新ing…】

介绍

Jinja2：Jinja是日本寺庙的意思，并且寺庙的英文是temple和模板的英文template的发音类似。Jinja2是默认的仿Django模板的一个模板引擎，由Flask的作者开发。它速度快，被广泛使用，并且提供了可选的沙箱模板来保证执行环境的安全，它有以下优点：

让前端开发者和后端开发者工作分离。
减少Flask项目代码的耦合性，页面逻辑放在模板中，业务逻辑放在视图函数中，将页面逻辑和业务逻辑解耦有利于代码的维护。
提供了控制语句、继承等高级功能，减少开发的复杂度。

模版

{{ ... }}：装载一个变量，模板渲染的时候，会使用传进来的同名参数这个变量代表的值替换掉。
{% ... %}：装载一个控制语句。
{# ... #}：装载一个注释，模板渲染的时候会忽视这中间的值。

变量

在模板中添加变量，可以使用（set）语句。

{% set name='xx' %}

1	{% set name='xx' %}

with语句来创建一个内部的作用域，将set语句放在其中，这样创建的变量只在with代码块中才有效

{% with foo = 42 %}
{{ foo }}
{% endwith %}

{% with foo = 42 %}

{% endwith %}

if语句

{% if kenny.sick %}
Kenny is sick.
{% elif kenny.dead %}
You killed Kenny! You bastard!!!
{% else %}
Kenny looks okay --- so far
{% endif %}

{% if kenny.sick %}

Kenny is sick.

{% elif kenny.dead %}

You killed Kenny! You bastard!!!

{% else %}

Kenny looks okay --- so far

{% endif %}

for语句

{% for user in users %}
{{ user.username|e }}
{% endfor %}

{% for user in users %}

{% endfor %}

遍历字典

{% for key, value in <strong>my_dict.iteritems()</strong> %}
&lt;dt&gt;{{ key|e }}&lt;/dt&gt;
&lt;dd&gt;{{ value|e }}&lt;/dd&gt;
{% endfor %}

{% for key, value in <strong>my_dict.iteritems()</strong> %}

<dd>{{ value|e }}</dd>

{% endfor %}

Jinja2中for循环内置常量

loop.index	当前迭代的索引（从1开始）
loop.index0	当前迭代的索引（从0开始）
loop.first	是否是第一次迭代，返回True\/False
loop.last	是否是最后一次迭代，返回True\/False
loop.length	序列的长度

注意：不可以使用continue和break表达式来控制循环的执行。

阅读剩余部分 –

2018年二月月发布的文章

Ubuntu下测试格式化字符串漏洞

PreparedStatement防止sql注入

什么是sql注入

PreparedStatement与Statement区别

如何使用PreparedStatement

Jinja2 笔记

介绍

模版

变量

LOGO

近期文章

分类目录

文章归档

近期评论

功能

博客统计

	安全性	效率	开销	可读性	维护性
prepareStatement	高	高，预编译	大	好	容易
Statement	容易发生sql注入	低，每一次编译	小	差	不容易

2018年二月月 发布的文章

Ubuntu下测试格式化字符串漏洞

PreparedStatement防止sql注入

什么是sql注入

PreparedStatement与Statement区别

如何使用PreparedStatement

Jinja2 笔记

介绍

模版

变量

LOGO

近期文章

标签

分类目录

文章归档

近期评论

功能

博客统计

2018年二月月发布的文章