TLS-Attacker

TLS-Attacker est un framework basé sur Java pour analyser les bibliothèques TLS. Il est capable d'envoyer des messages de protocole arbitraires dans un ordre arbitraire au pair TLS, et de définir leurs modifications via une interface fournie. Cela offre au développeur la possibilité de définir facilement un flux de protocole TLS personnalisé et de le tester contre sa bibliothèque TLS.

Veuillez noter : TLS-Attacker est un outil de recherche destiné aux développeurs TLS et aux pentesteurs. Il n'y a pas d'interface graphique ni de feux verts/rouges.

Compilation et exécution

Pour compiler et utiliser TLS-Attacker, vous devez avoir Java et Maven installés. Sur Ubuntu, vous pouvez installer Maven en exécutant :

$ sudo apt-get install maven

TLS-Attacker nécessite actuellement Java JDK 21 pour fonctionner.

Si vous avez la version correcte de Java, vous pouvez exécuter la commande Maven depuis le répertoire TLS-Attacker :

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

Sinon, si vous êtes pressé, vous pouvez ignorer les tests en utilisant :

$ mvn clean install -DskipTests=true

Les fichiers jar résultants sont placés dans le dossier « apps ».

Si vous souhaitez utiliser ce projet comme dépendance, vous n'avez pas besoin de le compiler vous-même et pouvez l'inclure dans votre pom.xml comme suit.

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

TLS-Attacker est livré avec des applications de démonstration qui vous donnent un accès facile aux fonctionnalités de TLS-Attacker.

Vous pouvez exécuter TLS-Attacker en tant que client avec la commande suivante :

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

ou en tant que serveur avec :

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

Bien que ces exemples d'applications soient très puissants en eux-mêmes, TLS-Attacker déploie tout son potentiel lorsqu'il est utilisé comme bibliothèque de programmation.

Structure du code

TLS-Attacker se compose de plusieurs projets (Maven) :

• TLS-Client : L'application exemple client
• TLS-Core : La pile de protocoles et le cœur de TLS-Attacker
• TLS-Mitm : Un prototype pour les workflows MitM
• TLS-Server : L'application exemple serveur
• TLS-Proxy : Utiliser TLS-Attacker pour les SSLSockets
• TraceTool : Inspection et modification des traces de workflow de TLS-Attacker
• Transport : Utilitaires de transport pour les couches inférieures
• Utils : Une collection de classes utilitaires

Vous trouverez plus d'informations sur ces modules dans le Wiki.

Fonctionnalités

Actuellement, les fonctionnalités suivantes sont prises en charge :

• SSL 3, versions TLS 1.0 (RFC-2246), 1.1 (RFC-4346), 1.2 (RFC-5246) et 1.3 (RFC-8446)
• SSL 2 (partiellement pris en charge)
• Algorithmes d'échange de clés (EC)DH(E), RSA, PSK, SRP, GOST et ANON
• Chiffrement CBC, AEAD et par flux (AES, CAMELLIA, DES, 3DES, IDEA, RC2, ARIA, GOST_28147_CNT_IMIT, RC4, SEED, NULL)
• ~300 suites de chiffrement, ~30 extensions
• Client et serveur
• HTTPS
• Workflows avec plus de deux parties
• Beaucoup d'extensions
• Tokenbinding (EC) et Tokenbinding sur HTTP
• Sockets
• TLS 1.3 0-RTT
• STARTTLS
• ...

Utilisation

Voici quelques exemples très simples d'utilisation de TLS-Attacker.

Tout d'abord, vous devez démarrer un serveur TLS (veuillez ne pas utiliser de serveurs publics). Exécutez le script keygen.sh si ce n'est pas déjà fait. Par exemple, vous pouvez utiliser un serveur de test OpenSSL :

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

Cette commande démarre un serveur TLS sur le port 4433.

Si vous souhaitez vous connecter à un serveur, vous pouvez utiliser cette commande :

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

Remarque : Si cette poignée de main échoue, c'est probablement parce que vous n'avez pas spécifié une suite de chiffrement concrète. TLS-Attacker ne respectera pas complètement les suites de chiffrement sélectionnées par le serveur.

Vous pouvez utiliser une suite de chiffrement différente, une version TLS différente ou vous connecter à un port différent avec les paramètres suivants :

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

Si vous êtes un développeur plus expérimenté, vous pouvez créer votre propre flux de messages TLS en écrivant du code Java. Par exemple :

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 utilise le concept de WorkflowTraces pour définir un « flux de messages TLS ». Un WorkflowTrace consiste en une liste d'actions qui sont ensuite exécutées les unes après les autres. Bien que pour un « flux de messages TLS » typique, seules des SendAction et ReceiveAction soient nécessaires, le framework ne s'arrête pas là et implémente beaucoup d'autres actions qui peuvent être utilisées pour exécuter des flux de messages encore plus arbitraires. Une liste des actions actuellement implémentées avec des explications se trouve dans le Wiki.

Nous savons que beaucoup d'entre vous détestent Java. Par conséquent, vous pouvez également utiliser une structure XML et exécuter votre protocole TLS personnalisé à partir de XML :

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workflowTrace>
    <!-- Envoyer ClientHello -->
    <Send>
        <configuredMessages>
            <ClientHello>
                <extensions>
                    <ECPointFormat/>
                    <EllipticCurves/>
                    <SignatureAndHashAlgorithmsExtension/>
                    <RenegotiationInfoExtension/>
                </extensions>
            </ClientHello>
        </configuredMessages>
        <configuredRecords>
            <record/>
        </configuredRecords>
    </Send>
    
    <!-- Recevoir la réponse du serveur -->
    <Receive>
        <expectedMessages>
            <ServerHello>
                <extensions>
                    <ECPointFormat/>
                    <RenegotiationInfoExtension/>
                </extensions>
            </ServerHello>
            <Certificate/>
            <ServerHelloDone/>
        </expectedMessages>
    </Receive>
    
    <!-- Envoyer l'échange de clés client et la fin -->
    <Send>
        <configuredMessages>
            <RSAClientKeyExchange/>
            <ChangeCipherSpec/>
            <Finished/>
        </configuredMessages>
        <configuredRecords>
            <record/>
            <record/>
            <record/>
        </configuredRecords>
    </Send>
    
    <!-- Recevoir la fin du serveur -->
    <Receive>
        <expectedMessages>
            <ChangeCipherSpec/>
            <Finished/>
        </expectedMessages>
    </Receive>
</workflowTrace>

Si cette structure XML se trouve dans TLS-Attacker/apps/workflow.xml, il suffit d'exécuter :

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

Système Protocol-Attacker / Couche