Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE_2023_44487-Rapid_Reset — Strumento di test basato su Python per CVE-2023-44487 (HTTP/2 Rapid Reset) con molteplici modelli di attacco, configurazione granulare e monitoraggio per valutazioni di sicurezza autorizzate. | Kitploit
Strumenti/GitHubGitHub/gmh5225/cve_2023_44487-rapid_reset
Scanner di VulnerabilitàExploitSicurezza WebSicurezza di RetePenetration Testing
GitHubgmh5225/cve_2023_44487-rapid_reset

CVE_2023_44487-Rapid_Reset

Strumento di test basato su Python per CVE-2023-44487 (HTTP/2 Rapid Reset) con molteplici modelli di attacco, configurazione granulare e monitoraggio per valutazioni di sicurezza autorizzate.

Vedi Repository
1 anno faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2023-44487 Strumento di Test HTTP/2 Rapid Reset - Edizione Potenziata

Uno strumento di test Python completo per CVE-2023-44487, la vulnerabilità HTTP/2 Rapid Reset. Questa versione potenziata fornisce un controllo granulare sui parametri di test, molteplici modelli di attacco e funzionalità di monitoraggio avanzate.

⚠️ DISCLAIMER IMPORTANTE

Questo strumento è destinato SOLO a scopi educativi e test autorizzati!

  • Utilizzalo esclusivamente contro sistemi di tua proprietà o per i quali disponi di esplicita autorizzazione scritta
  • L'uso non autorizzato può essere illegale e potrebbe causare interruzioni del servizio
  • Lo strumento esegue un attacco Denial of Service che può compromettere la disponibilità del server
  • Assicurati sempre di avere la dovuta autorizzazione prima di effettuare test

🔍 Informazioni su CVE-2023-44487

CVE-2023-44487, nota anche come "HTTP/2 Rapid Reset," è una vulnerabilità critica nel protocollo HTTP/2 che consente agli aggressori di:

  • Causare denial of service inviando e annullando rapidamente stream HTTP/2
  • Consumare risorse server eccessive con risorse client minime
  • Bypassare molti meccanismi tradizionali di rate limiting
  • Colpire i principali web server e load balancer

Punteggio CVSS: 7.5 (Alto)

Denial of Service, Esaurimento delle Risorse

Impatto:

🚀 Funzionalità Potenziate

Molteplici Modelli di Attacco

  • ⚡ Rapid Reset: HEADERS standard + RST_STREAM immediato
  • 💥 Burst Reset: Richieste a raffiche con ritardi configurabili
  • 📈 Gradual Reset: Tasso di attacco in aumento graduale
  • 🎲 Random Reset: Temporizzazione casuale per bypassare i filtri predittivi
  • 🌊 Continuation Flood: Attacco di flooding con frame CONTINUATION
  • 🔀 Modello Misto: Combinazione di più modelli

Configurazione Granulare

  • 📡 Controlli di Connessione: Timeout, ritardi, limiti di concorrenza
  • ⏱️ Controlli di Temporizzazione: Temporizzazione precisa con supporto jitter
  • 🌐 Protocollo HTTP/2: Dimensioni finestra, dimensioni frame, impostazioni HPACK
  • 📋 Personalizzazione Header: Header personalizzati, generazione casuale
  • 🔬 Opzioni Avanzate: Randomizzazione ID stream, frame di priorità
  • 📊 Monitoraggio: Tracciamento latenza, analisi traffico, monitoraggio errori

Formati di Output

  • 🖥️ Console: Leggibile dall'uomo con aggiornamenti di avanzamento
  • 📋 JSON: Dati strutturati leggibili dalla macchina
  • 📊 CSV: Compatibile con fogli di calcolo per analisi
  • 🗃️ XML: Integrazione con strumenti aziendali

Funzionalità di Sicurezza

  • 🛡️ Controlli di Autorizzazione: Prompt di conferma obbligatori
  • 🔒 Rate Limiting: Limiti integrati di connessione e richiesta
  • 🎛️ Gestione Errori: Gestione corretta dei guasti
  • 📝 Audit Trail: Funzionalità di logging complete

📋 Requisiti

  • Python 3.7 o superiore
  • Nessuna dipendenza esterna (utilizza solo la libreria standard di Python)

📖 Installazione

  1. Clona o scarica lo script:
root@kitploit:~
git clone https://github.com/madhusudhan-in/CVE_2023_44487-Rapid_Reset.git
cd CVE_2023_44487-Rapid_Reset
  1. Rendi eseguibile lo script:
root@kitploit:~
chmod +x rapid_reset_test.py
  1. Verifica la versione di Python:
root@kitploit:~
python3 --version  # Dovrebbe essere 3.7+

🔧 Utilizzo

Utilizzo Base

root@kitploit:~
python3 rapid_reset_test.py https://target-server.com

Esempi di Utilizzo Avanzato

1. Test di Carico ad Alto Throughput

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

2. Test Stealth con Header Personalizzati

root@kitploit:~
python3 rapid_reset_test.py https://target.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. Test Specifico del Protocollo

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

4. Test di Monitoraggio Completo

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

5. Attacco CONTINUATION Flood

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

Opzioni Complete della Riga di Comando

Impostazioni di Connessione

OpzioneDescrizionePredefinito
-c, --connections NNumero di connessioni concorrenti1
--connection-timeout SECTimeout di connessione in secondi10
--read-timeout SECTimeout di lettura per le risposte5
--connection-delay SECRitardo tra le connessioni0.0

Impostazioni delle Richieste

OpzioneDescrizionePredefinito
-r, --requests NRichieste per connessione100
--delay SECRitardo tra HEADERS e RST_STREAM0.001
--request-delay SECRitardo tra le richieste0.0
--jitter FACTORFattore di randomizzazione della temporizzazione0.0

Modelli di Attacco

OpzioneDescrizionePredefinito
--pattern TYPEModello di attacco da utilizzarerapid_reset
--burst-size NRichieste per raffica10
--burst-delay SECRitardo tra le raffiche0.1

Modelli Disponibili:

  • rapid_reset - Attacco rapid reset standard
  • burst_reset - Attacchi basati su raffiche
  • gradual_reset - Tasso in aumento graduale
  • random_reset - Temporizzazione casuale
  • continuation_flood - Flooding con frame CONTINUATION
  • mixed_pattern - Mix di modelli

Impostazioni del Protocollo HTTP/2

OpzioneDescrizionePredefinito
--window-size BYTESDimensione finestra iniziale HTTP/265535
--frame-size BYTESDimensione massima frame16384
--header-table-size BYTESDimensione tabella header HPACK4096
--enable-pushAbilita server push HTTP/2False
--rst-error-code CODECodice errore RST_STREAM8

Personalizzazione Header

OpzioneDescrizionePredefinito
--custom-headers HEADERHeader personalizzati (Nome: Valore)None
--random-headersGenera header casualiFalse
--header-count NNumero di header casuali5

Opzioni Avanzate

OpzioneDescrizionePredefinito
--randomize-streamsUtilizza ID stream casualiFalse
--priority-framesIncludi informazioni di prioritàFalse
--continue-on-errorContinua dopo gli erroriTrue
--max-errors NErrori massimi prima dell'arresto10

Opzioni di Monitoraggio

OpzioneDescrizionePredefinito
--track-latencyTraccia la latenza delle richiesteFalse
--track-responsesTraccia le risposte del serverFalse
--monitor-memoryMonitora l'utilizzo della memoriaFalse

Opzioni di Output

OpzioneDescrizionePredefinito
--output FORMATFormato di outputconsole
--output-file FILENome del file di outputgenerato automaticamente
--verbose, -vOutput dettagliatoFalse
--debugLog di debugFalse
--log-file FILEScrivi log su fileNone

Formati di Output Disponibili:

  • console - Output console leggibile dall'uomo
  • json - JSON leggibile dalla macchina
  • csv - CSV compatibile con fogli di calcolo
  • xml - Formato XML strutturato

📊 Comprensione dei Risultati

Formato dei Risultati Potenziato

Lo strumento fornisce risultati completi tra cui:

  • Configurazione dell'Attacco: Parametri di test completi
  • Statistiche di Connessione: Tassi di successo/fallimento per connessione
  • Analisi del Traffico: Byte inviati/ricevuti, tassi di richiesta
  • Metriche di Latenza: Analisi della temporizzazione delle richieste (se abilitata)
  • Analisi degli Errori: Tracciamento e categorizzazione dettagliata degli errori
  • Valutazione del Rischio: Punteggio automatico della vulnerabilità

Struttura di Esempio dell'Output 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
}

Valutazione del Rischio

Lo strumento valuta automaticamente la vulnerabilità:

  • 🔴 RISCHIO ALTO (>80% di successo): Il server è probabilmente vulnerabile
  • 🟡 RISCHIO MEDIO (50-80% di successo): Vulnerabilità parziale
  • 🟢 RISCHIO BASSO (<50% di successo): Le mitigazioni sembrano efficaci

🔬 Dettagli Tecnici

Metodologie di Attacco

  1. Rapid Reset: Invia HEADERS immediatamente seguito da RST_STREAM
  2. Burst Reset: Raggruppa le richieste in raffiche con ritardi configurabili
  3. Gradual Reset: Aumenta progressivamente l'intensità dell'attacco
  4. Random Reset: Utilizza modelli di temporizzazione imprevedibili
  5. Continuation Flood: Sfrutta l'elaborazione dei frame CONTINUATION
  6. Modello Misto: Combina più tecniche

Implementazione HTTP/2

  • Gestione corretta del prefisso di connessione HTTP/2
  • Negoziazione dei frame SETTINGS con parametri personalizzati
  • Opzioni avanzate di compressione header HPACK
  • Multiplexing degli stream con ID stream configurabili
  • Struttura dei frame conforme a RFC 7540
  • Supporto per estensioni HTTP/2 e frame di priorità

Funzionalità di Monitoraggio

  • Tracciamento Latenza: Temporizzazione con precisione al microsecondo
  • Analisi del Traffico: Monitoraggio completo a livello di byte
  • Classificazione Errori: Categorizzazione dettagliata degli errori
  • Metriche di Prestazione: Analisi dei tassi di richiesta e throughput
  • Debug del Protocollo: Funzionalità di ispezione a livello di frame

🛡️ Strategie di Mitigazione

Se il tuo server risulta vulnerabile, implementa queste mitigazioni:

Azioni Immediate

  1. Aggiorna le implementazioni HTTP/2 alle versioni più recenti
  2. Abilita il rate limiting per stream e connessioni HTTP/2
  3. Configura i limiti di connessione e i timeout delle richieste
  4. Implementa il monitoraggio e il blocco dei reset degli stream

Protezioni Avanzate

  1. Distribuisci load balancer consapevoli di HTTP/2 con protezione dagli attacchi
  2. Configura il rate limiting adattivo basato sui modelli di connessione
  3. Implementa la prioritizzazione delle richieste e i limiti di allocazione delle risorse
  4. Monitora le risorse del server e implementa sistemi di allerta
  5. Utilizza il coalescing delle connessioni e i controlli di multiplexing

Monitoraggio e Rilevamento

  1. Monitora i tassi di RST_STREAM e i relativi modelli
  2. Traccia i tassi di stabilimento delle connessioni
  3. Implementa il rilevamento delle anomalie per il traffico HTTP/2
  4. Registra e analizza i modelli di attacco per la protezione futura

🔗 Esempi di Integrazione

Automazione Python

root@kitploit:~
import subprocess
import json

# Esegui test automatizzato
result = subprocess.run([
    'python3', 'rapid_reset_test.py',
    'https://target.com',
    '--pattern', 'mixed_pattern',
    '--output', 'json',
    '--output-file', 'results.json'
])

# Analizza i risultati
with open('results.json') as f:
    data = json.load(f)
    vulnerability_score = data['test_summary']['success_rate']
    if vulnerability_score > 80:
        print(f"RISCHIO ALTO: {vulnerability_score}% tasso di successo")

Monitoraggio Continuo

root@kitploit:~
#!/bin/bash
# Cron job: 0 2 * * * /path/to/monitor.sh

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

# Invia allerta se viene rilevata una vulnerabilità
if [ $(jq '.test_summary.success_rate' /var/log/rapid-reset-$(date +%Y%m%d).json) -gt 80 ]; then
    echo "ALLERTA: Il server è vulnerabile all'attacco rapid reset" | mail -s "Allerta di Sicurezza" [email protected]
fi

Analisi dei Dati

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

# Carica e analizza i risultati CSV
df = pd.read_csv('results.csv')

# Visualizza il successo dell'attacco per connessione
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
df.plot(x='connection_id', y='successful_attacks', kind='bar')
plt.title('Successo dell\'Attacco per Connessione')

plt.subplot(1, 2, 2)
df['success_rate'] = (df['successful_attacks'] / df['total_attacks']) * 100
plt.hist(df['success_rate'], bins=20)
plt.title('Distribuzione del Tasso di Successo')
plt.show()

🐛 Risoluzione dei Problemi

Problemi Comuni

  1. Connessione rifiutata:

    • Verifica che il target supporti HTTP/2
    • Controlla firewall e connettività di rete
    • Assicurati che HTTPS sia configurato correttamente
  2. Errori SSL/TLS:

    • Problemi di validazione del certificato
    • Utilizza --debug per informazioni SSL dettagliate
    • Controlla la negoziazione ALPN
  3. Tassi di successo bassi:

    • Il server potrebbe avere il rate limiting abilitato
    • Prova diversi modelli di attacco
    • Regola i parametri di temporizzazione
  4. Problemi di prestazione:

    • Riduci il numero di connessioni per il test
    • Utilizza --debug e --log-file per l'analisi
    • Monitora le risorse di sistema

Passaggi di Debug

  1. Abilita il logging dettagliato: --verbose --debug --log-file debug.log
  2. Testa con carico minimo: --connections 1 --requests 10
  3. Verifica il supporto HTTP/2: Utilizza gli strumenti di sviluppo del browser
  4. Controlla le risposte del server: --track-responses
  5. Monitora la latenza: --track-latency

📄 Licenza

Questo strumento è fornito sotto la Licenza MIT. Consulta il file LICENSE per i dettagli.

🔗 Riferimenti

  • Dettagli CVE-2023-44487
  • RFC 7540 - Specifica HTTP/2
  • Database CVE NIST
  • Analisi Tecnica Cloudflare
  • Blog sulla Sicurezza Google

⚖️ Avviso Legale

Questo strumento è destinato a professionisti della cybersecurity, ricercatori e amministratori di sistema per testare i propri sistemi o sistemi per i quali dispongono di esplicita autorizzazione. Gli autori non sono responsabili di qualsiasi uso improprio di questo strumento.

Punti Legali Chiave:

  • Testa solo sistemi di tua proprietà o per i quali hai autorizzazione scritta
  • I test non autorizzati possono violare le leggi sui crimini informatici
  • Questo strumento può causare reali interruzioni del servizio
  • Informa sempre le parti interessate prima di effettuare test
  • Utilizza durante le finestre di manutenzione quando possibile
  • Documenta tutte le attività di test per scopi di audit

Ricorda: Da un grande potere deriva una grande responsabilità. Utilizza questo strumento in modo etico e legale.

🆕 Novità nella Versione Potenziata

Funzionalità della Versione 2.0

  • ✅ 6 Modelli di Attacco: Molteplici vettori di attacco sofisticati
  • ✅ 40+ Opzioni di Configurazione: Controllo granulare su tutti i parametri
  • ✅ 4 Formati di Output: Supporto Console, JSON, CSV, XML
  • ✅ Monitoraggio Avanzato: Tracciamento latenza, analisi traffico, monitoraggio errori
  • ✅ Personalizzazione del Protocollo: Dimensioni finestra HTTP/2, dimensioni frame, impostazioni HPACK
  • ✅ Manipolazione Header: Header personalizzati, generazione casuale, flooding CONTINUATION
  • ✅ Controlli di Temporizzazione: Supporto jitter, modelli a raffica, escalation graduale
  • ✅ Miglioramenti della Sicurezza: Migliore rate limiting, gestione errori, audit trail
  • ✅ Pronto per l'Integrazione: Output JSON/CSV per automazione e analisi

Migrazione dalla Versione Base

La versione potenziata mantiene la compatibilità con la versione base. Tutte le opzioni esistenti della riga di comando continuano a funzionare, con nuove opzioni che forniscono funzionalità aggiuntive.

Per gli utenti che passano dalla versione base:

root@kitploit:~
# Il vecchio utilizzo base funziona ancora
python3 rapid_reset_test.py https://example.com --connections 5 --requests 100

# Nuovo utilizzo potenziato con opzioni aggiuntive
python3 rapid_reset_test.py https://example.com \
    --connections 5 --requests 100 \
    --pattern burst_reset --track-latency --output json
Scarica lo strumento