TLS-Attacker

GitHub release (latest by date)

TLS-Attacker es un framework basado en Java para analizar bibliotecas TLS. Es capaz de enviar mensajes de protocolo arbitrarios en un orden arbitrario al par TLS, y definir sus modificaciones utilizando una interfaz proporcionada. Esto le brinda al desarrollador la oportunidad de definir fácilmente un flujo de protocolo TLS personalizado y probarlo contra su biblioteca TLS.

Tenga en cuenta: TLS-Attacker es una herramienta de investigación destinada a desarrolladores TLS y pentesters. No tiene interfaz gráfica ni luces verdes/rojas.

Compilación y Ejecución

Para compilar y usar TLS-Attacker, necesita tener Java y Maven instalados. En Ubuntu puede instalar Maven ejecutando:

$ sudo apt-get install maven

TLS-Attacker actualmente necesita Java JDK 21 para funcionar.

Si tiene la versión correcta de Java, puede ejecutar el comando de Maven desde el directorio de TLS-Attacker:

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

Alternativamente, si tiene prisa, puede omitir las pruebas usando:

$ mvn clean install -DskipTests=true

Los archivos jar resultantes se colocan en la carpeta "apps".

Si desea usar este proyecto como dependencia, no tiene que compilarlo usted mismo y puede incluirlo en su pom.xml de la siguiente manera.

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

TLS-Attacker incluye aplicaciones demo que le proporcionan un acceso fácil a la funcionalidad de TLS-Attacker.

Puede ejecutar TLS-Attacker como cliente con el siguiente comando:

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

o como servidor con:

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

Aunque estas aplicaciones de ejemplo son muy potentes por sí mismas, TLS-Attacker despliega todo su potencial cuando se usa como biblioteca de programación.

Estructura del Código

TLS-Attacker consta de varios proyectos (maven):

TLS-Client: La aplicación de ejemplo de cliente
TLS-Core: La pila de protocolos y el corazón de TLS-Attacker
TLS-Mitm: Un prototipo para flujos de trabajo MitM
TLS-Server: La aplicación de ejemplo de servidor
TLS-Proxy: Usar TLS-Attacker para SSLSockets
TraceTool: Inspección y modificación de trazas de flujo de trabajo de TLS-Attacker
Transport: Utilidades de transporte para capas inferiores
Utils: Una colección de clases de utilidad

Diseño de TLS-Attacker

Puede encontrar más información sobre estos módulos en la Wiki.

Características

Actualmente, se admiten las siguientes características:

SSL 3, versiones TLS 1.0 (RFC-2246), 1.1 (RFC-4346), 1.2 (RFC-5246) y 1.3 (RFC-8446)
SSL 2 (soportado parcialmente)
Algoritmos de intercambio de claves (EC)DH(E), RSA, PSK, SRP, GOST y ANON
Cifrados CBC, AEAD y de flujo (AES, CAMELLIA, DES, 3DES, IDEA, RC2, ARIA, GOST_28147_CNT_IMIT, RC4, SEED, NULL)
~300 suites de cifrado, ~30 extensiones
Cliente y Servidor
HTTPS
Flujos de trabajo con más de dos partes
Muchas extensiones
Tokenbinding (EC) y Tokenbinding sobre HTTP
Sockets
TLS 1.3 0-RTT
STARTTLS
...

Uso

Aquí presentamos algunos ejemplos muy simples de uso de TLS-Attacker.

Primero, debe iniciar un servidor TLS (por favor no use servidores públicos). Ejecute el script keygen.sh si no lo ha hecho antes. Por ejemplo, puede usar un servidor de prueba OpenSSL:

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

Este comando inicia un servidor TLS en el puerto 4433.

Si desea conectarse a un servidor, puede usar este comando:

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

Nota: Si este Handshake falla, probablemente se deba a que no especificó una suite de cifrado concreta. TLS-Attacker no respetará completamente las suites de cifrado seleccionadas por el servidor.

Puede usar una suite de cifrado diferente, versión TLS o conectarse a un puerto diferente con los siguientes parámetros:

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

Si es un desarrollador más experimentado, puede crear su propio flujo de mensajes TLS escribiendo código Java. Por ejemplo:

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 utiliza el concepto de WorkflowTraces para definir un "flujo de mensajes TLS". Un WorkflowTrace consiste en una lista de acciones que se ejecutan una tras otra. Aunque para un "flujo de mensajes TLS" típico solo se necesitan SendAction y ReceiveAction, el framework no se detiene aquí e implementa muchas otras acciones que se pueden usar para ejecutar flujos de mensajes aún más arbitrarios. En la Wiki se puede encontrar una lista de las acciones implementadas actualmente con explicaciones.

Sabemos que muchos odian Java. Por lo tanto, también puede usar una estructura XML y ejecutar su protocolo TLS personalizado desde XML:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workflowTrace>
    <!-- Enviar ClientHello -->
    <Send>
        <configuredMessages>
            <ClientHello>
                <extensions>
                    <ECPointFormat/>
                    <EllipticCurves/>
                    <SignatureAndHashAlgorithmsExtension/>
                    <RenegotiationInfoExtension/>
                </extensions>
            </ClientHello>
        </configuredMessages>
        <configuredRecords>
            <record/>
        </configuredRecords>
    </Send>
    
    <!-- Recibir respuesta del servidor -->
    <Receive>
        <expectedMessages>
            <ServerHello>
                <extensions>
                    <ECPointFormat/>
                    <RenegotiationInfoExtension/>
                </extensions>
            </ServerHello>
            <Certificate/>
            <ServerHelloDone/>
        </expectedMessages>
    </Receive>
    
    <!-- Enviar intercambio de claves del cliente y finalizar -->
    <Send>
        <configuredMessages>
            <RSAClientKeyExchange/>
            <ChangeCipherSpec/>
            <Finished/>
        </configuredMessages>
        <configuredRecords>
            <record/>
            <record/>
            <record/>
        </configuredRecords>
    </Send>
    
    <!-- Recibir finalización del servidor -->
    <Receive>
        <expectedMessages>
            <ChangeCipherSpec/>
            <Finished/>
        </expectedMessages>
    </Receive>
</workflowTrace>

Dado que esta estructura XML está ubicada en TLS-Attacker/apps/workflow.xml, solo necesitaría ejecutar:

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

Sistema de Capas/Protocol-Attacker

Originalmente diseñado para atacar el protocolo TLS, TLS-Attacker es capaz de admitir protocolos arbitrarios. Para ello, TLS-Attacker asigna una pila de capas a cada conexión. Esta pila de capas consta de las diferentes capas de protocolo que el usuario desea utilizar. Con la pila de capas, el usuario puede agregar capas como DTLS o HTTP (más están en desarrollo) en un orden arbitrario.

TLS-Attacker v7.0.0-rtc