Der Secure-hash-und salt für PHP Passwörter

Eine viel kürzere und sicherere Antwort - nicht schreiben Sie Ihre eigenen Passwort-Mechanismus an alle, verwenden Sie einen bewährten Mechanismus.

• PHP 5.5 oder höher: password_hash() eine gute Qualität hat und Teil des PHP-Kern.
• Älteren PHP-Versionen: OpenWall ist phpass Bibliothek ist viel besser als die meisten custom code in WordPress, Drupal, etc.

Meisten Programmierer einfach nicht die Kompetenz haben, zu schreiben, Krypto-code sicher und ohne die Einführung von Schwachstellen.

Schnellen selbst-test: was ist Passwort dehnen und wie viele Iterationen sollten Sie verwenden? Wenn Sie die Antwort nicht wissen, sollten Sie password_hash() als Passwort stretching ist heute ein entscheidendes Merkmal von Passwort-Mechanismen durch schnellere CPUs und die Verwendung von GPUs und FPGAs zu knacken Passwörter bei Preisen von Milliarden von Vermutungen pro Sekunde (bei GPUs).

Beispielsweise können Sie knacken Sie die 8-Zeichen-Windows-Kennwörter in 6 Stunden mit 25 GPUs installiert in 5 desktop-PCs. Das ist brute-forcen, d.h. das auflisten und überprüfen alle 8-stelligen Windows-Kennwort, einschließlich Sonderzeichen, und ist nicht ein Wörterbuch-Angriff. Das war in 2012, ab 2018 könnten Sie weniger GPUs, oder crack schneller mit 25 GPUs.

Gibt es auch viele rainbow-table-Angriffe auf Windows-Kennwörter, die auf normalen CPUs und sind sehr schnell. All dies ist, weil Windows noch nicht Salz-oder stretch seine Passwörter, auch in Windows 10 - machen Sie nicht den gleichen Fehler wie Microsoft gemacht hat!

Siehe auch:

• ausgezeichnete Antwort mit Sie mehr darüber, warum password_hash() oder phpass sind der beste Weg zu gehen.
• gute blog-Artikel geben recommmended 'Arbeit-Faktoren" (Anzahl der Iterationen) für die wichtigsten algorithmen, darunter bcrypt, scrypt und PBKDF2.

InformationsquelleAutor RichVel

Als PHP 5.5, PHP ist eine einfache, sichere Funktionen für das hashing und die Verifizierung der Passwörter, password_hash() und password_verify()

$password = 'anna';
$hash = password_hash($password, PASSWORD_DEFAULT);
$expensiveHash = password_hash($password, PASSWORD_DEFAULT, array('cost' => 20));

password_verify('anna', $hash); //Returns true
password_verify('anna', $expensiveHash); //Also returns true
password_verify('elsa', $hash); //Returns false

Wenn password_hash() verwendet wird, erzeugt es eine zufällige Salz und schließt es in der ausgegebenen hash (zusammen mit den Kosten und Algorithmus verwendet.) password_verify() dann liest, dass hash und legt die Salz-und Verschlüsselungs-Methode verwendet, und prüft es gegen das mitgelieferte Klartext Passwort.

Bereitstellung der PASSWORD_DEFAULT weist PHP an, verwenden Sie die Standard-hashing-Algorithmus, der die installierte version von PHP. Genau, mit welchem Algorithmus das bedeutet, soll im Laufe der Zeit ändern sich in zukünftigen Versionen, so dass es immer eine der stärksten verfügbaren algorithmen.

Steigenden Kosten (standardmäßig 10) macht der hash schwerer zu brute-force -, sondern auch Mittel generieren von hashes und überprüfen der Passwörter gegen Sie werden mehr arbeiten für Ihre server-CPU.

Beachten Sie, dass, obwohl die Standard-hashing-Algorithmus kann sich ändern, alte hashes werden auch weiterhin, um zu überprüfen, einfach in Ordnung, weil der Algorithmus gespeichert ist, der in der hash-und password_verify() greift es.

InformationsquelleAutor AlliterativeAlice

Ich möchte nur darauf hinweisen, dass PHP 5.5 beinhaltet ein Passwort-hashing-API, stellt einen wrapper um crypt(). Diese API vereinfacht die Aufgabe, hashing, Verifikation und Aufbereitung Passwort-hashes. Der Autor hat auch veröffentlicht eine compatibility pack (in form einer einzigen password.php die Datei, die Sie einfach require zu verwenden), für diejenigen, die sich mit PHP 5.3.7 und höher und nutzen wollen, dieses Recht jetzt.

Es unterstützt nur BCRYPT für jetzt, aber es soll leicht erweiterbar sein, um auch andere Passwort-hashing-Techniken und, weil die Technik und die Kosten werden als Teil des hash-änderungen, um Ihre bevorzugte Hash-Technik/Kosten führt nicht zur Unwirksamkeit aktuellen hashes, wird der Rahmen automatisch, verwenden Sie die richtige Technik/Kosten bei der Validierung. Sie übernimmt auch die Erstellung einer "sicheren" Salz, wenn Sie nicht explizit definieren Sie Ihre eigenen.

Die API stellt vier Funktionen:

• password_get_info() - gibt Informationen über den angegebenen hash
• password_hash() - erstellt eine Passwort-hash
• password_needs_rehash() - prüft, ob der übergebene hash-entspricht den Optionen gegeben. Nützlich, um zu überprüfen, ob der hash entspricht Ihre aktuelle Technik/Kosten-Schema sodass Sie wiederhaben, wenn nötig
• password_verify() - stellt sicher, dass ein Kennwort entspricht einem hash

Momentan werden diese Funktionen nehmen die PASSWORD_BCRYPT und PASSWORD_DEFAULT Passwort Konstanten, die gleichbedeutend sind im moment, mit dem Unterschied, dass PASSWORD_DEFAULT "ändern kann in neueren Versionen von PHP, wenn neuere, stärkere Hash-algorithmen werden unterstützt." Mit PASSWORD_DEFAULT und password_needs_rehash() auf login (und-Aufbereitung, falls erforderlich) sollten sicherstellen, dass Ihre Hashwerte sind relativ widerstandsfähig gegen brute-force-Angriffe mit wenig bis gar keine Arbeit für Sie.

EDIT: habe gerade realisiert, dass dies kurz erwähnt in Robert K ' s Antwort. Ich lasse diese Antwort hier, da ich denke, es bietet ein wenig mehr Informationen darüber, wie es funktioniert und die Benutzerfreundlichkeit, die es bietet für diejenigen, die nicht wissen, dass Sicherheit.

InformationsquelleAutor JonoCoetzee

DINGE ZU ERINNERN,

Viel gesagt worden über die Passwort-Verschlüsselung für PHP, die meisten von denen sehr gute Ratschläge, aber bevor Sie selbst beginnen, den Prozess der Verwendung von PHP für die Passwort-Verschlüsselung stellen Sie sicher, Sie haben die folgende umgesetzt oder fertig umgesetzt werden.

SERVER

PORTS

Egal wie gut deine Verschlüsselung ist, wenn Sie nicht richtig sichern der server läuft die PHP und DB alle Ihre Anstrengungen wertlos sind. Die meisten Server-Funktion relativ die gleiche Weise, Sie müssen die ports zugewiesen, damit Sie Zugriff auf Sie aus der Ferne, entweder über ftp oder shell. Stellen Sie sicher, dass Sie das default port ändern, von denen je remote-Verbindung aktiv ist. Durch dies nicht zu tun Sie im Endeffekt gemacht haben, die Angreifer zu tun ein kleiner Schritt, in auf Ihr system zugreifen.

BENUTZERNAME

Für all das gute in der Welt verwenden Sie nicht den Benutzernamen admin, root oder ähnliches. Auch wenn Sie auf einem unix-basierten system machen Sie NICHT den root-account login zugänglich, es muss immer sudo nur.

PASSWORT

Sagen Sie Ihren Nutzern ermöglichen, gute Passwörter, um zu vermeiden, gehackt, das gleiche zu tun. Was ist der Punkt im gehen durch alle die Mühe, sperren Sie Ihre Tür, wenn Sie die Hintertür weit offen.

DATENBANK

SERVER

Idealerweise sollten Sie Ihre DB und ANWENDUNG auf getrennten Servern. Dies ist nicht immer möglich, wegen der Kosten, aber es erlaubt für einige Sicherheit, da der Angreifer wird durch zwei Schritte, um vollständig auf das system zugreifen.

BENUTZER

Haben immer Ihre Anwendung haben Ihre eigenen Konto, um den Zugriff auf die DB, und nur geben es die Privilegien, die Sie benötigen.

Haben dann einen separaten user-account für Sie, der nicht irgendwo gespeichert auf dem server, auch nicht in der Anwendung.

Wie immer NICHT root oder ähnliches.

PASSWORT

Folgen Sie den gleichen Richtlinien wie bei allen guten Passwörter. Auch nicht wiederverwenden das gleiche Kennwort auf einem beliebigen SERVER oder DB-Konten auf dem gleichen system.

PHP

PASSWORT

NIE speichern eines Kennworts in der DB, statt speichern den hash und einzigartigen Salz, ich werde erklären, warum später.

HASHING

ONE-WAY-HASHING!!!!!!!, Nie hash eines Passwortes in einer Weise, dass es rückgängig gemacht werden kann, Hashes, sollte ein Weg sein, das heißt, Sie vertauschen Sie nicht und vergleichen Sie das Kennwort ein, die Sie stattdessen hash des eingegebenen Passworts die gleiche Art und Weise und ein Vergleich der beiden Hashwerte. Dies bedeutet, dass selbst wenn ein Angreifer erhält Zugriff auf die DB, die er nicht weiß, was das eigentlich Passwort ist, sondern nur seine daraus resultierenden Hashwert. Das bedeutet mehr Sicherheit für Ihre Benutzer in die Schlimmste mögliche Szenario.

Es gibt eine Menge von guten Hash-Funktionen gibt (password_hash, hash, etc...), aber Sie brauchen, um zu wählen ein guter Algorithmus für den hash, um wirksam zu sein. (bcrypt und diejenigen, die Ihnen ähnlich sind anständig algorithmen.)

Beim hashing Geschwindigkeit ist der Schlüssel, desto langsamer ist die widerstandsfähiger gegen Brute-Force-Attacken.

Einer der häufigsten Fehler bei hashing ist, dass die hashes sind nicht einzigartig für den Benutzer. Dies ist vor allem, weil die Salze sind nicht eindeutig generiert.

SALZEN

Passwörter sollten immer gesalzen werden, bevor Sie gehasht. Salzen fügt eine zufällige Zeichenfolge, die das Kennwort so ähnlich Passwörter nicht angezeigt, das gleiche in der DB. Wenn aber das Salz ist nicht für jeden Benutzer einmalig (ie: verwenden Sie eine hart codierte Salz) als Sie haben ziemlich viel aus Ihrem Salz wertlos. Denn sobald ein Angreifer die zahlen aus einem Kennwort-Salz-er hat das Salz für alle von Ihnen.

Beim erstellen einer Salz stellen Sie sicher, es ist einzigartig das Passwort, es ist das Salzen, dann speichern Sie sowohl das vollständig ausgefüllte hash-und salt in der DB. Was wird dies tun, ist machen Sie es so, dass ein Angreifer einzeln knacken jedes salt und hash, bevor Sie zugreifen können. Dies bedeutet eine Menge mehr Arbeit und Zeit für die Angreifer.

BENUTZER ERSTELLEN PASSWÖRTER

Wenn der Benutzer ein Passwort erstellen, die durch das frontend, d.h. es muss an den server gesendet werden. Dies öffnet ein Sicherheits-Problem, weil das bedeutet, dass die unverschlüsselte Passwort an den server gesendet werden und wenn ein Angreifer in der Lage ist zu hören und Zugriff auf alle Ihre Sicherheit in PHP ist wertlos. IMMER übertragen die Daten SICHER, dies geschieht über SSL, aber müde werden, auch SSL ist nicht makellos (OpenSSL die Heartbleed Fehler ist ein Beispiel HIERFÜR).

Machen auch die Benutzer-erstellen Sie ein Sicheres Passwort, es ist einfach und sollte immer durchgeführt werden, der Benutzer wird dankbar sein für das es in der end.

Schließlich, egal, die Sicherheitsmaßnahmen, die Sie nehmen nichts 100% sicher ist, je weiter Fortgeschritten die Technologie zu schützen, wird die erweiterte Angriffe geworden. Aber nach diesen Schritten wird Ihre Website sicherer und weit weniger wünschenswert für Angreifer nach zu gehen.

Hier ist eine PHP-Klasse, die erstellt einen hash-und salt für Passwort einfach

http://git.io/mSJqpw

InformationsquelleAutor wmfrancia

Fand ich perfekte Thema auf diese Sache hier: https://crackstation.net/hashing-security.htm, ich wollte Sie davon profitieren, hier ist der Quellcode auch zur Verfügung gestellt, dass die Prävention gegen die Zeit-basierte Angriffe auch.

<?php
/*
 * Password hashing with PBKDF2.
 * Author: havoc AT defuse.ca
 * www: https://defuse.ca/php-pbkdf2.htm
 */

//These constants may be changed without breaking existing hashes.
define("PBKDF2_HASH_ALGORITHM", "sha256");
define("PBKDF2_ITERATIONS", 1000);
define("PBKDF2_SALT_BYTES", 24);
define("PBKDF2_HASH_BYTES", 24);

define("HASH_SECTIONS", 4);
define("HASH_ALGORITHM_INDEX", 0);
define("HASH_ITERATION_INDEX", 1);
define("HASH_SALT_INDEX", 2);
define("HASH_PBKDF2_INDEX", 3);

function create_hash($password)
{
    //format: algorithm:iterations:salt:hash
    $salt = base64_encode(mcrypt_create_iv(PBKDF2_SALT_BYTES, MCRYPT_DEV_URANDOM));
    return PBKDF2_HASH_ALGORITHM . ":" . PBKDF2_ITERATIONS . ":" .  $salt . ":" . 
        base64_encode(pbkdf2(
            PBKDF2_HASH_ALGORITHM,
            $password,
            $salt,
            PBKDF2_ITERATIONS,
            PBKDF2_HASH_BYTES,
            true
        ));
}

function validate_password($password, $good_hash)
{
    $params = explode(":", $good_hash);
    if(count($params) < HASH_SECTIONS)
       return false; 
    $pbkdf2 = base64_decode($params[HASH_PBKDF2_INDEX]);
    return slow_equals(
        $pbkdf2,
        pbkdf2(
            $params[HASH_ALGORITHM_INDEX],
            $password,
            $params[HASH_SALT_INDEX],
            (int)$params[HASH_ITERATION_INDEX],
            strlen($pbkdf2),
            true
        )
    );
}

//Compares two strings $a and $b in length-constant time.
function slow_equals($a, $b)
{
    $diff = strlen($a) ^ strlen($b);
    for($i = 0; $i < strlen($a) && $i < strlen($b); $i++)
    {
        $diff |= ord($a[$i]) ^ ord($b[$i]);
    }
    return $diff === 0; 
}

/*
 * PBKDF2 key derivation function as defined by RSA's PKCS #5: https://www.ietf.org/rfc/rfc2898.txt
 * $algorithm - The hash algorithm to use. Recommended: SHA256
 * $password - The password.
 * $salt - A salt that is unique to the password.
 * $count - Iteration count. Higher is better, but slower. Recommended: At least 1000.
 * $key_length - The length of the derived key in bytes.
 * $raw_output - If true, the key is returned in raw binary format. Hex encoded otherwise.
 * Returns: A $key_length-byte key derived from the password and salt.
 *
 * Test vectors can be found here: https://www.ietf.org/rfc/rfc6070.txt
 *
 * This implementation of PBKDF2 was originally created by https://defuse.ca
 * With improvements by http://www.variations-of-shadow.com
 */
function pbkdf2($algorithm, $password, $salt, $count, $key_length, $raw_output = false)
{
    $algorithm = strtolower($algorithm);
    if(!in_array($algorithm, hash_algos(), true))
        die('PBKDF2 ERROR: Invalid hash algorithm.');
    if($count <= 0 || $key_length <= 0)
        die('PBKDF2 ERROR: Invalid parameters.');

    $hash_length = strlen(hash($algorithm, "", true));
    $block_count = ceil($key_length / $hash_length);

    $output = "";
    for($i = 1; $i <= $block_count; $i++) {
        //$i encoded as 4 bytes, big endian.
        $last = $salt . pack("N", $i);
        //first iteration
        $last = $xorsum = hash_hmac($algorithm, $last, $password, true);
        //perform the other $count - 1 iterations
        for ($j = 1; $j < $count; $j++) {
            $xorsum ^= ($last = hash_hmac($algorithm, $last, $password, true));
        }
        $output .= $xorsum;
    }

    if($raw_output)
        return substr($output, 0, $key_length);
    else
        return bin2hex(substr($output, 0, $key_length));
}
?>

InformationsquelleAutor Jason OOO

Normalerweise verwende ich SHA1 und salt mit der Benutzer-ID (oder eine andere Benutzer-spezifische information), und manchmal habe ich zusätzlich, mit einem Konstanten Salz - (also ich habe 2 Teile Salz).

SHA1-ist nun auch als etwas beeinträchtigt, aber in weitaus geringerem Maße als bei MD5. Durch die Verwendung eines salt (irgendein Salz), Sie verhindert die Verwendung des generischen rainbow-table zum Angriff auf Ihren hashes (einige Leute haben auch Erfolg gehabt, mit Google als eine Art rainbow-Tabelle über die Suche nach dem hash). Ein Angreifer könnte unter Umständen erzeugen rainbow-Tabelle mit Ihrem Salz, so dass s, warum sollten Sie ein Benutzer-spezifisches Salz. So, Sie generieren eine rainbow-Tabelle für jede und jeden Datensatz in Ihrem system, nicht nur für Ihre gesamte system zu! Mit dieser Art von Salzen, sogar MD5 ist anständig zu sichern.

InformationsquelleAutor rmeador

ok
in der fitsy wir brauchen Salz
Salz muss eindeutig sein
also lassen Sie es generieren

   /**
     * Generating string
     * @param $size
     * @return string
     */
    function Uniwur_string($size){
        $text = md5(uniqid(rand(), TRUE));
        RETURN substr($text, 0, $size);
    }

außerdem benötigen wir den hash
Ich bin mit sha512
es ist die beste und es ist in php

   /**
     * Hashing string
     * @param $string
     * @return string
     */
    function hash($string){
        return hash('sha512', $string);
    }

so, jetzt können wir verwenden diese Funktionen, um den sicheren Kennwort

//generating unique password
$password = Uniwur_string(20); //or you can add manual password
//generating 32 character salt
$salt = Uniwur_string(32);
//now we can manipulate this informations

//hashin salt for safe
$hash_salt = hash($salt);
//hashing password
$hash_psw = hash($password.$hash_salt);

nun müssen wir speichern in unserer Datenbank $hash_psw Wert der variable und $salt variable

und für die Autorisierung verwenden wir dieselben Schritte...

es ist der beste Weg, um sicher unseren Kunden Passwörter...

P. s. für die letzten 2 Schritte, die Sie verwenden können, Ihren eigenen Algorithmus...
aber sicher sein, dass Sie erzeugen können, das gehashte Passwort in die Zukunft
wenn Sie brauchen, zu autorisieren Benutzer...

InformationsquelleAutor shalvasoft