nodejs - node hash sha256

node.js cadena de hash?

Question

Tengo una cadena que quiero hash. ¿Cuál es la forma más fácil de generar el hash en node.js?

El hash es para versiones, no seguridad.

Answer 1

Aquí puede evaluar todos los hashes admitidos en su hardware, admitidos por su versión de node.js. Algunos son criptográficos, y otros son solo para una suma de comprobación. Su cálculo "Hola Mundo" 1 millón de veces para cada algoritmo. Puede tomar alrededor de 1 a 15 segundos para cada algoritmo (probado en el motor de computación estándar de Google con 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);  
}

Resultado:
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-con-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
Hidromasaje: 2578ms

Answer 2

Echa un vistazo a crypto.createHash(algorithm)

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);
});

Answer 3

El módulo crypto hace muy fácil.

Preparar:

const crypto = require(''crypto'');

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

Uso:

sha256(''Hello, world. '');

Answer 4

Si solo quieres md5 hash una simple cadena encontré que esto funciona para mí.

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

Answer 5

Teniendo en cuenta los pensamientos de http://www.thoughtcrime.org/blog/the-cryptographic-doom-principle/ (en pocas palabras: PRIMERO cifrar, LUEGO autenticar. Luego PRIMERO verificar, LUEGO descifrar) He implementado la siguiente solución en el nodo. 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); 
    }
}

Se puede probar con:

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

Espero que esto ayude :-)

Answer 6

Uso blueimp-md5 que es "Compatible con entornos del lado del servidor como Node.js, cargadores de módulos como RequireJS, Browserify o webpack y todos los navegadores web".

Úsalo así:

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

var myHashedString = createHash(''GreensterRox'');

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

Si pasar valores hash al descubierto es siempre una buena idea saltearlos para que a las personas les resulte más difícil recrearlos:

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

Answer 7

La API del módulo criptográfico de Node sigue siendo inestable.

A partir de la versión 4.0.0, el módulo criptográfico nativo ya no es inestable. De la documentación oficial :

Crypto

Estabilidad: 2 - Estable

La API ha demostrado ser satisfactoria. La compatibilidad con el ecosistema npm es una alta prioridad y no se romperá a menos que sea absolutamente necesario.

Por lo tanto, debe considerarse seguro utilizar la implementación nativa, sin dependencias externas.

Para referencia, los módulos que se mencionan a continuación fueron sugeridos como soluciones alternativas cuando el módulo Crypto aún era inestable.

También puede usar uno de los módulos sha1 o md5 que hacen el trabajo.

$ npm install sha1

y entonces

var sha1 = require(''sha1'');

var hash = sha1("my message");

console.log(hash); // 104ab42f1193c336aa2cf08a2c946d5c6fd0fcdb

o

$ npm install md5

y entonces

var md5 = require(''md5'');

var hash = md5("my message");

console.log(hash); // 8ba6c19dc1def5702ff5acbf2aeea5aa

(MD5 es inseguro pero a menudo es usado por servicios como Gravatar).

¡La API de estos módulos no cambiará!

Answer 8

sha256("string or binary");

Experimenté problema con otra respuesta. Le aconsejo que establezca el argumento de codificación en binary para usar la cadena de bytes y evitar el hash diferente entre Javascript (NodeJS) y otros servicios / idiomas como Python, PHP, Github ...

Si no usa este código, puede obtener un hash diferente entre NodeJS y Python ...

Cómo obtener el mismo hash que Python, PHP, Perl, Github (y evitar un problema):

NodeJS es hashing de la representación UTF-8 de la cadena. Otros lenguajes (como Python, PHP o PERL ...) son hash de la cadena de bytes.

Podemos agregar un argumento binario para usar la cadena de bytes.

Código:

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");

Documentación:

• crypto.createHash (algoritmo [, opciones]): El algoritmo depende de los algoritmos disponibles compatibles con la versión de OpenSSL en la plataforma.
• hash.digest ([codificación]): la codificación puede ser ''hex'', ''latin1'' o ''base64''. (la base 64 es menos larga).

Puede obtener el problema con: sha256 ("/ xac"), "/ xd1", "/ xb9", "/ xe2", "/ xbb", "/ x93", etc ...

• Otros idiomas (como PHP, Python, Perl ...) y mi solución con .update(data, "binary") :

  sha1("/xac") //39527c59247a39d18ad48b9947ea738396a3bc47

• Nodejs por defecto (sin binario):

  sha1("/xac") //f50eb35d94f1d75480496e54f4b4a472a9148752