viernes 27 septiembre 2024

Cómo generar valores hash con HASHBYTES en SQL Server

¿Qué es `HASHBYTES` y para qué se usa?

HASHBYTES es una función criptográfica que toma una cadena de texto o un valor binario y devuelve un valor hash (o digest) que representa la entrada de manera compacta. Los valores hash son secuencias de longitud fija, únicas para cada entrada distinta, y tienen la propiedad de ser difíciles de revertir. HASHBYTES se utiliza comúnmente en los siguientes escenarios:

Verificar integridad de datos: Comparar valores hash para detectar si se realizaron cambios en los datos.
Almacenamiento de contraseñas: Crear versiones encriptadas de contraseñas para su almacenamiento.
Detección de duplicados: Identificar registros duplicados mediante sus valores hash.
Generar identificadores únicos: Crear firmas o resúmenes de texto para garantizar la unicidad en conjuntos de datos.

Sintaxis de `HASHBYTES`

HASHBYTES ( 'algoritmo', input )

algoritmo: Especifica el algoritmo de hash que se utilizará. Los valores permitidos son:
'MD2'
'MD4'
'MD5'
'SHA' (equivalente a SHA-1)
'SHA1'
'SHA2_256' (SHA-256)
'SHA2_512' (SHA-512)
input: La cadena de texto o valor binario que se desea convertir en un hash. Puede ser de tipo nvarchar, varchar o varbinary.

Ejemplos de uso de `HASHBYTES`

Generar un hash MD5 de una cadena de texto

Supongamos que tienes una cadena y deseas calcular su hash usando el algoritmo MD5:

SELECT HASHBYTES('MD5', 'Hola Mundo') AS HashMD5;

Resultado:

HashMD5
---------------------------------
0x68E109F0F40CA72A15E05CC22786F8E6

El valor 0x68E109F0F40CA72A15E05CC22786F8E6 es el hash MD5 en formato hexadecimal para la cadena 'Hola Mundo'.

Generar un hash SHA-256 para una cadena

Si necesitas un hash más seguro, puedes utilizar SHA2_256:

SELECT HASHBYTES('SHA2_256', 'ContraseñaSegura') AS HashSHA256;

Resultado:

HashSHA256
-----------------------------------------
0x6AA9D6D06CD7D4AF8B1D726295B6BA6470F097D7081B2C24BA1A841E65B9AF8E

El resultado es un hash de 256 bits, que es más seguro y largo que el hash MD5.

Generar hashes para datos de una tabla

Supongamos que tienes una tabla Usuarios con las columnas UsuarioID y Contraseña, y deseas almacenar las contraseñas como hashes usando SHA2_256:

UPDATE Usuarios
SET Contraseña = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', Contraseña));

Esto convierte las contraseñas existentes en hashes de 64 caracteres (SHA-256) y los actualiza en la tabla Usuarios.

Comparar valores hash para verificar integridad

Si tienes dos valores y deseas verificar si son idénticos:

DECLARE @Cadena1 NVARCHAR(100) = 'Hola Mundo';
DECLARE @Cadena2 NVARCHAR(100) = 'Hola Mundo!';

IF HASHBYTES('SHA2_256', @Cadena1) = HASHBYTES('SHA2_256', @Cadena2)
    PRINT 'Las cadenas son iguales';
ELSE
    PRINT 'Las cadenas son diferentes';

El resultado será 'Las cadenas son diferentes' porque los valores hash generados para cada cadena serán distintos.

Generar un hash para múltiples columnas

Puedes combinar varias columnas de una fila y calcular un hash que represente la fila completa. Esto es útil para detectar cambios en los datos:

SELECT HASHBYTES('SHA2_256', CONCAT(Nombre, Apellido, Telefono)) AS HashFila
FROM Empleados;

Esto genera un hash único para cada combinación de Nombre, Apellido y Telefono.

Almacenamiento de hashes en formato binario

El valor que devuelve HASHBYTES es de tipo VARBINARY, por lo que se almacena mejor en columnas VARBINARY. Por ejemplo:

CREATE TABLE Contraseñas (
    UsuarioID INT PRIMARY KEY,
    HashContraseña VARBINARY(64)
);

INSERT INTO Contraseñas (UsuarioID, HashContraseña)
VALUES (1, HASHBYTES('SHA2_512', 'Contraseña123'));

Esto inserta un hash de 512 bits para la contraseña 'Contraseña123'.

Comparar valores hash en una consulta

Si deseas comparar contraseñas de texto plano con los hashes almacenados, utiliza HASHBYTES en la cláusula WHERE:

SELECT UsuarioID 
FROM Contraseñas
WHERE HashContraseña = HASHBYTES('SHA2_512', 'Contraseña123');

Esto busca registros en los que el valor hash de 'Contraseña123' coincida con el hash almacenado en la columna HashContraseña.

Consideraciones importantes

Los algoritmos de hash más antiguos como MD2, MD4, MD5 y SHA (SHA-1) se consideran inseguros para aplicaciones criptográficas debido a vulnerabilidades conocidas. Se recomienda utilizar algoritmos más seguros como SHA2_256 o SHA2_512.
La función HASHBYTES devuelve NULL si se usa con cadenas de más de 8000 bytes para tipos de datos varchar o nvarchar. En estos casos, se sugiere utilizar conversiones a varbinary.
El resultado de HASHBYTES es de tipo VARBINARY, por lo que para mostrarlo como texto, se debe convertir a VARCHAR si se necesita un formato legible.

SELECT CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', 'Texto'));

No utilices HASHBYTES para comparar directamente contraseñas de texto plano. En su lugar, utiliza técnicas de "salting" y "hashing" seguras para mejorar la protección de contraseñas.

Referencia oficial

Para más información sobre HASHBYTES, consulta la documentación oficial de Microsoft.

Etiquetas:

sql sql server bases de datos

Creado por:

Jorge García

Fullstack developer