Seguridad en Golang
Tags: webdev, go, security, programming
Published: 2023-04-25 01:49:59

## Cómo escribir código mas seguro en Go?

En esta ocasion, vamos a ver funciones de `hash` y de `cifrado/decifrado` con su principal diferencia. Como bonus, una repasada a las funciones pseudo aleatorias del lenguaje.

1. [Intro](#intro)
2. [Hash con SHA512](#hash-con-sha512)
3. [Usos comunes del hashing](#usos-mas-comunes)
4. [Cifrado y descifrado] (#cifrado-y-descifrado)
5. [Usos comunes del cifrado](#usos-mas-comunes)
6. [Números aleatorios] (#números-aleatorios)
7. [Conclusiones](#conclusiones)


### Intro
Para comenzar, tenemos el paquete Crypto de la _stdlib_ nos va a proveer el 100% (casi siempre) de las utilidades que necesitamos. Por eso es importante tener a mano su [documentacion oficial](https://pkg.go.dev/hash) para solventar dudas de implementación y lograr entender los pormenores.
Segundo, pero igual de importante, es que esta operación es "one way", es decir, con el resultado no puedo volver hacia atrás y obtener el valor ingresado.

### Hash con SHA512
Seguramente habrán visto la sigla SHA en algún lugar de la web, curso, etc, ésta corresponde a Secure Hash Algorithm y viene de larga data acompañándonos. Fue desarrollada en los Estados Unidos en el 2001, por la [NSA](https://es.wikipedia.org/wiki/National_Security_Agency) y aprobada ese mismo año para su uso, existen variantes del algoritmo, comenzando por SHA-0 (luego vinieron 1, 2 y 3 que es la actual) **y el 512 refiere al tamaño en bits** de la "salida" o el _digest_ en inglés.
EL funcionamiento básico es muy simple de explicar sin entrar en tecnisismos: recibe una entrada (arreglo de bytes) de cualquier tamaño y devuelve una palabra de siempre la misma longitud (en este caso 512 bits). Cabe destacar que la entrada puede ser realmente muy grande, segun los datos oficiales es de (2^128-1).

Ya sabemos como funcionan, ahora un pequño problema que nosotros no nos vamos a encontrar, pero si los involucrados en el desarrollo de estas fantásticas soluciones, fue que al tener un tamaño de salida definido y tanta capacidad para recibir muchos valores, se encontron con la no-grata sorpresa de que destintas entradas tenian como respuesta el mismo resultado, comúnmente llamadas colisiones.
La buena noticia es que a partir de `SHA-2`, no se volvieron a encontrar y es algo por lo cual no nos tenemos que preocupar.

Ahora pasamos un poco al código

```go
// hashShortVersion simplemente usa la función para del package, devuelve slice de bytes, simple y efectivo.
func hashShortVersion(s string) string {
	hasher := sha512.Sum512([]byte(s))
	return fmt.Sprintf("%x", hasher)
}

// hasherVersion creamos una interface hash.Hasher, le asignamos una implemntación de sha512 y usamos el método sum de la interface. Nos puede servir para hacer composición o polimorfismo, el resultado es distinto al anterior.
func hasherVersion(s string) string {
	var hasher hash.Hash
	hasher = sha512.New()
	b := hasher.Sum([]byte(s))

	res := fmt.Sprintf("%x", b)
	return res
}

// binaryVersion convierte a binario nuestros datos.
func binaryVersion(s string) string {
	var hasher hash.Hash

	hasher = sha512.New()
	hasher.Write([]byte(s))

	m, _ := hasher.(encoding.BinaryMarshaler)
	_, _ = m.MarshalBinary()

	return string(hasher.Sum(nil))
}
```

Como expresan tanto el código y los comentarios, los resultados no son iguales ya que usan métodos/funciones distintas. El `MarshallBinary()` no es recomandable usar para guardar los datos en un storage "normal" como bases de datos relacionales, de documentos o archivos porque tiene un formato muy distinto, además de ser ilegible para los humanos y no podemos compararlos con el operador `"=="`.

### Usos mas comunes

Decíamos que las funciones hash, tienen como objetivo captar una entrada "digerirla" y devolver un resultado siempre del mismo tamaño. No importa si ingresamos <u>un solo caracter, Don Quijote entero o todo el código fuente de el Kernel de Linux</u>, la salida tiene siempre el mismo largo. Y como toda función pura, ante la misma entrada, vamos a tener la misma salida, es por eso que el **uso mas común** es el de garantizar la autenticidad de un software, cuando entregamos el SHA de un **compilado o ejecutable**, el usuario que lo descarga puede hacer el mismo proceso y validar que haya descargado el mismo que la documentación oficial dice.
Por otra parte, un uso muy común pero que no recomiendo, es para contraseñas, ya que existen tablas con muchisimos datos llamadas [Rainbow tables](https://auditoriadecodigo.com/rainbow-tables-como-se-crean-y-usan-las-tablas-de-cracking-de-hash-mas-potentes-explicado-facil-o-casi-facil/) que se usan para poder _crackear_ contraseñas, por lo que no es un caso de uso muy acertado.

Bueno, hasta acá de _hashing_, ahora pasamos al cifrado

---

### Cifrado y descifrado

LA principal diferencia con el hashing, es que aca si podemos volver a obtener lo que enviamos en un principio y la segunda, es que ante la misma entrada, podemos no obtener la misma salida (mientras menos colisiones haya, mejor) por sofisticadas funciones matématicas que se denomina **sal** (o salt en inglés) y es un conjunto de bits aleatorios que su objetivo es el de, justamente, <u>cambiar el resultado ante los mismos valores de entrada.</u>

ejemplos en código:

```go
func Encrypt(s string) ([]byte, error) {
	return bcrypt.GenerateFromPassword([]byte(s), bcrypt.MinCost) // puede ser también defaultCost
}

func Decrypt(encryptedPassword, plainPassword string) error {
	return bcrypt.CompareHashAndPassword([]byte(encryptedPassword), []byte(plainPassword))
}
```
Bueno con este si que no nos podemos quejar, lo fácil y claro que es no deja margen de dudas.
Si prueban imprimir solo el _string_ resultante varias veces con la misma entrada, pueden ver como obtienen distintos resultados.

### Usos más comunes

Claramente el uso mas común (hace muchísimos años) es el de ocultar un mensaje y que un receptor pueda interpretarlo. En informática lo vamos a usar extensamente para contraseñas, tokens y valores que el usuario envía y son sensibles.

---

### Números aleatorios

Antes de empezar a abordar el tema, no son aleatorios, son pseudo aleatorios y es una definición teórica que pueden ver [explicado acá](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&cad=rja&uact=8&ved=2ahUKEwjO-e748sP-AhVeq5UCHYXSC7oQFnoECBsQAw&url=https%3A%2F%2Fes.wikipedia.org%2Fwiki%2FN%25C3%25BAmero_pseudoaleatorio&usg=AOvVaw1801fHvnj4wXsJFnI0lnQb).

En éste código, vemos dos casos de uso muy comunes, el primero es obtener un string aleatorio dado un alfabeto. El parámetro de entrada es uno solo y corresponde a que tan larga debería ser la cadena resultante. Así de simple y sencillo.

La segunda función, es un poco mas de lo mismo, solo que generamos únicamente números y el parametro de entrada corresponde al límete superior sin incluir, es decir, si ponemos `1000`, vamos a generar un número entre `0` y `999`.

```go
func GenerateRandomString(n int) (string, error) {
	const letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-"
	ret := make([]byte, 0, n)
	for i := 0; i < n; i++ {
		num, err := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))
		if err != nil {
			return "", err
		}
		ret = append(ret, letters[num.Int64()])
	}

	return string(ret), nil
}

func GenerateRandNum(n int) int64 {
	b, err := rand.Int(rand.Reader, big.NewInt(int64(n)))
	if err != nil {
		return 0
	}
	return b.Int64()
}

```
Con estos dos `snippets` ya tienen para cubrir bastantes casos.


### Conclusiones

Aprendimos (o repasamos) las principales diferencias entre el hashing y el cifrado, tanto conceptualmente como implementaciones en Golang y sus usos mas frecuentes en la industria, también como el desarrollos académicos.
Por último, cubrimos brevemente que es y como se usa el paquete crypto.Rand y claramente, agregamos un poco de código.

Ya saben, si quieren sponsorearme, [pueden hacerlo acá!](https://github.com/sponsors/tomiok)