TLS-Attacker

GitHub release (latest by date)

O TLS-Attacker é um framework baseado em Java para analisar bibliotecas TLS. Ele é capaz de enviar mensagens de protocolo arbitrárias em uma ordem arbitrária para o peer TLS, e definir suas modificações usando uma interface fornecida. Isso dá ao desenvolvedor a oportunidade de definir facilmente um fluxo de protocolo TLS personalizado e testá-lo contra sua biblioteca TLS.

Por favor, note: O TLS-Attacker é uma ferramenta de pesquisa destinada a desenvolvedores TLS e pentesters. Não há GUI nem luzes verdes/vermelhas.

Compilando e Executando

Para compilar e usar o TLS-Attacker, você precisa ter Java e Maven instalados. No Ubuntu você pode instalar o Maven executando:

$ sudo apt-get install maven

O TLS-Attacker atualmente precisa do Java JDK 21 para executar.

Se você tiver a versão correta do Java, pode executar o comando maven a partir do diretório do TLS-Attacker:

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

Alternativamente, se estiver com pressa, você pode pular os testes usando:

$ mvn clean install -DskipTests=true

Os arquivos jar resultantes são colocados na pasta "apps".

Se você quiser usar este projeto como dependência, não precisa compilá-lo você mesmo e pode incluí-lo em seu pom .xml da seguinte forma.

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

O TLS-Attacker vem com aplicações de demonstração que fornecem acesso fácil à funcionalidade do TLS-Attacker.

Você pode executar o TLS-Attacker como cliente com o seguinte comando:

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

ou como servidor com:

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

Embora esses aplicativos de exemplo sejam muito poderosos por si só, o TLS-Attacker libera todo o seu potencial quando usado como uma biblioteca de programação.

Estrutura do Código

O TLS-Attacker consiste em vários projetos (maven):

TLS-Client: O aplicativo de exemplo do cliente
TLS-Core: A pilha de protocolos e o coração do TLS-Attacker
TLS-Mitm: Um protótipo para workflows MitM
TLS-Server: O aplicativo de exemplo do servidor
TLS-Proxy: Use o TLS-Attacker para SSLSockets
TraceTool: Inspeção e modificação de traces de workflow do TLS-Attacker
Transport: Utilitários de transporte para camadas inferiores
Utils: Uma coleção de classes utilitárias

TLS-Attacker design

Você pode encontrar mais informações sobre esses módulos na Wiki.

Funcionalidades

Atualmente, as seguintes funcionalidades são suportadas:

SSL 3, versões TLS 1.0 (RFC-2246), 1.1 (RFC-4346), 1.2 (RFC-5246) e 1.3 (RFC-8446)
SSL 2 (Suporte parcial)
Algoritmos de troca de chaves (EC)DH(E), RSA, PSK, SRP, GOST e ANON
CBC, AEAD e Streamciphers (AES, CAMELLIA, DES, 3DES, IDEA, RC2, ARIA, GOST_28147_CNT_IMIT, RC4, SEED, NULL)
~300 conjuntos de cifras, ~30 Extensões
Cliente e Servidor
HTTPS
Workflows com mais de duas partes
Muitas extensões
Tokenbinding (EC) e Tokenbinding sobre HTTP
Sockets
TLS 1.3 0-RTT
STARTTLS
...

Uso

Aqui apresentamos alguns exemplos muito simples de uso do TLS-Attacker.

Primeiro, você precisa iniciar um servidor TLS (por favor, não use servidores públicos). Execute o script keygen.sh se ainda não o fez. Por exemplo, você pode usar um servidor de teste OpenSSL:

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

Este comando inicia um servidor TLS na porta 4433.

Se você quiser conectar a um servidor, pode usar este comando:

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

Nota: Se este Handshake falhar, provavelmente é porque você não especificou uma suíte de cifras concreta. O TLS-Attacker não respeitará completamente as suítes de cifras selecionadas pelo servidor.

Você pode usar uma suíte de cifras diferente, versão TLS, ou conectar a uma porta diferente com os seguintes parâmetros:

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

Caso você seja um desenvolvedor mais experiente, pode criar seu próprio fluxo de mensagens TLS escrevendo código Java. Por exemplo:

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();

O TLS-Attacker usa o conceito de WorkflowTraces para definir um "fluxo de mensagens TLS". Um WorkflowTrace consiste em uma lista de ações que são então executadas uma após a outra. Embora para um "fluxo de mensagens TLS" típico apenas SendAction's e ReceiveAction's sejam necessários, o framework não para por aí e implementa muitas ações diferentes que podem ser usadas para executar fluxos de mensagens ainda mais arbitrários. Uma lista de ações atualmente implementadas com explicações pode ser encontrada na Wiki.

Sabemos que muitos de vocês odeiam Java. Portanto, você também pode usar uma estrutura XML e executar seu protocolo TLS personalizado a partir de 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>

Dado que esta estrutura XML está localizada em TLS-Attacker/apps/workflow.xml, você precisaria apenas executar:

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

Sistema de Protocolo-Attacker/Camada

Originalmente projetado para atacar o protocolo TLS, o TLS-Attacker é capaz de suportar protocolos arbitrários. Para isso, o TLS-Attacker atribui uma pilha de camadas a cada conexão. Esta pilha de camadas consiste nas diferentes camadas de protocolo que o usuário deseja utilizar. Com a pilha de camadas, o usuário pode adicionar camadas como DTLS, ou HTTP (mais estão em andamento) em uma ordem arbitrária.

TLS-Attacker v7.8.0