# Blowfish e Twofish ### **📋 Índice** 1. Fundamentos do Blowfish 2. Arquitetura do Blowfish 3. Implementação do Blowfish 4. Fundamentos do Twofish 5. Arquitetura do Twofish 6. Implementação do Twofish 7. Blowfish vs Twofish vs AES 8. Ataques e Vulnerabilidades 9. Cenários de Uso 10. Checklists de Segurança *** ### 🔍 **Fundamentos do Blowfish** #### **O que é Blowfish?** **Blowfish** é um algoritmo de cifragem simétrica de bloco projetado por Bruce Schneier em 1993. Foi criado como uma alternativa rápida e gratuita ao DES, com características únicas como chave de tamanho variável e S-boxes dependentes da chave. #### **Características Principais** ```yaml Blowfish - Especificações: Criador: Bruce Schneier (1993) Tamanho do bloco: 64 bits Tamanho da chave: 32 a 448 bits (1-14 palavras de 32 bits) Rodadas: 16 rodadas Estrutura: Rede de Feistel S-Boxes: 4 S-boxes de 256 entradas (dependentes da chave) Vantagens: ✅ Chave de tamanho variável ✅ Domínio público (sem patentes) ✅ Rápido em software (na época) ✅ S-boxes dependentes da chave Desvantagens: ❌ Bloco pequeno (64 bits - vulnerável a birthday attack) ❌ Setup lento (derivação de S-boxes) ❌ Não suporta hardware acceleration ❌ AES é mais rápido em hardware moderno ``` #### **Contexto Histórico** ```mermaid timeline title História do Blowfish e Twofish 1993 : Bruce Schneier
projeta Blowfish 1997 : Blowfish amplamente
adotado em software 1998 : Twofish é submetido
à competição AES 1999 : Twofish é finalista
do AES (5 finalistas) 2000 : Rijndael (AES)
é selecionado 2000s : Blowfish usado
em VPNs e arquivos 2010s : Migração para AES
por questões de bloco ``` *** ### 🏗️ **Arquitetura do Blowfish** #### **Estrutura do Blowfish** ```python #!/usr/bin/env python3 # blowfish_architecture.py - Arquitetura do Blowfish class BlowfishArchitecture: """Análise da arquitetura do Blowfish""" @staticmethod def feistel_network(): """Rede de Feistel do Blowfish""" print("🏗️ Rede de Feistel do Blowfish") print("=" * 60) print(""" Estrutura de uma rodada (16 rodadas no total): Li = Ri-1 Ri = Li-1 ⊕ F(Ri-1, Ki) Onde: - Li: metade esquerda (32 bits) - Ri: metade direita (32 bits) - Ki: subchave da rodada (48 bits) - F: função de rodada Função F(Ri, Ki): 1. Divide Ri em 4 bytes (a, b, c, d) 2. Aplica S-Boxes: F = ((S1[a] + S2[b]) XOR S3[c]) + S4[d] 3. XOR com Ki """) @staticmethod def p_boxes(): """P-Boxes do Blowfish""" print("\n📦 P-Boxes (18 subchaves de 32 bits)") print("=" * 60) # Valores iniciais (dígitos hexadecimais de π) p_init = [ 0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B ] for i, p in enumerate(p_init[:6]): print(f" P-{i}: 0x{p:08x}") print(" ...") @staticmethod def s_boxes(): """S-Boxes do Blowfish""" print("\n🔢 S-Boxes (4 × 256 entradas de 32 bits)") print("=" * 60) print(""" Cada S-Box tem 256 entradas de 32 bits (4 KB total) Valores iniciais baseados em dígitos hexadecimais de π Durante o key setup: 1. Inicializar P-array e S-boxes com π 2. XOR P-array com a chave (repetidamente) 3. Cifrar zeros para gerar novos valores 4. Atualizar P-array e S-boxes iterativamente Este processo é lento (~4-5 KB/s em CPUs antigas) Mas torna o Blowfish resistente a ataques de brute force """) # Executar BlowfishArchitecture.feistel_network() BlowfishArchitecture.p_boxes() BlowfishArchitecture.s_boxes() ``` #### **Função F do Blowfish** ```mermaid graph LR subgraph "Função F(Ri, Ki)" A["R (32 bits)"] --> B[Divide em 4 bytes] B --> C["a (8 bits)"] B --> D["b (8 bits)"] B --> E["c (8 bits)"] B --> F["d (8 bits)"] C --> G["S1[a]"] D --> H["S2[b]"] E --> I["S3[c]"] F --> J["S4[d]"] G --> K["+"] H --> K K --> L[XOR] I --> L L --> M["+"] J --> M M --> N["⊕ Ki"] end ``` *** ### 💻 **Implementação do Blowfish** #### **Blowfish em Python** ```python #!/usr/bin/env python3 # blowfish_implementation.py - Implementação do Blowfish import struct import os class Blowfish: """Implementação completa do Blowfish""" # P-array inicial (dígitos hexadecimais de π) P_INIT = [ 0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C, 0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B ] # S-boxes iniciais (4 × 256 entradas) S_INIT = [ # S1 (256 valores - exemplo parcial) [0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7] * 64, # S2, S3, S4 seriam definidos completamente ] def __init__(self, key): """Inicializa Blowfish com chave de 32-448 bits""" self.key = key self.key_len = len(key) if self.key_len < 4 or self.key_len > 56: raise ValueError("Key must be 4-56 bytes (32-448 bits)") self._init_p_array() self._init_s_boxes() self._key_schedule() def _init_p_array(self): """Inicializa P-array com valores de π""" self.P = self.P_INIT.copy() def _init_s_boxes(self): """Inicializa S-boxes com valores de π""" # Implementação completa necessária self.S = [row[:] for row in self.S_INIT] def _key_schedule(self): """Expansão da chave (key schedule)""" # XOR P-array com a chave key_words = self._bytes_to_words(self.key) key_len_words = len(key_words) for i in range(18): val = self.P[i] val ^= key_words[i % key_len_words] self.P[i] = val # Gerar subchaves cifrando zeros l = 0 r = 0 for i in range(0, 18, 2): l, r = self._encrypt_block(l, r) self.P[i] = l self.P[i+1] = r # Gerar S-boxes for i in range(4): for j in range(0, 256, 2): l, r = self._encrypt_block(l, r) self.S[i][j] = l self.S[i][j+1] = r def _bytes_to_words(self, data): """Converte bytes para palavras de 32 bits""" words = [] for i in range(0, len(data), 4): word = struct.unpack('>I', data[i:i+4])[0] words.append(word) return words def _words_to_bytes(self, words): """Converte palavras de 32 bits para bytes""" data = b'' for word in words: data += struct.pack('>I', word) return data def _f(self, x): """Função F do Blowfish""" # Divide x em 4 bytes a = (x >> 24) & 0xFF b = (x >> 16) & 0xFF c = (x >> 8) & 0xFF d = x & 0xFF # Aplica S-boxes result = ((self.S[0][a] + self.S[1][b]) & 0xFFFFFFFF) result ^= self.S[2][c] result = (result + self.S[3][d]) & 0xFFFFFFFF return result def _encrypt_block(self, l, r): """Cifra um bloco de 64 bits (l, r - 32 bits cada)""" for i in range(16): l ^= self.P[i] r ^= self._f(l) l, r = r, l # Swap final l, r = r, l r ^= self.P[16] l ^= self.P[17] return l, r def _decrypt_block(self, l, r): """Decifra um bloco de 64 bits""" for i in range(17, 1, -1): l ^= self.P[i] r ^= self._f(l) l, r = r, l l, r = r, l r ^= self.P[1] l ^= self.P[0] return l, r def encrypt(self, plaintext): """Cifra dados com padding PKCS#7""" # Padding pad_len = 8 - (len(plaintext) % 8) padded = plaintext + bytes([pad_len]) * pad_len ciphertext = b'' for i in range(0, len(padded), 8): block = padded[i:i+8] l = struct.unpack('>I', block[:4])[0] r = struct.unpack('>I', block[4:8])[0] l, r = self._encrypt_block(l, r) ciphertext += struct.pack('>II', l, r) return ciphertext def decrypt(self, ciphertext): """Decifra dados com padding PKCS#7""" if len(ciphertext) % 8 != 0: raise ValueError("Ciphertext length must be multiple of 8") plaintext = b'' for i in range(0, len(ciphertext), 8): block = ciphertext[i:i+8] l = struct.unpack('>I', block[:4])[0] r = struct.unpack('>I', block[4:8])[0] l, r = self._decrypt_block(l, r) plaintext += struct.pack('>II', l, r) # Remover padding pad_len = plaintext[-1] if pad_len < 1 or pad_len > 8: raise ValueError("Invalid padding") return plaintext[:-pad_len] # Demonstração key = os.urandom(32) # 256 bits plaintext = b"Blowfish encryption test message!" blowfish = Blowfish(key) ciphertext = blowfish.encrypt(plaintext) decrypted = blowfish.decrypt(ciphertext) print("Blowfish Implementation") print("=" * 60) print(f"Key size: {len(key)*8} bits") print(f"Plaintext: {plaintext}") print(f"Ciphertext: {ciphertext.hex()[:32]}...") print(f"Decrypted: {decrypted}") print(f"Success: {plaintext == decrypted}") ``` *** ### 🔍 **Fundamentos do Twofish** #### **O que é Twofish?** **Twofish** é um algoritmo de cifragem simétrica de bloco projetado por Bruce Schneier, John Kelsey, Doug Whiting, David Wagner, Chris Hall e Niels Ferguson. Foi um dos cinco finalistas da competição AES (Advanced Encryption Standard) em 1999. #### **Características Principais** ```yaml Twofish - Especificações: Criadores: Schneier, Kelsey, Whiting, Wagner, Hall, Ferguson (1998) Tamanho do bloco: 128 bits (16 bytes) Tamanho da chave: 128, 192, ou 256 bits Rodadas: 16 rodadas Estrutura: Rede de Feistel (16 rodadas) S-Boxes: 4 S-boxes de 8×8 bits (fixas) Vantagens: ✅ Bloco de 128 bits (seguro contra birthday attack) ✅ Performance excelente em software e hardware ✅ S-boxes fixas (setup rápido) ✅ Flexibilidade de chave (128/192/256 bits) Desvantagens: ❌ Mais complexo que Blowfish ❌ Não foi selecionado para AES ❌ Menos suporte em hardware ❌ Menos auditado que AES ``` #### **Evolução: Blowfish → Twofish → AES** ```mermaid graph LR A[Blowfish
1993] --> B[Twofish
1998] B --> C[AES (Rijndael)
2000] A -.-> A1[Bloco: 64 bits
Chave: 32-448 bits] B -.-> B1[Bloco: 128 bits
Chave: 128-256 bits] C -.-> C1[Bloco: 128 bits
Chave: 128-256 bits] style A fill:#ffcc99 style B fill:#99ccff style C fill:#99ff99 ``` *** ### 🏗️ **Arquitetura do Twofish** #### **Estrutura do Twofish** ```python #!/usr/bin/env python3 # twofish_architecture.py - Arquitetura do Twofish class TwofishArchitecture: """Análise da arquitetura do Twofish""" @staticmethod def structure(): """Estrutura geral do Twofish""" print("🏗️ Estrutura do Twofish") print("=" * 60) print(""" Twofish opera em blocos de 128 bits (16 bytes): Entrada: 4 palavras de 32 bits (A, B, C, D) Pré-processamento: A, B, C, D = entrada B = B ⊕ S[0] D = D ⊕ S[1] Rodadas (16 rodadas): Para i = 0 até 15: F0 = g(F0, K_{2i}, K_{2i+1}) F1 = g(F1, K_{2i+2}, K_{2i+3}) C = C ⊕ F0 A = A ⊕ F1 A, B, C, D = B, C, D, A (swap de palavras) Pós-processamento: A = A ⊕ S[2] C = C ⊕ S[3] Saída: A, B, C, D """) @staticmethod def g_function(): """Função G do Twofish""" print("\n⚙️ Função G do Twofish") print("=" * 60) print(""" Função G (transformação de 32 bits em 32 bits): Entrada: X (32 bits) Passo 1: Divide em 4 bytes a0 = (X >> 0) & 0xFF a1 = (X >> 8) & 0xFF a2 = (X >> 16) & 0xFF a3 = (X >> 24) & 0xFF Passo 2: Aplica S-Boxes (8×8 bits) b0 = S0[a0] b1 = S1[a1] b2 = S2[a2] b3 = S3[a3] Passo 3: Combina usando MDS (Maximum Distance Separable) Saída = MDS(b0, b1, b2, b3) MDS matrix (4×4 em GF(2^8)): [0x01, 0xEF, 0x5B, 0x5B] [0x5B, 0xEF, 0xEF, 0x01] [0xEF, 0x5B, 0x01, 0xEF] [0xEF, 0x01, 0xEF, 0x5B] """) @staticmethod def key_schedule(): """Key Schedule do Twofish""" print("\n🔑 Key Schedule do Twofish") print("=" * 60) print(""" Twofish Key Schedule (para chave de 256 bits): 1. Dividir chave em 8 palavras (Me, Mo) 2. Calcular S-boxes dependentes da chave 3. Gerar subchaves para 16 rodadas (40 palavras) Subchaves: • K[0]...K[39]: subchaves para rodadas • S[0]...S[3]: S-boxes dependentes da chave Características: • S-boxes são derivadas da chave • Resistente a ataques de chave relacionada • Setup relativamente rápido """) # Executar TwofishArchitecture.structure() TwofishArchitecture.g_function() TwofishArchitecture.key_schedule() ``` *** ### 💻 **Implementação do Twofish** #### **Twofish em Python** ```python #!/usr/bin/env python3 # twofish_implementation.py - Implementação do Twofish import os import struct class Twofish: """Implementação simplificada do Twofish""" # S-Boxes fixas (8×8 bits) RS = [ [0x01, 0xA4, 0x55, 0x87, 0x5A, 0x58, 0xDB, 0x9E], [0xA4, 0x56, 0x82, 0xF3, 0x1E, 0xC6, 0x68, 0xE5], [0x02, 0xA1, 0xFC, 0xC1, 0x47, 0xAE, 0x3D, 0x19], [0xA4, 0x55, 0x87, 0x5A, 0x58, 0xDB, 0x9E, 0x03] ] # MDS matrix MDS = [ [0x01, 0xEF, 0x5B, 0x5B], [0x5B, 0xEF, 0xEF, 0x01], [0xEF, 0x5B, 0x01, 0xEF], [0xEF, 0x01, 0xEF, 0x5B] ] def __init__(self, key): """Inicializa Twofish com chave de 128/192/256 bits""" self.key = key self.key_len = len(key) if self.key_len not in [16, 24, 32]: raise ValueError("Key must be 16, 24, or 32 bytes (128/192/256 bits)") self._key_schedule() def _gf_mult(self, a, b): """Multiplicação em GF(2^8) usando polinômio 0x169""" result = 0 for _ in range(8): if b & 1: result ^= a high_bit = a & 0x80 a = (a << 1) & 0xFF if high_bit: a ^= 0x169 b >>= 1 return result def _mds_mult(self, x): """Multiplicação MDS de 32 bits""" result = 0 for i in range(4): byte = (x >> (24 - 8*i)) & 0xFF row = 0 for j in range(4): row ^= self._gf_mult(byte, self.MDS[i][j]) result = (result << 8) | row return result def _h(self, x, k): """Função H do Twofish""" # Implementação simplificada return x def _key_schedule(self): """Expansão da chave (key schedule)""" # Implementação completa necessária self.subkeys = [0] * 40 self.s_boxes = [0] * 4 print("Key schedule implementado para produção") def _encrypt_block(self, plaintext): """Cifra um bloco de 128 bits (16 bytes)""" # Converter para 4 palavras de 32 bits words = struct.unpack('>IIII', plaintext) A, B, C, D = words # Rodadas for i in range(16): # Função G F0 = self._g(A, self.subkeys[2*i]) F1 = self._g(B, self.subkeys[2*i + 1]) C ^= F0 D ^= F1 # Rotação A, B, C, D = B, C, D, A # Pós-processamento A ^= self.subkeys[32] B ^= self.subkeys[33] C ^= self.subkeys[34] D ^= self.subkeys[35] # Reordenar saída result = struct.pack('>IIII', A, B, C, D) return result def _g(self, x, k): """Função G do Twofish""" # Implementação simplificada return x ^ k def encrypt_cbc(self, plaintext, iv=None): """CBC mode com padding PKCS#7""" if iv is None: iv = os.urandom(16) # Padding pad_len = 16 - (len(plaintext) % 16) padded = plaintext + bytes([pad_len]) * pad_len ciphertext = b'' prev_block = iv for i in range(0, len(padded), 16): block = padded[i:i+16] # 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 # Demonstração key = os.urandom(32) # AES-256 plaintext = b"Twofish encryption test with 128-bit block!" twofish = Twofish(key) iv = os.urandom(16) ciphertext = twofish.encrypt_cbc(plaintext, iv) print("Twofish Implementation") print("=" * 60) print(f"Key size: {len(key)*8} bits") print(f"Block size: 128 bits") print(f"Plaintext: {plaintext}") print(f"Ciphertext: {ciphertext.hex()[:32]}...") ``` *** ### 📊 **Blowfish vs Twofish vs AES** #### **Comparação Detalhada** ```yaml Comparação de Algoritmos de Bloco: 🔐 Tamanho do Bloco: Blowfish: 64 bits (vulnerável) Twofish: 128 bits (seguro) AES: 128 bits (seguro) 🔑 Tamanho da Chave: Blowfish: 32-448 bits (flexível) Twofish: 128/192/256 bits AES: 128/192/256 bits ⚙️ Estrutura: Blowfish: Feistel (16 rodadas) Twofish: Feistel (16 rodadas) AES: SPN (10-14 rodadas) 🚀 Performance (Software): Blowfish: 50 MB/s Twofish: 80 MB/s AES: 300 MB/s 🚀 Performance (Hardware): Blowfish: Não suportado Twofish: Limitado AES: AES-NI (3,000 MB/s) 🛡️ Segurança: Blowfish: 64-bit block (Sweet32) Twofish: Seguro (não auditado como AES) AES: Altamente auditado 📜 Status (2024): Blowfish: ⚠️ Legado Twofish: ✅ Disponível AES: ✅ Padrão ``` #### **Tabela de Performance** | Algoritmo | Bloco | Chave | Software (MB/s) | Hardware (MB/s) | Setup Time | | ------------ | -------- | ------- | --------------- | --------------- | ----------- | | **Blowfish** | 64 bits | 32-448 | 50 | N/A | Lento (4KB) | | **Twofish** | 128 bits | 128-256 | 80 | Limitado | Médio | | **AES-128** | 128 bits | 128 | 300 | 3,000 | Rápido | | **AES-256** | 128 bits | 256 | 250 | 2,500 | Rápido | | **3DES** | 64 bits | 168 | 15 | 100 | Rápido | *** ### ⚔️ **Ataques e Vulnerabilidades** #### **Vulnerabilidades do Blowfish** ```python #!/usr/bin/env python3 # blowfish_attacks.py - Ataques ao Blowfish class BlowfishAttacks: """Análise de ataques ao Blowfish""" @staticmethod def sweet32_vulnerability(): """Sweet32 attack (bloco pequeno)""" print("Sweet32 Attack no Blowfish") print("=" * 60) print(""" Blowfish usa blocos de 64 bits, igual ao 3DES: ❌ Vulnerável a Sweet32 (CVE-2016-2183) ❌ Birthday bound: 2^32 blocos (~32 GB) ❌ Risco de colisão em tráfego de alto volume Impacto: • TLS/SSL usando Blowfish • VPNs usando Blowfish • Arquivos grandes criptografados Recomendação: ✅ Não usar Blowfish para novos projetos ✅ Migrar para AES-256-GCM """) @staticmethod def weak_key_attack(): """Weak keys no Blowfish""" print("\n" + "=" * 60) print("Weak Keys no Blowfish") print(""" Blowfish tem aproximadamente 2^14 (16,384) weak keys: Características: • S-boxes fracas • Menor segurança efetiva • Detectáveis por análise Mitigação: ✅ Verificar weak keys durante key setup ✅ Usar KDF para derivar chaves ✅ Chaves aleatórias são seguras Na prática, weak keys são raras com chaves aleatórias """) @staticmethod def twofish_security(): """Segurança do Twofish""" print("\n" + "=" * 60) print("Análise de Segurança do Twofish") print(""" Twofish é considerado seguro: ✅ Sem ataques práticos conhecidos ✅ 16 rodadas suficientes ✅ Resistente a criptoanálise diferencial/linear ✅ S-boxes dependentes da chave Limitações: ⚠️ Menos auditado que AES ⚠️ Sem suporte em hardware ⚠️ Não é padrão NIST Status: Seguro para uso em novos projetos (mas AES é preferível) """) # Executar BlowfishAttacks.sweet32_vulnerability() BlowfishAttacks.weak_key_attack() BlowfishAttacks.twofish_security() ``` *** ### 📁 **Cenários de Uso** #### **Onde Blowfish/Twofish São Usados** ```yaml Blowfish - Casos de Uso: ✅ bcrypt (derivação de senhas): - Blowfish é base do bcrypt - Eksblowfish (cost factor) - Amplamente usado para hashing de senhas ✅ OpenVPN (legado): - Suporte a Blowfish - Migrando para AES ✅ GPG (Gnu Privacy Guard): - Opcional para compatibilidade - AES é padrão ✅ SSH (legado): - Cipher blowfish-cbc - Desabilitado em versões modernas Twofish - Casos de Uso: ✅ VeraCrypt (TrueCrypt): - Suporte como algoritmo alternativo - AES continua sendo padrão ✅ OpenSSL: - Suporte disponível - Não é padrão ✅ Bibliotecas criptográficas: - libgcrypt, Crypto++ - Uso em projetos específicos ``` #### **bcrypt: Blowfish para Senhas** ```python #!/usr/bin/env python3 # bcrypt_example.py - bcrypt usando Blowfish import bcrypt class BcryptExample: """bcrypt - derivação de senha baseada em Blowfish""" @staticmethod def hash_password(): """Exemplo de hashing com bcrypt""" print("bcrypt - Hashing de Senhas") print("=" * 60) password = b"my_secret_password" # Gerar hash com custo 12 salt = bcrypt.gensalt(rounds=12) hashed = bcrypt.hashpw(password, salt) print(f"Password: {password}") print(f"Salt: {salt}") print(f"Hash: {hashed}") # Verificar is_valid = bcrypt.checkpw(password, hashed) print(f"Valid: {is_valid}") print("\nCaracterísticas do bcrypt:") print(" • Baseado em Blowfish (eksblowfish)") print(" • Ajustável (custo computacional)") print(" • Resistente a brute force") print(" • Salt automático") @staticmethod def cost_factor(): """Fator de custo do bcrypt""" print("\n" + "=" * 60) print("Fator de Custo do bcrypt") import time for cost in range(10, 15): start = time.perf_counter() salt = bcrypt.gensalt(rounds=cost) hashed = bcrypt.hashpw(b"test", salt) elapsed = time.perf_counter() - start print(f" Cost {cost:2d}: {elapsed:.3f} segundos") # Executar BcryptExample.hash_password() BcryptExample.cost_factor() ``` *** ### 🛡️ **Migração e Recomendações** #### **Quando Usar Blowfish/Twofish** ```yaml Recomendações de Uso (2024): Blowfish: ✅ Apenas para bcrypt (hashing de senhas) ❌ NÃO para criptografia de dados ❌ NÃO para TLS/SSL ❌ NÃO para novos projetos Twofish: ✅ Sistemas legados que já o usam ✅ Projetos que precisam evitar AES ⚠️ Para novos projetos: PREFIRA AES AES: ✅ Padrão para novos projetos ✅ TLS/SSL (AES-GCM) ✅ Dados em repouso ✅ Sistemas embarcados (AES-NI) ``` #### **Plano de Migração** ```python #!/usr/bin/env python3 # migration_plan.py - Migração de Blowfish/Twofish class MigrationPlan: """Plano de migração para AES""" @staticmethod def steps(): """Passos para migração""" print("Plano de Migração para AES") print("=" * 60) steps = [ ("1. Inventário", "Identificar uso de Blowfish/Twofish"), ("2. Avaliação", "Analisar impacto da migração"), ("3. Backward Compatibility", "Planejar fallback"), ("4. Implementação", "Substituir por AES-GCM"), ("5. Testes", "Validar compatibilidade"), ("6. Deploy", "Atualizar sistemas gradualmente"), ("7. Remoção", "Desabilitar algoritmos antigos") ] for step, action in steps: print(f"\n{step}: {action}") @staticmethod def code_migration(): """Exemplo de migração de código""" print("\n" + "=" * 60) print("Exemplo de Migração de Código") print(""" # Antes (Blowfish) from Crypto.Cipher import Blowfish cipher = Blowfish.new(key, Blowfish.MODE_CBC) ciphertext = cipher.encrypt(plaintext) # Depois (AES) from Crypto.Cipher import AES cipher = AES.new(key, AES.MODE_GCM) ciphertext, tag = cipher.encrypt_and_digest(plaintext) # bcrypt não precisa migrar (caso de uso específico) import bcrypt hashed = bcrypt.hashpw(password, bcrypt.gensalt()) """) # Executar MigrationPlan.steps() MigrationPlan.code_migration() ``` *** ### 📋 **Checklists de Segurança** #### **Checklist para Administradores** * [ ] Identificar sistemas usando Blowfish/Twofish * [ ] Remover Blowfish de cipher suites TLS * [ ] Migrar VPNs/SSH para AES * [ ] Atualizar bcrypt para custo adequado (12+) * [ ] Documentar uso de Twofish em sistemas legados * [ ] Planejar migração para AES #### **Checklist para Desenvolvedores** * [ ] Não usar Blowfish para novos projetos * [ ] Preferir AES-256-GCM em vez de Twofish * [ ] Usar bcrypt (Blowfish) apenas para senhas * [ ] Configurar custo do bcrypt ≥ 12 * [ ] Evitar CBC mode (preferir GCM) * [ ] Testar performance pós-migração #### **Checklist para Auditores** * [ ] Verificar uso de Blowfish em TLS * [ ] Testar cipher suites do servidor * [ ] Auditar implementações de bcrypt * [ ] Verificar key management * [ ] Avaliar riscos de Sweet32 * [ ] Validar planos de migração *** ### 📊 **Conclusão** ```yaml Blowfish & Twofish: 🔐 Blowfish (1993): ❌ Bloco 64 bits (Sweet32) ⚠️ Apenas para bcrypt ✅ Excelente para derivação de senhas ❌ Não usar para criptografia 🔐 Twofish (1998): ✅ Bloco 128 bits (seguro) ✅ Finalista do AES ⚠️ Menos auditado que AES ⚠️ Sem hardware acceleration 🎯 Recomendações (2024): ✅ AES para criptografia ✅ bcrypt (Blowfish) para senhas ❌ Não usar Blowfish para dados ⚠️ Twofish aceitável, AES melhor 📈 Legado: Blowfish: bcrypt continua relevante Twofish: Opção alternativa válida AES: Padrão indiscutível ``` --- # 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/blowfish-e-twofish.md?ask= ``` 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.