精华内容
下载资源
问答
  • java 防止sql注入 什么是SQL注入? (What is SQL Injection?) SQL Injection is one of the top 10 web application vulnerabilities. In simple words, SQL Injection means injecting/inserting SQL code in a ...

    java 防止sql注入

    什么是SQL注入? (What is SQL Injection?)

    SQL Injection is one of the top 10 web application vulnerabilities. In simple words, SQL Injection means injecting/inserting SQL code in a query via user-inputted data. It can occur in any applications using relational databases like Oracle, MySQL, PostgreSQL and SQL Server.

    SQL注入是十大Web应用程序漏洞之一。 简而言之,SQL注入意味着通过用户输入的数据在查询中注入/插入SQL代码。 它可以在使用关系数据库的任何应用程序中发生,例如Oracle,MySQL,PostgreSQL和SQL Server。

    To perform SQL Injection, a malicious user first tries to find a place in the application where he can embed SQL code along with data. It can be the login page of any web application or any other place. So when data embedded with SQL code is received by the application, SQL code will be executed along with the application query.

    为了执行SQL注入,恶意用户首先尝试在应用程序中找到一个可以将SQL代码与数据一起嵌入的位置。 它可以是任何Web应用程序或任何其他地方的登录页面 。 因此,当应用程序接收到嵌入有SQL代码的数据时,SQL代码将与应用程序查询一起执行。

    SQL注入的影响 (Impact of SQL Injection)

    • A malicious user can obtain unauthorized access to your application and steal data.

      恶意用户可以未经授权访问您的应用程序并窃取数据。
    • They can alter, delete data in your database and take your application down.

      他们可以更改,删除数据库中的数据并关闭您的应用程序。
    • A hacker can also get control of the system on which database server is running by executing database specific system commands.

      黑客还可以通过执行数据库特定的系统命令来控制运行数据库服务器的系统。

    SQL注入如何工作? (How Does SQL Injection Works?)

    Suppose we have a database table named tbluser which stores data of application users. The userId is the primary column of the table. We have functionality in the application, which lets you get information via userId. The value of userId is received from the user request.

    假设我们有一个名为tbluser的数据库表,用于存储应用程序用户的数据。 userId是表的主列。 我们在应用程序中具有功能,使您可以通过userId获取信息 从用户请求中接收到userId的值。

    Let’s have a look at the below example code.

    让我们看下面的示例代码。

    
    String userId = {get data from end user}; 
    String sqlQuery = "select * from tbluser where userId = " + userId;
    

    1.有效的用户输入 (1. Valid User Input)

    When the above query is executed with valid data i.e. userId value 132, it will look like below.

    当使用有效数据(即userId值132)执行上述查询时,它将如下所示。

    Input Data: 132

    输入数据: 132

    Executed Query: select * from tbluser where userId=132

    执行的查询: 从tbluser中选择*,其中userId = 132

    Result: Query will return data of user having userId 132. No SQL Injection is happening in this case.

    结果:查询将返回具有userId 132的用户的数据。在这种情况下,没有SQL注入发生。

    2.黑客用户输入 (2. Hacker User Input)

    A hacker can alter user requests using tools like Postman, cURL, etc. to send SQL code as data and this way bypassing any UI side validations.

    黑客可以使用Postman,cURL等工具更改用户请求,以将SQL代码作为数据发送,并以此方式绕过任何UI端验证。

    Input Data: 2 or 1=1

    输入数据: 2或1 = 1

    Executed Query: select * from tbluser where userId=2 or 1=1

    执行的查询: 从tbluser中选择*,其中userId = 2或1 = 1

    Result: Now the above query is having two conditions with SQL OR expression.

    结果:现在上面的查询具有两个带有SQL OR表达式的条件。

    • userId=2: This part will match table rows having userId value as ‘2’.

      userId = 2 :这部分将匹配userId值为'2'的表行。
    • 1=1: This part will be always evaluate as true. So Query will return all the rows of the table.

      1 = 1 :此部分将始终被评估为true。 因此查询将返回表的所有行。

    SQL注入的类型 (Types of SQL Injection)

    Let’s look at the four types of SQL injections.

    让我们看一下SQL注入的四种类型。

    1.基于布尔SQL注入 (1. Boolean Based SQL Injection)

    The above example is a case of Boolean Based SQL Injection. It uses a boolean expression that evaluates to true or false. It can be used to get additional information from the database. For example;

    上面的示例是基于布尔值SQL注入的情况。 它使用布尔表达式,其结果为true或false。 它可以用来从数据库中获取其他信息。 例如;

    Input Data: 2 or 1=1

    输入数据:2或1 = 1

    SQL Query:  select first_name, last_name from tbl_employee where empId=2 or 1=1

    SQL查询:从tbl_employee中选择first_name,last_name,其中empId = 2或1 = 1

    2. 基于联合SQL注入 (2. Union Based SQL Injection)

    SQL union operator combines data from two different queries with the same number of columns. In this case, the union operator is used to get data from other tables.

    SQL联合运算符将来自两个不同查询的数据与相同数量的列组合在一起。 在这种情况下,并集运算符用于从其他表获取数据。

    Input Data: 2 union select username, password from tbluser

    输入数据: 2位联合选择用户名,tbluser的密码

    Query:  Select first_name, last_name from tbl_employee where empId=2 union select username, password from tbluser

    查询:从tbl_employee中选择first_name,last_name,其中empId = 2并选择tbluser的用户名和密码

    By using Union Based SQL Injection,  an attacker can obtain user credentials.

    通过使用基于联合SQL注入,攻击者可以获得用户凭据。

    3. 基于时间SQL注入 (3. Time-Based SQL Injection)

    In  Time Based SQL Injection, special functions are injected in the query which can pause execution for a specified amount of time. This attack slows down the database server. It can bring down your application by affecting the database server performance. For example, In MySQL:

    基于时间SQL注入中 ,特殊函数被注入查询中,这些函数可以在指定的时间内暂停执行。 这种攻击会降低数据库服务器的速度。 它可以通过影响数据库服务器性能来降低应用程序的性能。 例如,在MySQL中:

    Input Data: 2 + SLEEP(5)

    输入数据: 2 + SLEEP(5)

    Query:  select emp_id, first_name, last_name from tbl_employee where empId=2 + SLEEP(5)

    查询: 从tbl_employee中选择emp_id,first_name,last_name,其中empId = 2 + SLEEP(5)

    In the above example, query execution will pause for 5 seconds.

    在上面的示例中,查询执行将暂停5秒钟。

    4. 基于错误SQL注入 (4. Error Based SQL Injection)

    In this variation, the attacker tries to get information like an error code and a message from the database. The attacker injects SQL which are syntactically incorrect so database server will return error code and messages which can be used to get database and system information.

    在这种变体中,攻击者试图从数据库中获取信息,例如错误代码和消息。 攻击者注入SQL在语法上是不正确的,因此数据库服务器将返回错误代码和消息,这些错误代码和消息可用于获取数据库和系统信息。

    Java SQL注入示例 (Java SQL Injection Example)

    We will use a simple Java Web application to demonstrate SQL Injection. We have Login.html, which is a basic login page that takes username and password from the user and submit them to LoginServlet.

    我们将使用一个简单的Java Web应用程序来演示SQL注入。 我们有Login.html ,这是一个基本的登录页面,该页面从用户那里获取用户名和密码,并将其提交给LoginServlet

    The LoginServlet gets username and password from request and validates them against database values. If authentication is successful then Servlet redirects the user to the home page otherwise it will return an error.

    LoginServlet从请求中获取用户名和密码,并根据数据库值对其进行验证。 如果身份验证成功,则Servlet会将用户重定向到主页,否则它将返回错误。

    Login.html Code:

    Login.html 代码

    
    <!DOCTYPE html>
    <html lang="en">
        <head>
            <title>Sql Injection Demo</title>
        </head>
        <body>
        <form name="frmLogin" method="POST" action="https://localhost:8080/Web1/LoginServlet">
            <table>
                <tr>
                    <td>Username</td>
                    <td><input type="text" name="username"></td>
                </tr>
                <tr>
                    <td>Password</td>
                    <td><input type="password" name="password"></td>
                </tr>
                <tr>
                    <td colspan="2"><button type="submit">Login</button></td>
                </tr>
            </table>
        </form>
        </body>
    </html>
    

    LoginServlet.java Code:

    LoginServlet.java 代码

    
    package com.journaldev.examples;
    import java.io.IOException;
    import java.sql.*;
    import javax.servlet.*;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.*;
    
    @WebServlet("/LoginServlet")
    public class LoginServlet extends HttpServlet {
        static {
            try {
                Class.forName("com.mysql.jdbc.Driver");
            } catch (Exception e) {}
        }
    
        protected void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            boolean success = false;
            String username = request.getParameter("username");
            String password = request.getParameter("password");
            // Unsafe query which uses string concatenation
            String query = "select * from tbluser where username='" + username + "' and password = '" + password + "'";
            Connection conn = null;
            Statement stmt = null;
            try {
                conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/user", "root", "root");
                stmt = conn.createStatement();
                ResultSet rs = stmt.executeQuery(query);
                if (rs.next()) {
                    // Login Successful if match is found
                    success = true;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    stmt.close();
                    conn.close();
                } catch (Exception e) {}
            }
            if (success) {
                response.sendRedirect("home.html");
            } else {
                response.sendRedirect("login.html?error=1");
            }
        }
    }
    

    Database Queries [MySQL]:

    数据库查询[MySQL]:

    
    create database user;
    
    create table tbluser(username varchar(32) primary key, password varchar(32));
    
    insert into tbluser (username,password) values ('john','secret');
    insert into tbluser (username,password) values ('mike','pass10');
    

    1.从登录页面输入有效用户名和密码时 (1. When Valid Username and Password is entered from the login page)

    Input username: john

    输入用户名 :john

    Input username: secret

    输入用户名 :秘密

    Query: select * from tbluser where username=’john’ and password = ‘secret’

    查询 :从tbluser中选择*,其中username ='john'和password ='secret'

    Result: Username and Password exists in the database so authentication is successful. The user will be redirected to the home page.

    结果 :数据库中存在用户名和密码,因此身份验证成功。 用户将被重定向到主页。

    2.使用SQL Injection获得未经授权的系统访问 (2. Getting Unauthorized access to the system using SQL Injection)

    Input username: dummy

    输入用户名 :哑

    Input password: ‘ or ‘1’=’1

    输入密码 :'或'1'='1

    Query: select * from tbluser where username=’dummy’ and password = ” or ‘1’=’1′

    查询 :从tbluser中选择*,其中username ='dummy'和password =”或'1'='1'

    Result: Inputted Username and Password doesn’t exist in the database but authentication is successful.  Why?

    结果 :输入的用户名和密码在数据库中不存在,但认证成功。 为什么?

    It is due to SQL Injection as we have entered ‘ or ‘1’=’1 as password. There are 3 conditions in the query.

    这是由于SQL注入,因为我们输入了'或'1'='1作为密码。 查询中有3个条件。

    1. username=’dummy’: It will be evaluated to false as there is no user with username dummy in the table.

      username ='dummy' :由于表中没有用户名是dummy的用户,它将被评估为false。
    2. password = ”: It will be evaluated to false as there is no empty password in the table.

      password =” :由于表中没有空密码,它将被评估为false。
    3. ‘1’=’1′: It will be evaluated to true as this is static string comparison.

      '1'='1' :因为这是静态字符串比较,它将被评估为true。

    Now combining all 3 conditions i.e false and false or true => Final result will be true.

    现在结合所有三个条件,即false和false或true =>最终结果将为true

    In the above scenario, we have used the boolean expression to perform SQL Injection. There are some other ways to do SQL Injection. In the next section, we will see ways to prevent SQL injection in our Java application.

    在上述情况下,我们使用了布尔表达式来执行SQL注入。 还有其他一些方法可以执行SQL注入。 在下一节中,我们将介绍在Java应用程序中防止SQL注入的方法。

    防止Java代码中SQL注入 (Preventing SQL Injection in Java Code)

    The simplest solution is to use PreparedStatement instead of Statement to execute the query. 

    最简单的解决方案是使用PreparedStatement而不是Statement来执行查询。

    Instead of concatenating username and password into the query, we provide them to query via PreparedStatement’s setter methods. 

    我们没有将用户名和密码串联到查询中,而是提供它们通过PreparedStatement的setter方法进行查询。

    Now, the value of username and password received from the request is treated as only data so no SQL Injection will happen.

    现在,从请求接收的用户名和密码的值仅被视为数据,因此不会发生SQL注入。

    Let’s look at the modified servlet code.

    让我们看一下修改后的servlet代码。

    
    String query = "select * from tbluser where username=? and password = ?";
    Connection conn = null;
    PreparedStatement stmt = null;
    try {
        conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/user", "root", "root");
        stmt = conn.prepareStatement(query);
        stmt.setString(1, username);
        stmt.setString(2, password);
        ResultSet rs = stmt.executeQuery();
        if (rs.next()) {
            // Login Successful if match is found
            success = true;
        }
        rs.close();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            stmt.close();
            conn.close();
        } catch (Exception e) {
        }
    }
    

    Let’s understand what’s happening in this case.

    让我们了解在这种情况下发生了什么。

    Query: select * from tbluser where username = ? and password = ?

    查询从tbluser中选择*,其中username =? 和密码=?

    The question mark (?) in the above query is called a positional parameter.  There are 2 positional parameters in the above query. We don’t concatenate username and password to query. We use methods available in the PreparedStatement to provide user Input.

    以上查询中的问号(?)称为位置参数。 上述查询中有2个位置参数。 我们不会将用户名和密码连接在一起进行查询。 我们使用PreparedStatement中可用的方法来提供用户输入。

    We have set the first Parameter by using stmt.setString(1, username)  and the second parameter by using stmt.setString(2, password). The underlying JDBC API takes care of sanitizing the values to avoid SQL injection.

    我们已经使用stmt.setString(1, username)设置了第一个参数,并使用了stmt.setString(2, password)了第二个参数。 底层的JDBC API负责清理值以避免SQL注入。

    避免SQL注入的最佳实践 (Best Practices to avoid SQL Injection)

    1. Validate data before using them in the query.

      在查询中使用数据之前,请先对其进行验证。
    2. Do not use common words as your table name or column name. For example, many applications use tbluser or tblaccount to store user data. Email, firstname, lastname are common column names.

      不要使用常用词作为表名或列名。 例如,许多应用程序使用tbluser或tblaccount来存储用户数据。 电子邮件,名,姓是常用的列名。
    3. Do not directly concatenate data ( received as user input) to create SQL queries.

      不要直接串联数据(作为用户输入接收)来创建SQL查询。
    4. Use frameworks like Hibernate and Spring Data JPA for the data layer of an application.

      HibernateSpring Data JPA之类的框架用于应用程序的数据层。
    5. Use positional parameters in the query. If you are using plain JDBC, then use PreparedStatement to execute the query.

      在查询中使用位置参数。 如果您使用的是普通JDBC ,则使用PreparedStatement执行查询。
    6. Limit the application’s access to the database via permissions & grants.

      通过权限和授予限制应用程序对数据库的访问。
    7. Do not return sensitive error code and message to the end-user.

      不要将敏感的错误代码和消息返回给最终用户。
    8. Do proper code review so that no developer accidentally write unsafe SQL code.

      请进行正确的代码审查,以免开发人员意外地编写不安全SQL代码。
    9. Use tools like SQLMap to find and fix SQL Injection vulnerabilities in your application.

      使用SQLMap之类的工具来查找和修复应用程序中SQL Injection漏洞。

    That’s all for Java SQL Injection, I hope nothing important got missed here.

    Java SQL注入就这些了,我希望这里没有重要的事情。

    You can download the sample java web application project from the below link.

    您可以从下面的链接下载示例Java Web应用程序项目。

    翻译自: https://www.journaldev.com/34028/sql-injection-in-java

    java 防止sql注入

    展开全文
  • java防止SQL注入

    2013-11-19 18:32:46
    java防止SQL注入对一个系统十分的重要,系统没有安全保障,那再好的系统也是扯淡。在平时系统开发中一定注意安全漏洞。
  • JavaSQL注入方法

    千次阅读 2017-06-21 10:38:39
    JavaSQL注入方法

    在前面的博客中,我们详细介绍了:


           sql注入攻击详解(二)sql注入过程详解 


           sql注入攻击详解(一)sql注入原理详解 


          我们了解了sql注入原理和sql注入过程,今天我们就来了解一下sql注入的解决办法。怎么来解决和防范sql注入,由于本人主要是搞Java web开发的小程序员,所以这里我只讲一下有关于java web的防止办法。其实对于其他的,思路基本相似。下面我们先从web应用程序的角度来看一下如何避免sql注入:


    1、普通用户与系统管理员用户的权限要有严格的区分。


      如果一个普通用户在使用查询语句中嵌入另一个Drop Table语句,那么是否允许执行呢?由于Drop语句关系到数据库的基本对象,故要操作这个语句用户必须有相关的权限。在权限设计中,对于终端用户,即应用软件的使用者,没有必要给他们数据库对象的建立、删除等权限。那么即使在他们使用SQL语句中带有嵌入式的恶意代码,由于其用户权限的限制,这些代码也将无法被执行。故应用程序在设计的时候,最好把系统管理员的用户与普通用户区分开来。如此可以最大限度的减少注入式攻击对数据库带来的危害。


    2、 强迫使用参数化语句。


      如果在编写SQL语句的时候,用户输入的变量不是直接嵌入到SQL语句。而是通过参数来传递这个变量的话,那么就可以有效的防治SQL注入式攻击。也就是说,用户的输入绝对不能够直接被嵌入到SQL语句中。与此相反,用户的输入的内容必须进行过滤,或者使用参数化的语句来传递用户输入的变量。参数化的语句使用参数而不是将用户输入变量嵌入到SQL语句中。采用这种措施,可以杜绝大部分的SQL注入式攻击。不过可惜的是,现在支持参数化语句的数据库引擎并不多。不过数据库工程师在开发产品的时候要尽量采用参数化语句。


    3加强对用户输入的验证。


      总体来说,防治SQL注入式攻击可以采用两种方法,一是加强对用户输入内容的检查与验证;二是强迫使用参数化语句来传递用户输入的内容。在SQLServer数据库中,有比较多的用户输入内容验证工具,可以帮助管理员来对付SQL注入式攻击。测试字符串变量的内容,只接受所需的值。拒绝包含二进制数据、转义序列和注释字符的输入内容。这有助于防止脚本注入,防止某些缓冲区溢出攻击。测试用户输入内容的大小和数据类型,强制执行适当的限制与转换。这即有助于防止有意造成的缓冲区溢出,对于防治注入式攻击有比较明显的效果。


    4、 多多使用SQL Server数据库自带的安全参数。


      为了减少注入式攻击对于SQL Server数据库的不良影响,在SQLServer数据库专门设计了相对安全的SQL参数。在数据库设计过程中,工程师要尽量采用这些参数来杜绝恶意的SQL注入式攻击。


    5、 多层环境如何防治SQL注入式攻击?


      在多层应用环境中,用户输入的所有数据都应该在验证之后才能被允许进入到可信区域。未通过验证过程的数据应被数据库拒绝,并向上一层返回一个错误信息。实现多层验证。对无目的的恶意用户采取的预防措施,对坚定的攻击者可能无效。更好的做法是在用户界面和所有跨信任边界的后续点上验证输入。如在客户端应用程序中验证数据可以防止简单的脚本注入。但是,如果下一层认为其输入已通过验证,则任何可以绕过客户端的恶意用户就可以不受限制地访问系统。故对于多层应用环境,在防止注入式攻击的时候,需要各层一起努力,在客户端与数据库端都要采用相应的措施来防治SQL语句的注入式攻击。


    6、必要的情况下使用专业的漏洞扫描工具来寻找可能被攻击的点。


      使用专业的漏洞扫描工具,可以帮助管理员来寻找可能被SQL注入式攻击的点。不过漏洞扫描工具只能发现攻击点,而不能够主动起到防御SQL注入攻击的作用。当然这个工具也经常被攻击者拿来使用。如攻击者可以利用这个工具自动搜索攻击目标并实施攻击。为此在必要的情况下,企业应当投资于一些专业的漏洞扫描工具。一个完善的漏洞扫描程序不同于网络扫描程序,它专门查找数据库中的SQL注入式漏洞。最新的漏洞扫描程序可以查找最新发现的漏洞。所以凭借专业的工具,可以帮助管理员发现SQL注入式漏洞,并提醒管理员采取积极的措施来预防SQL注入式攻击。如果攻击者能够发现的SQL注入式漏洞数据库管理员都发现了并采取了积极的措施堵住漏洞,那么攻击者也就无从下手了。


            上面主要是介绍了在web应用程序中对sql注入的大体解决思路,下面我们就根据java web应用程序的特征来具体说明一下如何解决在java web应用程序中的sql注入问题。


    1.采用预编译语句集,它内置了处理SQL注入的能力,只要使用它的setXXX方法传值即可。

    使用好处:

    (1).代码的可读性和可维护性.

    (2).PreparedStatement尽最大可能提高性能.

    (3).最重要的一点是极大地提高了安全性.

    1. String sql= "select * from users where username=? and password=?;  
    2.           PreparedStatement preState = conn.prepareStatement(sql);  
    3.           preState.setString(1, userName);  
    4.           preState.setString(2, password);  
    5.           ResultSet rs = preState.executeQuery();   
    String sql= "select * from users where username=? and password=?;
              PreparedStatement preState = conn.prepareStatement(sql);
              preState.setString(1, userName);
              preState.setString(2, password);
              ResultSet rs = preState.executeQuery(); 


    原理:sql注入只对sql语句的准备(编译)过程有破坏作用,而PreparedStatement已经准备好了,执行阶段只是把输入串作为数据处理,而不再对sql语句进行解析,准备,因此也就避免了sql注入问题.

     

    2.使用正则表达式过滤传入的参数


    正则表达式:

    private String CHECKSQL = “^(.+)\\sand\\s(.+)|(.+)\\sor(.+)\\s$”;

    判断是否匹配:

    Pattern.matches(CHECKSQL,targerStr);

    下面是具体的正则表达式:

    检测SQL meta-characters的正则表达式 :

    /(\%27)|(\’)|(\-\-)|(\%23)|(#)/ix

    修正检测SQL meta-characters的正则表达式 :/((\%3D)|(=))[^\n]*((\%27)|(\’)|(\-\-)|(\%3B)|(:))/i

    典型的SQL 注入攻击的正则表达式 :/\w*((\%27)|(\’))((\%6F)|o|(\%4F))((\%72)|r|(\%52))/ix

    检测SQL注入,UNION查询关键字的正则表达式 :/((\%27)|(\’))union/ix(\%27)|(\’)

    检测MS SQL Server SQL注入攻击的正则表达式:

    /exec(\s|\+)+(s|x)p\w+/ix

    等等…..

     其实可以简单的使用replace方法也可以实现上诉功能:

     public static String TransactSQLInjection(String str)
              {
                    return str.replaceAll(".*([';]+|(--)+).*", " ");
              } 


    3.字符串过滤


    比较通用的一个方法:

    (||之间的参数可以根据自己程序的需要添加)


    1. public static boolean sql_inj(String str)  
    2. {  
    3. String inj_str = "'|and|exec|insert|select|delete|update|  
    4. count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+|,";  
    5. String inj_stra[] = split(inj_str,"|");  
    6. for (int i=0 ; i < inj_stra.length ; i++ )  
    7. {  
    8. if (str.indexOf(inj_stra[i])>=0)  
    9. {  
    10. return true;  
    11. }  
    12. }  
    13. return false;  
    14. }  
    public static boolean sql_inj(String str)
    {
    String inj_str = "'|and|exec|insert|select|delete|update|
    count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+|,";
    String inj_stra[] = split(inj_str,"|");
    for (int i=0 ; i < inj_stra.length ; i++ )
    {
    if (str.indexOf(inj_stra[i])>=0)
    {
    return true;
    }
    }
    return false;
    }


     

    4.jsp中调用该函数检查是否包函非法字符

     

    防止SQL从URL注入:

    sql_inj.java代码:

     

    1. package sql_inj;  
    2. import java.net.*;  
    3. import java.io.*;  
    4. import java.sql.*;  
    5. import java.text.*;  
    6. import java.lang.String;  
    7. public class sql_inj{  
    8. public static boolean sql_inj(String str)  
    9. {  
    10. String inj_str = "'|and|exec|insert|select|delete|update|  
    11. count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+|,";  
    12. //这里的东西还可以自己添加  
    13. String[] inj_stra=inj_str.split("\\|");  
    14. for (int i=0 ; i < inj_stra.length ; i++ )  
    15. {  
    16. if (str.indexOf(inj_stra[i])>=0)  
    17. {  
    18. return true;  
    19. }  
    20. }  
    21. return false;  
    22. }  
    23. }  
    24.    
    package sql_inj;
    import java.net.*;
    import java.io.*;
    import java.sql.*;
    import java.text.*;
    import java.lang.String;
    public class sql_inj{
    public static boolean sql_inj(String str)
    {
    String inj_str = "'|and|exec|insert|select|delete|update|
    count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+|,";
    //这里的东西还可以自己添加
    String[] inj_stra=inj_str.split("\\|");
    for (int i=0 ; i < inj_stra.length ; i++ )
    {
    if (str.indexOf(inj_stra[i])>=0)
    {
    return true;
    }
    }
    return false;
    }
    }
     


    5.JSP页面添加客户端判断代码:

     

    使用JavaScript在客户端进行不安全字符屏蔽

    功能介绍:检查是否含有”‘”,”\\”,”/”

    参数说明:要检查的字符串

    返回值:0:是1:不是

    函数名是

    1. function check(a)  
    2. {  
    3. return 1;  
    4. fibdn = new Array (”‘” ,”\\”,”/”);  
    5. i=fibdn.length;  
    6. j=a.length;  
    7. for (ii=0; ii<i; ii++)  
    8. for (jj=0; jj<j; jj++)  
    9. { temp1=a.charAt(jj);  
    10. temp2=fibdn[ii];  
    11. if (tem’; p1==temp2)  
    12. return 0; }  
    13. }  
    14. }  
    15. return 1;  
    16. }  
    function check(a)
    {
    return 1;
    fibdn = new Array (”‘” ,”\\”,”/”);
    i=fibdn.length;
    j=a.length;
    for (ii=0; ii<i; ii++)
    { for (jj=0; jj<j; jj++)
    { temp1=a.charAt(jj);
    temp2=fibdn[ii];
    if (tem’; p1==temp2)
    { return 0; }
    }
    }
    return 1;
    }


     关于安全性,本文可总结出一下几点:

              1.要对用户输入的内容保持警惕。
              2.只在客户端进行输入验证等于没有验证。
              3.永远不要把服务器错误信息暴露给用户。


    注明:本文参考了网上一些资源,写的时候没有记下出处,所以无法注明,并且本文仅供读者学习所用,请不要做有些违反法律的事情,一旦发生,与本无关。

    ------------------------------------------------------------------------------------------------------------

    《Java程序员由笨鸟到菜鸟》电子版书正式发布,欢迎大家下载


    http://blog.csdn.net/csh624366188/article/details/7999247

    展开全文
  • Java防止SQL注入

    千次阅读 2014-09-23 17:32:56
    Java防止SQL注入 SQL 注入简介:  SQL注入是最常见的攻击方式之一,它不是利用操作系统或其它系统的漏洞来实现攻击的,而是程序员因为没有做好判断,被不法 用户钻了SQL的空子,下面我们先来看下...
    Java防止SQL注入

    SQL 注入简介:
            SQL注入是最常见的攻击方式之一,它不是利用操作系统或其它系统的漏洞来实现攻击的,而是程序员因为没有做好判断,被不法

    用户钻了SQL的空子,下面我们先来看下什么是SQL注入:

            比如在一个登陆界面,要求用户输入用户名和密码:

            用户名:     ' or 1=1 --   

            密     码:   

            点登陆,如若没有做特殊处理,而只是一条带条件的查询语句如:

            String sql="select * from users where username='"+userName+"' and password='"+password+"' "

            那么这个非法用户就很得意的登陆进去了.(当然现在的有些语言的数据库API已经处理了这些问题)

            这是为什么呢?我们来看看这条语句,将用户输入的数据替换后得到这样一条语句:

            select * from users where username='' or 1=1 --' and password=''

            为了更明白些,可以将其复制到SQL分析器中,将会发现,这条语句会将数据库的数据全部读出来,为什么呢?

            很简单,看到条件后面 username='' or 1=1 用户名等于 '' 或 1=1 那么这个条件一定会成功,然后后面加两个-,这意味着

    什么?没错,注释,它将后面的语句注释,让他们不起作用,这样就可以顺利的把数据库中的数据读取出来了。

            这还是比较温柔的,如果是执行 
            select * from users where username='' ;DROP Database    (DB Name) --' and password=''

            .......其他的您可以自己想象。。。

            那么我们怎么来处理这种情况呢?下面我以java为列给大家两种简单的方法:

            第一种采用预编译语句集,它内置了处理SQL注入的能力,只要使用它的setString方法传值即可
            String sql= "select * from users where username=? and password=?;
            PreparedStatement preState = conn.prepareStatement(sql);
            preState.setString(1, userName);
            preState.setString(2, password);
            ResultSet rs = preState.executeQuery();
            ...

            第二种是采用正则表达式将包含有 单引号('),分号(;) 和 注释符号(--)的语句给替换掉来防止SQL注入
            public static String TransactSQLInjection(String str)
            {
                  return str.replaceAll(".*([';]+|(--)+).*", " ");

               // 我认为 应该是return str.replaceAll("([';])+|(--)+","");

            }

            userName=TransactSQLInjection(userName);
            password=TransactSQLInjection(password);

            String sql="select * from users where username='"+userName+"' and password='"+password+"' "
            Statement sta = conn.createStatement();
            ResultSet rs = sta.executeQuery(sql);

          第三种 使用Hibernate框架的SQL注入防范 Hibernate是目前使用最多的ORM框架,在Java Web开发中,很多时候不直接使用JDBC,而使用Hibernate来提高开发效率。在Hibernate中,仍然不应该通过拼接HQL的方式,而应使用参数化的方式来防范SQL注入。有两种方式, 一种仍然是使用JDBC一样的占位符“?”但更好的方式是使用Hibernate的命名参数,例如检测用户名和密码是否正确,使用Hibernate可以写成: String queryStr = “from user where username=:username ”+”password=:password”; List result = session.createQuery(queryStr).setString("username", username).setString("password", password).list();
    展开全文
  • javasql注入攻击过滤器

    热门讨论 2011-08-09 17:28:20
    javasql注入攻击过滤器 filter
  • java当中sql注入详解

    千次阅读 2018-02-22 17:01:15
    (1)代码如下package ...import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import org.junit.Test;public class...

    (1)代码如下

    package cn.packa.wwy;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    import org.junit.Test;
    public class TestLogin {
    @Test
    public void testLogin() {
    try {
    login("wwy' or 'gg", "111");
    } catch (ClassNotFoundException | SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    }
    /*
    * 测试sql注入

    */
    public void login(String username, String password) throws ClassNotFoundException, SQLException {


    // 注册驱动
    Class.forName("com.mysql.jdbc.Driver");
    // 获取连接
    String url = "jdbc:mysql://127.0.0.1:3308/wwy221?useUnicode=true&characterEncoding=utf8";
    String conname = "root";
    String password1 = "123456";
    Connection conn = DriverManager.getConnection(url, conname, password1);
    // 创建执行sql的对象
    Statement stement = conn.createStatement();
    String sql = "select * from tb_user where username='" + username + "' and userpass='" + password + "'";
    ResultSet rs = stement.executeQuery(sql);
    if (rs.next()) {
    System.out.println("登录成功");
    System.out.println(sql);
    } else {
    System.out.println("无此人");
    System.out.println(sql);
    }
    if (rs != null)
    rs.close();
    if (stement != null)
    stement.close();
    if (conn != null)
    conn.close();
    }


    }

    (2)数据库设计如下


    
    

    (3)查询结果如下


    (4)由于statement当中存在sql拼接问题,因此可能会导致开发过程当中出现sql注入问题

    (5)解决方案

    1、过滤用户输入的数据是否合法

    2、分步校验,先使用用户名对用户身份进行校验,如果找到了,在进行密码校验

    3、使用preparestatement,该代码如下

    public void preStatementLogin(String username, String pass) throws ClassNotFoundException, SQLException {
    Class.forName("com.mysql.jdbc.Driver");
    // 获取连接
    String url = "jdbc:mysql://127.0.0.1:3308/wwy221?useUnicode=true&characterEncoding=utf8";
    String conname = "root";
    String password1 = "123456";
    Connection conn = DriverManager.getConnection(url, conname, password1);
    String sql = "select * from tb_user where username=? and userpass=?";
    PreparedStatement pst = conn.prepareStatement(sql);
    pst.setString(1, username);
    pst.setString(2, pass);
    ResultSet rs = null;
    rs = pst.executeQuery();
    if (rs.next()) {
    System.out.println("登录成功");
    System.out.println(sql);
    } else {
    System.out.println("无此人");
    System.out.println(sql);
    }
    if (rs != null)
    rs.close();
    if (pst != null)
    pst.close();
    if (conn != null)
    conn.close();

    }

    效果截图



    展开全文
  • JAVA实现sql注入点检测

    2013-04-24 10:07:48
    JAVA实现的网络爬虫以及对爬到的页进行sql注入的判断
  • Java防止SQL注入的几个途径,对于网页安全很有帮助
  • javasql注入代码

    2009-05-11 16:30:36
    很强大的防SQL注入,针对JAVA系统 方便使用,作为过滤器使用。
  • java防止sql注入

    2012-10-11 09:07:59
     SQL注入是最常见的攻击方式之一,它不是利用操作系统或其它系统的漏洞来实现攻击的,而是程序员因为没有做好判断,被不法 用户钻了SQL的空子,下面我们先来看下什么是SQL注入:  比如在一个登陆界面,要求用户...
  • javasql注入方法小结

    千次阅读 2017-10-16 19:33:47
    本文对java操作数据库的一项重点内容——防sql注入进行说明。对现有方法进行了简单优劣讨论与总结,供大家参考讨论。 重点:不要将用户输入内容,在未经检查的情况下,直接拼接为sql语句进行数据库访问操作。 防...
  • 原文地址:Java防止SQL注入SQL 注入简介: SQL注入是最常见的攻击方式之一,它不是利用操作系统或其它系统的漏洞来实现攻击的,而是程序员因为没有做好判断,被不法用户钻了SQL的空子,下面我们先来看下什么是SQL注入:...
  • java开发Sql注入检测正则表达式

    千次阅读 2019-06-18 14:40:15
    sql拼装过程中有时候需要把特殊外部的参数拼装到sql语句中去,若不检测外部传入的参数是否含有sql关键词,黑客利用系统这个漏洞注入sql脚本语句进行数据库删除或盗取数据资料。 sql非法注入检测正则表达式 \b(and|...
  • java web sql注入漏洞

    千次阅读 2015-01-06 10:50:26
    这段时间做项目发现了一个问题就是sql注入漏洞,最开始我根本就不知道什么是sql注入漏洞,也不知道是怎么一回事,但是问题被发现了就只有去解决啊。我百度才知道这就是一些人利用sql语句进行获取数据的一种方式。 ...
  • MySQL for JavaSQL注入测试

    千次阅读 2015-05-14 15:39:24
    只要你学JDBC,基本上所有的人都会和你说,Statement不能防止SQL注入, PreparedStatement能够防止SQL注入. 基本上参加工作了一段时间之后还是这么认为的, 没错, 这句是没有问题的, 但到底如何进行SQL注入?怎么直观的...
  • Java防止SQL注入的方法

    千次阅读 2019-05-08 11:02:32
    一、SQL 注入简介:SQL注入是最常见的攻击方式之一,它不是利用操作系统或其它系统的漏洞来实现攻击的,而是程序员因为没有做好判断,被不法用户钻了SQL的空子,下面我们先来看下什么是SQL注入: 1、比如在一个登陆界面,...
  • java防止SQL注入的几个途径

    万次阅读 2013-02-17 10:37:21
    javaSQL注入,最简单的办法是杜绝SQL拼接,SQL注入攻击能得逞是因为在原有SQL语句中加入了新的逻辑,如果使用PreparedStatement来代替Statement来执行SQL语句,其后只是输入参数,SQL注入攻击手段将无效,这是因为...
  • 关于JavaSQL注入的方法研究

    千次阅读 2016-05-03 13:59:17
    在说如何防止之前首先我先说一下造成SQL注入的原因是因为程序员书写的原因  一般来说SQL注入很多时候都是SQL语句拼接造成的。 方法一: //过滤 ‘ //ORACLE 注解 -- /**/ //关键字过滤 update ,dele
  • JavaSQL注入过滤器代码

    万次阅读 2018-01-14 18:55:22
    所谓SQL注入,就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令,达到一定的非法用途。 解决办法 1、配置WEB-INF/web.xml web-app&...
  • java防止sql注入过滤器

    千次阅读 2019-04-11 11:40:31
    普通的列表模糊查询,可能会被sql注入利用,造成数据泄漏,严重的甚至导致删表删库! 貌似正常的sql语句 SELECT*FROMtblStudentWHEREunit_namelike'%aaa%'orderbycreate_timedesclimit 0, 30 ; 倘若想要借此进行...
  • javasql注入

    千次阅读 2009-03-10 11:39:00
    package com.cssweb.webcall.util;//: 防止一般SQL注入// 调用方法:PreventInfusion.sqlInfusion(str);public class PreventInfusion { private static final String inj_str = "@and@exec@insert@select@delete
  • SQL注入的解析: SQL注入的解决方法:
  • Java SQL检查器 用于测试Java代码是否存在SQL注入漏洞的实用程序。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,495
精华内容 50,598
关键字:

java常见的sql注入

java 订阅