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-2002-1120 — Classico buffer overflow basato sullo stack in Savant Web Server 3.1 che dimostra la corruzione remota della memoria dei primi anni 2000 tramite una richiesta HTTP predisposta. | Kitploit
Strumenti/GitHubGitHub/themalwareguardian/cve-2002-1120
Analisi delle VulnerabilitàExploitReverse EngineeringShellcodeDebuggerSicurezza WebFuzzingPenetration TestingApprendimento e FormazioneSviluppo PayloadBinary Exploitation
GitHubthemalwareguardian/cve-2002-1120

CVE-2002-1120

Classico buffer overflow basato sullo stack in Savant Web Server 3.1 che dimostra la corruzione remota della memoria dei primi anni 2000 tramite una richiesta HTTP predisposta.

Vedi Repository
14 mesi 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-2002-1120: Savant Web Server 3.1 - Buffer Overflow basato su stack (Egghunter)

Classico buffer overflow basato su stack in Savant Web Server 3.1 che dimostra la corruzione della memoria remota dei primi anni 2000 attraverso una richiesta HTTP appositamente realizzata (una vulnerabilità del 2002 che richiede di più a un principiante rispetto alla maggior parte dei buffer overflow CVE del 2025).




📑 Indice

  • Perché questo repository esiste
  • Perché questa vulnerabilità è interessante
  • Contesto e software interessato
  • Sulla vulnerabilità
  • Attivazione del crash
  • Sfruttamento



🎓 Perché questo repository esiste

Questo repository fa parte del materiale che utilizzo quando insegno lo sfruttamento della corruzione della memoria (oltre al mio lavoro regolare, insegno anche in diversi corsi di cybersecurity dove aiuto a formare la prossima generazione di reverse engineer). Quando in classe tratto i buffer overflow basati su stack, analizzo casi reali piuttosto che esempi giocattolo, e questo CVE è uno a cui ritorno specificamente quando voglio mettere alla prova studenti che hanno già una certa esperienza con le sovrascritture di base di EIP.

Il motivo è che l'anno in un identificatore CVE non dice nulla sulla difficoltà dello sfruttamento. La maggior parte degli studenti presume che i CVE più vecchi debbano essere più semplici: un overflow diretto, un JMP ESP, fatto. Questo dimostra il contrario. Alcuni CVE che insegno del 2025 sono fondamentalmente più basilari di questo, perché la classe di vulnerabilità è più semplice o i vincoli sono minori. CVE-2002-1120 richiede la comprensione di cose che alcuni exploit moderni non richiedono: perché certi opcode non possono essere usati in certe parti della richiesta, come costruire un salto condizionale che scatta sempre quando quello incondizionato è bloccato, come consegnare shellcode quando non entra dove lo metteresti normalmente, e come un egghunter risolve un problema di spazio che altrimenti renderebbe impossibile l'exploit.

È il CVE che assegno quando voglio vedere se qualcuno capisce davvero cosa sta facendo.




💡 Perché questa vulnerabilità è interessante

Questa vulnerabilità colpisce Savant 3.1, un server HTTP freeware per Windows del 2002. Ciò che la rende degna di studio nel 2025 non è l'età, ma la combinazione di vincoli che introduce e le tecniche necessarie per aggirarli:

  • Nessuno spazio dopo EIP. Il buffer utilizzabile è di circa 267 byte prima dell'indirizzo di ritorno. Oltre non si raggiunge il buffer vulnerabile, quindi lo shellcode non può essere posizionato nella solita posizione dopo EIP.
  • Il campo del metodo HTTP è eseguibile. Savant copia il metodo in memoria e lo esegue. I byte che normalmente dicono GET vengono trattati come codice, il che significa che un attaccante può posizionare opcode lì, ma solo opcode che sopravvivono a un filtro rigoroso di caratteri non validi.
  • Due liste separate di caratteri non validi. L'URI e il campo del metodo hanno logiche di filtraggio diverse all'interno di Savant. Entrambi devono essere analizzati indipendentemente. La zona del metodo blocca un insieme molto più ampio di byte rispetto all'URI.
  • Il JMP incondizionato è un carattere non valido. \xeb non supera il filtro della zona del metodo. Un salto condizionale che scatta sempre deve essere costruito manualmente usando tre opcode: caricare un valore in un registro, confrontarlo con un valore più piccolo e saltare se il risultato non è minore o uguale.
  • Lo shellcode non entra. Anche con il salto funzionante e l'esecuzione che atterra nel buffer URI, ~264 byte non bastano per una reverse shell. Il payload reale deve andare altrove, nel corpo HTTP, che Savant memorizza in una regione heap separata dallo stack, e un egghunter è necessario per localizzarlo a runtime.

Ognuno di questi vincoli è una lezione a sé stante.




🔍 Contesto e software interessato

Savant è un server HTTP freeware open-source per Windows progettato originariamente per trasformare qualsiasi computer desktop in un server web. Ascolta sulla porta TCP 80 e processa le normali richieste HTTP GET. L'overflow si verifica nel gestore che copia il percorso URI in un buffer stack di dimensione fissa senza verificarne la lunghezza.

Dettagli tecnici chiave:

  • Tipo di vulnerabilità: Buffer overflow basato su stack
  • Versione interessata: Savant Web Server 3.1
  • Endpoint interessato: Richiesta HTTP GET
  • Componente vulnerabile: Gestione del percorso URI nel gestore GET
  • Autenticazione richiesta: No
  • Impatto: Esecuzione di codice remota



⚠️ Sulla vulnerabilità

Savant processa le richieste HTTP GET in arrivo e copia il percorso URI in un buffer stack di dimensione fissa senza controllarne la lunghezza. Una versione semplificata della logica vulnerabile appare così:

root@kitploit:~
char uri_buffer[270];

strcpy(uri_buffer, uri_path);

L'invio di una richiesta GET con un URI di circa 271 byte sovrascrive l'indirizzo di ritorno salvato sullo stack. L'overflow è limitato: inviare molto più di questo fa crashare in modo tale che EIP non è più controllabile, quindi la finestra utilizzabile è stretta.

Lo sfruttamento è più complesso di una normale sovrascrittura di EIP a causa di due proprietà aggiuntive del server: anche il campo del metodo HTTP viene copiato in memoria ed eseguito, e il corpo della richiesta HTTP viene memorizzato in una regione heap separata invece che sullo stack (entrambe queste proprietà diventano parti essenziali della catena di exploit).




💥 Attivazione del crash

Il crash può essere riprodotto inviando una richiesta GET con un URI sufficientemente lungo. Non è richiesta autenticazione. Esempio con Python:

root@kitploit:~
import socket

HOST = '127.0.0.1'
PORT = 80

payload = b"A" * 271

request = (
	b"GET /" + payload + b" HTTP/1.1\r\n"
	b"Host: 127.0.0.1\r\n"
	b"Connection: close\r\n"
	b"\r\n"
)

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send(request)
s.close()
Scarica lo strumento

Eseguito sotto un debugger, il crash mostra EIP sovrascritto con dati controllati dall'utente:

root@kitploit:~
EIP = 41414141

Confermando che l'indirizzo di ritorno salvato è stato corrotto dall'overflow.




💣 Sfruttamento

L'obiettivo di questo repository non è solo dimostrare il crash, ma illustrare l'intero processo di sfruttamento passo dopo passo, inclusi ogni vincolo che rende questo caso più difficile di una normale sovrascrittura di EIP e ogni decisione presa per aggirarli.

Per mantenere il README principale pulito, le note dettagliate sullo sfruttamento, gli script e i passaggi del debugger sono inseriti nella cartella Vulnerability 📂 di questo repository.

Lì troverai il flusso di lavoro completo utilizzato per sfruttare questo CVE, tra cui:

  • Fuzzing dell'URI GET per identificare la finestra di crash.
  • Scoperta manuale dell'offset (i pattern ciclici non possono essere usati qui).
  • Analisi dei caratteri non validi per la zona URI e per il campo del metodo HTTP separatamente.
  • Trovare un gadget POP / RET in Savant.exe per la sovrascrittura di EIP.
  • Confermare che l'esecuzione cada nel campo del metodo dopo l'attivazione del gadget.
  • Costruire un salto condizionale JNLE per raggiungere il buffer URI dal campo del metodo.
  • Localizzare il corpo HTTP nell'heap e misurare lo spazio disponibile.
  • Posizionare un egghunter nel buffer URI e lo shellcode taggato con l'uovo nel corpo HTTP.