Este tutorial le mostrará una forma práctica de generar un hash para una cadena en JavaScript y le brindará ejemplos de código de trabajo que puede usar en su propio proyecto.
¿Qué es un hash?
Un Hash o Checksum es un valor calculado con una longitud específica. Al pasar un algoritmo hash a una cadena, que puede tener cualquier longitud, se devuelve un hash calculado de una longitud constante. Cada vez que se pasa la misma cadena al algoritmo hash, se debe devolver el mismo hash calculado.
Como el resultado del algoritmo hash debe ser siempre el mismo, siempre que la entrada sea la misma, el valor devuelto se puede usar para determinar si el valor original se modificó o no.
Un ejemplo de uso de esto es con descargas de archivos. Se descarga un archivo y el archivo descargado, independientemente de su tamaño, se puede codificar. Este hash se puede comparar con el hash del archivo original para verificar que la descarga se haya realizado correctamente y que no se haya dañado.
Como los hashes tienen un tamaño fijo que es más pequeño que el archivo descargado, no es necesario volver a descargar el archivo para verificarlo; solo se necesita conocer el hash mucho más corto.
Usos en JavaScript
Esto es útil en JavaScript solo para ese propósito:verificar los datos transferidos. Si se conoce el hash de una gran cantidad de datos, se puede verificar.
Algoritmos hash seguros
El hash se usa a menudo en seguridad y criptografía, especialmente hash que son difíciles de revertir. Los hashes utilizados para la criptografía también se pueden usar para otros fines, como el ejemplo de verificación de descarga descrito anteriormente.
Generando un Hash en JavaScript
SubtleCrypto es una adición reciente a JavaScript que se puede usar para generar hashes seguros.
Se pueden usar para generar hashes para cualquier propósito, no solo de seguridad, lo cual es útil porque significa que podemos usarlos en lugar de escribir código adicional nosotros mismos.
La siguiente función usa SubtleCrypto para generar el hash seguro para una cadena dada:
// Function to generate a hash from a string
// The algorithm used can be specified, or will default to SHA-512
function generateHash(str, algorithm = "SHA-512") {
// Create an array buffer for the supplied string - this buffer contains an integer representation of the string which can be used to generate the hash
let strBuffer = new TextEncoder().encode(str);
// use SubtleCrypto to generate the hash using the specified algorithm
return crypto.subtle.digest(algorithm, strBuffer)
.then(hash => {
// The resulting hash is an arrayBuffer, and should be converted to its hexadecimal representation
// Initialize the result as an empty string - the hexadecimal characters for the values in the array buffer will be appended to it
let result = '';
// The DataView view provides an interface for reading number types from the ArrayBuffer
const view = new DataView(hash);
// Iterate over each value in the arrayBuffer and append the converted hexadecimal value to the result
for (let i = 0; i < hash.byteLength; i += 4) {
result += ('00000000' + view.getUint32(i).toString(16)).slice(-8);
}
return result;
});
} Esta función devuelve una Promesa, se usa así:
generateHash('London Bridge is falling down')
.then(hash => {
console.log(hash);
}); La promesa se resuelve con el hash de la cadena proporcionada:un hash SHA-512 que contiene valores hexadecimales.
¿Desarrollando su propia autenticación?
Si está utilizando sus propias funciones de hash para crear su propio sistema de autenticación, ya sea cifrando contraseñas para el almacenamiento, generando códigos de verificación o cualquier cosa relacionada con la seguridad... No lo haga.
Utilice una biblioteca o servicio mantenido, establecido y debidamente examinado por la comunidad para manejar su autenticación. No vale la pena mantener su propio sistema; incluso un simple error podría comprometer su aplicación, sus sistemas o la información privada de sus usuarios.