Wie verschlüsseln / entschlüsseln Daten in PHP?

Vorwort

Beginnend mit dem Tabellen-definition:

- UserID
- Fname
- Lname
- Email
- Password
- IV

Hier sind die änderungen:

1. Die Felder Fname, Lname und Email werden verschlüsselt mit einem symmetrischen Schlüssel, die zur Verfügung gestellt von OpenSSL,
2. Die IV Feld speichern der Initialisierungsvektor für die Verschlüsselung verwendet. Die storage-Anforderungen sind abhängig von der Verschlüsselung und-Modus verwendet; mehr dazu später.
3. Die Password Feld wird Hash mit einem one-way - Passwort-hash,

Verschlüsselung

Cipher-Modus und

Auswahl der besten Verschlüsselungs-cipher-Modus und sprengt den Rahmen dieser Antwort, aber die endgültige Wahl beeinflusst die Größe der sowohl die Verschlüsselung, Schlüssel und Initialisierungsvektor; aus diesem post wir werden mit AES-256-CBC, die eine Feste Blockgröße von 16 bytes und einer Schlüssellänge von entweder 16, 24 oder 32 bytes.

Verschlüsselungsschlüssel

Eine gute Verschlüsselung Schlüssel ist ein binärer blob, erstellt von einem zuverlässigen Zufallszahlengenerator. Das folgende Beispiel wäre zu empfehlen (>= 5.3):

$key_size = 32; //256 bits
$encryption_key = openssl_random_pseudo_bytes($key_size, $strong);
//$strong will be true if the key is crypto safe

Diese kann getan werden, um einmal oder mehrfach (wenn Sie möchten, erstellen Sie eine Kette von Schlüsseln). Halten Sie diese so privat wie möglich.

IV

Den Initialisierungsvektor ergänzt Zufälligkeit der Verschlüsselung und benötigt für die CBC-Modus. Diese Werte sollten im Idealfall nur einmal verwendet werden (technisch einmal pro encryption key), so dass ein update auf einen beliebigen Teil einer Zeile sollte regenerieren.

Eine Funktion ist bereitgestellt, um Ihnen helfen, generieren die IV:

$iv_size = 16; //128 bits
$iv = openssl_random_pseudo_bytes($iv_size, $strong);

Beispiel

Let ' s encrypt-der name-Feld, mit dem früheren $encryption_key und $iv; um dies zu tun, müssen wir pad-unsere Daten in die block-Größe:

function pkcs7_pad($data, $size)
{
    $length = $size - strlen($data) % $size;
    return $data . str_repeat(chr($length), $length);
}

$name = 'Jack';
$enc_name = openssl_encrypt(
    pkcs7_pad($name, 16), //padded data
    'AES-256-CBC',        //cipher and mode
    $encryption_key,      //secret key
    0,                    //options (not used)
    $iv                   //initialisation vector
);

Storage-Anforderungen

Die verschlüsselte Ausgabe, wie die IV, ist Binär, das speichern dieser Werte in einer Datenbank kann erreicht werden, indem die benannten Spalte Typen wie BINARY oder VARBINARY.

Den Ausgang Wert, wie die IV, ist binary; zum speichern dieser Werte in MySQL, sollten Sie die Verwendung BINARY oder VARBINARY Spalten. Ist dies nicht eine option, können Sie auch konvertieren Sie die binäre Daten in eine textuelle Darstellung mit base64_encode() oder bin2hex(), dies erfordert, dass zwischen 33% bis 100% mehr Speicherplatz.

Entschlüsselung

Entschlüsselung der gespeicherten Werte ist ähnlich:

function pkcs7_unpad($data)
{
    return substr($data, 0, -ord($data[strlen($data) - 1]));
}

$row = $result->fetch(PDO::FETCH_ASSOC); //read from database result
//$enc_name = base64_decode($row['Name']);
//$enc_name = hex2bin($row['Name']);
$enc_name = $row['Name'];
//$iv = base64_decode($row['IV']);
//$iv = hex2bin($row['IV']);
$iv = $row['IV'];

$name = pkcs7_unpad(openssl_decrypt(
    $enc_name,
    'AES-256-CBC',
    $encryption_key,
    0,
    $iv
));

Authentifizierte Verschlüsselung

Können Sie weitere Verbesserung der Integrität der erzeugten verschlüsselten text durch Anhängen einer Signatur, erzeugt aus einem geheimen Schlüssel (unterscheidet sich von der encryption key) und der cipher text. Vor dem verschlüsselten text entschlüsselt, die Signatur wird zunächst überprüft (am besten mit einem konstant-Zeit-Vergleich-Methode).

Beispiel

//generate once, keep safe
$auth_key = openssl_random_pseudo_bytes(32, $strong);

//authentication
$auth = hash_hmac('sha256', $enc_name, $auth_key, true);
$auth_enc_name = $auth . $enc_name;

//verification
$auth = substr($auth_enc_name, 0, 32);
$enc_name = substr($auth_enc_name, 32);
$actual_auth = hash_hmac('sha256', $enc_name, $auth_key, true);

if (hash_equals($auth, $actual_auth)) {
    //perform decryption
}

Siehe auch: hash_equals()

Hashing

Speichern eine reversible Passwort in der Datenbank muss so weit wie möglich vermieden werden; Sie wollen nur überprüfen Sie das Kennwort, eher als zu wissen, seinen Inhalt. Wenn ein Benutzer verliert Ihr Passwort, ist es besser, Ihnen zu erlauben, setzen Sie es vielmehr als das senden Sie Ihr original ein (stellen Sie sicher, dass der Passwort-reset kann nur durchgeführt werden, für eine begrenzte Zeit).

Anwenden einer hash-Funktion ist eine one-way-operation; danach kann es sicher verwendet werden, die für die überprüfung grundsätzlich ohne Offenlegung der ursprünglichen Daten; für Kennworte, ein brute-force-Methode ist ein möglicher Ansatz, um aufzudecken, die es aufgrund seiner relativ kurzen Länge und Armen Kennwort Entscheidungen vieler Menschen.

Hashing algorithmen wie MD5 oder SHA1 vorgenommen wurden, überprüfen Sie den Inhalt der Datei mit einem bekannten hash-Wert. Sie sind stark optimiert, um diese überprüfung so schnell wie möglich, während immer noch genau sind. Angesichts Ihrer relativ begrenzten output-Raum, war es einfach, bauen Sie eine Datenbank mit bekannten Passwörtern und Ihren jeweiligen hash-Ausgänge, die rainbow-Tabellen.

Hinzufügen von Salz, um das Passwort vor dem Hashen machen würde eine rainbow-table-nutzlos, aber neuere hardware Fortschritte gemacht, brute-force-lookups ein brauchbarer Ansatz. Deshalb brauchen Sie einen hashing-Algorithmus, die bewusst langsam und einfach unmöglich zu optimieren. Es sollte auch in der Lage sein, um die Last zu erhöhen, die für schnellere hardware, ohne die Möglichkeit zu überprüfen, bestehende Passwort-hashes zu machen es zukunftssicher.

Derzeit gibt es zwei beliebte Möglichkeiten zur Verfügung:

1. PBKDF2 (Password Based Key Derivation Funktion v2)
2. bcrypt (aka Blowfish)

Diese Antwort wird ein Beispiel mit bcrypt.

Generation

Einen Passwort-hash erzeugt werden kann, wie diese:

$password = 'my password';
$random = openssl_random_pseudo_bytes(18);
$salt = sprintf('$2y$%02d$%s',
    13, //2^n cost factor
    substr(strtr(base64_encode($random), '+', '.'), 0, 22)
);

$hash = crypt($password, $salt);

Den salt generiert wird, mit openssl_random_pseudo_bytes(), um die form eines random-blob von Daten, welche dann durch base64_encode() und strtr() angepasst alphabet [A-Za-z0-9/.].

Den crypt() Funktion führt die hashing basiert auf dem Algorithmus ($2y$ für Blowfish), die Kosten-Faktor (Faktor 13 dauert etwa 0.40 s auf einer 3GHz-Maschine) und das Salz von 22 Zeichen.

Validierung

Sobald Sie abgerufen haben, die Zeile, in der der Benutzer Informationen, überprüfen Sie das Kennwort in dieser Art und Weise:

$given_password = $_POST['password']; //the submitted password
$db_hash = $row['Password']; //field with the password hash

$given_hash = crypt($given_password, $db_hash);

if (isEqual($given_hash, $db_hash)) {
    //user password verified
}

//constant time string compare
function isEqual($str1, $str2)
{
    $n1 = strlen($str1);
    if (strlen($str2) != $n1) {
        return false;
    }
    for ($i = 0, $diff = 0; $i != $n1; ++$i) {
        $diff |= ord($str1[$i]) ^ ord($str2[$i]);
    }
    return !$diff;
}

Überprüfen Sie ein Kennwort, rufen Sie crypt() wieder, aber Sie pass des zuvor berechneten hash, als der salt-Wert. Der Rückgabewert ergibt den gleichen hash, wenn das angegebene Passwort passt der hash. Zum überprüfen des hash, ist es oft empfehlenswert, eine konstant-Zeit-Vergleich-Funktion zu vermeiden-timing-Angriffe schützt.

Passwort-hashing mit PHP 5.5

PHP 5.5 eingeführt, die Passwort-hashing-Funktionen, die Sie verwenden können, um die Vereinfachung der oben genannten Methode hashing:

$hash = password_hash($password, PASSWORD_BCRYPT, ['cost' => 13]);

Überprüfen und sicherstellen:

if (password_verify($given_password, $db_hash)) {
    //password valid
}

Siehe auch: password_hash(), password_verify()

InformationsquelleAutor der Antwort Ja͢ck

Antwort Hintergrund und Erklärung

, Diese Frage zu verstehen, müssen Sie zuerst verstehen, was SHA256 ist. SHA256 ist eine Kryptographische Hash-Funktion. Eine Kryptographische Hash-Funktion ist eine one-way-Funktion, deren Ausgabe ist kryptographisch sicher. Dies bedeutet, es ist leicht zu berechnen ist ein hash (äquivalent zur Verschlüsselung von Daten), aber schwer zu bekommen die original-Eingabe mit der Raute (äquivalent zum entschlüsseln der Daten). Da unter Verwendung einer Kryptographischen hash-Funktion entschlüsseln ist rechnerisch unmöglich, deshalb können Sie nicht führen Sie die Entschlüsselung mit SHA256.

Was Sie verwenden möchten, ist ein zwei-Wege-Funktion, sondern eher speziell, ein Block Cipher. Eine Funktion, die es ermöglicht sowohl die Verschlüsselung und Entschlüsselung von Daten. Die Funktionen mcrypt_encrypt und mcrypt_decrypt standardmäßig verwendet den Blowfish-Algorithmus. PHP ist die Verwendung von mcrypt kann man in diesem Handbuch. Eine Liste der Chiffre Definitionen wählen Sie die Chiffre-mcrypt verwendet besteht auch. Ein wiki von Blowfish finden Sie unter Wikipedia. Eine Blockchiffre verschlüsselt die Eingabe in Blöcke der bekannten Größe und die position mit einem bekannten Schlüssel, so dass die Daten können später entschlüsselt werden, die mit dem Schlüssel. Dies ist, was SHA256 nicht Ihnen zur Verfügung stellen.

Code

$key = 'ThisIsTheCipherKey';

$ciphertext = mcrypt_encrypt(MCRYPT_BLOWFISH, $key, 'This is plaintext.', MCRYPT_MODE_CFB);

$plaintext = mcrypt_decrypt(MCRYPT_BLOWFISH, $key, $encrypted, MCRYPT_MODE_CFB);

InformationsquelleAutor der Antwort cytinus

Es dauerte eine ganze Weile, um herauszufinden, wie Sie sich nicht eine false bei der Verwendung openssl_decrypt() und bekommen ver-und entschlüsseln funktioniert.

    //cryptographic key of a binary string 16 bytes long (because AES-128 has a key size of 16 bytes)
    $encryption_key = '58adf8c78efef9570c447295008e2e6e'; //example
    $iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length('aes-256-cbc'));
    $encrypted = openssl_encrypt($plaintext, 'aes-256-cbc', $encryption_key, OPENSSL_RAW_DATA, $iv);
    $encrypted = $encrypted . ':' . base64_encode($iv);

    //decrypt to get again $plaintext
    $parts = explode(':', $encrypted);
    $decrypted = openssl_decrypt($parts[0], 'aes-256-cbc', $encryption_key, OPENSSL_RAW_DATA, base64_decode($parts[1])); 

Wenn Sie übergeben möchten, die verschlüsselte Zeichenfolge über eine URL, die Sie benötigen, um die Zeichenfolge urlencode:

    $encrypted = urlencode($encrypted);

Besser zu verstehen, was Los ist, Lesen:

• http://blog.turret.io/the-missing-php-aes-encryption-example/
• http://thefsb.tumblr.com/post/110749271235/using-opensslendecrypt-in-php-

Generieren, die 16 Byte lange Schlüssel, die Sie verwenden können:

    $bytes = openssl_random_pseudo_bytes(16);
    $hex = bin2hex($bytes);

Sehen Fehlermeldungen von openssl, die Sie verwenden können: echo openssl_error_string();

Hoffe, das hilft.

InformationsquelleAutor der Antwort Kai Noack