Valider un mot de passe par rapport à un hachage SSHA256 en PHP

Question

Pour l'authentification avec Dovecot, j'utilise des hachages SSHA256 mais je ne sais pas comment valider un mot de passe donné par rapport au hachage existant. Les fonctions PHP suivantes (trouvées sur le web) sont utilisées pour créer le hachage SSHA256 :

function ssha256($pw) {
        $salt = make_salt();
        return "{SSHA256}" . base64_encode( hash('sha256', $pw . $salt, true ) . $salt );
}

function make_salt() {
        $len   = 4;
        $bytes = array();
        for ($i = 0; $i < $len; $i++ ) {
                $bytes[] = rand(1,255);
        }
        $salt_str = '';
        foreach ($bytes as $b) {
                $salt_str .= pack('C', $b);
        }
        return $salt_str;
}

Exemple de sortie : {SSHA256}lGq49JTKmBC49AUrk7wLyQVmeZ7cGl/V13A9QbY4RVKchckL

Je dois extraire le sel, mais comment ? J'ai complètement perdu le chemin pour résoudre le problème, quelqu'un a-t-il un indice pour cela ?

Merci à tous pour votre aide !

Oh et désolé, je dois utiliser SSHA256, car Dovecot 1.2.15 ne supporte que ces schémas : CRYPT MD5 MD5-CRYPT SHA SHA1 SHA256 SMD5 SSHA SSHA256 PLAIN CLEARTEXT CRAM-MD5 HMAC-MD5 DIGEST-MD5 PLAIN-MD4 PLAIN-MD5 LDAP-MD5 LANMAN NTLM OTP SKEY RPA

Answer 1

Vous devez stocker le sel en même temps que la valeur hachée.

Lorsque vous devez valider le mot de passe, il vous suffit de recalculer le hachage avec le mot de passe saisi par l'utilisateur + le sel stocké. Si les hachages correspondent, l'utilisateur a saisi le bon mot de passe.

Pour votre format, utilisez base64_decode d'abord, les 4 derniers octets du résultat seront le sel.

Answer 2

Vous ne devriez pas utiliser la famille SHA pour le hachage des mots de passe. Ils sont rapide et conçu pour hachage de fichiers à la vitesse . Vous avez besoin que le hachage de mot de passe soit coûteux . Utilisez bcrypt, PHPass ou tout simplement cette classe, que j'ai moi-même développée (mais pas avant d'avoir appris à y faire des trous) :

class PassHash {
    public static function rand_str($length) {
        $total = $length % 2;
        $output = "";
        if ($total !== 0) {
            $count = floor($length / 2);
            $output .= ".";
        } else $count = $length / 2;

        $bytes = openssl_random_pseudo_bytes($count);
        $output .= bin2hex($bytes);

        // warning: prepending with a dot if the length is odd.
        // this can be very dangerous. no clue why you'd want your
        // bcrypt salt to do this, but /shrug

        return $output;
    }
    // 2y is an exploit fix, and an improvement over 2a. Only available in 5.4.0+
    public static function hash($input) {
        return crypt($input, "$2y$13$" . self::rand_str(22));

    }

    // legacy support, add exception handling and fall back to <= 5.3.0
    public static function hash_weak($input) {
        return crypt($input, "$2a$13$" . self::rand_str(22));
    }

    public static function compare($input, $hash) {
        return (crypt($input, $hash) === $hash);
    }
}

Vous devez hacher le texte en clair donné et comparer ce hachage à celui que vous avez stocké. Les sels sont stockés dans les hachages, et doivent être aléatoires. Si vous le souhaitez, vous pouvez ajouter un poivre. Vous devez également rendre le taux de travail variable, de sorte que vous puissiez le modifier à tout moment en cas de besoin et que votre système fonctionne toujours.

---

Si, comme vous le dites, vous n'avez aucun moyen de mettre cela en œuvre, vous pouvez décomposer le hachage comme suit :

function unpack_hash($hash) {
        $hash = base64_decode($hash);
        $split = str_split($hash, 64);
        return array("salt" => $split[1], "hash" => $split[0]);

En effet, SHA256 compte 256 bits, soit 64 caractères hexadécimaux. Vous pouvez toujours supposer que les 64 premiers caractères sont le hachage.