Gerador e Analisador de Chaves Bitcoin secp256k1
⚠️ Este script é apenas para fins educacionais. Nunca utilize chaves privadas geradas por scripts de terceiros para armazenar fundos reais.
Domine a Criptografia de Curva Elíptica
Aprenda na prática como funciona a geração de chaves Bitcoin através de um script Python completo que implementa todos os algoritmos criptográficos da curva secp256k1, do zero até a geração de endereços.
O que é este Script?
Este é um gerador e analisador completo de chaves Bitcoin desenvolvido em Python puro, sem dependências externas além das bibliotecas padrão. O script implementa toda a matemática da curva elíptica secp256k1 utilizada pelo Bitcoin, permitindo que você entenda exatamente como funciona cada etapa do processo de geração de chaves.
Diferente de bibliotecas prontas que abstraem toda a complexidade, este código mostra explicitamente cada operação matemática: multiplicação de pontos na curva, dobramento de pontos, adição de pontos, cálculo de inverso modular, conversão para formato WIF, geração de endereços e muito mais.
💡 Destaque: O script permite gerar chaves em intervalos específicos de potências de 2 (2^n até 2^(n+1)-1), ideal para estudar a distribuição das chaves no espaço de 256 bits e realizar análises estatísticas.
Benefícios do Script
Implementação Completa
Código fonte completo de todos os algoritmos criptográficos: multiplicação escalar, operações modulares, hashing SHA256 e RIPEMD160, codificação Base58Check e mais.
Análise Flexível
Gere de 1 até milhares de chaves em intervalos personalizados. Ideal para análises estatísticas, testes de distribuição e estudos sobre o espaço de chaves Bitcoin.
Didático e Comentado
Cada função possui documentação clara explicando exatamente o que faz. Perfeito para estudantes de criptografia e desenvolvedores que querem entender os fundamentos.
Algoritmo Otimizado
Utiliza o algoritmo double-and-add para multiplicação de pontos, garantindo eficiência mesmo para chaves privadas com valores extremamente grandes (até 2^256).
Formatos Múltiplos
Gera chaves públicas comprimidas e não comprimidas, WIF em ambos formatos, endereços Bitcoin legacy e permite validar a recuperação de coordenadas Y.
Exportação Automática
Salva automaticamente todas as chaves geradas em arquivo texto organizado, facilitando análises posteriores e importação para outras ferramentas.
Como o Script Funciona
Definição do Intervalo
Você escolhe um expoente n (exemplo: n=70) e o script trabalha no intervalo de 2^70 até 2^71-1. Isso permite estudar regiões específicas do espaço de chaves privadas de 256 bits. Você também define quantas chaves quer testar nesse intervalo (exemplo: 100 chaves distribuídas uniformemente).
Geração da Chave Pública
Para cada chave privada selecionada, o script multiplica o ponto gerador G da curva secp256k1 pelo valor da chave privada usando o algoritmo double-and-add. Este algoritmo é extremamente eficiente, convertendo a operação em uma sequência de dobros e somas de pontos na curva elíptica, resultando nas coordenadas públicas X e Y.
Conversão e Validação
A chave pública é convertida para formatos comprimido (33 bytes) e não comprimido (65 bytes). O script então valida a conversão testando se consegue recuperar corretamente a coordenada Y a partir apenas da coordenada X e do prefixo (02 ou 03). Em seguida, gera os formatos WIF (Wallet Import Format) para ambas as versões e calcula os endereços Bitcoin correspondentes usando SHA256 e RIPEMD160.
Recursos Técnicos Implementados
- ✓ Curva Elíptica secp256k1: Implementação completa da equação y² = x³ + 7 (mod p) com todos os parâmetros oficiais do Bitcoin
- ✓ Algoritmo Double-and-Add: Multiplicação escalar eficiente de pontos na curva elíptica, otimizado para operações de grande escala
- ✓ Inverso Modular: Implementação do algoritmo estendido de Euclides para cálculo de inversos modulares
- ✓ Compressão de Chaves: Conversão entre formatos comprimido e não comprimido com recuperação de coordenada Y
- ✓ Formato WIF: Codificação de chaves privadas em Wallet Import Format com checksum SHA256
- ✓ Base58Check: Implementação completa da codificação Base58 com validação de checksum
- ✓ Geração de Endereços: Pipeline completo SHA256 → RIPEMD160 → Base58Check para criação de endereços Bitcoin
- ✓ Modo de Saída Configurável: Escolha entre exibição completa com todos os detalhes ou modo resumido mostrando apenas as WIFs
Para Quem é Este Script
👨🎓 Estudantes de Criptografia
Aprenda na prática como funciona a criptografia de curva elíptica, vendo cada operação matemática implementada em código legível e comentado.
💻 Desenvolvedores Blockchain
Entenda os fundamentos do Bitcoin em nível baixo, sem abstrações. Ideal para quem quer desenvolver carteiras, exploradores ou ferramentas de análise.
🔬 Pesquisadores
Ferramenta perfeita para análises estatísticas sobre distribuição de chaves, testes de colisão e estudos sobre segurança de curvas elípticas.
🎯 Entusiastas de Bitcoin
Explore o funcionamento interno do Bitcoin e entenda exatamente como suas chaves são geradas e protegidas matematicamente.
Exemplo de Uso Prático
# Configuração principal
IMPRIMIR_TUDO = True # True: detalhes completos / False: apenas WIFs
# Exemplo 1: Gera 100 chaves no intervalo 2^70 até 2^71-1
gerar_e_testar_chaves(n_inicial=70, n_final=70, num_testes=100)
# Exemplo 2: Análise de múltiplos intervalos com 10 testes cada
gerar_e_testar_chaves(n_inicial=1, n_final=10, num_testes=10)
# Exemplo 3: Teste massivo com 1000 chaves
gerar_e_testar_chaves(n_inicial=50, n_final=50, num_testes=1000)💡 Dica: Para intervalos maiores (n > 60), o script pode levar alguns segundos por chave devido à complexidade das operações modulares. Para análises massivas com milhares de chaves, considere executar em lotes menores ou utilizar pypy para melhor performance.
Estrutura do Código
O script está organizado em módulos funcionais claros, facilitando a compreensão e modificação:
- 📐 Operações de Curva Elíptica: inverso_modular(), euclides_estendido(), multiplicar_ponto(), dobrar_ponto(), adicionar_pontos()
- 🔑 Geração de Chaves: gerar_chave_publica(), chave_publica_comprimida(), chave_publica_nao_comprimida(), recuperar_y()
- 🔐 Funções de Hash: sha256(), hash160()
- 💼 Codificação e Formatos: base58_encode(), privkey_to_wif(), pubkey_to_address()
- 🔍 Análise e Validação: separar_chave_publica(), gerar_e_testar_chaves()
⚠️ Avisos Importantes de Segurança
- Este script é exclusivamente para fins educacionais. Não utilize as chaves geradas para armazenar fundos reais.
- Chaves geradas de forma determinística são previsíveis. Qualquer pessoa com o mesmo script pode gerar as mesmas chaves.
- Para uso real, utilize geradores de números aleatórios criptograficamente seguros fornecidos por bibliotecas confiáveis como secrets do Python ou bibliotecas especializadas em Bitcoin.
- Nunca compartilhe chaves privadas ou WIFs publicamente. Qualquer pessoa com acesso a esses dados pode controlar os fundos associados.
- O script não implementa geração de entropia segura. Ele trabalha com valores determinísticos em intervalos específicos para fins de estudo.
Requisitos do Sistema
Python 3.6 ou superior. O script utiliza apenas bibliotecas padrão (hashlib, os).
Mínimo 512MB RAM. Para testes com milhares de chaves, recomenda-se 2GB ou mais.
Qualquer CPU moderna. Para melhor performance em grandes volumes, utilize PyPy.
Configurações Personalizáveis
O script oferece controle total sobre a execução através de parâmetros simples de configurar:
Parâmetros Principais:
- n_inicial e n_final: Define o intervalo de potências de 2 para análise (exemplo: 70 a 100 gera intervalos de 2^70 até 2^100)
- num_testes: Quantidade de chaves a serem geradas em cada intervalo (de 1 até milhares)
- IMPRIMIR_TUDO: True para ver todos os detalhes técnicos, False para mostrar apenas as WIFs geradas
# Configure aqui antes de executar:
IMPRIMIR_TUDO = True # Mude para False para modo resumido
# Exemplos de configuração:
# Modo 1: Análise detalhada de um único intervalo
gerar_e_testar_chaves(n_inicial=70, n_final=70, num_testes=100)
# Modo 2: Varredura rápida de múltiplos intervalos
gerar_e_testar_chaves(n_inicial=1, n_final=100, num_testes=10)
# Modo 3: Teste massivo em intervalo específico
gerar_e_testar_chaves(n_inicial=50, n_final=50, num_testes=10000)O que Você Aprenderá
🔢 Matemática da Curva Elíptica
Entenda como funcionam as operações de adição e multiplicação de pontos na curva secp256k1, incluindo a fórmula y² = x³ + 7 (mod p) e aritmética modular.
🔐 Geração de Chaves
Veja passo a passo como uma chave privada (número inteiro) é convertida em chave pública (ponto na curva) através de multiplicação escalar.
📦 Compressão de Dados
Aprenda como uma chave pública de 65 bytes pode ser comprimida para 33 bytes e como recuperar a informação perdida usando propriedades da curva.
🏦 Formato de Carteiras
Descubra como funcionam os formatos WIF (Wallet Import Format) e como endereços Bitcoin são derivados através de múltiplas camadas de hashing.
🔍 Validação e Checksums
Compreenda os mecanismos de checksum que protegem contra erros de digitação em endereços e chaves privadas usando duplo SHA256.
⚡ Otimização de Algoritmos
Veja como o algoritmo double-and-add transforma uma operação que seria impossível de calcular diretamente em algo viável computacionalmente.
Arquivo de Saída Gerado
O script cria automaticamente um arquivo 2_inicial.txt contendo todas as WIFs geradas, facilitando a importação para carteiras de teste ou análises posteriores. O formato é simples e direto:
WIF Comprimido:
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn
WIF Não Comprimido:
5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf
WIF Comprimido:
L1aW4aubDFB7yfras2S1mN3bqg9nwySY8nkoLmJebSLD5BWv3ENZ
WIF Não Comprimido:
5JG9hT3beGTJuUAmCQEmNaxAuMacCTfXuw1R3FCXig23RQHMr4KCada par de WIFs representa a mesma chave privada em formatos diferentes, permitindo importação tanto em carteiras que suportam chaves comprimidas quanto não comprimidas.
Performance e Dicas de Otimização
Tempos Aproximados de Execução:
- Intervalos pequenos (2^1 até 2^20): ~0.01 segundos por chave
- Intervalos médios (2^21 até 2^60): ~0.1 segundos por chave
- Intervalos grandes (2^61 até 2^100): ~0.5 a 2 segundos por chave
- Intervalos massivos (2^100+): ~3 a 10 segundos por chave
Dicas para Melhorar Performance:
- Use PyPy em vez de CPython para ganhos de 3x a 10x em velocidade
- Para análises massivas, divida em múltiplos arquivos executando intervalos separados
- Configure IMPRIMIR_TUDO = False para reduzir operações de I/O
- Execute em lotes: 100-1000 chaves por execução para evitar travamentos
- Considere usar processamento paralelo para múltiplos intervalos simultâneos
Aplicações Práticas do Script
📚 Ensino e Educação
Use em cursos, workshops e tutoriais para demonstrar conceitos de criptografia de curva elíptica de forma prática e visual.
🔬 Pesquisa Acadêmica
Realize estudos sobre distribuição de chaves, análise estatística do espaço de chaves Bitcoin e propriedades matemáticas da secp256k1.
🛠️ Desenvolvimento
Base de código para desenvolver ferramentas de análise de blockchain, geradores de carteiras educacionais ou validadores de chaves.
🔐 Auditoria de Segurança
Teste e valide implementações de carteiras verificando se os algoritmos geram as mesmas chaves para os mesmos valores de entrada.
Recursos Adicionais e Aprendizado
Para aprofundar seus conhecimentos sobre criptografia de curva elíptica e Bitcoin, recomendamos os seguintes recursos oficiais:
- Bitcoin Wiki - secp256k1: Documentação oficial sobre a curva elíptica utilizada pelo Bitcoin
- BIP32/BIP39: Padrões de geração hierárquica determinística de chaves (HD Wallets)
- Bitcoin Developer Guide: Guia técnico completo sobre o funcionamento do Bitcoin
- Mastering Bitcoin (Andreas Antonopoulos): Livro técnico gratuito sobre desenvolvimento Bitcoin
- Standards for Efficient Cryptography (SEC): Especificações técnicas das curvas elípticas
Pronto para Explorar a Criptografia Bitcoin?
Baixe o script completo, experimente diferentes configurações e descubra os segredos matemáticos por trás da tecnologia mais revolucionária da última década.
⚠️ Lembrete Final: Este script foi desenvolvido exclusivamente para fins educacionais e de pesquisa. Nunca utilize chaves geradas por este ou qualquer outro script determinístico para armazenar fundos reais. Para uso em produção, sempre utilize bibliotecas consolidadas e auditadas pela comunidade, com geração de entropia criptograficamente segura através de fontes de aleatoriedade adequadas.
"""Gerador e Analisador Completo de Chaves secp256k1Gera chaves privadas no intervalo 2^n até 2^(n+1)-1Calcula chaves públicas, endereços e formatos WIF"""import hashlibimport os# Parâmetros da curva secp256k1: y² = x³ + 7 (mod p)P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FN = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8def inverso_modular(a, m):"""Calcula o inverso modular de a mod m usando algoritmo estendido de Euclides"""if a < 0:a = (a % m + m) % mg, x, _ = euclides_estendido(a, m)if g != 1:raise Exception('Inverso modular não existe')return x % mdef euclides_estendido(a, b):"""Algoritmo estendido de Euclides"""if a == 0:return b, 0, 1gcd, x1, y1 = euclides_estendido(b % a, a)x = y1 - (b // a) * x1y = x1return gcd, x, ydef multiplicar_ponto(k, x, y):"""Multiplica um ponto (x,y) por escalar k na curva elíptica (double-and-add)"""if k == 0:return None, Noneif k == 1:return x, y# Ponto no infinitoif k < 0 or x is None:return None, None# Dobrar e adicionarrx, ry = None, Noneax, ay = x, ywhile k:if k & 1: # Se bit é 1, adiciona o pontoif rx is None:rx, ry = ax, ayelse:rx, ry = adicionar_pontos(rx, ry, ax, ay)# Dobra o pontoax, ay = dobrar_ponto(ax, ay)k >>= 1return rx, rydef dobrar_ponto(x, y):"""Dobra um ponto na curva: P + P"""if y == 0:return None, None# s = (3x² + a) / (2y) onde a=0 na secp256k1s = (3 * x * x * inverso_modular(2 * y, P)) % Pxr = (s * s - 2 * x) % Pyr = (s * (x - xr) - y) % Preturn xr, yrdef adicionar_pontos(x1, y1, x2, y2):"""Adiciona dois pontos na curva: P + Q"""if x1 is None:return x2, y2if x2 is None:return x1, y1if x1 == x2:if y1 == y2:return dobrar_ponto(x1, y1)else:return None, None# s = (y2 - y1) / (x2 - x1)s = ((y2 - y1) * inverso_modular(x2 - x1, P)) % Pxr = (s * s - x1 - x2) % Pyr = (s * (x1 - xr) - y1) % Preturn xr, yrdef gerar_chave_publica(chave_privada):"""Gera chave pública a partir da chave privada: PubKey = privKey * G"""x, y = multiplicar_ponto(chave_privada, Gx, Gy)return x, ydef chave_publica_comprimida(x, y):"""Converte coordenadas (x,y) para formato comprimido"""prefixo = '02' if y % 2 == 0 else '03'return prefixo + f'{x:064x}'def chave_publica_nao_comprimida(x, y):"""Converte coordenadas (x,y) para formato não comprimido"""return '04' + f'{x:064x}' + f'{y:064x}'def recuperar_y(x_hex, prefixo):"""Recupera Y a partir de X e prefixo (02/03)"""x_int = int(x_hex, 16)alpha = (pow(x_int, 3, P) + 7) % Py_int = pow(alpha, (P + 1) // 4, P)# Ajusta paridadeif (prefixo == '02') != (y_int % 2 == 0):y_int = P - y_intreturn y_intdef sha256(data):"""Calcula SHA256"""return hashlib.sha256(data).digest()def hash160(data):"""Calcula RIPEMD160(SHA256(data))"""return hashlib.new('ripemd160', sha256(data)).digest()def base58_encode(data):"""Codifica bytes em Base58"""alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'num = int.from_bytes(data, 'big')encoded = ''while num > 0:num, remainder = divmod(num, 58)encoded = alphabet[remainder] + encoded# Adiciona '1' para cada byte zero no iníciofor byte in data:if byte == 0:encoded = '1' + encodedelse:breakreturn encodeddef privkey_to_wif(privkey_int, comprimido=True):"""Converte chave privada para formato WIF"""# 0x80 (mainnet) + privkey + (0x01 se comprimido)extended = b'\x80' + privkey_int.to_bytes(32, 'big')if comprimido:extended += b'\x01'# Adiciona checksum (primeiros 4 bytes do duplo SHA256)checksum = sha256(sha256(extended))[:4]wif_bytes = extended + checksumreturn base58_encode(wif_bytes)def pubkey_to_address(pubkey_hex):"""Converte chave pública para endereço Bitcoin"""pubkey_bytes = bytes.fromhex(pubkey_hex)h160 = hash160(pubkey_bytes)# 0x00 (mainnet) + hash160extended = b'\x00' + h160checksum = sha256(sha256(extended))[:4]address_bytes = extended + checksumreturn base58_encode(address_bytes)def separar_chave_publica(chave_hex):"""Separa coordenadas X e Y de chave pública"""chave = chave_hex[2:] if chave_hex.startswith('0x') else chave_hexprefixo = chave[:2].lower()if prefixo == '04': # Não comprimidax_hex = chave[2:66]y_hex = chave[66:130]return x_hex, y_hex, 'Não Comprimida'elif prefixo in ('02', '03'): # Comprimidax_hex = chave[2:66]y_int = recuperar_y(x_hex, prefixo)y_hex = f'{y_int:064x}'return x_hex, y_hex, 'Comprimida'return None, None, 'Inválida'def gerar_e_testar_chaves(n_inicial=0, n_final=10, num_testes=4, imprimir_detalhes=True):"""Gera chaves no intervalo 2^n até 2^(n+1)-1 e testa análiseArgs:n_inicial: Expoente inicial (padrão: 0)n_final: Expoente final (padrão: 10)num_testes: Quantidade de testes por intervalo (padrão: 4)imprimir_detalhes: True para imprimir todos os detalhes, False para imprimir apenas WIFs (padrão: True)"""if imprimir_detalhes:print("\n" + "="*80)print("GERADOR E ANALISADOR DE CHAVES SECP256K1")print("="*80)for n in range(n_inicial, n_final + 1):inicio = 2 ** nfim = 2 ** (n + 1) - 1if imprimir_detalhes:print(f"\n{'─'*80}")print(f"INTERVALO n={n}: 2^{n} até 2^{n+1}-1")print(f"Decimal: {inicio} até {fim}")print(f"{'─'*80}")# Lista para armazenar WIFswifs_geradas = []# Gera chaves de teste distribuídas uniformemente no intervaloif num_testes == 1:chaves_teste = [inicio]elif num_testes == 2:chaves_teste = [inicio, fim]else:# Distribui uniformemente: início, pontos intermediários, fimpasso = (fim - inicio) / (num_testes - 1)chaves_teste = [int(inicio + i * passo) for i in range(num_testes)]chaves_teste[-1] = fim # Garante que o último seja exatamente o fimfor idx, privkey in enumerate(chaves_teste, 1):if imprimir_detalhes:print(f"\n[Teste {idx}] Chave Privada: {privkey}")print(f" Hex: 0x{privkey:064x}")# Gera chave públicax, y = gerar_chave_publica(privkey)if x is None:if imprimir_detalhes:print(" ✗ Erro ao gerar chave pública")continueif imprimir_detalhes:print(f" Coordenadas calculadas:")print(f" X = {x:064x}")print(f" Y = {y:064x}")# Formatos comprimido e não comprimidopubkey_comp = chave_publica_comprimida(x, y)pubkey_uncomp = chave_publica_nao_comprimida(x, y)if imprimir_detalhes:print(f"\n Chave Pública COMPRIMIDA:")print(f" {pubkey_comp}")print(f"\n Chave Pública NÃO COMPRIMIDA:")print(f" {pubkey_uncomp}")# Testa separação da chave comprimidaprint(f"\n 🔍 Testando separação (formato comprimido):")x_sep, y_sep, formato = separar_chave_publica(pubkey_comp)if x_sep and y_sep:x_match = x_sep == f'{x:064x}'y_match = y_sep == f'{y:064x}'print(f" Formato detectado: {formato}")print(f" X recuperado: {'✓ OK' if x_match else '✗ ERRO'}")print(f" Y recuperado: {'✓ OK' if y_match else '✗ ERRO'}")# Gera WIFswif_comp = privkey_to_wif(privkey, comprimido=True)wif_uncomp = privkey_to_wif(privkey, comprimido=False)if imprimir_detalhes:print(f"\n WIF COMPRIMIDO:")print(f" {wif_comp}")print(f"\n WIF NÃO COMPRIMIDO:")print(f" {wif_uncomp}")else:# Modo resumido: imprime apenas as WIFsprint(f"p2pkh:{wif_comp}")print(f"p2wpkh-p2sh:{wif_comp}")print(f"p2wpkh:{wif_comp}")print(f"p2pkh:{wif_uncomp}")print(f"p2wpkh-p2sh:{wif_uncomp}")print(f"p2wpkh:{wif_uncomp}")# Gera endereçosaddr_comp = pubkey_to_address(pubkey_comp)addr_uncomp = pubkey_to_address(pubkey_uncomp)if imprimir_detalhes:print(f"\n Endereço (comprimido): {addr_comp}")print(f" Endereço (não comprimido): {addr_uncomp}")# Adiciona à listawifs_geradas.append({'teste': idx,'privkey_dec': privkey,'privkey_hex': f'0x{privkey:064x}','wif_comprimido': wif_comp,'wif_nao_comprimido': wif_uncomp,'pubkey_comprimida': pubkey_comp,'pubkey_nao_comprimida': pubkey_uncomp,'endereco_comprimido': addr_comp,'endereco_nao_comprimido': addr_uncomp})# Salva em arquivonome_arquivo = f"2_inicial.txt"with open(nome_arquivo, 'w', encoding='utf-8') as f:for wif_data in wifs_geradas:f.write(f"p2pkh:{wif_data['wif_comprimido']}")f.write(f"p2wpkh-p2sh:{wif_data['wif_comprimido']}")f.write(f"p2wpkh:{wif_data['wif_comprimido']}")f.write(f"p2pkh:{wif_data['wif_nao_comprimido']}")f.write(f"p2wpkh-p2sh:{wif_data['wif_nao_comprimido']}")f.write(f"p2wpkh:{wif_data['wif_nao_comprimido']}")if imprimir_detalhes:print(f"\n✓ Arquivo salvo: {nome_arquivo}")if imprimir_detalhes:print("\n" + "="*80)print("GERAÇÃO CONCLUÍDA!")print(f"Arquivos criados: 2^0_inicial.txt até 2^{n_final}_inicial.txt")print("="*80 + "\n")# ============= CONFIGURAÇÃO =============# ESCOLHA AQUI: True para imprimir todos os detalhes, False para imprimir apenas WIFsIMPRIMIR_TUDO = False # Mude para True / False se quiser ver apenas as WIFs# ============= EXECUÇÃO =============if __name__ == "__main__":# Gera chaves de 2^70 até 2^100 com 100 testes cadagerar_e_testar_chaves(n_inicial=70, n_final=100, num_testes=100, imprimir_detalhes=IMPRIMIR_TUDO)# Exemplos práticos (comentados):'''# 1. Apenas início e fim (2 testes)gerar_e_testar_chaves(n_inicial=5, n_final=5, num_testes=2, imprimir_detalhes=IMPRIMIR_TUDO)# 2. Análise detalhada com 10 testesgerar_e_testar_chaves(n_inicial=10, n_final=10, num_testes=10, imprimir_detalhes=IMPRIMIR_TUDO)# 3. Análise ultra-detalhada com 100 testesgerar_e_testar_chaves(n_inicial=20, n_final=20, num_testes=100, imprimir_detalhes=IMPRIMIR_TUDO)# 4. Análise massiva de 1000 testes (cuidado com o tempo!)gerar_e_testar_chaves(n_inicial=30, n_final=30, num_testes=1000, imprimir_detalhes=IMPRIMIR_TUDO)# 5. Múltiplos intervalos com 5 testes cadagerar_e_testar_chaves(n_inicial=0, n_final=10, num_testes=5, imprimir_detalhes=IMPRIMIR_TUDO)'''
Comentários
Comente só assim vamos crescer juntos!