---
title: "Laboratorio: guardar contraseñas y construir códigos TOTP"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "gratuito"
environment: "tu propio ordenador (Linux, macOS o Windows con WSL2) con Python 3.9 o posterior; una app de autenticación en el móvil es opcional"
lang: es
source_hash: c069a4b1d609
---

# Laboratorio: guardar contraseñas y construir códigos TOTP

## Objetivo
Ver con tus propios ojos por qué un hash simple es una mala forma de guardar contraseñas, guardarlas de la forma segura con una sal y un hash lento, y construir tú mismo el código de seis dígitos de una app de autenticación en unas 20 líneas de Python. Después compruebas tu código con los valores de prueba oficiales del RFC 6238.

## Objetivos
- Demostrar que un hash SHA-256 simple da el mismo valor para la misma contraseña y que una contraseña común se puede buscar.
- Guardar contraseñas con una sal aleatoria y `hashlib.scrypt`, y verificarlas con una comparación en tiempo constante.
- Generar códigos TOTP y comprobarlos con los vectores de prueba del Apéndice B del RFC 6238.
- Decir qué segundo factor frenaría a un sitio de phishing que reenvía códigos en tiempo real.

## Requisitos previos
- Python 3.9 o posterior (`python3 --version`). Pegas scripts cortos y los ejecutas; no hace falta que seas programador.
- Un terminal y un sitio donde pegar texto (los comandos de abajo crean los archivos por ti).
- Opcional (paso 4): una app de autenticación en el móvil que permita añadir una cuenta escribiendo una clave (la mayoría puede).
- [La lección de Autenticación y MFA](lesson.es.md) de este módulo.
- Sin cuentas, sin red y sin datos de pago.

> [!WARNING]
> Todo esto se ejecuta en tu propio ordenador con usuarios y contraseñas inventados. No uses nunca una contraseña que utilices de verdad y no pegues nunca el secreto TOTP de una cuenta real en ningún script. El secreto que creas en el paso 4 es **solo para este laboratorio**: bórralo de la app de tu móvil en la sección de Limpieza.

## Arquitectura
![A la izquierda, una zona para tu ordenador, carpeta ~/auth-lab, con cuatro pasos: el paso 1 plain_hash.py muestra que la misma contraseña da el mismo SHA-256; el paso 2 store.py guarda con una sal y scrypt para que los valores difieran; el paso 3 totp.py comprueba los vectores de prueba del RFC 6238; el paso 4 show_code.py imprime un secreto aleatorio y un código en vivo. A la derecha, una zona opcional del móvil con una app de autenticación donde escribes a mano el secreto del laboratorio. Una flecha une el paso 4 con la app y compruebas si ambos muestran los mismos seis dígitos. Una nota dice que hay que borrar el secreto del móvil en la limpieza.](../../../assets/diagrams/auth-lab-architecture.es.svg)

*Figura 1. Cuatro scripts pequeños en una carpeta. Solo el paso 4 toca tu móvil, y solo si tú quieres.*

## Pasos

### Paso 1 — Descubre por qué los hashes simples son malos (8 min)
Un hash convierte una contraseña en una huella de longitud fija que no se puede invertir. Guardar `SHA-256(password)` parece seguro. Veamos qué puede hacer un atacante que robe una tabla así. Crea la carpeta y un script:

```bash
mkdir ~/auth-lab
cd ~/auth-lab
cat > plain_hash.py <<'EOF2'
import hashlib

def sha256(text):
    return hashlib.sha256(text.encode()).hexdigest()

# A pretend user table where passwords are stored as a plain SHA-256 hash.
users = {"alice": sha256("sunshine1"), "bob": sha256("sunshine1"), "carol": sha256("c0rrect horse battery")}
for name, stored in users.items():
    print(name, stored)

# An attacker who stole the table tries a short list of common passwords.
common = ["123456", "password", "qwerty", "letmein", "sunshine1"]
lookup = {sha256(word): word for word in common}
print()
for name, stored in users.items():
    print(name, "->", lookup.get(stored, "not in my list"))
EOF2
python3 plain_hash.py
```

Salida esperada:
```text
alice 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
bob 284fff3bd254b48cca05a8bfc4fad69e05cad0d086513a034a66a118829e6fa4
carol af2de743ce77cb99a82cda058f8a04c158bf7f8109e06f302539ba2107320f8d

alice -> sunshine1
bob -> sunshine1
carol -> not in my list
```

En lenguaje llano:

- **alice y bob tienen el mismo valor guardado.** La misma contraseña da el mismo hash. Cualquiera que lea la tabla ve que dos personas comparten contraseña, y averiguar una contraseña revela las dos.
- **La segunda mitad es el atacante.** Calcula una sola vez el hash de cada contraseña común, construye una tabla de búsqueda y la compara con la tabla robada. Alice y bob caen con una sola búsqueda. Las listas reales tienen miles de millones de entradas, y los hashes rápidos como SHA-256 permiten a una tarjeta gráfica probar miles de millones por segundo.
- **carol está a salvo solo porque su frase de contraseña no está en la lista.** Eso es suerte, no diseño.

<details>
<summary>¿Por qué no aplicar el hash dos veces, sin más?</summary>

Aplicar el hash dos veces con la misma función rápida sigue siendo rápido, y sigue dando el mismo valor para la misma contraseña. Las dos soluciones son una **sal** (un valor distinto por usuario) y un hash **lento** (costoso en cada intento). El paso 2 usa ambas.

</details>

### Paso 2 — Guarda contraseñas con una sal y scrypt (10 min)
Ahora, la forma correcta. Para cada usuario, crea una **sal** aleatoria y después calcula el hash de la contraseña y la sal juntas con **scrypt**, una función deliberadamente lenta y con alto consumo de memoria. Guarda la sal junto al resultado. Para iniciar sesión, repite el cálculo con la sal guardada y compara.

```bash
cat > store.py <<'EOF2'
import hashlib, hmac, os

def make_record(password):
    salt = os.urandom(16)  # random, different for every user
    digest = hashlib.scrypt(password.encode(), salt=salt, n=2**14, r=8, p=1, dklen=32)
    return salt, digest

def check(password, salt, digest):
    attempt = hashlib.scrypt(password.encode(), salt=salt, n=2**14, r=8, p=1, dklen=32)
    return hmac.compare_digest(attempt, digest)

alice = make_record("sunshine1")
bob = make_record("sunshine1")
print("alice salt:  ", alice[0].hex())
print("alice stored:", alice[1].hex())
print("bob salt:    ", bob[0].hex())
print("bob stored:  ", bob[1].hex())
print("same stored value?", alice[1] == bob[1])
print("alice, right password:", check("sunshine1", *alice))
print("alice, wrong password:", check("sunshine2", *alice))
EOF2
python3 store.py
```

Salida esperada (los valores hexadecimales son aleatorios y **cambian en cada ejecución**; las tres últimas líneas nunca cambian):
```text
alice salt:   193e9e110d6fa0c36ea40a17ebd745be
alice stored: a58c567800dd4b22ff91e798bf0d25af061a5bbb06988decd854e812ea7d7729
bob salt:     ecca3df25d21df01104b2ad8b5795727
bob stored:   a7e5da3f8effd62fda91f6dabfeadafe9511c49457f9a28ef35761d10a5b750c
same stored value? False
alice, right password: True
alice, wrong password: False
```

En lenguaje llano:

- **alice y bob usan la misma contraseña, pero los valores guardados son distintos.** Sus sales son diferentes, así que los hashes son diferentes. Una tabla de búsqueda hecha de antemano no sirve de nada, y el atacante debe atacar cada cuenta por separado.
- **La sal se guarda en claro.** Está bien: su función es ser única, no secreta.
- **La comprobación** repite scrypt con la sal guardada. `True` para la contraseña correcta, `False` para la incorrecta.
- **`hmac.compare_digest`** compara dos valores en tiempo constante. Un `==` normal puede detenerse en el primer byte distinto, y esa diferencia minúscula de tiempo puede filtrar información.
- **Lento a propósito.** Un scrypt tarda aquí unas centésimas de segundo. Nadie lo nota al iniciar sesión, pero para un atacante multiplica el coste de cada intento.

> [!NOTE]
> `n=2**14` se ha elegido para que el laboratorio se ejecute rápido en cualquier ordenador. Los sistemas reales usan ajustes más fuertes, o Argon2id. Consulta las recomendaciones actuales en la Password Storage Cheat Sheet de OWASP en lugar de copiar cifras de un laboratorio.

Ejecútalo una segunda vez y mira las sales:

```bash
python3 store.py | head -2
```

La sal y el valor guardado vuelven a ser distintos, aunque la contraseña no haya cambiado.

### Paso 3 — Construye TOTP y compruébalo con el RFC (12 min)
Un código TOTP es un cálculo sobre un secreto compartido y la hora. Lo escribirás como un módulo pequeño que reutilizarán los pasos siguientes. Lee los comentarios: cada línea es una caja de la figura de la lección.

```bash
cat > totp.py <<'EOF2'
import hashlib, hmac, struct, time

def totp(secret_bytes, t=None, digits=6, step=30):
    counter = int((time.time() if t is None else t) // step)  # the time step T
    mac = hmac.new(secret_bytes, struct.pack(">Q", counter), hashlib.sha1).digest()
    offset = mac[-1] & 0x0F                                   # dynamic truncation
    number = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
    return str(number % 10**digits).zfill(digits)

if __name__ == "__main__":
    secret = b"12345678901234567890"   # RFC 6238 test secret
    for t, expected in [(59, "94287082"), (1111111109, "07081804"), (1111111111, "14050471"),
                        (1234567890, "89005924"), (2000000000, "69279037")]:
        code = totp(secret, t, digits=8)
        print(t, code, expected, "OK" if code == expected else "WRONG")
EOF2
python3 totp.py
```

Salida esperada:
```text
59 94287082 94287082 OK
1111111109 07081804 07081804 OK
1111111111 14050471 14050471 OK
1234567890 89005924 89005924 OK
2000000000 69279037 69279037 OK
```

En lenguaje llano:

- **Cada línea** muestra un tiempo Unix en segundos, el código que ha calculado tu función, el código que según el RFC es correcto, y OK o WRONG.
- Los cinco tiempos de prueba y los códigos esperados de 8 dígitos proceden del **RFC 6238, Apéndice B** (la columna SHA-1). Si obtienes cinco líneas OK, tu código hace exactamente lo que hacen las apps de autenticación.
- Las líneas de la función se corresponden con la lección: `// step` es el intervalo de tiempo, `hmac.new(...)` es el HMAC-SHA1, `& 0x0F` y el corte son el truncamiento dinámico, y `% 10**digits` da los dígitos.
- Las apps reales usan 6 dígitos, que es el valor por defecto (`digits=6`); los vectores del RFC usan 8.

Comprobación rápida: la primera línea es el tiempo 59, es decir, 59 segundos después del 1 de enero de 1970. El intervalo de tiempo `59 // 30` es 1. ¿Qué código de 6 dígitos mostraría entonces una app?

<details>
<summary>Mostrar la respuesta</summary>

Los últimos seis dígitos del valor de 8 dígitos: `287082`. Puedes comprobarlo:

```bash
python3 -c "from totp import totp; print(totp(b'12345678901234567890', 59))"
```

Salida: `287082`. (El código de 6 dígitos es el mismo número módulo un millón, así que son los últimos seis dígitos de `94287082`.)

</details>

### Paso 4 — Un secreto real y un código en vivo (10 min)
Las apps de autenticación guardan el secreto como texto en **base32** (letras A-Z y dígitos 2-7). Vamos a crear uno aleatorio e imprimir el código actual cada cinco segundos.

```bash
cat > show_code.py <<'EOF2'
import base64, secrets, time
from totp import totp

secret_b32 = base64.b32encode(secrets.token_bytes(10)).decode()  # 80 random bits -> 16 letters
print("Secret (lab only):", secret_b32)
key = base64.b32decode(secret_b32)
for _ in range(6):
    left = 30 - int(time.time()) % 30
    print(time.strftime("%H:%M:%S"), totp(key), f"(changes in {left}s)")
    time.sleep(5)
EOF2
python3 show_code.py
```

Salida esperada (el secreto, las horas y los códigos **serán distintos en tu caso**; la forma es la misma):
```text
Secret (lab only): EM35V2C6LLWLHA47
20:35:52 297598 (changes in 8s)
20:35:57 297598 (changes in 3s)
20:36:02 434430 (changes in 28s)
20:36:07 434430 (changes in 23s)
20:36:12 434430 (changes in 18s)
20:36:17 434430 (changes in 13s)
```

En lenguaje llano: el código se mantiene igual durante 30 segundos (el mismo intervalo de tiempo) y después cambia. El contador «changes in» llega a cero cuando empieza el siguiente intervalo. El servidor y tu móvil siguen el mismo reloj, así que coinciden sin hablarse.

**Opcional: compáralo con tu móvil.** Ejecuta el script otra vez, para que el secreto quede en tu pantalla, y en tu app de autenticación elige «añadir una cuenta» y después «introducir una clave de configuración» (la redacción cambia según la app):

1. Nombre de la cuenta: `auth-lab`.
2. Clave: las 16 letras impresas después de `Secret (lab only):`.
3. Tipo de clave: **basada en el tiempo**. Deja los valores por defecto (6 dígitos, 30 segundos, SHA-1).

Compara los seis dígitos de la app con los del terminal. Deberían coincidir. Si el móvil muestra un código justo antes de un cambio y el terminal uno justo después, espera al siguiente.

Acabas de hacer lo que hace escanear un código QR: un código QR es solo este secreto, más un nombre, escrito como un enlace `otpauth://` en forma de imagen.

### Paso 5 — Ejercicio de reflexión: ¿quién frena el reenvío? (5 min)
Un sitio de phishing muestra una copia de la página de inicio de sesión de tu empresa. Escribes tu contraseña y el código de seis dígitos de tu app. En segundo plano, el sitio envía ambos al sitio real en cuestión de segundos y consigue iniciar sesión como tú.

Pregunta: para cada método, ¿frenaría este ataque? Responde sí o no y explica por qué: (a) una contraseña sola, (b) un código por SMS, (c) el código TOTP que acabas de construir, (d) una notificación push con coincidencia de números, (e) una llave de seguridad FIDO2 o una passkey.

<details>
<summary>Mostrar la respuesta</summary>

| Método | ¿Frena el reenvío en tiempo real? | Por qué |
|---|---|---|
| (a) Contraseña sola | No | La página de phishing la recoge directamente. |
| (b) Código por SMS | No | Escribes el código en la página falsa, que lo reenvía. |
| (c) Código TOTP | No | El código es válido durante 30 segundos y no está ligado a ningún sitio web. Tu script lo demuestra: la función recibe solo un secreto y una hora, nunca una dirección web. |
| (d) Push con coincidencia de números | Parcialmente | Es más difícil, porque el usuario debe hacer coincidir el número que se muestra en el inicio de sesión real. Pero un reenvío puede mostrar ese número en la página falsa, así que un usuario cansado o con prisa puede caer. |
| (e) Llave FIDO2 o passkey | **Sí** | La llave firma un desafío junto con la dirección web que ve el navegador. En el sitio falso no hay una credencial que coincida, y una firma para la dirección falsa no sirve en el sitio real. |

Por eso la guía actual favorece los métodos resistentes al phishing para administradores y cuentas de alto valor.

</details>

## Verificación
Comprueba esto, en orden:

```bash
cd ~/auth-lab
python3 totp.py
python3 store.py | tail -3
```

Lo superas si:
- `totp.py` imprime cinco líneas que terminan todas en `OK`.
- `store.py` imprime `same stored value? False`, después `True` para la contraseña correcta y `False` para la incorrecta.
- En el paso 1, alice y bob mostraron el mismo SHA-256 y una búsqueda recuperó `sunshine1`.
- (Opcional) Tu móvil y `show_code.py` mostraron los mismos seis dígitos.

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `AttributeError: module 'hashlib' has no attribute 'scrypt'` | Este Python se compiló sin compatibilidad con scrypt de OpenSSL | Usa un Python estándar 3.9 o posterior de tu sistema o de python.org; en un contenedor mínimo, instala el paquete `python3` completo |
| `ModuleNotFoundError: No module named 'totp'` | No estás en `~/auth-lab`, o falta `totp.py` o se ha renombrado | Ejecuta `cd ~/auth-lab`, comprueba con `ls` y vuelve a ejecutar el bloque del paso 3 |
| `SyntaxError` o `IndentationError` | Al pegar se perdieron líneas o espacios | Borra ese archivo y pega de nuevo el bloque completo, incluida la última línea `EOF2` |
| `totp.py` imprime `WRONG` | Un error de escritura en el código, en un valor del RFC o en el secreto | Compara el archivo con el bloque; el secreto debe ser exactamente `12345678901234567890` |
| El móvil muestra un código distinto | Error al escribir el secreto; la app no está configurada como basada en el tiempo; el reloj del móvil se desvía más de unos pocos segundos | Vuelve a introducir la clave, comprueba que el tipo es basado en el tiempo, activa la fecha y hora automáticas en el móvil |
| `mkdir: cannot create directory ... File exists` | Ya ejecutaste el paso 1 | No pasa nada: ejecuta `cd ~/auth-lab` y continúa |

## Reto (opcional)
1. Escribe `verify(secret, code)` que acepte el código del intervalo actual y de los intervalos inmediatamente anterior y posterior (una ventana de un intervalo, como un servidor real). Pruébalo pasándole el código de hace 30 segundos y el código de hace 90 segundos.
2. Mide el tiempo de `make_record` con `n=2**14` y con `n=2**17` (para el valor mayor, añade `maxmem=2**28` a la llamada a `hashlib.scrypt`, o Python se niega a usar tanta memoria). ¿Cuánto más lenta resulta una comprobación de contraseña? ¿Qué significa eso para un atacante?
3. Pasa una frase de contraseña larga por `check` con un carácter cambiado y sin cambiar. ¿Se parece el valor guardado? ¿Por qué no?

## Limpieza
Borra la carpeta y el secreto del laboratorio de tu móvil:

```bash
cd ~
rm -r ~/auth-lab
```

En tu móvil, abre la app de autenticación y elimina la cuenta `auth-lab` si la añadiste. No se ha instalado ni cambiado nada más.

## Qué has aprendido
- Un hash simple da el mismo valor para la misma contraseña y se puede buscar, así que no es un almacenamiento seguro de contraseñas.
- Una sal aleatoria por usuario y un hash lento como scrypt hacen que contraseñas idénticas parezcan distintas y que cada intento sea costoso. Compara en tiempo constante.
- Un código TOTP es solo el HMAC-SHA1 del intervalo de tiempo de 30 segundos con un secreto compartido, truncado a dígitos. Lo has comprobado con el RFC 6238.
- Un código que escribes no está ligado a ningún sitio web, así que un sitio de phishing puede reenviarlo. Una llave FIDO2 o una passkey firma el origen, así que no se puede reenviar.
