bind: blackhole para consultas recursivas inválidas?

Eu tenho um servidor de nomes acessível ao público, pois é o servidor de nomes oficial para alguns domínios .

Atualmente, o servidor é inundado por ANYsolicitações de tipo falsificado para isc.org, mature.net e similares (que é um ataque de DoS distribuído conhecido ).

O servidor executa o BIND e allow-recursionconfigurou a minha LAN para que essas solicitações sejam rejeitadas. Nesses casos, o servidor responde apenas com authoritye additionalseções referentes aos servidores raiz.

Posso configurar o BIND para que ele ignore completamente essas solicitações, sem enviar uma resposta?

Diante do mesmo problema, optei por ignorar todos os pedidos recursivos. Todos os resolvedores enviam uma consulta não recursiva quando desejam usar meu servidor como um servidor autoritativo. Somente clientes e atacantes mal configurados, no meu próprio caso, usam consultas recursivas.

Infelizmente, não encontrei uma maneira de deixar o BIND fazer isso, mas, caso o iptables seja bom o suficiente para você, usei

iptables -t raw -I PREROUTING -i eth0 -p udp --destination-port 53 \
    -m string --algo kmp --from 30 \
    --hex-string "|01000001000000000000|" -j DROP

Eu tentaria:

zone "." {
  type redirect;
  allow-query "none";
}

As respostas referentes aos clientes para os servidores raiz são controladas pela zona "redirecionar". Isso deve dizer para não responder a eles.

Isso é sugerido nos documentos do Bind9: http://ftp.isc.org/isc/bind9/cur/9.9/doc/arm/Bv9ARM.ch06.html#id2592674

Você pode substituir "none" com sua sub-rede local.

Se você já possui uma zone "."declaração, basta adicioná allow-query "none";-la.

Geralmente, eu sugeriria:

Ative os logs de ligação e registre os ips que recebem resposta rejeitada. Instale o programa fail2ban, adicione a ação blackhole: http://pastebin.com/k4BxrAeG (coloque a regra no arquivo em /etc/fail2ban/actions.d)

Crie um arquivo de filtro de ligação em /etc/fail2ban/filter.d com algo parecido com isto (precisa de depuração!)

[Definition]
failregex = ^.* security: info: client #<HOST>: query \(cache\) .* denied

Edite fail2ban.conf, adicione a seção:

[bindban]

enabled  = true
filter   = bind
# "bantime" is the number of seconds that a host is banned.
bantime  = 6000
# A host is banned if it has generated "maxretry" during the last "findtime"
# seconds.
findtime  = 60
# "maxretry" is the number of failures before a host get banned.
maxretry = 150
action   = blackhole
logpath  = /var/log/named.log

Espero que isso ajude!

A idéia básica permite que o bind classifique a resposta DNS como recusada e use o iptables para converter a recusada em ignorada silenciosamente.

Recusado é a parte fácil da seção de opções named.conf:

allow-recursion { none;};

Ou, é claro, suas ACLs favoritas para exceções locais ...

Na próxima mágica do iptables, ajuste ou remova "-o eth0", conforme necessário. Este comando assume o cabeçalho padrão da camada IPv4 de 20 bytes antes do UDP.

iptables -A OUTPUT -o eth0 -p udp --sport 53 -m string --from 30 --to 32 --hex-string "|8105|" --algo bm -j DROP

Essas teclas no campo sinalizadores da resposta DNS com os seguintes bits definidos

• Resposta DNS
• Consulta recursiva
• Código de resposta recusado

A mensagem de log percebida executando a ligação na depuração "erro ao enviar resposta: host inacessível" quando a regra corresponde a ter algum feedback para o teste.

Devo admitir que tudo isso é um exercício um tanto inútil. Se não houver amplificação, um invasor poderá refletir com a mesma facilidade o TCP SYN. Em última análise, o DNS está quebrado simplesmente não há solução viável além do uso do TCP ou da implantação dos cookies DNS da Eastlake.

Você tentou bloquear a string isc.org ou bloquear a string hexadecimal?

Isso funcionou para mim:

iptables -A INPUT -p udp -m string --hex-string "| 03697363036f726700 |" --algo bm -j DROP

Esse ataque é chamado de negação de serviço amplificada. Você deve configurar a ligação corretamente, mas esse tráfego não deve chegar à sua ligação em primeiro lugar. Bloqueie-o no primeiro dispositivo de rede capaz de fazê-lo na sua rede. Eu tive o mesmo problema e lidei com isso com a regra do ronco surdo:

alert udp $ EXTERNAL_NET any -> $ HOME_NET 53 (msg: "consultas excessivas em PROTOCOLO-DNS do tipo ANY - DoS em potencial"; byte_test: 1,! &, 0xF8,2; conteúdo: "| 00 00 FF 00 01 |"; detection_filter: track by_src, count 30, seconds 30; metadata: service dns; reference: url, foxpa.ws / 2010/07/21 / thwarting-isc-org-dns-ddos /; classtype: tentativa-dos; sid : 21817; rev: 4;)

Primeiro, eu sei que essa é uma pergunta antiga, mas ...

Estou executando meu próprio servidor DNS autoritativo e não recursivo há décadas, mas nunca fui vítima de nenhum ataque DDoS baseado em DNS - até agora, quando mudei para um novo ISP. Milhares de consultas DNS falsificadas inundaram meus logs e fiquei muito irritado - não tanto pelo impacto no meu servidor, mas pelo fato de ele atrapalhar meus logs e pela sensação desconfortável de ser abusado. Parece que o invasor tenta usar meu DNS em um " ataque do servidor de nomes autoritário ".

Então, imaginei que, embora eu limite consultas recursivas à minha rede interna (negando todas as outras), prefiro gastar meus ciclos de CPU na correspondência de cadeias de caracteres em tabelas de ip do que enviando respostas negativas aos endereços IP falsificados (menos confusão nos meus logs, menos tráfego de rede e um nível mais alto de satisfação).

Comecei fazendo o que todo mundo parece fazer , descubra quais nomes de domínio são consultados e criei uma correspondência de string nesse domínio com uma DROP de destino. Mas logo percebi que acabaria com uma enorme quantidade de regras, cada uma delas consumindo ciclos de CPU. Então o que fazer? Como não executo um servidor de nomes recursivo, achei que poderia fazer a correspondência nas zonas reais para as quais sou autoritário e largar todo o resto.

Minha política padrão no iptables é ACEITAR, se sua política for DROP, você provavelmente precisará fazer alguns ajustes se desejar usar a seguinte solução.

Eu mantenho minha configuração de zona em um arquivo separado (/etc/bind/named.conf.local), vamos usar isso como um exemplo:

zone "1.168.192.in-addr.arpa" { // Private
        type master;
        allow-query { 192.168.1.0/24; 127.0.0.1; };
        allow-transfer { 127.0.0.1; };
        file "/etc/bind/db.192.168.1";
};

zone "home.example.net" { // Private
        type master;
        allow-query { 192.168.1.0/24; 127.0.0.1; };
        allow-transfer { 127.0.0.1; };
        file "/etc/bind/pri/db.home.example.net";
};

zone "example.net" {
        type master;
        file "/etc/bind/pri/db.example.net";
        allow-transfer { 127.0.0.1; 8.8.8.8; };
};

zone "example.com" {
        type slave;
        masters { 8.8.8.8; };
        file "sec.example.com";
        allow-transfer { 127.0.0.1; };
        notify no;
};

zone "subdomain.of.example.nu" {
        type slave;
        masters { 8.8.8.8; };
        file "sec.subdomain.of.example.nu";
        allow-transfer { 127.0.0.1; };
        notify no;
};

Observe o comentário “// Privado” nas minhas duas primeiras zonas, eu uso isso no script a seguir para excluí-las da lista de zonas válidas.

#!/usr/bin/perl
# zone2iptables - Richard Lithvall, april 2014
#
# Since we want to match not only example.net, but also (for example)
# www.example.net we need to set a reasonable maximum value for a domain
# name in our zones - 100 character should be more that enough for most people
# and 255 is the absolute maximum allowed in rfc1034.
# Set it to 0 (zero) if you would like the script to fetch each zone (axfr)
# to get the actual max value.
$maxLengthOfQueryName=255;
$externalInterface="eth1";

print "# first time you run this, you will get error on the 3 first commands.\n";
print "# It's here to make it safe/possible to periodically run this script.\n";
print "/sbin/iptables -D INPUT -i $externalInterface -p udp --dport 53 -j DNSvalidate\n";
print "/sbin/iptables -F DNSvalidate\n";
print "/sbin/iptables -X DNSvalidate\n";
print "#\n";
print "# now, create the chain (again)\n";
print "/sbin/iptables -N DNSvalidate\n";
print "# and populate it with your zones\n";
while(<>){
        if(/^zone\s+"(.+)"\s+\{$/){
                $zone=$1;
                if($maxLengthOfQueryName){
                        $max=$maxLengthOfQueryName;
                } else {
                        open(DIG,"dig -t axfr +nocmd +nostats $zone |");
                        $max=0;
                        while(<DIG>){
                                if(/^(.+?)\.\s/){
                                        $max=(length($1)>$max)?length($1):$max;
                                }
                        }
                        close(DIG);
                }
                printf("iptables -A DNSvalidate -m string --from 40 --to %d --hex-string \"",($max+42));
                foreach $subdomain (split('\.',$zone)){
                        printf("|%02X|%s",length($subdomain),$subdomain);
                }
                print("|00|\" --algo bm -j RETURN -m comment --comment \"$zone\"\n");
        }
}
print "# and end the new chain with a drop\n";
print "/sbin/iptables -A DNSvalidate -j DROP\n";
print "# And, at last, make the new chain active (on UDP/53)\n";
print "/sbin/iptables -A INPUT -i $externalInterface -p udp --dport 53 -j DNSvalidate\n";

Execute o script acima com o arquivo de configuração da zona como argumento.

root:~/tmp/# ./zone2iptables.pl /etc/bind/named.conf.local 
# first time you run this, you will get error on the 3 first commands.
# It's here to make it safe/possible to periodically run this script.
/sbin/iptables -D INPUT -i eth1 -p udp --dport 53 -j DNSvalidate
/sbin/iptables -F DNSvalidate
/sbin/iptables -X DNSvalidate
#
# now, create the chain (again)
/sbin/iptables -N DNSvalidate
# and populate it with your zones
iptables -A DNSvalidate -m string --from 40 --to 297 --hex-string "|07|example|03|net|00|" --algo bm -j RETURN -m comment --comment "example.net"
iptables -A DNSvalidate -m string --from 40 --to 297 --hex-string "|07|example|03|com|00|" --algo bm -j RETURN -m comment --comment "example.com"
iptables -A DNSvalidate -m string --from 40 --to 297 --hex-string "|09|subdomain|02|of|07|example|02|nu|00|" --algo bm -j RETURN -m comment --comment "subdomain.of.example.nu"
# and end the new chain with a drop
/sbin/iptables -A DNSvalidate -j DROP
# And, at last, make the new chain active (on UDP/53)
/sbin/iptables -A INPUT -i eth1 -p udp --dport 53 -j DNSvalidate

Salve a saída em um script, coloque-o em um shell ou copie e cole no seu terminal para criar a nova cadeia e começar a filtrar todas as consultas DNS inválidas.

execute / sbin / iptables -L DNSvalidate -nvx para ver os contadores de pacotes (e bytes) em cada regra da nova cadeia (você pode mover a zona com a maioria dos pacotes para o topo da lista para torná-la mais eficiente).

Na esperança de que alguém possa achar isso útil :)