Si vous voulez juste MD5 hash une chaîne simple, j'ai trouvé que cela fonctionne 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 crypto de Node est toujours instable.

Depuis la version 4.0.0, le module crypto natif n'est plus instable. Extrait de la documentation officielle :

Crypto

Stabilité: 2 - Stable

L'API s'est avérée satisfaisante. Compatibilité avec l'écosystème npm est une priorité élevée et ne sera pas brisée à moins d'être absolument nécessaire.

Donc, il devrait être considéré comme sûr d'utiliser le natif implémentation, sans dépendances externes.

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

Vous pouvez également utiliser l'un des modules sha1 ou md5, qui à la fois faire le travail.

$ npm install sha1

, puis

var sha1 = require('sha1');

var hash = sha1("my message");

console.log(hash); // 104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb

Ou

$ npm install md5

, puis

var md5 = require('md5');

var hash = md5("my message");

console.log(hash); // 8ba6c19dc1def5702ff5acbf2aeea5aa

(MD5 est non sécurisé mais souvent utilisé par des services comme Gravatar.)

L'API de ces modules ne changera pas!

sha256("string or binary");

J'ai rencontré un problème avec une autre réponse. Je vous conseille de définir l'argument d'encodage sur binary pour utiliser la chaîne d'octets et éviter un hachage différent entre Javascript (NodeJS) et d'autres langages/services comme Python, PHP, Github...

Si vous n'utilisez pas ce code, vous pouvez obtenir un hachage différent entre NodeJS et Python...

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

NodeJS est en train de hacher la représentation UTF-8 du chaîne. D'autres langages (comme Python, PHP ou PERL...) sont en train de hacher la chaîne d'octets.

, Nous pouvons ajouter binaire argument pour l'utilisation de 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 string
}

sha256("string or binary");

Documentation:

• crypto.createHash(algorithm [, options]): l'algorithme dépend des algorithmes disponibles pris en charge par la version D'OpenSSL sur la plate-forme.
• hachage.digest([encodage]):, Le codage peut être 'hex', 'latin1' ou 'base64'. (la base 64 est moins longue).

, Vous pouvez obtenir de la question 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 binaire) :

  sha1("\xac") //f50eb35d94f1d75480496e54f4b4a472a9148752
  

Le module crypto rend cela très facile.

Configuration:

const crypto = require('crypto');

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

Utilisation:

sha256('Hello, world. ');

Ici, vous pouvez comparer tous les hachages pris en charge sur votre matériel, pris en charge par votre version de node.js. Certains sont cryptographiques, et certains sont juste pour une somme 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 de calcul Google Standard avec Node.js 4.2.2).

for(var i1=0;i1<crypto.getHashes().length;i1++){
  var Algh=crypto.getHashes()[i1];
  console.time(Algh);
  for(var i2=0;i2<1000000;i2++){
    crypto.createHash(Algh).update("Hello World").digest("hex");
  }
  console.timeEnd(Algh);  
}

Résultat:
DSA: 1992ms
DSA-SHA: 1960ms
DSA-SHA1: 2062ms
DSA-sha1-Vieux: 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: 1910 ms
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
tourbillon: 2578ms

Considérant les pensées de http://www.thoughtcrime.org/blog/the-cryptographic-doom-principle/ (en bref: d'abord chiffrer, puis authentifier. Ensuite, vérifiez D'abord, puis décryptez) 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 aide : -)

J'utilise blueimp-md5 qui est " Compatible avec les environnements côté serveur comme Node.js, Chargeurs de modules comme RequireJS, Browserify ou webpack et tous les navigateurs web."

Utilisez-le comme ceci:

var md5 = require("blueimp-md5");

var myHashedString = createHash('GreensterRox');

createHash(myString){
    return md5(myString);
}

Si vous passez des valeurs hachées à l'air libre, c'est toujours une bonne idée de les saler pour qu'il soit plus difficile pour les gens de les recréer:

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