it-swarm.com.de

Zweiwege-Verschlüsselung: Ich muss Kennwörter speichern, die abgerufen werden können

Ich erstelle eine Anwendung, die Passwörter speichert, die der Benutzer abrufen und anzeigen kann. Die Passwörter gelten für ein Hardwaregerät, so dass das Überprüfen auf Hashes nicht in Frage kommt.

Was ich wissen muss ist:

  1. Wie ver- und entschlüssele ich ein Passwort in PHP?

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

  3. Wo speichere ich den privaten Schlüssel?

  4. Ist es eine gute Idee, Benutzer zur Eingabe des privaten Schlüssels aufzufordern, wenn sie ein entschlüsseltes Kennwort benötigen, anstatt den privaten Schlüssel zu speichern? (Benutzer dieser Anwendung können vertrauenswürdig sein)

  5. Wie kann das Passwort gestohlen und entschlüsselt werden? Was muss ich beachten?

170
HyderA

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

  1. Wie ver- und entschlüssele ich ein Passwort in PHP?

    Weiter unten finden Sie eine starke Klasse, die sich um alles kümmert:

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

    am sichersten? 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 möglicherweise die Verschlüsselung knacken (ohne den Schlüssel ist keine Verschlüsselung zu 100% unumkehrbar). OneTimePad ).

  3. Wo speichere ich den privaten Schlüssel?

    Was ich tun würde, ist die Verwendung von 3 Schlüsseln. Einer wird vom Benutzer bereitgestellt, einer ist anwendungsspezifisch und der andere ist benutzerspezifisch (wie ein Salz). Der anwendungsspezifische Schlüssel kann an einem beliebigen Ort gespeichert werden (in einer Konfigurationsdatei außerhalb des Webstamms, in einer Umgebungsvariablen usw.). Das benutzerspezifische Kennwort wird in einer Spalte in der Datenbank neben dem verschlüsselten Kennwort gespeichert. Der vom Nutzer angegebene würde nicht gespeichert. Dann würden Sie so etwas tun:

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

    Der Vorteil dabei ist, dass 2 der Schlüssel kompromittiert werden können, ohne dass die Daten kompromittiert werden. Bei einem SQL-Injection-Angriff erhalten sie den $userKey, Nicht aber den anderen 2. Bei einem lokalen Server-Exploit erhalten sie $userKey Und $serverKey, Jedoch nicht der dritte $userSuppliedKey. Wenn sie den Benutzer mit einem Schraubenschlüssel schlagen, erhalten sie den $userSuppliedKey, Aber nicht die anderen 2 (aber wenn der Benutzer mit einem Schraubenschlüssel geschlagen wird, sind Sie trotzdem zu spät).

  4. Ist es eine gute Idee, Benutzer zur Eingabe des privaten Schlüssels aufzufordern, wenn sie ein entschlüsseltes Kennwort benötigen, anstatt den privaten Schlüssel zu speichern? (Benutzer dieser Anwendung können vertrauenswürdig sein)

    Absolut. In der Tat, das ist der einzige Weg, wie ich es tun würde. Andernfalls müssten Sie eine unverschlüsselte Version in einem dauerhaften Speicherformat (gemeinsam genutzter Speicher wie APC oder memcached oder in einer Sitzungsdatei) speichern. Das setzt sich zusätzlichen Kompromissen aus. Speichern Sie die unverschlüsselte Version des Kennworts nur in einer lokalen Variablen.

  5. Wie kann das Passwort gestohlen und entschlüsselt werden? Was muss ich beachten?

    Bei jeder Form von Kompromittierung können Ihre Systeme verschlüsselte Daten anzeigen. Wenn sie Code einschleusen 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 Form von Replay oder MITM-Attacke verschafft ihnen auch vollen Zugriff auf die beteiligten Schlüssel. Wenn Sie den rohen HTTP-Datenverkehr abhören, erhalten Sie auch die Schlüssel.

    Verwenden Sie SSL für den gesamten Datenverkehr. Stellen Sie außerdem sicher, dass auf dem Server keine Schwachstellen vorhanden sind (CSRF, XSS, SQL Injection, Rechteerweiterung, 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 Funktion verwende, die in PHP 5.6: hash_equals hinzugefügt wurde. Wenn Sie eine niedrigere Version als 5.6 haben, können Sie diese Ersatzfunktion verwenden Funktion, die eine zeitsichere Gegenüberstellung Funktion mit doppelte 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 zum Entschlüsseln:

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

Beachten Sie, dass ich beim zweiten Mal $e2 Verwendet habe, um Ihnen zu zeigen, dass verschiedene Instanzen die Daten immer noch ordnungsgemäß entschlüsseln.

Wie funktioniert es? Warum sollte es über eine andere Lösung angewendet werden?

  1. Schlüssel

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

    • 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 bietet daher eine Schlüsselrotation für Chiffrier- und Authentifizierungsschlüssel.

    • WICHTIGER HINWEIS : Der Parameter $rounds Ist für echte Zufallsschlüssel mit ausreichender Stärke konfiguriert (mindestens 128 Bit Cryptographically Secure Random). Wenn Sie ein Kennwort oder einen nicht zufälligen Schlüssel (oder weniger als 128 Bit CS Random) 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 die Laufzeit verlängern) ...

  2. Datenintegrität

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

    • Es verwendet mcrypt, um die Verschlüsselung tatsächlich durchzuführen. Ich würde vorschlagen, entweder die Ziffern MCRYPT_BLOWFISH Oder MCRYPT_RIJNDAEL_128 Und MCRYPT_MODE_CBC Für den Modus zu verwenden. Es ist stark genug und trotzdem ziemlich schnell (ein Ver- und Entschlüsselungszyklus dauert auf meinem Computer ungefähr eine halbe Sekunde).

Was nun Punkt 3 aus der ersten Liste betrifft, so ist dies eine Funktion wie die folgende:

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

Sie könnten es in der Funktion makeKey() dehnen, aber da es später gedehnt wird, gibt es keinen wirklichen Grund, dies zu tun.

Was die Speichergröße anbelangt, kommt es auf den Klartext an. Blowfish verwendet eine 8-Byte-Blockgröße, sodass Sie Folgendes haben:

  • 16 Bytes für das Salz
  • 64 Bytes für das hmac
  • datenlänge
  • Auffüllen, sodass die Datenlänge% 8 == 0 ist

Für eine 16-stellige Datenquelle müssen also 16 Datenzeichen verschlüsselt werden. Das bedeutet, dass die tatsächliche Größe der verschlüsselten Daten aufgrund der Auffüllung 16 Byte beträgt. Fügen Sie dann die 16 Bytes für das Salt und die 64 Bytes für das hmac hinzu, und die insgesamt gespeicherte Größe beträgt 96 Bytes. Also gibt es bestenfalls einen Overhead von 80 Zeichen und schlimmstenfalls einen Overhead von 87 Zeichen ...

Ich hoffe das hilft...

Hinweis: 11.12.12: Ich habe diese Klasse gerade mit einer VIEL besseren Verschlüsselungsmethode aktualisiert, die besser abgeleitete Schlüssel verwendet und die MAC-Generation korrigiert. .

209
ircmaxell

Wie ver- und entschlüssele ich ein Passwort in PHP? Durch Implementierung eines von vielen Verschlüsselungsalgorithmen. (oder mit einer von vielen Bibliotheken)

Mit welchem ​​Algorithmus werden die Passwörter am sichersten verschlüsselt? Es gibt Unmengen verschiedener Algorithmen, von denen keiner zu 100% sicher ist . Aber viele von ihnen sind sicher genug für den Handel und sogar für militärische Zwecke

Wo speichere ich den privaten Schlüssel? Wenn Sie sich für die Implementierung eines Kryptografiealgorithmus mit öffentlichem Schlüssel (z. B. RSA) entschieden haben, haben Sie Speichere keinen privaten Schlüssel. Benutzer haben privaten Schlüssel. Ihr System verfügt über einen öffentlichen Schlüssel, der an einem beliebigen Ort gespeichert werden kann.

Anstatt den privaten Schlüssel zu speichern, ist es eine gute Idee, die Benutzer zu verpflichten, den privaten Schlüssel jedes Mal einzugeben, wenn sie ein entschlüsseltes Kennwort benötigen. (Benutzer dieser Anwendung können vertrauenswürdig sein.) Wenn Ihr Benutzer sich dann an lächerlich lange Primzahlen erinnern kann - ja, warum nicht. Im Allgemeinen müssten Sie sich jedoch ein System einfallen lassen, mit dem der Benutzer seinen Schlüssel irgendwo speichern kann.

Wie kann das Passwort gestohlen und entschlüsselt werden? Was muss ich beachten? Dies hängt vom Algorithmus ab gebraucht. Stellen Sie jedoch immer sicher, dass Sie dem Benutzer kein unverschlüsseltes Kennwort senden. Verschlüsseln/entschlüsseln Sie es entweder auf der Client-Seite oder verwenden Sie https (oder verwenden Sie andere kryptografische Mittel, um die Verbindung zwischen Server und Client zu sichern).

Wenn Sie Kennwörter jedoch nur verschlüsselt speichern müssen, sollten Sie eine einfache XOR Chiffre verwenden. Das Hauptproblem bei diesem Algorithmus besteht darin, dass sie durch die Frequenzanalyse leicht zerstört werden können. Da Passwörter im Allgemeinen nicht aus langen Absätzen von englischem Text bestehen, sollten Sie sich darüber keine Gedanken machen. Das zweite Problem mit XOR Chiffre ist, dass Sie eine verschlüsselte und eine verschlüsselte Nachricht haben In entschlüsselter Form können Sie leicht herausfinden, mit welchem ​​Passwort es 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.

14
Ivan
  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 verwenden, um Ihr Passwort zu entschlüsseln.

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

  2. Angesichts der Tatsache, dass PHP zum Verschlüsseln benötigt wird - nicht sicher, ob Sie es irgendwo verstecken können -, begrüßen Sie Kommentare dazu. Standard PHP Es gelten natürlich die besten Codierungsmethoden!

  3. Angesichts der Tatsache, dass der Verschlüsselungsschlüssel ohnehin in Ihrem Code enthalten ist, sind Sie sich nicht sicher, was Sie erhalten, vorausgesetzt, der Rest Ihrer Anwendung ist sicher.

  4. Wenn das verschlüsselte Passwort und der Verschlüsselungsschlüssel gestohlen werden, ist das Spiel natürlich vorbei.

Ich würde meiner Antwort einen Reiter hinzufügen - ich bin kein PHP Krypto-Experte, aber ich denke, was ich beantwortet habe, ist Standardübung - ich begrüße Kommentare, die andere vielleicht haben.

12
Jon Rhoades

Viele Benutzer haben vorgeschlagen, mcrypt zu verwenden, was korrekt ist, aber ich gehe gerne noch einen Schritt weiter, um es einfach zu speichern und zu übertragen (da verschlüsselte Werte es manchmal schwierig machen können, 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 konvertieren Sie es dann in Hex-Code. Sobald Sie den Hex-Code eingegeben haben, können Sie ihn auf verschiedene Arten ü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);
6
Bradley

Ich würde die Verschlüsselung mit öffentlichen Schlüsseln nur empfehlen, wenn Sie das Kennwort eines Benutzers ohne dessen Interaktion festlegen möchten (dies kann für das Zurücksetzen und Freigeben von Kennwörtern hilfreich sein).

Öffentlicher Schlüssel

  1. Die OpenSSL Erweiterung, speziell openssl_public_encrypt und openssl_private_decrypt
  2. Dies ist eine einfache RSA-Methode, vorausgesetzt, Ihre Passwörter passen in die Schlüsselgröße - Auffüllen, andernfalls benötigen Sie eine symmetrische Ebene
  3. Speichern Sie beide Schlüssel für jeden Benutzer. Die Passphrase des privaten Schlüssels ist das Anwendungskennwort

Symmetrisch

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

Beide

4. Ja - Benutzer müssen jedes Mal ihr Anwendungskennwort eingeben, das Speichern in der Sitzung wirft jedoch andere Probleme auf

5.

  • Wenn jemand die Anwendungsdaten stiehlt, ist diese ebenso sicher wie die symmetrische Verschlüsselung (beim öffentlichen Schlüsselschema dient sie zum Schutz des privaten Schlüssels mit der Passphrase).
  • Ihre Anwendung sollte auf jeden Fall nur über SSL zugänglich sein, vorzugsweise mit Client-Zertifikaten.
  • Erwägen Sie, einen zweiten Faktor für die Authentifizierung hinzuzufügen, der nur einmal pro Sitzung verwendet wird, z. B. ein per SMS gesendetes Token.
5
Long Ears

Die Passwörter gelten für ein Hardwaregerät, so dass das Überprüfen auf Hashes nicht in Frage kommt

Wie? Ich verstehe nicht Meinen Sie damit nur, dass das Passwort wiederherstellbar sein muss?

Wie bereits erwähnt, bietet die Erweiterung mcrypt Zugriff auf zahlreiche kryptografische Funktionen. Sie fordern jedoch Ihre Benutzer auf, alle Eier in einen Korb zu legen - einer, der potenziell ein Ziel für Angreifer sein kann - und wenn Sie es nicht einmal wissen Wie kann man anfangen, das Problem zu lösen? Dann tun Sie Ihren Benutzern einen schlechten Dienst. Sie sind nicht in der Lage zu verstehen, wie die Daten geschützt werden.

Die meisten Sicherheitslücken entstehen nicht, weil der zugrunde liegende Algorithmus fehlerhaft oder unsicher ist - sondern weil Probleme mit der Art und Weise auftreten, wie der Algorithmus im Anwendungscode verwendet wird.

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

Sie sollten asymmetrische Verschlüsselung nur in Betracht ziehen, wenn ein Benutzer eine sichere Nachricht erstellen muss, die von einem anderen (bestimmten) Benutzer gelesen werden kann. Der Grund dafür ist, dass es rechenintensiv ist. Wenn Sie nur ein Repository bereitstellen möchten, in das Benutzer ihre eigenen Daten eingeben und abrufen können, ist eine symmetrische Verschlüsselung ausreichend.

Wenn Sie den Schlüssel zum Entschlüsseln der Nachricht jedoch an derselben Stelle speichern wie die verschlüsselte Nachricht (oder an der Stelle, an der die verschlüsselte Nachricht gespeichert ist), ist das System nicht sicher. Verwenden Sie zur Authentifizierung des Benutzers dasselbe Token wie für den Entschlüsselungsschlüssel (oder verwenden Sie bei asymmetrischer Verschlüsselung das Token als Passphrase für den privaten Schlüssel). Da Sie das Token auf dem Server speichern müssen, auf dem die Entschlüsselung zumindest vorübergehend stattfindet, sollten Sie ein nicht durchsuchbares Sitzungsspeichersubstrat verwenden oder das Token direkt an einen der Sitzung zugeordneten Dämon übergeben, in dem das Token gespeichert wird Token im Speicher und führen die Entschlüsselung von Nachrichten nach Bedarf durch.

2
symcbean

Ich habe so etwas versucht, aber bitte beachte, dass ich kein Kryptograf bin und keine fundierten Kenntnisse über php oder eine andere Programmiersprache habe. Es ist nur eine Idee. Meine Idee ist es, key in einer Datei oder database zu speichern (oder manuell einzugeben), was (Ort) nicht einfach vorherzusagen ist (und natürlich wird irgendwann alles entschlüsselt, das Konzept besteht darin, die zu verlängern Entschlüsselungszeit) 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 zu schätzen.

2
Santosh Linkha

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