# 3DES (Triple DES)

### **📋 Índice**

1. Fundamentos do 3DES
2. Arquitetura e Modos de Operação
3. Implementação Prática
4. Keying Options
5. Ataques e Vulnerabilidades
6. Sweet32 Attack
7. Meet-in-the-Middle Attack
8. 3DES vs AES
9. Cenários de Uso e Legado
10. Migração e Sunset
11. Checklists de Segurança

***

### 🔍 **Fundamentos do 3DES**

#### **O que é 3DES?**

**Triple DES (3DES ou TDEA - Triple Data Encryption Algorithm)** é um algoritmo de cifragem simétrica que aplica o DES três vezes a cada bloco de dados. Foi desenvolvido como uma solução para as vulnerabilidades do DES original, estendendo o tamanho efetivo da chave.

#### **Por que 3DES?**

```yaml
Motivação para o 3DES:
  ❌ DES original (56 bits): quebrado por brute force (1999)
  ✅ 3DES: extensão simples e compatível
  ✅ Backward compatibility com DES
  ✅ Aumento do espaço de chaves

Problemas do DES:
  - Chave muito curta (56 bits)
  - Vulnerável a brute force
  - Bloco pequeno (64 bits)
  - SWEET32 attack (birthday)

Limitações do 3DES:
  - Ainda usa blocos de 64 bits
  - Performance 3x mais lenta que DES
  - Vulnerável a meet-in-the-middle
```

#### **Histórico**

```mermaid
timeline
    title Evolução do 3DES
    1977 : DES adotado<br>como padrão
    1998 : Deep Crack quebra<br>DES em 56 horas
    1999 : DES quebrado<br>em 22 horas
    1999 : 3DES proposto<br>como solução temporária
    2000 : AES selecionado<br>substitui DES/3DES
    2016 : Sweet32 attack<br>quebra segurança do 3DES
    2023 : NIST deprecia<br>3DES completamente
```

***

### 🏗️ **Arquitetura e Modos de Operação**

#### **Modo EDE (Encrypt-Decrypt-Encrypt)**

```python
#!/usr/bin/env python3
# triple_des_modes.py - Modos de operação do 3DES

class TripleDESModes:
    """Implementação dos modos de operação do 3DES"""
    
    @staticmethod
    def ede_mode():
        """Modo EDE (Encrypt-Decrypt-Encrypt) - Padrão"""
        print("🔐 Modo EDE (Encrypt-Decrypt-Encrypt)")
        print("=" * 60)
        
        print("""
Operação:
  Ciphertext = E_K3(D_K2(E_K1(Plaintext)))
  Plaintext = D_K1(E_K2(D_K3(Ciphertext)))

Vantagens:
  ✅ Usa 3 chaves diferentes
  ✅ Backward compatibility com DES (se K1=K2)
  ✅ Segurança máxima

Padrão:
  - ANSI X9.52
  - ISO/IEC 18033-3
""")
    
    @staticmethod
    def eee_mode():
        """Modo EEE (Encrypt-Encrypt-Encrypt)"""
        print("\n🔐 Modo EEE (Encrypt-Encrypt-Encrypt)")
        print("=" * 60)
        
        print("""
Operação:
  Ciphertext = E_K3(E_K2(E_K1(Plaintext)))
  Plaintext = D_K1(D_K2(D_K3(Ciphertext)))

Vantagens:
  ✅ Simples de implementar
  ✅ Mesma chave pode ser usada

Desvantagens:
  ❌ Não compatível com DES
  ❌ Menos comum
""")
    
    @staticmethod
    def comparison():
        """Comparação entre modos"""
        print("\n📊 Comparação de Modos")
        print("=" * 60)
        
        modes = {
            "DES": {
                "chaves": 1,
                "tamanho_chave": 56,
                "segurança": 56,
                "performance": "Alta",
                "status": "❌ Quebrado"
            },
            "2TDEA": {
                "chaves": 2,
                "tamanho_chave": 112,
                "segurança": 80,
                "performance": "Média",
                "status": "⚠️ Depreciado"
            },
            "3TDEA (EDE)": {
                "chaves": 3,
                "tamanho_chave": 168,
                "segurança": 112,
                "performance": "Baixa",
                "status": "⚠️ Sunset 2023"
            }
        }
        
        print(f"{'Modo':12} {'Chaves':8} {'Tamanho':10} {'Segurança':10} {'Performance':12} {'Status'}")
        print("-" * 70)
        
        for mode, info in modes.items():
            print(f"{mode:12} {info['chaves']:<8} {info['tamanho_chave']:<10} "
                  f"{info['segurança']:<10} {info['performance']:<12} {info['status']}")

# Executar
TripleDESModes.ede_mode()
TripleDESModes.eee_mode()
TripleDESModes.comparison()
```

#### **Fluxo de Criptografia 3DES**

```mermaid
graph TD
    subgraph "Criptografia 3DES (EDE)"
        A[Plaintext 64 bits] --> B[E_K1]
        B --> C[D_K2]
        C --> D[E_K3]
        D --> E[Ciphertext 64 bits]
    end
    
    subgraph "Decriptografia 3DES (EDE)"
        F[Ciphertext 64 bits] --> G[D_K3]
        G --> H[E_K2]
        H --> I[D_K1]
        I --> J[Plaintext 64 bits]
    end
    
    subgraph "Backward Compatibility"
        K[Se K1 = K2] --> L[E_K1(D_K1(E_K3)) = E_K3]
        M[Compatível com DES simples]
    end
    
    style B fill:#99ccff
    style C fill:#ffcc99
    style D fill:#99ccff
```

***

### 💻 **Implementação Prática**

#### **3DES Completo em Python**

```python
#!/usr/bin/env python3
# triple_des_impl.py - Implementação completa do 3DES

import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding

class TripleDES:
    """Implementação completa do 3DES com CBC mode"""
    
    def __init__(self, key1, key2, key3):
        """
        Inicializa 3DES com 3 chaves de 64 bits (56 efetivos)
        Cada chave: 64 bits (8 bytes)
        """
        self.key1 = key1
        self.key2 = key2
        self.key3 = key3
        
        # Verificar tamanho das chaves
        for i, key in enumerate([key1, key2, key3]):
            if len(key) != 8:
                raise ValueError(f"Chave {i+1} deve ter 8 bytes")
    
    @staticmethod
    def des_encrypt(block, key):
        """DES single (simplificado - usar biblioteca real)"""
        # Em produção, usar pycryptodome ou cryptography
        from Crypto.Cipher import DES
        cipher = DES.new(key, DES.MODE_ECB)
        return cipher.encrypt(block)
    
    @staticmethod
    def des_decrypt(block, key):
        """DES single (simplificado)"""
        from Crypto.Cipher import DES
        cipher = DES.new(key, DES.MODE_ECB)
        return cipher.decrypt(block)
    
    def encrypt_block(self, plaintext_64):
        """Cifrar um bloco de 64 bits (8 bytes)"""
        # EDE: E_K1(D_K2(E_K3(plaintext)))
        step1 = self.des_encrypt(plaintext_64, self.key1)
        step2 = self.des_decrypt(step1, self.key2)
        step3 = self.des_encrypt(step2, self.key3)
        return step3
    
    def decrypt_block(self, ciphertext_64):
        """Decifrar um bloco de 64 bits (8 bytes)"""
        # DED: D_K3(E_K2(D_K1(ciphertext)))
        step1 = self.des_decrypt(ciphertext_64, self.key3)
        step2 = self.des_encrypt(step1, self.key2)
        step3 = self.des_decrypt(step2, self.key1)
        return step3
    
    def encrypt_cbc(self, plaintext, iv=None):
        """CBC mode com padding PKCS#7"""
        if iv is None:
            iv = os.urandom(8)
        
        # Padding
        padder = padding.PKCS7(64).padder()
        padded_data = padder.update(plaintext) + padder.finalize()
        
        ciphertext = b''
        prev_block = iv
        
        for i in range(0, len(padded_data), 8):
            block = padded_data[i:i+8]
            # XOR com bloco anterior
            xored = bytes(a ^ b for a, b in zip(block, prev_block))
            # Cifrar
            encrypted = self.encrypt_block(xored)
            ciphertext += encrypted
            prev_block = encrypted
        
        return iv + ciphertext
    
    def decrypt_cbc(self, ciphertext):
        """Decifrar CBC mode"""
        iv = ciphertext[:8]
        encrypted_data = ciphertext[8:]
        
        plaintext = b''
        prev_block = iv
        
        for i in range(0, len(encrypted_data), 8):
            block = encrypted_data[i:i+8]
            # Decifrar
            decrypted = self.decrypt_block(block)
            # XOR com bloco anterior
            xored = bytes(a ^ b for a, b in zip(decrypted, prev_block))
            plaintext += xored
            prev_block = block
        
        # Remover padding
        unpadder = padding.PKCS7(64).unpadder()
        try:
            result = unpadder.update(plaintext) + unpadder.finalize()
            return result
        except:
            raise ValueError("Invalid padding - possible corruption")

# Demonstração
key1 = os.urandom(8)
key2 = os.urandom(8)
key3 = os.urandom(8)

plaintext = b"Secret message for 3DES encryption test!"

tdes = TripleDES(key1, key2, key3)
iv = os.urandom(8)

ciphertext = tdes.encrypt_cbc(plaintext, iv)
decrypted = tdes.decrypt_cbc(ciphertext)

print("3DES Implementation")
print("=" * 60)
print(f"Key1: {key1.hex()}")
print(f"Key2: {key2.hex()}")
print(f"Key3: {key3.hex()}")
print(f"IV: {iv.hex()}")
print(f"Plaintext: {plaintext}")
print(f"Ciphertext: {ciphertext.hex()[:32]}...")
print(f"Decrypted: {decrypted}")
print(f"Success: {plaintext == decrypted}")
```

#### **3DES com Cryptography Library**

```python
#!/usr/bin/env python3
# triple_des_library.py - 3DES usando cryptography library

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

class TripleDESLibrary:
    """3DES usando biblioteca cryptography"""
    
    def __init__(self, key_3des):
        """
        key_3des: 16 bytes (2TDEA) ou 24 bytes (3TDEA)
        """
        self.key = key_3des
        self.backend = default_backend()
        
        if len(key_3des) not in [16, 24]:
            raise ValueError("Key must be 16 or 24 bytes")
    
    def encrypt_cbc(self, plaintext, iv=None):
        """CBC mode encryption"""
        if iv is None:
            iv = os.urandom(8)
        
        cipher = Cipher(
            algorithms.TripleDES(self.key),
            modes.CBC(iv),
            backend=self.backend
        )
        encryptor = cipher.encryptor()
        
        # Padding PKCS#7
        pad_len = 8 - (len(plaintext) % 8)
        padded = plaintext + bytes([pad_len]) * pad_len
        
        ciphertext = encryptor.update(padded) + encryptor.finalize()
        return iv + ciphertext
    
    def decrypt_cbc(self, ciphertext):
        """CBC mode decryption"""
        iv = ciphertext[:8]
        encrypted = ciphertext[8:]
        
        cipher = Cipher(
            algorithms.TripleDES(self.key),
            modes.CBC(iv),
            backend=self.backend
        )
        decryptor = cipher.decryptor()
        
        decrypted = decryptor.update(encrypted) + decryptor.finalize()
        
        # Remover padding
        pad_len = decrypted[-1]
        if pad_len < 1 or pad_len > 8:
            raise ValueError("Invalid padding")
        
        return decrypted[:-pad_len]

# Demonstração
key = os.urandom(24)  # 3TDEA - 192 bits (168 efetivos)
tdes = TripleDESLibrary(key)

plaintext = b"Confidential data for 3DES"
ciphertext = tdes.encrypt_cbc(plaintext)
decrypted = tdes.decrypt_cbc(ciphertext)

print("3DES with Cryptography Library")
print("=" * 60)
print(f"Key size: {len(key)*8} bits")
print(f"Plaintext: {plaintext}")
print(f"Ciphertext: {ciphertext.hex()[:32]}...")
print(f"Decrypted: {decrypted}")
```

***

### 🔑 **Keying Options**

#### **Opções de Chave no 3DES**

```python
#!/usr/bin/env python3
# triple_des_keying.py - Opções de chave no 3DES

class TripleDESKeying:
    """Análise das opções de chave no 3DES"""
    
    @staticmethod
    def keying_options():
        """Opções de chave (Keying Options)"""
        print("Opções de Chave no 3DES")
        print("=" * 60)
        
        options = {
            "Option 1 (3TDEA)": {
                "chaves": "K1, K2, K3 (todas diferentes)",
                "tamanho": "168 bits (192 com paridade)",
                "segurança": "112 bits efetivos",
                "status": "✅ Recomendado",
                "uso": "Alta segurança"
            },
            "Option 2 (2TDEA)": {
                "chaves": "K1, K2, K1 (K1 = K3)",
                "tamanho": "112 bits (128 com paridade)",
                "segurança": "80 bits efetivos",
                "status": "⚠️ Depreciado",
                "uso": "Legado"
            },
            "Option 3 (DES)": {
                "chaves": "K1, K2, K3 (K1 = K2 = K3)",
                "tamanho": "56 bits (64 com paridade)",
                "segurança": "56 bits",
                "status": "❌ Quebrado",
                "uso": "Nenhum"
            }
        }
        
        for option, info in options.items():
            print(f"\n{option}:")
            for key, value in info.items():
                print(f"  {key}: {value}")
    
    @staticmethod
    def key_derivation():
        """Derivação de chaves"""
        print("\n" + "=" * 60)
        print("Derivação de Chaves 3DES")
        
        print("""
A partir de uma chave mestra, podemos derivar:

  1. 3TDEA (168 bits):
     Master Key (168 bits)
        ├── K1 (56 bits)
        ├── K2 (56 bits)
        └── K3 (56 bits)

  2. 2TDEA (112 bits):
     Master Key (112 bits)
        ├── K1 (56 bits)
        └── K2 (56 bits)
     K3 = K1

  3. DES (56 bits):
     Master Key (56 bits)
     K1 = K2 = K3
""")
    
    @staticmethod
    def key_parity():
        """Bits de paridade"""
        print("\n" + "=" * 60)
        print("Bits de Paridade no 3DES")
        
        print("""
Cada byte da chave inclui 1 bit de paridade:
  • 8 bits por byte
  • 1 bit de paridade (LSB)
  • 7 bits efetivos por byte

Tamanhos efetivos:
  • DES: 56 bits (8 bytes × 7 bits)
  • 2TDEA: 112 bits (16 bytes × 7 bits)
  • 3TDEA: 168 bits (24 bytes × 7 bits)

Verificação de paridade:
  Cada byte deve ter paridade ímpar (número de 1s)
""")

# Executar
TripleDESKeying.keying_options()
TripleDESKeying.key_derivation()
TripleDESKeying.key_parity()
```

***

### ⚔️ **Ataques e Vulnerabilidades**

#### **Meet-in-the-Middle Attack**

```python
#!/usr/bin/env python3
# mitm_3des.py - Ataque Meet-in-the-Middle ao 3DES

class MeetInTheMiddle:
    """Simulação do ataque Meet-in-the-Middle ao 2TDEA"""
    
    @staticmethod
    def complexity():
        """Complexidade do ataque"""
        print("Ataque Meet-in-the-Middle ao 2TDEA")
        print("=" * 60)
        
        print("""
2TDEA: C = E_K1(D_K2(E_K1(P)))

Ataque Meet-in-the-Middle:
  1. Escolher par (P, C) conhecido
  2. Calcular X = E_K1(P) para todos K1 (2^56)
  3. Armazenar (X, K1) em tabela hash
  4. Calcular Y = D_K2(E_K1(C)) ? (formulação)
  5. Procurar correspondência

Complexidade:
  • Tempo: 2^56 + 2^56 = 2^57 operações
  • Memória: 2^56 entradas (~2^60 bytes)
  • Mais eficiente que brute force (2^112)

Resultado:
  ✅ 2TDEA tem segurança de apenas 57 bits
  ❌ Não afeta 3TDEA (3 chaves diferentes)
""")
    
    @staticmethod
    def mitigation():
        """Mitigações"""
        print("\n" + "=" * 60)
        print("Mitigações")
        
        print("""
Para prevenir Meet-in-the-Middle:

  ✅ Usar 3TDEA (3 chaves diferentes)
  ✅ Usar AES em vez de 3DES
  ✅ Aumentar tamanho do bloco (AES: 128 bits)
  ✅ Usar modos autenticados (GCM)

2TDEA deve ser considerado inseguro para:
  ❌ Dados sensíveis
  ❌ Longa duração
  ❌ Altos volumes
""")

# Executar
MeetInTheMiddle.complexity()
MeetInTheMiddle.mitigation()
```

#### **Sweet32 Attack (Birthday)**

```python
#!/usr/bin/env python3
# sweet32_attack.py - Ataque Sweet32 ao 3DES

class Sweet32Attack:
    """Explicação do ataque Sweet32 (CVE-2016-2183)"""
    
    @staticmethod
    def explanation():
        """Explicação do Sweet32"""
        print("Sweet32 Attack (CVE-2016-2183)")
        print("=" * 60)
        
        print("""
Sweet32 ataca cifras de bloco de 64 bits (DES, 3DES, Blowfish)

Princípio:
  1. Birthday paradox: após ~2^32 blocos (32 GB)
  2. Colisão no ciphertext
  3. Recuperação de informação sensível

Impacto:
  • TLS/SSL usando 3DES
  • VPNs usando 3DES
  • Protocolos legacy

Probabilidade:
  • Após 2^32 blocos (~32 GB) → 50% de colisão
  • Em redes de alta velocidade, alcançável em horas

Descoberta: 2016 (Bhargavan, Leurent)
""")
    
    @staticmethod
    def birthday_bound():
        """Cálculo do birthday bound"""
        print("\n" + "=" * 60)
        print("Birthday Bound para 64-bit block")
        
        import math
        
        block_size = 64  # bits
        n_blocks = 2 ** (block_size / 2)  # 2^32 ≈ 4.3e9
        
        # Probabilidade de colisão após N blocos
        def collision_probability(blocks):
            n = blocks
            N = 2**32
            # Aproximação: 1 - e^(-n^2/(2N))
            prob = 1 - math.exp(- (n * n) / (2 * N))
            return prob
        
        print(f"\nTamanho do bloco: {block_size} bits")
        print(f"Birthday bound: 2^{block_size/2:.0f} = {n_blocks:.2e} blocos")
        
        # Volumes de dados
        volumes = [
            (2**30, "1 GB"),
            (2**31, "2 GB"),
            (2**32, "4 GB"),
            (2**33, "8 GB"),
            (2**34, "16 GB")
        ]
        
        print("\nProbabilidade de colisão por volume:")
        for blocks, name in volumes:
            prob = collision_probability(blocks)
            print(f"  {name:8}: {prob:.2%}")
    
    @staticmethod
    def mitigation():
        """Mitigações"""
        print("\n" + "=" * 60)
        print("Mitigações contra Sweet32")
        
        print("""
Recomendações NIST (2023):

  ✅ DESABILITAR 3DES em TLS
  ✅ REMOVER cipher suites com 3DES
  ✅ MIGRAR para AES-128/256-GCM
  ✅ LIMITAR volume de dados (se inevitável)

Configuração TLS:
  TLS 1.2: Desabilitar TLS_RSA_WITH_3DES_EDE_CBC_SHA
  TLS 1.3: Não suporta 3DES

Checklist:
  [ ] Verificar cipher suites no servidor
  [ ] Testar com sslyze/openssl
  [ ] Remover 3DES de configurações
  [ ] Atualizar aplicações legadas
""")

# Executar
Sweet32Attack.explanation()
Sweet32Attack.birthday_bound()
Sweet32Attack.mitigation()
```

#### **Ataques de Performance**

```python
#!/usr/bin/env python3
# 3des_performance_attacks.py - Ataques de performance

class PerformanceAttacks:
    """Ataques relacionados à performance do 3DES"""
    
    @staticmethod
    def comparison():
        """Comparação de performance"""
        print("Performance Comparativa (Blocos de 1KB)")
        print("=" * 60)
        
        performances = {
            "AES-NI (hardware)": "3,000 MB/s",
            "AES (software)": "300 MB/s",
            "DES": "50 MB/s",
            "3DES": "15 MB/s",
            "3DES (software puro)": "5 MB/s"
        }
        
        for algo, speed in performances.items():
            print(f"  {algo:25}: {speed}")
        
        print("\nImpacto:")
        print("  • 3DES é 20x mais lento que AES-NI")
        print("  • Maior consumo de CPU")
        print("  • Vulnerável a timing attacks")
        print("  • Limitado em dispositivos embarcados")
    
    @staticmethod
    def timing_attack():
        """Ataques de tempo"""
        print("\n" + "=" * 60)
        print("Timing Attacks no 3DES")
        
        print("""
Implementações vulneráveis de 3DES podem sofrer:

  1. Cache timing (S-Box lookups)
  2. Branch prediction timing
  3. Bit slicing timing

Mitigações:
  ✅ Usar implementações constant-time
  ✅ AES-NI (hardware) não tem timing variations
  ✅ Bibliotecas auditadas (OpenSSL, LibreSSL)

Exemplo de código vulnerável:
  if (byte == 0):
      delay(100)  # 🔴 Timing leak!
  sbox_lookup(byte)
""")

# Executar
PerformanceAttacks.comparison()
PerformanceAttacks.timing_attack()
```

***

### 📊 **3DES vs AES**

#### **Comparação Detalhada**

```yaml
3DES vs AES - Comparação Completa:

  🔐 Tamanho do Bloco:
    3DES: 64 bits (limitante - Sweet32)
    AES: 128 bits (seguro)

  🔑 Tamanho da Chave:
    3DES: 168 bits (112 efetivos)
    AES: 128/192/256 bits (seguro)

  ⚙️ Estrutura:
    3DES: Rede de Feistel (16 rodadas × 3)
    AES: SPN (10-14 rodadas)

  🚀 Performance (CPU moderno):
    3DES: 15 MB/s
    AES: 300 MB/s
    AES-NI: 3,000 MB/s

  🛡️ Segurança:
    3DES: 112 bits (Sweet32 enfraquece)
    AES-128: 128 bits
    AES-256: 256 bits

  📜 Status (2024):
    3DES: ⚠️ Depreciado (sunset 2023)
    AES: ✅ Padrão global

  💰 Custo Computacional:
    3DES: Alto (3x DES)
    AES: Baixo (otimizado)

  🔌 Suporte Hardware:
    3DES: Limitado
    AES: AES-NI, ARM Crypto
```

#### **Tabela de Migração**

| Caso de Uso              | Solução Antiga                      | Solução Moderna            | Prazo    |
| ------------------------ | ----------------------------------- | -------------------------- | -------- |
| **TLS/SSL**              | TLS\_RSA\_WITH\_3DES\_EDE\_CBC\_SHA | TLS\_AES\_256\_GCM\_SHA384 | Imediato |
| **Dados em Repouso**     | 3DES-CBC                            | AES-256-GCM                | Imediato |
| **Hardware Legado**      | 3DES em smart cards                 | AES-128                    | 2025     |
| **ATM/POS**              | 3DES (PIN)                          | AES-256                    | 2024     |
| **Sistemas Financeiros** | 3DES (3TDEA)                        | AES-256                    | 2025     |

***

### 🛡️ **Migração e Sunset**

#### **Plano de Migração**

```python
#!/usr/bin/env python3
# migration_plan.py - Plano de migração do 3DES

class MigrationPlan:
    """Plano de migração do 3DES para AES"""
    
    @staticmethod
    def timeline():
        """Cronograma de sunset"""
        print("Cronograma de Sunset do 3DES")
        print("=" * 60)
        
        timeline = {
            "2016": "Sweet32 attack descoberto",
            "2018": "NIST recomenda descontinuação",
            "2020": "PCI SSC proíbe 3DES em novos sistemas",
            "2021": "Maiores CAs removem suporte",
            "2023": "NIST deprecia completamente",
            "2024": "Fim do suporte em TLS",
            "2025": "Deadline para migração completa"
        }
        
        for year, event in timeline.items():
            print(f"  {year}: {event}")
    
    @staticmethod
    def migration_steps():
        """Passos para migração"""
        print("\n" + "=" * 60)
        print("Passos para Migração")
        
        steps = [
            ("1. Inventário", "Identificar todos os sistemas usando 3DES"),
            ("2. Priorização", "Classificar por criticidade e exposição"),
            ("3. Testes", "Validar compatibilidade com AES"),
            ("4. Migração", "Substituir algoritmos gradualmente"),
            ("5. Validação", "Testar performance e segurança"),
            ("6. Remoção", "Desabilitar 3DES completamente"),
            ("7. Monitoramento", "Detectar uso residual")
        ]
        
        for step, action in steps:
            print(f"\n  {step}: {action}")
    
    @staticmethod
    def compliance():
        """Requisitos de compliance"""
        print("\n" + "=" * 60)
        print("Requisitos de Compliance")
        
        standards = {
            "PCI DSS": "3DES proibido após 2023",
            "NIST SP 800-57": "3DES não recomendado",
            "FIPS 140-3": "AES preferido",
            "GDPR": "Dados requerem AES",
            "HIPAA": "AES-128 mínimo"
        }
        
        for standard, requirement in standards.items():
            print(f"  {standard}: {requirement}")

# Executar
MigrationPlan.timeline()
MigrationPlan.migration_steps()
MigrationPlan.compliance()
```

#### **Script de Verificação**

```bash
#!/bin/bash
# check_3des.sh - Verificador de uso de 3DES

echo "=== Verificação de 3DES ==="

# 1. Verificar cipher suites do servidor
echo -e "\n[1] Cipher suites do servidor:"
openssl s_client -connect example.com:443 -cipher '3DES' 2>/dev/null | grep -i "Cipher"

# 2. Verificar configuração do OpenSSL
echo -e "\n[2] OpenSSL 3DES support:"
openssl ciphers -v '3DES' | head -5

# 3. Verificar configuração do Apache
echo -e "\n[3] Apache config:"
grep -r "SSLCipherSuite" /etc/apache2/ 2>/dev/null | grep -i "3des"

# 4. Verificar configuração do Nginx
echo -e "\n[4] Nginx config:"
grep -r "ssl_ciphers" /etc/nginx/ 2>/dev/null | grep -i "3des"

# 5. Verificar arquivos de configuração
echo -e "\n[5] Arquivos de configuração:"
find /etc -name "*.conf" -exec grep -l "3DES" {} \; 2>/dev/null

# 6. Verificar código fonte
echo -e "\n[6] Código fonte:"
grep -r "TripleDES\|3DES" --include="*.py" --include="*.java" --include="*.c" . 2>/dev/null | head -5
```

***

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

#### **Checklist para Administradores**

* [ ] Identificar todos os sistemas usando 3DES
* [ ] Remover cipher suites 3DES do TLS
* [ ] Migrar para AES-256-GCM
* [ ] Atualizar hardware criptográfico legado
* [ ] Verificar compliance com PCI/NIST
* [ ] Testar performance pós-migração
* [ ] Documentar sunset do 3DES

#### **Checklist para Desenvolvedores**

* [ ] Substituir 3DES por AES nas bibliotecas
* [ ] Usar AES-256-GCM para novos projetos
* [ ] Evitar implementações caseiras de 3DES
* [ ] Validar padding oracles (CBC mode)
* [ ] Testar com dados de volume (Sweet32)
* [ ] Implementar key rotation

#### **Checklist para Auditores**

* [ ] Verificar uso de 3DES em TLS
* [ ] Testar cipher suites com sslyze
* [ ] Auditar key management de 3DES
* [ ] Verificar compliance regulatório
* [ ] Avaliar riscos de Sweet32
* [ ] Validar planos de migração

***

### 📊 **Conclusão**

```yaml
3DES (Triple DES):

  ❌ Status (2024):
    - Depreciado pelo NIST
    - Sunset completo em 2023
    - Vulnerável a Sweet32
    - Performance inadequada

  ⚠️ Riscos:
    - Bloco de 64 bits (birthday attack)
    - Meet-in-the-middle (2TDEA)
    - Timing attacks
    - Baixa performance

  🎯 Recomendações:
    - MIGRAR para AES-256-GCM
    - REMOVER de TLS/SSL
    - DESABILITAR cipher suites
    - ATUALIZAR sistemas legados

  📈 Lições:
    - Tamanho do bloco importa (64 vs 128 bits)
    - Padrões criptográficos têm vida útil
    - Performance é fator de segurança
    - Hardware acceleration é fundamental
```


---

# 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/conceitos/criptografia/simetrica/3des-triple-des.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.