# Downgrade Attacks

## 📑 **Índice**

1. [Fundamentos dos Downgrade Attacks](#-fundamentos-dos-downgrade-attacks)
2. [Tipos de Ataques de Downgrade](#-tipos-de-ataques-de-downgrade)
3. [Protocolos e Serviços Vulneráveis](#-protocolos-e-serviços-vulneráveis)
4. [Técnicas de Exploração](#-técnicas-de-exploração)
5. [Impacto e Consequências](#-impacto-e-consequências)
6. [Ferramentas de Ataque e Análise](#-ferramentas-de-ataque-e-análise)
7. [Detecção e Monitoramento](#-detecção-e-monitoramento)
8. [Mitigação e Hardening](#-mitigação-e-hardening)
9. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos dos Downgrade Attacks**

### **O que é um Ataque de Downgrade?**

Um ataque de downgrade (ou rebaixamento de versão) é uma técnica que força um sistema, serviço ou conexão a usar versões mais antigas, menos seguras, de um protocolo ou software. O objetivo é explorar vulnerabilidades conhecidas que foram corrigidas em versões mais recentes, permitindo ao atacante contornar mecanismos de segurança implementados em versões modernas.

### **Princípio Básico**

```mermaid
graph LR
    A[Cliente solicita versão segura] --> B[Atacante intercepta/modifica]
    B --> C[Servidor oferece versão antiga]
    C --> D[Conexão estabelecida com versão insegura]
    D --> E[Atacante explora vulnerabilidades]
```

### **Contexto Histórico**

```yaml
Principais ataques de downgrade:
  1995: SSL/TLS downgrade (CVE-1999-1043)
  2009: SSH downgrade (CVE-2009-2904)
  2014: POODLE (CVE-2014-3566) – TLS 1.0 downgrade
  2015: Logjam (CVE-2015-4000) – TLS downgrade para export-grade
  2016: SSH Terrapin (CVE-2023-48795) – downgrade de criptografia
  2020: TLS 1.0/1.1 deprecation e ataques de downgrade
```

***

## 🎯 **Tipos de Ataques de Downgrade**

### **1. Protocolo SSL/TLS**

#### **POODLE (Padding Oracle On Downgraded Legacy Encryption)**

```bash
# Forçar downgrade para SSL 3.0
curl -3 -v https://vulnerable-site.com

# Exploração via MITM
# Atacante modifica pacotes para forçar SSL 3.0
# Explora padding oracle para decifrar cookies
```

#### **Logjam (Downgrade para Export-Grade TLS)**

```bash
# Forçar uso de Diffie-Hellman export-grade (512 bits)
# Atacante pode calcular chave privada e decifrar tráfego
```

#### **FREAK (Factoring RSA Export Keys)**

```bash
# Forçar uso de criptografia export-grade (RSA 512 bits)
# Permite recuperação da chave privada
```

### **2. SSH (Secure Shell)**

#### **Terrapin Attack (CVE-2023-48795)**

```yaml
Impacto:
  - Downgrade da integridade do canal SSH
  - Remoção de mensagens de início de sessão
  - Quebra do Sequence Number Extension
  - Afeta SSH versões 9.5 e anteriores

Vetor:
  - Atacante em posição MITM
  - Modifica mensagens de negociação
  - Remove suporte a criptografia forte
```

#### **SSHv1 Downgrade**

```bash
# Servidor SSH aceita conexões SSHv1
ssh -1 user@target
# Vulnerabilidades conhecidas (CVE-2001-0144, etc.)
```

### **3. Criptografia e Autenticação**

| Protocolo    | Ataque                   | Efeito                     |
| ------------ | ------------------------ | -------------------------- |
| **Kerberos** | Downgrade de encriptação | Uso de RC4 em vez de AES   |
| **NTLM**     | Downgrade para NTLMv1    | Quebra de hash mais fácil  |
| **LDAP**     | TLS downgrade            | Comunicação em texto claro |
| **SMB**      | SMB1 downgrade           | Exploração de EternalBlue  |
| **RDP**      | SSL/TLS downgrade        | Interceptação de sessão    |

### **4. Gerenciadores de Pacotes**

#### **APT/APT-Get Downgrade**

```bash
# Forçar instalação de versão antiga
apt-get install package=old-version

# Se o repositório permite downgrade, atacante pode instalar pacotes vulneráveis
```

#### **Repositórios HTTP (não HTTPS)**

```bash
# MITM pode modificar pacotes durante download
# Forçar instalação de versões maliciosas
```

***

## ⚔️ **Técnicas de Exploração**

### **1. TLS Downgrade Attack**

```python
#!/usr/bin/env python3
# tls_downgrade_attack.py - Demonstração educacional

import socket
import ssl
import sys

class TLSDowngradeAttack:
    """
    Demonstração de downgrade de versão TLS
    APENAS para fins educacionais
    """
    
    def __init__(self, target_host, target_port=443):
        self.target_host = target_host
        self.target_port = target_port
    
    def connect_with_version(self, ssl_version):
        """Tentar conexão com versão específica de SSL/TLS"""
        try:
            context = ssl.SSLContext(ssl_version)
            sock = socket.create_connection((self.target_host, self.target_port))
            ssock = context.wrap_socket(sock, server_hostname=self.target_host)
            
            print(f"✅ Conexão estabelecida com: {ssock.version()}")
            return ssock
        except Exception as e:
            print(f"❌ Falha com versão específica: {e}")
            return None
    
    def test_downgrade(self):
        """Testar downgrade para versões inseguras"""
        versions = [
            (ssl.PROTOCOL_SSLv3, "SSLv3"),
            (ssl.PROTOCOL_TLSv1, "TLSv1.0"),
            (ssl.PROTOCOL_TLSv1_1, "TLSv1.1")
        ]
        
        print(f"[*] Testando downgrade em {self.target_host}:{self.target_port}")
        
        for ctx, name in versions:
            sock = self.connect_with_version(ctx)
            if sock:
                sock.close()
                print(f"[!] VULNERÁVEL: Servidor aceita {name}")

# Uso
if __name__ == "__main__":
    attack = TLSDowngradeAttack("example.com")
    attack.test_downgrade()
```

### **2. SSH Terrapin Attack (CVE-2023-48795)**

```python
#!/usr/bin/env python3
# terrapin_attack_demo.py - Simulação de downgrade SSH

import paramiko
import time

class TerrapinAttack:
    """
    Simulação do ataque Terrapin (downgrade de integridade SSH)
    """
    
    def __init__(self, target_host, target_port=22):
        self.target_host = target_host
        self.target_port = target_port
    
    def check_vulnerability(self):
        """Verificar se servidor é vulnerável"""
        try:
            transport = paramiko.Transport((self.target_host, self.target_port))
            transport.start_client()
            
            # Verificar ciphers suportados
            ciphers = transport.get_security_options().ciphers
            
            vulnerable_ciphers = [
                'aes128-cbc',
                'aes192-cbc',
                'aes256-cbc',
                '3des-cbc'
            ]
            
            weak = [c for c in vulnerable_ciphers if c in ciphers]
            
            if weak:
                print(f"[!] VULNERÁVEL: Ciphers fracos disponíveis: {weak}")
                return True
            else:
                print("[+] Seguro: Nenhum cipher fraco detectado")
                return False
                
        except Exception as e:
            print(f"Erro: {e}")
            return False
    
    def simulate_downgrade(self):
        """Simular downgrade de algoritmo"""
        print("[*] Simulando downgrade de algoritmo SSH")
        print("[*] Atacante modifica mensagens KEX para remover criptografia forte")
        
        # Em cenário real, atacante em MITM faria:
        # 1. Interceptar mensagem de negociação
        # 2. Remover algoritmos seguros da lista
        # 3. Reencaminhar versão modificada
        # 4. Forçar uso de ciphers fracos

# Uso
attack = TerrapinAttack("192.168.1.100")
attack.check_vulnerability()
```

### **3. SMB Downgrade Attack (EternalBlue)**

```bash
# Forçar downgrade para SMBv1
smbclient -L //target -m NT1

# Verificar se SMBv1 está habilitado
nmap -p 445 --script smb-protocols target

# Exploração via metasploit
msf6 > use exploit/windows/smb/ms17_010_eternalblue
```

### **4. APT Repository Downgrade**

```bash
#!/bin/bash
# apt_downgrade_attack.sh - Demonstração educacional

# 1. Verificar se repositórios usam HTTP (não HTTPS)
grep -r "deb http://" /etc/apt/sources.list*

# 2. Em MITM, atacante pode modificar pacotes
# Forçar downgrade de pacote específico
apt-cache policy package-name

# 3. Instalar versão antiga
apt-get install package-name=old-version

# 4. Adicionar repositório não oficial com versões antigas
echo "deb http://old-repo.com/ubuntu focal main" >> /etc/apt/sources.list
```

***

## 💥 **Impacto e Consequências**

### **Cadeia de Ataque**

```mermaid
graph TD
    A[Downgrade Attack] --> B[Versão insegura ativada]
    B --> C[Exploração de vulnerabilidades]
    C --> D[Comprometimento]
    
    D --> E[Decifragem de tráfego]
    D --> F[Injeção de dados]
    D --> G[Escalonamento]
    
    E --> H[Exfiltração de credenciais]
    F --> I[Man-in-the-Middle persistente]
    G --> J[Controle total do sistema]
```

### **Impactos por Protocolo**

| Protocolo    | Ataque           | Impacto                       | Gravidade |
| ------------ | ---------------- | ----------------------------- | --------- |
| **TLS**      | POODLE           | Decifragem de cookies/sessões | Alta      |
| **TLS**      | Logjam           | Decifragem de chaves DH       | Crítica   |
| **SSH**      | Terrapin         | Bypass de integridade         | Alta      |
| **SMB**      | SMBv1 downgrade  | RCE (EternalBlue)             | Crítica   |
| **Kerberos** | RC4 downgrade    | Quebra de hash de senha       | Média     |
| **NTLM**     | NTLMv1 downgrade | Pass-the-hash                 | Alta      |

***

## 🛠️ **Ferramentas de Ataque e Análise**

### **1. testssl.sh – Análise de TLS**

```bash
# Testar vulnerabilidades de downgrade TLS
testssl.sh --vulnerable https://target.com

# Testar POODLE
testssl.sh --poodle https://target.com

# Testar Logjam
testssl.sh --logjam https://target.com

# Testar versões de protocolo
testssl.sh --protocols https://target.com
```

### **2. sslyze – Scanner SSL/TLS**

```bash
# Instalar
pip install sslyze

# Escanear
sslyze --regular target.com:443

# Verificar versões suportadas
sslyze --protocols target.com
```

### **3. ssh-audit – Análise SSH**

```bash
# Instalar
git clone https://github.com/jtesta/ssh-audit.git

# Escanear
ssh-audit target.com

# Verificar ciphers fracos
ssh-audit target.com | grep -E "(CBC|MD5|3DES)"
```

### **4. Metasploit Modules**

```bash
# SSL/TLS downgrade
msf6 > use auxiliary/scanner/ssl/ssl_version
msf6 > use auxiliary/scanner/ssl/ssl_vuln_poodle

# SMB downgrade
msf6 > use exploit/windows/smb/ms17_010_eternalblue
```

### **5. Scanner Personalizado para SSH Ciphers**

```python
#!/usr/bin/env python3
# ssh_downgrade_scanner.py

import paramiko
import socket
import sys

class SSHDowngradeScanner:
    def __init__(self, host, port=22):
        self.host = host
        self.port = port
    
    def scan_ciphers(self):
        """Listar ciphers suportados e identificar fracos"""
        weak_ciphers = []
        strong_ciphers = []
        
        try:
            transport = paramiko.Transport((self.host, self.port))
            transport.start_client()
            
            ciphers = transport.get_security_options().ciphers
            
            weak_list = [
                'aes128-cbc', 'aes192-cbc', 'aes256-cbc',
                '3des-cbc', 'blowfish-cbc', 'cast128-cbc',
                'arcfour', 'arcfour128', 'arcfour256'
            ]
            
            for cipher in ciphers:
                if cipher in weak_list:
                    weak_ciphers.append(cipher)
                else:
                    strong_ciphers.append(cipher)
            
            transport.close()
            
        except Exception as e:
            print(f"Erro: {e}")
        
        return weak_ciphers, strong_ciphers
    
    def scan_macs(self):
        """Listar MACs suportados e identificar fracos"""
        weak_macs = []
        strong_macs = []
        
        try:
            transport = paramiko.Transport((self.host, self.port))
            transport.start_client()
            
            macs = transport.get_security_options().digests
            
            weak_list = [
                'hmac-md5', 'hmac-md5-96', 'hmac-ripemd160',
                'hmac-sha1', 'hmac-sha1-96'
            ]
            
            for mac in macs:
                if mac in weak_list:
                    weak_macs.append(mac)
                else:
                    strong_macs.append(mac)
            
            transport.close()
            
        except Exception as e:
            print(f"Erro: {e}")
        
        return weak_macs, strong_macs
    
    def check_kex(self):
        """Verificar algoritmos KEX fracos"""
        weak_kex = []
        
        try:
            transport = paramiko.Transport((self.host, self.port))
            transport.start_client()
            
            kex = transport.get_security_options().kex
            
            weak_list = [
                'diffie-hellman-group1-sha1',
                'diffie-hellman-group-exchange-sha1'
            ]
            
            for algo in kex:
                if algo in weak_list:
                    weak_kex.append(algo)
            
            transport.close()
            
        except Exception as e:
            print(f"Erro: {e}")
        
        return weak_kex
    
    def scan(self):
        """Executar scan completo"""
        print(f"[*] Escaneando {self.host}:{self.port}")
        
        weak_ciphers, strong_ciphers = self.scan_ciphers()
        weak_macs, strong_macs = self.scan_macs()
        weak_kex = self.check_kex()
        
        print("\n=== Ciphers ===")
        if weak_ciphers:
            print(f"[!] Ciphers fracos: {weak_ciphers}")
        else:
            print("[+] Nenhum cipher fraco")
        
        print("\n=== MACs ===")
        if weak_macs:
            print(f"[!] MACs fracos: {weak_macs}")
        else:
            print("[+] Nenhum MAC fraco")
        
        print("\n=== KEX ===")
        if weak_kex:
            print(f"[!] KEX fracos: {weak_kex}")
        else:
            print("[+] Nenhum KEX fraco")
        
        if weak_ciphers or weak_macs or weak_kex:
            print("\n[!] SERVIDOR VULNERÁVEL A DOWNGRADE ATTACKS")
            return True
        else:
            print("\n[+] Servidor seguro")
            return False

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: python ssh_downgrade_scanner.py <host> [port]")
        sys.exit(1)
    
    port = int(sys.argv[2]) if len(sys.argv) > 2 else 22
    scanner = SSHDowngradeScanner(sys.argv[1], port)
    scanner.scan()
```

***

## 🔍 **Detecção e Monitoramento**

### **Logs de Sistema**

```bash
# Verificar logs SSH para conexões com versões antigas
grep "protocol 1" /var/log/auth.log
grep "cipher.*cbc" /var/log/auth.log
grep "MAC.*md5" /var/log/auth.log

# Verificar logs de TLS
grep "SSLv3" /var/log/apache2/error.log
grep "TLSv1.0" /var/log/nginx/access.log
```

### **Auditoria com Auditd**

```bash
# Monitorar conexões TLS com versões antigas
auditctl -w /etc/ssl -p r -k tls_config

# Monitorar alterações em configurações SSH
auditctl -w /etc/ssh/sshd_config -p wa -k ssh_config

# Verificar logs
ausearch -k ssh_config
```

### **Snort/Suricata Rules**

```snort
# Detectar downgrade de TLS
alert tcp any any -> any 443 (msg:"TLS Version Downgrade"; 
    flow:to_server,established; 
    content:"|16 03 00|"; depth:3; 
    content:"|01 00|"; within:2; 
    sid:1000001;)

# Detectar SSH com ciphers fracos
alert tcp any any -> any 22 (msg:"SSH Weak Cipher Negotiation"; 
    content:"aes128-cbc"; 
    sid:1000002;)
```

### **Indicadores de Comprometimento (IOCs)**

```yaml
IOCs para downgrade attacks:
  - Uso de protocolos antigos (SSLv3, TLSv1.0, SSHv1)
  - Ciphers CBC no SSH (aes128-cbc, etc.)
  - MACs MD5 ou SHA1
  - Conexões com algoritmos export-grade (512 bits)
  - Múltiplas tentativas de negociação em sequência
```

***

## 🛡️ **Mitigação e Hardening**

### **1. TLS/SSL Hardening**

```nginx
# nginx - Configuração segura
server {
    listen 443 ssl;
    
    # Desabilitar versões antigas
    ssl_protocols TLSv1.2 TLSv1.3;
    
    # Ciphers fortes
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;
    
    # HSTS
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
}
```

```apache
# Apache - Configuração segura
SSLProtocol -all +TLSv1.2 +TLSv1.3
SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256
SSLHonorCipherOrder off
Header always set Strict-Transport-Security "max-age=31536000; includeSubDomains"
```

### **2. SSH Hardening**

```bash
# /etc/ssh/sshd_config
Protocol 2

# Desabilitar ciphers fracos
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com

# Desabilitar MACs fracos
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

# Desabilitar KEX fracos
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org

# Desabilitar SSHv1
Protocol 2

# Limitar versões
HostKeyAlgorithms ssh-ed25519,rsa-sha2-512,rsa-sha2-256
```

### **3. SMB Hardening**

```bash
# Desabilitar SMBv1
echo "[global]" >> /etc/samba/smb.conf
echo "server min protocol = SMB2" >> /etc/samba/smb.conf

# No Windows (PowerShell)
Set-SmbServerConfiguration -EnableSMB1Protocol $false
```

### **4. Gerenciadores de Pacotes**

```bash
# APT - Forçar HTTPS
echo 'Acquire::https::Verify-Peer "true";' >> /etc/apt/apt.conf
echo 'Acquire::https::Verify-Host "true";' >> /etc/apt/apt.conf

# Usar apenas repositórios HTTPS
sed -i 's/http:/https:/g' /etc/apt/sources.list
```

### **5. Script de Hardening Automático**

```bash
#!/bin/bash
# hardening_downgrade.sh

echo "[*] Aplicando hardening contra downgrade attacks"

# 1. TLS/SSL
echo "Configurando TLS..."
cat > /etc/nginx/conf.d/tls.conf << EOF
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
ssl_prefer_server_ciphers off;
EOF

# 2. SSH
echo "Configurando SSH..."
cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
cat >> /etc/ssh/sshd_config << EOF

# Hardening against downgrade attacks
Protocol 2
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org
EOF

systemctl restart sshd

# 3. APT
echo "Configurando APT..."
echo 'Acquire::https::Verify-Peer "true";' >> /etc/apt/apt.conf
echo 'Acquire::https::Verify-Host "true";' >> /etc/apt/apt.conf

echo "[+] Hardening concluído"
```

***

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

### **Checklist de Prevenção**

* [ ] **TLS/SSL**
  * [ ] Desabilitar SSLv2, SSLv3, TLSv1.0, TLSv1.1
  * [ ] Usar apenas TLSv1.2 e TLSv1.3
  * [ ] Desabilitar ciphers export-grade
  * [ ] Desabilitar ciphers CBC (preferir GCM)
  * [ ] Habilitar HSTS
* [ ] **SSH**
  * [ ] Desabilitar SSHv1
  * [ ] Desabilitar ciphers CBC
  * [ ] Desabilitar MACs MD5 e SHA1
  * [ ] Desabilitar KEX diffie-hellman-group1-sha1
  * [ ] Usar apenas algoritmos fortes (ed25519, curve25519)
* [ ] **SMB**
  * [ ] Desabilitar SMBv1
  * [ ] Usar SMBv3 com criptografia
* [ ] **Repositórios**
  * [ ] Usar apenas HTTPS
  * [ ] Verificar assinaturas de pacotes
  * [ ] Bloquear downgrade de pacotes

### **Checklist de Auditoria**

* [ ] **Reconhecimento**
  * [ ] Testar versões de TLS aceitas
  * [ ] Listar ciphers SSH suportados
  * [ ] Verificar presença de SMBv1
* [ ] **Exploração**
  * [ ] Testar downgrade para SSLv3 (POODLE)
  * [ ] Testar downgrade para export-grade (Logjam)
  * [ ] Testar downgrade de ciphers SSH
* [ ] **Validação**
  * [ ] Verificar se HSTS está habilitado
  * [ ] Confirmar bloqueio de protocolos antigos
  * [ ] Validar configurações de hardening

***

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

### **Resumo Técnico**

```yaml
Downgrade Attacks são ameaças persistentes:
  ✅ Permitem bypass de segurança implementada em versões modernas
  ✅ Exploram compatibilidade retroativa
  ✅ Podem ser realizados em posição MITM

Defesas essenciais:
  ❌ Desabilitar protocolos e algoritmos antigos
  ✓ Usar apenas versões modernas (TLSv1.3, SSHv2, SMBv3)
  ✓ Implementar HSTS para HTTPS
  ✓ Forçar criptografia forte em todos os serviços
```

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

1. **Para Administradores**
   * Desative protocolos antigos em todos os serviços
   * Mantenha sistemas atualizados
   * Utilize ferramentas de scanning regularmente
   * Implemente HSTS e outros cabeçalhos de segurança
2. **Para Pentesters**
   * Teste todas as versões de protocolo
   * Verifique ciphers e algoritmos suportados
   * Explore downgrade como vetor inicial
   * Documente configurações inseguras
3. **Para Arquitetos**
   * Projete com "secure by default"
   * Implemente defesa em profundidade
   * Considere uso de certificados e assinaturas
   * Planeje migração de sistemas legados

**🔐 Lembre-se**: A compatibilidade retroativa é inimiga da segurança. Cada versão antiga mantida ativa é uma porta de entrada para ataques. O caminho seguro é eliminar gradualmente suporte a protocolos e algoritmos obsoletos.


---

# 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/sistemas-operacionais/linux/downgrade-attacks.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.