---
title: "Laboratorio: calcolare hash, cifrare e firmare con OpenSSL"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "gratuito"
environment: "il tuo computer (Linux, macOS o Windows con WSL2) con OpenSSL 3.0 o successivo; accesso a Internet solo per l'ultimo passo"
lang: it
source_hash: a5518221ad4e
---

# Laboratorio: calcolare hash, cifrare e firmare con OpenSSL

## Obiettivo
Prova ogni strumento della lezione su un piccolo file di testo con il comando `openssl`: calcolane l'hash, cifralo con una password, firmalo con una coppia di chiavi e trasforma una chiave in un certificato. Poi leggi la vera catena di certificati di `example.com`, come fa il tuo browser.

## Obiettivi
- Calcolare un digest SHA-256 e verificare che la modifica di un solo carattere lo cambia completamente.
- Cifrare e decifrare un file con una password, e osservare che cosa accade con una password errata e con un file manomesso.
- Creare una coppia di chiavi, firmare un file, verificare la firma e osservare il fallimento della verifica dopo una modifica.
- Creare un certificato autofirmato e leggerne i campi.
- Individuare il soggetto, l'emittente, le date di validità e il SAN in una vera catena di certificati.

## Prerequisiti
- OpenSSL 3.0 o successivo. Verificalo con `openssl version`. Deve indicare `OpenSSL 3.x`, non `LibreSSL` né `1.1.1`.
- Un terminale. Su Windows, usa WSL2.
- Accesso a Internet solo per il Passo 7.
- [La lezione sui fondamenti di crittografia](lesson.it.md) di questo modulo.

> [!WARNING]
> Tutto ciò che avviene nei Passi da 1 a 6 si svolge sul tuo computer con file che crei tu. Il Passo 7 si limita a **connettersi alla porta 443 di `example.com` e a leggere il certificato che offre**, esattamente come fa un browser. Non indirizzare `openssl s_client` verso sistemi che non possiedi o che non sei autorizzato a verificare, e non inviare loro nient'altro.

> [!NOTE]
> Le chiavi e le password di questo laboratorio servono solo per esercitarsi. Non riutilizzare mai una chiave del laboratorio per usi reali e non digitare mai una password reale nella riga di comando: è visibile nell'elenco dei processi e viene salvata nella cronologia della shell.

## Architettura
![Scenario del laboratorio. A sinistra, una zona per il tuo computer, cartella ~/crypto-lab, con quattro schede. Passo 2, hash: message.txt, con sha256sum e openssl dgst. Passi 3 e 4, cifratura: message.enc, con openssl enc e AES-256-CBC. Passo 5, firma: private.pem, public.pem e message.sig con Ed25519. Passo 6, certificato: server.crt e server.key, con openssl req e openssl x509. A destra, una zona di sola lettura per Internet con il passo 7, la vera catena di certificati di example.com sulla porta 443, letta con openssl s_client.](../../../assets/diagrams/crypto-lab-architecture.it.svg)

*Figura 1. I Passi da 2 a 6 restano sul tuo computer; il Passo 7 si limita a leggere un certificato pubblico.*

## Passaggi

### Passo 1 — Crea una cartella di lavoro e un file (3 min)
Lavori in un'unica cartella, così la pulizia finale richiede un solo comando. Il file è una minuscola «disposizione bancaria» che proteggerai in modi diversi.

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

Che cosa fa ciascuna riga: `openssl version` verifica lo strumento; `mkdir` e `cd` creano la cartella e vi accedono; `printf` scrive una riga in `message.txt`; `cat` la mostra.

Output atteso (la data di compilazione dopo la versione sarà diversa sul tuo computer, purché inizi con `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
```

### Passo 2 — Calcola l'hash del file e modifica un carattere (8 min)
Un hash è l'impronta di un file. Calcolalo in due modi: con `sha256sum` (Linux e WSL2; su macOS usa `shasum -a 256`) e con `openssl dgst`.

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

Output atteso:
```text
190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f  message.txt
SHA2-256(message.txt)= 190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f
```

Osserva: entrambi gli strumenti stampano gli **stessi 64 caratteri esadecimali**. Esegui di nuovo uno dei due comandi e otterrai ogni volta lo stesso digest.

Ora crea una copia in cui `100` diventa `900` e calcolane l'hash:

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

Output atteso:
```text
Transfer 900 EUR to account ES00 1234
10bfa161dcd38705488563c4f86395ad2456430fe5b97d08fbbfc8c8322f96c5  message2.txt
```

Confronta con il primo digest. Nel file è cambiato un solo carattere, eppure il digest appare del tutto privo di relazione: è l'**effetto valanga**. La lunghezza resta di 64 caratteri.

Infine usa il digest come lo useresti per verificare un download. Salva il digest in un file, poi chiedi a `sha256sum` di controllare il file rispetto ad esso, prima e dopo la manomissione:

```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» (controlla). I due comandi `cp` sostituiscono prima `message.txt` con la versione modificata (simulando l'azione di un attaccante) e poi lo ripristinano.

Output atteso (le parole sono tradotte in altre lingue):
```text
message.txt: OK
message.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
message.txt: OK
```

<details>
<summary>Domanda: un digest corrispondente dimostra che il file proviene dal vero autore?</summary>

No. Dimostra che il file è identico a quello di cui è stato calcolato l'hash. Se un attaccante può modificare il file, può modificare anche `SHA256SUMS`. Per dimostrare **chi** ha creato il file serve una chiave: è la firma che creerai nel Passo 5.

</details>

### Passo 3 — Cifra e decifra con una password (8 min)
Ora la riservatezza. `openssl enc` cifra un file con AES-256 e una chiave ricavata dalla tua password. L'opzione `-pbkdf2 -iter 600000` fa sì che openssl trasformi la password in una chiave con PBKDF2, lentamente, e `-salt` aggiunge un salt casuale (è di nuovo l'idea della lezione sull'hash delle password).

```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` fornisce la password nella riga di comando, cosa accettabile solo in un laboratorio (vedi la nota precedente). `wc -c` conta i byte. `xxd` mostra il file in esadecimale, perché il testo cifrato non è un testo leggibile.

Output atteso (tutto ciò che segue `Salted__` varia a ogni esecuzione, perché il salt è casuale):
```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
```

Osserva: il file inizia con la parola `Salted__` e 8 byte di salt, e il resto appare casuale. Il testo originale non è visibile. Il file è di 64 byte: 8 per `Salted__`, 8 per il salt e 48 per i dati cifrati (il messaggio di 38 byte viene completato con padding fino a un multiplo di 16).

Decifralo con la password corretta:

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

`-d` significa decifra. Devi indicare lo **stesso** cifrario e lo stesso valore di `-iter`.

Output atteso:
```text
Transfer 100 EUR to account ES00 1234
```

Ora prova con una password errata. Invia l'output a un file, perché una chiave errata produce dati privi di senso:

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

Output atteso (il codice esadecimale all'inizio della seconda riga varia):
```text
bad decrypt
00332243777F0000:error:1C800064:Provider routines:ossl_cipher_unpadblock:bad decrypt:providers/implementations/ciphers/ciphercommon_block.c:107:
```

Osserva: la password errata non rivela nulla; ottieni un errore. Il comando `rm` elimina il file con dati privi di senso rimasto.

> [!NOTE]
> L'errore non è garantito. Con questa modalità, circa 1 password errata su 256 produce per caso un padding valido, quindi `openssl` non stampa alcun errore e l'output è privo di senso. La modalità non ha modo di dire «questa chiave è errata». Il Passo 4 mostra una debolezza maggiore dello stesso tipo.

### Passo 4 — Perché serve la cifratura autenticata (6 min)
La lezione afferma che AES-CBC non garantisce l'integrità. Verificalo. Il comando seguente modifica **un byte** al centro di `message.enc`, come potrebbe fare un attaccante. `dd` sovrascrive con zero il byte in posizione 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
```

Output atteso (i byte alterati nella seconda riga e il byte modificato all'inizio della terza riga variano, perché il salt è casuale):
```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.
```

Osserva tre cose. Il comando indica **successo** (codice di uscita 0). I primi 16 caratteri sono corretti. I 16 successivi sono privi di senso, e lo spazio all'inizio dell'ultima riga (prima di `1234`) è stato sostituito da un altro byte. OpenSSL non ha rilevato la manomissione: ecco perché i protocolli moderni usano la cifratura **autenticata** (AEAD), come AES-GCM, che fallisce se cambia anche un solo bit.

Chiedi a `openssl enc` di usarne una:

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

Output atteso:
```text
enc: AEAD ciphers not supported
enc: Use -help for summary.
```

Questo è un limite onesto dello strumento: `openssl enc` non supporta AES-GCM. Va bene per imparare, non per proteggere dati reali. Per i file reali usa uno strumento mantenuto e basato sulla cifratura autenticata, come `age` o GnuPG, e nei tuoi programmi una libreria che offra AES-GCM o ChaCha20-Poly1305.

<details>
<summary>Domanda: perché la decifratura è «riuscita» con un file danneggiato?</summary>

CBC si limita a trasformare i blocchi di byte nuovamente in testo in chiaro. Non dispone di alcun valore di controllo (né MAC né tag), quindi non può sapere che il testo cifrato è stato modificato. Il danno compare come dati privi di senso nel blocco successivo al byte modificato, più un byte invertito nel blocco seguente. Una modalità AEAD aggiunge un tag di autenticazione e rifiuta di decifrare se il tag non corrisponde.

</details>

### Passo 5 — Firma un file e verifica la firma (8 min)
Ora l'autenticità. Crei una **coppia di chiavi** con l'algoritmo Ed25519, firmi `message.txt` con la chiave **privata** e la verifichi con la chiave **pubblica**.

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

`genpkey` genera la chiave privata. `pkey -pubout` ne ricava la chiave pubblica. Solo la chiave pubblica è destinata a essere condivisa.

Output atteso (il testo della tua chiave sarà diverso):
```text
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAVPF2/34u81ANojBZJ/uT7OQ+7sX3ui2HiaKGVgG8t98=
-----END PUBLIC KEY-----
```

Osserva i permessi del file della chiave privata. Su Linux, OpenSSL lo crea leggibile soltanto da te:

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

Output atteso (proprietario, data e caratteri aggiuntivi variano):
```text
-rw------- 1 user user 119 Nov  7 20:40 private.pem
```

`-rw-------` significa che solo tu puoi leggerlo e scriverlo. Una chiave privata deve sempre avere questi permessi.

Firma il messaggio:

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

`pkeyutl -sign` firma con la chiave privata. `-rawin` indica di prendere l'intero file come input. Ed25519 calcola l'hash del file al proprio interno, quindi non devi calcolarlo prima.

Output atteso:
```text
64 message.sig
```

Una firma Ed25519 è sempre di 64 byte, indipendentemente dalle dimensioni del file. Ora verifica con la chiave **pubblica**:

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

`-pubin` indica che la chiave fornita è una chiave pubblica.

Output atteso:
```text
Signature Verified Successfully
```

Ora prova a verificare la stessa firma rispetto al file **modificato**, `message2.txt` (quello con 900 EUR):

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

Output atteso (il codice all'inizio della prima riga varia):
```text
005364386B7F0000:error:030000EA:digital envelope routines:EVP_DigestVerify:provider signature failure:crypto/evp/m_sigver.c:795:ED25519 digest_verify:
Signature Verification Failure
```

Osserva: un solo carattere modificato e la firma non corrisponde più. Nessuno può correggerla senza la chiave privata. A differenza dell'hash del Passo 2, un attaccante non può sostituire la firma per adeguarla a un file manomesso.

<details>
<summary>Domanda: chi ha bisogno della chiave privata e chi della chiave pubblica?</summary>

Il **firmatario** ha bisogno della chiave privata, per creare le firme. **Chiunque voglia verificare** ha bisogno della chiave pubblica. Per questo puoi pubblicare liberamente la chiave pubblica e devi proteggere la chiave privata. La domanda rimanente, «questa è davvero la chiave pubblica dell'autore?», trova risposta nei certificati, nel passo successivo.

</details>

### Passo 6 — Crea un certificato autofirmato e leggilo (7 min)
Un certificato associa una chiave pubblica a un nome. Un solo comando crea una nuova coppia di chiavi e un certificato **autofirmato** (firmato con la propria chiave, senza alcuna CA) per un nome inventato nel dominio riservato `example.org`, valido per 30 giorni.

```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"
```

Significato delle opzioni: `req -x509` crea un certificato anziché una richiesta; `-newkey ed25519` crea una nuova chiave; `-nodes` lascia la chiave privata non cifrata (solo per il laboratorio); `-keyout` e `-out` assegnano i nomi ai file; `-days 30` imposta la validità; `-subj` imposta i campi del nome; `-addext` aggiunge il SAN.

Output atteso:
```text
-----
```

Leggi i campi del certificato appresi nella lezione:

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

Output atteso (le date distano 30 giorni, a partire dal momento in cui hai eseguito il 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
```

Osserva: **soggetto ed emittente sono identici**. Questo significa «autofirmato». Per vedere tutto, compresi la chiave pubblica e la firma, stampa il testo completo:

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

Output atteso (abbreviato; numero di serie, chiave e byte della firma variano):
```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:
        ...
```

Individua ciascun campo: Serial Number, Issuer, Validity, Subject, Subject Public Key Info, le estensioni (SAN, Basic Constraints) e la Signature dell'emittente.

Ora vedi perché i browser non vi si fidano. Chiedi a OpenSSL di verificarlo rispetto all'elenco delle radici attendibili del tuo computer, e poi rispetto a se stesso:

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

Output atteso:
```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
```

Osserva: il primo controllo fallisce perché nessuna CA nel tuo **archivio delle radici attendibili** garantisce per questo certificato. Il secondo riesce solo perché hai indicato a OpenSSL di considerare attendibile proprio questo certificato. La fiducia di un browser segue lo stesso principio, con un centinaio circa di radici già installate.

### Passo 7 — Leggi la vera catena di certificati di example.com (5 min)
Questo passo richiede Internet. `openssl s_client` apre una connessione TLS come un browser. `-servername example.com` invia il nome del server, così il server sceglie il certificato corretto. `</dev/null` termina subito la sessione, così non viene inviato nient'altro.

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

Il primo comando salva l'intero output in `chain.txt`; `sed` stampa solo la sezione della catena.

> [!NOTE]
> Questo è un sito web reale, quindi **il tuo output sarà diverso da quello riportato di seguito**: il certificato viene rinnovato ogni poche settimane o mesi, e le autorità di certificazione, la lunghezza della catena e gli algoritmi possono cambiare. Cerca lo stesso tipo di informazioni, non gli stessi valori.

Output atteso (abbreviato ai primi due certificati; il tuo elenco può essere più breve o più lungo):
```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
 ...
---
```

Leggilo così: `s:` è il **soggetto** (subject) e `i:` è l'**emittente** (issuer). Il certificato 0 è la **foglia** per `example.com`, emessa dalla CA intermedia che è il certificato 1. L'emittente di ciascun certificato è il soggetto del successivo: questa è la catena. `v:` indica le date di validità. Gli ultimi certificati dell'elenco sono le CA al di sopra dell'intermedia.

Ora verifica che cosa ha usato la connessione e se il tuo computer l'ha considerata attendibile:

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

Output atteso:
```text
Verification: OK
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Protocol: TLSv1.3
```

Osserva: **TLS 1.3** con un cifrario **AES-GCM**, l'ibrido della lezione. `Verification: OK` significa che la catena termina in una radice presente nel tuo archivio delle radici attendibili. I tuoi valori possono differire (per esempio `TLS_AES_128_GCM_SHA256`).

Infine leggi i dettagli del certificato foglia con il comando `x509` usato nel Passo 6. `openssl x509` legge il primo certificato del file, la foglia:

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

Output atteso:
```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
```

Rispondi a queste domande con il **tuo** output:

1. Chi è il soggetto e chi è l'emittente del certificato foglia?
2. Per quanti giorni è valido il certificato?
3. Quali nomi elenca il SAN? Il certificato sarebbe valido per `www.example.com`? E per `a.b.example.com`?

<details>
<summary>Mostra le risposte (per l'output riportato sopra)</summary>

1. Il soggetto è `CN=example.com`; l'emittente è la CA intermedia `Cloudflare TLS Issuing ECC CA 3`.
2. Dal 26 settembre al 25 dicembre 2026: circa 90 giorni. I certificati pubblici hanno una vita breve, come spiega la lezione.
3. `example.com` e `*.example.com`. `www.example.com` corrisponde al carattere jolly. `a.b.example.com` no: un carattere jolly copre una sola etichetta.

Le tue risposte saranno diverse, ma il metodo è lo stesso: leggi il soggetto, l'emittente, `NotBefore` e `NotAfter`, e il SAN.

</details>

## Verifica
Controlla di aver ottenuto i risultati principali. Tutte queste condizioni devono essere vere:

```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
```

Output atteso:
```text
message.txt: OK
Signature Verified Successfully
server.crt: OK
```

Hai superato la verifica se:
- il digest del file originale corrisponde (`OK`) e il file modificato ha prodotto un digest diverso nel Passo 2;
- la password corretta ha decifrato il file e una errata ha prodotto `bad decrypt`;
- la firma è stata verificata per `message.txt` ed è fallita per `message2.txt`;
- hai saputo indicare il soggetto, l'emittente, le date di validità e il SAN di `example.com` nel Passo 7.

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `openssl version` indica `LibreSSL` oppure `OpenSSL 1.1.1`, oppure `pkeyutl` non riconosce `-rawin` | Una versione di OpenSSL più datata o diversa (quella predefinita di macOS è LibreSSL) | Usa OpenSSL 3.0 o successivo: installalo (per esempio con Homebrew su macOS) oppure usa WSL2 su Windows |
| `Signature Verification Failure` nel Passo 5 per `message.txt` | Hai modificato `message.txt` dopo la firma, oppure hai firmato un altro file | Ripeti `openssl pkeyutl -sign` sul `message.txt` attuale. Il fallimento per `message2.txt` è previsto |
| `bad decrypt` durante la decifratura con la password corretta | Un valore di `-iter` o un cifrario diversi da quelli usati nella cifratura, oppure un errore di battitura nella password | Usa esattamente le stesse opzioni e la stessa password del comando di cifratura |
| `error 18 ... self-signed certificate` da `openssl verify server.crt` | Previsto: nessuna CA attendibile lo ha firmato | Usa `-CAfile server.crt` come nel Passo 6 per considerarlo attendibile in modo esplicito |
| `connect: Connection refused`, `Connection timed out` o errori `getaddrinfo` nel Passo 7 | Nessun accesso a Internet, oppure un firewall o un proxy blocca la porta 443 | Controlla la connessione e riprova; un proxy può modificare la catena che vedi. Salta il Passo 7 se la rete è limitata |
| `sha256sum: command not found` su macOS | macOS dispone di `shasum` | Usa `shasum -a 256 message.txt` |
| La riga `Verification:` manca o indica un errore | Il tuo computer non ha un bundle di CA, oppure l'orologio è errato | Controlla la data di sistema e installa il pacchetto dei certificati CA del tuo sistema |

## Sfida (facoltativa)
1. Ripeti il Passo 3 **senza** l'opzione `-iter`, e con `-iter 1000`. Decifra ciascun file. Perché il numero di iterazioni è importante per una password, e che cosa devi ricordare al momento della decifratura?
2. Genera una coppia di chiavi RSA con `openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out rsa-key.pem`, ricavane la chiave pubblica come nel Passo 5 (chiamala `rsa.pub`) e firma `message.txt` con `openssl pkeyutl -sign -inkey rsa-key.pem -rawin -digest sha256 -in message.txt -out rsa.sig`. Verificala nello stesso modo (aggiungi `-digest sha256` anche al comando di verifica). Confronta la dimensione della firma e quella del file della chiave pubblica con quelle di Ed25519 (suggerimento: 384 byte contro 64).
3. Nel Passo 7, connettiti a `example.org` anziché a `example.com` e confronta la catena, l'emittente e il SAN con quelli di `example.com`.

## Pulizia
Il laboratorio ha creato una sola cartella nella tua directory home e nient'altro. Eliminala, insieme alle chiavi che contiene:

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

Verifica che sia scomparsa:

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

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

Non è stato installato nulla e nessun archivio di fiducia del sistema è stato modificato.

## Cosa hai imparato
- Un hash è un'impronta di dimensione fissa e ripetibile: un carattere modificato produce un digest completamente diverso. Dimostra l'integrità, ma chiunque può ricalcolarlo, quindi non dimostra chi ha scritto il file.
- La cifratura con password tramite `openssl enc` nasconde il contenuto, ma la modalità CBC non rileva le manomissioni. Preferisci la cifratura autenticata (AES-GCM, ChaCha20-Poly1305) tramite una libreria o uno strumento adeguato.
- Una firma creata con una chiave privata si verifica con la chiave pubblica e si invalida quando il file cambia. Mantieni riservata la chiave privata (permessi `600`).
- Un certificato associa un nome (il SAN) a una chiave pubblica; uno autofirmato non è considerato attendibile da nessuno a meno che non lo si indichi, mentre uno reale è collegato da una catena a una radice presente nell'archivio delle radici attendibili.
- `openssl s_client` mostra ciò che vede il tuo browser: la catena, le date di validità, la versione di TLS e il cifrario.
