Ogni tanto sento il consiglio "Usa bcrypt per archiviare le password in PHP, regole bcrypt".

Ma cos'è bcrypt? PHP non offre tali funzioni, Wikipedia parla di un'utilità di crittografia dei file e le ricerche sul Web rivelano solo alcune implementazioni di Blowfish in diverse lingue. Ora Blowfish è disponibile anche in PHP tramitemcrypt , ma in che modo aiuta a memorizzare le password? Blowfish è un codice generico, funziona in due modi. Se potrebbe essere crittografato, può essere decrittografato. Le password richiedono una funzione di hashing unidirezionale.

Qual è la spiegazione?

bcryptè un algoritmo di hash che è scalabile con l'hardware (tramite un numero configurabile di round). La sua lentezza e i suoi molteplici round assicurano che un utente malintenzionato debba distribuire ingenti fondi e hardware per poter violare le password. Aggiungi a quei sali per password ( bcryptRICHIEDE sali) e puoi essere sicuro che un attacco è praticamente irrealizzabile senza una quantità ridicola di fondi o hardware.

bcryptutilizza l' algoritmo Eksblowfish per eseguire l'hash delle password. Mentre la fase di crittografia di Eksblowfish e Blowfish è esattamente la stessa, la fase di pianificazione delle chiavi di Eksblowfish garantisce che qualsiasi stato successivo dipenda sia da salt che da chiave (password utente) e che nessuno stato possa essere precompilato senza la conoscenza di entrambi. A causa di questa differenza fondamentale, bcryptè un algoritmo di hashing unidirezionale. Non è possibile recuperare la password del testo normale senza conoscere già il sale, i round e la chiave (password). [ Fonte ]

Come usare bcrypt:

Utilizzando PHP> = 5.5-DEV

Le funzioni di hashing delle password ora sono state integrate direttamente in PHP> = 5.5 . Ora puoi usare password_hash()per creare un bcrypthash di qualsiasi password:

<?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

Per verificare la password fornita da un utente rispetto a un hash esistente, è possibile utilizzare password_verify()come tale:

<?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.';
}

Utilizzo di PHP> = 5.3.7, <5.5-DEV (anche RedHat PHP> = 5.3.3)

C'è una libreria di compatibilità su GitHub creata in base al codice sorgente delle funzioni di cui sopra originariamente scritto in C, che fornisce la stessa funzionalità. Una volta installata la libreria di compatibilità, l'utilizzo è lo stesso di cui sopra (meno la notazione dell'array abbreviata se si è ancora nel ramo 5.3.x).

Utilizzo di PHP <5.3.7 (DEPRECATED)

È possibile utilizzare la crypt()funzione per generare hash bcrypt di stringhe di input. Questa classe può generare automaticamente sali e verificare hash esistenti rispetto a un input. Se si utilizza una versione di PHP successiva o uguale a 5.3.7, si consiglia vivamente di utilizzare la funzione integrata o la libreria compat . Questa alternativa è fornita solo per scopi storici.

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;
  }
}

Puoi usare questo codice in questo modo:

$bcrypt = new Bcrypt(15);

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

In alternativa, puoi anche utilizzare il Portable PHP Hashing Framework .

Quindi, vuoi usare bcrypt? Eccezionale!Tuttavia, come altre aree della crittografia, non dovresti farlo da solo. Se devi preoccuparti di qualcosa come la gestione delle chiavi, la memorizzazione di sali o la generazione di numeri casuali, stai sbagliando.

Il motivo è semplice: è così banalmente facile rovinare bcrypt . In effetti, se guardi quasi ogni parte di codice in questa pagina, noterai che sta violando almeno uno di questi problemi comuni.

Ammettilo, la crittografia è difficile.

Lascialo per gli esperti. Lascialo per le persone il cui compito è mantenere queste librerie. Se devi prendere una decisione, la stai sbagliando.

Invece, basta usare una libreria. Ne esistono diversi a seconda delle tue esigenze.

biblioteche

Ecco una ripartizione di alcune delle API più comuni.

API PHP 5.5 - (disponibile per 5.3.7+)

A partire da PHP 5.5, viene introdotta una nuova API per le password di hashing. C'è anche una libreria di compatibilità shim mantenuta (da me) per 5.3.7+. Questo ha il vantaggio di essere un'implementazione peer-reviewed e semplice da usare.

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
    }
}

Davvero, mira ad essere estremamente semplice.

risorse:

• Documentazione: su PHP.net
• Libreria di compatibilità: su GitHub
• RFC di PHP: su wiki.php.net

Zend \ Crypt \ Password \ Bcrypt (5.3.2+)

Questa è un'altra API simile a quella di PHP 5.5 e ha uno scopo simile.

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
    }
}

risorse:

• Documentazione: su Zend
• Post del blog: Hashing delle password con Zend Crypt

PasswordLib

Questo è un approccio leggermente diverso all'hash delle password. Anziché supportare semplicemente bcrypt, PasswordLib supporta un gran numero di algoritmi di hashing. È utile soprattutto in contesti in cui è necessario supportare la compatibilità con sistemi legacy e disparati che potrebbero essere al di fuori del proprio controllo. Supporta un gran numero di algoritmi di hashing. Ed è supportato 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
    }
}

Riferimenti:

• Codice sorgente / Documentazione: GitHub

PHPASS

Questo è un livello che supporta bcrypt, ma supporta anche un algoritmo abbastanza potente utile se non si ha accesso a PHP> = 5.3.2 ... In realtà supporta PHP 3.0+ (anche se non con 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
    }
}

risorse

• Codice: cvsweb
• Sito del progetto: su OpenWall
• Una revisione dell'algoritmo <5.3.0: su StackOverflow

Nota: non utilizzare le alternative PHPASS che non sono ospitate su openwall, sono progetti diversi !!!

Informazioni su BCrypt

Se noti, ognuna di queste librerie restituisce una singola stringa. Ciò è dovuto al modo in cui BCrypt funziona internamente. E ci sono un sacco di risposte a riguardo. Ecco una selezione che ho scritto, che non copierò / incollerò qui, ma rimanderò a:

• Differenza fondamentale tra algoritmi di hash e crittografia - Spiegazione della terminologia e alcune informazioni di base su di essi.
• Informazioni sull'inversione degli hash senza tabelle arcobaleno : in sostanza perché dovremmo usare bcrypt in primo luogo ...
• Memorizzazione di hash bcrypt - fondamentalmente perché il salt e l'algoritmo sono inclusi nel risultato hash.
• Come aggiornare il costo degli hash di bcrypt - fondamentalmente come scegliere e quindi mantenere il costo dell'hash di bcrypt.
• Come eseguire l'hashing di password lunghe con bcrypt - spiegando il limite di 72 caratteri per password di bcrypt.
• Come bcrypt usa i sali
• Best practice per la salatura e il peppering delle password - Fondamentalmente, non usare un "pepe"
• Migrazione di vecchie md5password su bcrypt

Incartare

Ci sono molte scelte diverse. Quale scegli dipende da te. Tuttavia, vorrei ALTAMENTE consiglia di utilizzare una delle librerie di cui sopra per la gestione di questo per voi.

Ancora una volta, se stai usando crypt()direttamente, probabilmente stai facendo qualcosa di sbagliato. Se il tuo codice utilizza hash()(o md5()o sha1()) direttamente, stai quasi sicuramente facendo qualcosa di sbagliato.

Usa una libreria ...

Otterrai molte informazioni in Basta con The Rainbow Tables: cosa devi sapere sugli schemi di password sicure o sul framework di hashing delle password PHP portatile .

L'obiettivo è hash della password con qualcosa di lento, quindi qualcuno che ottiene il tuo database delle password morirà nel tentativo di forzare la forza (un ritardo di 10 ms per controllare una password non fa per te, molto per qualcuno che cerca di forzare la forza). Bcrypt è lento e può essere utilizzato con un parametro per scegliere quanto è lento.

Puoi creare un hash unidirezionale con bcrypt usando la crypt()funzione di PHP e passando un sale Blowfish appropriato. La più importante di tutta l'equazione è che A) l'algoritmo non è stato compromesso e B) si sale correttamente ogni password . Non utilizzare un sale a livello di applicazione; che apre l'intera applicazione per attaccare da un singolo set di tabelle Rainbow.

PHP - Funzione Crypt

Modifica: 2013.01.15 - Se il tuo server lo supporterà, usa invece la soluzione di martinstoeckli .

Tutti vogliono renderlo più complicato di quello che è. La funzione crypt () svolge la maggior parte del lavoro.

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);
}

Esempio:

$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

So che dovrebbe essere ovvio, ma per favore non usare "password" come password.

La versione 5.5 di PHP avrà il supporto integrato per BCrypt, le funzioni password_hash()e password_verify(). In realtà questi sono solo involucri attorno alla funzione crypt()e devono renderlo più facile da usare correttamente. Si occupa della generazione di un sale casuale sicuro e fornisce buoni valori predefiniti.

Il modo più semplice per utilizzare queste funzioni sarà:

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

Questo codice eseguirà l'hashing della password con BCrypt (algoritmo 2y), genera un salt casuale dalla fonte casuale del SO e utilizza il parametro di costo predefinito (al momento è 10). La seconda riga verifica se l'utente ha inserito una password corrispondente a un valore hash già memorizzato.

Se si desidera modificare il parametro di costo, è possibile farlo in questo modo, aumentando il parametro di costo di 1, raddoppiando il tempo necessario per calcolare il valore di hash:

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

Contrariamente al "cost"parametro, è meglio omettere il "salt"parametro, poiché la funzione fa già del suo meglio per creare un sale crittograficamente sicuro.

Per PHP versione 5.3.7 e successive, esiste un pacchetto di compatibilità , dello stesso autore che ha creato la password_hash()funzione. Per le versioni PHP precedenti alla 5.3.7 non è supportato crypt()con 2yl'algoritmo BCrypt sicuro Unicode. Si potrebbe invece sostituirlo con 2a, che è la migliore alternativa per le precedenti versioni di PHP.

Pensiero attuale: gli hash dovrebbero essere i più lenti disponibili, non i più veloci possibili. Questo elimina gli attacchi da tavolo arcobaleno .

Anche correlato, ma precauzionale: un utente malintenzionato non dovrebbe mai avere accesso illimitato alla schermata di accesso. Per evitarlo: imposta una tabella di tracciamento dell'indirizzo IP che registri ogni hit insieme all'URI. Se più di 5 tentativi di accesso provengono dallo stesso indirizzo IP in un periodo di cinque minuti, bloccare con spiegazione. Un approccio secondario è quello di avere uno schema di password a due livelli, come fanno le banche. Mettere un blocco per errori sul secondo passaggio aumenta la sicurezza.

Riepilogo: rallenta l'attaccante utilizzando le funzioni hash che richiedono tempo. Inoltre, blocca troppi accessi al tuo login e aggiungi un secondo livello di password.

Ecco una risposta aggiornata a questa vecchia domanda!

Il modo giusto per hash delle password in PHP è 5.5 password_hash()e il modo giusto per verificarle è con password_verify(), e questo è ancora vero in PHP 8.0. Queste funzioni usano hash bcrypt per impostazione predefinita, ma sono stati aggiunti altri algoritmi più potenti. È possibile modificare il fattore di lavoro (effettivamente quanto "forte" è la crittografia) tramite i password_hashparametri.

Tuttavia, mentre è ancora abbastanza forte, bcrypt non è più considerato all'avanguardia ; un migliore set di algoritmi di hash delle password è arrivato chiamato Argon2 , con le varianti Argon2i, Argon2d e Argon2id. La differenza tra loro (come descritto qui ):

Argon2 ha una variante primaria: Argon2id e due varianti supplementari: Argon2d e Argon2i. Argon2d utilizza l'accesso alla memoria dipendente dai dati, che lo rende adatto per le criptovalute e le applicazioni di prova di lavoro senza minacce da attacchi di temporizzazione del canale laterale. Argon2i utilizza l'accesso alla memoria indipendente dai dati, che è preferito per l'hash della password e la derivazione della chiave basata su password. Argon2id funziona come Argon2i per la prima metà della prima iterazione sulla memoria e come Argon2d per il resto, fornendo così sia la protezione dagli attacchi del canale laterale sia risparmi sui costi della forza bruta a causa di compromessi della memoria temporale.

Il supporto per Argon2i è stato aggiunto in PHP 7.2 e lo richiedi in questo modo:

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

e il supporto Argon2id è stato aggiunto in PHP 7.3:

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

Non sono necessarie modifiche per la verifica delle password poiché la stringa di hash risultante contiene informazioni su quali algoritmo, salt e fattori di lavoro sono stati utilizzati al momento della creazione.

Abbastanza separatamente (e in qualche modo ridondante), libsodium (aggiunto in PHP 7.2) fornisce anche l'hashing di Argon2 tramite le funzioni sodium_crypto_pwhash_str ()e sodium_crypto_pwhash_str_verify(), che funzionano allo stesso modo dei built-in PHP. Una possibile ragione per l'uso di questi è che a volte PHP può essere compilato senza libargon2, il che rende gli algoritmi Argon2 non disponibili per la funzione password_hash; PHP 7.2 e versioni successive dovrebbero sempre avere libsodium abilitato, ma potrebbe non esserlo - ma almeno ci sono due modi per ottenere quell'algoritmo. Ecco come è possibile creare un hash Argon2id con libsodium (anche in PHP 7.2, che altrimenti non ha il supporto Argon2id)):

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

Si noti che non consente di specificare manualmente un sale; questo fa parte dell'ethos di libsodium - non permettere agli utenti di impostare parametri su valori che potrebbero compromettere la sicurezza - per esempio non c'è nulla che ti impedisca di passare una stringa di sale vuota alla password_hashfunzione di PHP ; libsodium non ti consente di fare nulla di così sciocco!

Per le password di OAuth 2 :

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

Come tutti sappiamo, archiviare la password in chiaro nel database non è sicuro. bcrypt è una tecnica con password di hashing, utilizzata per creare la sicurezza delle password. una delle incredibili funzioni di bcrypt è che ci salva dagli hacker, è usato per proteggere la password dagli attacchi di hacking perché la password è memorizzata in forma criptata.

la funzione password_hash () viene utilizzata per creare un nuovo hash password. Utilizza un algoritmo di hashing forte e robusto. La funzione password_hash () è molto compatibile con la funzione crypt (). Pertanto, gli hash delle password creati da crypt () possono essere utilizzati con password_hash () e viceversa. Le funzioni password_verify () e password_hash () sono solo i wrapper attorno alla funzione crypt () e rendono molto più facile usarlo con precisione.

SINTASSI

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

I seguenti algoritmi sono attualmente supportati dalla funzione password_hash ():

PASSWORD_DEFAULT PASSWORD_BCRYPT PASSWORD_ARGON2I PASSWORD_ARGON2ID

Parametri: questa funzione accetta tre parametri come indicato sopra e descritto di seguito:

password : memorizza la password dell'utente. algo : è la costante dell'algoritmo della password che viene utilizzata continuamente mentre indica l'algoritmo che deve essere utilizzato quando si verifica l'hash della password. opzioni : è un array associativo, che contiene le opzioni. Se questo viene rimosso e non include, verrà utilizzato un salt casuale e verrà utilizzato l'utilizzo di un costo predefinito. Valore di ritorno : restituisce la password con hash in caso di successo o Falso in caso di fallimento.

Esempio :

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

Di seguito i programmi illustrano la funzione password_hash () in PHP:

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

PRODUZIONE

$2y$10$Z166W1fBdsLcXPVQVfPw/uRq1ueWMA6sLt9bmdUFz9AmOGLdM393G