Mettre à jour les anciens mots de passe md5 stockés dans PHP pour augmenter la sécurité

OK, passons en revue quelques points ici

1. ce que vous avez dans $salt n'est pas un sel. C'est déterministe (ce qui veut dire qu'il n'y a pas de hasard là-dedans). Si vous voulez un sel, utilisez mcrypt_create_iv($size, MCRYPT_DEV_URANDOM) ou une autre source d'entropie aléatoire réelle. Le point est qu'il doit être à la fois unique et aléatoire. Notez qu'il n'a pas besoin d'être cryptographique sécurisé aléatoire... À l'absolu pire, j'avais faites quelque chose comme ceci:

   function getRandomBytes($length) {
       $bytes = '';
       for ($i = 0; $i < $length; $i++) {
           $bytes .= chr(mt_rand(0, 255));
       }
       return $bytes;
   }
   

2. @Anony-Mousse indiqué, jamais nourrir la sortie d'une fonction de hachage à une autre sans re-ajouter les données d'origine. Utilisez plutôt un algorithme itératif approprié tel que PBKDF2 , PHPASS ou CRYPT_BLOWFISH ($2a$).

   Ma suggestion serait d'utiliser crypt avec blowfish, car C'est le meilleur disponible pour PHP en ce moment:

   function createBlowfishHash($password) {
       $salt = to64(getRandomBytes(16));
       $salt = 'a$' . $salt;
       $result = crypt($password, $salt);
   }
   

   et vérifier ensuite en utilisant une méthode comme celle-ci:

   function verifyBlowfishHash($password, $hash) {
       return $hash == crypt($password, $hash);
   }
   

   (notez que to64 est une bonne méthode définie ici ). Vous pouvez également utiliser str_replace('+', '.', base64_encode($salt)); ...

je vous suggère aussi de lire les deux suivants:

• fondamental différence entre le hachage et le chiffrement
• de nombreuses itérations de hachage, ajoutent du sel à chaque fois?

Edit: pour Répondre À la Question Migratoire

Ok, donc je me rends compte que ma réponse n'a pas abordé l'aspect migratoire de la question originale. Voilà comment je le résoudrais.

tout d'abord, construire une fonction temporaire pour créer un nouveau hachage de poisson-lune à partir de la hachage md5 original, avec un sel aléatoire et un préfixe de sorte que nous pouvons le détecter plus tard:

function migrateMD5Password($md5Hash) {
    $salt = to64(getRandomBytes(16));
    $salt = 'a$' . $salt;
    $hash = crypt($md5Hash, $salt);
    return '$md5' . $hash;
}

maintenant, exécutez tous les hachages md5 existants à travers cette fonction et enregistrez le résultat dans la base de données. Nous mettons notre propre préfixe pour que nous puissions détecter le mot de passe original et ajouter l'étape md5 supplémentaire. Donc maintenant nous sommes tous émigrés.

ensuite, créer une autre fonction pour vérifier les mots de passe, et si nécessaire mettre à jour la base de données avec un nouveau hachage:

function checkAndMigrateHash($password, $hash) {
    if (substr($hash, 0, 4) == '$md5') {
        // Migrate!
        $hash = substr($hash, 4);
        if (!verifyBlowfishHash(md5($password), $hash) {
            return false;
        }
        // valid hash, so let's generate a new one
        $newHash = createBlowfishHash($password);
        saveUpdatedPasswordHash($newHash);
        return true;
    } else {
        return verifyBlowfishHash($password, $hash);
    }
}

C'est ce que je suggérerais pour quelques raisons:

1. il obtient le md5() hashes hors de votre base de données immédiatement.
2. éventuellement (connexion suivante pour chaque utilisateur) met à jour le hachage vers une meilleure alternative (une qui est bien comprise).
3. c'est assez facile à suivre en code.

pour répondre aux commentaires:

1. un sel n'a pas besoin d'être aléatoire - je vous dirige à RFC 2898 - cryptographie basée sur Mot de passe . Plus Précisément, La Section 4.1. Et je cite:

   S'il n'y a pas d'inquiétude au sujet des interactions entre utilisations multiples de la même clé (ou un préfixe de la clé) avec le mot de passe- des techniques de cryptage et d'authentification basées sur un le mot de passe donné, puis le sel peut être généré au hasard et n'a pas besoin d'être vérifiée pour un format particulier par la partie la réception du sel. Il doit être d'au moins huit octets (64 bits).

   en plus,

   Note. Si un générateur de nombres aléatoires ou pseudorandom n'est pas disponible, une alternative déterministe pour générer le sel (ou la partie aléatoire de celui-ci) est d'appliquer une clé basée sur le mot de passe dérivation fonction pour le mot de passe et le message M à traiter.

   un générateur de PseudoRandom est disponible, alors pourquoi ne pas l'utiliser?

2. votre solution est-elle la même que bcrypt? Je ne trouve pas beaucoup de documentation sur ce qu'est en fait bcrypt? - je suppose que vous avez déjà lu l'Article bcrypt Wikipedia , et essayer de l'expliquer mieux.

   BCrypt est basé sur le bloc de Blowfish. Il utilise l'algorithme key schedule setup du chiffrement, et utilise cela pour hacher les mots de passe. La raison pour laquelle il est bon, est que l'algorithme de configuration pour Blowfish est conçu pour être très cher (qui fait partie de ce qui rend blowfish si fort d'un cypher). Le processus de base est le suivant:

   1. Une 18 de l'élément de matrice (P boîtes, 32 bits) et 4 à 2-dimensions des tableaux (appelées Boîtes S, chacune avec 256 entrées de 8 bits chacune) sont utilisées pour configurer le programme en initialisant les tableaux avec des valeurs statiques prédéterminées. De plus, un état 64 bits est initialisé à tous les 0.

   2. la clé passée est Xorée avec toutes les boîtes de 18 P dans l'ordre (rotation de la clé si elle est trop courte).

   3. les cases P sont alors utilisées pour chiffrer l'état qui a été précédemment initialisé.

   4. le texte chiffré produit par l'étape 3 est utilisé pour remplacer P1 et P2 (les 2 premiers éléments du tableau P).

   5. Étape 3 est répétée, et le résultat est mis en P3 et P4. Cela continue jusqu'à ce que P17 et P18 soient peuplés.

   c'est le dérivé clé du chiffre Blowfish. BCrypt modifie cela à ceci:

   1. l'état 64 bits est initialisé en une version cryptée du sel .

   2. même

   3. les cases P sont alors utilisées pour chiffrer la (état xor partie du sel ) qui a été précédemment initialisée.

   4. même

   5. Same

   6. la configuration résultante est alors utilisée pour chiffrer le mot de passe 64 fois. C'est ce qui est retourné par BCrypt.

   le point est simple: c'est un algorithme très coûteux qui prend beaucoup de temps CPU. C'est la vraie raison pour laquelle il doit être utilisé.

j'espère que ça éclaircira les choses.