Mein Datenhaufen zu IT und Elektronik Themen.

Schlagwort: Bind

Bind 9.18 mit DoH und DoT

Über die Techniken DoT (DNS over TLS) habe ich bereits im Zusammenhang mit Bind 9.16 geschrieben. Ebenfalls DoH (DNS over HTTPS) gibt es einen kleinen Beitrag.

Zu diesem Zeitpunkt bracht BIND 9 die Unterstützung für DoH und DoT noch nicht selbst mit. Daher waren zu diesem Zeitpunkt noch Umwege über stunnel oder nginx zusammen mit doh-proxy nötig.

Zum Glück kommt die letzte stable Version 9.18.0 (26. Januar 2022) mit dem nötigen Support.

named now supports securing DNS traffic using Transport Layer Security (TLS). TLS is used by both DNS over TLS (DoT) and DNS over HTTPS (DoH).

Warum möchte man noch gleich DoH oder DoT benutzen? Ganz einfach… Über diese Techniken werden DNS Abfragen verschlüsselt übertragen. Dieses ist ein weiterer Schutz davor manipulierte Antworten zu bekommen und selbstverständlich, damit die eigenen DNS Abfragen erst überhaupt nicht mitgelesen werden. Denn wenn von einem Gerät im Netzwerk die DNS Abfrage zu z.B.: www.tagesschau.de kommt, könnte man davon bereits Dinge ableiten.

Wie die meisten Bind Konfigurationen ist dieses ebenfalls straightforward. Ab Version 9.18 bringt Bind alles Nötige mit. Da wir nun TLS mit dem Bind sprechen möchten, benötigen wir natürlich ein gültiges Zertifikat, wie z.B. beim nginx für seine Webseite.

Ebenfalls sollte man ein paar frische Diffie-Hellmann Parameter generieren:

openssl dhparam -out dhparam.pem 4096

Die eigentliche bind Konfiguration kann in der named.conf.options geschehen:

options {
        [...]
        listen-on port 853 tls local-tls { 37.120.183.220; };
        listen-on-v6 port 853 tls local-tls { 2a03:4000:38:20e::853; };
        listen-on port 443 tls local-tls http default { 37.120.183.220;  };
        listen-on-v6 port 443 tls local-tls http default { 2a03:4000:38:20e::853; };
        [...]
        allow-recursion-on { 127.0.0.0/8; ::1/128; 2a03:4000:38:20e::853; 37.120.183.220; };
        [...]
};

Da der bind auf weiteren Ports lauschen soll erweitert man diese für IPv4 und IPv6. Der Default Port für DoH ist dabei 443 und der default Port für DoT ist 853, beides TCP.

listen-on sowie listen-on-v6 sind wohl selbsterklärend.
port ist der TCP Port und erklärt sich ebenfalls.
tls sagt dem Bind das wir tls sprechen möchten.
local-tls verweißt auf den gleichnamigen tls Block über welchen man seine TLS Konfiguration vornimmt.
http ist für DoH.
default gibt den eigentlichen endpoint für die DoH Abfragen an, im default ist es /dns-query

Da der Server unsere DNS Abfragen erledigen soll, müssen wir ihm dieses noch per allow-recursion-on auf den jeweiligen Adressen erlauben.

Als nächstes wird die eigentliche TLS Terminierung konfiguriert (das lässt sich ebenfalls auslagern, wenn gewünscht). Dafür wird der folgende Block, außerhalb der Options Blocks, ergänzt:

tls local-tls {
    cert-file "/usr/local/etc/ssl/wild.kernel-error.de/2022/ecp/chain.crt";
    key-file "/usr/local/etc/ssl/wild.kernel-error.de/2022/ecp/http.key";
    dhparam-file "/usr/local/etc/ssl/dhparam.pem";
    protocols { TLSv1.2; TLSv1.3; };
    ciphers "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256";
    prefer-server-ciphers yes;
    session-tickets no;
};

local-tls ist dabei der name des Blocks. Auf diesen verweisen wir oben.
cert-file ist der Pfad zum Zertifikat. Ich habe dort nicht nur das Zertifikat, sondern die gesamte Chain, also mit Intermediate und Root.
key-file ist der Pfad zum Key des Zertifikates.
dhparam-file ist der Pfad zu den Diffie-Hellman Parametern.
protocols definiert die zu verwendenden TLS Protokolle. In diesem Beispiel TLS1.2 sowie TLS1.3.
ciphers definiert die zu verwendenden cipher. Es soll ja „sicher“ bleiben.
prefer-server-ciphers übermittelt dem Client die Information, in welcher Reihenfolge protokoll/cipher Kombinationen probiert werden sollen um einen Match zu finden. Erst das vermeintlich sicherste und dann immer „schlechter“.
session-tickets regelt ob eine Wiederaufnahme von TLS Sessions erlaubt ist oder nicht. Da ich forward secrecy nutzen möchte, ist es deaktiviert.

Damit ist die Konfiguration schon abgeschlossen (Firewall ggf. nicht vergessen!). Also testen….

Ein einfaches Tool dafür ist dog, oder natürlich dig aus den bind-tools aber Version 9.18. Für bind gibt es dann die Optionen +https oder auch +tls

dig +https @dns.kernel-error.de www.kernel-error.de A
dig +tls @dns.kernel-error.de www.kernel-error.de A

Der gleiche Test mit dog, sieht wie folgt aus:

dog www.kernel-error.de --tls "@dns.kernel-error.de"
A www.kernel-error.de. 6h00m00s   148.251.40.23
dog www.kernel-error.de --https "@https://dns.kernel-error.de/dns-query"
A www.kernel-error.de. 6h00m00s   148.251.40.23

Das war es auch schon! Viele Spaß mit einem „besseren“ DNS und wenn es noch Fragen gibt, einfach fragen 🙂

DoH (DNS over HTTPS) mit Bind

Meine Tests mit DoT (DNS over TLS) habe ich bereits vor einiger Zeit gestartet.  DoT DNS over TLS mit Bind, stunnel und Android 9 Dieses arbeitet noch immer ganz fein auf meinem Smartphone. DoT gefällt mir noch immer um einiges besser als DoH aber auch hier wollte ich nun einmal einen Versuch starten. Zusammen mit nginx und einem etwas angepassten doh-proxy läuft dieses nun auf dem gleichen System.

Im Firefox ist es schnell aktiviert https://ns1.kernel-error.de/dns-query…

DoH DNS over HTTPS Firefox

Es funktioniert auch, so richtig glücklich macht es mich aber nicht! Natürlich ist die Umsetzung nur etwas für einen kleinen privaten Test. „Schnell“ genug ist es ebenfalls! Zumindest zum Surfen im Internet, dennoch wäre mir eine saubere Implementierung von DoT im resolver vom OS viel lieber. So wie bereits ab Android 9 zu sehen. Vielleicht ändert sich mein Gefühl ja etwas zusammen mit QUIC (HTTP/3)?!?

DoT DNS over TLS mit Bind, stunnel und Android 9

Die eigenen DNS Anfragen über eine Verschlüsselte Verbindung an einen DNS Server zu schicken welchem man vertraut, dieses liest sich schon gut oder? Keiner verfolgt mein Surfverhalten und zusammen mit DNSSEC schiebt mir so schnell keiner falsche Records unter 🙂

Am ehesten vertraue ich meinem eigenen DNS Server (ns1.kernel-error.de). Auf diesem arbeitet ein Bind und vor diesen habe ich für DoT stunnel gestellt. Die Konfiguration vom stunnel sieht dabei grob wie folgt aus:

[dns4]
accept = 853
connect = 127.0.0.1:53
cert = /usr/local/etc/stunnel/ssl/dns.crt
key = /usr/local/etc/stunnel/ssl/dns.key
CAfile = /usr/local/etc/stunnel/ssl/ca.crt
ciphers = ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256
options = NO_SSLv2
options = NO_SSLv3
options = NO_TLSv1
options = NO_TLSv1.1
options = CIPHER_SERVER_PREFERENCE
options = DONT_INSERT_EMPTY_FRAGMENTS
renegotiation = no
TIMEOUTclose = 0

[dns6]

accept = 2a03:4000:38:20e::53:853 connect = ::1:53 cert = /usr/local/etc/stunnel/ssl/dns.crt key = /usr/local/etc/stunnel/ssl/dns.key CAfile = /usr/local/etc/stunnel/ssl/ca.crt ciphers = ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256 options = NO_SSLv2 options = NO_SSLv3 options = NO_TLSv1 options = NO_TLSv1.1 options = CIPHER_SERVER_PREFERENCE options = DONT_INSERT_EMPTY_FRAGMENTS renegotiation = no

Die TLS Konfiguration ergibt dabei nun folgendes Bild: https://tls.imirhil.fr/tls/ns1.kernel-error.de:853

Auf einem Android 9 Gerät kann ich also nun unter den Einstellungen ==> Netzwerk & Internet ==> Erweitert ==> Privates DNS meinen Nameserver eintragen.

DoT Android 9

Jetzt sieht mir keiner mehr beim meinen DNS Abfragen zu 😀

DNS über TLS mit stunnel und Bind9

Ihr erinnert euch an meine Ankündigung über TLS an meinem DNS vor ein paar Tagen? RFC 7858 – DNS over Transport Layer Security

Bei mir ist inzwischen recht oft die Frage nach dem „Wie“ angekommen. Nun ich habe dafür stunnel benutzt. stunnel ist nicht speziell für DNS sondern ist ein Stück Software welches sich vor Dienste schalten lässt die keine oder eine schlechte Implementierung für SSL/TLS haben. Eine komplett stumpfe Konfiguration um zu testen würde zum Beispiel auf einem FreeBSD wie folgt aussehen:

/usr/local/etc/stunnel/conf.d/dnstls.conf

[dns4]
accept = 853
connect = 5.9.24.235:53
cert = /usr/local/etc/stunnel/ssl/dns.crt
key = /usr/local/etc/stunnel/ssl/dns.key
CAfile = /usr/local/etc/stunnel/ssl/ca.crt


[dns6]

accept = :::853 connect = 5.9.24.235:53 cert = /usr/local/etc/stunnel/ssl/dns.crt key = /usr/local/etc/stunnel/ssl/dns.key CAfile = /usr/local/etc/stunnel/ssl/ca.crt

So gestartet lässt sich eine TLS Verbinung zu Port 853 aufbauen und stunnel schiebt dann alles einfach weiter an den Bind auf Port 53. Ob eine SSL/TLS Verbindung aufgebaut werden kann testet man am besten mit openSSL: openssl s_client -connect ns1.kernel-error.de:853 -showcerts Ich werfe weiter unten mal den kompletten Output in den Post…

Um eine komplette DNS Abfrage über TLS zu prüfen nutze ich gerne getdns_query. Dieses ist bereits in den FreeBSD Ports. Ein Test würde wie folgt aussehen: getdns_query @5.9.24.235 -s -a -A -l L www.kernel-error.de AAAA die Option „-l L“ weißt getdns_query dabei an es per TLS zu probieren. Auch hier werde ich den kompletten Output weiter untem im Post zeigen.

Der versprochene openSSL Output

kernel@s-meer-bsd ~> openssl s_client -connect ns1.kernel-error.de:853 -showcerts
CONNECTED(00000003)
depth=2 C = BE, O = GlobalSign nv-sa, OU = Root CA, CN = GlobalSign Root CA
verify return:1
depth=1 C = BE, O = GlobalSign nv-sa, CN = AlphaSSL CA - SHA256 - G2
verify return:1
depth=0 OU = Domain Control Validated, CN = *.kernel-error.de
verify return:1
---
Certificate chain
 0 s:/OU=Domain Control Validated/CN=*.kernel-error.de
   i:/C=BE/O=GlobalSign nv-sa/CN=AlphaSSL CA - SHA256 - G2
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
 1 s:/C=BE/O=GlobalSign nv-sa/CN=AlphaSSL CA - SHA256 - G2
   i:/C=BE/O=GlobalSign nv-sa/OU=Root CA/CN=GlobalSign Root CA
-----BEGIN CERTIFICATE-----
MIIETTCCAzWgAwIBAgILBAAAAAABRE7wNjEwDQYJKoZIhvcNAQELBQAwVzELMAkG
A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw0xNDAyMjAxMDAw
MDBaFw0yNDAyMjAxMDAwMDBaMEwxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
YWxTaWduIG52LXNhMSIwIAYDVQQDExlBbHBoYVNTTCBDQSAtIFNIQTI1NiAtIEcy
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2gHs5OxzYPt+j2q3xhfj
kmQy1KwA2aIPue3ua4qGypJn2XTXXUcCPI9A1p5tFM3D2ik5pw8FCmiiZhoexLKL
dljlq10dj0CzOYvvHoN9ItDjqQAu7FPPYhmFRChMwCfLew7sEGQAEKQFzKByvkFs
MVtI5LHsuSPrVU3QfWJKpbSlpFmFxSWRpv6mCZ8GEG2PgQxkQF5zAJrgLmWYVBAA
cJjI4e00X9icxw3A1iNZRfz+VXqG7pRgIvGu0eZVRvaZxRsIdF+ssGSEj4k4HKGn
kCFPAm694GFn1PhChw8K98kEbSqpL+9Cpd/do1PbmB6B+Zpye1reTz5/olig4het
ZwIDAQABo4IBIzCCAR8wDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8C
AQAwHQYDVR0OBBYEFPXN1TwIUPlqTzq3l9pWg+Zp0mj3MEUGA1UdIAQ+MDwwOgYE
VR0gADAyMDAGCCsGAQUFBwIBFiRodHRwczovL3d3dy5hbHBoYXNzbC5jb20vcmVw
b3NpdG9yeS8wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5nbG9iYWxzaWdu
Lm5ldC9yb290LmNybDA9BggrBgEFBQcBAQQxMC8wLQYIKwYBBQUHMAGGIWh0dHA6
Ly9vY3NwLmdsb2JhbHNpZ24uY29tL3Jvb3RyMTAfBgNVHSMEGDAWgBRge2YaRQ2X
yolQL30EzTSo//z9SzANBgkqhkiG9w0BAQsFAAOCAQEAYEBoFkfnFo3bXKFWKsv0
XJuwHqJL9csCP/gLofKnQtS3TOvjZoDzJUN4LhsXVgdSGMvRqOzm+3M+pGKMgLTS
xRJzo9P6Aji+Yz2EuJnB8br3n8NA0VgYU8Fi3a8YQn80TsVD1XGwMADH45CuP1eG
l87qDBKOInDjZqdUfy4oy9RU0LMeYmcI+Sfhy+NmuCQbiWqJRGXy2UzSWByMTsCV
odTvZy84IOgu/5ZR8LrYPZJwR2UcnnNytGAMXOLRc3bgr07i5TelRS+KIz6HxzDm
MTh89N1SyvNTBCVXVmaU6Avu5gMUTu79bZRknl7OedSyps9AsUSoPocZXun4IRZZ
Uw==
-----END CERTIFICATE-----
---
Server certificate
subject=/OU=Domain Control Validated/CN=*.kernel-error.de
issuer=/C=BE/O=GlobalSign nv-sa/CN=AlphaSSL CA - SHA256 - G2
---
No client certificate CA names sent
Peer signing digest: SHA512
Server Temp Key: ECDH, P-256, 256 bits
---
SSL handshake has read 4014 bytes and written 433 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES256-GCM-SHA384
Server public key is 4096 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES256-GCM-SHA384
    Session-ID: B1956B432DABE228C78E756329A796FA56C9646BE64326F8F96782BD946CCA82
    Session-ID-ctx: 
    Master-Key: 10329FBAE32471FC56D45E0AA0971CF5EB7977F7569AE4079219D9438E7A0F9DA8EC4150D9A074FC0AD8E63E00849047
    Key-Arg   : None
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    Start Time: 1513937385
    Timeout   : 300 (sec)
    Verify return code: 0 (ok)
---

Der versprochene getdns_query Output:

kernel@s-meer-bsd ~> getdns_query @5.9.24.235 -s -a -A -l L www.kernel-error.de AAAA
{
  "answer_type": GETDNS_NAMETYPE_DNS,
  "canonical_name": <bindata for www.kernel-error.de.>,
  "just_address_answers":
  [
    {
      "address_data": <bindata for 2a01:4f8:161:3ec::443>,
      "address_type": <bindata of "IPv6">
    },
    {
      "address_data": <bindata for 5.9.24.250>,
      "address_type": <bindata of "IPv4">
    }
  ],
  "replies_full":
  [
     <bindata of 0xd3578500000100010003000703777777...>,
     <bindata of 0xe9288500000100010003000703777777...>
  ],
  "replies_tree":
  [
    {
      "additional":
      [
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns1.kernel-error.de.>,
          "rdata":
          {
            "ipv4_address": <bindata for 5.9.24.235>,
            "rdata_raw": <bindata of 0x050918eb>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns2.kernel-error.org.>,
          "rdata":
          {
            "ipv4_address": <bindata for 176.9.109.53>,
            "rdata_raw": <bindata of 0xb0096d35>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns3.kernel-error.com.>,
          "rdata":
          {
            "ipv4_address": <bindata for 203.137.119.119>,
            "rdata_raw": <bindata of 0xcb897777>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns1.kernel-error.de.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2a01:4f8:161:3ec::53>,
            "rdata_raw": <bindata of 0x2a0104f8016103ec0000000000000053>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns2.kernel-error.org.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2a01:4f8:150:1095::53>,
            "rdata_raw": <bindata of 0x2a0104f8015010950000000000000053>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns3.kernel-error.com.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2001:310:6000:f::1fc7:1>,
            "rdata_raw": <bindata of 0x200103106000000f000000001fc70001>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        },
        {
          "do": 0,
          "extended_rcode": 0,
          "rdata":
          {
            "rdata_raw": <bindata of 0x>
          },
          "type": GETDNS_RRTYPE_OPT,
          "udp_payload_size": 4096,
          "version": 0,
          "z": 0
        }
      ],
      "answer":
      [
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for www.kernel-error.de.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2a01:4f8:161:3ec::443>,
            "rdata_raw": <bindata of 0x2a0104f8016103ec0000000000000443>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        }
      ],
      "answer_type": GETDNS_NAMETYPE_DNS,
      "authority":
      [
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for kernel-error.de.>,
          "rdata":
          {
            "nsdname": <bindata for ns2.kernel-error.org.>,
            "rdata_raw": <bindata for ns2.kernel-error.org.>
          },
          "ttl": 86400,
          "type": GETDNS_RRTYPE_NS
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for kernel-error.de.>,
          "rdata":
          {
            "nsdname": <bindata for ns1.kernel-error.de.>,
            "rdata_raw": <bindata of 0x036e7331c010>
          },
          "ttl": 86400,
          "type": GETDNS_RRTYPE_NS
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for kernel-error.de.>,
          "rdata":
          {
            "nsdname": <bindata for ns3.kernel-error.com.>,
            "rdata_raw": <bindata for ns3.kernel-error.com.>
          },
          "ttl": 86400,
          "type": GETDNS_RRTYPE_NS
        }
      ],
      "canonical_name": <bindata for www.kernel-error.de.>,
      "header":
      {
        "aa": 1,
        "ad": 0,
        "ancount": 1,
        "arcount": 7,
        "cd": 0,
        "id": 54103,
        "nscount": 3,
        "opcode": GETDNS_OPCODE_QUERY,
        "qdcount": 1,
        "qr": 1,
        "ra": 0,
        "rcode": GETDNS_RCODE_NOERROR,
        "rd": 1,
        "tc": 0,
        "z": 0
      },
      "question":
      {
        "qclass": GETDNS_RRCLASS_IN,
        "qname": <bindata for www.kernel-error.de.>,
        "qtype": GETDNS_RRTYPE_AAAA
      }
    },
    {
      "additional":
      [
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns1.kernel-error.de.>,
          "rdata":
          {
            "ipv4_address": <bindata for 5.9.24.235>,
            "rdata_raw": <bindata of 0x050918eb>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns2.kernel-error.org.>,
          "rdata":
          {
            "ipv4_address": <bindata for 176.9.109.53>,
            "rdata_raw": <bindata of 0xb0096d35>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns3.kernel-error.com.>,
          "rdata":
          {
            "ipv4_address": <bindata for 203.137.119.119>,
            "rdata_raw": <bindata of 0xcb897777>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns1.kernel-error.de.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2a01:4f8:161:3ec::53>,
            "rdata_raw": <bindata of 0x2a0104f8016103ec0000000000000053>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns2.kernel-error.org.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2a01:4f8:150:1095::53>,
            "rdata_raw": <bindata of 0x2a0104f8015010950000000000000053>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for ns3.kernel-error.com.>,
          "rdata":
          {
            "ipv6_address": <bindata for 2001:310:6000:f::1fc7:1>,
            "rdata_raw": <bindata of 0x200103106000000f000000001fc70001>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_AAAA
        },
        {
          "do": 0,
          "extended_rcode": 0,
          "rdata":
          {
            "rdata_raw": <bindata of 0x>
          },
          "type": GETDNS_RRTYPE_OPT,
          "udp_payload_size": 4096,
          "version": 0,
          "z": 0
        }
      ],
      "answer":
      [
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for www.kernel-error.de.>,
          "rdata":
          {
            "ipv4_address": <bindata for 5.9.24.250>,
            "rdata_raw": <bindata of 0x050918fa>
          },
          "ttl": 300,
          "type": GETDNS_RRTYPE_A
        }
      ],
      "answer_type": GETDNS_NAMETYPE_DNS,
      "authority":
      [
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for kernel-error.de.>,
          "rdata":
          {
            "nsdname": <bindata for ns2.kernel-error.org.>,
            "rdata_raw": <bindata for ns2.kernel-error.org.>
          },
          "ttl": 86400,
          "type": GETDNS_RRTYPE_NS
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for kernel-error.de.>,
          "rdata":
          {
            "nsdname": <bindata for ns1.kernel-error.de.>,
            "rdata_raw": <bindata of 0x036e7331c010>
          },
          "ttl": 86400,
          "type": GETDNS_RRTYPE_NS
        },
        {
          "class": GETDNS_RRCLASS_IN,
          "name": <bindata for kernel-error.de.>,
          "rdata":
          {
            "nsdname": <bindata for ns3.kernel-error.com.>,
            "rdata_raw": <bindata for ns3.kernel-error.com.>
          },
          "ttl": 86400,
          "type": GETDNS_RRTYPE_NS
        }
      ],
      "canonical_name": <bindata for www.kernel-error.de.>,
      "header":
      {
        "aa": 1,
        "ad": 0,
        "ancount": 1,
        "arcount": 7,
        "cd": 0,
        "id": 59688,
        "nscount": 3,
        "opcode": GETDNS_OPCODE_QUERY,
        "qdcount": 1,
        "qr": 1,
        "ra": 0,
        "rcode": GETDNS_RCODE_NOERROR,
        "rd": 1,
        "tc": 0,
        "z": 0
      },
      "question":
      {
        "qclass": GETDNS_RRCLASS_IN,
        "qname": <bindata for www.kernel-error.de.>,
        "qtype": GETDNS_RRTYPE_A
      }
    }
  ],
  "status": GETDNS_RESPSTATUS_GOOD
}

Oh und weil ich gerade dabei war… Ich habe direkt ns2.kernel-error.org mit einem gültigen Zertifikat ausgestattet.

Fragen? Dann fragen 🙂

DNSSEC edns und path maximum transmission unit (PMTU) size beim bind – Fehlermeldung dnsviz

Mir ist in der letzten Zeit an ein paar Systemen ein kleines „Problem“ im Zusammenhang mit DNSSEC, IPv6 und UDP Paketgrößen aufgefallen. Wobei aufgefallen hier nicht ganz korrekt ist, ich bin durch http://dnsviz.net darauf gestoßen worden. Die Jungs kommen mir nämlich mit der folgenden Warnung entgegen:

domain.tld/A: No response was received until the UDP payload size was decreased, indicating that the server might be attempting to send a payload that exceeds the path maximum transmission unit (PMTU) size. (2001:210:5000:bbbb::aaaa:1, UDP_0_EDNS0_32768_4096)

Diese Meldung besagt das es vom jeweiligen DNS Server erst eine Antwort gegeben hat, nachdem die UDP Größe verringert wurde. Dieses fällt einem im normalen Tests mit dig / drill oder ähnlichem nicht wirklich auf. Denn hier wird absolut automatisch die Paketgröße weiter verringert bis es klappt. Es „dauert“ nur etwas länger….

Der DNS-Server, in diesem Fall ein bind9.11, versucht auf die Frage mit einem IPv6 UDP Paket zu Antworten und schickt dieses mit 4096 Byte raus. Aus irgendeinem Grund (Firewall, Einstellungen im OS, Filter auf dem Netzwerk….) wird dieses Paket auf seinem Weg aber verworfen und erreicht sein Ziel nicht. Da wir hier über UDP sprechen merkt das der Server nicht und glaubt er habe seinen Job gut gemacht. Woher soll bind auch wissen das sein Paket nicht angekommen ist oder irgendwas auf dem Weg sein Pakete mit dieser Größe nicht mag?

Um als Admins herauszufinden wie groß die Pakete von seinem System denn werden können kann man folgenden einfachen Test nutzen:

$ dig +short rs.dns-oarc.net txt
rst.x490.rs.dns-oarc.net.
rst.x499.x490.rs.dns-oarc.net.
rst.x457.x499.x490.rs.dns-oarc.net.
"2001:310:6000:f::1fc7:1 sent EDNS buffer size 512"
"Tested at 2017-07-05 08:23:52 UTC"
"2001:310:6000:f::1fc7:1 DNS reply size limit is at least 499"

Wie zu erkennen ist endet es auf diesem System bei 512 Byte. Wenn wir uns jetzt nicht weiter um den Grund kümmern wollen oder können, müssten wir also unserem bind sagen das er bitte immer nur mit maximal 512 Byte arbeitet, wenn er UDP nutzt. Dieses geht wie folgt im Options Block:

options {
	[....]
	edns-udp-size 512;
	max-udp-size 512;
	[....]
};

edns-upd-size ist hier für das Empfangen und max-udp-size für das Senden von Paketen. Ab dem Moment probiert es bind nur noch mit 512 Byte und die Clients werde auf ihre erste Frage hin direkt eine Antwort bekommen, ohne die Frage so oft wiederholen zu müssen, bis sie schrittweise zurück auf 512 Byte sind.

So long…

DNSSEC IPv6 DENIC und ein DNS in Japan

Ich brauche mal eure Hilfe…

Zum Spaß habe ich mir einen VPS Server in Japan geklickt. Was nun damit tun? Einfach mal ein weiteren DNS Server nutzen \o/ Gute Idee? Nein… Warum nicht? Weil der Server in Japan steht, höhere Antwortzeiten hat und der meist zufällig entscheidet, welcher DNS Server nun gefragt wird. Ich habe somit also sporadisch DEUTLICH langsamere DNS Antworten. Für meinen Spieltrieb aber gerade OK .-P

Ist also nun ein FreeBSD 10 mit einem Bind9.11 als slave für drei Spielzonen (kernel-error.org, kernel-error.com, kernel-error.de). FreeBSD ans Ende gepatcht, aktuellen Bind drauf, getestet ob die Kiste sauber signierte Zonen abfragen und prüfen kann (TCP/UDP und größer 512) alles gut. Dann als slave eingebunden wieder getestet und dann in die Zone darüber eintragen lassen. Die Zonen org. sowie com. haben den DNS-Server einfach gefressen. die Zone de. meckert aber! DNS timeout bei IPv6 O_o Öhm, ok… dig und drill sagen das geht aber. Bind ist auch fest ein und ausgehend an die IPv6 Adresse gebunden. Als „Firewall“ rennt PF, das mal deaktiviert ändert aber nichts. Vielleicht filter der Provider? Nope nur switch, iptables und ebtables öhm, das klingt sehr spartanisch.

Hat das Problem nur denic? Nö, DNSViz scheint es auch nicht zu können: http://dnsviz.net/d/kernel-error.com/dnssec/

Wie gesagt NUR bei IPv6! Jetzt habe ich mir alle Mühe gegeben diesen Timeout selbst mal zu produzieren, klappt aber nicht. Bei mir geht es einfach IMMER egal was für Optionen ich dig mitgebe.

# dig @2001:310:6000:f::1fc7:1 +edns +multi +norec +bufsize=4096 kernel-error.com IN MX +short
10 smtp.kernel-error.de.
# dig @2001:310:6000:f::1fc7:1 +tcp +edns +multi +norec +bufsize=4096 kernel-error.com IN MX +short
10 smtp.kernel-error.de.

Ich verstehe das nicht! Ich mache am bind keine Unterscheidung zwischen IPv4 und IPv6, für mich geht alles. Alle Antworten und Fragen in alle Richtungen laufen ohne jedes Problem. Nur DNSViz und denic scheinen ein „Problem“ zu haben. Mal sehen ob jemand von der denic mit einen sinnvollen Tipp geben kann. Mir würde ja schon der dig Aufruf reichen der zu einem timeout führt :-/ Dann hätte ich etwas zum Testen.

Oh ja, ich habe natürlich auch ganz brav mal tcpdump laufen lassen. Leider sieht es hier ebenfalls einfach funktionstüchtig aus 🙁

https://www.kernel-error.de/download/dns.tar.gz

Hat von euch irgendjemand eine Idee?


*U-P-D-A-T-E*

Die interne Fehlermeldung der API DENIC:

ERROR: 223 Timeout after switching from UDP to TCP – switch to TCP due to timeout (target) (ns3.kernel-error.com./2001:310:6000:f:0:0:1fc7:1:53)


*U-P-D-A-T-E*

Mal querry log eingeschaltet:

30-Jan-2017 18:30:04.669 client @0x802e62600 2a02:568:201:214::1:15#38145 (ns3.kernel-error.com): query: ns3.kernel-error.com IN A -E(0)DC (2001:310:6000:f::1fc7:1)
30-Jan-2017 18:30:04.670 client @0x802e62600 2a02:568:201:214::1:15#41589 (ns3.kernel-error.com): query: ns3.kernel-error.com IN AAAA -E(0)DC (2001:310:6000:f::1fc7:1)
30-Jan-2017 18:30:04.938 client @0x802e62600 2a02:568:201:214::1:15#20703 (kernel-error.de): query: kernel-error.de IN SOA - (2001:310:6000:f::1fc7:1)
30-Jan-2017 18:30:05.510 client @0x802e6f800 2a02:568:201:214::1:15#58465 (kernel-error.de): query: kernel-error.de IN NS -T (2001:310:6000:f::1fc7:1)
30-Jan-2017 18:30:05.889 client @0x802e62600 2a02:568:201:214::1:15#47548 (kernel-error.de): query: kernel-error.de IN SOA -E(0)D (2001:310:6000:f::1fc7:1)
30-Jan-2017 18:30:05.896 client @0x802e62600 2a02:568:201:214::1:15#55493 (kernel-error.de): query: kernel-error.de IN DNSKEY -E(0)D (2001:310:6000:f::1fc7:1)
30-Jan-2017 18:30:06.416 client @0x802e70c00 2a02:568:201:214::1:15#37170 (kernel-error.de): query: kernel-error.de IN DNSKEY -E(0)TD (2001:310:6000:f::1fc7:1)

*U-P-D-A-T-E*

Ich glaube es nicht… Ich teste hier gerade rum, will einem Kollegen zeigen das es nicht geht und das Update läuft bei DENIC einfach durch und OK Ö_ö ich verstehe das nicht, wirklich nicht. Absolut 0,0 warum geht das jetzt und warum meint DNSViz das es dennoch nicht geht? Was passiert hier?


*U-P-D-A-T-E*

Bleibt nur noch meine Vermutung, dass es wirklich um die Antwortzeit des Servers geht… Die liegt so zwischen 200 und 300ms. Das ist echt lange aber auch nicht SOOOOOOO lange :-/ Mal sehen ob von denic irgendwas kommt?!?!


*U-P-D-A-T-E*

Da fliegt mir doch gerade folgende Info rein:

die DENIC meinte dazu:

    unsere Kollegen können derzeit nicht genau sagen woran es hängt. Jedoch sind unsere Verbindungen nach Korea zeitweise leicht beeinträchtigt, evtl. wurde dir Nast Prüfung genau in dem Moment durchgeführt.


Es scheint als bekommen wir das nicht geklärt. Aber schön, wenn das
Update nun durch ist.

PS: Ein leicht ungutes Gefühl bleibt ...

Mein kleines DNSSEC Howto

Die Domain Name System Security Extensions (DNSSEC) sind eine Erweiterung des DNS, mit der Authentizität und Datenintegrität von DNS-Transaktionen gewährleistet werden. Ein DNS-Teilnehmer kann damit verifizieren, dass die durch den Server, mit dem er kommuniziert, gelieferten Zonendaten auch tatsächlich identisch mit denen sind, die der für die Zone autorisierte und die Zone signierende Server ausliefert. DNSSEC wurde als Mittel gegen Cache-Poisoning entwickelt, Serverauthentifizierung findet nicht statt. Wer jetzt noch genauere Informationen dazu haben möchte beginnt am besten >>hier<<….

Was mich beim ersten Lesen eines Artikels zu DNSSEC etwas durcheinander gebracht hat, war dieses Umhergewerfe mit den Begriffen: KSK, ZSK, SEP, DNSKEY, RRSIG und DS… Daher versuche ich das mal kurz verständlich zu erklären, den im Grunde ist das alles total einfach!
Der KSK (Key signing Key) hat grob gesehen nur eine einzige Aufgabe. Er muss den ZSK (Zone signing Key) unterschreiben. Der KSK ist nämlich immer in der übergeordneten Zone hinterlegt (von kernel-error.org ist die übergeordnete Zone z.B.: org). Der ZSK hat auch nur eine Aufgabe, das unterschreiben der Zone…..
Es beginnt also alles mit dem KSK der Rootzone. Die Rootzone ist „.“! Mal angenommen wir wollen nach www.kernel-error.org fragen. Dann geht es ganz oben los. Die Nameserver der Rootzone wissen welche Nameserver für die einzelnen TLDs (Top level domains) zuständig sind. Die Nameserver der TLDs wissen welche Nameserver für die einzelnen Unterdomains (z.B.: kernel-error.org) zuständig sind. Der Nameserver der Unterdomain kennt nun selbst die Adresse für www.kernel-error.org oder kann zumindest sagen welcher Nameserver für die Unterdomain „www“ zuständig ist. Will ein Angreifer nun also dafür sorgen dass man mit seinem Browser beim Aufruf von www.kernel-error.org nicht auf meinem Webserver landet, sondern auf seinem (bei Banken hätte das ja was, oder?), dann hat er zwei einfache Möglichkeiten.

  1. Er antwortet auf die Anfrage des Clients (wer ist denn der für die Domain kernel-error.org zuständige Nameserver) mit seinem eigenen Nameserver. Somit fragt der Client immer den Nameserver des Angreifers, welcher mit den falschen Adressen antwortet.
  2. Er antwortet auf jede Anfrage des Clients (mit gefälschter Absenderkennung) schneller als der eigentlich zuständige DNS-Server und kann so falsche Informationen übermitteln.

Mal angenommen man würde nun auf DNSSEC setzten und jeder Nameserver würde seine Zone signieren. Woher wüsste man dann, dass die Antwort korrekt ist? Angreifer können genau so signierte Antworten schicken. Genau, man muss die Gültigkeit der Signatur prüfen. Genau dafür ist nun der KSK. Der KSK signiert die Zone und zusätzlich wird der KSK jeweils in der übergeordneten Zone bekannt gemacht. Die übergeordnete Zone wird mit dem ZSK signiert, welcher mit dem KSK der übergeordneten Zone unterschrieben wurde, dieser KSK ist natürlich wieder der Zone darüber bekannt…. Man kann also Stück für Stück nach oben gehen. Am Ende steht dann der KSK der Root-Zone. Die folgende Zeichnung soll das ganze noch verständlicher darstellen.

DNSSEC Vertrauenskette

Sollte es jemandem denn noch nicht klar sein, helfe ich gerne weiter. >>Einfach fragen<<

Es sind leider noch lange nicht alle TLDs signiert bzw. haben DS-Records in den Root-Servern. Eine ganz nette Liste über bereits signierte TLDs findet sich hier: https://www.tldwithdnssec.se/
Unsere DENIC hat ein .de testbed eingerichtet. Die Jungs wollen Anfang 2011 aber auch loslegen. Infos zum DENIC DNSSEC testbed gibt es hier.

Möchte man seine Domain per DNSSEC schützen muss natürlich als erstes der für die Domain zuständige DNS-Server DNSSEC unterstützen und es muss aktiviert sein. Klingt logisch, oder? Ich bin, unter anderem, ein Freund von Bind. Daher beschränke ich mich hier einfach mal auf diesen…. Ab ISC Bind 9.6.2 sind alle Tools und Funktionen wohl soweit ausgereift dass man es im Zusammenhang mit DNSSEC sauber nutzen kann!

DNSSEC schaltet man recht einfach im options-Block ein:

options {
........
dnssec-enable yes;
dnssec-validation yes;
........
};

Recursive DNS-Server benötigen natürlich noch den KSK der Rootzone. Diesen muss man als vertrauenswürdig einstufen. Am einfachsten bekommt man diesen mit folgendem Aufruf:

$ dig . dnskey | grep -w 257 > dnssec_root.key

Diesen legt man jetzt im trusted-keys Block ab:

trusted-keys {
. 257 3 8 "AwEAAagAIKlVZrpC6Ia7gEzahOR+9W29euxhJhVVLOyQbSEW0O8gcCjF FVQUTf6v58fLjwBd0YI0EzrAcQqBGCzh/RStIoO8g0NfnfL2MTJRkxoX bfDaUeVPQuYEhg37NZWAJQ9VnMVDxP/VHL496M/QZxkjf5/Efucp2gaD X6RS6CXpoY68LsvPVjR0ZSwzz1apAzvN9dlzEheX7ICJBBtuA6G3LQpz W5hOA2hzCTMjJPJ8LbqF6dsV6DoBQzgul0sGIcGOYl7OyQdXfZ57relS Qageu+ipAdTTJ25AsRTAoub8ONGcLmqrAmRLKBP1dfwhYB4N7knNnulq QxA+Uk1ihz0=";<br />};</div> <p>Um sicherzustellen das man auch den richtigen bekommen hat, erstellt man kurzerhand daraus einen DS-Record und vergleicht diesen...</p> <div style="padding: 7pt; width: 100%; background-color: #7e0000;"># dnssec-dsfromkey -2 dnssec_root.key

. IN DS 19036 8 2 49AAC11D7B6F6446702E54A1607371607A1A41855200FD2CE1CDDE32 F24E8FB5

Für die Integritätsprüfung dieses Schlüssels hat die ICANN mehrere Methoden spezifiziert. Dieses liest sich sehr gut >>hier<<.

Nun sollte man Bind neu starten, damit er die Änderungen übernimmt. Theoretisch ist Bind nun schon in der Lage mit DNSSEC umzugehen.

Frage ich z.B.: meinen DNS-Server zuhause nach einer signierten Domain (www.cacert.org), das Flag +ad fordert den Nameserver auf die Antwort per DNSSEC zu validieren:

$ dig +ad www.cacert.org SOA @2a01:198:6ce::1

Dann bekomme ich die folgende Antwort.

dig +ad www.cacert.org SOA

Möchte man wissen ob sein DNS-Server überhaupt DNSSEC beherrscht, setzt man bei seiner Anfrage einfach das Flag +dnssec
Beherrscht der gefragte Nameserver DNSSEC erhält man signierte Records….

$ dig +dnssec www.cacert.org SOA @2a01:198:6ce::1
dig +dnssec www.cacert.org SOA

Gehen einem die, gleich erstellten, Schlüssel verloren, oder die signierte Zonendatei brennt ab, hat mein ein Problem. Genau wie bei der eigentlichen Einrichtung oder Aktualisierung ist die Reihenfolge sehr wichtig und einzuhalten. Denn die rekursiven DNS-Server halten ja für die Zeit der TTL die Abfrage im Cache…. Somit könnte man, bei falschem Vorgehen, für die Zeit der längsten TTL ~nicht~ erreichbar sein!

Ich habe mir folgenden Masterplan fürs DNSSEC aufgestellt. Im Grunde nichts weiter also vor jeder „großen“ Änderung immer die längste TTL der Zone abzuwarten und fertig! Dieses habe ich mir mal irgendwann aufgemalt (nicht schön aber extrem selten). Hier also dieses ~analoge~ Bild!

Analoger DNSSEC Masterplan

Nun könnte man schon beginnen seine Zonen zu signieren. Dazu muss natürlich erstmal ein neuer Schlüssel erzeugt werden. In meinem Fall dreht sich alles um die Domain kernel-errror.org
Um für diese ZONE nun einen 4096 Bit langen KSK zu erzeugen gibt man folgendes ein:

$ dnssec-keygen -r /dev/urandom -f KSK -a NSEC3RSASHA1 -b 4096 -n ZONE kernel-error.org
Kkernel-error.org.+007+55836

Den ZSK für die ZONE erstellt man mit:

$ dnssec-keygen -r /dev/urandom -a NSEC3RSASHA1 -b 4096 -n ZONE kernel-error.org
Kkernel-error.org.+007+25685

Nun finden sich im Verzeichnis vier neue Dateien. Kkernel-error.org ist die Domain, +007 ist der Schlüsseltyp und +55836 bzw. +25685 ist die ID des Schlüssels. Die Endung .key bezeichnet jeweils den öffentlichen Teil, .privat steht für den privaten Teil. Den privaten Teil sollte keiner in die Finger bekommen

Den öffentlichen Teil des KSK und des ZSK müssen nun noch in der Zone hinzugefügt werden.

$ cat *.key >> kernel-error.org

Der öffentliche Teil des KSK ist zusätzlich der Teil, welcher in der übergeordneten Zone publiziert werden muss. In diesem Fall müssen also die Jungs an den Root-Servern der TLD .org einen DS aus unserem öffentlichen KSK erstellen und ihn neben die NS-Records klatschen! Das läuft überall etwas anders. Die Vorgehensweise von der DENIC und EURID schaut so aus, dass man seinen öffentlichen KSK dort hinschickt die Jungs basteln daraus einen DS-Record (sie trauen es einem wohl nicht selbst zu) und veröffentlichen diesen daraufhin.

Somit kann man nun das eigentliche Zonenfile signieren 🙂 Folgender Aufruf erledigt dieses:

dnssec-signzone -r /dev/urandom -e +31104000 -k Kkernel-error.org.+007+55836 -f kernel-error.org.signed kernel-error.org Kkernel-error.org.+007+25685
Verifying the zone using the following algorithms: NSEC3RSASHA1.
Zone signing complete:
Algorithm: NSEC3RSASHA1: ZSKs: 1, KSKs: 1 active, 0 revoked, 0 stand-by
kernel-error.org.signed

+31104000 ist hier etwas besonders. Denn das ist die Zeit in Sekunden, welche die Signatur gültig ist. In diesem Fall 360 Tage….

Nun teilt man Bind noch mit dass er anstelle der Zonendatei kernel-error.org die Datei kernel-error.org.signed >>laden<< soll, restart und schon ist die Arbeit fast beendet… Änderungen an der Zone nimmt man nun weiterhin wie gewohnt in der kernel-error.org vor, muss nach diesen Änderungen nur jeweils die Zone neu signieren. Ist ja klar, oder?

Man darf natürlich nicht vergessen den KSK in der übergeordneten Zone bekannt zu machen. Für die Publikation des KSK haben die meisten Registries ein Webinterface (meiner leider nicht :-/). Am Ende sind dann neben den NS-Records auch die nötigen DS-Records. Ob diese gesetzt sind findet man am besten heraus, indem man die DNS-Server der übergeordneten Zone (hier also die der TLD .org) danach fragt…..

$ dig org. in NS

Wirft uns die zuständigen DNS-Server für die TLD .org entgegen. Von diesen fischt man sich einfach einen heraus und fragt nach dem DS-Record der gewünschten Domain (ich frage einfach mal wieder nach cacert.org)!

$ dig +short @b2.org.afilias-nst.org cacert.org in DS
cacert.org.             86400   IN      DS      59365 3 1 DA0668FAF7F726EF64284FC8D1393CF3DD0A39C5
cacert.org.             86400   IN      DS      59365 7 2 3A4F6F9F8CFB0FABB508CDE5E874206F159B8A893938A8792C091613 6CF499BD

Vom feinsten, oder?


Gibt es etwas besonders zu beachten, gibt es Probleme?

Ja, die gibt es :-/

Normalerweise läuft die Kommunikation mit den Nameservern über das UDP Protokoll, schlägt dieses fehl kommt der Fallback auf TCP. Das UDP Protokoll hat aber ein Größenlimit von 512 Bytes pro Paket. Die Schlüssel bei DNSSEC sind dafür einfach zu groß. Vor allem bei NSEC3 Schlüsseln! EDNS (Extension Mechanisms for DNS) heben dieses auf. EDNS (RFC 2671) erlaubt nämlich unter anderem größere Pakete. Dieses wurde alles schon 1999 festgelegt. Na ja, wie bei so vielen schönen Dingen hängt, wie z.B. bei IPv6, die Umsetzung leider etwas durch . Somit hat die ein oder andere Firewall, security appliance und vor allem einige plaste DSL-Router damit Probleme. Einige lösen einfach nichts mehr auf und andere erschrecken sich bei einer signierten Antwort so sehr, dass sie erstmal abstürzen!


Ich als Freund vom Firefox habe da noch ein Addon gefunden. Dieses Firefox Plugin, der DNSSEC Validator zeigt einem jeweils den Status der aktuellen Seite an: https://addons.mozilla.org/de/firefox/addon/64247/


* UPDATES 08.02.2011 *

Heute gibt es zwei schöne Updates….

1. DeNIC will die de-Domain bald signieren
2. Mein Registrar hat es endlich geschafft meinen DS-Record in der ORG-Zone zu veröffentlichen 🙂

Domain kernel-error.org ist nun sauber signiert

Ich habe mir natürlich auch mal angeschaut in wie weit Microsofts Serverbetriebssystem hier mitspielt. Windows Server 2008 R2 SP1…. Der mitgelieferte DNS-Server soll/kann DNSSEC. Leider frisst der DNS-Server aus den Windows Sever 2008 R2 SP1 Boardmitteln nur Schlüssel vom Type SHA1. Das kommt daher, weil zuerst geplant war die ROOT-Zone so zu signieren. Später ist es dann aber doch SHA256 geworden. Daher lässt sich mit dem Systemeigenen DNS-Server nicht viel anfangen. Im SP2rc habe ich auch keine Verbessungen dazu gesehen. Wann dazu ein Update kommt, keine Ahnung 🙂

Davon mal abgesehen…. So geht es!

Windows Server2008RC2 SP1 DNSSEC

Klickt man im DNS-Manager mit der rechten Maustaste auf den gewünschten DNS-Server und geht dort in die Eigenschaften öffnen sich diese auch in einem neuen Fenster. Hier findet sich nun der Reiter: „Anchors für Vertrauensstellung“. Hier werden nun alle als vertrauenswürdig eingestuften Schlüssel aufgelistet. Die DNSKEYs der TLD se sind schon seit (ich glaube) 2007 signiert. Die Jungs haben Schlüssel vom Type SHA1… Diese lassen sich also importieren. Die Schlüssel besorgt man sich am einfachsten wieder mit dig:

$ dig se. dnsskey
dig se. dnssec

Nun ist es wohl am Einfachsten die Schlüssel in einen Texteditor zu werfern und dort schnell die Leerzeichen zu entfernen, sonst firsst der Windows Server 2008RC2 SP1 DNS-Server die Schlüssel nicht!

DNSKEY se anpassen

Dann schnell die Eingabeaufforderung des Admins öffnen und mit dem Befehl:

c:\>dnscmd /TrustAnchorADD se ##Schlüssel##

Den DNSKEY In den lokalen DNS-Server werfen…..

Windows Server 2008RC2 SP1 DNS-Server DNSSEC

Und schon ist der Schlüssel in der Liste 🙂 Auch wenn man damit keine vollständige Vertrauenskette bilden kann.
Wir warten also alle mal auf ein Update!
Was der Microsoft Server 2011 da kann, werde ich in den nächsten Tagen mal testen.


Ok, habe mir dann mal den Microsoft Windows Server 2011 SBS in den ESX4-Cluster geworfen…. Was soll ich sagen? Laut GUI kann der 2011 SBS Standard DNS-Server das auch ~noch~ nicht 🙁

Microsoft Windows Server 2011 SBS DNSSEC

Wer mit Microsoft Systemen und deren Boardmitteln arbeiten will, dem bleibt nichts weiter übrig als zu warten….


* UPDATES 22.02.2011 *

Ich habe gerade meine kernel-error.de Domain auch signiert. Mein Registrar hat den DNSKEY freundlicherweise direkt veröffentlicht. Das bringt zwar erst etwas, wenn die TLD de. offiziell signiert ist…. Denn noch fängt der frühe Vogel den Wurm (oder so ähnlich)!

Über die Resolver aus dem DeNIC Testbed kann natürlich auch jetzt schon sauber abgefragt werden!

dnssec kernel-error.de denic testbed dnskey
DNSSEC Testbed DNSKEY kernel-error.de

* UPDATE 08.06.2011 *

Wooohoooo DeNIC hat ja inzwischen die TLD de sauber signiert. Inzwischen sind die DS-RR auch in der Root-Zone angekommen und nutzbar 🙂 Damit ist die TLD .de. fertig signiert und voll nutzbar *freu*


* UPDATE 28.02.2012 *

Ich habe gerade alles in die Wege geleitet um die Domain: kernel-error.com zu schützen.

Zusätzlich habe ich eine ganz nette Möglichkeit gefunden sich alles nett grafisch darstellen zu lassen. Für meine Domains wären es folgende Links:

https://dnsviz.net/d/kernel-error.de/dnssec/
https://dnsviz.net/d/kernel-error.org/dnssec/
https://dnsviz.net/d/kernel-error.com/dnssec/

Wer sich den Link anschaut, wird erkennen wie er schnell „seine“ Domain dort eintragen kann.

Um zu testen ob sein eigener Rechner derzeit überhaupt die Möglichkeit hat mit DNSSEC zu arbeiten klickt am besten kurz hier:

https://test.dnssec-or-not.org/

* UPDATE 27.05.2012 *

Wenn man schon eine so geschützten DNS-Server hat, dann lassen sich natürlich sehr gut darüber weitere Informationen als nur A-RECORDS oder ähnliches verteilen.

Ich habe hier https://www.kernel-error.de/dnssec/gpg-im-dns beschrieben wie sich die eigenen GPG Schlüssel über den DNS Server verteilen lassen und hier https://www.kernel-error.de/dnssec/ssh-key-im-dns ist beschrieben wie sich mit OpenSSH die Fingerprints einzelner Hosts mit dem DNS Server abgleichen lassen.


* UPDATE 12.10.2012 *

Ich glaub es nicht der geht… nö der geööööhhht!

Der Microsoft Windows Server 8 also öhm der Microsoft Windows Server 2012 kann es. Komplett sauber und ganz Microsoft in klickibunti… Ich habe sogar sinnige und nutzbare Informationen zu dem Thema bei Microsoft selbst gefunden.
Es lässt sich wirklich fast alles mit der Maus erledigen, vom Zonen signieren bis im Im- und Export von allem möglichen Zeugs. Auch eine Schritt für Schritt Anleitung habe ich gefunden. https://technet.microsoft.com/en-us/library/hh831411.aspx

Ich habe hier auch noch ein paar Bilder zum gucken!


* UPDATE 10.08.2013 *

Jetzt sind zusätzlich die TLS/SSL Schlüssel meiner Dienste per DANE mit dem DNS abgleichbar 🙂


* UPDATE 14.11.2012 *

Ich habe dann mal die Schlüssellänge auf 4096bit angepasst 😀

© 2022 -=Kernel-Error=-

Theme von Anders NorénHoch ↑