Conversión de texto plano a hash con SHA256 en Go

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:46

Conversión de texto plano a hash con SHA256 en Go

Curso de Go

Clase 26 de 28

Clase 26 / 28

Recursos

Aprender a convertir información sensible en un hash utilizando Go y SHA256 es fundamental para proteger los datos de una aplicación. Encriptar cadenas como contraseñas, números de tarjeras o incluso nombres es esencial si gestionas una API o manipulas información confidencial. De este modo, ante cualquier filtración indeseada, los datos permanecerán seguros gracias a caracteres ilegibles generados por la encriptación.

¿Por qué es importante convertir texto plano a hash?

Guardar información sensible en formato de texto plano es un gran riesgo para la seguridad. Al utilizar técnicas de hash como SHA256, se convierte un texto fácilmente legible en una serie compleja de caracteres difícilmente descifrable. Esto mejora significativamente la seguridad porque:

Evita que la información personal sea legible en una filtración accidental.
Impide que usuarios no autorizados accedan fácilmente a datos sensibles.
Añade una capa adicional de seguridad en aplicaciones y bases de datos.

¿Cómo crear un hash en Go usando SHA256?

La creación de un hash en Go requiere pocas líneas de código y algunos pasos simples:

Importar los paquetes necesarios, específicamente crypto/sha256 y el paquete fmt:

import (
  "crypto/sha256"
  "fmt"
)

Crear una cadena base que se desea encriptar:

cadenaBase := "Amin Espinoza"

Generar el hash usando SHA256:

hash := sha256.New()
hash.Write([]byte(cadenaBase))
arregloHash := hash.Sum(nil)
fmt.Printf("%x\n", arregloHash)

Este código generará un hash que puede almacenarse de forma segura en tu base de datos, sustituyendo al texto plano.

¿Qué beneficios tiene implementar rápidamente el hashing en tus aplicaciones?

Usar hashing protege rápidamente la información del usuario y mejora la percepción de seguridad en tus aplicaciones. Beneficios inmediatos incluyen:

Protección efectiva frente a vulnerabilidades comunes.
Confianza y satisfacción mejorada del usuario debido a la mayor seguridad.
Manejo fácil y rápido del proceso de encriptado gracias a funciones integradas en Go.

Implementarlo es sencillo y una práctica recomendada para cualquier aplicación que maneje datos vulnerables. Te invitamos a probarlo e incorporar esta técnica en tus desarrollos posteriores, fortaleciendo así la seguridad de tus proyectos digitales.

Ronaldo Jiménez

Hace un año

La diferencia entre usar bcrypt en Go (paquete:golang.org/x/crypto/bcrypt) y usar directamente crypto/sha256 es fundamental, sobre todo en temas de seguridad y propósito:

🔑 1. Propósito principal

bcrypt Diseñado específicamente para hashing de contraseñas. Incluye sal interna, es adaptable (puedes subir el “cost” con el tiempo) y es resistente a ataques de fuerza bruta y de hardware especializado (GPU/ASIC).
crypto/sha256 Es una función hash criptográfica genérica. Sirve para integridad, firmas digitales, checksums, etc. Pero no es segura para almacenar contraseñas por sí sola, porque es rápida y paralelizable.

⚡ 2. Velocidad y resistencia

bcrypt: Intencionalmente lento y configurable (parámetro cost). Eso hace que probar millones de contraseñas sea costoso para un atacante.
sha256: Extremadamente rápido (millonésimas de segundo). Un atacante puede probar miles de millones de contraseñas por segundo con hardware especializado.

🧂 3. Manejo de sal

bcrypt: Maneja internamente la generación y el almacenamiento de la sal. Cuando guardas el hash, la sal ya está embebida en él.
sha256: No usa sal automáticamente. Si quieres prevenir ataques de rainbow tables, tienes que manejar la sal manualmente y concatenarla antes de hacer el hash.

🔒 4. Adaptabilidad

bcrypt: Tiene un parámetro de “cost” que puedes aumentar con el tiempo, para que siga siendo caro computacionalmente incluso si el hardware mejora.
sha256: No tiene parámetros configurables. Siempre es rápido y no se puede hacer más costoso sin envolverlo en un esquema adicional (ej: PBKDF2, scrypt, Argon2).

✅ 5. Cuándo usar cada uno

Usar bcrypt → Para almacenar y verificar contraseñas de usuarios.
Usar sha256 → Para integridad de datos, generación de huellas digitales (hash de archivos, firmas digitales, etc.), pero no para almacenar contraseñas directamente.

Ronaldo Jiménez

Hace un año

package main

import (
	"fmt"
	"log"

	"golang.org/x/crypto/bcrypt"
)

func main() {
	fmt.Println("--- SIMULACIÓN DEL REGISTRO DE USUARIO ---")

	// 1. Se define la contraseña del usuario.
	password := []byte("mi_super_contraseña_secreta_123")

	// 2. Se genera el hash de la contraseña.
	// bcrypt.GenerateFromPassword genera un hash que ya incluye la sal.
	// El segundo argumento es el 'cost', que determina la fuerza del hash.
	// bcrypt.DefaultCost es un valor por defecto seguro.
	hashedPassword, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
	if err != nil {
		log.Fatal(err)
	}

	// Simulamos que `hashedPassword` es lo que se guarda en la base de datos.
	fmt.Printf("Contraseña en texto plano: %s\n", password)
	fmt.Printf("Hash almacenado en la DB: %s\n", hashedPassword)

	// --- SIMULACIÓN DEL LOGIN ---
	fmt.Println("\n--- SIMULACIÓN DEL LOGIN ---")

	// 1. El usuario introduce la contraseña para iniciar sesión.
	loginPassword := []byte("mi_super_contraseña_secreta_123")

	// 2. Se verifica la contraseña.
	// bcrypt.CompareHashAndPassword compara el hash almacenado con la contraseña ingresada.
	// bcrypt se encarga de extraer la sal del hash automáticamente.
	err = bcrypt.CompareHashAndPassword(hashedPassword, loginPassword)
	if err != nil {
		fmt.Println("Contraseña incorrecta. Acceso denegado.")
	} else {
		fmt.Println("¡Contraseña correcta! Acceso concedido.")
	}

	// --- EJEMPLO CON CONTRASEÑA INCORRECTA ---
	fmt.Println("\n--- EJEMPLO CON CONTRASEÑA INCORRECTA ---")
	wrongPassword := []byte("contraseña_incorrecta")

	err = bcrypt.CompareHashAndPassword(hashedPassword, wrongPassword)
	if err != nil {
		fmt.Println("Contraseña incorrecta. Acceso denegado.")
	} else {
		fmt.Println("¡Contraseña correcta! Acceso concedido.")
	}
}

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Conversión de texto plano a hash con SHA256 en Go