web-dev-qa-db-fra.com

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 sert à la gestion des versions, pas à la sécurité.

hashnode.js
294
Harry

Jetez un 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);
});
201
timbooo

Si vous voulez juste md5 hacher une chaîne simple, je trouve 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
639
braitsch

L'API du module de cryptographie du nœud est toujours instable.

Depuis 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é satisfaisant. La compatibilité avec l'écosystème npm est une priorité absolue et ne sera rompue que si cela est absolument nécessaire.

Ainsi, il devrait être considéré comme sûr d’utiliser l’implémentation native, 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 dont les deux font 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 n'est pas sécurisé mais est souvent utilisé par des services tels que Gravatar.)

L'API de ces modules ne changera pas!

77
pvorb
sha256("string or binary");

J'ai rencontré un problème avec une autre réponse. Je vous conseille de définir l'argument de codage sur binary pour utiliser la chaîne d'octets et éviter un hachage différent entre Javascript (NodeJS) et un autre langage/service 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 hash que Python, PHP, Perl, Github (et éviter un problème):

NodeJS est en train de hacher 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 ajouter un argument binaire 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 string
}

sha256("string 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 binaire):

    sha1("\xac") //f50eb35d94f1d75480496e54f4b4a472a9148752
18
A-312

Le module 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. ');
12
sdgfsdh

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 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-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-with-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 à remous: 2578ms

8
user3077458

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 myHashedString = createHash('GreensterRox');

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

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

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

Considérant les pensées de http://www.thoughtcrime.org/blog/the-cryptographic-Doom-principle/ (en bref: PREMIER CODE, PUIS authentifier. Ensuite, PREMIER vérifier, PUIS déchiffrer), j'ai a 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 :-)

1
batomaeus

Même si le hachage n’est pas destiné à la sécurité, vous pouvez utiliser sha au lieu de md5. À mon avis, les gens devraient oublier md5 pour l’instant, c’est du passé!

Le noeud normal sha256 est obsolète. Donc, vous avez deux alternatives pour le moment:

var shajs = require('sha.js') - https://www.npmjs.com/package/sha.js (utilisé par Browserify)

var hash = require('hash.js') - https://github.com/indutny/hash.js

Je préfère utiliser shajs au lieu de hash, car je considère que sha est la meilleure fonction de hachage de nos jours et vous n'avez pas besoin d'une fonction de hachage différente pour l'instant. Donc, pour obtenir un hachage dans l'hex, vous devriez faire quelque chose comme ceci: sha256.update('hello').digest('hex').

0
Moisés Ferreira