lapsiufcg/frida-inesc-pqc-dnssec repository overview

⁠Projeto FRIDA — Ambiente DNSSEC com BIND9 e ECDSA-P256

Ambiente Docker para experimentação e medição de desempenho de DNSSEC, utilizando o BIND9 para representar uma infraestrutura DNS composta por servidor autoritativo, resolvedor recursivo e cliente.

O ambiente estabelece uma linha de base clássica utilizando ECDSA-P256, que poderá ser utilizada posteriormente como referência para estudos envolvendo algoritmos de assinatura pós-quântica (PQC) aplicados ao DNSSEC.

⁠Visão geral

O experimento é composto por três containers Docker:

• dnssec-authoritative — servidor DNS autoritativo responsável pela zona lab.test, geração das chaves DNSSEC e assinatura da zona;
• dnssec-resolver — resolvedor DNS recursivo responsável por consultar o servidor autoritativo, validar as respostas DNSSEC e armazenar resultados em cache;
• dnssec-cliente — cliente responsável pela realização das consultas DNS e pela coleta das métricas experimentais.

As três imagens estão disponíveis no Docker Hub:

lapsiufcg/frida-inesc-pqc-dnssec:autoritativo
lapsiufcg/frida-inesc-pqc-dnssec:resolver
lapsiufcg/frida-inesc-pqc-dnssec:cliente

⁠Arquitetura do experimento

                         Rede Docker
                        (rede-dnssec)
                              |
                              |
                    +------------------+
                    |     Cliente      |
                    | dnssec-cliente   |
                    +--------+---------+
                             |
                       Consulta DNS
                             |
                             v
                    +------------------+
                    |    Resolvedor    |
                    | dnssec-resolver  |
                    | DNSSEC Validator |
                    +--------+---------+
                             |
                      Consulta recursiva
                             |
                             v
                    +------------------+
                    |    Autoritativo  |
                    | dnssec-authoritative
                    |   zona lab.test  |
                    +------------------+

O servidor autoritativo mantém as chaves DNSSEC e disponibiliza a zona assinada.

O resolvedor realiza as consultas ao servidor autoritativo, valida criptograficamente as respostas recebidas e disponibiliza os resultados ao cliente.

O cliente realiza as consultas e coleta as métricas utilizadas nos experimentos.

⁠DNSSEC utilizado

A zona experimental utilizada é:

lab.test

O servidor autoritativo utiliza o algoritmo:

ECDSAP256SHA256

correspondente ao algoritmo DNSSEC 13 (ECDSA P-256).

São utilizadas duas chaves:

• KSK (Key Signing Key) — utilizada para assinar o conjunto de registros DNSKEY;
• ZSK (Zone Signing Key) — utilizada para assinar os demais registros da zona.

As chaves são geradas localmente no servidor autoritativo utilizando as ferramentas disponibilizadas pelo BIND9.

A assinatura da zona é realizada utilizando:

dnssec-signzone

A integridade da zona assinada pode ser verificada com:

dnssec-verify

A zona assinada contém registros DNSSEC, incluindo:

DNSKEY
RRSIG
NSEC

Esses registros permitem que o resolvedor valide criptograficamente as respostas DNS e autentique respostas negativas.

⁠Pré-requisitos

Para executar o ambiente são necessários:

• Linux;
• Docker Engine instalado;
• acesso ao terminal;
• recursos suficientes para executar três containers;
• acesso ao Docker Hub.

O experimento utiliza containers Docker para manter os componentes DNS isolados e facilitar a reprodução da infraestrutura experimental.

⁠Execução do ambiente

⁠Passo 1 — Baixar as imagens

O ambiente é distribuído como três imagens Docker.

Baixe as imagens:

docker pull lapsiufcg/frida-inesc-pqc-dnssec:autoritativo

docker pull lapsiufcg/frida-inesc-pqc-dnssec:resolver

docker pull lapsiufcg/frida-inesc-pqc-dnssec:cliente

Confira as imagens disponíveis localmente:

docker images | grep frida-inesc-pqc-dnssec

Espera-se encontrar:

lapsiufcg/frida-inesc-pqc-dnssec   autoritativo
lapsiufcg/frida-inesc-pqc-dnssec   resolver
lapsiufcg/frida-inesc-pqc-dnssec   cliente

⁠Passo 2 — Criar a rede Docker

Crie uma rede isolada para comunicação entre os componentes:

docker network create rede-dnssec

Caso a rede já exista, o Docker informará que ela já está criada.

É possível verificar a rede com:

docker network inspect rede-dnssec

⁠Passo 3 — Subir os containers

O ambiente utiliza três containers, cada um baseado em uma imagem específica.

⁠Servidor autoritativo

docker run -dit \
  --name dnssec-authoritative \
  --network rede-dnssec \
  lapsiufcg/frida-inesc-pqc-dnssec:autoritativo

⁠Resolvedor

docker run -dit \
  --name dnssec-resolver \
  --network rede-dnssec \
  lapsiufcg/frida-inesc-pqc-dnssec:resolver

⁠Cliente

docker run -dit \
  --name dnssec-cliente \
  --network rede-dnssec \
  lapsiufcg/frida-inesc-pqc-dnssec:cliente

Confira os containers em execução:

docker ps

O resultado deverá apresentar:

dnssec-authoritative
dnssec-resolver
dnssec-cliente

⁠Verificação da infraestrutura

⁠Endereços IP

Os endereços IP dos containers podem ser obtidos com:

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' dnssec-authoritative

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' dnssec-resolver

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' dnssec-cliente

Os endereços podem variar entre execuções. Por isso, os comandos de consulta devem utilizar os IPs obtidos no ambiente atual.

⁠Validação do servidor autoritativo

A zona experimental utilizada pelo servidor é:

lab.test

Uma consulta direta ao servidor autoritativo pode ser realizada com:

docker exec dnssec-cliente \
  dig @IP_DO_AUTORITATIVO www.lab.test A +dnssec

Substitua IP_DO_AUTORITATIVO pelo endereço obtido anteriormente.

Uma resposta válida deverá apresentar:

• o registro A de www.lab.test;
• uma assinatura RRSIG;
• resposta autoritativa (aa).

Também é possível consultar os registros DNSKEY:

docker exec dnssec-cliente \
  dig @IP_DO_AUTORITATIVO lab.test DNSKEY +dnssec

A resposta deverá apresentar os registros das chaves utilizadas na zona e suas respectivas assinaturas.

⁠Validação do resolvedor DNSSEC

O cliente realiza uma consulta através do resolvedor:

docker exec dnssec-cliente \
  dig @IP_DO_RESOLVER www.lab.test A +dnssec

Uma resposta DNSSEC validada deverá apresentar a flag:

ad

A presença de ad indica que o resolvedor considerou os dados autenticados por DNSSEC.

Também é possível verificar a resposta utilizando:

docker exec dnssec-cliente \
  dig @IP_DO_RESOLVER www.lab.test A +dnssec

No resultado, devem aparecer o registro A e a respectiva assinatura RRSIG.

⁠Validação de respostas negativas

Também são realizados testes de autenticação da inexistência de nomes DNS.

Por exemplo:

docker exec dnssec-cliente \
  dig @IP_DO_RESOLVER inexistente.lab.test A +dnssec

A resposta esperada é:

NXDOMAIN

e, quando validada pelo resolvedor, deverá apresentar a flag:

ad

A resposta negativa utiliza registros como:

NSEC
RRSIG

para permitir a autenticação criptográfica da inexistência do nome consultado.

⁠Medição experimental

O cliente possui o script:

client/medir_dnssec.py

O script realiza as consultas DNS e registra informações utilizadas posteriormente na análise experimental.

Entre os dados registrados estão:

• número da execução;
• timestamp em UTC;
• cenário experimental;
• condição do cache;
• endereço do resolvedor;
• domínio consultado;
• tipo do registro;
• sucesso da consulta;
• status DNS;
• presença da flag AD;
• flags da resposta;
• tempo reportado pelo dig;
• latência observada pelo cliente;
• tamanho da mensagem DNS;
• código de retorno;
• informações de erro, quando existentes.

⁠Execução do cenário warm

Para realizar 30 execuções no cenário com cache:

docker exec dnssec-cliente \
  python3 /root/medir_dnssec.py 30 warm

Os resultados são armazenados em arquivo CSV no ambiente do cliente.

⁠Execução do cenário cold

Para realizar uma execução no cenário sem utilização prévia do cache:

docker exec dnssec-cliente \
  python3 /root/medir_dnssec.py 1 cold

O roteiro:

client/medir_cold.sh

pode ser utilizado para automatizar as execuções do cenário cold.

⁠Cenários de cache

O experimento considera duas condições principais.

⁠Warm

No cenário warm, o resolvedor pode utilizar informações previamente armazenadas em cache.

Esse cenário permite observar o comportamento de consultas quando informações relacionadas à resolução já podem estar disponíveis no cache.

⁠Cold

No cenário cold, o cache do resolvedor é reinicializado antes da consulta.

Esse cenário permite avaliar o custo de uma consulta sem depender de informações previamente armazenadas no cache.

⁠Resultados experimentais atuais

A linha de base utilizando ECDSA-P256 foi executada com 30 execuções válidas em cada cenário.

Esses valores correspondem à linha de base atual do experimento e podem ser atualizados à medida que novas execuções e cenários forem realizados.

⁠Dados brutos

Os dados brutos utilizados na análise são armazenados em arquivos CSV:

client/resultado_dnssec_ECDSA-P256_warm.csv
client/resultado_dnssec_ECDSA-P256_cold.csv

A análise pode ser realizada com:

python3 client/analisar_dnssec.py \
  client/resultado_dnssec_ECDSA-P256_warm.csv

Para o cenário cold:

python3 client/analisar_dnssec.py \
  client/resultado_dnssec_ECDSA-P256_cold.csv

⁠Organização do projeto

A estrutura do projeto é:

dnssec_exp/
├── authoritative/
│   ├── dnssec/
│   │   ├── K*.key
│   │   └── K*.private
│   ├── named.conf
│   └── zones/
│       └── lab.test
│
├── resolver/
│   └── named.conf
│
├── client/
│   ├── medir_dnssec.py
│   ├── medir_cold.sh
│   ├── analisar_dnssec.py
│   ├── resultado_dnssec_ECDSA-P256_warm.csv
│   └── resultado_dnssec_ECDSA-P256_cold.csv
│
└── docker/
    ├── Dockerfile.authoritative
    ├── Dockerfile.resolver
    └── Dockerfile.client

⁠Segurança das chaves DNSSEC

As chaves privadas DNSSEC não devem ser expostas ou versionadas em repositórios públicos.

Para distribuição das imagens Docker, recomenda-se que novas chaves sejam geradas no ambiente de execução, evitando a publicação de chaves privadas utilizadas durante os experimentos.

Em particular, arquivos com extensão:

.private

não devem ser enviados para repositórios públicos.

⁠Objetivo futuro — DNSSEC pós-quântico

O ambiente foi estruturado para que a linha de base com ECDSA-P256 possa ser utilizada como referência para uma futura investigação de DNSSEC utilizando algoritmos de assinatura pós-quântica.

Entre os algoritmos de interesse estão:

• ML-DSA;
• SLH-DSA.

A investigação futura poderá comparar os mecanismos considerando diferentes aspectos do funcionamento do DNSSEC, incluindo:

• tempo de geração de chaves;
• tempo de assinatura;
• tempo de validação;
• tamanho das chaves;
• tamanho das assinaturas;
• tamanho das respostas DNS;
• latência das consultas;
• consumo de CPU;
• consumo de memória;
• fragmentação;
• comportamento da rede.

O ML-KEM, por ser um mecanismo de encapsulamento de chaves, não substitui diretamente os mecanismos de assinatura utilizados pelo DNSSEC. Para a investigação de DNSSEC pós-quântico, o foco principal será nos algoritmos de assinatura digital pós-quântica.

⁠Objetivo do projeto

O experimento estabelece uma infraestrutura controlada e reproduzível para avaliar o custo da utilização de mecanismos criptográficos no DNSSEC.

A metodologia atual estabelece uma linha de base utilizando ECDSA-P256, permitindo que futuras implementações pós-quânticas sejam comparadas com o cenário clássico.

O fluxo experimental pode ser representado por:

Geração de chaves
        ↓
Assinatura da zona
        ↓
Consulta DNS
        ↓
Validação DNSSEC
        ↓
Medição de desempenho
        ↓
Análise dos resultados
        ↓
Comparação com algoritmos PQC

Dessa forma, o ambiente Docker fornece uma infraestrutura controlada para estudar os impactos da utilização de diferentes mecanismos criptográficos na operação do DNSSEC.