---
title: "Laboratório: calcular hashes, cifrar e assinar com o OpenSSL"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "gratuito"
environment: "o seu próprio computador (Linux, macOS ou Windows com WSL2) com OpenSSL 3.0 ou posterior; acesso à Internet apenas no último passo"
lang: pt
source_hash: a5518221ad4e
---

# Laboratório: calcular hashes, cifrar e assinar com o OpenSSL

## Objetivo
Experimente todas as ferramentas da lição num pequeno ficheiro de texto com o comando `openssl`: calcule o respetivo hash, cifre-o com uma palavra-passe, assine-o com um par de chaves e transforme uma chave num certificado. Depois, leia a cadeia de certificados real de `example.com`, tal como o seu browser faz.

## Objetivos
- Calcular um resumo SHA-256 e ver que alterar um carácter o muda por completo.
- Cifrar e decifrar um ficheiro com uma palavra-passe, e ver o que acontece com uma palavra-passe errada e com um ficheiro adulterado.
- Criar um par de chaves, assinar um ficheiro, verificar a assinatura e ver a verificação falhar após uma alteração.
- Criar um certificado autoassinado e ler os respetivos campos.
- Identificar o titular (subject), o emissor (issuer), as datas de validade e o SAN numa cadeia de certificados real.

## Pré-requisitos
- OpenSSL 3.0 ou posterior. Verifique-o com `openssl version`. Tem de indicar `OpenSSL 3.x`, não `LibreSSL` nem `1.1.1`.
- Um terminal. No Windows, use o WSL2.
- Acesso à Internet apenas para o Passo 7.
- [A lição Fundamentos de criptografia](lesson.pt.md) deste módulo.

> [!WARNING]
> Tudo nos Passos 1 a 6 acontece no seu próprio computador, com ficheiros que cria. O Passo 7 apenas **liga à porta 443 de `example.com` e lê o certificado que este apresenta**, exatamente como faz um browser. Não aponte o `openssl s_client` a sistemas que não lhe pertençam ou que não esteja autorizado a testar, e não lhes envie mais nada.

> [!NOTE]
> As chaves e as palavras-passe deste laboratório servem apenas para praticar. Nunca reutilize uma chave do laboratório para algo real e nunca escreva uma palavra-passe real na linha de comandos: fica visível na lista de processos e guardada no histórico da shell.

## Arquitetura
![Cenário do laboratório. À esquerda, uma zona para o seu computador, pasta ~/crypto-lab, com quatro cartões. Passo 2, hash: message.txt, com sha256sum e openssl dgst. Passos 3 e 4, cifrar: message.enc, com openssl enc e AES-256-CBC. Passo 5, assinar: private.pem, public.pem e message.sig com Ed25519. Passo 6, certificado: server.crt e server.key, com openssl req e openssl x509. À direita, uma zona só de leitura para a Internet com o passo 7, a cadeia de certificados real de example.com na porta 443, lida com openssl s_client.](../../../assets/diagrams/crypto-lab-architecture.pt.svg)

*Figura 1. Os passos 2 a 6 ficam no seu computador; o Passo 7 apenas lê um certificado público.*

## Passos

### Passo 1 — Criar uma pasta de trabalho e um ficheiro (3 min)
Trabalha numa única pasta, para que a limpeza no fim seja um só comando. O ficheiro é uma pequena «instrução bancária» que vai proteger de diferentes formas.

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

O que faz cada linha: `openssl version` verifica a ferramenta; `mkdir` e `cd` criam e abrem a pasta; `printf` escreve uma linha em `message.txt`; `cat` mostra-a.

Resultado esperado (a data de compilação a seguir à versão é diferente no seu computador, desde que comece 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
```

### Passo 2 — Calcular o hash do ficheiro e alterar um carácter (8 min)
Um hash é uma impressão digital do ficheiro. Calcule-o de duas formas: `sha256sum` (Linux e WSL2; no macOS use `shasum -a 256`) e `openssl dgst`.

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

Resultado esperado:
```text
190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f  message.txt
SHA2-256(message.txt)= 190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f
```

Repare: as duas ferramentas mostram os **mesmos 64 carateres hexadecimais**. Execute qualquer um dos comandos outra vez e obtém sempre o mesmo resumo.

Agora faça uma cópia em que `100` passa a `900` e calcule o respetivo hash:

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

Resultado esperado:
```text
Transfer 900 EUR to account ES00 1234
10bfa161dcd38705488563c4f86395ad2456430fe5b97d08fbbfc8c8322f96c5  message2.txt
```

Compare com o primeiro resumo. Mudou um carácter no ficheiro e, no entanto, o resumo parece completamente sem relação: é o **efeito avalanche**. O tamanho continua a ser de 64 carateres.

Por fim, use o resumo como o usaria para verificar um ficheiro descarregado. Guarde o resumo num ficheiro e peça ao `sha256sum` que verifique o ficheiro com base nele, antes e depois da adulteração:

```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» (verificar). Os dois comandos `cp` substituem primeiro o `message.txt` pela versão alterada (a fingir que foi um atacante) e depois restauram-no.

Resultado esperado (as palavras são traduzidas noutras línguas):
```text
message.txt: OK
message.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
message.txt: OK
```

<details>
<summary>Pergunta: um resumo coincidente prova que o ficheiro é do autor verdadeiro?</summary>

Não. Prova que o ficheiro é igual àquele de que se calculou o hash. Se um atacante pode alterar o ficheiro, pode alterar também o `SHA256SUMS`. Para provar **quem** fez o ficheiro é preciso uma chave: é a assinatura que cria no Passo 5.

</details>

### Passo 3 — Cifrar e decifrar com uma palavra-passe (8 min)
Agora a confidencialidade. O `openssl enc` cifra um ficheiro com AES-256 e uma chave obtida a partir da sua palavra-passe. A opção `-pbkdf2 -iter 600000` faz com que o openssl transforme a palavra-passe numa chave com o PBKDF2, lentamente, e `-salt` acrescenta um sal aleatório (é de novo a ideia de hash de palavras-passe da lição).

```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` indica a palavra-passe na linha de comandos, o que só é aceitável num laboratório (veja a nota acima). `wc -c` conta os bytes. `xxd` mostra o ficheiro em hexadecimal, porque o texto cifrado não é texto legível.

Resultado esperado (tudo o que vem depois de `Salted__` varia em cada execução, porque o sal é aleatório):
```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
```

Repare: o ficheiro começa pela palavra `Salted__` e por 8 bytes de sal, e o resto parece aleatório. O texto original não é visível. Tem 64 bytes: 8 para `Salted__`, 8 para o sal e 48 para os dados cifrados (a mensagem de 38 bytes é preenchida até um múltiplo de 16).

Decifre-o com a palavra-passe certa:

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

`-d` significa decifrar (*decrypt*). Tem de indicar a **mesma** cifra e o mesmo valor de `-iter`.

Resultado esperado:
```text
Transfer 100 EUR to account ES00 1234
```

Experimente agora uma palavra-passe errada. Envie o resultado para um ficheiro, porque uma chave errada produz lixo:

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

Resultado esperado (o código hexadecimal no início da segunda linha varia):
```text
bad decrypt
00332243777F0000:error:1C800064:Provider routines:ossl_cipher_unpadblock:bad decrypt:providers/implementations/ciphers/ciphercommon_block.c:107:
```

Repare: a palavra-passe errada não revela nada; obtém um erro. O `rm` apaga o ficheiro de lixo que ficou.

> [!NOTE]
> O erro não é garantido. Com este modo, cerca de 1 palavra-passe errada em 256 acaba por produzir um preenchimento válido, pelo que o `openssl` não mostra erro e o resultado é lixo. O modo não tem forma de dizer «esta chave está errada». O Passo 4 mostra uma fraqueza maior do mesmo tipo.

### Passo 4 — Por que razão se quer cifragem autenticada (6 min)
A lição diz que o AES-CBC não dá integridade. Confirme-o. O comando abaixo altera **um byte** a meio do `message.enc`, como poderia fazer um atacante. O `dd` substitui por zero o byte na posição 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
```

Resultado esperado (os bytes corrompidos na segunda linha e o byte alterado no início da terceira linha variam, porque o sal é aleatório):
```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.
```

Repare em três coisas. O comando diz **sucesso** (código de saída 0). Os primeiros 16 carateres estão bem. Os 16 seguintes são lixo e o espaço no início da última linha (antes de `1234`) foi substituído por outro byte. O OpenSSL não detetou a adulteração: é por isso que os protocolos modernos usam cifragem **autenticada** (AEAD), como o AES-GCM, que falha se mudar sequer um bit.

Peça ao `openssl enc` que use uma:

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

Resultado esperado:
```text
enc: AEAD ciphers not supported
enc: Use -help for summary.
```

Este é um limite assumido da ferramenta: o `openssl enc` não consegue fazer AES-GCM. Serve para aprender, não para proteger dados reais. Para ficheiros reais use uma ferramenta mantida e construída sobre cifragem autenticada, como o `age` ou o GnuPG, e nos seus programas uma biblioteca que ofereça AES-GCM ou ChaCha20-Poly1305.

<details>
<summary>Pergunta: por que razão a decifragem «teve sucesso» com um ficheiro danificado?</summary>

O CBC apenas transforma blocos de bytes de volta em texto em claro. Não tem valor de verificação (nem MAC, nem etiqueta), pelo que não pode saber que o texto cifrado foi alterado. O dano aparece como lixo no bloco a seguir ao byte alterado, mais um byte invertido no bloco seguinte. Um modo AEAD acrescenta uma etiqueta de autenticação e recusa-se a decifrar se a etiqueta não coincidir.

</details>

### Passo 5 — Assinar um ficheiro e verificar a assinatura (8 min)
Agora a autenticidade. Cria um **par de chaves** com o algoritmo Ed25519, assina o `message.txt` com a chave **privada** e verifica-o com a chave **pública**.

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

`genpkey` gera a chave privada. `pkey -pubout` deriva dela a chave pública. Só a chave pública se destina a ser partilhada.

Resultado esperado (o texto da sua chave é diferente):
```text
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAVPF2/34u81ANojBZJ/uT7OQ+7sX3ui2HiaKGVgG8t98=
-----END PUBLIC KEY-----
```

Veja as permissões do ficheiro da chave privada. No Linux, o OpenSSL cria-o legível apenas por si:

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

Resultado esperado (o proprietário, a data e os carateres adicionais variam):
```text
-rw------- 1 user user 119 Nov  7 20:40 private.pem
```

`-rw-------` significa que só você a pode ler e escrever. Uma chave privada deve estar sempre assim.

Assine a mensagem:

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

`pkeyutl -sign` assina com a chave privada. `-rawin` indica que deve receber o ficheiro inteiro como entrada. O Ed25519 calcula o hash do ficheiro dentro do próprio algoritmo, por isso não é preciso calculá-lo antes.

Resultado esperado:
```text
64 message.sig
```

Uma assinatura Ed25519 tem sempre 64 bytes, por maior que seja o ficheiro. Agora verifique com a chave **pública**:

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

`-pubin` indica que a chave fornecida é uma chave pública.

Resultado esperado:
```text
Signature Verified Successfully
```

Agora tente verificar a mesma assinatura com o ficheiro **alterado**, `message2.txt` (o de 900 EUR):

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

Resultado esperado (o código no início da primeira linha 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
```

Repare: um carácter alterado e a assinatura deixa de coincidir. Ninguém a consegue corrigir sem a chave privada. Ao contrário do hash do Passo 2, um atacante não pode substituir a assinatura para a fazer coincidir com um ficheiro adulterado.

<details>
<summary>Pergunta: quem precisa da chave privada e quem precisa da chave pública?</summary>

O **signatário** precisa da chave privada, para criar assinaturas. **Todos os que querem verificar** precisam da chave pública. É por isso que pode publicar livremente a chave pública e tem de proteger a chave privada. A pergunta que resta, «esta é mesmo a chave pública do autor?», é respondida pelos certificados, no passo seguinte.

</details>

### Passo 6 — Criar um certificado autoassinado e lê-lo (7 min)
Um certificado liga uma chave pública a um nome. Um só comando cria um novo par de chaves e um certificado **autoassinado** (assinado pela sua própria chave, sem CA) para um nome inventado no domínio reservado `example.org`, válido durante 30 dias.

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

O que significam as opções: `req -x509` cria um certificado em vez de um pedido; `-newkey ed25519` cria uma chave nova; `-nodes` deixa a chave privada sem cifra (só para o laboratório); `-keyout` e `-out` dão nome aos ficheiros; `-days 30` define a validade; `-subj` define os campos do nome; `-addext` acrescenta o SAN.

Resultado esperado:
```text
-----
```

Leia os campos do certificado que aprendeu na lição:

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

Resultado esperado (as datas distam 30 dias, a começar quando executou o 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
```

Repare: **o titular (subject) e o emissor (issuer) são idênticos**. É isso que significa «autoassinado». Para ver tudo, incluindo a chave pública e a assinatura, mostre o texto completo:

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

Resultado esperado (abreviado; o número de série e os bytes da chave e da assinatura variam):
```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:
        ...
```

Encontre cada campo: Serial Number, Issuer, Validity, Subject, Subject Public Key Info, extensões (SAN, Basic Constraints) e a Signature do emissor.

Veja agora por que razão os browsers não confiam nele. Peça ao OpenSSL que o verifique com a lista de raízes de confiança do seu computador e depois consigo próprio:

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

Resultado esperado:
```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
```

Repare: a primeira verificação falha porque nenhuma CA do seu **repositório de raízes** (*root store*) garante este certificado. A segunda só passa porque indicou ao OpenSSL que confie neste certificado exato. A confiança de um browser é a mesma ideia, com cerca de uma centena de raízes já instaladas.

### Passo 7 — Ler a cadeia de certificados real de example.com (5 min)
Este passo precisa da Internet. O `openssl s_client` abre uma ligação TLS como um browser. `-servername example.com` envia o nome do servidor para que este escolha o certificado certo. `</dev/null` termina a sessão logo a seguir, pelo que não se envia mais nada.

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

O primeiro comando guarda todo o resultado em `chain.txt`; o `sed` mostra apenas a secção da cadeia.

> [!NOTE]
> Este é um sítio web real, pelo que **o seu resultado será diferente do que se mostra abaixo**: o certificado é renovado a cada poucas semanas ou meses, e as autoridades de certificação, o tamanho da cadeia e os algoritmos podem mudar. Procure os mesmos tipos de informação, não os mesmos valores.

Resultado esperado (abreviado aos dois primeiros certificados; a sua lista pode ser mais curta ou mais longa):
```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
 ...
---
```

Leia assim: `s:` é o **titular** (subject) e `i:` é o **emissor** (issuer). O certificado 0 é o certificado **final** (*leaf*) de `example.com`, emitido pela CA intermédia que é o certificado 1. O emissor de cada certificado é o titular do seguinte: é isso a cadeia. `v:` indica as datas de validade. Os últimos certificados da lista são as CA acima da intermédia.

Veja agora o que a ligação usou e se o seu computador confiou nela:

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

Resultado esperado:
```text
Verification: OK
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Protocol: TLSv1.3
```

Repare: **TLS 1.3** com uma cifra **AES-GCM**, o híbrido da lição. `Verification: OK` significa que a cadeia termina numa raiz que está no seu repositório de raízes. Os seus valores podem ser diferentes (por exemplo, `TLS_AES_128_GCM_SHA256`).

Por fim, leia os detalhes do certificado final com o comando `x509` que usou no Passo 6. O `openssl x509` lê o primeiro certificado do ficheiro, o certificado final:

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

Resultado esperado:
```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
```

Responda a estas perguntas com o **seu** resultado:

1. Quem é o titular e quem é o emissor do certificado final?
2. Durante quantos dias é válido o certificado?
3. Que nomes lista o SAN? O certificado seria válido para `www.example.com`? E para `a.b.example.com`?

<details>
<summary>Mostrar as respostas (para o resultado acima)</summary>

1. O titular é `CN=example.com`; o emissor é a CA intermédia `Cloudflare TLS Issuing ECC CA 3`.
2. De 26 de setembro a 25 de dezembro de 2026: cerca de 90 dias. Os certificados públicos têm vida curta, como a lição explica.
3. `example.com` e `*.example.com`. `www.example.com` corresponde ao wildcard. `a.b.example.com` não: um wildcard cobre apenas uma etiqueta (*label*).

As suas respostas serão diferentes, mas o método é o mesmo: leia o titular, o emissor, `NotBefore` e `NotAfter`, e o SAN.

</details>

## Verificação
Confirme que obteve os resultados principais. Todas estas condições têm de se verificar:

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

Resultado esperado:
```text
message.txt: OK
Signature Verified Successfully
server.crt: OK
```

Está aprovado se:
- o resumo do ficheiro original coincide (`OK`) e o ficheiro alterado deu um resumo diferente no Passo 2;
- a palavra-passe certa decifrou o ficheiro e uma errada deu `bad decrypt`;
- a assinatura foi verificada para o `message.txt` e falhou para o `message2.txt`;
- conseguiu identificar o titular, o emissor, as datas de validade e o SAN de `example.com` no Passo 7.

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `openssl version` indica `LibreSSL` ou `OpenSSL 1.1.1`, ou o `pkeyutl` não conhece `-rawin` | Um OpenSSL mais antigo ou diferente (o predefinido no macOS é o LibreSSL) | Use o OpenSSL 3.0 ou posterior: instale-o (por exemplo, com o Homebrew no macOS) ou use o WSL2 no Windows |
| `Signature Verification Failure` no Passo 5 para o `message.txt` | Editou o `message.txt` depois de o assinar, ou assinou outro ficheiro | Repita o `openssl pkeyutl -sign` sobre o `message.txt` atual. A falha para o `message2.txt` é esperada |
| `bad decrypt` ao decifrar com a palavra-passe certa | Um `-iter` ou uma cifra diferentes dos usados ao cifrar, ou um erro de escrita na palavra-passe | Use exatamente as mesmas opções e a mesma palavra-passe do comando de cifragem |
| `error 18 ... self-signed certificate` no `openssl verify server.crt` | Esperado: nenhuma CA de confiança o assinou | Use `-CAfile server.crt` como no Passo 6 para confiar nele explicitamente |
| `connect: Connection refused`, `Connection timed out` ou erros `getaddrinfo` no Passo 7 | Sem acesso à Internet, ou uma firewall ou um proxy bloqueia a porta 443 | Verifique a ligação e tente de novo; um proxy pode alterar a cadeia que vê. Salte o Passo 7 se a rede for restrita |
| `sha256sum: command not found` no macOS | O macOS tem o `shasum` | Use `shasum -a 256 message.txt` |
| A linha `Verification:` não aparece ou indica um erro | O seu computador não tem pacote de CA, ou o relógio está errado | Verifique a data do sistema e instale o pacote de certificados de CA do seu sistema |

## Desafio (opcional)
1. Repita o Passo 3 **sem** a opção `-iter` e com `-iter 1000`. Decifre cada um. Por que razão o número de iterações importa numa palavra-passe e do que tem de se lembrar no momento da decifragem?
2. Gere um par de chaves RSA com `openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out rsa-key.pem`, derive a chave pública como no Passo 5 (chame-lhe `rsa.pub`) e assine o `message.txt` com `openssl pkeyutl -sign -inkey rsa-key.pem -rawin -digest sha256 -in message.txt -out rsa.sig`. Verifique-o da mesma forma (acrescente também `-digest sha256` ao comando de verificação). Compare o tamanho da assinatura e o do ficheiro da chave pública com os do Ed25519 (pista: 384 bytes contra 64).
3. No Passo 7, ligue-se em vez disso a `example.org` e compare a cadeia, o emissor e o SAN com os de `example.com`.

## Limpeza
O laboratório criou uma pasta no seu diretório pessoal e mais nada. Remova-a, com as chaves lá dentro:

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

Confirme que desapareceu:

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

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

Nada foi instalado e nenhum repositório de confiança do sistema foi alterado.

## O que aprendeu
- Um hash é uma impressão digital de tamanho fixo e repetível: um carácter alterado dá um resumo completamente diferente. Mostra integridade, mas qualquer pessoa o pode recalcular, pelo que não prova quem escreveu o ficheiro.
- A cifragem com palavra-passe do `openssl enc` esconde o conteúdo, mas o modo CBC não deteta adulteração. Prefira cifragem autenticada (AES-GCM, ChaCha20-Poly1305) através de uma biblioteca ou ferramenta adequada.
- Uma assinatura feita com uma chave privada é verificada com a chave pública e deixa de ser válida quando o ficheiro muda. Mantenha a chave privada privada (permissões `600`).
- Um certificado liga um nome (o SAN) a uma chave pública; um autoassinado não tem a confiança de ninguém, a menos que o indique, enquanto um real encadeia até uma raiz do repositório de raízes.
- O `openssl s_client` mostra o que o seu browser vê: a cadeia, as datas de validade, a versão do TLS e a cifra.
