Protegendo Dados com Criptografia: Chaves SSH, GPG, openssl

2026-05-30 Tempo de leitura: Cerca de 14 min Dificuldade: Intermediário

O Que Você Vai Alcançar

• Gerar pares de chaves RSA / ED25519 com ssh-keygen e explicar seus usos
• Registrar uma chave pública em um host remoto com ssh-copy-id e conectar via autenticação por chave pública
• Inserir a passphrase apenas uma vez usando ssh-agent / ssh-add
• Distinguir os usos do encaminhamento de porta SSH (-L / -R / -D)
• Criptografar, descriptografar, assinar e verificar arquivos com gpg
• Computar hashes e executar criptografia simétrica básica com openssl
• Explicar como as permissões de arquivos de chave (600 / 700) se relacionam com falhas de autenticação

Este é o núcleo do objetivo 110.3 do LPIC-1 "Proteger dados com criptografia". A chave para dominá-lo é separar a proteção do canal (SSH) da proteção dos dados em si (GPG / openssl).

Como Funciona a Autenticação por Chave Pública SSH?

A autenticação por chave pública prova a "posse da chave privada". A chave pública do cliente é registrada no ~/.ssh/authorized_keys do servidor, enquanto a chave privada nunca sai da sua máquina. Como nenhuma senha é enviada pela rede, é altamente seguro.

O fluxo é um desafio-resposta: o servidor criptografa um valor aleatório com a chave pública do cliente, o cliente descriptografa com a chave privada e responde, provando a posse da chave privada. A chave privada nunca trafega pela rede.

Passos para Gerar Chaves e Conectar

Passo 1: Gerar um par de chaves com ssh-keygen

ssh-keygen -t ed25519 -C "user@example.com"

Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_ed25519
Your public key has been saved in /home/user/.ssh/id_ed25519.pub

-t especifica o tipo de chave. Conforme man ssh-keygen, os valores para -t são dsa / ecdsa / ecdsa-sk / ed25519 / ed25519-sk / rsa. ED25519 é o recomendado atualmente; para RSA, especifique um comprimento de chave como -b 4096. -C é um comentário (um rótulo de identificação anexado à chave pública). A passphrase é uma proteção extra da chave privada; pode ser vazia, mas defini-la é mais seguro.

ssh-keygen -t rsa -b 4096

Você normalmente escolhe RSA somente quando precisa se conectar a um servidor mais antigo que não consegue interpretar ED25519.

Passo 2: Registrar a chave pública no host remoto

ssh-copy-id user@server.example.com

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'user@server.example.com'"
and check to make sure that only the key(s) you wanted were added.

ssh-copy-id adiciona sua chave pública ao ~/.ssh/authorized_keys remoto e ajusta as permissões. Para fazer manualmente, adicione o conteúdo da chave pública como uma linha em authorized_keys. Nunca envie a chave privada (o arquivo sem .pub).

Passo 3: Conectar com autenticação por chave pública

ssh user@server.example.com

Enter passphrase for key '/home/user/.ssh/id_ed25519':
Last login: Fri May 30 10:00:00 2026 from 203.0.113.10
user@server:~$

Se a chave pública está registrada, você faz login apenas com a passphrase da chave privada, não com uma senha. Quando algo falha, verifique o log detalhado com ssh -v user@host.

Passo 4: Armazenar a chave em cache com ssh-agent

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
ssh-add -l

Agent pid 4521
Enter passphrase for /home/user/.ssh/id_ed25519:
Identity added: /home/user/.ssh/id_ed25519 (user@example.com)
256 SHA256:abc...xyz user@example.com (ED25519)

ssh-agent é um agente de autenticação que mantém chaves privadas na memória. Uma vez que você registre uma chave com ssh-add, conexões posteriores não pedem mais a passphrase. ssh-add -l lista chaves registradas e ssh-add -D remove todas.

Passo 5: Corrigir as permissões

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

O OpenSSH se recusa a usar uma chave privada que outros possam ler. Definir ~/.ssh como 700 e a chave privada como 600 é a linha de base. Pular isso é a causa clássica de "a chave existe mas a autenticação falha".

Qual é a Diferença Entre os Três Modos de Encaminhamento de Porta?

-L é encaminhamento local (através de uma porta local para um serviço no lado remoto), -R é encaminhamento remoto (uma porta remota para um serviço na sua máquina), e -D é encaminhamento dinâmico (um proxy SOCKS). Escolha pela direção e finalidade.

ssh -L 8080:internal-db:5432 user@gateway
ssh -R 9000:localhost:3000 user@remote
ssh -D 1080 user@gateway

Conforme definido para -L / -R / -D em man ssh, isso transporta tráfego de aplicação pelo canal criptografado do SSH. Com um túnel estabelecido, mesmo um protocolo em texto plano pode ser transportado com segurança.

Como Criptografar e Assinar Dados com GPG?

GPG (GnuPG) é uma implementação do padrão OpenPGP que criptografa e assina arquivos. Enquanto o SSH protege o canal, o GPG protege dados que você armazena ou distribui. Você criptografa com uma chave pública, e somente a chave privada correspondente pode descriptografar.

Gerar um par de chaves

gpg --gen-key
gpg --list-keys

pub   ed25519 2026-05-30 [SC]
      ABCDEF0123456789ABCDEF0123456789ABCDEF01
uid           [ultimate] User Name <user@example.com>
sub   cv25519 2026-05-30 [E]

gpg --gen-key solicita nome e email interativamente e cria um par de chaves. --list-keys lista chaves públicas e --list-secret-keys lista chaves privadas.

Distribuir e importar chaves públicas

gpg --export -a user@example.com > mypubkey.asc
gpg --import friend_pubkey.asc

--export -a grava uma chave pública em formato ASCII (armored). A outra parte a importa com --import. Para criptografar para alguém, você precisa da chave pública dessa pessoa em mãos.

Criptografar e descriptografar um arquivo

gpg -e -r user@example.com secret.txt
gpg -d secret.txt.gpg > secret.txt

gpg: encrypted with cv25519 key, ID 0123456789ABCDEF, created 2026-05-30
      "User Name <user@example.com>"

Criptografar com -e (--encrypt) e -r (destinatário) produz secret.txt.gpg. Descriptografe com -d (--decrypt). Somente alguém que possua a chave privada do destinatário especificado pode descriptografar.

Assinar e verificar

gpg --sign document.txt
gpg --verify document.txt.gpg

gpg: Signature made Fri 30 May 2026 10:00:00 JST
gpg:                using EDDSA key ABCDEF0123456789ABCDEF0123456789ABCDEF01
gpg: Good signature from "User Name <user@example.com>"

--sign assina com a chave privada, garantindo o autor e detectando adulteração. --verify verifica com a chave pública do assinante. Criptografia (confidencialidade) e assinatura (autenticidade) servem a propósitos diferentes; não os confunda.

O Que Você Pode Fazer com openssl?

openssl é um toolkit que fornece funções de TLS e criptografia. Ele lida com hashing, criptografia simétrica, geração de chaves e certificados, e mais. Para o LPIC-1, foque em hashing e criptografia básicos.

openssl dgst -sha256 file.txt
openssl enc -aes-256-cbc -pbkdf2 -in file.txt -out file.enc
openssl enc -d -aes-256-cbc -pbkdf2 -in file.enc -out file.txt

SHA256(file.txt)= 9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
enter AES-256-CBC encryption password:

openssl dgst -sha256 computa um hash (uma impressão digital do arquivo). openssl enc é criptografia simétrica que usa a mesma senha para criptografar e descriptografar. Adicione -pbkdf2 para derivação de chave. A diferença do GPG é que enc é compartilhamento de senha, enquanto o GPG protege dados com criptografia de chave pública.

Erros Comuns e Correções

Erro 1: Permissões frouxas na chave privada ou ~/.ssh

Se ~/.ssh está com 777 ou a chave privada está com 644 para que outros possam lê-la, o OpenSSH ignora a chave por razões de segurança e volta para autenticação por senha ou recusa a conexão. Corrija com chmod 700 ~/.ssh e chmod 600 ~/.ssh/id_*.

Erro 2: Ignorar o aviso de mudança de chave do host no known_hosts

Reconstruir um servidor muda sua chave pública, produzindo o aviso REMOTE HOST IDENTIFICATION HAS CHANGED! ao conectar. Este é um aviso importante que também pode indicar um ataque man-in-the-middle. Após confirmar que a mudança é legítima, remova a linha correspondente do known_hosts com ssh-keygen -R hostname e reconecte.

Erro 3: Confundir chaves pública e privada no GPG

Use a chave pública do destinatário para criptografar e sua própria chave privada para descriptografar. Distribua apenas a chave pública. Confundir --export (chave pública) com --export-secret-keys (chave privada) e compartilhar a chave privada anula o propósito da criptografia.

Erro 4: Não definir ou gerenciar uma passphrase

Se a chave privada não tem passphrase, qualquer pessoa que roube o arquivo de chave pode se passar por você. Defina uma passphrase e use ssh-agent para reduzir quantas vezes você a digita. Gerencie a passphrase da chave privada GPG da mesma forma.

Erro 5: Enviar a chave privada em vez da pública para o servidor

O que você registra em authorized_keys é a chave pública terminando em .pub. Usar ssh-copy-id registra corretamente e automaticamente. Ao copiar manualmente, tenha cuidado para não enviar a chave privada (id_ed25519).

Solução de Problemas

Sintoma: Uma senha é solicitada mesmo com a chave pública registrada

Causa: Permissões excessivas na chave privada ou ~/.ssh, ou uma entrada com defeito em authorized_keys

Verificação:

ssh -v user@host
ls -ld ~/.ssh
ls -l ~/.ssh/authorized_keys

Correção: Defina chmod 700 ~/.ssh e chmod 600 ~/.ssh/authorized_keys. Na saída de ssh -v, encontre onde a chave é oferecida ou rejeitada.

Sintoma: Conexão para com um aviso de mudança de chave do host

Causa: A chave do host do servidor mudou e não corresponde mais ao registro em known_hosts

Verificação:

ssh-keygen -l -F hostname

Correção: Após confirmar que a mudança é legítima, exclua o registro antigo com ssh-keygen -R hostname e reconecte. Se você não consegue explicar a mudança, aborte a conexão e investigue.

Sintoma: gpg --decrypt não consegue descriptografar

Causa: A chave privada correspondente não está no seu chaveiro, ou você criptografou com o destinatário errado

Verificação:

gpg --list-secret-keys

Correção: Confirme que você tem sua chave privada. Sem ela, aquele texto cifrado não pode ser descriptografado. Ao criptografar, especifique o destinatário correto com -r (você mesmo, se for descriptografar).

Lista de Verificação de Conclusão

• [ ] Gerou um par de chaves com ssh-keygen -t ed25519
• [ ] Registrou a chave pública em um host remoto com ssh-copy-id
• [ ] Conectou via autenticação por chave pública
• [ ] Adicionou a chave privada ao ssh-agent com ssh-add
• [ ] Definiu ~/.ssh como 700 e a chave privada como 600
• [ ] Verificou criptografia e descriptografia de arquivo com gpg
• [ ] Computou um hash com openssl dgst

Resumo

O SSH protege o canal; GPG e openssl protegem os dados em si. Domine essa divisão de papéis e a disciplina de permissões de arquivos de chave, e o 110.3 se torna uma fonte confiável de pontos.

Próximas Leituras

• Fundamentos de Administração de Segurança
• Segurança do Host
• Fundamentos de Protocolos de Internet