node.js chaîne de hachage?

J’ai une chaîne que je veux hacher. Quel est le moyen le plus simple de générer le hachage dans node.js?

Le hachage est destiné au contrôle de version, pas à la sécurité.

Jetez un coup d’oeil à crypto.createHash (algorithme)

var filename = process.argv[2]; var crypto = require('crypto'); var fs = require('fs'); var md5sum = crypto.createHash('md5'); var s = fs.ReadStream(filename); s.on('data', function(d) { md5sum.update(d); }); s.on('end', function() { var d = md5sum.digest('hex'); console.log(d + ' ' + filename); }); 

Si vous voulez juste md5 hash une simple chaîne, j’ai trouvé que cela fonctionnait pour moi.

 var crypto = require('crypto'); var name = 'braitsch'; var hash = crypto.createHash('md5').update(name).digest('hex'); console.log(hash); // 9b74c9897bac770ffc029102a200c5de 

L’API du module cryptographique de Node est toujours instable.

A partir de la version 4.0.0, le module Crypto natif n’est plus instable. De la documentation officielle :

Crypto

Stabilité: 2 – Stable

L’API s’est avérée satisfaisante. La compatibilité avec l’écosystème npm est une priorité et ne sera pas rompue, sauf en cas d’absolue nécessité.

Il convient donc de considérer l’utilisation de l’implémentation native en toute sécurité, sans dépendances externes.

Pour référence, les modules mentionnés ci-dessous ont été proposés comme solutions alternatives lorsque le module Crypto était encore instable.


Vous pouvez également utiliser l’un des modules sha1 ou md5 qui font tous les deux le travail.

 $ npm install sha1 

et alors

 var sha1 = require('sha1'); var hash = sha1("my message"); console.log(hash); // 104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb 

ou

 $ npm install md5 

et alors

 var md5 = require('md5'); var hash = md5("my message"); console.log(hash); // 8ba6c19dc1def5702ff5acbf2aeea5aa 

(MD5 n’est pas sûr mais souvent utilisé par des services comme Gravatar.)

L’API de ces modules ne changera pas!

 sha256("ssortingng or binary"); 

J’ai rencontré un problème avec une autre réponse. Je vous conseille de définir l’argument d’encodage en binary pour utiliser la chaîne d’octets et empêcher différents hachages entre Javascript (NodeJS) et d’autres langages / services tels que Python, PHP, Github …

Si vous n’utilisez pas ce code, vous pouvez obtenir un hash différent entre NodeJS et Python …

Comment obtenir le même hachage que Python, PHP, Perl, Github (et éviter un problème):

NodeJS hache la représentation UTF-8 de la chaîne. D’autres langages (comme Python, PHP ou PERL …) hachent la chaîne d’octets.

Nous pouvons append un argument binary pour utiliser la chaîne d’octets.

Code:

 const crypto = require("crypto"); function sha256(data) { return crypto.createHash("sha256").update(data, "binary").digest("base64"); // ------ binary: hash the byte ssortingng } sha256("ssortingng or binary"); 

Documentation:

  • crypto.createHash (algorithme [, options]): L’algorithme dépend des algorithmes disponibles pris en charge par la version d’OpenSSL sur la plate-forme.
  • hash.digest ([encoding]): L’encodage peut être ‘hex’, ‘latin1’ ou ‘base64’. (la base 64 est moins longue).

Vous pouvez obtenir le problème avec: sha256 (“\ xac”), “\ xd1”, “\ xb9”, “\ xe2”, “\ xbb”, “\ x93”, etc …

  • Autres langages (comme PHP, Python, Perl …) et ma solution avec .update(data, "binary") :

     sha1("\xac") //39527c59247a39d18ad48b9947ea738396a3bc47 
  • Nodejs par défaut (sans binary):

     sha1("\xac") //f50eb35d94f1d75480496e54f4b4a472a9148752 

Le module de crypto rend cela très facile.

Installer:

 const crypto = require('crypto'); const sha256 = x => crypto.createHash('sha256').update(x, 'utf8').digest('hex'); 

Usage:

 sha256('Hello, world. '); 

Ici, vous pouvez évaluer tous les hachages pris en charge sur votre matériel, pris en charge par votre version de node.js. Certains sont cryptographiques et d’autres servent uniquement à une sum de contrôle. Son calcul “Hello World” 1 million de fois pour chaque algorithme. Cela peut prendre environ 1 à 15 secondes pour chaque algorithme (testé sur le moteur Google Computing standard avec Node.js 4.2.2).

 for(var i1=0;i1 

Résultat:
DSA: 1992ms
DSA-SHA: 1960ms
DSA-SHA1: 2062ms
DSA-SHA1-old: 2124ms
RSA-MD4: 1893ms
RSA-MD5: 1982ms
RSA-MDC2: 2797ms
RSA-RIPEMD160: 2101ms
RSA-SHA: 1948ms
RSA-SHA1: 1908ms
RSA-SHA1-2: 2042ms
RSA-SHA224: 2176ms
RSA-SHA256: 2158ms
RSA-SHA384: 2290ms
RSA-SHA512: 2357ms
dsaEncryption: 1936ms
dsaWithSHA: 1910ms
dsaWithSHA1: 1926ms
dss1: 1928ms
ecdsa-avec-SHA1: 1880ms
md4: 1833ms
md4WithRSAEncryption: 1925ms
md5: 1863ms
md5WithRSAEncryption: 1923ms
mdc2: 2729ms
mdc2WithRSA: 2890ms
Ripemd: 2101ms
ripemd160: 2153ms
ripemd160WithRSA: 2210ms
rmd160: 2146ms
sha: 1929ms
sha1: 1880ms
sha1WithRSAEncryption: 1957ms
sha224: 2121ms
sha224WithRSAEncryption: 2290ms
sha256: 2134ms
sha256WithRSAEncryption: 2190ms
sha384: 2181ms
sha384WithRSAEncryption: 2343ms
sha512: 2371ms
sha512WithRSAEncryption: 2434ms
shaWithRSAEncryption: 1966ms
ssl2-md5: 1853ms
ssl3-md5: 1868ms
ssl3-sha1: 1971ms
bain tourbillon: 2578ms

Considérant les pensées de http://www.thoughtcrime.org/blog/the-cryptographic-doom-principle/ (en bref: FIRST encrypt, THEN authentifier. Ensuite, FIRST vérifier, THEN decrypt) J’ai implémenté la solution suivante dans node. js:

 function encrypt(text,password){ var cipher = crypto.createCipher(algorithm,password) var crypted = cipher.update(text,'utf8','hex') crypted += cipher.final('hex'); return crypted; } function decrypt(text,password){ var decipher = crypto.createDecipher(algorithm,password) var dec = decipher.update(text,'hex','utf8') dec += decipher.final('utf8'); return dec; } function hashText(text){ var hash = crypto.createHash('md5').update(text).digest("hex"); //console.log(hash); return hash; } function encryptThenAuthenticate(plainText,pw) { var encryptedText = encrypt(plainText,pw); var hash = hashText(encryptedText); return encryptedText+"$"+hash; } function VerifyThenDecrypt(encryptedAndAuthenticatedText,pw) { var encryptedAndHashArray = encryptedAndAuthenticatedText.split("$"); var encrypted = encryptedAndHashArray[0]; var hash = encryptedAndHashArray[1]; var hash2Compare = hashText(encrypted); if (hash === hash2Compare) { return decrypt(encrypted,pw); } } 

Il peut être testé avec:

 var doom = encryptThenAuthenticate("The encrypted text",user.cryptoPassword); console.log(VerifyThenDecrypt(doom,user.cryptoPassword)); 

J’espère que cela t’aides 🙂

J’utilise blueimp-md5 qui est “compatible avec les environnements côté serveur tels que Node.js, les chargeurs de modules tels que RequireJS, Browserify ou Webpack et tous les navigateurs Web.”

Utilisez-le comme ceci:

 var md5 = require("blueimp-md5"); var myHashedSsortingng = createHash('GreensterRox'); createHash(mySsortingng){ return md5(mySsortingng); } 

Si vous passez des valeurs de hachage au grand jour, il est toujours bon de les saluer pour que les gens puissent les recréer plus difficilement:

 createHash(mySsortingng){ var salt = 'HnasBzbxH9'; return md5(mySsortingng+salt); }