A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.
## 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
<figure class="diagram" style="--dg-w: 1020px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1020 330" width="1020" height="330" role="img" aria-labelledby="crypto-lab-architecture-pt-title crypto-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="crypto-lab-architecture-pt-title">Cenário do laboratório: cinco exercícios com openssl em ~/crypto-lab</title>
<desc id="crypto-lab-architecture-pt-desc">À 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 como faria um browser, com openssl s_client.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1019" height="329" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="640" height="290" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">O seu computador: ~/crypto-lab</text></g>
<rect class="dg-card" x="40" y="62" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(56 78) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><line x1="4" x2="20" y1="9" y2="9"/><line x1="4" x2="20" y1="15" y2="15"/><line x1="10" x2="8" y1="3" y2="21"/><line x1="16" x2="14" y1="3" y2="21"/></g></g>
<g class="dg-l2"><text x="98" y="99" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Passo 2: hash</text></g>
<text x="58" y="130" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">message.txt</text>
<text x="58" y="150" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">sha256sum, openssl dgst</text>
<rect class="dg-card" x="346" y="62" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(362 78) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g></g>
<g class="dg-l2"><text x="404" y="99" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Passos 3-4: cifrar</text></g>
<text x="364" y="130" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">message.enc</text>
<text x="364" y="150" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">openssl enc, AES-256-CBC</text>
<rect class="dg-card" x="40" y="182" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(56 198) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20h9"/><path d="M16.376 3.622a1 1 0 0 1 3.002 3.002L7.368 18.635a2 2 0 0 1-.855.506l-2.872.838a.5.5 0 0 1-.62-.62l.838-2.872a2 2 0 0 1 .506-.854z"/></g></g>
<g class="dg-l2"><text x="98" y="219" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Passo 5: assinar</text></g>
<text x="58" y="250" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">private.pem public.pem</text>
<text x="58" y="270" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">message.sig (Ed25519)</text>
<rect class="dg-card" x="346" y="182" width="288" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(362 198) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g></g>
<g class="dg-l2"><text x="404" y="219" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">Passo 6: certificado</text></g>
<text x="364" y="250" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">server.crt server.key</text>
<text x="364" y="270" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">openssl req, openssl x509</text>
<g class="dg-l1"><rect class="dg-tint" x="720" y="20" width="280" height="290" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(736 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="762" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet (só leitura)</text></g>
<rect class="dg-card" x="736" y="100" width="248" height="106" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(752 116) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g></g>
<g class="dg-l1"><text x="794" y="137" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">Passo 7: cadeia real</text></g>
<text x="754" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">example.com:443</text>
<text x="754" y="188" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">como faria um browser</text>
<g class="dg-l1"><path class="dg-stroke" d="M662 153H718" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M713 147l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="836" y="232" font-size="12" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">openssl s_client</text>
</svg></figure>
*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.