Pular para o conteúdo

Como armazenar senhas com segurança no PHP

Brayan Monteiro Brayan Monteiro
5 min de leitura
Imagem de destaque do artigo armazenar senhas com segurança no PHP, a imagem tem uma pagina branca centralizada escrito php com um icone de cadeado e senha acima
Compartilhar:

Guardar senhas em um banco de dados parece uma tarefa simples: recebe o valor do formulário, salva na tabela de usuários e depois compara durante o login. O problema é que, se alguém conseguir acesso ao banco, uma implementação descuidada pode entregar as credenciais de todos os usuários de bandeja.

Neste artigo, vou mostrar como armazenar senhas com segurança no PHP usando as funções nativas da linguagem e como aplicar o mesmo conceito em uma aplicação Laravel. Também vamos entender a diferença entre hash e criptografia, como funciona o salt, por que não devemos usar MD5 ou SHA-256 diretamente e como atualizar hashes sem obrigar todo mundo a trocar de senha.

Nunca armazene senhas em texto puro

A primeira regra é simples: nunca salve a senha original do usuário no banco de dados.

Imagine uma tabela users com uma coluna chamada password contendo valores como 123456, minhasenha ou qualquer outra senha escolhida pelo usuário. Se o banco for comprometido, o atacante terá acesso imediato às credenciais.

E tem outro problema: muita gente reutiliza a mesma senha em vários serviços. Uma falha no seu sistema pode acabar comprometendo contas em outros lugares também.

O correto é armazenar uma representação da senha que permita verificar se uma tentativa de login está correta, mas sem precisar guardar o valor original.

É aí que entra o hash de senha.

Entenda a diferença entre hash e criptografia

Hash e criptografia não são a mesma coisa, apesar de muita gente usar os termos como se fossem sinônimos.

A criptografia é reversível quando você possui a chave correta. Isso significa que um dado criptografado pode ser recuperado ao passar pelo processo de descriptografia.

Já o hash é uma operação de mão única. Você fornece uma informação e recebe uma representação calculada a partir dela. Não existe uma função inversa que simplesmente transforme esse resultado de volta na senha original.

Para autenticação, é justamente isso que queremos.

O fluxo funciona assim:

  1. O usuário informa uma senha no cadastro.
  2. A aplicação gera um hash usando um algoritmo próprio para armazenamento de senhas.
  3. Somente o hash é salvo no banco de dados.
  4. No login, a aplicação recebe a senha informada e verifica se ela corresponde ao hash armazenado.
  5. Se corresponder, a autenticação pode continuar.

Mesmo que alguém consiga um dump do banco de dados, não terá acesso direto às senhas originais. Isso não significa que os hashes sejam impossíveis de quebrar: um atacante ainda pode tentar descobrir as senhas por força bruta ou dicionário. A função do algoritmo é tornar essas tentativas muito mais caras.

Use algoritmos próprios para armazenar senhas

Um erro bastante comum é utilizar funções como md5(), sha1() ou até hash('sha256', $senha) para proteger senhas.

Esses algoritmos não foram projetados para esse tipo de tarefa. Eles são rápidos, e isso é ótimo para diversas operações, mas péssimo quando o assunto é armazenamento de senhas. Um atacante com acesso aos hashes pode testar uma quantidade enorme de combinações em pouco tempo.

Para esse cenário, precisamos de algoritmos de hash adaptativos, que permitem ajustar o custo computacional da verificação.

Entre as opções conhecidas estão:

  • Argon2id: opção recomendada pela OWASP para novas implementações quando disponível. Combina resistência a ataques por GPU com uso significativo de memória.
  • bcrypt: algoritmo consolidado, bastante utilizado em aplicações PHP e frameworks. Permite ajustar o custo de processamento.
  • PBKDF2: alternativa utilizada em cenários específicos, inclusive quando há requisitos de conformidade que exigem implementações validadas.

A recomendação da OWASP é priorizar Argon2id. Quando ele não estiver disponível, existem alternativas como scrypt e, em sistemas legados, bcrypt com parâmetros adequados.

Por que bcrypt ainda aparece tanto em projetos PHP?

O bcrypt continua bastante presente porque é suportado nativamente pelas funções de senha do PHP e também é utilizado por padrão no Laravel.

No PHP, podemos utilizar PASSWORD_DEFAULT, que atualmente aponta para bcrypt. Essa constante foi criada para acompanhar possíveis mudanças futuras no algoritmo padrão, sem exigir que o desenvolvedor altere toda a implementação.

Outro detalhe importante: o custo padrão do bcrypt foi aumentado de 10 para 12 no PHP 8.4. Portanto, o comportamento pode variar conforme a versão e a configuração do ambiente.

Nos exemplos deste artigo, vou utilizar PASSWORD_DEFAULT para acompanhar o padrão disponibilizado pelo PHP. Também vou mostrar como trabalhar com Argon2id quando o ambiente oferecer suporte.

Gere o hash da senha com password_hash()

O PHP já oferece uma função própria para esse trabalho: password_hash().

Ela recebe a senha original e o algoritmo escolhido, gerando um hash que pode ser armazenado no banco de dados.

Veja um exemplo simples:

<?php

$password = 'MinhaSenhaSegura123';

$hash = password_hash($password, PASSWORD_DEFAULT);

echo $hash;

O resultado será uma string semelhante a esta:

$2y$12$eImiTXuWVxfM37uY4JANjQxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Esse valor é apenas ilustrativo. Um hash real será gerado com um salt aleatório.

Observe que não precisamos criar manualmente um salt, nem armazenar o algoritmo e o custo em colunas separadas. O PHP inclui as informações necessárias no próprio resultado.

O que é salt e por que não precisamos criá-lo manualmente?

O salt é um valor aleatório utilizado durante a geração do hash. Ele faz com que duas pessoas com a mesma senha tenham hashes diferentes.

Por exemplo, imagine dois usuários cadastrados com a senha MinhaSenha123. Mesmo que a senha seja idêntica, cada chamada de password_hash() gera um resultado diferente, porque utiliza um salt próprio.

Isso dificulta ataques baseados em tabelas pré-computadas e impede que um atacante identifique facilmente usuários que compartilham a mesma senha apenas comparando os hashes.

A função password_hash() já gera esse salt automaticamente. Não invente um salt fixo no .env, não reutilize o mesmo valor para todos os usuários e não tente passar um salt manualmente. Deixe o PHP cuidar dessa parte.

Armazene o hash em uma coluna VARCHAR(255)

Um detalhe que merece atenção é o tamanho da coluna no banco de dados.

Você pode encontrar tutoriais antigos utilizando VARCHAR(60) para armazenar hashes bcrypt. Embora esse tamanho seja suficiente para o formato tradicional do bcrypt, não é uma boa escolha quando utilizamos PASSWORD_DEFAULT.

O algoritmo padrão pode mudar em versões futuras do PHP, e o tamanho do hash também pode mudar.

Por isso, a própria documentação recomenda reservar espaço para hashes maiores. Uma coluna VARCHAR(255) é uma escolha adequada.

Exemplo de estrutura:

CREATE TABLE users (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(150) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Repare que utilizei o nome password_hash em vez de simplesmente password. Não é uma exigência técnica, mas deixa mais explícito o tipo de informação armazenada nessa coluna.

Salve a senha com segurança usando PHP e PDO

Agora que já entendemos como gerar o hash, vamos aplicar isso em um cadastro utilizando PHP puro e PDO.

O ponto principal é gerar o hash antes de persistir o usuário. A senha original nunca deve chegar ao comando de inserção.

<?php

$password = $_POST['password'];

$passwordHash = password_hash(
    $password,
    PASSWORD_DEFAULT
);

$statement = $pdo->prepare(
    'INSERT INTO users (name, email, password_hash)
     VALUES (:name, :email, :password_hash)'
);

$statement->execute([
    'name' => $name,
    'email' => $email,
    'password_hash' => $passwordHash,
]);

Nesse exemplo, o banco recebe somente o hash gerado pelo PHP.

Também estamos utilizando prepared statements para evitar concatenar dados diretamente na consulta SQL. Isso é importante porque proteger a senha não elimina a necessidade de proteger as consultas ao banco.

Se você ainda não trabalha com PDO, vale conferir também nosso artigo sobre o que é PDO em PHP e como utilizar essa interface de acesso a banco de dados.

Verifique a senha com password_verify()

Na hora do login, não devemos gerar um novo hash e comparar as duas strings.

Lembra que o salt é aleatório? Isso significa que executar password_hash() novamente com a mesma senha normalmente produzirá outro resultado.

Por isso, o PHP disponibiliza a função password_verify().

Ela recebe a senha informada pelo usuário e o hash armazenado no banco, verificando se os dois correspondem.

Veja:

<?php

$password = 'MinhaSenhaSegura123';

$hash = '$2y$12$hash_armazenado_no_banco';

if (password_verify($password, $hash)) {
    echo 'Senha correta!';
} else {
    echo 'Senha incorreta!';
}

Na aplicação real, o hash deve vir do registro encontrado no banco de dados:

<?php

$statement = $pdo->prepare(
    'SELECT id, email, password_hash
     FROM users
     WHERE email = :email
     LIMIT 1'
);

$statement->execute([
    'email' => $email,
]);

$user = $statement->fetch(PDO::FETCH_ASSOC);

if (!$user || !password_verify($password, $user['password_hash'])) {
    throw new RuntimeException('Credenciais inválidas.');
}

// Continue o processo de autenticação.

A função retorna true quando a senha corresponde ao hash e false quando não corresponde. Ela também foi projetada para realizar essa verificação de forma segura contra ataques de temporização.

Perceba que não precisamos saber qual salt foi utilizado, nem separar o algoritmo do hash. Todas essas informações já estão contidas na string gerada anteriormente.

Atualize hashes antigos com password_needs_rehash()

Uma aplicação pode ficar anos em produção. Nesse período, o hardware melhora, os algoritmos evoluem e os parâmetros de segurança podem precisar de ajustes.

Imagine que seu sistema começou utilizando bcrypt com custo 10. Depois de algum tempo, você decide aumentar o custo para 12. Como atualizar os hashes de todos os usuários sem conhecer as senhas originais?

Não dá para simplesmente recalcular os hashes, porque você não possui as senhas em texto puro. E nem seria correto tentar recuperá-las.

A solução é fazer a atualização durante um login bem-sucedido.

O PHP possui a função password_needs_rehash(), que verifica se o hash armazenado corresponde ao algoritmo e às opções que a aplicação utiliza atualmente.

Veja como implementar:

<?php

if (password_verify($password, $user['password_hash'])) {
    if (password_needs_rehash(
        $user['password_hash'],
        PASSWORD_DEFAULT
    )) {
        $newHash = password_hash(
            $password,
            PASSWORD_DEFAULT
        );

        $statement = $pdo->prepare(
            'UPDATE users
             SET password_hash = :password_hash
             WHERE id = :id'
        );

        $statement->execute([
            'password_hash' => $newHash,
            'id' => $user['id'],
        ]);
    }

    // Login autorizado.
}

O fluxo é simples: primeiro verificamos a senha. Se estiver correta, verificamos se o hash precisa ser atualizado. Caso precise, geramos um novo hash com os parâmetros atuais e substituímos o valor antigo.

O usuário nem percebe que isso aconteceu.

Essa estratégia permite evoluir a segurança da aplicação gradualmente, sem exigir que todos redefinam suas senhas. A documentação do PHP apresenta justamente esse padrão de uso para password_needs_rehash().

Quando utilizar Argon2id no PHP?

Até aqui, utilizamos PASSWORD_DEFAULT, que atualmente corresponde ao bcrypt. Mas existe outra opção importante: Argon2id.

A OWASP recomenda Argon2id como primeira escolha para novas implementações, quando disponível. Uma das diferenças é que ele utiliza memória durante o processamento, tornando ataques em hardware especializado mais custosos.

O PHP permite utilizá-lo por meio da constante PASSWORD_ARGON2ID, desde que o ambiente tenha suporte ao algoritmo.

Um exemplo seguindo os parâmetros mínimos recomendados pela OWASP é:

<?php

$options = [
    'memory_cost' => 19456,
    'time_cost' => 2,
    'threads' => 1,
];

$hash = password_hash(
    $password,
    PASSWORD_ARGON2ID,
    $options
);

Os valores representam:

  • memory_cost: quantidade de memória utilizada, em KiB. Nesse exemplo, aproximadamente 19 MiB.
  • time_cost: quantidade de passagens realizadas pelo algoritmo.
  • threads: grau de paralelismo utilizado.

Esses parâmetros não devem ser copiados sem pensar no ambiente de produção. É necessário testar o consumo de CPU e memória, principalmente em aplicações com muitos logins simultâneos.

Também vale verificar se a instalação do PHP oferece suporte ao Argon2id antes de escolher esse algoritmo. A documentação oficial explica as opções disponíveis e as dependências de compilação.

Se o ambiente não oferecer suporte, PASSWORD_DEFAULT continua sendo uma alternativa prática e segura, desde que utilizado corretamente.

Atenção: bcrypt possui um limite de entrada de 72 bytes. Isso não significa necessariamente 72 caracteres, especialmente quando a senha contém caracteres acentuados ou emojis. O PHP trunca entradas maiores quando utiliza PASSWORD_BCRYPT. Se você permitir senhas longas, considere esse limite ao escolher o algoritmo e validar os dados.

Como armazenar senhas com segurança no Laravel

Se você trabalha com Laravel, não precisa implementar manualmente todo esse fluxo. O framework já oferece uma camada própria para hashing de senhas.

A facade Hash disponibiliza métodos como make(), check() e needsRehash(), que encapsulam as funções de hash utilizadas pelo PHP.

Gere o hash com Hash::make()

Para armazenar uma senha, podemos utilizar:

use Illuminate\Support\Facades\Hash;

$hash = Hash::make($password);

O método gera o hash utilizando o driver configurado na aplicação. Por padrão, o Laravel utiliza bcrypt, mas também oferece suporte a Argon e Argon2id.

Uma alternativa interessante é utilizar o cast hashed diretamente no model:

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    protected $hidden = [
        'password',
        'remember_token',
    ];

    protected function casts(): array
    {
        return [
            'password' => 'hashed',
        ];
    }
}

Com esse cast, o Eloquent aplica o hashing quando o valor é atribuído ao atributo password.

Assim, podemos criar um usuário sem chamar Hash::make() manualmente:

$user = User::create([
    'name' => $name,
    'email' => $email,
    'password' => $password,
]);

Outra possibilidade é gerar o hash explicitamente com Hash::make() e não utilizar o cast hashed para esse atributo. O importante é escolher uma abordagem clara e evitar aplicar hashing duas vezes sem necessidade.

O atributo $hidden também é importante: ele impede que a senha armazenada seja incluída automaticamente quando o model é convertido para array ou JSON.

Autentique utilizando Auth::attempt()

No Laravel, não precisamos buscar o usuário e chamar Hash::check() manualmente em um fluxo convencional de autenticação.

O próprio framework faz isso por meio de Auth::attempt():

use Illuminate\Support\Facades\Auth;

if (Auth::attempt([
    'email' => $email,
    'password' => $password,
])) {
    request()->session()->regenerate();

    return redirect()->intended('/dashboard');
}

Um detalhe importante: não gere o hash da senha recebida antes de chamar Auth::attempt(). O Laravel espera receber a senha original nesse array e compara o valor com o hash armazenado no usuário.

Também regeneramos o ID da sessão após o login, uma medida importante para reduzir o risco de session fixation.

Atualize a senha quando necessário

O Laravel também oferece suporte à verificação de hashes que precisam ser atualizados.

Podemos utilizar:

if (Hash::needsRehash($user->password)) {
    $user->update([
        'password' => Hash::make($password),
    ]);
}

Em fluxos convencionais de autenticação com Auth::attempt(), o Laravel também oferece rehash automático quando a configuração exige uma atualização. Isso evita que cada aplicação precise implementar essa lógica manualmente.

A documentação oficial explica como configurar o hashing, verificar senhas e atualizar hashes automaticamente:

Como aplico isso nos meus projetos

Para não ficar apenas na teoria, vou mostrar duas implementações reais que utilizei como referência.

No projeto PHP puro com Twig, disponível publicamente no GitHub, implementei o armazenamento de senhas em um serviço separado. O UserService gera o hash antes de persistir os dados e remove a senha original do array utilizado na operação:

$data['password_hash'] = password_hash(
    $data['password'],
    PASSWORD_DEFAULT
);

unset($data['password']);

O projeto também utiliza password_verify() durante a autenticação e password_needs_rehash() para atualizar hashes antigos quando necessário.

Outro detalhe que implementei nesse fluxo é a utilização de um hash dummy quando o e-mail informado não existe. Dessa forma, a aplicação também executa password_verify() em uma situação de usuário inexistente, reduzindo a diferença de tempo de resposta que poderia ajudar a identificar contas cadastradas.

Você pode conferir a implementação completa no repositório: template-php-postgresql-twig — GitHub

Já em uma aplicação Laravel, utilizei a facade Hash para gerar os hashes, o cast hashed no model e o atributo $hidden para evitar que a informação seja exposta em respostas JSON.

Na autenticação, o Auth::attempt() faz a verificação da senha, enquanto o framework cuida do fluxo de login. Também utilizo limitação de tentativas para dificultar ataques automatizados.

São abordagens diferentes na organização do código, mas a ideia central é a mesma: a senha original só é utilizada durante o processamento necessário e o banco guarda apenas o hash.

Cuidados adicionais para proteger senhas

Utilizar password_hash() corretamente resolve uma parte importante do problema, mas não significa que o sistema de autenticação esteja automaticamente seguro.

Existem outros cuidados que precisam fazer parte da implementação:

  • Não registre senhas em logs: evite registrar o conteúdo de requisições de autenticação, principalmente quando elas incluem credenciais.
  • Não devolva hashes em APIs: mesmo que não sejam senhas originais, hashes não devem ser expostos desnecessariamente.
  • Limite tentativas de login: utilize rate limiting para dificultar ataques de força bruta.
  • Utilize HTTPS: proteja a comunicação entre o navegador e o servidor para evitar que credenciais sejam interceptadas durante o envio.
  • Implemente proteção CSRF: principalmente em aplicações que utilizam sessões e formulários tradicionais.
  • Utilize mensagens genéricas: não informe se o e-mail não existe ou se a senha está incorreta. Isso reduz a possibilidade de enumeração de usuários.
  • Proteja as sessões: regenere o identificador após autenticação e configure corretamente os cookies de sessão.

Se quiser aprofundar essa última parte, temos também um artigo sobre como proteger sessões PHP contra roubo e fixation.

E, se estiver construindo um sistema de autenticação do zero, vale conferir nosso guia sobre erros comuns em login PHP com PDO e como corrigi-los.

Conclusão

Armazenar senhas com segurança não precisa ser complicado. O PHP já oferece funções próprias para gerar, verificar e atualizar hashes, enquanto frameworks como Laravel deixam esse processo ainda mais simples.

O mais importante é entender que não estamos tentando esconder a senha dentro do banco, mas sim armazenar uma representação que permita validar a autenticação sem precisar recuperar o valor original.

Se você estiver começando um projeto novo, considere Argon2id quando o ambiente oferecer suporte e os parâmetros forem compatíveis com sua infraestrutura. Se utilizar bcrypt, ajuste o custo de acordo com a capacidade do servidor e fique atento ao limite de 72 bytes.

E, principalmente, não invente soluções próprias para algo que a linguagem já resolve muito bem. Use as funções nativas, mantenha os parâmetros atualizados e trate a autenticação como uma parte importante da segurança da aplicação.

Referências

Palavras-chave:

#armazenar senhas com segurança no PHP #senhas no php #senhas com php

Sobre o autor

Brayan Monteiro

Brayan Monteiro

Bacharel em Sistemas de Informação pela Faculdade Maurício de Nassau e desenvolvedor de software. Produzo conteúdo e gerencio blogs. Sou especialista em desenvolvimento web e SEO de sites.

Continue lendo

Postagens relacionadas

Discussão

Comentários

Nenhum comentário ainda. Seja o primeiro a comentar.