Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE_2023_44487-Rapid_Reset — Ferramenta de teste baseada em Python para CVE-2023-44487 (HTTP/2 Rapid Reset) com múltiplos padrões de ataque, configuração granular e monitoramento para avaliações de segurança autorizadas. | Kitploit
Ferramentas/GitHubGitHub/gmh5225/cve_2023_44487-rapid_reset
Scanners de VulnerabilidadesExploraçãoSegurança WebSegurança de RedeTestes de Penetração
GitHubgmh5225/cve_2023_44487-rapid_reset

CVE_2023_44487-Rapid_Reset

Ferramenta de teste baseada em Python para CVE-2023-44487 (HTTP/2 Rapid Reset) com múltiplos padrões de ataque, configuração granular e monitoramento para avaliações de segurança autorizadas.

Ver Repositório
há 1 anoAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Ferramenta de Teste de Reset Rápido HTTP/2 CVE-2023-44487 - Edição Aprimorada

Uma ferramenta de teste abrangente em Python para CVE-2023-44487, a vulnerabilidade de Reset Rápido HTTP/2. Esta versão aprimorada fornece controle granular sobre parâmetros de teste, múltiplos padrões de ataque e recursos avançados de monitoramento.

⚠️ AVISO LEGAL IMPORTANTE

Esta ferramenta é apenas para fins educacionais e testes autorizados!

  • Use apenas contra sistemas que você possui ou para os quais tenha permissão explícita por escrito para testar
  • O uso não autorizado pode ser ilegal e pode causar interrupção de serviço
  • A ferramenta executa um ataque de Negação de Serviço que pode impactar a disponibilidade do servidor
  • Sempre garanta que você tenha autorização adequada antes de testar

🔍 Sobre CVE-2023-44487

CVE-2023-44487, também conhecida como "Reset Rápido HTTP/2", é uma vulnerabilidade crítica no protocolo HTTP/2 que permite que atacantes:

  • Causem negação de serviço enviando e cancelando rapidamente fluxos HTTP/2
  • Consumam recursos excessivos do servidor com recursos mínimos do cliente
  • Contornem muitos mecanismos tradicionais de limitação de taxa
  • Afetem os principais servidores web e balanceadores de carga

Pontuação CVSS: 7.5 (Alta)

Impacto: Negação de Serviço, Exaustão de Recursos

🚀 Recursos Aprimorados

Múltiplos Padrões de Ataque

  • ⚡ Reset Rápido: HEADERS padrão + RST_STREAM imediato
  • 💥 Reset em Rajada: Solicitações em rajadas com atrasos configuráveis
  • 📈 Reset Gradual: Taxa de ataque aumentando gradualmente
  • 🎲 Reset Aleatório: Temporização aleatória para contornar filtragem preditiva
  • 🌊 Inundação de Continuação: Ataque de inundação de quadros CONTINUATION
  • 🔀 Padrão Misto: Combinação de múltiplos padrões

Configuração Granular

  • 📡 Controles de Conexão: Timeouts, atrasos, limites de concorrência
  • ⏱️ Controles de Temporização: Temporização precisa com suporte a jitter
  • 🌐 Protocolo HTTP/2: Tamanhos de janela, tamanhos de quadro, configurações HPACK
  • 📋 Personalização de Cabeçalhos: Cabeçalhos personalizados, geração aleatória
  • 🔬 Opções Avançadas: Randomização de ID de fluxo, quadros de prioridade
  • 📊 Monitoramento: Rastreamento de latência, análise de tráfego, monitoramento de erros

Formatos de Saída

  • 🖥️ Console: Legível por humanos com atualizações de progresso
  • 📋 JSON: Dados estruturados legíveis por máquina
  • 📊 CSV: Compatível com planilhas para análise
  • 🗃️ XML: Integração com ferramentas empresariais

Recursos de Segurança

  • 🛡️ Controles de Autorização: Prompts de confirmação obrigatórios
  • 🔒 Limitação de Taxa: Limites integrados de conexão e solicitação
  • 🎛️ Tratamento de Erros: Tratamento gracioso de falhas
  • 📝 Trilha de Auditoria: Recursos abrangentes de registro

📋 Requisitos

  • Python 3.7 ou superior
  • Sem dependências externas (usa apenas a biblioteca padrão do Python)

📖 Instalação

  1. Clone ou baixe o script:
root@kitploit:~
git clone https://github.com/madhusudhan-in/CVE_2023_44487-Rapid_Reset.git
cd CVE_2023_44487-Rapid_Reset
  1. Torne o script executável:
root@kitploit:~
chmod +x rapid_reset_test.py
  1. Verifique a versão do Python:
root@kitploit:~
python3 --version  # Deve ser 3.7+

🔧 Uso

Uso Básico

root@kitploit:~
python3 rapid_reset_test.py https://servidor-alvo.com

Exemplos de Uso Avançado

1. Teste de Carga de Alto Rendimento

root@kitploit:~
python3 rapid_reset_test.py https://alvo.com \
    --connections 50 \
    --requests 1000 \
    --delay 0 \
    --pattern rapid_reset \
    --track-latency \
    --output json

2. Teste Furtivo com Cabeçalhos Personalizados

root@kitploit:~
python3 rapid_reset_test.py https://alvo.com \
    --pattern burst_reset \
    --burst-size 5 \
    --burst-delay 2.0 \
    --custom-headers "User-Agent: Mozilla/5.0 (legitbot)" "Authorization: Bearer token123" \
    --jitter 0.3

3. Teste Específico de Protocolo

root@kitploit:~
python3 rapid_reset_test.py https://alvo.com \
    --window-size 32768 \
    --frame-size 32768 \
    --header-table-size 8192 \
    --enable-push \
    --priority-frames \
    --randomize-streams

4. Teste Abrangente de Monitoramento

root@kitploit:~
python3 rapid_reset_test.py https://alvo.com \
    --connections 10 \
    --requests 200 \
    --pattern mixed_pattern \
    --track-latency \
    --track-responses \
    --monitor-memory \
    --verbose \
    --debug \
    --log-file attack.log

5. Ataque de Inundação CONTINUATION

root@kitploit:~
python3 rapid_reset_test.py https://alvo.com \
    --pattern continuation_flood \
    --requests 50 \
    --random-headers \
    --header-count 20

Opções Completas de Linha de Comando

Configurações de Conexão

OpçãoDescriçãoPadrão
-c, --connections NNúmero de conexões concorrentes1
--connection-timeout SECTimeout de conexão em segundos10
--read-timeout SECTimeout de leitura para respostas5
--connection-delay SECAtraso entre conexões0.0

Configurações de Solicitação

OpçãoDescriçãoPadrão
-r, --requests NSolicitações por conexão100
--delay SECAtraso entre HEADERS e RST_STREAM0.001
--request-delay SECAtraso entre solicitações0.0
--jitter FACTORFator de randomização de temporização0.0

Padrões de Ataque

OpçãoDescriçãoPadrão
--pattern TYPEPadrão de ataque a usarrapid_reset
--burst-size NSolicitações por rajada10
--burst-delay SECAtraso entre rajadas0.1

Padrões Disponíveis:

  • rapid_reset - Ataque padrão de reset rápido
  • burst_reset - Ataques baseados em rajadas
  • gradual_reset - Taxa aumentando gradualmente
  • random_reset - Temporização aleatória
  • continuation_flood - Inundação de quadros CONTINUATION
  • mixed_pattern - Mistura de padrões

Configurações do Protocolo HTTP/2

OpçãoDescriçãoPadrão
--window-size BYTESTamanho inicial da janela HTTP/265535
--frame-size BYTESTamanho máximo do quadro16384
--header-table-size BYTESTamanho da tabela de cabeçalhos HPACK4096
--enable-pushHabilitar push do servidor HTTP/2False
--rst-error-code CODECódigo de erro RST_STREAM8

Personalização de Cabeçalhos

OpçãoDescriçãoPadrão
--custom-headers HEADERCabeçalhos personalizados (Nome: Valor)None
--random-headersGerar cabeçalhos aleatóriosFalse
--header-count NNúmero de cabeçalhos aleatórios5

Opções Avançadas

OpçãoDescriçãoPadrão
--randomize-streamsUsar IDs de fluxo aleatóriosFalse
--priority-framesIncluir informações de prioridadeFalse
--continue-on-errorContinuar após errosTrue
--max-errors NErros máximos antes de parar10

Opções de Monitoramento

OpçãoDescriçãoPadrão
--track-latencyRastrear latência de solicitaçõesFalse
--track-responsesRastrear respostas do servidorFalse
--monitor-memoryMonitorar uso de memóriaFalse

Opções de Saída

OpçãoDescriçãoPadrão
--output FORMATFormato de saídaconsole
--output-file FILENome do arquivo de saídagerado automaticamente
--verbose, -vSaída detalhadaFalse
--debugRegistro de depuraçãoFalse
--log-file FILERegistrar em arquivoNone

Formatos de Saída Disponíveis:

  • console - Saída de console legível por humanos
  • json - JSON legível por máquina
  • csv - CSV compatível com planilhas
  • xml - Formato XML estruturado

📊 Entendendo os Resultados

Formato de Resultado Aprimorado

A ferramenta fornece resultados abrangentes incluindo:

  • Configuração do Ataque: Parâmetros completos do teste
  • Estatísticas de Conexão: Taxas de sucesso/falha por conexão
  • Análise de Tráfego: Bytes enviados/recebidos, taxas de solicitação
  • Métricas de Latência: Análise de temporização de solicitações (se habilitado)
  • Análise de Erros: Rastreamento e categorização detalhados de erros
  • Avaliação de Risco: Pontuação automatizada de vulnerabilidade

Estrutura de Exemplo de Saída JSON

root@kitploit:~
{
  "target_url": "https://example.com",
  "test_config": {
    "attack_pattern": "rapid_reset",
    "max_connections": 10,
    "requests_per_connection": 100,
    "delay_between_headers_rst": 0.001
  },
  "test_summary": {
    "duration": 2.34,
    "successful_connections": 10,
    "total_successful_attacks": 950,
    "success_rate": 95.0,
    "requests_per_second": 405.98,
    "total_bytes_sent": 125600,
    "average_latency": 0.0024
  },
  "connection_stats": [...],
  "errors": [...],
  "timestamp": 1640995200.0
}

Avaliação de Risco

A ferramenta avalia automaticamente a vulnerabilidade:

  • 🔴 ALTO RISCO (>80% de sucesso): Servidor provavelmente vulnerável
  • 🟡 RISCO MÉDIO (50-80% de sucesso): Vulnerabilidade parcial
  • 🟢 BAIXO RISCO (<50% de sucesso): Mitigações parecem eficazes

🔬 Detalhes Técnicos

Metodologias de Ataque

  1. Reset Rápido: Envia HEADERS imediatamente seguido por RST_STREAM
  2. Reset em Rajada: Agrupa solicitações em rajadas com atrasos configuráveis
  3. Reset Gradual: Aumenta progressivamente a intensidade do ataque
  4. Reset Aleatório: Usa padrões de temporização imprevisíveis
  5. Inundação de Continuação: Explora o processamento de quadros CONTINUATION
  6. Padrão Misto: Combina múltiplas técnicas

Implementação HTTP/2

  • Tratamento adequado do prefácio de conexão HTTP/2
  • Negociação de quadros SETTINGS com parâmetros personalizados
  • Opções avançadas de compressão de cabeçalhos HPACK
  • Multiplexação de fluxos com IDs de fluxo configuráveis
  • Estrutura de quadros em conformidade com RFC 7540
  • Suporte para extensões HTTP/2 e quadros de prioridade

Capacidades de Monitoramento

  • Rastreamento de Latência: Temporização com precisão de microssegundos
  • Análise de Tráfego: Monitoramento abrangente em nível de byte
  • Classificação de Erros: Categorização detalhada de erros
  • Métricas de Desempenho: Taxas de solicitação e análise de throughput
  • Depuração de Protocolo: Capacidades de inspeção em nível de quadro

🛡️ Estratégias de Mitigação

Se o seu servidor for encontrado vulnerável, implemente estas mitigações:

Ações Imediatas

  1. Atualize as implementações HTTP/2 para as versões mais recentes
  2. Habilite a limitação de taxa para fluxos e conexões HTTP/2
  3. Configure limites de conexão e timeouts de solicitação
  4. Implemente monitoramento e bloqueio de reset de fluxo

Proteções Avançadas

  1. Implante balanceadores de carga cientes de HTTP/2 com proteção contra ataques
  2. Configure limitação de taxa adaptativa com base em padrões de conexão
  3. Implemente priorização de solicitações e limites de alocação de recursos
  4. Monitore recursos do servidor e implemente alertas
  5. Use coalescência de conexões e controles de multiplexação

Monitoramento e Detecção

  1. Monitore taxas e padrões de RST_STREAM
  2. Acompanhe taxas de estabelecimento de conexão
  3. Implemente detecção de anomalias para tráfego HTTP/2
  4. Registre e analise padrões de ataque para proteção futura

🔗 Exemplos de Integração

Automação Python

root@kitploit:~
import subprocess
import json

# Executar teste automatizado
result = subprocess.run([
    'python3', 'rapid_reset_test.py',
    'https://alvo.com',
    '--pattern', 'mixed_pattern',
    '--output', 'json',
    '--output-file', 'results.json'
])

# Analisar resultados
with open('results.json') as f:
    data = json.load(f)
    vulnerability_score = data['test_summary']['success_rate']
    if vulnerability_score > 80:
        print(f"ALTO RISCO: {vulnerability_score}% taxa de sucesso")

Monitoramento Contínuo

root@kitploit:~
#!/bin/bash
# Trabalho cron: 0 2 * * * /caminho/para/monitor.sh

python3 rapid_reset_test.py https://meuservidor.com \
    --pattern rapid_reset \
    --connections 5 \
    --requests 50 \
    --output json \
    --output-file /var/log/rapid-reset-$(date +%Y%m%d).json

# Alertar se vulnerabilidade for detectada
if [ $(jq '.test_summary.success_rate' /var/log/rapid-reset-$(date +%Y%m%d).json) -gt 80 ]; then
    echo "ALERTA: Servidor vulnerável a ataque de reset rápido" | mail -s "Alerta de Segurança" [email protected]
fi

Análise de Dados

root@kitploit:~
import pandas as pd
import matplotlib.pyplot as plt

# Carregar e analisar resultados CSV
df = pd.read_csv('results.csv')

# Visualizar sucesso do ataque por conexão
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
df.plot(x='connection_id', y='successful_attacks', kind='bar')
plt.title('Sucesso do Ataque por Conexão')

plt.subplot(1, 2, 2)
df['success_rate'] = (df['successful_attacks'] / df['total_attacks']) * 100
plt.hist(df['success_rate'], bins=20)
plt.title('Distribuição da Taxa de Sucesso')
plt.show()

🐛 Solução de Problemas

Problemas Comuns

  1. Conexão recusada:

    • Verifique se o alvo suporta HTTP/2
    • Verifique firewall e conectividade de rede
    • Garanta que HTTPS esteja configurado corretamente
  2. Erros SSL/TLS:

    • Problemas de validação de certificado
    • Use --debug para informações SSL detalhadas
    • Verifique a negociação ALPN
  3. Baixas taxas de sucesso:

    • O servidor pode ter limitação de taxa habilitada
    • Tente diferentes padrões de ataque
    • Ajuste os parâmetros de temporização
  4. Problemas de desempenho:

    • Reduza o número de conexões para teste
    • Use --debug e --log-file para análise
    • Monitore recursos do sistema

Etapas de Depuração

  1. Habilite registro detalhado: --verbose --debug --log-file debug.log
  2. Teste com carga mínima: --connections 1 --requests 10
  3. Verifique suporte HTTP/2: Use ferramentas de desenvolvedor do navegador
  4. Verifique respostas do servidor: --track-responses
  5. Monitore latência: --track-latency

📄 Licença

Esta ferramenta é fornecida sob a Licença MIT. Consulte o arquivo LICENSE para detalhes.

🔗 Referências

  • Detalhes CVE-2023-44487
  • RFC 7540 - Especificação HTTP/2
  • Banco de Dados CVE do NIST
  • Análise Técnica da Cloudflare
  • Blog de Segurança do Google

⚖️ Aviso Legal

Esta ferramenta é destinada a profissionais de cibersegurança, pesquisadores e administradores de sistemas para testar seus próprios sistemas ou sistemas para os quais tenham permissão explícita para testar. Os autores não são responsáveis por qualquer uso indevido desta ferramenta.

Pontos Legais Principais:

  • Teste apenas sistemas que você possui ou para os quais tenha permissão por escrito para testar
  • Testes não autorizados podem violar leis de crimes de computador
  • Esta ferramenta pode causar interrupção real de serviço
  • Sempre informe as partes interessadas relevantes antes de testar
  • Use durante janelas de manutenção quando possível
  • Documente todas as atividades de teste para fins de auditoria

Lembre-se: Com grandes poderes vêm grandes responsabilidades. Use esta ferramenta de forma ética e legal.

🆕 Novidades na Versão Aprimorada

Recursos da Versão 2.0

  • ✅ 6 Padrões de Ataque: Múltiplos vetores de ataque sofisticados
  • ✅ Mais de 40 Opções de Configuração: Controle granular sobre todos os parâmetros
  • ✅ 4 Formatos de Saída: Suporte a Console, JSON, CSV, XML
  • ✅ Monitoramento Avançado: Rastreamento de latência, análise de tráfego, monitoramento de erros
  • ✅ Personalização de Protocolo: Tamanhos de janela HTTP/2, tamanhos de quadro, configurações HPACK
  • ✅ Manipulação de Cabeçalhos: Cabeçalhos personalizados, geração aleatória, inundações CONTINUATION
  • ✅ Controles de Temporização: Suporte a jitter, padrões de rajada, escalada gradual
  • ✅ Aprimoramentos de Segurança: Melhor limitação de taxa, tratamento de erros, trilhas de auditoria
  • ✅ Pronto para Integração: Saída JSON/CSV para automação e análise

Migração da Versão Básica

A versão aprimorada mantém compatibilidade retroativa com a versão básica. Todas as opções de linha de comando existentes continuam funcionando, com novas opções fornecendo capacidades adicionais.

Para usuários que estão atualizando da versão básica:

root@kitploit:~
# O uso básico antigo ainda funciona
python3 rapid_reset_test.py https://example.com --connections 5 --requests 100

# Novo uso aprimorado com opções adicionais
python3 rapid_reset_test.py https://example.com \
    --connections 5 --requests 100 \
    --pattern burst_reset --track-latency --output json
Baixar ferramenta