Java - ciąg znaków zmiany znaczenia, aby zapobiec iniekcji SQL

Próbuję umieścić w javie jakiś iniekcję anti sql i jest mi bardzo trudno pracować z funkcją string „replaceAll”. Ostatecznie potrzebuję funkcji, która skonwertuje wszystkie istniejące \na \\, dowolne "na \", dowolne 'na \'i dowolne \nna \\ntak, że gdy ciąg jest oceniany przez wstrzyknięcia SQL MySQL, zostaną zablokowane.

Podłączyłem jakiś kod, z którym pracowałem, i cała \\\\\\\\\\\funkcja przyprawia mnie o szaleństwo. Byłbym bardzo wdzięczny, gdyby ktoś miał na to przykład.

PreparedStatements to droga do zrobienia, ponieważ uniemożliwiają iniekcję SQL. Oto prosty przykład uwzględniający dane wejściowe użytkownika jako parametry:

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
      }
   }
}

Bez względu na to, jakie znaki są w nazwie i e-mailu, zostaną one umieszczone bezpośrednio w bazie danych. Nie wpłyną one w żaden sposób na instrukcję INSERT.

Istnieją różne metody ustawiania dla różnych typów danych - to, której z nich używasz, zależy od tego, jakie są pola bazy danych. Na przykład, jeśli masz w bazie danych kolumnę INTEGER, powinieneś użyć setIntmetody. Dokumentacja PreparedStatement zawiera listę wszystkich dostępnych metod ustawiania i pobierania danych.

Jedynym sposobem zapobiegania iniekcji SQL jest sparametryzowany SQL. Po prostu nie jest możliwe zbudowanie filtra, który byłby mądrzejszy niż ludzie, którzy zarabiają na życie hakowaniem SQL.

Dlatego użyj parametrów dla wszystkich klauzul input, updates i where. Dynamiczny SQL to po prostu otwarte drzwi dla hakerów, co obejmuje dynamiczny SQL w procedurach składowanych. Parametryzacja, parametryzacja, parametryzacja.

Jeśli naprawdę nie możesz użyć opcji obrony 1: gotowe instrukcje (zapytania parametryczne) lub opcji obrony 2: procedury składowane , nie twórz własnego narzędzia, użyj interfejsu API OWASP Enterprise Security . Z OWASP ESAPI hostowanego w Google Code:

Nie pisz własnych zabezpieczeń! Odkrywanie na nowo koła, jeśli chodzi o opracowywanie kontroli bezpieczeństwa dla każdej aplikacji internetowej lub usługi internetowej, prowadzi do marnowania czasu i ogromnych luk w zabezpieczeniach. Zestawy narzędzi OWASP Enterprise Security API (ESAPI) pomagają programistom chronić się przed błędami projektowymi i wdrożeniowymi związanymi z bezpieczeństwem.

Aby uzyskać więcej informacji, zobacz temat Zapobieganie iniekcjom SQL w języku Java i ściągawka dotycząca zapobiegania iniekcjom SQL .

Zwróć szczególną uwagę na opcję obrony 3: ucieczka od wszystkich danych wprowadzonych przez użytkownika, która wprowadza projekt OWASP ESAPI ).

(Jest to odpowiedź na komentarz OP w pierwotnym pytaniu; Całkowicie zgadzam się, że narzędzie PreparedStatement jest narzędziem do tego zadania, a nie wyrażeniami regularnymi).

Kiedy mówisz \n, czy masz na myśli sekwencję \+ nczy rzeczywisty znak nowego wiersza? Jeśli to \+ n, zadanie jest dość proste:

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

Aby dopasować jeden lewy ukośnik w danych wejściowych, należy umieścić cztery z nich w ciągu wyrażenia regularnego. Aby wstawić jeden odwrotny ukośnik na wyjściu, należy umieścić cztery z nich w ciągu zastępczym. Zakłada się, że tworzysz wyrażenia regularne i zamienniki w postaci literałów Java String. Jeśli utworzysz je w jakikolwiek inny sposób (np. Czytając je z pliku), nie musisz robić tego podwójnego znaku ucieczki.

Jeśli masz znak wysuwu wiersza na wejściu i chcesz go zastąpić sekwencją ucieczki, możesz wykonać drugie przejście przez wejście za pomocą tego:

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

A może chcesz dwa odwrotne ukośniki (nie jestem tego pewien):

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

PreparedStatements to sposób postępowania w większości, ale nie we wszystkich przypadkach. Czasami znajdziesz się w sytuacji, w której zapytanie lub jego część musi zostać zbudowane i zapisane jako łańcuch do późniejszego wykorzystania. Zapoznaj się ze ściągawką dotyczącą zapobiegania iniekcjom SQL w witrynie OWASP, aby uzyskać więcej informacji i interfejsów API w różnych językach programowania.

Przygotowane instrukcje są najlepszym rozwiązaniem, ale jeśli naprawdę musisz to zrobić ręcznie, możesz również użyć StringEscapeUtilsklasy z biblioteki Apache Commons-Lang. Ma escapeSql(String)metodę, której możesz użyć:

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

Użycie wyrażenia regularnego w celu usunięcia tekstu, który mógłby spowodować wstrzyknięcie SQL, brzmi tak, jakby instrukcja SQL była wysyłana do bazy danych za pośrednictwem, Statementa nie PreparedStatement.

Jednym z najłatwiejszych sposobów zapobiegania iniekcji SQL w pierwszej kolejności jest użycie a PreparedStatement, który akceptuje dane do zastąpienia w instrukcji SQL przy użyciu symboli zastępczych, która nie polega na konkatenacji ciągów w celu utworzenia instrukcji SQL do wysłania do bazy danych.

Aby uzyskać więcej informacji, dobrym początkiem byłoby użycie gotowych instrukcji z samouczków języka Java .

Jeśli masz do czynienia ze starszym systemem lub masz zbyt wiele miejsc, aby przełączyć się na PreparedStatements w zbyt krótkim czasie - tj. Jeśli napotkasz przeszkodę w zastosowaniu najlepszych praktyk sugerowanych przez inne odpowiedzi, możesz wypróbować AntiSQLFilter

Potrzebujesz poniższego kodu. Na pierwszy rzut oka może to wyglądać jak każdy stary kod, który wymyśliłem. Jednak spojrzałem na kod źródłowy http://grepcode.com/file/repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.31/com/mysql/jdbc/PreparedStatement. java . Następnie dokładnie przejrzałem kod setString (int parameterIndex, String x), aby znaleźć znaki, z których ucieka, i dostosowałem to do mojej własnej klasy, aby można go było użyć do celów, których potrzebujesz. W końcu, jeśli jest to lista postaci, które uciekają Oracle, to świadomość, że jest to naprawdę pocieszające pod względem bezpieczeństwa. Może Oracle potrzebuje zachęty, aby dodać metodę podobną do tej dla następnej większej wersji Java.

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();
    }
}

Po przeszukaniu wielu testowych rozwiązań zapobiegających wstrzykiwaniu sqlmap do sql, w przypadku starszego systemu, który nie może wszędzie zastosować przygotowanych instrukcji.

temat java-security-cross-site-scripting-xss-and-sql-injection BYŁO ROZWIĄZANIEM

wypróbowałem rozwiązanie @Richard, ale nie zadziałało w moim przypadku. użyłem filtra

Celem tego filtru jest umieszczenie żądania w zakodowanym przez siebie opakowaniu MyHttpRequestWrapper, który przekształca:

parametry HTTP ze znakami specjalnymi (<,>, ',…) do kodów HTML za pomocą metody org.springframework.web.util.HtmlUtils.htmlEscape (…). Uwaga: w Apache Commons występuje podobna klasa: org.apache.commons.lang.StringEscapeUtils.escapeHtml (…) znaki iniekcji SQL („,„,…) za pośrednictwem Apache Commons classe 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;
    }
}

Od: [Źródło]

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;

}

Jeśli używasz PL / SQL, możesz go również użyć DBMS_ASSERT , aby oczyścić dane wejściowe, dzięki czemu możesz z niego korzystać bez martwienia się o wstrzyknięcia SQL.

zobacz tę odpowiedź na przykład: https://stackoverflow.com/a/21406499/1726419