Como order_by e order_dir entram na estrutura da query, eles precisam ser limitados a valores conhecidos.

Usar addslashes evita SQL Injection?

Não é o ideal. Funções como addslashes ou tentativas manuais de escapar strings não substituem prepared statements.

O problema é que escapar manualmente pode falhar dependendo do banco, charset, driver e contexto da consulta. Com PDO preparado corretamente, você separa o comando SQL dos valores.

Validação de dados também é importante

Prepared statement protege a consulta, mas não substitui validação de dados. Mesmo usando PDO, você ainda deve validar se os valores fazem sentido.

Exemplos:

• ID deve ser inteiro positivo;
• E-mail deve ter formato válido;
• Senha deve ter tamanho mínimo;
• Status deve estar dentro de uma lista permitida;
• Datas devem ter formato correto;
• Campos obrigatórios não podem estar vazios.

Segurança boa combina prepared statements, validação, controle de acesso e tratamento de erros.

Não exiba erro SQL para o usuário

Em produção, mensagens de erro do banco não devem aparecer na resposta da API ou na tela do usuário.

Evite retornar algo como:

SQLSTATE[42S22]: Column not found: 1054 Unknown column...

Esse tipo de mensagem pode revelar detalhes internos da aplicação. O melhor é registrar o erro em log e retornar uma mensagem genérica.

prepare($sql);
    $stmt->execute($params);
} catch (PDOException $e) {
    error_log('Erro SQL: ' . $e->getMessage());

    http_response_code(500);
    echo json_encode([
        'success' => false,
        'message' => 'Erro interno no servidor.'
    ]);
    exit;
}

Checklist para evitar SQL Injection em PHP

• Não concatene valores externos diretamente no SQL;
• Use PDO com prepared statements;
• Use parâmetros nomeados ou posicionais;
• Valide IDs como inteiros;
• Valide e-mails, datas, status e campos obrigatórios;
• Use lista branca para colunas em ORDER BY;
• Não use addslashes como solução principal;
• Não exiba erros SQL para o usuário final;
• Registre falhas em log;
• Use password_hash e password_verify em logins;
• Restrinja permissões do usuário do banco;
• Mantenha PHP, banco e dependências atualizados.

Permissões do usuário do banco também importam

Além de proteger o código, é importante configurar o usuário do banco com as permissões necessárias e nada além disso.

Por exemplo, se uma aplicação só precisa ler dados em determinada área, não faz sentido usar um usuário com permissão para excluir tabelas.

Reduzir privilégios ajuda a limitar danos caso algum problema de segurança aconteça.

Erros comuns ao tentar evitar SQL Injection

1. Achar que validação no frontend é suficiente

O frontend pode ser ignorado facilmente. A proteção precisa estar no backend.

2. Usar concatenação porque “é só um ID”

Mesmo IDs devem ser validados e enviados como parâmetros.

3. Usar addslashes como proteção principal

Escapar manualmente não é tão seguro quanto usar prepared statements.

4. Parametrizar valores, mas não validar ORDER BY

Colunas e direções de ordenação devem passar por lista branca.

5. Mostrar erro real do banco em produção

Mensagens internas devem ir para logs, não para a resposta pública.

Exemplo completo de endpoint protegido

Abaixo temos um endpoint completo de listagem de usuários com busca, status, ordenação segura e prepared statements.

 PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES => false
        ]
    );

    $busca = isset($_GET['busca']) ? trim($_GET['busca']) : '';
    $status = isset($_GET['status']) ? trim($_GET['status']) : '';
    $orderBy = $_GET['order_by'] ?? 'id';
    $orderDir = strtolower($_GET['order_dir'] ?? 'desc');

    $colunasPermitidas = ['id', 'nome', 'email', 'created_at'];
    $direcoesPermitidas = ['asc', 'desc'];

    if (!in_array($orderBy, $colunasPermitidas, true)) {
        $orderBy = 'id';
    }

    if (!in_array($orderDir, $direcoesPermitidas, true)) {
        $orderDir = 'desc';
    }

    $where = [];
    $params = [];

    if ($busca !== '') {
        $where[] = "(nome LIKE :busca OR email LIKE :busca)";
        $params[':busca'] = '%' . $busca . '%';
    }

    if ($status !== '') {
        $statusPermitidos = ['ativo', 'inativo'];

        if (!in_array($status, $statusPermitidos, true)) {
            jsonResponse(422, [
                'success' => false,
                'message' => 'Status inválido.'
            ]);
        }

        $where[] = "status = :status";
        $params[':status'] = $status;
    }

    $whereSql = '';

    if (!empty($where)) {
        $whereSql = 'WHERE ' . implode(' AND ', $where);
    }

    $sql = "
        SELECT id, nome, email, status, created_at
        FROM usuarios
        {$whereSql}
        ORDER BY {$orderBy} {$orderDir}
        LIMIT 50
    ";

    $stmt = $pdo->prepare($sql);
    $stmt->execute($params);

    $usuarios = $stmt->fetchAll();

    jsonResponse(200, [
        'success' => true,
        'data' => $usuarios
    ]);

} catch (PDOException $e) {
    error_log('Erro PDO: ' . $e->getMessage());

    jsonResponse(500, [
        'success' => false,
        'message' => 'Erro interno ao consultar os dados.'
    ]);

} catch (Throwable $e) {
    error_log('Erro inesperado: ' . $e->getMessage());

    jsonResponse(500, [
        'success' => false,
        'message' => 'Erro interno no servidor.'
    ]);
}

Conclusão

SQL Injection é uma falha grave, mas pode ser evitada com práticas corretas no PHP. A principal regra é nunca concatenar valores externos diretamente na consulta SQL.

Usando PDO com prepared statements, validação de dados, lista branca para ordenação e tratamento adequado de erros, sua aplicação fica muito mais segura contra manipulações de consulta.

Essa proteção deve ser aplicada em login, cadastro, filtros, buscas, APIs, painéis administrativos e qualquer ponto do sistema que interaja com o banco de dados.

Perguntas frequentes sobre SQL Injection em PHP

O que é SQL Injection em PHP?

SQL Injection é uma falha que acontece quando dados enviados pelo usuário são inseridos diretamente em uma consulta SQL, permitindo manipular o comportamento da query.

Como evitar SQL Injection em PHP?

A forma mais recomendada é usar PDO com prepared statements, passando os valores como parâmetros em vez de concatenar diretamente no SQL.

PDO evita SQL Injection?

Sim, quando usado corretamente com prepared statements e parâmetros. O PDO ajuda a separar o comando SQL dos valores enviados pelo usuário.

addslashes protege contra SQL Injection?

Não deve ser usado como proteção principal. O ideal é usar prepared statements em vez de tentar escapar manualmente os valores.

Preciso validar os dados mesmo usando prepared statements?

Sim. Prepared statements protegem a consulta, mas a validação garante que os dados façam sentido para a regra da aplicação.

LIKE pode ser usado com prepared statement?

Sim. Basta montar o valor com % e passá-lo como parâmetro, por exemplo '%' . $busca . '%'.