Hashing seguro de contraseñas en Go

Las credenciales de usuario son la información necesaria para autenticar la identidad de una persona y darle acceso a un sistema o una aplicación. Por lo general, incluyen un nombre de usuario o una dirección de correo electrónico y una contraseña. Aunque el nombre de usuario se puede almacenar como texto sin formato en una base de datos, la información confidencial, como las direcciones de correo electrónico o las contraseñas, no debería almacenarse así.

Si un actor malicioso obtiene acceso a la base de datos donde almacenas esta información, no quieres ponérsela fácilmente a su alcance. En cambio, debes asegurarte de que no pueda acceder a ella, incluso si hace un esfuerzo decidido y utiliza todos los recursos disponibles. Aquí es donde el hashing cobra importancia.

Como continuación de nuestra publicación anterior sobre hashing de contraseñas en Java, en esta publicación hablaremos del hashing de contraseñas en Go. Empecemos por repasar algunos conceptos y prácticas recomendadas del hashing de contraseñas.

Usa hashing para las contraseñas 

Un hash es una función matemática que toma una entrada (en este caso, una contraseña) y genera una cadena de caracteres de tamaño fijo, que suele ser una combinación de letras y números. El resultado, conocido como valor hash o código hash, es único para cada entrada. Las funciones hash están diseñadas para ser unidireccionales, lo que significa que es computacionalmente inviable reconstruir la entrada original a partir del valor hash. Para almacenar contraseñas de forma segura, se les aplica hashing y se guardan como valores hash en lugar de texto sin formato.

La diferencia entre hashing y cifrado es que, mientras que el hashing es una función unidireccional, el cifrado es una función bidireccional que permite recuperar el valor original a partir del valor cifrado. El cifrado se usa comúnmente para datos confidenciales, como el correo electrónico y otros datos de identificación personal, pero para las contraseñas se recomienda el hashing.

Pero, si el hashing es una función unidireccional, ¿cómo verificamos las credenciales de usuario? El proceso es sencillo: generamos un hash de la contraseña en texto sin formato que proporciona el usuario y lo comparamos con el hash almacenado en nuestra base de datos. Si los hashes coinciden, la contraseña es correcta. Si no coinciden, las credenciales son incorrectas. La ventaja del hashing es que nunca necesitamos conocer la contraseña real del usuario.

Métodos de ataque

Antes dijimos que debes asegurarte de que no puedan acceder a esta información, incluso si hacen un esfuerzo decidido y utilizan todos los recursos disponibles. Un actor malicioso puede usar varios métodos para obtener la contraseña a partir del hash.

Un hacker podría tener acceso a una lista de tus contraseñas obtenida de otras fuentes, como cuentas vulneradas. Puede usar una tabla rainbow para intentar descifrar el hash. Si los hashes coinciden, habrá descifrado la contraseña. También puede recurrir a ataques de fuerza bruta, en los que prueba distintas combinaciones de contraseñas para ver si el hash de la contraseña generada coincide con el de la contraseña original.

Aunque esto requiere recursos de alta velocidad o una gran capacidad de cómputo, estos métodos han demostrado ser eficaces contra algoritmos de hashing antiguos, como los de la familia SHA1, dada la capacidad de cómputo disponible actualmente.

Por eso, es sumamente importante usar algoritmos de hashing más recientes y otras prácticas recomendadas para asegurarse de que sea imposible descifrar el hash generado, o que hacerlo tome varias décadas de permutaciones y combinaciones.

Prácticas recomendadas para el hashing

Estas son algunas prácticas recomendadas para usar métodos modernos de hashing.

Salting

Un valor salt es un valor generado aleatoriamente (por lo general, datos binarios aleatorios, como bytes) que se agrega a la contraseña al crear un hash. Cada contraseña tiene su propio salt único. Esto brinda una capa adicional de seguridad, ya que el actor malicioso tendría que descifrar el salt y el hash. Por lo tanto, descifrar el hash se convierte en un proceso de dos pasos que requiere más recursos.

La longitud del salt depende del algoritmo de hashing utilizado. En los algoritmos más recientes, el salt se genera automáticamente, por lo que no es necesario proporcionarlo. Para obtener más información, consulta esta hoja de referencia de OWASP sobre el almacenamiento de contraseñas.

Algoritmos de hashing

Los algoritmos de hashing desempeñan un papel crucial en el hashing de contraseñas. Es esencial elegir un algoritmo resistente al descifrado. Los algoritmos de hashing modernos permiten personalizar ajustes como el factor de trabajo y las iteraciones de hashing, lo que hace que el hash sea más difícil de descifrar. Teniendo en cuenta la capacidad de cómputo disponible, se recomienda elegir valores más altos. Como regla general, cuanto mayor sea el factor de trabajo o el número de iteraciones, más difícil será descifrar el hash.

Como práctica recomendada, selecciona el valor más alto posible para el factor de trabajo o el número de iteraciones que tu sistema pueda manejar sin un impacto significativo en el rendimiento.

Consideraciones sobre los algoritmos hash

Estos son algunos aspectos que debes tener en cuenta al implementar un algoritmo hash.

Gestión de colisiones de hash

Las colisiones de hash se producen cuando dos entradas distintas generan el mismo valor hash. Aunque los algoritmos de hashing modernos están diseñados para minimizar la probabilidad de que ocurran, las colisiones siguen siendo posibles. Para mitigar este riesgo, se recomienda usar valores hash más largos, como SHA-256 o SHA-512, que ofrecen un espacio de salida mayor y reducen la probabilidad de colisiones.

Número de iteraciones

El número de iteraciones es un factor importante para el hashing de contraseñas. Cuanto mayor sea, más recursos se necesitarán para descifrar el hash, lo que ralentizará el ataque. Sin embargo, es importante encontrar un equilibrio entre la seguridad y el rendimiento, ya que demasiadas iteraciones pueden generar demoras para los usuarios legítimos durante el proceso de autenticación. Se recomienda usar un valor que brinde seguridad adecuada sin afectar significativamente el rendimiento.

Actualiza los algoritmos de hashing con regularidad

A medida que avanza la tecnología y aumenta la capacidad de cómputo, se desarrollan nuevos algoritmos de hashing y se dejan de usar los antiguos. Esto se debe a que los algoritmos antiguos ya no pueden seguir el ritmo de estos avances y se convierten en blancos fáciles para los atacantes.

Hashing de contraseñas en Go

El paquete crypto de Go incluye funciones de hashing para algoritmos populares como argon2, scrypt, bcrypt, pbkdf2 y otros. Estas funciones son muy útiles para implementar la funcionalidad de hashing de contraseñas. El paquete bcrypt incluso incluye una función CompareHashAndPassword para comparar contraseñas en texto sin formato con contraseñas con hash y comprobar si coinciden.

Argon2

Actualmente, Argon2 se considera el algoritmo de hashing más seguro (aunque esto podría cambiar en el futuro). Tiene tres variantes: Argon2d, que maximiza la resistencia a los ataques de descifrado con GPU; Argon2i, optimizado para resistir ataques de canal lateral; y Argon2id, que combina ambos enfoques.

La hoja de referencia de OWASP sobre el almacenamiento de contraseñas recomienda usar el algoritmo híbrido Argon2id para almacenar contraseñas. La hoja de referencia recomienda los siguientes valores mínimos para el tamaño de memoria (m), el número mínimo de iteraciones (t) y el grado de paralelismo (p):

• m=47104 (46 MiB), t=1, p=1 (No usar con Argon2i)

• m=19456 (19 MiB), t=2, p=1 (No usar con Argon2i)

• m=12288 (12 MiB), t=3, p=1

• m=9216 (9 MiB), t=4, p=1

• m=7168 (7 MiB), t=5, p=1

Implementación en Go

Veamos ahora un ejemplo de implementación de Argon2id para generar un hash a partir de una contraseña en texto sin formato y compararlo con el hash.

Configuración

Para empezar, crearemos una estructura que almacene todos los parámetros de configuración necesarios para aplicar hashing con Argon2id:

1type Argon2idHash struct {
2	// time represents the number of 
3	// passed over the specified memory.
4	time    uint32
5	// cpu memory to be used.
6	memory  uint32
7	// threads for parallelism aspect
8	// of the algorithm.
9	threads uint8
10	// keyLen of the generate hash key.
11	keyLen  uint32
12	// saltLen the length of the salt used.
13	saltLen uint32
14}

La estructura Argon2idHash contiene los siguientes parámetros: time, memory (costo de cómputo), threads (paralelismo), keyLen y saltLen. Estos parámetros se usan para generar un hash a partir de una contraseña en texto sin formato.

A continuación, escribiremos una función constructora para inicializar la estructura con los valores proporcionados.

1// NewArgon2idHash constructor function for 
2// Argon2idHash.
3func NewArgon2idHash(time, saltLen uint32, memory uint32, threads uint8, keyLen uint32) *Argon2idHash {
4	return &Argon2idHash{
5		time:    time,
6		saltLen: saltLen,
7		memory:  memory,
8		threads: threads,
9		keyLen:  keyLen,
10	}
11}

Generación del salt

Para facilitar la generación de valores aleatorios, especialmente la del salt, desarrollamos la función randomSecret. Esta función acepta la longitud deseada del valor secreto aleatorio y usa la función rand.Read para generarlo.

1func randomSecret(length uint32) ([]byte, error) {
2	secret := make([]byte, length)
3
4	_, err := rand.Read(secret)
5	if err != nil {
6		return nil, err
7	}
8
9	return secret, nil
10}

Generación del hash

A continuación, creamos el método de hashing GenerateHash en la estructura Argon2idHash. Este método nos permite generar un hash con los valores configurados. Si no se proporciona un salt aleatorio, generamos uno con la misma longitud que el salt configurado. Luego, usamos todos los valores configurados para generar el hash con la función argon2.IDKey. Si el hash se genera correctamente, devolvemos el par de hash y salt.

1// GenerateHash using the password and provided salt.
2// If not salt value provided fallback to random value
3// generated of a given length.
4func (a *Argon2idHash) GenerateHash(password, salt []byte) (*HashSalt, error) {
5	var err error
6	// If salt is not provided generate a salt of
7	// the configured salt length.
8	if len(salt) == 0 {
9		salt, err = randomSecret(a.saltLen)
10	}
11	if err != nil {
12		return nil, err
13	}
14	// Generate hash
15	hash := argon2.IDKey(password, salt, a.time, a.memory, a.threads, a.keyLen)
16	// Return the generated hash and salt used for storage.
17	return &HashSalt{Hash: hash, Salt: salt}, nil
18}

Comparación de contraseñas

Para comparar contraseñas, creamos otro método, Compare, en la estructura Argon2idHash. Este método recibe el hash y el salt almacenados, junto con la contraseña que se va a comparar.

Primero, generamos un hash con la función GenerateHash que creamos en el paso anterior. Esta función recibe la contraseña y el salt proporcionados como entradas.

A continuación, comparamos el hash generado con el hash almacenado mediante la función bytes.Equal. Si los dos hashes son iguales, coinciden. Si no, significa que el hash almacenado no corresponde a la contraseña proporcionada.

1// Compare generated hash with store hash.
2func (a *Argon2idHash) Compare(hash, salt, password []byte) error {
3	// Generate hash for comparison.
4	hashSalt, err := a.GenerateHash(password, salt)
5	if err != nil {
6		return err
7	}
8	// Compare the generated hash with the stored hash.
9	// If they don't match return error.
10	if !bytes.Equal(hash, hashSalt.Hash) {
11		return errors.New("hash doesn't match")
12	}
13	return nil
14}

En este ejemplo, usamos la función argon2.IDKey para generar el hash. Como mencionamos antes, otros paquetes de criptografía de Go tienen funciones similares que se pueden usar para generar hashes seguros de contraseñas, como el que generamos en este ejemplo.

Scrypt

Scrypt ocupa el segundo lugar en la lista de algoritmos de hashing. Argon2id debería ser tu primera opción; si no está disponible, scrypt debería ser tu alternativa.

Al igual que con Argon2id, la hoja de referencia de OWASP sobre el almacenamiento de contraseñas recomienda los siguientes valores para los campos: parámetro mínimo de costo de CPU y memoria (N), tamaño de bloque (r) y grado de paralelismo (p).

• N = 2^17 (128 MiB), r = 8 (1024 bytes), p = 1

• N = 2^16 (64 MiB), r = 8 (1024 bytes), p = 2

• N = 2^15 (32 MiB), r = 8 (1024 bytes), p = 3

• N = 2^14 (16 MiB), r = 8 (1024 bytes), p = 5

• N = 2^13 (8 MiB), r = 8 (1024 bytes), p = 10

La documentación del paquete de Go para el paquete scrypt incluye un ejemplo de cómo generar una clave hash con scrypt. Las operaciones para generar y comparar deberían ser muy similares a las que implementamos para la estructura ^Argon2idHash.

Bcrypt

bcrypt debería ser tu último recurso, al igual que PBKDF2 (que veremos a continuación) si necesitas cumplir con FIPS-140. Según la hoja de referencia de OWASP sobre el almacenamiento de contraseñas, el factor de trabajo debe ser lo más alto posible sin superar lo que permita el rendimiento del servidor de verificación, con un mínimo de 10.

El paquete bcrypt de Go incluye funciones para generar y comparar hashes. Por eso, no veremos un ejemplo aquí. Puedes consultar la documentación del paquete de Go para ver ejemplos.

PBKDF2 (compatible con FIPS 140)

Según la hoja de referencia de OWASP sobre el almacenamiento de contraseñas, el factor de trabajo de PBKDF2 se implementa mediante un número de iteraciones que debe ajustarse según el algoritmo de hashing interno utilizado.

• PBKDF2-HMAC-SHA1: 1,300,000 iteraciones

• PBKDF2-HMAC-SHA256: 600,000 iteraciones

• PBKDF2-HMAC-SHA512: 210,000 iteraciones

Ejemplo de hashing

Como PBKDF2 es el único algoritmo de nuestra lista que cumple con FIPS 140, veremos cómo usarlo para aplicar hashing a contraseñas en Go. Empecemos.

A continuación, se muestra la función ToKey del paquete pbkdf2, que usaremos para generar un hash a partir de una contraseña en texto sin formato:

1func Key(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte

Para realizar el hashing, necesitarás la contraseña y la sal como slices de bytes, junto con el número de iteraciones y la longitud deseada de la clave o el hash generado. También se necesita una función de hashing. En nuestro caso, la contraseña es la contraseña en texto plano que queremos procesar, mientras que la sal será un valor generado aleatoriamente. Puedes configurar las iteraciones y la longitud de la clave. Para la función de hashing, usaremos sha3.New256.

Configuración

1// PBKDF2Hash used to generate hash
2// from plain text password and also
3// compare plain text password with
4// stored hash.
5type PBKDF2Hash struct {
6	// itr the number of iterations.
7	itr int
8	// keyLen the length of the generated key.
9	keyLen int
10	// saltLen the length of the salt used.
11	saltLen int
12}

Generar el hash

1// GenerateHash using the password and provided salt.
2// If not salt value provided fallback to random value
3// generated of a given length.
4func (p *PBKDF2Hash) GenerateHash(password, salt []byte) (*HashSalt, error) {
5	var err error
6	// If salt is not provided generate a salt of
7	// the configured salt length.
8	if len(salt) == 0 {
9		salt, err = randomSecret(p.saltLen)
10	}
11	if err != nil {
12		return nil, err
13	}
14	// Generate hash using pbkdf2 exported key method.
15	hash := pbkdf2.Key(password, salt, p.itr, p.keyLen, sha3.New256)
16	// Return the generated hash and salt used for storage.
17	return &HashSalt{Hash: hash, Salt: salt}, nil
18}

Comparar contraseñas

1// Compare generated hash with store hash.
2func (p *PBKDF2Hash) Compare(hash, salt, password []byte) error {
3	// Generate hash for comparison.
4	hashSalt, err := p.GenerateHash(password, salt)
5	if err != nil {
6		return err
7	}
8	// Compare the generated hash with the stored hash.
9	// If they don't match return error.
10	if !bytes.Equal(hash, hashSalt.Hash) {
11		return errors.New("hash doesn't match")
12	}
13	return nil
14}

Esto es muy similar a nuestra implementación de Argon2idHash. Por lo tanto, puedes modificar el ejemplo de código completo para usar PBKDF2Hash en su lugar.

Código completo

Ahora, veamos todo en conjunto.

Estructura del proyecto

./hashing
|_main.go
|_argon2id.go
|_go.mod
|_go.sum

El archivo argon2id.go:

1package main
2
3import (
4	"bytes"
5	"context"
6	"errors"
7
8	"golang.org/x/crypto/argon2"
9)
10
11// HashSalt struct used to store
12// generated hash and salt used to
13// generate the hash.
14type HashSalt struct {
15	Hash, Salt []byte
16}
17
18type Argon2idHash struct {
19	// time represents the number of 
20	// passed over the specified memory.
21	time    uint32
22	// cpu memory to be used.
23	memory  uint32
24	// threads for parallelism aspect
25	// of the algorithm.
26	threads uint8
27	// keyLen of the generate hash key.
28	keyLen  uint32
29	// saltLen the length of the salt used.
30	saltLen uint32
31}
32
33// NewArgon2idHash constructor function for 
34// Argon2idHash.
35func NewArgon2idHash(time, saltLen uint32, memory uint32, threads uint8, keyLen uint32) *Argon2idHash {
36	return &Argon2idHash{
37		time:    time,
38		saltLen: saltLen,
39		memory:  memory,
40		threads: threads,
41		keyLen:  keyLen,
42	}
43}
44
45// GenerateHash using the password and provided salt.
46// If not salt value provided fallback to random value
47// generated of a given length.
48func (a *Argon2idHash) GenerateHash(password, salt []byte) (*HashSalt, error) {
49	var err error
50	// If salt is not provided generate a salt of
51	// the configured salt length.
52	if len(salt) == 0 {
53		salt, err = randomSecret(a.saltLen)
54	}
55	if err != nil {
56		return nil, err
57	}
58	// Generate hash
59	hash := argon2.IDKey(password, salt, a.time, a.memory, a.threads, a.keyLen)
60	// Return the generated hash and salt used for storage.
61	return &HashSalt{Hash: hash, Salt: salt}, nil
62}
63
64// Compare generated hash with store hash.
65func (a *Argon2idHash) Compare(hash, salt, password []byte) error {
66	// Generate hash for comparison.
67	hashSalt, err := a.GenerateHash(password, salt)
68	if err != nil {
69		return err
70	}
71	// Compare the generated hash with the stored hash.
72	// If they don't match return error.
73	if !bytes.Equal(hash, hashSalt.Hash) {
74		return errors.New("hash doesn't match")
75	}
76	return nil
77}

El archivo main.go:

1package main
2
3import (
4	"context"
5	"crypto/rand"
6
7	"fmt"
8	"os"
9)
10
11func main() {
12	password := []byte("super-secret-password")
13
14	argon2IDHash := NewArgon2idHash(1, 32, 64*1024, 32, 256)
15
16	hashSalt, err := argon2IDHash.GenerateHash(password, nil)
17	if err != nil {
18		fmt.Fprintln(os.Stderr, err)
19		os.Exit(1)
20	}
21
22	fmt.Println(hashSalt.Hash)
23	fmt.Println(hashSalt.Salt)
24
25	err = argon2IDHash.Compare(hashSalt.Hash, hashSalt.Salt, password)
26	if err != nil {
27		fmt.Fprintln(os.Stderr, err)
28		os.Exit(1)
29	}
30	fmt.Println("argon2IDHash Password and Hash match")
31}
32
33func randomSecret(length uint32) ([]byte, error) {
34	secret := make([]byte, length)
35
36	_, err := rand.Read(secret)
37	if err != nil {
38		return nil, err
39	}
40
41	return secret, nil
42}

Elige tu algoritmo con cuidado

Los ejemplos anteriores son una excelente introducción a la implementación de algoritmos de hashing seguros para almacenar contraseñas en Go. Recuerda que no todos los algoritmos de hashing son iguales y que debes elegirlos con cuidado según tus necesidades y el estado actual de seguridad del algoritmo. Lo que hoy se considera un algoritmo sólido cambiará con el tiempo, así que conviene reevaluarlo periódicamente.

Además, ten en cuenta que las herramientas SAST como Snyk Code pueden ayudarte a identificar algoritmos obsoletos y recomendarte cómo actualizarlos si es necesario. Elige con cuidado tu algoritmo de hashing de contraseñas, mantente al día y ¡a programar!