Les deux sens de chiffrement: j'ai besoin de stocker des mots de passe qui peuvent être récupérés

Personnellement, je voudrais utiliser mcrypt comme les autres affiché. Mais il ya beaucoup plus à la note...

1. Comment chiffrer et de déchiffrer un mot de passe en PHP?

   Voir ci-dessous pour une forte classe qui prend soin de tout pour vous:

2. Ce qui est le plus sûr de l'algorithme pour chiffrer les mots de passe avec?

   la plus sûre? l'un d'eux. La méthode la plus sûre si vous allez à chiffrer est de protéger contre la divulgation d'informations vulnérabilités XSS, à distance de l'inclusion, etc). Si elle sort, l'attaquant peut éventuellement se fissurer le chiffrement (pas de chiffrement est de 100% de l'onu-réversible sans la clé Comme @NullUserException points ce n'est pas tout à fait vrai. Il y a quelques systèmes de cryptage qui sont impossible à décrypter comme OneTimePad).

3. Où puis-je stocker la clé privée?

   Ce que je voudrais faire est d'utiliser 3 touches. L'un est fourni par l'utilisateur, l'une est spécifique à l'application et l'autre est spécifique à l'utilisateur (comme le sel). L'application spécifique de la clé peut être stocké n'importe où (dans un fichier de config à l'extérieur de la web-racine, dans une variable d'environnement, etc). L'utilisateur spécifique serait stockée dans une colonne dans la db suivante pour le mot de passe crypté. L'utilisateur fournies ne seraient pas stockées. Alors, vous feriez quelque chose comme ceci:

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

   L'avantage, c'est que toutes les 2 des clés peut être compromise, sans compromettre les données. Si il y a une attaque par Injection SQL, ils peuvent obtenir de la $userKey, mais pas les 2 autres. Si il y a un serveur local exploiter, ils peuvent obtenir $userKey et $serverKey, mais pas le troisième $userSuppliedKey. Si ils vont battre l'utilisateur avec une clé, ils peuvent obtenir de la $userSuppliedKey, mais pas les 2 autres (mais là encore, si l'utilisateur est battu avec une clé, vous êtes trop tard de toute façon).

4. Au lieu de stocker la clé privée, est-ce une bonne idée de demander aux utilisateurs d'entrer la clé privée de tout temps, ils ont besoin d'un mot de passe décrypté? (Les utilisateurs de cette application peuvent être de confiance)

   Absolument. En fait, c'est la seule façon que je le ferais. Sinon, vous auriez besoin de stocker une version non chiffrée dans une semelle format de stockage (mémoire partagée, telles que APC ou memcached, ou dans un fichier de session). C'est vous exposer à d'autres compromis. Ne jamais stocker de la version non chiffrée du mot de passe à tout, sauf à une variable locale.

5. De quelles manières le mot de passe volés et de les déchiffrer? Que dois-je faire attention?

   Toute forme de compromis de vos systèmes de laisser afficher des données chiffrées. Si ils peuvent injecter du code ou obtenez à votre système de fichiers, ils peuvent consulter les données déchiffrées (car ils peuvent modifier les fichiers de déchiffrer les données). Toute forme de Relecture ou d'attaque de type MITM sera également leur donner un accès complet à l'clés impliquées. Flairant le raw HTTP trafic sera également leur donner les clés.

   De l'utilisation de SSL pour l'ensemble du trafic. Et assurez-vous que rien sur le serveur a tout type de vulnérabilités (CSRF, XSS, SQL Injection, augmentation de Privilège, Exécution de Code à Distance, etc).

Edit: Voici une classe PHP de la mise en œuvre d'une solide méthode de chiffrement:

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

Remarque que je suis en utilisant une fonction ajoutée dans PHP 5.6: hash_equals. Si vous êtes en baisse de 5,6, vous pouvez utiliser ce substitut de la fonction qui implémente un calendrier-sûr de comparaison fonction à l'aide de double HMAC vérification:

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

Utilisation:

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

Puis, à décrypter:

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

Notez que j'ai utilisé $e2 le deuxième temps de vous montrer les différentes instances seront toujours correctement déchiffrer les données.

Maintenant, comment ça fonctionne et pourquoi l'utiliser sur une autre solution:

1. Clés

   • Les touches ne sont pas directement utilisées. Au lieu de cela, la clé est tendu par une norme PBKDF2 dérivation.

   • La clé utilisée pour le chiffrement est unique pour chaque bloc de texte chiffré. La clé fournie devient donc un "master key". Cette classe fournit donc une rotation de la clé de chiffrement et d'authentification des clés.

   • REMARQUE IMPORTANTE, le $rounds paramètre est configuré pour vrai des touches au hasard d'une force suffisante (128 bits de sécurité Cryptographique aléatoire au minimum). Si vous allez utiliser un mot de passe, ou de la non-clé aléatoire (ou moins aléatoire puis 128 bits de CS aléatoire), vous doit augmentation de ce paramètre. Je vous suggère un minimum de 10000 mots de passe (le plus que vous pouvez vous permettre, le mieux, mais il va ajouter à l'exécution)...

2. L'Intégrité Des Données

   • La version mise à jour utilise CRYPTER PUIS-MAC, qui est une bien meilleure méthode pour s'assurer de l'authenticité des données chiffrées.

3. De chiffrement:

   • Il utilise mcrypt pour effectuer le chiffrement. Je vous recommande d'utiliser soit MCRYPT_BLOWFISH ou MCRYPT_RIJNDAEL_128 méthode de chiffrement et MCRYPT_MODE_CBC pour la mode. Elle est assez forte, et encore assez rapide (un de chiffrement et de déchiffrement cycle dure environ 1/2 seconde sur ma machine).

Maintenant, comme pour le point 3, à partir de la liste, ce qui vous donnerait une fonction comme ceci:

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

Vous pourrait étirer dans le makeKey() fonction, mais depuis ça va être tendu plus tard, il n'y a pas vraiment un énorme point de le faire.

Autant que la taille de stockage, il dépend de la forme de texte brut. Blowfish utilise un 8 octets de taille de bloc, de sorte que vous aurez:

• 16 octets pour le sel
• 64 octets pour le hmac
• longueur de données
• Rembourrage de sorte que la longueur des données % 8 == 0

Donc, pour un 16 caractère de source de données, il y aura 16 caractères de données chiffrées. Cela signifie donc que le réel des données chiffrées de la taille est de 16 octets, en raison de rembourrage. Puis ajouter les 16 octets pour le sel et 64 octets pour le hmac et le total stocké taille est de 96 octets. Il y a donc, au mieux, un de 80 caractères généraux, et, au pire, 87 caractère de frais généraux...

J'espère que ça aide...

Remarque: 12/11/12: je viens de mettre à jour cette classe avec une BIEN meilleure méthode de cryptage, en utilisant mieux les clés dérivées, et la fixation de la MAC génération...

1. La fonction PHP que vous êtes après est Mcrypt (http://www.php.net/manual/en/intro.mcrypt.php).

L'exemple le manuel est légèrement modifié pour cet exemple):

<?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";
?>

Vous utilisez mcrypt_decrypt pour décrypter votre mot de passe.

1. Le meilleur algorithme est plutôt subjectif - demander à 5 personnes, obtenez 5 réponses. Personnellement, si la valeur par défaut (Blowfish) n'est pas assez bon pour vous, vous avez probablement plus de problèmes!

2. Étant donné qu'il est nécessaire par PHP pour chiffrer - pas sûr que vous pouvez cacher n'importe où - recevoir des commentaires sur cette. Standard de PHP meilleures pratiques de codage s'applique bien sûr!

3. Étant donné que la clé de chiffrement sera dans votre code, de toute façon, pas sûr de ce que vous gagnerez, en fournissant le reste de votre application est sécurisée.

4. Évidemment, si le mot de passe chiffré et la clé de chiffrement sont volés, puis game over.

Je l'avais mis un coureur sur ma réponse - je ne suis pas un PHP crypto expert, mais je pense que ce que j'ai répondu à la pratique courante - je recevoir des commentaires d'autres peuvent avoir.

Je voudrais seulement suggérer chiffrement à clé publique si vous souhaitez la possibilité de définir un mot de passe utilisateur sans leur interaction (ce qui peut être pratique pour se réinitialise et partagé leurs mots de passe).

Clé publique

1. La OpenSSL extension, spécifiquement openssl_public_encrypt et openssl_private_decrypt
2. Ce serait tout droit RSA en supposant que votre mot de passe ajustement de la taille des clés - rembourrage, sinon vous avez besoin d'un symétrique couche
3. Stocker à la fois les clés pour chaque utilisateur, la clé privée du mot de passe est leur mot de passe d'application

Symétrique

1. La Mcrypt extension
2. AES-256 est probablement un pari sûr, mais cela pourrait être une question en elle-même
3. Vous n'avez pas - ce serait de leur mot de passe d'application

Les deux

4. Oui - les utilisateurs doivent entrer leur mot de passe d'application à chaque fois, mais de les stocker dans la session soulever d'autres questions

5.

• Si quelqu'un vole les données de l'application, il est aussi sûr que le chiffrement symétrique (pour la clé publique du programme, il est utilisé pour protéger la clé privée avec le mot de passe.)
• Votre application devrait certainement être uniquement accessible via le protocole SSL, de préférence à l'aide de certificats client.
• Envisager l'ajout d'un deuxième facteur d'authentification qui ne serait utilisé qu'une fois par session, comme un jeton envoyé par SMS.

Les mots de passe d'un périphérique matériel, donc la vérification contre les hachages sont hors de question

Hein? Je ne comprends pas. Avez-vous tout simplement dire que le mot de passe doit être récupérable?

Comme d'autres l'ont dit, l'extension mcrypt donne accès à de nombreuses fonctions cryptographiques - cependant, vous êtes en invitant les utilisateurs à mettre tous leurs œufs dans le même panier, qui sera potentiellement être une cible pour les pirates - et si vous ne savez même pas comment commencer à résoudre le problème, alors vous faites à vos utilisateurs un mauvais service. Vous n'êtes pas en mesure de comprendre comment protéger les données.

Plupart des failles de sécurité viennent pas parce que l'algorithme sous-jacent est défectueux ou mal -, mais en raison de problèmes avec la façon dont l'algorithme est utilisé dans le code de l'application.

Cela dit, il est possible de construire un système raisonnablement sécurisé.

Vous ne devez envisager un chiffrement asymétrique si vous avez une exigence pour un utilisateur de créer un message sécurisé qui est lisible par un autre (spécifique) de l'utilisateur. La raison en est que son gourmand en ressources. Si vous souhaitez simplement fournir un référentiel pour les utilisateurs d'entrer et de récupérer leurs propres données, le chiffrement symétrique est adéquate.

Si, toutefois, vous pouvez stocker la clé pour déchiffrer le message au même endroit que le message chiffré (ou lorsque le message chiffré est stocké), alors le système n'est pas sécurisé. Utiliser le même jeton d'authentification pour l'authentification de l'utilisateur comme pour la clé de déchiffrement (ou, dans le cas de chiffrement assymétrique, utilisez le jeton comme la clé privée phrase de passe). Puisque vous aurez besoin de stocker le jeton sur le serveur où le déchiffrement se fait au moins temporairement, vous pouvez envisager d'utiliser un non-consultable session de stockage de substrat, ou en passant directement le jeton à un démon associé à la session qui serait de stocker le jeton dans la mémoire et effectuer le déchiffrement des messages sur demande.