De vez em quando, ouço o conselho "Use o bcrypt para armazenar senhas no PHP, regras do bcrypt".

Mas o que é isso bcrypt? O PHP não oferece essas funções, a Wikipedia fala sobre um utilitário de criptografia de arquivos e as pesquisas na Web apenas revelam algumas implementações do Blowfish em diferentes idiomas. Agora, o Blowfish também está disponível em PHP mcrypt, mas como isso ajuda no armazenamento de senhas? Blowfish é uma cifra de uso geral, funciona de duas maneiras. Se puder ser criptografado, poderá ser descriptografado. As senhas precisam de uma função de hash unidirecional.

Qual a explicação?

bcrypté um algoritmo de hash escalável com hardware (através de um número configurável de rodadas). Sua lentidão e várias rodadas garantem que um invasor precise implantar fundos e hardware maciços para poder decifrar suas senhas. Adicione a isso os sais por senha ( bcryptEXIGE sais) e você pode ter certeza de que um ataque é praticamente inviável sem uma quantidade absurda de fundos ou hardware.

bcryptusa o algoritmo Eksblowfish para hash senhas. Embora a fase de criptografia do Eksblowfish e do Blowfish seja exatamente a mesma, a fase de programação principal do Eksblowfish garante que qualquer estado subsequente dependa do sal e da chave (senha do usuário), e nenhum estado pode ser pré-computado sem o conhecimento de ambos. Devido a essa diferença fundamental, bcrypté um algoritmo de hash unidirecional. Você não pode recuperar a senha em texto simples sem conhecer o salt, rounds e key (senha). [ Fonte ]

Como usar o bcrypt:

Usando PHP> = 5.5-DEV

As funções de hash de senha agora foram construídas diretamente no PHP> = 5.5 . Agora você pode usar password_hash()para criar um bcrypthash de qualquer senha:

<?php
// Usage 1:
echo password_hash('rasmuslerdorf', PASSWORD_DEFAULT)."\n";
// $2y$10$xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// For example:
// $2y$10$.vGA1O9wmRjrwAVXD98HNOgsNpDczlqm3Jq7KnEd1rVAGv3Fykk1a

// Usage 2:
$options = [
  'cost' => 11
];
echo password_hash('rasmuslerdorf', PASSWORD_BCRYPT, $options)."\n";
// $2y$11$6DP.V0nO7YI3iSki4qog6OQI5eiO6Jnjsqg7vdnb.JgGIsxniOn4C

Para verificar uma senha fornecida pelo usuário com relação a um hash existente, você pode usar o seguinte password_verify():

<?php
// See the password_hash() example to see where this came from.
$hash = '$2y$07$BCryptRequires22Chrcte/VlQH0piJtjXl.0t1XkA8pw9dMXTpOq';

if (password_verify('rasmuslerdorf', $hash)) {
    echo 'Password is valid!';
} else {
    echo 'Invalid password.';
}

Usando PHP> = 5.3.7, <5.5-DEV (também RedHat PHP> = 5.3.3)

Existe uma biblioteca de compatibilidade no GitHub criada com base no código fonte das funções acima, originalmente escritas em C, que fornece a mesma funcionalidade. Depois que a biblioteca de compatibilidade é instalada, o uso é o mesmo que acima (menos a notação abreviada de matriz, se você ainda estiver na ramificação 5.3.x).

Usando PHP <5.3.7 (DEPRECATED)

Você pode usar a crypt()função para gerar hashes bcrypt de strings de entrada. Essa classe pode gerar sais automaticamente e verificar os hashes existentes em uma entrada. Se você estiver usando uma versão do PHP maior ou igual a 5.3.7, é altamente recomendável usar a função interna ou a biblioteca compat . Essa alternativa é fornecida apenas para fins históricos.

class Bcrypt{
  private $rounds;

  public function __construct($rounds = 12) {
    if (CRYPT_BLOWFISH != 1) {
      throw new Exception("bcrypt not supported in this installation. See http://php.net/crypt");
    }

    $this->rounds = $rounds;
  }

  public function hash($input){
    $hash = crypt($input, $this->getSalt());

    if (strlen($hash) > 13)
      return $hash;

    return false;
  }

  public function verify($input, $existingHash){
    $hash = crypt($input, $existingHash);

    return $hash === $existingHash;
  }

  private function getSalt(){
    $salt = sprintf('$2a$%02d$', $this->rounds);

    $bytes = $this->getRandomBytes(16);

    $salt .= $this->encodeBytes($bytes);

    return $salt;
  }

  private $randomState;
  private function getRandomBytes($count){
    $bytes = '';

    if (function_exists('openssl_random_pseudo_bytes') &&
        (strtoupper(substr(PHP_OS, 0, 3)) !== 'WIN')) { // OpenSSL is slow on Windows
      $bytes = openssl_random_pseudo_bytes($count);
    }

    if ($bytes === '' && is_readable('/dev/urandom') &&
       ($hRand = @fopen('/dev/urandom', 'rb')) !== FALSE) {
      $bytes = fread($hRand, $count);
      fclose($hRand);
    }

    if (strlen($bytes) < $count) {
      $bytes = '';

      if ($this->randomState === null) {
        $this->randomState = microtime();
        if (function_exists('getmypid')) {
          $this->randomState .= getmypid();
        }
      }

      for ($i = 0; $i < $count; $i += 16) {
        $this->randomState = md5(microtime() . $this->randomState);

        if (PHP_VERSION >= '5') {
          $bytes .= md5($this->randomState, true);
        } else {
          $bytes .= pack('H*', md5($this->randomState));
        }
      }

      $bytes = substr($bytes, 0, $count);
    }

    return $bytes;
  }

  private function encodeBytes($input){
    // The following is code from the PHP Password Hashing Framework
    $itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

    $output = '';
    $i = 0;
    do {
      $c1 = ord($input[$i++]);
      $output .= $itoa64[$c1 >> 2];
      $c1 = ($c1 & 0x03) << 4;
      if ($i >= 16) {
        $output .= $itoa64[$c1];
        break;
      }

      $c2 = ord($input[$i++]);
      $c1 |= $c2 >> 4;
      $output .= $itoa64[$c1];
      $c1 = ($c2 & 0x0f) << 2;

      $c2 = ord($input[$i++]);
      $c1 |= $c2 >> 6;
      $output .= $itoa64[$c1];
      $output .= $itoa64[$c2 & 0x3f];
    } while (true);

    return $output;
  }
}

Você pode usar este código assim:

$bcrypt = new Bcrypt(15);

$hash = $bcrypt->hash('password');
$isGood = $bcrypt->verify('password', $hash);

Como alternativa, você também pode usar o Portable PHP Hashing Framework .

Então, você quer usar o bcrypt? Impressionante! No entanto, como outras áreas da criptografia, você não deve fazer isso sozinho. Se você precisa se preocupar com algo como gerenciar chaves, armazenar sais ou gerar números aleatórios, está fazendo algo errado.

O motivo é simples: é tão trivialmente fácil estragar o bcrypt . De fato, se você examinar quase todos os trechos de código desta página, notará que está violando pelo menos um desses problemas comuns.

Enfrente, a criptografia é difícil.

Deixe para os especialistas. Deixe para as pessoas cujo trabalho é manter essas bibliotecas. Se você precisa tomar uma decisão, está fazendo algo errado.

Em vez disso, basta usar uma biblioteca. Existem vários, dependendo dos seus requisitos.

Bibliotecas

Aqui está um detalhamento de algumas das APIs mais comuns.

API do PHP 5.5 - (disponível para 5.3.7 ou superior)

A partir do PHP 5.5, uma nova API para hash de senhas está sendo introduzida. Também há uma biblioteca de compatibilidade de calços mantida (por mim) para 5.3.7+. Isso tem o benefício de ser uma implementação revisada por pares e simples de usar.

function register($username, $password) {
    $hash = password_hash($password, PASSWORD_BCRYPT);
    save($username, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    if (password_verify($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Realmente, o objetivo é ser extremamente simples.

Recursos:

• Documentação: no PHP.net
• Biblioteca de compatibilidade: no GitHub
• RFC do PHP: no wiki.php.net

Zend \ Crypt \ Password \ Bcrypt (5.3.2 ou superior)

Essa é outra API semelhante à do PHP 5.5 e tem um objetivo semelhante.

function register($username, $password) {
    $bcrypt = new Zend\Crypt\Password\Bcrypt();
    $hash = $bcrypt->create($password);
    save($user, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    $bcrypt = new Zend\Crypt\Password\Bcrypt();
    if ($bcrypt->verify($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Recursos:

• Documentação: no Zend
• Postagem no blog: hash de senha com o Zend Crypt

PasswordLib

Essa é uma abordagem ligeiramente diferente para o hash de senha. Em vez de simplesmente dar suporte ao bcrypt, o PasswordLib suporta um grande número de algoritmos de hash. É principalmente útil em contextos em que você precisa oferecer suporte à compatibilidade com sistemas legados e diferentes que podem estar fora de seu controle. Ele suporta um grande número de algoritmos de hash. E é suportado 5.3.2+

function register($username, $password) {
    $lib = new PasswordLib\PasswordLib();
    $hash = $lib->createPasswordHash($password, '$2y$', array('cost' => 12));
    save($user, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    $lib = new PasswordLib\PasswordLib();
    if ($lib->verifyPasswordHash($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Referências:

• Código-fonte / Documentação: GitHub

PHPASS

Esta é uma camada que suporta bcrypt, mas também suporta um algoritmo bastante forte que é útil se você não tiver acesso ao PHP> = 5.3.2 ... Na verdade, ele suporta o PHP 3.0+ (embora não com o bcrypt).

function register($username, $password) {
    $phpass = new PasswordHash(12, false);
    $hash = $phpass->HashPassword($password);
    save($user, $hash);
}

function login($username, $password) {
    $hash = loadHashByUsername($username);
    $phpass = new PasswordHash(12, false);
    if ($phpass->CheckPassword($password, $hash)) {
        //login
    } else {
        // failure
    }
}

Recursos

• Código: cvsweb
• Site do projeto: no OpenWall
• Uma revisão do algoritmo <5.3.0: no StackOverflow

Nota: Não use as alternativas PHPASS que não estão hospedadas no openwall, pois são projetos diferentes !!!

Sobre o BCrypt

Se você notar, cada uma dessas bibliotecas retorna uma única sequência. É por isso que o BCrypt funciona internamente. E há uma tonelada de respostas sobre isso. Aqui está uma seleção que eu escrevi, que não vou copiar / colar aqui, mas link para:

• Diferença fundamental entre algoritmos de hash e criptografia - explicando a terminologia e algumas informações básicas sobre eles.
• Sobre a reversão de hashes sem tabelas de arco-íris - Basicamente, por que devemos usar o bcrypt em primeiro lugar ...
• Armazenando hashes bcrypt - basicamente por que o salt e o algoritmo estão incluídos no resultado do hash.
• Como atualizar o custo dos hashes bcrypt - basicamente como escolher e depois manter o custo do hash bcrypt.
• Como fazer hash de senhas longas com o bcrypt - explicando o limite de 72 caracteres da senha do bcrypt.
• Como o bcrypt usa sais
• Práticas recomendadas para salgar e digitar senhas - basicamente, não use uma "pimenta"
• Migrando md5senhas antigas para bcrypt

Embrulhar

Existem muitas opções diferentes. A escolha que você escolher depende de você. No entanto, gostaria ALTAMENTE recomendamos que você use uma das bibliotecas acima para lidar com isso para você.

Novamente, se você estiver usando crypt()diretamente, provavelmente está fazendo algo errado. Se o seu código estiver usando hash()(ou md5()ousha1() ) diretamente, você está quase definitivamente fazendo algo errado.

Basta usar uma biblioteca ...

Você encontrará muitas informações em Suficiente com as tabelas Rainbow: o que você precisa saber sobre esquemas de senha segura ou estrutura portátil de hash de senha PHP .

O objetivo é hash a senha com algo lento, para que alguém que obtenha seu banco de dados de senha morra tentando forçá-la (um atraso de 10 ms para verificar uma senha não é nada para você, muito para alguém que tenta forçá-la). O Bcrypt é lento e pode ser usado com um parâmetro para escolher o quão lento é.

Você pode criar um hash unidirecional com o bcrypt usando a crypt()função PHP e passando um sal Blowfish apropriado. A mais importante de toda a equação é que A) o algoritmo não foi comprometido e B) você salta corretamente cada senha . Não use sal de aplicação geral; que abre todo o aplicativo para atacar a partir de um único conjunto de tabelas Rainbow.

PHP - Função Crypt

Edit: 15.01.2013 - Se o seu servidor oferecer suporte, use a solução de martinstoeckli .

Todo mundo quer tornar isso mais complicado do que é. A função crypt () faz a maior parte do trabalho.

function blowfishCrypt($password,$cost)
{
    $chars='./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    $salt=sprintf('$2y$%02d$',$cost);
//For PHP < PHP 5.3.7 use this instead
//    $salt=sprintf('$2a$%02d$',$cost);
    //Create a 22 character salt -edit- 2013.01.15 - replaced rand with mt_rand
    mt_srand();
    for($i=0;$i<22;$i++) $salt.=$chars[mt_rand(0,63)];
    return crypt($password,$salt);
}

Exemplo:

$hash=blowfishCrypt('password',10); //This creates the hash
$hash=blowfishCrypt('password',12); //This creates a more secure hash
if(crypt('password',$hash)==$hash){ /*ok*/ } //This checks a password

Sei que deve ser óbvio, mas não use 'senha' como sua senha.

A versão 5.5 do PHP terá suporte embutido para BCrypt, as funções password_hash()e password_verify(). Na verdade, são apenas invólucros em torno da função crypt()e facilitarão o uso correto. Ele cuida da geração de um sal aleatório seguro e fornece bons valores padrão.

A maneira mais fácil de usar essas funções será:

$hashToStoreInDb = password_hash($password, PASSWORD_BCRYPT);
$isPasswordCorrect = password_verify($password, $existingHashFromDb);

Esse código hash a senha com BCrypt (algoritmo 2y), gera um sal aleatório a partir da fonte aleatória do SO e usa o parâmetro de custo padrão (no momento é 10). A segunda linha verifica se o usuário digitou a senha corresponde a um valor de hash já armazenado.

Se você deseja alterar o parâmetro cost, pode fazê-lo assim, aumentando o parâmetro cost em 1, dobra o tempo necessário para calcular o valor do hash:

$hash = password_hash($password, PASSWORD_BCRYPT, array("cost" => 11));

Ao contrário do "cost"parâmetro, é melhor omitir o "salt"parâmetro, porque a função já faz o possível para criar um sal criptograficamente seguro.

Para o PHP versão 5.3.7 e posterior, existe um pacote de compatibilidade , do mesmo autor que fez a password_hash()função. Para versões do PHP anteriores 5.3.7 não há suporte para crypt()com 2yo algoritmo bcrypt segura unicode. Pode-se substituí-lo por 2a, que é a melhor alternativa para versões anteriores do PHP.

Pensamento atual: os hashes devem ser os mais lentos disponíveis, não os mais rápidos possíveis. Isso suprime os ataques da tabela arco-íris .

Também relacionado, mas por precaução: um invasor nunca deve ter acesso ilimitado à sua tela de login. Para evitar isso: Configure uma tabela de rastreamento de endereço IP que registre cada ocorrência junto com o URI. Se mais de 5 tentativas de login vierem do mesmo endereço IP em um período de cinco minutos, bloqueie com explicação. Uma abordagem secundária é ter um esquema de senha de duas camadas, como os bancos. A colocação de um bloqueio para falhas na segunda passagem aumenta a segurança.

Resumo: diminua a velocidade do invasor usando funções hash demoradas. Além disso, bloqueie muitos acessos ao seu login e adicione uma segunda camada de senha.

Aqui está uma resposta atualizada para essa pergunta antiga!

A maneira correta de hash senhas no PHP desde 5.5 é com password_hash(), e a maneira correta de verificá-las é com password_verify(), e isso ainda é verdade no PHP 8.0. Essas funções usam hashes bcrypt por padrão, mas outros algoritmos mais fortes foram adicionados. Você pode alterar o fator de trabalho (efetivamente quão forte é a criptografia) através dos password_hashparâmetros.

No entanto, embora ainda seja suficientemente forte, o bcrypt não é mais considerado o estado da arte ; chegou um conjunto melhor de algoritmos de hash de senha chamado Argon2 , com as variantes Argon2i, Argon2d e Argon2id. A diferença entre eles (como descrito aqui ):

O Argon2 tem uma variante principal: Argon2id e duas variantes suplementares: Argon2d e Argon2i. O Argon2d usa acesso à memória dependente de dados, o que o torna adequado para aplicações de criptomoedas e prova de trabalho sem ameaças de ataques de sincronização de canal lateral. O Argon2i usa acesso à memória independente de dados, o que é preferido para hash de senha e derivação de chave baseada em senha. O Argon2id funciona como Argon2i na primeira metade da primeira iteração sobre a memória e como Argon2d no restante, fornecendo proteção contra ataques de canal lateral e economia de custos de força bruta devido a trocas de memória de tempo.

O suporte ao Argon2i foi adicionado no PHP 7.2, e você solicita assim:

$hash = password_hash('mypassword', PASSWORD_ARGON2I);

e suporte ao Argon2id foi adicionado no PHP 7.3:

$hash = password_hash('mypassword', PASSWORD_ARGON2ID);

Nenhuma alteração é necessária para verificar as senhas, pois a sequência de hash resultante contém informações sobre quais algoritmos, sal e fatores de trabalho foram usados ​​quando foram criados.

De maneira bem separada (e um tanto redundante), o libsodium (adicionado no PHP 7.2) também fornece hash do Argon2 através das funções sodium_crypto_pwhash_str ()e sodium_crypto_pwhash_str_verify(), que funcionam da mesma maneira que os embutidos do PHP. Uma razão possível para usá-las é que o PHP às vezes pode ser compilado sem o libargon2, o que torna os algoritmos do Argon2 indisponíveis para a função password_hash; O PHP 7.2 e superior sempre devem ter o libsodium ativado, mas pode não - mas pelo menos existem duas maneiras de obter esse algoritmo. Aqui está como você pode criar um hash Argon2id com libsodium (mesmo no PHP 7.2, que não possui suporte ao Argon2id):

$hash = sodium_crypto_pwhash_str(
    'mypassword',
    SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE,
    SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE
);

Observe que ele não permite que você especifique um sal manualmente; isso faz parte do ethos da libsodium - não permita que os usuários definam parâmetros para valores que possam comprometer a segurança - por exemplo, nada impede que você passe uma string de sal vazia para a password_hashfunção do PHP ; libsodium não permite que você faça nada tão bobo!

Para senhas do OAuth 2 :

$bcrypt = new \Zend\Crypt\Password\Bcrypt;
$bcrypt->create("youpasswordhere", 10)

Como todos sabemos, armazenar a senha em texto não criptografado no banco de dados não é seguro. o bcrypt é uma técnica de senha com hash. É usada para criar segurança de senha. uma das funções surpreendentes do bcrypt é nos salvar dos hackers; é usado para proteger a senha contra ataques de hackers, porque a senha é armazenada na forma bcrypted.

a função password_hash () é usada para criar um novo hash de senha. Ele usa um algoritmo de hash forte e robusto. A função password_hash () é muito compatível com a função crypt (). Portanto, os hashes de senha criados por crypt () podem ser usados ​​com password_hash () e vice-versa. As funções password_verify () e password_hash () são apenas os wrappers da função crypt (), e facilitam muito o uso preciso.

SINTAXE

string password_hash($password , $algo , $options)

Atualmente, os seguintes algoritmos são suportados pela função password_hash ():

PASSWORD_DEFAULT PASSWORD_BCRYPT PASSWORD_ARGON2I PASSWORD_ARGON2ID

Parâmetros: Esta função aceita três parâmetros, como mencionado acima e descrito abaixo:

senha : armazena a senha do usuário. algo : É a constante do algoritmo de senha que é usada continuamente enquanto denota o algoritmo que deve ser usado quando o hash da senha ocorrer. options : É uma matriz associativa, que contém as opções. Se isso for removido e não incluir, um sal aleatório será usado e a utilização de um custo padrão ocorrerá. Valor de retorno : retorna a senha com hash em caso de sucesso ou False em caso de falha.

Exemplo :

Input : echo password_hash("GFG@123", PASSWORD_DEFAULT); Output : $2y$10$.vGA19Jh8YrwSJFDodbfoHJIOFH)DfhuofGv3Fykk1a

Os programas abaixo ilustram a função password_hash () no PHP:

<?php echo password_hash("GFG@123", PASSWORD_DEFAULT); ?>

RESULTADO

$2y$10$Z166W1fBdsLcXPVQVfPw/uRq1ueWMA6sLt9bmdUFz9AmOGLdM393G