Existe-t-il des implémentations JavaScript SHA-256 qui sont généralement considérées comme dignes de confiance?

J'écris un login pour un forum et je dois hacher le mot de passe côté client en javascript avant de l'envoyer au serveur. J'ai du mal à déterminer à quelle implémentation SHA-256 je peux vraiment faire confiance. Je m'attendais à ce qu'il y ait une sorte de script faisant autorité que tout le monde utilise, mais je trouve des tas de projets différents, tous avec leurs propres implémentations.

Je me rends compte que l'utilisation de la crypto d'autres personnes est toujours un acte de foi à moins que vous ne soyez qualifié pour l'examiner vous-même, et qu'il n'y a pas de définition universelle de «digne de confiance», mais cela semble être quelque chose de commun et assez important pour qu'il devrait y en avoir un. de consensus sur ce qu'il faut utiliser. Suis-je juste naïf?

Modifier car cela revient souvent dans les commentaires: Oui, nous refaisons un hachage plus strict côté serveur. Le hachage côté client n'est pas le résultat final que nous sauvegardons dans la base de données. Le hachage côté client est dû au fait que le client humain le demande. Ils n'ont pas donné de raison précise pour laquelle, probablement ils aiment juste exagérer.

La bibliothèque cryptographique Stanford JS contient une implémentation de SHA-256. Bien que la crypto dans JS ne soit pas vraiment une entreprise aussi bien approuvée que les autres plates-formes de mise en œuvre, celle-ci est au moins partiellement développée par, et dans une certaine mesure parrainée par, Dan Boneh , qui est un nom bien établi et de confiance en cryptographie. , et signifie que le projet est supervisé par quelqu'un qui sait réellement ce qu'il fait. Le projet est également soutenu par la NSF .

Cela vaut la peine de souligner, cependant ...
... que si vous hachez le mot de passe côté client avant de le soumettre, alors le hachage est le mot de passe , et le mot de passe d'origine devient inutile. Un attaquant n'a qu'à intercepter le hachage pour se faire passer pour l'utilisateur, et si ce hachage est stocké non modifié sur le serveur, alors le serveur stocke le vrai mot de passe (le hachage) en texte brut .

Donc, votre sécurité est maintenant pire parce que vous avez décidé d' ajouter vos propres améliorations à ce qui était auparavant un système de confiance.

Sur https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest, j'ai trouvé cet extrait de code qui utilise le module js interne:

async function sha256(message) {
    // encode as UTF-8
    const msgBuffer = new TextEncoder('utf-8').encode(message);                    

    // hash the message
    const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);

    // convert ArrayBuffer to Array
    const hashArray = Array.from(new Uint8Array(hashBuffer));

    // convert bytes to hex string                  
    const hashHex = hashArray.map(b => ('00' + b.toString(16)).slice(-2)).join('');
    return hashHex;
}

Notez que crypto.subtledans uniquement disponible sur httpsou localhost- par exemple pour votre développement local avec python3 -m http.servervous devez ajouter cette ligne à votre /etc/hosts: 0.0.0.0 localhost

Redémarrez - et vous pouvez ouvrir localhost:8000en travaillant crypto.subtle.

L'implémentation SHA-256 de Forge est rapide et fiable.

Pour exécuter des tests sur plusieurs implémentations JavaScript SHA-256, accédez à http://brillout.github.io/test-javascript-hash-implementations/ .

Les résultats sur ma machine suggèrent que forge est la mise en œuvre la plus rapide et également considérablement plus rapide que la bibliothèque crypto Javascript Stanford (sjcl) mentionnée dans la réponse acceptée.

Forge a une taille de 256 Ko, mais l'extraction du code associé à SHA-256 réduit la taille à 4,5 Ko, voir https://github.com/brillout/forge-sha256

Pour ceux qui sont intéressés, voici le code pour créer un hachage SHA-256 en utilisant sjcl:

import sjcl from 'sjcl'

const myString = 'Hello'
const myBitArray = sjcl.hash.sha256.hash(myString)
const myHash = sjcl.codec.hex.fromBits(myBitArray)

Non, il n'y a aucun moyen d'utiliser le JavaScript du navigateur pour améliorer la sécurité des mots de passe. Je vous recommande vivement de lire cet article . Dans votre cas, le plus gros problème est le problème des œufs de poule:

Quel est le "problème de l'oeuf de poule" avec la livraison de la cryptographie Javascript?

Si vous ne faites pas confiance au réseau pour fournir un mot de passe ou, pire, si vous ne faites pas confiance au serveur pour ne pas garder les secrets des utilisateurs, vous ne pouvez pas leur faire confiance pour fournir le code de sécurité. Le même attaquant qui reniflait des mots de passe ou lisait des journaux avant d'introduire la cryptographie détourne simplement du code cryptographique après vous.

[...]

Pourquoi ne puis-je pas utiliser TLS / SSL pour fournir le code crypto Javascript?

Vous pouvez. C'est plus difficile qu'il n'y paraît, mais vous transmettez en toute sécurité la cryptographie Javascript à un navigateur utilisant SSL. Le problème est qu'après avoir établi un canal sécurisé avec SSL, vous n'avez plus besoin de la cryptographie Javascript; vous avez une «vraie» cryptographie.

Ce qui conduit à ceci:

Le problème avec l'exécution de code crypto en Javascript est que pratiquement toutes les fonctions dont dépend la cryptographie peuvent être remplacées silencieusement par tout élément de contenu utilisé pour créer la page d'hébergement. La sécurité cryptographique peut être annulée tôt dans le processus (en générant de faux nombres aléatoires, ou en falsifiant les constantes et les paramètres utilisés par les algorithmes), ou plus tard (en renvoyant le matériel clé à un attaquant), ou --- dans le scénario le plus probable --- en contournant complètement la crypto.

Il n'y a aucun moyen fiable pour un morceau de code Javascript de vérifier son environnement d'exécution. Le code crypto Javascript ne peut pas demander, "est-ce que j'ai vraiment affaire à un générateur de nombres aléatoires, ou à un fac-similé de celui fourni par un attaquant?" Et il ne peut certainement pas affirmer que "personne n'est autorisé à faire quoi que ce soit avec ce crypto secret sauf d'une manière que moi, l'auteur, j'approuve". Ce sont deux propriétés qui sont souvent fournies dans d'autres environnements utilisant la cryptographie, et elles sont impossibles en Javascript.

Fondamentalement, le problème est le suivant:

• Vos clients ne font pas confiance à vos serveurs, ils souhaitent donc ajouter un code de sécurité supplémentaire.
• Ce code de sécurité est fourni par vos serveurs (ceux auxquels ils ne font pas confiance).

Ou bien,

• Vos clients ne font pas confiance à SSL, ils veulent donc que vous utilisiez un code de sécurité supplémentaire.
• Ce code de sécurité est fourni via SSL.

Remarque: De plus, SHA-256 ne convient pas à cela, car il est si facile de forcer brutalement des mots de passe non itérés non salés . Si vous décidez quand même de le faire, recherchez une implémentation de bcrypt , scrypt ou PBKDF2 .

J'ai trouvé cette implémentation très simple à utiliser. Possède également une généreuse licence de style BSD:

jsSHA: https://github.com/Caligatio/jsSHA

J'avais besoin d'un moyen rapide d'obtenir la représentation hexadécimale d'un hachage SHA-256. Cela n'a pris que 3 lignes:

var sha256 = new jsSHA('SHA-256', 'TEXT');
sha256.update(some_string_variable_to_hash);
var hash = sha256.getHash("HEX");

Outre la bibliothèque de Stanford mentionnée par tylerl. J'ai trouvé jsrsasign très utile (Github repo ici: https://github.com/kjur/jsrsasign ). Je ne sais pas à quel point il est digne de confiance, mais j'ai utilisé son API de SHA256, Base64, RSA, x509, etc. et cela fonctionne plutôt bien. En fait, il inclut également la bibliothèque de Stanford.

Si tout ce que vous voulez faire est SHA256, jsrsasign peut être exagéré. Mais si vous avez d'autres besoins dans le domaine connexe, je pense que c'est une bonne solution.