Hin und wieder höre ich den Rat "Verwenden Sie bcrypt zum Speichern von Passwörtern in PHP, bcrypt Regeln".

Aber was ist das bcrypt? PHP bietet keine solchen Funktionen, Wikipedia plappert über ein Dienstprogramm zur Dateiverschlüsselung und Websuchen enthüllen nur einige Implementierungen von Blowfish in verschiedenen Sprachen. Jetzt ist Blowfish auch in PHP über verfügbar mcrypt, aber wie hilft das beim Speichern von Passwörtern? Blowfish ist eine Allzweck-Chiffre, die auf zwei Arten funktioniert. Wenn es verschlüsselt werden könnte, kann es entschlüsselt werden. Passwörter benötigen eine Einweg-Hashing-Funktion.

Was ist die Erklärung?

bcryptist ein Hashing-Algorithmus, der mit Hardware skalierbar ist (über eine konfigurierbare Anzahl von Runden). Die Langsamkeit und die mehreren Runden stellen sicher, dass ein Angreifer massive Mittel und Hardware einsetzen muss, um Ihre Passwörter knacken zu können. Dazu kommen pro-Passwort Salze ( bcryptBRAUCHT Salze) , und Sie können sicher sein , dass ein Angriff ohne entweder lächerliche Menge von Geldern oder Hardware praktisch nicht durchführbar ist.

bcryptverwendet den Eksblowfish- Algorithmus zum Hashing von Passwörtern. Während die Verschlüsselungsphase von Eksblowfish und Blowfish genau gleich ist, stellt die Schlüsselzeitplanphase von Eksblowfish sicher, dass jeder nachfolgende Status sowohl von Salt als auch vom Schlüssel (Benutzerkennwort) abhängt und kein Status ohne Wissen von beiden vorberechnet werden kann. Aufgrund dieses Hauptunterschieds bcrypthandelt es sich um einen Einweg-Hashing-Algorithmus. Sie können das Nur-Text-Passwort nicht abrufen, ohne das Salz, die Runden und den Schlüssel (Passwort) bereits zu kennen . [ Quelle ]

So verwenden Sie bcrypt:

Mit PHP> = 5.5-DEV

Passwort-Hashing-Funktionen wurden jetzt direkt in PHP> = 5.5 integriert . Sie können jetzt password_hash()einen bcryptHash eines beliebigen Passworts erstellen :

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

Um ein vom Benutzer angegebenes Kennwort anhand eines vorhandenen Hashs zu überprüfen, können Sie Folgendes verwenden 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.';
}

Mit PHP> = 5.3.7, <5.5-DEV (auch RedHat PHP> = 5.3.3)

Es gibt eine Kompatibilitätsbibliothek auf GitHub erstellt auf den Quellcode der oben genannten Funktionen basieren ursprünglich in C geschrieben, die die gleiche Funktionalität zur Verfügung stellt. Sobald die Kompatibilitätsbibliothek installiert ist, ist die Verwendung dieselbe wie oben (abzüglich der Kurzarray-Notation, wenn Sie sich noch im Zweig 5.3.x befinden).

Verwenden von PHP <5.3.7 (DEPRECATED)

Sie können die crypt()Funktion verwenden, um bcrypt-Hashes von Eingabezeichenfolgen zu generieren. Diese Klasse kann automatisch Salze erzeugen und vorhandene Hashes anhand einer Eingabe überprüfen. Wenn Sie eine Version von PHP verwenden, die höher oder gleich 5.3.7 ist, wird dringend empfohlen, die integrierte Funktion oder die kompatible Bibliothek zu verwenden . Diese Alternative wird nur für historische Zwecke bereitgestellt.

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

Sie können diesen Code folgendermaßen verwenden:

$bcrypt = new Bcrypt(15);

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

Alternativ können Sie auch das Portable PHP Hashing Framework verwenden .

Sie möchten also bcrypt verwenden? Genial! Wie in anderen Bereichen der Kryptographie sollten Sie dies jedoch nicht selbst tun. Wenn Sie sich Gedanken über die Verwaltung von Schlüsseln, das Speichern von Salzen oder das Generieren von Zufallszahlen machen müssen, machen Sie es falsch.

Der Grund ist einfach: Es ist so einfach, bcrypt zu vermasseln . Wenn Sie sich fast jeden Code auf dieser Seite ansehen, werden Sie feststellen, dass mindestens eines dieser häufigen Probleme verletzt wird.

Seien Sie ehrlich, Kryptographie ist schwer.

Überlassen Sie es den Experten. Überlassen Sie es den Personen, deren Aufgabe es ist, diese Bibliotheken zu pflegen. Wenn Sie eine Entscheidung treffen müssen, machen Sie es falsch.

Verwenden Sie stattdessen einfach eine Bibliothek. Je nach Ihren Anforderungen gibt es mehrere.

Bibliotheken

Hier finden Sie eine Aufschlüsselung einiger der gängigsten APIs.

PHP 5.5 API - (Verfügbar für 5.3.7+)

Ab PHP 5.5 wird eine neue API zum Hashing von Passwörtern eingeführt. Es gibt auch eine Shim-Kompatibilitätsbibliothek, die (von mir) für 5.3.7+ verwaltet wird. Dies hat den Vorteil, dass es sich um eine von Experten überprüfte und einfach zu verwendende Implementierung handelt.

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

Wirklich, es soll extrem einfach sein.

Ressourcen:

• Dokumentation: auf PHP.net
• Kompatibilitätsbibliothek: auf GitHub
• PHPs RFC: auf wiki.php.net

Zend \ Crypt \ Password \ Bcrypt (5.3.2+)

Dies ist eine weitere API, die der von PHP 5.5 ähnelt und einen ähnlichen Zweck erfüllt.

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

Ressourcen:

• Dokumentation: auf Zend
• Blog-Beitrag: Passwort-Hashing mit Zend-Krypta

PasswordLib

Dies ist ein etwas anderer Ansatz für das Passwort-Hashing. PasswordLib unterstützt nicht nur bcrypt, sondern auch eine Vielzahl von Hashing-Algorithmen. Dies ist vor allem in Kontexten nützlich, in denen Sie die Kompatibilität mit älteren und unterschiedlichen Systemen unterstützen müssen, die möglicherweise außerhalb Ihrer Kontrolle liegen. Es unterstützt eine große Anzahl von Hashing-Algorithmen. Und wird 5.3.2+ unterstützt

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

Verweise:

• Quellcode / Dokumentation: GitHub

PHPASS

Dies ist eine Ebene, die bcrypt unterstützt, aber auch einen ziemlich starken Algorithmus unterstützt, der nützlich ist, wenn Sie keinen Zugriff auf PHP> = 5.3.2 haben ... Sie unterstützt tatsächlich PHP 3.0+ (obwohl nicht mit 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
    }
}

Ressourcen

• Code: cvsweb
• Projektseite: auf OpenWall
• Eine Überprüfung des <5.3.0-Algorithmus: auf StackOverflow

Hinweis: Verwenden Sie keine PHPASS-Alternativen, die nicht auf Openwall gehostet werden, sondern unterschiedliche Projekte !!!

Über BCrypt

Wenn Sie bemerken, gibt jede dieser Bibliotheken eine einzelne Zeichenfolge zurück. Das liegt daran, wie BCrypt intern funktioniert. Und dazu gibt es eine Menge Antworten. Hier ist eine Auswahl, die ich geschrieben habe und die ich hier nicht kopieren / einfügen werde, sondern auf Folgendes verweise:

• Grundlegender Unterschied zwischen Hashing- und Verschlüsselungsalgorithmen - Erläutern der Terminologie und einiger grundlegender Informationen dazu.
• Über das Umkehren von Hashes ohne Regenbogentabellen - Grundsätzlich, warum wir bcrypt überhaupt verwenden sollten ...
• Speichern von bcrypt Hashes - im Grunde genommen ist das Salt und der Algorithmus im Hash-Ergebnis enthalten.
• So aktualisieren Sie die Kosten für bcrypt-Hashes - im Grunde genommen, wie Sie die Kosten für den bcrypt-Hash auswählen und dann beibehalten.
• Wie man lange Passwörter mit bcrypt hasht - erklärt das 72-Zeichen-Passwortlimit von bcrypt.
• Wie bcrypt Salze verwendet
• Best Practices zum Salzen und Peppen von Passwörtern - Verwenden Sie grundsätzlich keinen "Pfeffer"
• Migrieren alter md5Passwörter zu bcrypt

Einpacken

Es gibt viele verschiedene Möglichkeiten. Welche Sie wählen, liegt bei Ihnen. Ich würde jedoch dringend empfehlen, dass Sie eine der oben genannten Bibliotheken verwenden, um dies für Sie zu erledigen .

Wenn Sie crypt()direkt verwenden, machen Sie wahrscheinlich etwas falsch. Wenn Ihr Code direkt hash()(oder md5()oder sha1()) verwendet, machen Sie mit ziemlicher Sicherheit etwas falsch.

Verwenden Sie einfach eine Bibliothek ...

In Genug mit den Regenbogentabellen finden Sie viele Informationen : Was Sie über sichere Kennwortschemata oder das tragbare PHP-Kennwort-Hashing-Framework wissen müssen .

Das Ziel ist es, das Passwort mit etwas Langsamem zu hashen, damit jemand, der Ihre Passwortdatenbank erhält, beim Versuch, es brutal zu erzwingen, stirbt (eine Verzögerung von 10 ms, um ein Passwort zu überprüfen, ist nichts für Sie, viel für jemanden, der versucht, es brutal zu erzwingen). Bcrypt ist langsam und kann mit einem Parameter verwendet werden, um zu wählen, wie langsam es ist.

Sie können mit bcrypt einen Einweg-Hash erstellen, indem Sie die PHP- crypt()Funktion verwenden und ein geeignetes Blowfish-Salz eingeben. Das Wichtigste der gesamten Gleichung ist, dass A) der Algorithmus nicht kompromittiert wurde und B) Sie jedes Passwort richtig salzen . Verwenden Sie kein anwendungsweites Salz. Dadurch wird Ihre gesamte Anwendung für Angriffe von einem einzigen Satz von Rainbow-Tabellen aus geöffnet.

PHP - Kryptofunktion

Edit: 2013.01.15 - Wenn Ihr Server dies unterstützt, verwenden Sie stattdessen die Lösung von martinstoeckli .

Jeder möchte das komplizierter machen als es ist. Die crypt () -Funktion erledigt den größten Teil der Arbeit.

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

Beispiel:

$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

Ich weiß, dass es offensichtlich sein sollte, aber bitte verwenden Sie nicht 'Passwort' als Ihr Passwort.

Version 5.5 von PHP bietet integrierte Unterstützung für BCrypt, die Funktionen password_hash()und password_verify(). Eigentlich sind dies nur Wrapper um die Funktion crypt()und sollen die korrekte Verwendung erleichtern. Es sorgt für die Erzeugung eines sicheren zufälligen Salzes und liefert gute Standardwerte.

Der einfachste Weg, diese Funktionen zu nutzen, ist:

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

Dieser Code hasht das Passwort mit BCrypt (Algorithmus 2y), generiert ein zufälliges Salt aus der zufälligen Quelle des Betriebssystems und verwendet den Standardkostenparameter (im Moment ist dies 10). In der zweiten Zeile wird geprüft, ob das vom Benutzer eingegebene Passwort mit einem bereits gespeicherten Hashwert übereinstimmt.

Wenn Sie den Kostenparameter ändern möchten, können Sie dies folgendermaßen tun: Erhöhen Sie den Kostenparameter um 1 und verdoppeln Sie die für die Berechnung des Hashwerts erforderliche Zeit:

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

Im Gegensatz zum "cost"Parameter ist es am besten, den "salt"Parameter wegzulassen , da die Funktion bereits ihr Bestes tut, um ein kryptografisch sicheres Salz zu erstellen.

Für PHP Version 5.3.7 und höher gibt es ein Kompatibilitätspaket desselben Autors, der die password_hash()Funktion erstellt hat. Für PHP - Versionen vor 5.3.7 gibt es keine Unterstützung für crypt()mit 2y, die Unicode sicher BCrypt Algorithmus. Man könnte es stattdessen durch ersetzen 2a, was die beste Alternative für frühere PHP-Versionen ist.

Aktuelles Denken: Hashes sollten am langsamsten verfügbar sein, nicht am schnellsten. Dies unterdrückt Regenbogentischangriffe .

Ebenfalls verwandt, aber vorsorglich: Ein Angreifer sollte niemals uneingeschränkten Zugriff auf Ihren Anmeldebildschirm haben. Um dies zu verhindern: Richten Sie eine IP-Adressverfolgungstabelle ein, die jeden Treffer zusammen mit dem URI aufzeichnet. Wenn in einem Zeitraum von fünf Minuten mehr als 5 Anmeldeversuche von derselben IP-Adresse ausgehen, blockieren Sie dies mit einer Erklärung. Ein sekundärer Ansatz besteht darin, ein zweistufiges Passwortschema zu haben, wie es Banken tun. Das Sperren von Fehlern im zweiten Durchgang erhöht die Sicherheit.

Zusammenfassung: Verlangsamen Sie den Angreifer mithilfe zeitaufwändiger Hash-Funktionen. Blockieren Sie außerdem zu viele Zugriffe auf Ihr Login und fügen Sie eine zweite Kennwortebene hinzu.

Hier ist eine aktualisierte Antwort auf diese alte Frage!

Der richtige Weg, um Passwörter in PHP seit 5.5 zu hashen, ist mit password_hash(), und der richtige Weg, sie zu überprüfen, ist mit password_verify(), und dies gilt immer noch in PHP 8.0. Diese Funktionen verwenden standardmäßig bcrypt-Hashes, es wurden jedoch auch andere stärkere Algorithmen hinzugefügt. Sie können den Arbeitsfaktor (effektiv, wie "stark" die Verschlüsselung ist) über die password_hashParameter ändern .

Obwohl bcrypt immer noch stark genug ist, gilt es nicht mehr als Stand der Technik . Mit den Varianten Argon2i, Argon2d und Argon2id ist ein besserer Satz von Passwort-Hash-Algorithmen namens Argon2 eingetroffen . Der Unterschied zwischen ihnen (wie hier beschrieben ):

Argon2 hat eine primäre Variante: Argon2id und zwei zusätzliche Varianten: Argon2d und Argon2i. Argon2d verwendet einen datenabhängigen Speicherzugriff, wodurch es für Kryptowährungen und Proof-of-Work-Anwendungen ohne Bedrohung durch Side-Channel-Timing-Angriffe geeignet ist. Argon2i verwendet einen datenunabhängigen Speicherzugriff, der für das Kennwort-Hashing und die kennwortbasierte Schlüsselableitung bevorzugt wird. Argon2id arbeitet als Argon2i für die erste Hälfte der ersten Iteration über den Speicher und als Argon2d für den Rest und bietet somit sowohl Seitenkanal-Angriffsschutz als auch Brute-Force-Kosteneinsparungen aufgrund von Zeit-Speicher-Kompromissen.

Argon2i-Unterstützung wurde in PHP 7.2 hinzugefügt und Sie fordern dies folgendermaßen an:

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

und Argon2id-Unterstützung wurde in PHP 7.3 hinzugefügt:

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

Für die Überprüfung von Kennwörtern sind keine Änderungen erforderlich, da die resultierende Hash-Zeichenfolge Informationen darüber enthält, welche Algorithmen, Salt- und Arbeitsfaktoren bei der Erstellung verwendet wurden.

Ganz separat (und etwas redundant) bietet libsodium (hinzugefügt in PHP 7.2) auch Argon2-Hashing über die Funktionen sodium_crypto_pwhash_str ()und sodium_crypto_pwhash_str_verify(), die ähnlich wie die integrierten PHP-Funktionen funktionieren. Ein möglicher Grund für die Verwendung dieser ist, dass PHP manchmal ohne libargon2 kompiliert werden kann, wodurch die Argon2-Algorithmen für die Funktion password_hash nicht verfügbar sind. PHP 7.2 und höher sollte immer libsodium aktiviert haben, aber möglicherweise nicht - aber es gibt zumindest zwei Möglichkeiten, wie Sie diesen Algorithmus verwenden können. So können Sie einen Argon2id-Hash mit libsodium erstellen (auch in PHP 7.2, das ansonsten keine Argon2id-Unterstützung bietet)):

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

Beachten Sie, dass Sie ein Salz nicht manuell angeben können. Dies ist Teil des libsodium-Ethos. Erlauben Sie Benutzern nicht, Parameter auf Werte zu setzen, die die Sicherheit gefährden könnten. Beispielsweise hindert Sie nichts daran, eine leere Salt-Zeichenfolge an die PHP- password_hashFunktion zu übergeben. libsodium lässt dich nichts so Dummes tun!

Für OAuth 2- Passwörter:

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

Wie wir alle wissen, ist das Speichern des Passworts im Klartext in der Datenbank nicht sicher. Das bcrypt ist eine Hashing-Passwort-Technik. Es wird verwendet, um die Passwortsicherheit aufzubauen. Eine der erstaunlichen Funktionen von bcrypt ist, dass es uns vor Hackern schützt. Es wird verwendet, um das Passwort vor Hacking-Angriffen zu schützen, da das Passwort in verschlüsselter Form gespeichert ist.

Mit der Funktion password_hash () wird ein neuer Passwort-Hash erstellt. Es verwendet einen starken und robusten Hashing-Algorithmus. Die Funktion password_hash () ist sehr gut mit der Funktion crypt () kompatibel. Daher können von crypt () erstellte Passwort-Hashes mit password_hash () verwendet werden und umgekehrt. Die Funktionen password_verify () und password_hash () sind nur die Wrapper um die Funktion crypt () und erleichtern die genaue Verwendung erheblich.

SYNTAX

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

Die folgenden Algorithmen werden derzeit von der Funktion password_hash () unterstützt:

PASSWORD_DEFAULT PASSWORD_BCRYPT PASSWORD_ARGON2I PASSWORD_ARGON2ID

Parameter: Diese Funktion akzeptiert drei Parameter, wie oben erwähnt und unten beschrieben:

Passwort : Hier wird das Passwort des Benutzers gespeichert. algo : Dies ist die Konstante des Passwortalgorithmus, die kontinuierlich verwendet wird, während der Algorithmus angegeben wird, der verwendet werden soll, wenn das Hashing des Passworts stattfindet. Optionen : Es ist ein assoziatives Array, das die Optionen enthält. Wenn dies entfernt wird und nicht enthalten ist, wird ein zufälliges Salz verwendet, und die Verwendung von Standardkosten erfolgt. Rückgabewert : Es gibt das Hash - Passwort auf Erfolg oder False bei Fehlern.

Beispiel :

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

Die folgenden Programme veranschaulichen die Funktion password_hash () in PHP:

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

AUSGABE

$2y$10$Z166W1fBdsLcXPVQVfPw/uRq1ueWMA6sLt9bmdUFz9AmOGLdM393G