php password - Zwei-Wege-Verschlüsselung:Ich muss Passwörter speichern, die abgerufen werden können




encryption hash (8)

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

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?


Viele Benutzer haben vorgeschlagen, mcrypt zu verwenden ... was richtig ist, aber ich gehe gerne einen Schritt weiter, um es leicht zu speichern und zu übertragen (da manchmal verschlüsselte Werte es schwierig machen, sie mit anderen Technologien wie curl oder json zu senden) .

Nachdem Sie erfolgreich mit mcrypt verschlüsselt haben, führen Sie es über base64_encode aus und wandeln es anschließend in Hexcode um. Einmal im Hex-Code ist es einfach, auf verschiedene Arten zu übertragen.

$td = mcrypt_module_open('tripledes', '', 'ecb', '');
$iv = mcrypt_create_iv (mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
$key = substr("SUPERSECRETKEY",0,mcrypt_enc_get_key_size($td));
mcrypt_generic_init($td, $key, $iv);
$encrypted = mcrypt_generic($td, $unencrypted);
$encrypted = $ua."||||".$iv;
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
$encrypted = base64_encode($encrypted);
$encrypted = array_shift(unpack('H*', $encrypted));

Und auf der anderen Seite:

$encrypted = pack('H*', $encrypted);
$encrypted = base64_decode($encrypted);
list($encrypted,$iv) = explode("||||",$encrypted,2);
$td = mcrypt_module_open('tripledes', '', 'ecb', '');
$key = substr("SUPERSECRETKEY",0,mcrypt_enc_get_key_size($td));
mcrypt_generic_init($td, $key, $iv);
$unencrypted = mdecrypt_generic($td, $encrypted);
mcrypt_generic_deinit($td);
mcrypt_module_close($td);

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.


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

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.

Ich habe so etwas probiert, aber bitte beachte, dass ich weder Kryptograf bin, noch php Kenntnisse über php oder irgendeine php Programmiersprache habe. Es ist nur eine Idee. Meine Idee ist es, key in einer Datei oder database zu speichern (oder manuell eingeben), die (Lage) nicht leicht vorhergesagt werden kann (und natürlich wird alles irgendwann entschlüsselt werden, das Konzept ist die Entschlüsselungszeit zu verlängern) und vertrauliche Informationen verschlüsseln.

$iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH , MCRYPT_MODE_ECB);
$iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
$key = "evenifyouaccessmydatabaseyouwillneverfindmyemail";
$text = "[email protected]";
echo "Key : ".$key."<br/>";
echo "Text : ".$text . "<br/>";
echo "Md5 : ".md5($text). "<br/>";
echo "Sha1 : ".sha1($text). "<br/>";



$crypttext = mcrypt_encrypt(MCRYPT_BLOWFISH , $key, $text, MCRYPT_MODE_ECB, $iv);
echo "Crypted Data : ".$crypttext."<br>";

$base64 = base64_encode($crypttext);
echo "Encoded Data : ".$base64."<br/>";
$decode =  base64_decode($base64);


$decryptdata = mcrypt_decrypt(MCRYPT_BLOWFISH , $key, $crypttext, MCRYPT_MODE_ECB, $iv);

echo "Decoded Data : ".ereg_replace("?", null ,  $decryptdata); 
//event if i add '?' to the sting to the text it works, I don't know why.

Bitte beachten Sie, dass es sich nur um ein Konzept handelt. Jede Verbesserung dieses Codes wäre sehr bemerkenswert.


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.


Hintergrund Sie müssen nie ... wirklich ... das Passwort des Benutzers kennen. Sie möchten nur überprüfen, ob ein eingehender Benutzer das Passwort für ein Konto kennt.

Hash It: Speichere Benutzer-Passwörter hashed (Einweg-Verschlüsselung) über eine starke Hash-Funktion. Eine Suche nach "c # encrypt passwords" liefert eine Menge Beispiele.

Sehen Sie sich den Online-SHA1-Hash-Ersteller an, um eine Vorstellung davon zu bekommen, was eine Hash-Funktion erzeugt (aber verwenden Sie nicht SHA1 als Hash-Funktion, sondern etwas Stärkeres wie SHA256).

Ein Hash-Passwort bedeutet nun, dass Sie (und Datendiebe) nicht in der Lage sein sollten, diesen Hash wieder in das ursprüngliche Passwort umzukehren.

Wie man es benutzt: Aber, sagen Sie, wie verwende ich dieses in der Datenbank gespeicherte Passwort?

Wenn sich der Benutzer anmeldet, gibt er Ihnen den Benutzernamen und das Passwort (im ursprünglichen Text). Sie verwenden nur den gleichen Hash-Code, um das eingegebene Passwort zu hasen, um die gespeicherte Version zu erhalten.

Vergleichen Sie also die beiden Hash-Passwörter (Datenbank-Hash für Benutzername und das eingegebene & Hash-Passwort). Sie können feststellen, ob "das, was sie eingegeben haben" übereinstimmt, "was der ursprüngliche Benutzer für sein Passwort eingegeben hat", indem sie deren Hashes vergleicht.

Extra-Kredit:

Frage: Wenn ich Ihre Datenbank hätte, könnte ich dann nicht einfach einen Cracker wie John the Ripper nehmen und Hashes erstellen, bis ich Übereinstimmungen mit Ihren gespeicherten, gehashten Passwörtern finde? (Da die Benutzer sowieso kurze Worte wählen, sollte es einfach sein)

Antwort: Ja ... ja, sie können.

Also sollten Sie Ihre Passwörter "salzen". Siehe den salt

Siehe "Wie Hash-Daten mit Salz" C # -Beispiel





php security encryption passwords