---
title: "Laboratorio: calcular hashes, cifrar y firmar con OpenSSL"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "gratuito"
environment: "tu propio ordenador (Linux, macOS o Windows con WSL2) con OpenSSL 3.0 o posterior; acceso a Internet solo para el último paso"
lang: es
source_hash: a5518221ad4e
---

# Laboratorio: calcular hashes, cifrar y firmar con OpenSSL

## Objetivo
Prueba cada herramienta de la lección sobre un pequeño archivo de texto con el comando `openssl`: calcula su hash, cífralo con una contraseña, fírmalo con un par de claves y convierte una clave en un certificado. Después lee la cadena de certificados real de `example.com`, igual que hace tu navegador.

## Objetivos
- Calcular un resumen SHA-256 y comprobar que cambiar un carácter lo modifica por completo.
- Cifrar y descifrar un archivo con una contraseña, y ver qué ocurre con una contraseña incorrecta y con un archivo manipulado.
- Crear un par de claves, firmar un archivo, verificar la firma y ver cómo la verificación falla tras un cambio.
- Crear un certificado autofirmado y leer sus campos.
- Identificar el subject, el issuer, las fechas de validez y el SAN en una cadena de certificados real.

## Requisitos previos
- OpenSSL 3.0 o posterior. Compruébalo con `openssl version`. Debe decir `OpenSSL 3.x`, no `LibreSSL` ni `1.1.1`.
- Un terminal. En Windows, usa WSL2.
- Acceso a Internet solo para el Paso 7.
- [La lección Fundamentos de criptografía](lesson.es.md) de este módulo.

> [!WARNING]
> Todo lo que ocurre en los Pasos 1 a 6 sucede en tu propio ordenador con archivos que creas tú. El Paso 7 solo **se conecta al puerto 443 de `example.com` y lee el certificado que ofrece**, exactamente igual que un navegador. No apuntes `openssl s_client` a sistemas que no sean tuyos o que no tengas permiso para probar, y no les envíes nada más.

> [!NOTE]
> Las claves y contraseñas de este laboratorio son solo para practicar. No reutilices nunca una clave del laboratorio para nada real, y no escribas nunca una contraseña real en la línea de comandos: es visible en la lista de procesos y queda guardada en el historial de tu shell.

## Arquitectura
![Escenario del laboratorio. A la izquierda, una zona para tu ordenador, carpeta ~/crypto-lab, con cuatro tarjetas. Paso 2, hash: message.txt, con sha256sum y openssl dgst. Pasos 3 y 4, cifrado: message.enc, con openssl enc y AES-256-CBC. Paso 5, firma: private.pem, public.pem y message.sig con Ed25519. Paso 6, certificado: server.crt y server.key, con openssl req y openssl x509. A la derecha, una zona de solo lectura para Internet con el paso 7, la cadena de certificados real de example.com en el puerto 443, leída con openssl s_client.](../../../assets/diagrams/crypto-lab-architecture.es.svg)

*Figura 1. Los pasos 2 a 6 se quedan en tu ordenador; el Paso 7 solo lee un certificado público.*

## Pasos

### Paso 1 — Crea una carpeta de trabajo y un archivo (3 min)
Trabajas en una sola carpeta para que la limpieza final sea un único comando. El archivo es una pequeña «instrucción bancaria» que protegerás de distintas formas.

```bash
openssl version
mkdir ~/crypto-lab
cd ~/crypto-lab
printf 'Transfer 100 EUR to account ES00 1234\n' > message.txt
cat message.txt
```

Qué hace cada línea: `openssl version` comprueba la herramienta; `mkdir` y `cd` crean la carpeta y entran en ella; `printf` escribe una línea en `message.txt`; `cat` la muestra.

Salida esperada (la fecha de compilación que sigue a la versión es distinta en tu ordenador, siempre que empiece por `OpenSSL 3`):
```text
OpenSSL 3.5.8 25 Aug 2026 (Library: OpenSSL 3.5.8 25 Aug 2026)
Transfer 100 EUR to account ES00 1234
```

### Paso 2 — Calcula el hash del archivo y cambia un carácter (8 min)
Un hash es una huella del archivo. Calcúlalo de dos maneras: `sha256sum` (Linux y WSL2; en macOS usa `shasum -a 256`) y `openssl dgst`.

```bash
sha256sum message.txt
openssl dgst -sha256 message.txt
```

Salida esperada:
```text
190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f  message.txt
SHA2-256(message.txt)= 190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f
```

Fíjate: ambas herramientas imprimen los **mismos 64 caracteres hexadecimales**. Ejecuta cualquiera de los dos comandos otra vez y obtienes el mismo resumen siempre.

Ahora haz una copia en la que `100` pase a ser `900` y calcula su hash:

```bash
sed 's/100/900/' message.txt > message2.txt
cat message2.txt
sha256sum message2.txt
```

Salida esperada:
```text
Transfer 900 EUR to account ES00 1234
10bfa161dcd38705488563c4f86395ad2456430fe5b97d08fbbfc8c8322f96c5  message2.txt
```

Compáralo con el primer resumen. Un carácter cambió en el archivo y, sin embargo, el resumen parece totalmente distinto: ese es el **efecto avalancha**. La longitud sigue siendo de 64 caracteres.

Por último, usa el resumen como lo usarías para comprobar una descarga. Guarda el resumen en un archivo y pide a `sha256sum` que compruebe el archivo contra él, antes y después de manipularlo:

```bash
sha256sum message.txt > SHA256SUMS
sha256sum -c SHA256SUMS
cp message.txt original.txt
cp message2.txt message.txt
sha256sum -c SHA256SUMS
cp original.txt message.txt
sha256sum -c SHA256SUMS
```

`-c` significa «check» (comprobar). Los dos `cp` primero sustituyen `message.txt` por la versión modificada (simulando que lo hizo un atacante) y después lo restauran.

Salida esperada (las palabras aparecen traducidas en otros idiomas):
```text
message.txt: OK
message.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
message.txt: OK
```

<details>
<summary>Pregunta: ¿demuestra un resumen que coincide que el archivo procede del autor real?</summary>

No. Demuestra que el archivo es el mismo que se procesó con el hash. Si un atacante puede cambiar el archivo, también puede cambiar `SHA256SUMS`. Para demostrar **quién** creó el archivo necesitas una clave: esa es la firma que creas en el Paso 5.

</details>

### Paso 3 — Cifra y descifra con una contraseña (8 min)
Ahora la confidencialidad. `openssl enc` cifra un archivo con AES-256 y una clave generada a partir de tu contraseña. La opción `-pbkdf2 -iter 600000` hace que openssl convierta la contraseña en una clave con PBKDF2, de forma lenta, y `-salt` añade una sal aleatoria (es de nuevo la idea de hash de contraseñas de la lección).

```bash
openssl enc -aes-256-cbc -pbkdf2 -iter 600000 -salt -pass pass:correct-horse -in message.txt -out message.enc
wc -c message.enc
xxd message.enc
```

`-pass pass:correct-horse` pasa la contraseña en la línea de comandos, lo cual solo es aceptable en un laboratorio (consulta la nota anterior). `wc -c` cuenta los bytes. `xxd` muestra el archivo en hexadecimal, porque el texto cifrado no es texto legible.

Salida esperada (todo lo que sigue a `Salted__` cambia en cada ejecución, porque la sal es aleatoria):
```text
64 message.enc
00000000: 5361 6c74 6564 5f5f 1865 220a 69f3 72b9  Salted__.e".i.r.
00000010: f14c 9111 b8a4 ce73 cd80 41b5 21c6 2ab0  .L.....s..A.!.*.
00000020: b186 557a af33 e545 2692 f807 cd4b 02ef  ..Uz.3.E&....K..
00000030: 9582 5a70 821b b6e4 ff27 f526 190c 0762  ..Zp.....'.&...b
```

Fíjate: el archivo empieza por la palabra `Salted__` y 8 bytes de sal, y el resto parece aleatorio. El texto original no se ve. Ocupa 64 bytes: 8 de `Salted__`, 8 de sal y 48 de datos cifrados (el mensaje de 38 bytes se rellena hasta un múltiplo de 16).

Descífralo con la contraseña correcta:

```bash
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:correct-horse -in message.enc
```

`-d` significa descifrar (*decrypt*). Debes indicar el **mismo** algoritmo y el mismo valor de `-iter`.

Salida esperada:
```text
Transfer 100 EUR to account ES00 1234
```

Prueba ahora una contraseña incorrecta. Envía la salida a un archivo, porque una clave incorrecta produce basura:

```bash
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:wrong-guess -in message.enc -out bad.txt
rm bad.txt
```

Salida esperada (el código hexadecimal del principio de la segunda línea varía):
```text
bad decrypt
00332243777F0000:error:1C800064:Provider routines:ossl_cipher_unpadblock:bad decrypt:providers/implementations/ciphers/ciphercommon_block.c:107:
```

Fíjate: la contraseña incorrecta no revela nada; obtienes un error. El `rm` elimina el archivo de basura que quedó.

> [!NOTE]
> El error no está garantizado. Con este modo, aproximadamente 1 de cada 256 contraseñas incorrectas produce por casualidad un relleno válido, así que `openssl` no imprime ningún error y la salida es basura. El modo no tiene forma de decir «esta clave es incorrecta». El Paso 4 muestra una debilidad mayor del mismo tipo.

### Paso 4 — Por qué quieres cifrado autenticado (6 min)
La lección dice que AES-CBC no da integridad. Compruébalo. El comando siguiente cambia **un byte** en medio de `message.enc`, como podría hacer un atacante. `dd` sobrescribe con cero el byte de la posición 32.

```bash
cp message.enc tampered.enc
printf '\000' | dd of=tampered.enc bs=1 seek=32 conv=notrunc 2>/dev/null
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:correct-horse -in tampered.enc -out tampered.txt
echo "exit code: $?"
xxd tampered.txt
```

Salida esperada (los bytes alterados de la segunda línea y el byte cambiado al principio de la tercera varían, porque la sal es aleatoria):
```text
exit code: 0
00000000: 5472 616e 7366 6572 2031 3030 2045 5552  Transfer 100 EUR
00000010: 63a6 2f97 15ae 6556 aa6a 448b 2a17 3791  c./...eV.jD.*.7.
00000020: 9131 3233 340a                           .1234.
```

Fíjate en tres cosas. El comando dice **éxito** (código de salida 0). Los primeros 16 caracteres están bien. Los 16 siguientes son basura, y el espacio del principio de la última línea (antes de `1234`) se sustituyó por otro byte. OpenSSL no detectó la manipulación: por eso los protocolos modernos usan cifrado **autenticado** (AEAD) como AES-GCM, que falla si cambia aunque sea un solo bit.

Pide a `openssl enc` que use uno:

```bash
openssl enc -aes-256-gcm -pbkdf2 -pass pass:x -in message.txt -out /dev/null
```

Salida esperada:
```text
enc: AEAD ciphers not supported
enc: Use -help for summary.
```

Es un límite real de la herramienta: `openssl enc` no puede usar AES-GCM. Sirve para aprender, no para proteger datos reales. Para archivos reales usa una herramienta mantenida y basada en cifrado autenticado, como `age` o GnuPG, y en tus programas una biblioteca que ofrezca AES-GCM o ChaCha20-Poly1305.

<details>
<summary>Pregunta: ¿por qué el descifrado «tuvo éxito» con un archivo dañado?</summary>

CBC solo convierte bloques de bytes de nuevo en texto plano. No tiene ningún valor de comprobación (ni MAC, ni etiqueta), así que no puede saber que el texto cifrado se modificó. El daño aparece como basura en el bloque posterior al byte cambiado, más un byte invertido en el bloque siguiente. Un modo AEAD añade una etiqueta de autenticación y se niega a descifrar si la etiqueta no coincide.

</details>

### Paso 5 — Firma un archivo y verifica la firma (8 min)
Ahora la autenticidad. Creas un **par de claves** con el algoritmo Ed25519, firmas `message.txt` con la clave **privada** y la compruebas con la clave **pública**.

```bash
openssl genpkey -algorithm ED25519 -out private.pem
openssl pkey -in private.pem -pubout -out public.pem
cat public.pem
```

`genpkey` genera la clave privada. `pkey -pubout` deriva de ella la clave pública. Solo la clave pública está pensada para compartirse.

Salida esperada (el texto de tu clave es distinto):
```text
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAVPF2/34u81ANojBZJ/uT7OQ+7sX3ui2HiaKGVgG8t98=
-----END PUBLIC KEY-----
```

Mira los permisos del archivo de la clave privada. En Linux, OpenSSL lo crea legible solo para ti:

```bash
ls -l private.pem
```

Salida esperada (el propietario, la fecha y los caracteres adicionales varían):
```text
-rw------- 1 user user 119 Nov  7 20:40 private.pem
```

`-rw-------` significa que solo tú puedes leerlo y escribirlo. Una clave privada debe estar siempre así.

Firma el mensaje:

```bash
openssl pkeyutl -sign -inkey private.pem -rawin -in message.txt -out message.sig
wc -c message.sig
```

`pkeyutl -sign` firma con la clave privada. `-rawin` le indica que tome el archivo completo como entrada. Ed25519 calcula el hash del archivo dentro del propio algoritmo, así que no hace falta calcularlo antes.

Salida esperada:
```text
64 message.sig
```

Una firma Ed25519 ocupa siempre 64 bytes, por grande que sea el archivo. Ahora verifica con la clave **pública**:

```bash
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message.txt -sigfile message.sig
```

`-pubin` indica que la clave que das es una clave pública.

Salida esperada:
```text
Signature Verified Successfully
```

Ahora intenta verificar la misma firma contra el archivo **modificado**, `message2.txt` (el de 900 EUR):

```bash
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message2.txt -sigfile message.sig
```

Salida esperada (el código del principio de la primera línea varía):
```text
005364386B7F0000:error:030000EA:digital envelope routines:EVP_DigestVerify:provider signature failure:crypto/evp/m_sigver.c:795:ED25519 digest_verify:
Signature Verification Failure
```

Fíjate: un carácter cambiado y la firma ya no coincide. Nadie puede arreglarlo sin la clave privada. A diferencia del hash del Paso 2, un atacante no puede sustituir la firma para que coincida con un archivo manipulado.

<details>
<summary>Pregunta: ¿quién necesita la clave privada y quién necesita la clave pública?</summary>

El **firmante** necesita la clave privada, para crear firmas. **Todo el que quiera verificar** necesita la clave pública. Por eso puedes publicar la clave pública libremente y debes proteger la clave privada. La pregunta que queda, «¿es esta realmente la clave pública del autor?», la responden los certificados, en el paso siguiente.

</details>

### Paso 6 — Crea un certificado autofirmado y léelo (7 min)
Un certificado vincula una clave pública a un nombre. Un solo comando crea un nuevo par de claves y un certificado **autofirmado** (firmado con su propia clave, sin CA) para un nombre inventado en el dominio reservado `example.org`, válido durante 30 días.

```bash
openssl req -x509 -newkey ed25519 -nodes -keyout server.key -out server.crt -days 30 \
  -subj "/CN=lab.example.org/O=CloudAcademia Lab" -addext "subjectAltName=DNS:lab.example.org"
```

Qué significan las opciones: `req -x509` crea un certificado en lugar de una solicitud; `-newkey ed25519` crea una clave nueva; `-nodes` deja la clave privada sin cifrar (solo para el laboratorio); `-keyout` y `-out` nombran los archivos; `-days 30` fija la validez; `-subj` fija los campos de nombre; `-addext` añade el SAN.

Salida esperada:
```text
-----
```

Lee los campos del certificado que aprendiste en la lección:

```bash
openssl x509 -in server.crt -noout -subject -issuer -dates -ext subjectAltName,basicConstraints
```

Salida esperada (las fechas distan 30 días, empezando cuando ejecutaste el comando):
```text
subject=CN=lab.example.org, O=CloudAcademia Lab
issuer=CN=lab.example.org, O=CloudAcademia Lab
notBefore=Nov  7 19:40:39 2026 GMT
notAfter=Dec  7 19:40:39 2026 GMT
X509v3 Basic Constraints: critical
    CA:TRUE
X509v3 Subject Alternative Name: 
    DNS:lab.example.org
```

Fíjate: **subject e issuer son idénticos**. Eso es lo que significa «autofirmado». Para verlo todo, incluida la clave pública y la firma, imprime el texto completo:

```bash
openssl x509 -in server.crt -noout -text
```

Salida esperada (abreviada; el número de serie y los bytes de la clave y de la firma varían):
```text
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            7f:8f:86:e8:fe:a8:69:a8:09:be:68:86:59:17:31:37:61:10:f1:7d
        Signature Algorithm: ED25519
        Issuer: CN=lab.example.org, O=CloudAcademia Lab
        Validity
            Not Before: Nov  7 19:40:39 2026 GMT
            Not After : Dec  7 19:40:39 2026 GMT
        Subject: CN=lab.example.org, O=CloudAcademia Lab
        Subject Public Key Info:
            Public Key Algorithm: ED25519
                ED25519 Public-Key:
                pub:
                    a7:11:42:5a:60:88:0d:5f:6b:41:97:23:f1:ba:5d:
                    ...
        X509v3 extensions:
            X509v3 Subject Key Identifier: 
                84:24:8A:08:11:DC:3E:B5:44:DF:38:19:3B:90:9F:73:58:49:EA:D5
            X509v3 Authority Key Identifier: 
                84:24:8A:08:11:DC:3E:B5:44:DF:38:19:3B:90:9F:73:58:49:EA:D5
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Subject Alternative Name: 
                DNS:lab.example.org
    Signature Algorithm: ED25519
    Signature Value:
        76:9f:98:3e:86:ac:f9:27:2b:f6:78:4d:56:2a:33:94:14:c3:
        ...
```

Localiza cada campo: Serial Number, Issuer, Validity, Subject, Subject Public Key Info, las extensiones (SAN, Basic Constraints) y la Signature del emisor.

Ahora comprueba por qué los navegadores no confían en él. Pide a OpenSSL que lo verifique contra la lista de raíces de confianza de tu ordenador y, después, contra sí mismo:

```bash
openssl verify server.crt
openssl verify -CAfile server.crt server.crt
```

Salida esperada:
```text
CN=lab.example.org, O=CloudAcademia Lab
error 18 at 0 depth lookup: self-signed certificate
error server.crt: verification failed
server.crt: OK
```

Fíjate: la primera comprobación falla porque ninguna CA de tu **almacén de raíces** avala este certificado. La segunda solo pasa porque tú le dijiste a OpenSSL que confiara en este certificado concreto. La confianza de un navegador es la misma idea, con un centenar largo de raíces ya instaladas.

### Paso 7 — Lee la cadena de certificados real de example.com (5 min)
Este paso necesita Internet. `openssl s_client` abre una conexión TLS como un navegador. `-servername example.com` envía el nombre del servidor para que este elija el certificado adecuado. `</dev/null` termina la sesión de inmediato, para que no se envíe nada más.

```bash
openssl s_client -connect example.com:443 -servername example.com </dev/null > chain.txt 2>&1
sed -n '/^Certificate chain/,/^---/p' chain.txt
```

El primer comando guarda toda la salida en `chain.txt`; `sed` imprime solo la sección de la cadena.

> [!NOTE]
> Este es un sitio web real, así que **tu salida será distinta de la de abajo**: el certificado se renueva cada pocas semanas o meses, y las autoridades de certificación, la longitud de la cadena y los algoritmos pueden cambiar. Busca los mismos tipos de información, no los mismos valores.

Salida esperada (abreviada a los dos primeros certificados; tu lista puede ser más corta o más larga):
```text
Certificate chain
 0 s:CN=example.com
   i:C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
   a:PKEY: EC, (prime256v1); sigalg: ecdsa-with-SHA256
   v:NotBefore: Sep 26 22:49:11 2026 GMT; NotAfter: Dec 25 22:56:35 2026 GMT
 1 s:C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
   i:C=US, O=SSL Corporation, CN=SSL.com TLS Transit ECC CA R2
   a:PKEY: EC, (prime256v1); sigalg: ecdsa-with-SHA384
   v:NotBefore: May 29 19:49:45 2025 GMT; NotAfter: May 27 19:49:44 2035 GMT
 ...
---
```

Léelo así: `s:` es el **subject** (sujeto) e `i:` es el **issuer** (emisor). El certificado 0 es la **hoja** de `example.com`, emitida por la CA intermedia que es el certificado 1. El issuer de cada certificado es el subject del siguiente: eso es la cadena. `v:` da las fechas de validez. Los últimos certificados de la lista son las CA que hay por encima de la intermedia.

Ahora mira qué usó la conexión y si tu ordenador confió en ella:

```bash
grep -E "Protocol|Cipher is|Verification:" chain.txt
```

Salida esperada:
```text
Verification: OK
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Protocol: TLSv1.3
```

Fíjate: **TLS 1.3** con un algoritmo **AES-GCM**, el híbrido de la lección. `Verification: OK` significa que la cadena termina en una raíz que está en tu almacén de raíces. Tus valores pueden diferir (por ejemplo, `TLS_AES_128_GCM_SHA256`).

Por último, lee los detalles del certificado hoja con el comando `x509` que usaste en el Paso 6. `openssl x509` lee el primer certificado del archivo, la hoja:

```bash
openssl x509 -in chain.txt -noout -subject -issuer -dates -ext subjectAltName
```

Salida esperada:
```text
subject=CN=example.com
issuer=C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
notBefore=Sep 26 22:49:11 2026 GMT
notAfter=Dec 25 22:56:35 2026 GMT
X509v3 Subject Alternative Name: 
    DNS:example.com, DNS:*.example.com
```

Responde a estas preguntas con **tu** salida:

1. ¿Quién es el subject y quién es el issuer del certificado hoja?
2. ¿Durante cuántos días es válido el certificado?
3. ¿Qué nombres lista el SAN? ¿Sería válido el certificado para `www.example.com`? ¿Y para `a.b.example.com`?

<details>
<summary>Mostrar las respuestas (para la salida de arriba)</summary>

1. El subject es `CN=example.com`; el issuer es la CA intermedia `Cloudflare TLS Issuing ECC CA 3`.
2. Del 26 de septiembre al 25 de diciembre de 2026: unos 90 días. Los certificados públicos tienen una vida corta, como explica la lección.
3. `example.com` y `*.example.com`. `www.example.com` coincide con el comodín. `a.b.example.com` no: un comodín cubre una sola etiqueta.

Tus propias respuestas serán distintas, pero el método es el mismo: lee el subject, el issuer, `NotBefore` y `NotAfter`, y el SAN.

</details>

## Verificación
Comprueba que obtuviste los resultados clave. Todo esto debe cumplirse:

```bash
sha256sum -c SHA256SUMS
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message.txt -sigfile message.sig
openssl verify -CAfile server.crt server.crt
```

Salida esperada:
```text
message.txt: OK
Signature Verified Successfully
server.crt: OK
```

Lo has superado si:
- el resumen del archivo original coincide (`OK`) y el archivo modificado dio un resumen distinto en el Paso 2;
- la contraseña correcta descifró el archivo y una incorrecta dio `bad decrypt`;
- la firma se verificó para `message.txt` y falló para `message2.txt`;
- pudiste señalar el subject, el issuer, las fechas de validez y el SAN de `example.com` en el Paso 7.

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `openssl version` dice `LibreSSL` u `OpenSSL 1.1.1`, o `pkeyutl` no reconoce `-rawin` | Una versión de OpenSSL anterior o distinta (la predeterminada de macOS es LibreSSL) | Usa OpenSSL 3.0 o posterior: instálalo (por ejemplo con Homebrew en macOS) o usa WSL2 en Windows |
| `Signature Verification Failure` en el Paso 5 para `message.txt` | Editaste `message.txt` después de firmar, o firmaste otro archivo | Repite `openssl pkeyutl -sign` sobre el `message.txt` actual. El fallo con `message2.txt` es el esperado |
| `bad decrypt` al descifrar con la contraseña correcta | Un `-iter` o un algoritmo distinto del usado al cifrar, o una errata en la contraseña | Usa exactamente las mismas opciones y la misma contraseña que en el comando de cifrado |
| `error 18 ... self-signed certificate` con `openssl verify server.crt` | Es lo esperado: ninguna CA de confianza lo firmó | Usa `-CAfile server.crt` como en el Paso 6 para confiar en él de forma explícita |
| Errores `connect: Connection refused`, `Connection timed out` o `getaddrinfo` en el Paso 7 | No hay acceso a Internet, o un cortafuegos o proxy bloquea el puerto 443 | Comprueba tu conexión e inténtalo de nuevo; un proxy puede cambiar la cadena que ves. Omite el Paso 7 si la red está restringida |
| `sha256sum: command not found` en macOS | macOS tiene `shasum` en su lugar | Usa `shasum -a 256 message.txt` |
| Falta la línea `Verification:` o indica un error | Tu ordenador no tiene un paquete de CA, o su reloj es incorrecto | Comprueba la fecha del sistema e instala el paquete de certificados de CA de tu sistema |

## Reto (opcional)
1. Repite el Paso 3 **sin** la opción `-iter`, y con `-iter 1000`. Descifra cada uno. ¿Por qué importa el número de iteraciones para una contraseña, y qué debes recordar en el momento del descifrado?
2. Genera un par de claves RSA con `openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out rsa-key.pem`, deriva su clave pública como en el Paso 5 (llámala `rsa.pub`) y firma `message.txt` con `openssl pkeyutl -sign -inkey rsa-key.pem -rawin -digest sha256 -in message.txt -out rsa.sig`. Verifícala del mismo modo (añade también `-digest sha256` al comando de verificación). Compara el tamaño de la firma y del archivo de clave pública con los de Ed25519 (pista: 384 bytes frente a 64).
3. En el Paso 7, conéctate a `example.org` en lugar de a `example.com` y compara la cadena, el issuer y el SAN con los de `example.com`.

## Limpieza
El laboratorio creó una carpeta en tu directorio personal y nada más. Elimínala, con las claves dentro:

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

Comprueba que ya no está:

```bash
ls ~/crypto-lab
```

Salida esperada:
```text
ls: cannot access '/home/<you>/crypto-lab': No such file or directory
```

No se instaló nada y no se cambió ningún almacén de confianza del sistema.

## Qué has aprendido
- Un hash es una huella repetible y de tamaño fijo: un carácter cambiado da un resumen completamente distinto. Demuestra integridad, pero cualquiera puede recalcularlo, así que no demuestra quién escribió el archivo.
- Cifrar con contraseña usando `openssl enc` oculta el contenido, pero el modo CBC no puede detectar manipulaciones. Prefiere el cifrado autenticado (AES-GCM, ChaCha20-Poly1305) mediante una biblioteca o herramienta adecuada.
- Una firma hecha con una clave privada se verifica con la clave pública y deja de ser válida cuando el archivo cambia. Mantén la clave privada en privado (permisos `600`).
- Un certificado vincula un nombre (el SAN) a una clave pública; uno autofirmado no es de confianza para nadie salvo que tú lo indiques, mientras que uno real enlaza con una raíz del almacén de raíces.
- `openssl s_client` muestra lo que ve tu navegador: la cadena, las fechas de validez, la versión de TLS y el algoritmo de cifrado.
