Osobiście użyłbym mcrypt tak jak inni zamieszczeni. Ale jest o wiele więcej do odnotowania...

1. Jak zaszyfrować i odszyfrować hasło w PHP?

   Zobacz poniżej silną klasę, która dba o wszystko za Ciebie:

2. Jaki jest najbezpieczniejszy algorytm szyfrowania haseł?

   najbezpieczniejszy ? żadnego z nich. Najbezpieczniejszą metodą szyfrowania jest ochrona przed lukami w zabezpieczeniach (XSS, zdalne włączenie, itp.). Jeśli się wydostanie, atakujący może w końcu złamać szyfrowanie (żadne szyfrowanie nie jest w 100% nieodwracalne bez klucza - jak wskazuje @NullUserException, nie jest to do końca prawdą. Istnieją pewne schematy szyfrowania, które są niemożliwe do złamania, takie jak OneTimePad ).

3. Gdzie przechowywać klucz prywatny?

   To, co bym zrobił, to użyć 3 klawiszy. Jeden jest dostarczany przez użytkownika, jeden jest specyficzny dla aplikacji, a drugi jest specyficzny dla użytkownika (jak sól). Klucz specyficzny dla aplikacji może być przechowywany w dowolnym miejscu (w pliku konfiguracyjnym poza web-rootem, w zmiennej środowiskowej, itd.). Konkretny użytkownik będzie przechowywany w kolumnie w db obok zaszyfrowanego hasła. Dostarczony przez użytkownika nie będzie przechowywany. Wtedy zrobiłbyś coś takiego:

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

   Korzyść polega na tym, że dowolne dwa klucze mogą zostać naruszone bez naruszania danych. Jeśli jest atak SQL Injection, mogą uzyskać $userKey, ale nie pozostałe 2. Jeśli istnieje lokalny exploit serwera, mogą uzyskać $userKey i $serverKey, ale nie trzeci $userSuppliedKey. Jeśli pobić użytkownika kluczem, może dostać $userSuppliedKey, ale nie pozostałe 2 (ale z drugiej strony, jeśli użytkownik zostanie pobity kluczem, i tak jest za późno).

4. Zamiast przechowywać klucz prywatny, czy dobrym pomysłem jest wymaganie od użytkowników wprowadzenia klucza prywatnego w każdej chwili, gdy potrzebują odszyfrowanego hasła? (Użytkownicy tej aplikacji mogą być zaufany)

   Absolutnie. Właściwie, to jedyny sposób, w jaki bym to zrobił. W przeciwnym razie konieczne byłoby przechowywanie niezaszyfrowanej wersji w trwałym formacie pamięci masowej (pamięć współdzielona, taka jak APC lub memcached, lub w pliku sesji). To narażanie się na dodatkowe kompromisy. Nigdy nie przechowuj niezaszyfrowanej wersji hasła w niczym innym niż w zmiennej lokalnej.
5. W jaki sposób można ukraść i odszyfrować hasło? O czym muszę wiedzieć?

   Any forma kompromisu Twoich systemów pozwoli im przeglądać zaszyfrowane dane. Jeśli mogą wprowadzić kod lub dostać się do systemu plików, mogą przeglądać odszyfrowane dane (ponieważ mogą edytować pliki, które odszyfrowują dane). Każda forma powtórki lub ataku MITM daje im również pełny dostęp do zaangażowanych kluczy. Wąchanie surowego ruchu HTTP również da im klucze.

   Użyj SSL dla całego ruchu. I upewnij się, że nic na serwerze nie ma żadnych luk (CSRF, XSS, SQL Injection, Eskalacja uprawnień, zdalne wykonywanie kodu, itp.).

Edit: oto Implementacja klasy PHP silnej metody szyfrowania:

/**
 * 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);
    }
}

Zauważ, że używam funkcji dodanej w PHP 5.6: hash_equals. Jeśli jesteś na niższym niż 5.6, możesz użyć tej funkcji zastępczej, która implementuje funkcję bezpieczne porównanie za pomocą podwójnej weryfikacji HMAC :

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

Użycie:

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

Następnie, aby odszyfrowanie:

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

Zauważ, że użyłem $e2 po raz drugi, aby pokazać, że różne instancje nadal poprawnie odszyfrowują dane.

Teraz, Jak to działa/po co używać go nad innym rozwiązaniem:

1. Klucze

   • Klucze nie są używane bezpośrednio. Zamiast tego klucz jest rozciągany przez standardową wyprowadzenie PBKDF2.

   • Klucz używany do szyfrowania jest unikalny dla każdego zaszyfrowanego bloku tekstu. Dostarczony klucz staje się zatem "master key". Klasa ta zapewnia zatem obrót klucza dla kluczy szyfrowych i auth.

   • WAŻNA UWAGA , parametr $rounds jest skonfigurowany dla prawdziwych kluczy losowych o wystarczającej sile (co najmniej 128 bitów Kryptograficznie zabezpieczonego losowego). Jeśli chcesz użyć hasła lub klucza nie-losowego (lub mniej losowego niż 128 bitów CS random), musisz zwiększyć ten parametr. Proponuję minimum 10000 za hasła (im więcej Cię stać, tym lepiej, ale doda do runtime)...

2. Integralność Danych

   • zaktualizowana wersja używa ENCRYPT-THEN-MAC, co jest znacznie lepszą metodą zapewnienia autentyczności zaszyfrowanych danych.

3. Szyfrowanie:

   • używa mcrypt, aby faktycznie wykonać szyfrowanie. Sugerowałbym użycie MCRYPT_BLOWFISH lub MCRYPT_RIJNDAEL_128 cypherów i MCRYPT_MODE_CBC dla trybu. Jest wystarczająco mocny, a mimo to dość szybki (szyfrowanie i cykl deszyfrowania trwa około 1/2 sekundy na mojej maszynie).

Teraz, co do punktu 3 z pierwszej listy, to co dałoby ci funkcję taką jak ta:

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

Możesz go rozciągnąć w funkcji makeKey(), ale ponieważ będzie on rozciągany później, nie ma w tym wielkiego sensu.

Jeśli chodzi o rozmiar pamięci, zależy to od zwykłego tekstu. Blowfish używa bloku o rozmiarze 8 bajtów, więc będziesz miał:

• 16 bajtów dla sól
• 64 bajty dla hmac
• Długość danych
• Padding tak, aby długość danych % 8 = = 0

Więc dla 16-znakowego źródła danych, będzie 16 znaków danych do zaszyfrowania. Oznacza to, że rzeczywisty rozmiar zaszyfrowanych danych wynosi 16 bajtów z powodu wypełnienia. Następnie dodaj 16 bajtów dla salt i 64 bajtów dla hmac, a całkowity przechowywany rozmiar wynosi 96 bajtów. Więc w najlepszym wypadku jest 80 znaków nad głową, a w najgorszym 87 znaków nad głową...

I mam nadzieję, że to pomoże...

Uwaga: 12/11/12: właśnie zaktualizowałem tę klasę o znacznie lepszą metodę szyfrowania, używając lepiej pochodnych kluczy i naprawiając generację komputerów MAC...