Um sistema de login em PHP parece simples até começar a apresentar problemas: a senha nunca é reconhecida, o usuário consegue acessar páginas sem autenticação ou a sessão desaparece depois do redirecionamento. E tem situações piores, como consultas vulneráveis a SQL Injection e informações sensíveis expostas nas mensagens de erro.
Neste artigo, vou mostrar erros comuns na implementação de autenticação com PHP e PDO, explicar por que acontecem e apresentar maneiras de corrigir cada um. Os exemplos consideram PHP 8.2 ou superior, MySQL e PDO.
1. Montar consultas SQL concatenando dados do formulário
Esse é um dos erros mais perigosos. Mesmo que o formulário tenha validação, nunca devemos confiar diretamente nos dados enviados pelo navegador.
Imagine uma consulta que verifica se o e-mail e a senha correspondem a um usuário:
$email = $_POST['email'];
$password = $_POST['password'];
$sql = "SELECT * FROM users
WHERE email = '$email'
AND password = '$password'";
$user = $pdo->query($sql)->fetch();
O problema é que os valores recebidos são inseridos diretamente na instrução SQL. Um usuário mal-intencionado pode manipular esses dados e alterar o comportamento da consulta.
Isso abre espaço para SQL Injection, uma vulnerabilidade que pode permitir acesso indevido ou manipulação de informações no banco. Aproveitando o gancho sobre senhas, fica a recomendação de uma postagem completa de como armazenar senhas com segurança no PHP, vale a pena demais ler.
Como corrigir
Utilize instruções preparadas do PDO e vincule os valores enviados pelo formulário:
$stmt = $pdo->prepare(
'SELECT id, email, password_hash
FROM users
WHERE email = :email'
);
$stmt->execute([
'email' => $email,
]);
$user = $stmt->fetch();
Perceba que a senha não faz parte da consulta. Ela será verificada posteriormente, usando o hash armazenado no banco.
Outra configuração interessante é desabilitar a emulação de prepared statements no MySQL:
$pdo = new PDO(
$dsn,
$username,
$password,
[
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false,
]
);
Prepared statements separam a estrutura da consulta dos valores enviados pelo usuário. Isso é fundamental para evitar que uma entrada seja interpretada como parte do código SQL.
Vale lembrar que placeholders representam valores, não nomes de tabelas, colunas ou comandos SQL. Se precisar montar uma ordenação dinâmica, por exemplo, utilize uma lista de opções permitidas em vez de concatenar diretamente a entrada do usuário.
2. Comparar senhas em texto puro
Outro erro bastante comum em projetos antigos é armazenar a senha diretamente no banco de dados e comparar o valor enviado pelo formulário com o conteúdo da coluna.
Um exemplo de implementação que não deve ser utilizado:
$stmt = $pdo->prepare(
'SELECT id FROM users
WHERE email = :email
AND password = :password'
);
$stmt->execute([
'email' => $email,
'password' => $password,
]);
$user = $stmt->fetch();
O problema vai além da implementação. Se alguém conseguir acesso ao banco de dados, poderá visualizar as senhas dos usuários.
Também não adianta simplesmente substituir a senha por MD5 ou SHA-1. Essas funções não foram projetadas para armazenar senhas e não oferecem a proteção necessária contra ataques de tentativa de descoberta.
Como corrigir
O PHP já possui funções próprias para trabalhar com senhas: password_hash() e password_verify().
No cadastro, gere um hash antes de armazenar a senha:
$passwordHash = password_hash(
$password,
PASSWORD_DEFAULT
);
$stmt = $pdo->prepare(
'INSERT INTO users (email, password_hash)
VALUES (:email, :password_hash)'
);
$stmt->execute([
'email' => $email,
'password_hash' => $passwordHash,
]);
Na autenticação, busque o usuário pelo e-mail e verifique a senha separadamente:
$stmt = $pdo->prepare(
'SELECT id, email, password_hash
FROM users
WHERE email = :email'
);
$stmt->execute([
'email' => $email,
]);
$user = $stmt->fetch();
if ($user && password_verify($password, $user['password_hash'])) {
// Senha válida.
} else {
// Credenciais inválidas.
}
Não tente comparar diretamente a senha enviada com o hash armazenado. O algoritmo e o salt utilizados no hash fazem parte do processo de verificação, e password_verify() já cuida disso.
Outro detalhe importante: não é necessário criar e armazenar um salt manualmente. A função password_hash() já faz esse trabalho.
Se estiver começando um projeto novo, prefira PASSWORD_DEFAULT ou avalie o uso de Argon2id quando disponível no ambiente. O importante é utilizar uma função própria para senhas, em vez de inventar um algoritmo.
3. Não encontrar o usuário e tentar acessar seus dados mesmo assim
Esse erro costuma aparecer quando o desenvolvedor utiliza fetch() e presume que sempre haverá um resultado.
Veja:
$user = $stmt->fetch();
if (password_verify($password, $user['password_hash'])) {
// Login realizado.
}
O método fetch() pode retornar false quando nenhuma linha é encontrada. Nesse cenário, tentar acessar $user['password_hash'] gera um erro.
Além de interromper o fluxo, dependendo da configuração do PHP, a aplicação pode apresentar avisos e informações desnecessárias ao usuário.
Como corrigir
Verifique primeiro se o usuário existe:
$user = $stmt->fetch();
if (!$user || !password_verify($password, $user['password_hash'])) {
$error = 'E-mail ou senha inválidos.';
} else {
// Login realizado.
}
A condição também ajuda a manter a autenticação em um único fluxo: se o usuário não existir ou se a senha estiver incorreta, o resultado será o mesmo.
Não confunda a ausência de um usuário com um erro de conexão ou de consulta. Problemas no banco devem ser tratados separadamente, com logs internos e mensagens genéricas na interface.
4. Exibir mensagens diferentes para e-mail e senha incorretos
É comum encontrar sistemas que mostram mensagens como:
- E-mail não cadastrado.
- Senha incorreta.
- Usuário bloqueado.
- Conta inexistente.
Parece uma boa experiência para quem está tentando entrar, mas existe um problema de segurança: essas mensagens ajudam alguém a descobrir quais e-mails possuem cadastro na aplicação.
Esse tipo de comportamento é conhecido como enumeração de usuários.
Imagine que alguém esteja testando uma lista de e-mails. Se a aplicação informar quais endereços existem, o atacante já terá uma parte importante do trabalho pronta.
Como corrigir
Utilize uma mensagem genérica para falhas de autenticação:
$error = 'E-mail ou senha inválidos.';
A aplicação deve apresentar a mesma resposta para e-mail inexistente e senha incorreta. Também é importante evitar diferenças evidentes nos códigos HTTP e no comportamento da resposta que possam revelar a existência de uma conta.
Em sistemas mais cuidadosos, também vale considerar diferenças no tempo de processamento. Uma alternativa é executar uma verificação de hash fictício quando o usuário não existe, aproximando o custo computacional dos dois cenários.
Isso não substitui outras medidas, como limitação de tentativas de login, mas reduz informações disponíveis para quem está tentando descobrir contas válidas.
5. Não regenerar o ID da sessão depois do login
A autenticação não termina quando a senha está correta. Também precisamos cuidar da sessão que identifica o usuário nas próximas requisições.
Um erro comum é iniciar a sessão e simplesmente armazenar o ID do usuário:
session_start();
$_SESSION['user_id'] = $user['id'];
O problema é que o identificador da sessão pode ter sido definido antes da autenticação. Se ele não for renovado, a aplicação fica mais exposta a ataques de session fixation, nos quais um atacante tenta fazer a vítima utilizar um identificador de sessão conhecido por ele.
Como corrigir
Regere o ID da sessão antes de armazenar os dados de autenticação:
session_regenerate_id(true);
$_SESSION['user_id'] = $user['id'];
$_SESSION['authenticated'] = true;
A função session_regenerate_id() cria um novo identificador e mantém os dados da sessão atual. O parâmetro true solicita a exclusão dos dados da sessão antiga.
Além disso, configure os cookies da sessão com opções seguras, como HttpOnly, Secure em conexões HTTPS e SameSite.
Uma configuração básica, que deve ser aplicada antes de session_start(), pode ser:
session_set_cookie_params([
'lifetime' => 0,
'path' => '/',
'secure' => true,
'httponly' => true,
'samesite' => 'Lax',
]);
session_start();
Nesse exemplo, secure está definido como true, portanto a aplicação deve estar sendo executada em HTTPS. Em desenvolvimento local sem HTTPS, ajuste a configuração conforme o ambiente.
Também habilite session.use_strict_mode e session.use_only_cookies na configuração do PHP.
6. Esquecer de iniciar a sessão ou iniciar depois de enviar conteúdo
Já aconteceu de implementar o login corretamente, mas a aplicação não reconhecer o usuário na página seguinte? Ou aparecer o erro headers already sent?
Um dos motivos pode ser a posição de session_start().
O PHP precisa enviar cabeçalhos HTTP para iniciar ou continuar uma sessão baseada em cookies. Se a aplicação já enviou conteúdo ao navegador, esses cabeçalhos podem não ser enviados corretamente.
Exemplo problemático:
<!DOCTYPE html>
<html>
<body>
<?php
session_start();
?>
</body>
</html>
Nesse caso, o HTML já começou a ser enviado antes da inicialização da sessão.
Como corrigir
Inicie a sessão antes de qualquer saída:
<?php
session_start();
// Verificações de autenticação e processamento.
Também fique atento a espaços em branco antes de <?php, arquivos incluídos que imprimem conteúdo e mensagens de depuração esquecidas no código.
Se estiver utilizando uma estrutura organizada, mantenha a inicialização da sessão em um ponto central da aplicação. Assim, você evita repetir configurações e reduz a chance de cada página tratar a autenticação de uma maneira diferente.
7. Redirecionar depois do login e continuar executando o código
Outro erro que parece pequeno, mas pode causar problemas, é esquecer de interromper a execução depois de chamar header().
Veja:
header('Location: dashboard.php');
Essa instrução envia um cabeçalho de redirecionamento, mas não encerra a execução do PHP. O restante do arquivo ainda pode ser executado.
Dependendo do que vem depois, isso pode gerar comportamentos inesperados e até executar operações que deveriam acontecer apenas antes do redirecionamento.
Como corrigir
Utilize exit logo depois do redirecionamento:
header('Location: dashboard.php');
exit;
O mesmo vale para quando o usuário não está autenticado:
session_start();
if (!isset($_SESSION['user_id'])) {
header('Location: login.php');
exit;
}
O exit garante que o restante do script não será executado depois que a resposta de redirecionamento for enviada.
E atenção: redirecionar para a página de login não substitui a proteção da página. Toda rota ou página privada precisa verificar a autenticação no servidor antes de entregar os dados.
8. Deixar dados do usuário sem escapar na página
Depois de autenticar, é comum mostrar o nome ou o e-mail do usuário no painel:
<p>Bem-vindo, <?= $_SESSION['name'] ?></p>
O problema é que dados armazenados no banco também podem conter conteúdo malicioso. Não é porque uma informação veio do banco que ela é automaticamente confiável.
Se esses dados forem inseridos no HTML sem escape, a aplicação pode ficar vulnerável a Cross-Site Scripting (XSS).
Como corrigir
Ao inserir valores dinâmicos em um contexto HTML, utilize htmlspecialchars():
<p>
Bem-vindo,
<?= htmlspecialchars(
$_SESSION['name'],
ENT_QUOTES | ENT_SUBSTITUTE,
'UTF-8'
) ?>
</p>
Essa função converte caracteres especiais em entidades HTML, impedindo que o navegador interprete determinados conteúdos como marcação ou código.
A regra vale para nomes, e-mails, mensagens de erro e qualquer outro dado dinâmico exibido na página.
Também não devolva a senha digitada pelo usuário no atributo value do formulário quando ocorrer uma falha de autenticação. Além de ser desnecessário, isso expõe uma informação que não deve ser reapresentada no HTML.
9. Não limitar as tentativas de login
Mesmo com prepared statements e senhas armazenadas corretamente, uma aplicação ainda pode sofrer ataques de força bruta.
Nesse tipo de ataque, alguém realiza várias tentativas de autenticação até encontrar uma combinação válida de e-mail e senha.
Uma implementação que permite tentativas ilimitadas facilita esse processo.
Como corrigir
Implemente limitação de tentativas, também conhecida como rate limiting.
Você pode considerar diferentes critérios:
- Quantidade de tentativas por endereço IP.
- Quantidade de tentativas associadas a uma conta.
- Intervalo de tempo entre tentativas.
- Período de espera depois de ultrapassar o limite.
Por exemplo, uma política pode permitir cinco tentativas em quinze minutos por combinação de IP e identificador da conta, além de um limite adicional por IP.
O armazenamento dessas tentativas precisa funcionar de forma consistente entre as requisições. Em aplicações com múltiplos servidores, utilize um armazenamento compartilhado, como Redis ou banco de dados.
Evite depender exclusivamente de bloqueio permanente da conta, pois um atacante poderia utilizar isso para impedir que usuários legítimos acessassem o sistema.
O rate limiting reduz o abuso, mas não elimina ataques distribuídos. Por isso, deve fazer parte de um conjunto de controles de segurança.
10. Mostrar detalhes da exceção do PDO para o usuário
Durante o desenvolvimento, é normal encontrar erros de conexão, consultas inválidas e problemas de configuração do banco.
O problema começa quando a aplicação apresenta os detalhes dessas exceções diretamente na tela.
Veja um exemplo que não deve ir para produção:
try {
$pdo = new PDO($dsn, $username, $password);
} catch (PDOException $e) {
echo $e->getMessage();
}
Dependendo do erro, a mensagem pode revelar nomes de tabelas, estrutura do banco, caminhos internos e outras informações que não deveriam ser públicas.
Como corrigir
Registre o erro internamente e apresente uma mensagem genérica:
try {
$pdo = new PDO($dsn, $username, $password);
} catch (PDOException $e) {
error_log($e->getMessage());
http_response_code(500);
exit('Não foi possível processar sua solicitação.');
}
Em um projeto real, prefira utilizar um logger com contexto adequado e acesso restrito aos registros. Evite registrar senhas, tokens, cookies de sessão e outros dados sensíveis.
Também configure display_errors=Off em produção e mantenha log_errors=On.
Checklist: o que conferir no seu sistema de login
Antes de colocar um sistema de autenticação em produção, vale revisar alguns pontos:
- Todas as consultas que recebem dados externos utilizam prepared statements.
- As senhas são armazenadas com
password_hash(). - A autenticação utiliza
password_verify(). - O sistema trata corretamente usuários inexistentes.
- As mensagens de falha não revelam se o e-mail está cadastrado.
- O ID da sessão é regenerado depois da autenticação.
- Os cookies de sessão possuem configurações seguras.
- A sessão é iniciada antes de qualquer saída.
- Os redirecionamentos são acompanhados de
exit. - Os dados dinâmicos são escapados antes de entrar no HTML.
- Existe limitação de tentativas de autenticação.
- Exceções e erros internos não são exibidos ao usuário.
- As páginas privadas verificam a autenticação no servidor.
- As operações que alteram dados possuem proteção contra CSRF.
Conclusão
Implementar um formulário de login é relativamente simples. O trabalho de verdade está em garantir que a autenticação continue segura quando alguém começa a enviar dados inesperados, repetir tentativas, manipular sessões ou explorar erros da aplicação.
Esses cuidados não são exclusivos de sistemas grandes. Mesmo um projeto pequeno, desenvolvido com PHP puro e PDO, precisa tratar autenticação, sessões e dados dos usuários com responsabilidade.
Se você quer ver esses conceitos reunidos em uma implementação funcional, confira também nosso tutorial Sistema de Login com PHP e MySQL (PDO). Nele, desenvolvi um projeto completo com cadastro, autenticação, troca de senha, proteção de sessões e outras medidas de segurança, além de disponibilizar o código-fonte para consulta.