Web e Desenvolvimento

PHP Hashing de Senhas: Argon2id, bcrypt e Migração Segura

PHP Password Hashing: Argon2id, bcrypt and Secure Migration

Aprenda a hashear senhas de forma segura em PHP usando Argon2id e bcrypt, escolha parâmetros seguros, verifique credenciais e migre hashes existentes sem forçar redefinições de senha.

Hashing de Senhas em PHP: Argon2id, bcrypt e Migração Segura

O armazenamento de senhas é uma das decisões de segurança mais importantes em um aplicativo web. Uma violação de banco de dados não deve revelar imediatamente as credenciais dos usuários, mas o hashing de senhas fraco pode tornar hashes roubados baratos de atacar.

O PHP inclui funções integradas para fazer hash, verificar e atualizar senhas. O desafio é selecionar o algoritmo certo, configurá-lo para sua infraestrutura e migrar contas existentes sem interromper a autenticação.

Para novos aplicativos, o Argon2id é geralmente a escolha preferida quando seu build do PHP suporta. O bcrypt continua sendo uma opção prática de compatibilidade. Ambos devem ser usados através da API de senhas do PHP, em vez de criptografia caseira.

Este guia aborda implementação, seleção de parâmetros, migração de legado e erros comuns.

Por que o SHA-256 não é adequado para armazenamento de senhas

O SHA-256 foi projetado para ser rápido. Isso o torna útil para verificações de integridade, mas inadequado por si só para armazenamento de senhas: um invasor com hashes roubados pode testar muitas suposições de senha rapidamente.

Algoritmos dedicados de hashing de senhas consomem deliberadamente mais recursos. O Argon2id pode exigir memória substancial, bem como tempo de processamento, tornando a tentativa em larga escala mais cara.

Um sistema de armazenamento seguro precisa de um salt aleatório único, um fator de trabalho configurável e uma maneira de aumentar o fator de trabalho à medida que o hardware melhora. O password_hash() do PHP gera e armazena as informações necessárias de salt automaticamente.

A OWASP Password Storage Cheat Sheet recomenda hashing de senhas adaptativo em vez de funções de hash generalistas rápidas.

Argon2id vs bcrypt: qual escolher?

Recurso Argon2id bcrypt
Principal defesa Custo de memória e computação Custo de computação
Difícil de memória Sim Não
Parâmetros configuráveis Memória, iterações, paralelismo Fator de custo
Limite de entrada de senha Sem limite de 72 bytes no estilo bcrypt 72 bytes
Disponibilidade no PHP Depende do build Amplamente disponível
Melhor adequado Preferido para novo armazenamento de senhas Compatibilidade e sistemas legados

O Argon2id foi projetado para resistir a ataques que se beneficiam de hardware massivamente paralelo. O bcrypt ainda é um algoritmo legítimo de hashing de senhas adaptativo, mas seu limite de entrada requer cuidado: ele considera no máximo os primeiros 72 bytes, não caracteres.

Não assuma que o PASSWORD_DEFAULT seleciona Argon2id. A documentação do PHP password_hash atualmente documenta o bcrypt como seu algoritmo padrão. O PHP 8.4 aumentou o custo padrão do bcrypt de 10 para 12, ilustrando por que confiar em parâmetros implícitos pode alterar o desempenho do aplicativo após atualizações.

Etapa 1: Verificar suporte ao Argon2id

O Argon2id não está necessariamente disponível em todo ambiente de hospedagem. Verifique o tempo de execução antes de selecioná-lo:

<?php
declare(strict_types=1);

if(in_array('argon2id', password_algos(), true)) {
    echo 'Argon2id is available';
} else {
    echo 'Argon2id is not available';
}

A disponibilidade depende de como o PHP foi construído. Não suponha que a atualização da versão do PHP habilite automaticamente o Argon2id.

Etapa 2: Fazer hash de uma senha com Argon2id

O OWASP documenta várias configurações de linha de base aceitáveis. Uma usa 19 MiB de memória, duas iterações e paralelismo de um. O PHP expressa o memory_cost em KiB, então 19 MiB são 19 * 1024 KiB.

<?php
declare(strict_types=1);

$options = [
    'memory_cost' => 19 * 1024,
    'time_cost' => 2
];

$password = 'example-user-password';

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

A opção de paralelismo threads é suportada com alguns backends do Argon2, incluindo libargon2, mas não em todo build do PHP. Se suportado, um valor de um corresponde a esta linha de base; omiti-lo é mais portátil. Faça benchmark da sua configuração real.

O hash codificado resultante inclui o identificador do algoritmo, parâmetros e salt. Não há necessidade de salvar esses valores em colunas separadas do banco de dados. Uma coluna VARCHAR(255) é um ponto de partida razoável para hashes de senhas modernos, desde que armazene o valor codificado completo.

Estes são parâmetros de linha de base, não uma configuração de produção universal. Teste latência e uso de memória sob tráfego realista de autenticação concorrente.

Etapa 3: Verificar credenciais corretamente

Illustration of the article's main concept

Como cada hash de senha usa um salt aleatório, gerar um novo hash e comparar strings não funcionará. Use o password_verify():

<?php
declare(strict_types=1);

$submittedPassword = (string)($_POST['password'] ?? '');
$storedHash = (string)$user['password_hash'];

if(!password_verify($submittedPassword, $storedHash)) {
    // Reject authentication without disclosing account existence.
    return;
}

// The password is valid. Continue with secure session handling.

A documentação do PHP especifica que o password_verify() é seguro contra ataques de tempo. Ele lê o algoritmo e os parâmetros de trabalho do hash armazenado.

A verificação de senha não substitui limitação de login, sessões seguras, HTTPS, tratamento adequado de erros ou autenticação multifatorial.

Etapa 4: Atualizar hashes de senha existentes durante o login

O password_needs_rehash() detecta quando um hash armazenado usa um algoritmo ou parâmetros desatualizados. Isso permite migração gradual sem forçar todos os usuários ativos a redefinir suas senhas.

<?php
declare(strict_types=1);

$options = [
    'memory_cost' => 19 * 1024,
    'time_cost' => 2
];

if(password_verify($submittedPassword, $storedHash)) {
    if(password_needs_rehash(
        $storedHash,
        PASSWORD_ARGON2ID,
        $options
    )) {
        $newHash = password_hash(
            $submittedPassword,
            PASSWORD_ARGON2ID,
            $options
        );

        // Persist with a prepared statement.
        // Prefer a conditional UPDATE to avoid overwriting
        // a newer hash from a concurrent request.
    }

    // Finish authentication and rotate the session identifier.
}

Faça rehash apenas após verificar com sucesso a senha enviada. Uma atualização condicional pode garantir que o hash armazenado ainda corresponda ao valor que foi verificado. Por exemplo, atualize o hash da senha apenas onde o ID do usuário e o hash antigo coincidam.

Consulte PHP password_needs_rehash() para detalhes da API.

Etapa 5: Migrar hashes legados MD5 ou SHA-1

Aplicativos mais antigos podem conter formatos de senha MD5, SHA-1 ou personalizados. Esses hashes nem sempre podem ser verificados com o password_verify().

Uma migração deve seguir uma sequência controlada:

  1. Identifique o formato legado usando metadados confiáveis ou um formato claro e documentado.
  2. Verifique a senha enviada usando o esquema legado original apenas para contas que ainda o exigem.
  3. Após a verificação bem-sucedida, crie imediatamente um hash moderno usando o password_hash().
  4. Substitua o hash legado armazenado usando uma atualização segura do banco de dados.
  5. Desative a verificação legado quando a migração estiver concluída.

Não adivinhe o algoritmo apenas pelo comprimento do hash quando vários formatos forem possíveis. Não tente descriptografar hashes de senha: hashing não é criptografia.

Para contas que nunca fazem login, considere uma política de redefinição de senha em vez de reter hashes fracos indefinidamente. Não introduza um caminho de fallback inseguro que aceite hashes fracos para novos usuários registrados.

Etapa 6: Fazer benchmark de hashing em sua infraestrutura

Os parâmetros de custo corretos dependem do seu hardware, volume de login concorrente e requisitos de latência.

<?php
declare(strict_types=1);

$options = [
    'memory_cost' => 19 * 1024,
    'time_cost' => 2
];

$start = hrtime(true);

$hash = password_hash(
    'benchmark-password',
    PASSWORD_ARGON2ID,
    $options
);

$milliseconds = (hrtime(true) - $start) / 1_000_000;

echo round($milliseconds, 2) . ' ms';
Technical workflow illustration

Execute isso apenas em um ambiente controlado, não como um endpoint web público. Meça também a verificação e repita sob carga representativa. Uma configuração que parece rápida isoladamente pode esgotar a RAM quando muitas solicitações chegam juntas.

O OWASP recomenda equilibrar segurança com capacidade operacional e geralmente manter operações individuais de hashing abaixo de um segundo.

Erros comuns de hashing de senhas

Adicionar um salt fixo manualmente. O PHP já gera salts seguros para sua API de senha. Um salt fixo remove uma proteção importante.

Usando MD5, SHA-1 ou SHA-256 crus. Esses algoritmos são muito rápidos para armazenamento de senhas por si próprios.

Ignorar o limite de 72 bytes do bcrypt. Caracteres UTF-8 multibyte podem atingir esse limite antes do que os usuários esperam.

Escolher configurações de custo extremas. Demandas excessivas de memória ou CPU podem criar um risco de negação de serviço nos endpoints de autenticação.

Registrando senhas enviadas. Evite expor credenciais por meio de logs de depuração, sistemas de monitoramento ou relatórios de erro.

Assumindo que o hashing de senhas resolve a segurança da autenticação. Limitação de taxa, resposta a violações, segurança de sessão e autenticação multifatorial ainda são importantes.

Você deve usar um pepper?

Um pepper é um segredo compartilhado adicional mantido fora do banco de dados de senhas. Diferente de um salt, ele não é armazenado junto a cada hash.

Um pepper adequadamente projetado pode fornecer defesa em profundidade se um invasor roubar apenas o banco de dados. Mas o uso de pepper introduz complexidade de gerenciamento e rotação de chaves: perder ou rotacionar um pepper pode exigir redefinições de senha.

Não improvise concatenando um segredo hardcoded a cada senha. Siga uma estratégia documentada, armazene segredos separadamente e planeje a rotação. O OWASP discute abordagens de pepper pré-hash e pós-hash.

Uma política prática de hashing de senhas

Para um novo aplicativo PHP, prefira Argon2id quando disponível, comece com uma configuração alinhada ao OWASP, faça benchmark e armazene o hash codificado completo. Onde o Argon2id não estiver disponível, o bcrypt através da API de senhas do PHP é uma alternativa prática se seu custo e limite de entrada forem compreendidos.

Para um aplicativo existente, continue verificando hashes legados suportados enquanto os atualiza após a autenticação bem-sucedida. Evite migrações disruptivas quando a senha original não estiver disponível.

Projete para atualizações desde o início. O hardware e as recomendações mudam; seu sistema de autenticação deve ser capaz de adotar parâmetros e algoritmos melhores sem alterar a senha de todos os usuários de uma vez.

Perguntas frequentes

O Argon2id é melhor que o bcrypt?

O Argon2id oferece dureza de memória configurável e é a escolha preferida do OWASP para novas implementações de armazenamento de senhas.

O PHP usa Argon2id por padrão?

Não. O PASSWORD_DEFAULT do PHP atualmente seleciona bcrypt. Use o PASSWORD_ARGON2ID explicitamente quando suportado.

Posso migrar hashes bcrypt sem redefinições de senha?

Sim. Verifique o hash existente e, em seguida, faça rehash da senha enviada após um login bem-sucedido.

Devo armazenar o salt separadamente?

Não. A API de hashing de senhas do PHP gera o salt e armazena as informações necessárias no hash codificado.

O SHA-256 é seguro para senhas?

Não por si só. Use um algoritmo dedicado de hashing de senhas adaptativo em vez do SHA-256 bruto.

Referências oficiais