hash

Hash - Security Module (gokit)

Módulo de hashing de contraseñas de gokit.
Soporta bcrypt y Argon2id, con autodetección de algoritmo, configuración global y API profesional.

Diseñado para ser seguro por defecto, flexible y fácil de integrar en cualquier proyecto Go.

✨ Características

• 🔐 Hashing con bcrypt y Argon2id
• 🤖 Autodetección de algoritmo (bcrypt / argon2)
• ⚙️ Configuración global
• 🧩 API unificada (Hash / Verify)
• 🛡️ Comparación en tiempo constante
• 🔄 Soporte para rehash automático
• 🔑 Generación de tokens seguros
• 📏 Validación de contraseñas (longitud mínima/máxima)

📦 Instalación

go get github.com/AndresGT/gokit/security/hash

🚀 Uso Básico

Hash de contraseña

import "github.com/AndresGT/gokit/security/hash"

hashed, err := hash.Hash("password123")
if err != nil {
	panic(err)
}

fmt.Println(hashed)

Verificar contraseña

ok, err := hash.Verify("password123", hashed)
if err != nil {
	panic(err)
}

if ok {
	fmt.Println("Password válido")
}

⚙️ Configuración

Puedes configurar el algoritmo y parámetros globalmente:

import "github.com/AndresGT/gokit/security/hash"

func init() {
	hash.Configure(hash.Config{
		Algorithm:  hash.AlgArgon2, // o hash.AlgBcrypt
		BcryptCost: 12,
		MinLength:  8,
		MaxLength:  128,
		Argon2: hash.Argon2Params{
			Memory:      64 * 1024,
			Iterations:  3,
			Parallelism: 2,
			SaltLength:  16,
			KeyLength:   32,
		},
	})
}

🧠 Algoritmos soportados

bcrypt (default)

• Rápido y ampliamente soportado
• Recomendado para la mayoría de aplicaciones

Argon2id

• Más seguro y resistente a ataques GPU/ASIC
• Recomendado para sistemas críticos

🔄 Autodetección de algoritmo

No necesitas saber qué algoritmo se usó:

ok, _ := hash.Verify("password123", hashed)

El módulo detecta automáticamente si el hash es bcrypt o Argon2id.

🔄 Rehash

Puedes detectar si un hash necesita ser regenerado:

if hash.NeedsRehash(hashed) {
	newHash, _ := hash.Hash("password123")
}

Ejemplo típico: migrar bcrypt → Argon2.

🔑 Tokens Seguros

Token aleatorio

token, _ := hash.GenerateRandomToken(32)

Token seguro (256 bits)

token, _ := hash.GenerateSecureToken()

📏 Validación de contraseñas

Por defecto:

• mínimo: 8 caracteres
• máximo: 128 caracteres

Ejemplo de error:

hashed, err := hash.Hash("123")
// error: password must be at least 8 characters

🧪 Ejemplo Completo

func main() {
	hash.Configure(hash.Config{
		Algorithm: hash.AlgBcrypt,
	})

	password := "super-secret"

	hashed, _ := hash.Hash(password)

	ok, _ := hash.Verify(password, hashed)

	fmt.Println("Valid:", ok)
}

🔐 Buenas Prácticas

• Usa Argon2id para sistemas críticos.
• Usa bcrypt para sistemas estándar.
• No guardes contraseñas en texto plano.
• Usa longitud mínima >= 8.
• Migra hashes antiguos con NeedsRehash.
• Nunca expongas hashes en logs.

📄 Licencia

MIT

🔗 Links

• gokit: https://github.com/AndresGT/gokit
• Hash module: https://github.com/AndresGT/gokit/tree/main/security/hash

Parte de gokit — módulo de hashing listo para producción.