tls-attacker/tls-attackerFramework 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à.
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.
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.
TLS-Attacker è composto da diversi progetti (maven):
Puoi trovare maggiori informazioni su questi moduli nel Wiki.
Attualmente, sono supportate le seguenti funzionalità:
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
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.