password_bcrypt - php secure hash




Zwei-Wege-Verschlüsselung: Ich muss Passwörter speichern, die abgerufen werden können (6)

Die Passwörter sind für ein Hardwaregerät, so dass eine Überprüfung gegen Hashes nicht in Frage kommt

Eh? Ich verstehe nicht. Meinst du nur, dass das Passwort wiederherstellbar sein muss?

Wie andere bereits gesagt haben, bietet die Mcrypt-Erweiterung Zugriff auf viele kryptografische Funktionen - Sie fordern jedoch Ihre Benutzer auf, alle ihre Eizellen in einen Korb zu legen - einen, der potentiell ein Angriffsziel für Angreifer sein könnte - und wenn Sie es nicht einmal wissen Wie man anfängt, das Problem zu lösen, dann tun Sie Ihren Benutzern einen schlechten Dienst. Sie sind nicht in der Lage zu verstehen, wie Sie die Daten schützen.

Die meisten Sicherheitslücken entstehen nicht, weil der zugrundeliegende Algorithmus fehlerhaft oder unsicher ist - sondern aufgrund von Problemen mit der Art und Weise, wie der Algorithmus innerhalb des Anwendungscodes verwendet wird.

Dennoch ist es möglich , ein einigermaßen sicheres System aufzubauen.

Sie sollten die asymmetrische Verschlüsselung nur in Betracht ziehen, wenn Sie die Anforderung haben, dass ein Benutzer eine sichere Nachricht erstellt, die von einem anderen (bestimmten) Benutzer gelesen werden kann. Der Grund dafür ist, dass es rechenintensiv ist. Wenn Sie nur ein Repository für Benutzer bereitstellen möchten, um eigene Daten einzugeben und abzurufen, ist eine symmetrische Verschlüsselung ausreichend.

Wenn Sie jedoch den Schlüssel zum Entschlüsseln der Nachricht an der gleichen Stelle wie die verschlüsselte Nachricht (oder wo die verschlüsselte Nachricht gespeichert ist) speichern, ist das System nicht sicher. Verwenden Sie dasselbe Token für die Authentifizierung des Benutzers wie für den Entschlüsselungsschlüssel (oder verwenden Sie im Fall der asymmetrischen Verschlüsselung das Token als Passphrase für den privaten Schlüssel). Da Sie das Token mindestens temporär auf dem Server speichern müssen, auf dem die Entschlüsselung stattfindet, sollten Sie in Erwägung ziehen, ein nicht durchsuchbares Sitzungsspeichersubstrat zu verwenden oder das Token direkt an einen Daemon weiterzuleiten, der der Sitzung zugeordnet ist Token im Speicher und führen die Entschlüsselung von Nachrichten bei Bedarf durch.

Ich erstelle eine Anwendung, die Passwörter speichert, die der Benutzer abrufen und sehen kann. Die Passwörter sind für ein Hardwaregerät, so dass eine Überprüfung gegen Hashes nicht in Frage kommt.

Was ich wissen muss ist:

  1. Wie kann ich ein Passwort in PHP verschlüsseln und entschlüsseln?

  2. Was ist der sicherste Algorithmus zum Verschlüsseln der Passwörter?

  3. Wo kann ich den privaten Schlüssel speichern?

  4. Anstatt den privaten Schlüssel zu speichern, ist es eine gute Idee, dass Benutzer den privaten Schlüssel jedes Mal eingeben müssen, wenn sie ein entschlüsseltes Passwort benötigen? (Benutzern dieser Anwendung kann vertraut werden)

  5. Wie kann das Passwort gestohlen und entschlüsselt werden? Worauf muss ich achten?


  1. Die PHP-Funktion, nach der Sie suchen, ist Mcrypt ( http://www.php.net/manual/en/intro.mcrypt.php ).

Das Beispiel aus dem Handbuch ist für dieses Beispiel leicht bearbeitet):

<?php
$iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_ECB);
$iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
$key = "This is a very secret key";
$pass = "PasswordHere";
echo strlen($pass) . "\n";

$crypttext = mcrypt_encrypt(MCRYPT_BLOWFISH, $key, $pass, MCRYPT_MODE_ECB, $iv);
echo strlen($crypttext) . "\n";
?>

Sie würden mcrypt_decrypt , um Ihr Passwort zu entschlüsseln.

  1. Der beste algorithm ist eher subjektiv - frage 5 Leute, bekomme 5 Antworten. Persönlich, wenn der Standard (Blowfish) nicht gut genug für Sie ist, haben Sie wahrscheinlich größere Probleme!

  2. Angesichts der Tatsache, dass es von PHP benötigt wird, um zu verschlüsseln - nicht sicher, dass Sie es überall verstecken können - begrüßen Kommentare dazu. Es gelten natürlich die besten Programmierpraktiken von PHP!

  3. Vorausgesetzt, dass der Verschlüsselungsschlüssel in Ihrem Code vorhanden ist, ist nicht sicher, was Sie gewinnen werden, vorausgesetzt, der Rest Ihrer Anwendung ist sicher.

  4. Offensichtlich, wenn das verschlüsselte Passwort und der Verschlüsselungsschlüssel gestohlen werden, dann ist das Spiel vorbei.

Ich würde eine Antwort auf meine Antwort geben - ich bin kein PHP-Krypto-Experte, aber ich denke, was ich beantwortet habe, ist Standard-Praxis - ich begrüße Kommentare, die andere möglicherweise haben.


Ich würde nur die Verschlüsselung mit öffentlichem Schlüssel vorschlagen, wenn Sie die Möglichkeit haben möchten, das Passwort eines Benutzers ohne deren Interaktion zu setzen (dies kann für Resets und freigegebene Passwörter nützlich sein).

Öffentlicher Schlüssel

  1. Die OpenSSL Erweiterung, insbesondere openssl_public_encrypt und openssl_private_decrypt
  2. Dies wäre eine direkte RSA, vorausgesetzt, dass Ihre Passwörter in die Schlüsselgröße padding passen, andernfalls benötigen Sie eine symmetrische Ebene
  3. Speichern Sie beide Schlüssel für jeden Benutzer, die Passphrase des privaten Schlüssels ist ihr Anwendungspasswort

Symmetrisch

  1. Die Mcrypt Erweiterung
  2. AES-256 ist wahrscheinlich eine sichere Wette, aber das könnte eine SO-Frage für sich sein
  3. Sie nicht - das wäre ihr Anwendungspasswort

Beide

4 . Ja - Benutzer müssen jedes Mal ihr Anwendungskennwort eingeben, aber wenn sie in der Sitzung gespeichert werden, treten andere Probleme auf

5 .

  • Wenn jemand die Anwendungsdaten stiehlt, ist es genauso sicher wie die symmetrische Chiffre (für das öffentliche Schlüsselschema wird es verwendet, um den privaten Schlüssel mit der Passphrase zu schützen.)
  • Ihre Anwendung sollte auf jeden Fall nur über SSL zugänglich sein, vorzugsweise unter Verwendung von Client-Zertifikaten.
  • Erwägen Sie, einen zweiten Faktor für die Authentifizierung hinzuzufügen, der nur einmal pro Sitzung verwendet wird, z. B. ein Token, das per SMS gesendet wird.

Verwenden Sie password_hash und password_verify

<?php
/**
 * In this case, we want to increase the default cost for BCRYPT to 12.
 * Note that we also switched to BCRYPT, which will always be 60 characters.
 */
$options = [
    'cost' => 12,
];
echo password_hash("rasmuslerdorf", PASSWORD_BCRYPT, $options)."\n";
?>

Und um zu entschlüsseln:

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

Wie kann ich ein Passwort in PHP verschlüsseln und entschlüsseln? Durch die Implementierung eines von vielen Verschlüsselungsalgorithmen. (oder mit einer von vielen Bibliotheken)

Was ist der sicherste Algorithmus zum Verschlüsseln der Passwörter? Es gibt Tonnen von verschiedenen Algorithmen, von denen keiner 100% sicher ist. Aber viele von ihnen sind sicher genug für Handel und sogar militärische Zwecke

Wo kann ich den privaten Schlüssel speichern? Wenn Sie sich entschieden haben, einen öffentlichen Schlüssel - Kryptografiealgorithmus (z. B. RSA) zu implementieren, speichern Sie keinen privaten Schlüssel. Benutzer haben einen privaten Schlüssel. Ihr System verfügt über einen öffentlichen Schlüssel, der beliebig gespeichert werden kann.

Anstatt den privaten Schlüssel zu speichern, ist es eine gute Idee, dass Benutzer den privaten Schlüssel jedes Mal eingeben müssen, wenn sie ein entschlüsseltes Passwort benötigen? (Benutzern dieser Anwendung kann vertraut werden) Nun, wenn Ihr Benutzer sich an lächerlich lange Primzahlen erinnern kann, dann - ja, warum nicht. Aber im Allgemeinen müssen Sie das System entwickeln, das es dem Benutzer ermöglicht, seinen Schlüssel irgendwo zu speichern.

Wie kann das Passwort gestohlen und entschlüsselt werden? Worauf muss ich achten? Dies hängt vom verwendeten Algorithmus ab. Stellen Sie jedoch immer sicher, dass Sie das Passwort nicht unverschlüsselt an den oder vom Benutzer senden. Entweder verschlüsseln / entschlüsseln Sie es auf der Client-Seite, oder verwenden Sie https (oder andere kryptografische Mittel des Benutzers, um die Verbindung zwischen Server und Client zu sichern).

Wenn Sie jedoch lediglich Kennwörter verschlüsselt speichern müssen, würde ich Ihnen einen einfachen XOR-Chiffrierschlüssel empfehlen. Das Hauptproblem dieses Algorithmus besteht darin, dass er leicht durch Frequenzanalyse gebrochen werden kann. Da jedoch im Allgemeinen keine Passwörter aus langen Absätzen von englischem Text bestehen, denke ich nicht, dass Sie sich darüber Gedanken machen sollten. Das zweite Problem mit XOR Cipher besteht darin, dass Sie, wenn Sie eine Nachricht in verschlüsselter und entschlüsselter Form haben, leicht herausfinden können, mit welchem ​​Passwort sie verschlüsselt wurde. Auch dies ist in Ihrem Fall kein großes Problem, da es nur den Benutzer betrifft, der bereits auf andere Weise kompromittiert wurde.


Persönlich würde ich mcrypt wie andere mcrypt . Aber es gibt viel mehr zu beachten ...

  1. Wie kann ich ein Passwort in PHP verschlüsseln und entschlüsseln?

    Siehe unten für eine starke Klasse, die sich um alles kümmert:

  2. Was ist der sicherste Algorithmus zum Verschlüsseln der Passwörter?

    sicherste ? jeder von ihnen. Die sicherste Methode zum Verschlüsseln ist der Schutz vor Sicherheitslücken bei der Offenlegung von Informationen (XSS, Remote Inclusion usw.). Wenn es herauskommt, kann der Angreifer schließlich die Verschlüsselung knacken (keine Verschlüsselung ist ohne den Schlüssel 100% reversibel) - Wie @NullUserException darauf hinweist, ist dies nicht ganz richtig. Es gibt einige Verschlüsselungsschemata, die unmöglich zu knacken sind, wie OneTimePad ) .

  3. Wo kann ich den privaten Schlüssel speichern?

    Was ich tun würde, ist 3 Schlüssel zu benutzen. Eins wird vom Benutzer bereitgestellt, eines ist anwendungsspezifisch und das andere ist benutzerspezifisch (wie ein Salz). Der anwendungsspezifische Schlüssel kann überall gespeichert werden (in einer Konfigurationsdatei außerhalb des Webstamms, in einer Umgebungsvariablen usw.). Der benutzerspezifische würde in einer Spalte in der Datenbank neben dem verschlüsselten Passwort gespeichert werden. Der Benutzer, der geliefert wurde, würde nicht gespeichert werden. Dann würden Sie so etwas tun:

    $key = $userKey . $serverKey . $userSuppliedKey;
    

    Der Vorteil besteht darin, dass zwei der Schlüssel kompromittiert werden können, ohne dass die Daten kompromittiert werden. Wenn es einen SQL-Injection-Angriff gibt, können sie den $userKey , aber nicht den anderen. Wenn es einen lokalen Server-Exploit gibt, können sie $userKey und $serverKey , aber nicht den dritten $userSuppliedKey . Wenn sie den Benutzer mit einem Schraubenschlüssel schlagen, können sie den $userSuppliedKey , aber nicht die anderen 2 (aber andererseits, wenn der Benutzer mit einem Schraubenschlüssel geschlagen wird, bist du ohnehin zu spät).

  4. Anstatt den privaten Schlüssel zu speichern, ist es eine gute Idee, dass Benutzer den privaten Schlüssel jedes Mal eingeben müssen, wenn sie ein entschlüsseltes Passwort benötigen? (Benutzern dieser Anwendung kann vertraut werden)

    Absolut. In der Tat, das ist die einzige Art, wie ich es tun würde. Andernfalls müssten Sie eine unverschlüsselte Version in einem dauerhaften Speicherformat speichern (Shared Memory wie APC oder Memcached oder in einer Sitzungsdatei). Das setzt dich zusätzlichen Kompromissen aus. Speichern Sie die unverschlüsselte Version des Kennworts niemals in einer anderen als einer lokalen Variablen.

  5. Wie kann das Passwort gestohlen und entschlüsselt werden? Worauf muss ich achten?

    Jede Form der Kompromittierung Ihrer Systeme lässt sie verschlüsselte Daten anzeigen. Wenn sie Code injizieren oder in Ihr Dateisystem gelangen können, können sie entschlüsselte Daten anzeigen (da sie die Dateien bearbeiten können, die die Daten entschlüsseln). Jede Art von Replay- oder MITM-Angriffen gibt ihnen auch vollen Zugriff auf die beteiligten Schlüssel. Beim Sniffing des unformatierten HTTP-Datenverkehrs erhalten Sie auch die Schlüssel.

    Verwenden Sie SSL für den gesamten Datenverkehr. Und stellen Sie sicher, dass auf dem Server keine Sicherheitslücken vorhanden sind (CSRF, XSS, SQL Injection, Berechtigungseskalation, Remotecodeausführung usw.).

Edit: Hier ist eine PHP-Klassenimplementierung einer starken Verschlüsselungsmethode:

/**
 * A class to handle secure encryption and decryption of arbitrary data
 *
 * Note that this is not just straight encryption.  It also has a few other
 *  features in it to make the encrypted data far more secure.  Note that any
 *  other implementations used to decrypt data will have to do the same exact
 *  operations.  
 *
 * Security Benefits:
 *
 * - Uses Key stretching
 * - Hides the Initialization Vector
 * - Does HMAC verification of source data
 *
 */
class Encryption {

    /**
     * @var string $cipher The mcrypt cipher to use for this instance
     */
    protected $cipher = '';

    /**
     * @var int $mode The mcrypt cipher mode to use
     */
    protected $mode = '';

    /**
     * @var int $rounds The number of rounds to feed into PBKDF2 for key generation
     */
    protected $rounds = 100;

    /**
     * Constructor!
     *
     * @param string $cipher The MCRYPT_* cypher to use for this instance
     * @param int    $mode   The MCRYPT_MODE_* mode to use for this instance
     * @param int    $rounds The number of PBKDF2 rounds to do on the key
     */
    public function __construct($cipher, $mode, $rounds = 100) {
        $this->cipher = $cipher;
        $this->mode = $mode;
        $this->rounds = (int) $rounds;
    }

    /**
     * Decrypt the data with the provided key
     *
     * @param string $data The encrypted datat to decrypt
     * @param string $key  The key to use for decryption
     * 
     * @returns string|false The returned string if decryption is successful
     *                           false if it is not
     */
    public function decrypt($data, $key) {
        $salt = substr($data, 0, 128);
        $enc = substr($data, 128, -64);
        $mac = substr($data, -64);

        list ($cipherKey, $macKey, $iv) = $this->getKeys($salt, $key);

        if (!hash_equals(hash_hmac('sha512', $enc, $macKey, true), $mac)) {
             return false;
        }

        $dec = mcrypt_decrypt($this->cipher, $cipherKey, $enc, $this->mode, $iv);

        $data = $this->unpad($dec);

        return $data;
    }

    /**
     * Encrypt the supplied data using the supplied key
     * 
     * @param string $data The data to encrypt
     * @param string $key  The key to encrypt with
     *
     * @returns string The encrypted data
     */
    public function encrypt($data, $key) {
        $salt = mcrypt_create_iv(128, MCRYPT_DEV_URANDOM);
        list ($cipherKey, $macKey, $iv) = $this->getKeys($salt, $key);

        $data = $this->pad($data);

        $enc = mcrypt_encrypt($this->cipher, $cipherKey, $data, $this->mode, $iv);

        $mac = hash_hmac('sha512', $enc, $macKey, true);
        return $salt . $enc . $mac;
    }

    /**
     * Generates a set of keys given a random salt and a master key
     *
     * @param string $salt A random string to change the keys each encryption
     * @param string $key  The supplied key to encrypt with
     *
     * @returns array An array of keys (a cipher key, a mac key, and a IV)
     */
    protected function getKeys($salt, $key) {
        $ivSize = mcrypt_get_iv_size($this->cipher, $this->mode);
        $keySize = mcrypt_get_key_size($this->cipher, $this->mode);
        $length = 2 * $keySize + $ivSize;

        $key = $this->pbkdf2('sha512', $key, $salt, $this->rounds, $length);

        $cipherKey = substr($key, 0, $keySize);
        $macKey = substr($key, $keySize, $keySize);
        $iv = substr($key, 2 * $keySize);
        return array($cipherKey, $macKey, $iv);
    }

    /**
     * Stretch the key using the PBKDF2 algorithm
     *
     * @see http://en.wikipedia.org/wiki/PBKDF2
     *
     * @param string $algo   The algorithm to use
     * @param string $key    The key to stretch
     * @param string $salt   A random salt
     * @param int    $rounds The number of rounds to derive
     * @param int    $length The length of the output key
     *
     * @returns string The derived key.
     */
    protected function pbkdf2($algo, $key, $salt, $rounds, $length) {
        $size   = strlen(hash($algo, '', true));
        $len    = ceil($length / $size);
        $result = '';
        for ($i = 1; $i <= $len; $i++) {
            $tmp = hash_hmac($algo, $salt . pack('N', $i), $key, true);
            $res = $tmp;
            for ($j = 1; $j < $rounds; $j++) {
                 $tmp  = hash_hmac($algo, $tmp, $key, true);
                 $res ^= $tmp;
            }
            $result .= $res;
        }
        return substr($result, 0, $length);
    }

    protected function pad($data) {
        $length = mcrypt_get_block_size($this->cipher, $this->mode);
        $padAmount = $length - strlen($data) % $length;
        if ($padAmount == 0) {
            $padAmount = $length;
        }
        return $data . str_repeat(chr($padAmount), $padAmount);
    }

    protected function unpad($data) {
        $length = mcrypt_get_block_size($this->cipher, $this->mode);
        $last = ord($data[strlen($data) - 1]);
        if ($last > $length) return false;
        if (substr($data, -1 * $last) !== str_repeat(chr($last), $last)) {
            return false;
        }
        return substr($data, 0, -1 * $last);
    }
}

Beachten Sie, dass ich eine in PHP 5.6 hinzugefügte Funktion verwende: hash_equals . Wenn Sie unter 5,6 sind, können Sie diese Ersatzfunktion verwenden, die eine zeitsparende Vergleichsfunktion mit doppelter HMAC-Verifikation implementiert:

function hash_equals($a, $b) {
    $key = mcrypt_create_iv(128, MCRYPT_DEV_URANDOM);
    return hash_hmac('sha512', $a, $key) === hash_hmac('sha512', $b, $key);
}

Verwendung:

$e = new Encryption(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
$encryptedData = $e->encrypt($data, $key);

Dann, um zu entschlüsseln:

$e2 = new Encryption(MCRYPT_BLOWFISH, MCRYPT_MODE_CBC);
$data = $e2->decrypt($encryptedData, $key);

Beachten Sie, dass ich $e2 das zweite Mal verwendet habe, um zu zeigen, dass verschiedene Instanzen die Daten immer noch korrekt entschlüsseln.

Nun, wie funktioniert es / warum verwenden Sie es gegenüber einer anderen Lösung:

  1. Schlüssel

    • Die Schlüssel werden nicht direkt verwendet. Stattdessen wird der Schlüssel durch eine Standard-PBKDF2-Ableitung gestreckt.

    • Der für die Verschlüsselung verwendete Schlüssel ist für jeden verschlüsselten Textblock eindeutig. Der mitgelieferte Schlüssel wird somit zum "Hauptschlüssel". Diese Klasse stellt daher eine Schlüsselrotation für Chiffrierschlüssel und Authentifizierungsschlüssel bereit.

    • WICHTIGER HINWEIS , der Parameter $rounds ist für echte zufällige Schlüssel mit ausreichender Stärke konfiguriert (mindestens 128 Bit Cryptographically Secure zufällig). Wenn Sie ein Passwort oder einen nicht zufälligen Schlüssel (oder weniger zufällig als 128 Bit CS zufällig) verwenden, müssen Sie diesen Parameter erhöhen. Ich würde ein Minimum von 10000 für Passwörter vorschlagen (je mehr Sie sich leisten können, desto besser, aber es wird zur Laufzeit hinzufügen) ...

  2. Datenintegrität

    • Die aktualisierte Version verwendet ENCRYPT-THEN-MAC, eine weitaus bessere Methode, um die Authentizität der verschlüsselten Daten zu gewährleisten.
  3. Verschlüsselung:

    • Es verwendet mcrypt, um die Verschlüsselung tatsächlich durchzuführen. Ich würde empfehlen, entweder MCRYPT_BLOWFISH oder MCRYPT_RIJNDAEL_128 cyphers und MCRYPT_MODE_CBC für den Modus zu verwenden. Es ist stark genug und immer noch ziemlich schnell (ein Verschlüsselungs- und Entschlüsselungszyklus dauert ungefähr 1/2 Sekunde auf meinem Rechner).

Nun, was Punkt 3 von der ersten Liste betrifft, was das für Sie bedeuten würde, ist eine Funktion wie diese:

function makeKey($userKey, $serverKey, $userSuppliedKey) {
    $key = hash_hmac('sha512', $userKey, $serverKey);
    $key = hash_hmac('sha512', $key, $userSuppliedKey);
    return $key;
}

Du makeKey() es in der makeKey() -Funktion makeKey() , aber da es später gestreckt wird, gibt es nicht wirklich einen großen Punkt dafür.

Was die Speichergröße betrifft, kommt es auf den Klartext an. Blowfish verwendet eine Blockgröße von 8 Byte. Sie haben also:

  • 16 Bytes für das Salz
  • 64 Bytes für den hmac
  • Datenlänge
  • Auffüllen mit Datenlänge% 8 == 0

Für eine 16-stellige Datenquelle werden daher 16 Zeichen Daten verschlüsselt. Das bedeutet, dass die tatsächliche Größe der verschlüsselten Daten 16 Byte beträgt. Fügen Sie dann die 16 Bytes für das Salz und 64 Bytes für das hmac hinzu, und die gesamte gespeicherte Größe beträgt 96 Bytes. Also gibt es bestenfalls einen 80 Zeichen Overhead und im schlimmsten Fall einen 87 Zeichen Overhead ...

Ich hoffe das hilft...

Hinweis: 12/11/12: Ich habe diese Klasse gerade mit einer VIELEN besseren Verschlüsselungsmethode aktualisiert, indem ich bessere abgeleitete Schlüssel verwendet habe und die MAC-Generation repariert habe ...





passwords