Java - string de escape para impedir a injeção de SQL

Estou tentando colocar alguma injeção anti-sql no java e estou com muita dificuldade em trabalhar com a função de cadeia "replaceAll". Por fim, preciso de uma função que converta qualquer existente \para \\, qualquer "para \", qualquer 'para \'e qualquer \npara, \\npara que quando a string for avaliada pelas injeções de SQL do MySQL sejam bloqueadas.

Eu criei um código com o qual estava trabalhando e todas \\\\\\\\\\\as funções estão fazendo meus olhos enlouquecerem. Se alguém tiver um exemplo disso, eu apreciaria muito.

PreparedStatements são o caminho a seguir, porque tornam impossível a injeção de SQL. Aqui está um exemplo simples, considerando a entrada do usuário como parâmetros:

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

Não importa quais caracteres estejam no nome e no email, esses caracteres serão colocados diretamente no banco de dados. Eles não afetarão a instrução INSERT de forma alguma.

Existem diferentes métodos de conjunto para diferentes tipos de dados - o que você usa depende dos campos de seu banco de dados. Por exemplo, se você tiver uma coluna INTEGER no banco de dados, use um setIntmétodo A documentação PreparedStatement lista todos os diferentes métodos disponíveis para definir e obter dados.

A única maneira de impedir a injeção de SQL é com SQL parametrizado. Simplesmente não é possível criar um filtro mais inteligente do que as pessoas que usam o SQL para viver.

Portanto, use parâmetros para todas as entradas, atualizações e cláusulas where. O SQL dinâmico é simplesmente uma porta aberta para hackers, e isso inclui SQL dinâmico em procedimentos armazenados. Parametrizar, parametrizar, parametrizar.

Se você realmente não pode usar a Opção 1 de Defesa: Instruções Preparadas (Consultas Parametrizadas) ou a Opção 2 de Defesa: Procedimentos Armazenados , não crie sua própria ferramenta, use a API de Segurança Corporativa da OWASP . No ESAPI da OWASP hospedado no Google Code:

Não escreva seus próprios controles de segurança! Reinventar a roda quando se trata de desenvolver controles de segurança para todos os aplicativos ou serviços da Web leva a perda de tempo e grandes falhas de segurança. Os kits de ferramentas da API de segurança corporativa da OWASP (ESAPI) ajudam os desenvolvedores de software a se protegerem contra falhas de projeto e implementação relacionadas à segurança.

Para obter mais detalhes, consulte Prevenção de injeção SQL em Java e Folha de dicas de prevenção de injeção SQL .

Preste atenção especial à Opção 3 de Defesa: Escapando Todas as Entradas Fornecidas pelo Usuário que apresenta o projeto ESAPI da OWASP ).

(Isso é uma resposta ao comentário do OP na pergunta original; concordo plenamente que o PreparedStatement é a ferramenta para este trabalho, não as expressões regulares.)

Quando você diz \n, você quer dizer a sequência \+ nou um caractere de avanço de linha real? Se for \+ n, a tarefa é bem simples:

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

Para corresponder a uma barra invertida na entrada, coloque quatro delas na sequência de caracteres regex. Para colocar uma barra invertida na saída, coloque quatro delas na cadeia de substituição. Isso pressupõe que você esteja criando as regexes e substituições na forma de literais Java String. Se você criá-los de outra maneira (por exemplo, lendo-os de um arquivo), você não precisa fazer tudo isso duas vezes.

Se você tiver um caractere de avanço de linha na entrada e desejar substituí-lo por uma sequência de escape, poderá fazer uma segunda passagem sobre a entrada com este:

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

Ou talvez você queira duas barras invertidas (não estou muito claro sobre isso):

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

As PreparedStatements são o caminho a seguir na maioria dos casos, mas não em todos os casos. Às vezes, você se encontra em uma situação em que uma consulta, ou parte dela, precisa ser criada e armazenada como uma string para uso posterior. Consulte a Folha de dicas sobre prevenção de injeção de SQL no site da OWASP para obter mais detalhes e APIs em diferentes linguagens de programação.

As instruções preparadas são a melhor solução, mas se você realmente precisar fazer isso manualmente, também poderá usar a StringEscapeUtilsclasse da biblioteca Apache Commons-Lang. Tem um escapeSql(String)método, que você pode usar:

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

O uso de uma expressão regular para remover texto que possa causar uma injeção de SQL parece que a instrução SQL está sendo enviada ao banco de dados por StatementumPreparedStatement .

Uma das maneiras mais fáceis de evitar uma injeção de SQL em primeiro lugar é usar um PreparedStatement , que aceita dados para substituir uma instrução SQL usando espaços reservados, que não depende de concatenações de cadeias para criar uma instrução SQL para enviar ao banco de dados.

Para obter mais informações, o uso de instruções preparadas nos tutoriais Java seria um bom ponto de partida.

Caso você esteja lidando com um sistema legado ou tenha muitos lugares para mudar para PreparedStatements em muito pouco tempo - por exemplo, se houver um obstáculo ao uso da melhor prática sugerida por outras respostas, tente o AntiSQLFilter

Você precisa do seguinte código abaixo. À primeira vista, isso pode parecer com qualquer código antigo que eu criei. No entanto, o que fiz foi verificar o código fonte de http://grepcode.com/file/repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.31/com/mysql/jdbc/PreparedStatement. java . Depois disso, examinei cuidadosamente o código de setString (int parameterIndex, String x) para encontrar os caracteres dos quais ele escapa e personalizo isso para minha própria classe, para que possa ser usado para os fins que você precisa. Afinal, se essa é a lista de caracteres dos quais o Oracle escapa, saber que isso é realmente reconfortante em termos de segurança. Talvez a Oracle precise de um empurrão para adicionar um método semelhante a este para a próxima versão principal do 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();
    }
}

Depois de pesquisar em um monte de soluções de teste para evitar que o sqlmap seja injetado no sql, no caso de um sistema legado que não pode aplicar declarações preparadas em todos os lugares.

tópico java-security-cross-site-scripting-xss-and-sql-injection foi a solução

Tentei a solução de @Richard, mas não funcionou no meu caso. eu usei um filtro

O objetivo desse filtro é envolver a solicitação em um invólucro MyHttpRequestWrapper com código próprio que transforma:

os parâmetros HTTP com caracteres especiais (<,>, ',…) nos códigos HTML por meio do método org.springframework.web.util.HtmlUtils.htmlEscape (…). Nota: Existe uma classe semelhante no Apache Commons: org.apache.commons.lang.StringEscapeUtils.escapeHtml (…) os caracteres de injeção SQL (', “,…) por meio da classe org.apache.commons.lang.StringEscapeUtils do Apache Commons. 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;
    }
}

De: [Fonte]

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;

}

Se você estiver usando PL / SQL, também poderá usar DBMS_ASSERT lo, além de higienizar sua entrada, para que possa usá-lo sem se preocupar com injeções de SQL.

veja esta resposta por exemplo: https://stackoverflow.com/a/21406499/1726419