Java - Escape-Zeichenfolge zur Verhinderung der SQL-Injection

Ich versuche, eine Anti-SQL-Injektion in Java zu installieren, und finde es sehr schwierig, mit der String-Funktion "replaceAll" zu arbeiten. Letztendlich brauche ich eine Funktion, die alle vorhandenen \in \\, alle "in \", alle 'in \'und alle \nin konvertiert , \\ndamit bei der Auswertung der Zeichenfolge durch MySQL SQL-Injektionen blockiert werden.

Ich habe einen Code aufgebockt, mit dem ich gearbeitet habe, und alle \\\\\\\\\\\Funktionen machen meine Augen verrückt. Wenn jemand ein Beispiel dafür hat, würde ich es sehr schätzen.

PreparedStatements sind der richtige Weg, da sie eine SQL-Injection unmöglich machen. Hier ist ein einfaches Beispiel, in dem die Benutzereingaben als Parameter verwendet werden:

public insertUser(String name, String email) {
   Connection conn = null;
   PreparedStatement stmt = null;
   try {
      conn = setupTheDatabaseConnectionSomehow();
      stmt = conn.prepareStatement("INSERT INTO person (name, email) values (?, ?)");
      stmt.setString(1, name);
      stmt.setString(2, email);
      stmt.executeUpdate();
   }
   finally {
      try {
         if (stmt != null) { stmt.close(); }
      }
      catch (Exception e) {
         // log this error
      }
      try {
         if (conn != null) { conn.close(); }
      }
      catch (Exception e) {
         // log this error
      }
   }
}

Unabhängig davon, welche Zeichen in Name und E-Mail enthalten sind, werden diese Zeichen direkt in der Datenbank abgelegt. Sie haben keinerlei Auswirkungen auf die INSERT-Anweisung.

Es gibt verschiedene Set-Methoden für verschiedene Datentypen. Welche Sie verwenden, hängt von Ihren Datenbankfeldern ab. Wenn Sie beispielsweise eine INTEGER-Spalte in der Datenbank haben, sollten Sie eine setIntMethode verwenden. In der PreparedStatement-Dokumentation sind alle verschiedenen Methoden zum Festlegen und Abrufen von Daten aufgeführt.

Die einzige Möglichkeit, die SQL-Injection zu verhindern, ist die Parametrisierung von SQL. Es ist einfach nicht möglich, einen Filter zu erstellen, der intelligenter ist als die Leute, die SQL für ihren Lebensunterhalt hacken.

Verwenden Sie daher Parameter für alle Eingaben, Aktualisierungen und where-Klauseln. Dynamisches SQL ist einfach eine offene Tür für Hacker, und dazu gehört auch dynamisches SQL in gespeicherten Prozeduren. Parametrieren, parametrisieren, parametrisieren.

Wenn Sie Defense Option 1: Vorbereitete Anweisungen (parametrisierte Abfragen) oder Defense Option 2: Gespeicherte Prozeduren wirklich nicht verwenden können , erstellen Sie kein eigenes Tool, sondern verwenden Sie die OWASP Enterprise Security API . Aus dem auf Google Code gehosteten OWASP ESAPI :

Schreiben Sie keine eigenen Sicherheitskontrollen! Die Neuerfindung des Rades bei der Entwicklung von Sicherheitskontrollen für jede Webanwendung oder jeden Webdienst führt zu Zeitverschwendung und massiven Sicherheitslücken. Die ESWI-Toolkits (OWASP Enterprise Security API) helfen Softwareentwicklern, sich vor sicherheitsrelevanten Design- und Implementierungsfehlern zu schützen.

Weitere Informationen finden Sie unter Verhindern von SQL Injection in Java und SQL Injection Prevention Cheat Sheet .

Achten Sie besonders auf Verteidigungsoption 3: Entkommen aller vom Benutzer bereitgestellten Eingaben , mit denen das OWASP ESAPI- Projekt eingeführt wird.

(Dies ist eine Antwort auf den Kommentar des OP unter der ursprünglichen Frage. Ich stimme voll und ganz zu, dass PreparedStatement das Werkzeug für diesen Job ist und keine regulären Ausdrücke.)

Wenn Sie sagen \n, meinen Sie die Sequenz \+ noder ein tatsächliches Zeilenvorschubzeichen? Wenn es \+ ist n, ist die Aufgabe ziemlich einfach:

s = s.replaceAll("['\"\\\\]", "\\\\$0");

Um einem Backslash in der Eingabe zu entsprechen, fügen Sie vier davon in die Regex-Zeichenfolge ein. Um einen Backslash in die Ausgabe einzufügen, fügen Sie vier davon in die Ersatzzeichenfolge ein. Dies setzt voraus, dass Sie die regulären Ausdrücke und Ersetzungen in Form von Java-String-Literalen erstellen. Wenn Sie sie auf andere Weise erstellen (z. B. indem Sie sie aus einer Datei lesen), müssen Sie nicht all diese doppelten Escapezeichen ausführen.

Wenn die Eingabe ein Zeilenvorschubzeichen enthält und Sie es durch eine Escape-Sequenz ersetzen möchten, können Sie die Eingabe folgendermaßen durchlaufen:

s = s.replaceAll("\n", "\\\\n");

Oder vielleicht möchten Sie zwei Backslashes (da bin ich mir nicht ganz sicher):

s = s.replaceAll("\n", "\\\\\\\\n");

PreparedStatements sind in den meisten, aber nicht in allen Fällen der richtige Weg. Manchmal befinden Sie sich in einer Situation, in der eine Abfrage oder ein Teil davon erstellt und zur späteren Verwendung als Zeichenfolge gespeichert werden muss. Weitere Informationen und APIs in verschiedenen Programmiersprachen finden Sie im SQL Injection Prevention Cheat Sheet auf der OWASP-Site .

Vorbereitete Anweisungen sind die beste Lösung. Wenn Sie dies jedoch wirklich manuell ausführen müssen, können Sie auch die StringEscapeUtilsKlasse aus der Apache Commons-Lang-Bibliothek verwenden. Es gibt eine escapeSql(String)Methode, die Sie verwenden können:

import org.apache.commons.lang.StringEscapeUtils; … String escapedSQL = StringEscapeUtils.escapeSql(unescapedSQL);

Die Verwendung eines regulären Ausdrucks zum Entfernen von Text, der eine SQL-Injection verursachen könnte, klingt so, als würde die SQL-Anweisung über a Statementund nicht über a an die Datenbank gesendet PreparedStatement.

Eine der einfachsten Möglichkeiten, eine SQL-Injection zu verhindern, ist die Verwendung von a PreparedStatement, das Daten akzeptiert, die mithilfe von Platzhaltern in eine SQL-Anweisung eingesetzt werden sollen. Dies beruht nicht auf Zeichenfolgenverkettungen, um eine SQL-Anweisung zum Senden an die Datenbank zu erstellen.

Weitere Informationen finden Sie unter Verwenden vorbereiteter Anweisungen aus den Java-Lernprogrammen .

PreparedStatementWenn Sie es mit einem Legacy-System zu tun haben oder zu viele Orte haben, um in zu kurzer Zeit zu s zu wechseln - dh wenn die Verwendung der von anderen Antworten vorgeschlagenen Best Practice behindert wird , können Sie AntiSQLFilter ausprobieren

Sie benötigen den folgenden Code. Auf den ersten Blick mag dies wie jeder alte Code aussehen, den ich erfunden habe. Ich habe mir jedoch den Quellcode für http://grepcode.com/file/repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.31/com/mysql/jdbc/PreparedStatement angesehen. Java . Danach habe ich den Code von setString (int parameterIndex, String x) sorgfältig durchgesehen, um die Zeichen zu finden, denen es entgeht, und dies an meine eigene Klasse angepasst, damit es für die von Ihnen benötigten Zwecke verwendet werden kann. Wenn dies die Liste der Zeichen ist, denen Oracle entgeht, ist es in Bezug auf die Sicherheit wirklich beruhigend, dies zu wissen. Möglicherweise benötigt Oracle einen Anstoß, um eine ähnliche Methode für die nächste große Java-Version hinzuzufügen.

public class SQLInjectionEscaper {

    public static String escapeString(String x, boolean escapeDoubleQuotes) {
        StringBuilder sBuilder = new StringBuilder(x.length() * 11/10);

        int stringLength = x.length();

        for (int i = 0; i < stringLength; ++i) {
            char c = x.charAt(i);

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

                break;

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

                break;

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

                break;

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

                break;

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

                break;

            case '"': /* Better safe than sorry */
                if (escapeDoubleQuotes) {
                    sBuilder.append('\\');
                }

                sBuilder.append('"');

                break;

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

                break;

            case '\u00a5':
            case '\u20a9':
                // escape characters interpreted as backslash by mysql
                // fall through

            default:
                sBuilder.append(c);
            }
        }

        return sBuilder.toString();
    }
}

Nach dem Durchsuchen einer Testlösung, um zu verhindern, dass SQLMap SQL-Injection ausführt, im Falle eines Legacy-Systems, das vorbereitete Anweisungen nicht überall anwenden kann.

Java-Security-Cross-Site-Scripting-xss-und-SQL-Injection-Thema Lösung

Ich habe @Richards Lösung ausprobiert, aber in meinem Fall nicht funktioniert. Ich habe einen Filter verwendet

Das Ziel dieses Filters ist es, die Anforderung in einen eigencodierten Wrapper MyHttpRequestWrapper zu verpacken, der Folgendes transformiert:

die HTTP-Parameter mit Sonderzeichen (<,>, ',…) in HTML-Codes über die Methode org.springframework.web.util.HtmlUtils.htmlEscape (…). Hinweis: In Apache Commons gibt es eine ähnliche Klasse: org.apache.commons.lang.StringEscapeUtils.escapeHtml (…) die SQL-Injection-Zeichen (', “,…) über die Apache Commons-Klasse org.apache.commons.lang.StringEscapeUtils. EscapeSql (…)

<filter>
<filter-name>RequestWrappingFilter</filter-name>
<filter-class>com.huo.filter.RequestWrappingFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>RequestWrappingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>




package com.huo.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletReponse;
import javax.servlet.http.HttpServletRequest;

public class RequestWrappingFilter implements Filter{

    public void doFilter(ServletRequest req, ServletReponse res, FilterChain chain) throws IOException, ServletException{
        chain.doFilter(new MyHttpRequestWrapper(req), res);
    }

    public void init(FilterConfig config) throws ServletException{
    }

    public void destroy() throws ServletException{
    }
}




package com.huo.filter;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import org.apache.commons.lang.StringEscapeUtils;

public class MyHttpRequestWrapper extends HttpServletRequestWrapper{
    private Map<String, String[]> escapedParametersValuesMap = new HashMap<String, String[]>();

    public MyHttpRequestWrapper(HttpServletRequest req){
        super(req);
    }

    @Override
    public String getParameter(String name){
        String[] escapedParameterValues = escapedParametersValuesMap.get(name);
        String escapedParameterValue = null; 
        if(escapedParameterValues!=null){
            escapedParameterValue = escapedParameterValues[0];
        }else{
            String parameterValue = super.getParameter(name);

            // HTML transformation characters
            escapedParameterValue = org.springframework.web.util.HtmlUtils.htmlEscape(parameterValue);

            // SQL injection characters
            escapedParameterValue = StringEscapeUtils.escapeSql(escapedParameterValue);

            escapedParametersValuesMap.put(name, new String[]{escapedParameterValue});
        }//end-else

        return escapedParameterValue;
    }

    @Override
    public String[] getParameterValues(String name){
        String[] escapedParameterValues = escapedParametersValuesMap.get(name);
        if(escapedParameterValues==null){
            String[] parametersValues = super.getParameterValues(name);
            escapedParameterValue = new String[parametersValues.length];

            // 
            for(int i=0; i<parametersValues.length; i++){
                String parameterValue = parametersValues[i];
                String escapedParameterValue = parameterValue;

                // HTML transformation characters
                escapedParameterValue = org.springframework.web.util.HtmlUtils.htmlEscape(parameterValue);

                // SQL injection characters
                escapedParameterValue = StringEscapeUtils.escapeSql(escapedParameterValue);

                escapedParameterValues[i] = escapedParameterValue;
            }//end-for

            escapedParametersValuesMap.put(name, escapedParameterValues);
        }//end-else

        return escapedParameterValues;
    }
}

Von: [Quelle]

public String MysqlRealScapeString(String str){
  String data = null;
  if (str != null && str.length() > 0) {
    str = str.replace("\\", "\\\\");
    str = str.replace("'", "\\'");
    str = str.replace("\0", "\\0");
    str = str.replace("\n", "\\n");
    str = str.replace("\r", "\\r");
    str = str.replace("\"", "\\\"");
    str = str.replace("\\x1a", "\\Z");
    data = str;
  }
return data;

}}

Wenn Sie PL / SQL verwenden, können Sie auch verwenden DBMS_ASSERT , um Ihre Eingabe zu bereinigen, sodass Sie es verwenden können, ohne sich um SQL-Injektionen sorgen zu müssen.

Siehe diese Antwort zum Beispiel: https://stackoverflow.com/a/21406499/1726419