Wer auf die Schnelle ein paar Brötchen backen will, dem kann ich folgendes Rezept empfehlen:

  • 250g Quark
  • 270g Mehl (Ich nehme meistens Dinkel, aber Roggenmehl geht auch gut. Hier kann man gut und gerne experimentieren.)
  • 1 Päckchen Backpulver
  • 2 Eier
  • 1 Prise Salz

Die Zubereitung dann so:

  • Alle Zutaten in eine Schüssel geben. Mehl und Backpulver am besten mit einem Zerstäuber zerstäuben, damits nicht klumpt.
  • Mittels Handmixer mit Knethaken alles vermengen.
  • Eine seperate Schüssel mit Mehl bereitstellen.
  • Backblech mit Backpapier bereitstellen.
  • Den Backofen auf 180°C vorwärmen,
  • Die Hände leicht anfeuchten.
  • Ein Stück Teig herrausnehmen und zu einer Kugel formen.
  • Kugel im Mehl rollen und aufs Backblech legen.
  • Die letzten 3 Schritte so oft wiederholen, bis der Teig komplett verarbeitet wurde.
  • Das Blech in den Ofen schieben.
  • Die Brötchen brauchen etwa 30 Minuten bis sie fertig sind. Am besten alle 10 Minuten nachsehen, wie weit sie gediehen sind.

Die fertigen Brötchen sehen bei mir dann so aus:

broetchen

Wenn man eine über DNSSEC gesicherte Zone betreibt, kenn man das Problem vieleicht: Man hat die Zone signiert aber man vergisst nach den 30 Tagen eine neue Signatur zu erzeugen.

Ich habe mir dafür inzwischen einen Cronjob der in regelmäßigen Abständen die Zone neu generiert. Aber es ist doch sinnvoll über Zabbix die Zonen zu überwachen das keine Domäne aus dem Raster fällt.

Ich habe dazu check-rrsig geschrieben, welches das Ablaufdatum der Signatur überprüft. Das Skript verlangt als Parameter einen Hostnamen, optional kann man noch einen anderen Resolver als der aus /etc/resolv.conf angeben und Debugmeldungen einschalten. Als erster Schritt wird zuerst der Hostname validiert, dazu verwende ich die Bibliothek Respect\Validation. Danach finde ich den Namensserver herraus der den Hostnamen zu Verfügung stellt herraus und frage diesen, über die Bibliothek net_dns2, direkt ab, da ich etwaige Caches umgehe, da ich ja einen möglichst realistischen Wert haben will. Dann frage ich von dem Original den ersten RRSIG-Record ab und extrahiere bei diesem den Ablaufzeitpunkt. Dann bilde ich noch den Unterschied zwischen dem aktuellen Datum und dem Ablaufdatum, gebe es zurück und bin fertig.

Die Integration in Zabbix ist damit relativ einfach. Man schafft die phar-Datei auf dem Zabbix-Server nach /etc/zabbix/externalscripts und kann dann ein Item entweder in einem Host oder in einem Template über einen External Check das Skript abrufen und Werte erfassen.

Ziel dieses Artikel ist es zu zeigen wie mein OpenVPN-Setup funktioniert, wie ich meine Clients konfiguriere und was das für Vorteile bringt.

Fangen wir mal mit dem warum an. Mein initiales anliegen war in das virtuele Netzwerk meines libvirt/KVM-Hostes einzusteigen, damit ich die virtuellen Maschienen besser verwalten kann. Ich habe zuerst an IPSec versucht, bin da aber an der harschen Internet-Realität gescheitert. So hat mein Internet-Anbieter Kabel Deutschland fragmentierte UDP-Pakete klammheimlich verworfen. Hat mit mich einige Zeit gekostet das raus zu finden, aber dank Netalyzr findet man solche Sachen dann doch relativ schnell. An dieser Stelle muss ich mal eine Lanze für Netalyzr brechen, wenn ihr in ein neues Netz kommt, führt den Test einmal aus, um euch der Limitationen des Netzes bewust zu werden. Dann habe ich mich an OpenVPN versucht und alles funktionierte ohne mit der Wimper zu zucken.

Bevor ich jetzt zu der Konfiguration komme, noch ein paar Takte zu meiner Infrastruktur.

Infrastruktur

Ich habe einen Server bei Hetzner gemieted auf dem ich mehrere virtuelle Maschienen mit unterschiedichen Diensten. Da ich nur eine IPv4-Addresse habe und aus kostengründen nichts ändern will, habe ich ein privates LAN mit NAT für die ganzen virtuellen Rechner eingerichtet. Das IPv4-Lan hat den Prefix 192.168.122.0/24, dieser Prefix sollte natürlich auch über das VPN erreichbar sein. Daneben habe ich von Hetzner einen nativen IPv6 Zugang erhalten und habe den Prefix 2a01:4f8:200:2265::/64. Was im Verlauf des einrichtens gelernt habe ist, das wenn man verschiedene Unterinfrastrukturen hat, diese auch mit eigenen Prefixen beglücken. So habe ich den /64 in mehrere /112-Netze aufgeteilt. Die Virtuellen Server haben den Prefix 2a01:4f8:200:2265:3::/112 und das VPN-Netz hat 2a01:4f8:200:2265:4::/112. Was ich in diesem Kontext auch gelernt habe, das 2000::/3 der komplette öffentlich routbare Teil von IPv6 ist. Zum Schluss sei noch gesagt das ich einen LDAP-Verzeichnis betreibe in dem ich Benutzer verwalte, das sollte auch an das OpenVPN angebunden werden. Soviel zur Infrastruktur, jetzt zur Konfiguration.

Server Konfiguration

Meine Server Konfiguration sieht so aus:

# Crypto konfigurieren
ca /etc/ipsec.d/cacerts/cacert.pem
cert /etc/ipsec.d/certs/node2.datenknoten.me.pem
key /etc/ipsec.d/private/node2.datenknoten.me.pem
dh /etc/ipsec.d/dh4096.pem

# Netzwerk aufsetzen
server 10.8.0.0 255.255.255.0
server-ipv6 2a01:4f8:200:2265:4::1/112
push "route 192.168.122.0 255.255.255.0"
push "redirect-gateway def1 bypass-dhcp"
push "route-ipv6 2000::/3"
push "dhcp-option DNS 192.168.122.9"

# Einstellungen
keepalive 10 120
comp-lzo
persist-key
persist-tun
verb 3
cipher AES-256-CBC
port 1194
proto tcp
dev tun

# LDAP aktivieren
plugin /usr/lib/openvpn/openvpn-auth-ldap.so /etc/openvpn/auth-ldap.conf

Die LDAP konfiguration sieht so aus:

<LDAP>
        URL             ldaps://ldap.datenknoten.me
        BindDN          cn=systemuser,ou=users,dc=datenknoten,dc=me
        Password        tolles passwort
        Timeout         15
        TLSEnable       no
        FollowReferrals yes
</LDAP>

<Authorization>
        BaseDN          "ou=users,dc=datenknoten,dc=me"
        SearchFilter    "(uid=%u)"
        RequireGroup    false
        <Group>
                BaseDN          "ou=groups,dc=datenknoten,dc=me"
                SearchFilter    "cn=vpnusers"
                MemberAttribute memberUid
        </Group>
</Authorization>

Hier ist anzufügen das die Limitierung auf die Gruppe vpnusers irgendwie nie geklapt hat. Für Sachdienliche Hinweise wäre ich sehr dankbar.

Als nächstes muss auf dem Server noch die Firewall eingerichtet werden. Ich benutze das Programm „Ferm” um meine IPTables-Regeln zu verwalten. Entsprechend sieht mein Script so aus:

# -*- shell-script -*-
#
#  Configuration file for ferm(1).
#

@def $DEV_WORLD = eth0;
@def $DEV_DMZ = virbr1;

@def $HOST_STATIC = 144.76.154.114;

@def $DEV_PRIVATE = virbr1;
@def $NET_PRIVATE = 192.168.122.0/24;

@def $DEV_VPN = tun0;
@def $NET_VPN = 10.8.0.0/24;

# convenience function which creates both the nat/DNAT and the filter/FORWARD
# rule
@def &FORWARD_TCP($proto, $port, $dest) = {
    # interface (lo $DEV_WORLD $DEV_VPN $DEV_PRIVATE)
    table filter chain FORWARD outerface $DEV_DMZ daddr $dest proto $proto dport $port ACCEPT;
    table nat chain PREROUTING daddr $HOST_STATIC proto $proto dport $port DNAT to $dest;
}

table filter {
    chain INPUT {
        policy ACCEPT;

        mod state state INVALID DROP;
        mod state state (ESTABLISHED RELATED) ACCEPT;

        interface $DEV_DMZ proto (tcp udp) dport (53 67) ACCEPT;
    }
    chain OUTPUT {
        policy ACCEPT;
    }
    chain FORWARD {
        policy ACCEPT;
        mod state state INVALID DROP;
        mod state state (ESTABLISHED RELATED) ACCEPT;
        interface $DEV_PRIVATE ACCEPT;
        interface $DEV_VPN mod conntrack ctstate NEW ACCEPT;
        mod conntrack ctstate (ESTABLISHED RELATED) ACCEPT;
    }
}

table nat {
    chain POSTROUTING {
        # masquerade private IP addresses
        saddr ($NET_PRIVATE $NET_VPN) outerface $DEV_WORLD MASQUERADE;
    }
}

domain ip6 {
    table filter {
        chain INPUT {
            policy ACCEPT;
        }
        chain OUTPUT {
            policy ACCEPT;
        }
        chain FORWARD {
            policy ACCEPT;
            interface ($DEV_WORLD $DEV_VPN) outerface $DEV_DMZ daddr 2a01:4f8:200:2265::/64 ACCEPT;
            outerface ($DEV_WORLD $DEV_VPN) interface $DEV_DMZ saddr 2a01:4f8:200:2265::/64 ACCEPT;
            interface $DEV_DMZ outerface $DEV_DMZ ACCEPT;
            interface ($DEV_WORLD $DEV_VPN) outerface $DEV_DMZ REJECT reject-with icmp6-port-unreachable;
            outerface ($DEV_WORLD $DEV_VPN) interface $DEV_DMZ REJECT reject-with icmp6-port-unreachable;

        }
    }
}

&FORWARD_TCP(tcp, (80 443), 192.168.122.2);

Es empfiehlt sich natürlich etwas mit der Materie auseinander zu setzen damit man versteht was ich hier schreibe. Vieles was in diesen Konfigurations-Dateien steht hat sich über die Jahre so entwickelt.

Client Konfiguration (Linux)

Unter Linux ist bis auf einen Punkt eigentlich alles sehr entspannt. Das Problem ist, das der DNS-Server den ich bereitstelle nicht übernommen wird. Dafür gibt es eine Lösung und jetzt erstmal die Config:

client
dev tun
proto tcp
remote 144.76.154.114
resolv-retry infinite
nobind
persist-key
persist-tun
ca dk-ca.crt
cert manjaro.crt
key manjaro.key
verb 3
cipher AES-256-CBC
auth SHA1
reneg-sec 0
route-delay 4
comp-lzo no
auth-user-pass
script-security 2
up /home/hana/openvpn/datenknoten/update-dns
down /home/hana/openvpn/datenknoten/update-dns

2 Anmerkungen: Zum einen sei hier der eintrag auth-user-pass hervorzuheben, der den Client auffordert sich Zugangsdaten vom Benutzer zu erfragen. Zum anderen die letzten 3 Zeile. Diese sorgen nämlich mittels einem kleinen Skript das openresolv aufruft, den mitgelieferte DNS-Server in der Datei /etc/resolv.conf einträgt. Hier das Skript:

#!/bin/bash
#
# Parses DHCP options from openvpn to update resolv.conf
# To use set as 'up' and 'down' script in your openvpn *.conf:
# up /etc/openvpn/update-resolv-conf
# down /etc/openvpn/update-resolv-conf
#
# Used snippets of resolvconf script by Thomas Hood <jdthood@yahoo.co.uk>
# and Chris Hanson
# Licensed under the GNU GPL.  See /usr/share/common-licenses/GPL.
# 07/2013 colin@daedrum.net Fixed intet name
# 05/2006 chlauber@bnc.ch
#
# Example envs set from openvpn:
# foreign_option_1='dhcp-option DNS 193.43.27.132'
# foreign_option_2='dhcp-option DNS 193.43.27.133'
# foreign_option_3='dhcp-option DOMAIN be.bnc.ch'
# foreign_option_4='dhcp-option DOMAIN-SEARCH bnc.local'

## You might need to set the path manually here, i.e.
RESOLVCONF=/sbin/resolvconf

case $script_type in

up)
  for optionname in ${!foreign_option_*} ; do
    option="${!optionname}"
    echo $option
    part1=$(echo "$option" | cut -d " " -f 1)
    if [ "$part1" == "dhcp-option" ] ; then
      part2=$(echo "$option" | cut -d " " -f 2)
      part3=$(echo "$option" | cut -d " " -f 3)
      if [ "$part2" == "DNS" ] ; then
        IF_DNS_NAMESERVERS="$IF_DNS_NAMESERVERS $part3"
      fi
      if [[ "$part2" == "DOMAIN" || "$part2" == "DOMAIN-SEARCH" ]] ; then
        IF_DNS_SEARCH="$IF_DNS_SEARCH $part3"
      fi
    fi
  done
  R=""
  if [ "$IF_DNS_SEARCH" ]; then
    R="search "
    for DS in $IF_DNS_SEARCH ; do
      R="${R} $DS"
    done
  R="${R}
"
  fi

  for NS in $IF_DNS_NAMESERVERS ; do
    R="${R}nameserver $NS
"
  done
  #echo -n "$R" | $RESOLVCONF -p -a "${dev}"
  echo -n "$R" | $RESOLVCONF -a "${dev}.inet"
  ;;
down)
  $RESOLVCONF -d "${dev}.inet"
  ;;
esac

Client Konfiguration (Android)

Unter Android benutze ich OpenVPN for android, welches es auch im F-Droid Store gibt.

Das Einrichten ist Einfach und es gibt nichts zu beachten. Als ich das VPN eingerichtet habe, habe ich einen Bug in dem von mir benutzen XMPP-Client Conversations gefunden, weil dieser, bzw die darunterliegende DNS-Bibliothek die DNS-Server nicht richtig bestimmen konnte (Ist inzwischen behoben).

Fazit

Insgesamt bin ich mit dem Setup sehr zufrieden, vorallem weil es kaputte Netze brauchbar macht, da ich durch das VPN ein zensurfreies Netz, IPv6, einen DNSSEC fähigen Resolver bekomme. Bei Fragen könnt ihr mich entweder per E-Mail, im Chat des Krautspaces kontaktieren oder hinterlasst einen Kommentar am Ende.

Mein Kumpel Micha kam bei einem Gespräch auf die Idee, eine Anwendung zur Hilfe für Refugees zu bauen. Auf der einen Seite gibt es Leute, die etwas an Refugees spenden wollen und auf der anderen Seite Refugees, die etwas benötigen. Die Anwendung soll beide Gruppen auf einfache Art und Weise zusammenbringen. Aktuell läuft das ja alles relativ unstrukturiert. Gruppen rufen auf, dass etwas benötigt wird und manchmal posten Leute noch, wenn sie etwas abgeben wollen. Unser Projekt soll dabei helfen. Wir haben uns auf den Namen „ligi“ geeignet. „Ligi“ ist Esperanto und steht für „verbinden“, weil wir Menschen verbinden wollen.

Eine große Problemstellung an dem Projekt sind die Sprachbarrieren der Menschen untereinander. So kann wahrscheinlich kaum einer der Spender arabisch oder persisch. Umgekehrt können die wenigstens Geflüchteten deutsch sprechen. Aus diesem Grund muss es Freiwillige geben, die die Inhalte und auch Nachrichten der Menschen untereinander Übersetzen.

Eine erste Demo habe ich unter ligi.datenknoten.me aufgesetzt. Die Version ist lange noch nicht fertig. Was auf jeden Fall noch fehlt:

  • Das oben angesprochene Übersetzungsfeature
  • Einfachere Login-Methoden
  • Feedback ☺

Wo ich noch Hilfe brauche:

  • Übersetzung des Interfaces: Wenn Du eine Sprache übersetzen willst, sag mir Bescheid und ich helfe dir es einzurichten, so dass Du die Übersetzung machen kannst.
  • Design: Da ich nix mit Design am Hut hab, benutze ich das Framework Semantic UI. Wenn Du in diesem Bereich aushelfen willst, sag Bescheid und ich helfe Dir loszulegen.
  • Projektmanagement: Ich programmiere gerade die Teile, von denen ich denke, dass sie gebraucht werden. Jemand anderes als ich sollte bestimmen, was wichtig ist und was nicht.

Den Quellcode von Ligi gibt es auf Github. „Pull Requests“ sind immer gern gesehen.

Hinweis: Dies ist eine Übersetzung ins deutsche von Zabbix: Postfix statistical graphs using passive checks. Zusätzlich habe ich das Zabbix-Template und das Skript hier noch gespiegelt.

Diese Anleitung hilft bei der Erstellung von passiven Checks. Es gibt dazu ein Skript welches mit logtail und pflogsumm die Postfix Log-Dateien auswertet und in eine Statistik-Datei schreibt. Zum Schluss wird ein UserParameter erstellt, welcher die Daten aus der Statistik-Datei an Zabbix weitergibt.

Vorraussetzungen installieren

Wir müssen pflogsumm und logtail installieren. Bei Debian sieht das so aus:

$ apt-get install pflogsumm logtail

Skript einrichten

Das Skript muss als postfix-zabbix-stats.bash in /usr/local/bin gespeichert werden und als ausführbar (+x) makiert werden.

Danach legt man einen Cronjob für das Skript an, damit es die Statistik-Datei schreiben kann:

*/5 * * * * /usr/local/bin/postfix-zabbix-stats.bash

Zabbix Agent einrichten

In der Datei /etc/zabbix/zabbix_agentd.conf muss man den Wert EnableRemoteCommands auf 1 setzen.

Danach erstellt man eine Datei /etc/zabbix/zabbix_agentd.conf.d/postfix.conf mit folgendem Inhalt:

UserParameter=postfix.pfmailq,mailq | grep -v "Mail queue is empty" | grep -c '^[0-9A-Z]'
UserParameter=postfix[*],/usr/local/bin/postfix-zabbix-stats.bash $1

Agent neustarten und in diesem Kapitel fertig.

Zabbix Template importieren

Nun muss man das Template importieren und dem Host auf dem Postfix läuft zuweisen und schon ist man fertig und bekommt nette Postfix-Statistiken.

Umgangssprachlich bezeichnet steht „kalter Kaffee“ ja für eine veraltete Nachricht, aber nicht in meinem Fall. Denn der kalte Kaffee ist diesmal wörtlich zu nehmen. Es gibt nämlich die Möglichkeit Kaffee kalt zu brühen. Hier eine kleine Beschreibung was ich gemacht habe.

Ich habe zuerst alles gesammelt was ich so brauche:

  • 200 Gram Kaffeepulver
  • 1 Liter Wasser
  • 1 Kaffeefilter (Hatte ich nicht da, ich habe stattdessen ein feines Sieb genommen)
  • 2 große Behälter

Ich habe das Pulver in den Behälter gegeben und dann nochmal gut umgerührt, damit das ganze Pulver auch feucht wurde. Das sah dann so aus:

A post shared by luther blisset (@0xaffe) on

Dann war erstmal das große Warten angesagt. Um genau zu sein 12 Stunden. Danach habe ich den Kaffee gefiltert. Die einfache Variante zum Filtern ist wie oben schon geschrieben ein normaler Kaffeefilter. Da ich sowas aber nicht da hatte, hab ich ein feines Sieb genommen und hat genausogut funktioniert. Mein gefiltertes Produkt sah so aus:

A post shared by luther blisset (@0xaffe) on

Eine wichtiger Hinweis: Das ist hier ist ein Konzentrat, also besser nicht unverdünt trinken. Meine Anleitung schrub etwas von 2 Einheiten warmes Wasser auf 1 Einheit Konzentrat. Mir war das allerdings immer noch etwas zu stramm und hatte danach Mühe die Finger ruhig zu halten.

So als Fazit kann ich sagen, das es jeder der gerne Kaffee trinkt auf jeden Fall ausprobieren sollte. Kalt gebrühter Kaffe ist im Geschmack wesentlich milder auch wenn er seine Wirkung immer noch, wenn nicht noch besser entfaltet. Die Kehrseite ist natürlich der erhöhte Aufwand der Zubereitung. Ich werde für den Morgenkaffee erstmal bei warm gebrühten bleiben. Aber wenn es mal wieder wärmer wird, werde ich das nochmal angehen, den Mixer auspacken, ein paar Eiswürfel, Vanille-Eis, etwas Milch und ordentlich Kaffee-Konzentrat reinschütten und einen ordentlichen Eis-Kaffee machen.

Mals was locker flockigen Jazz für zwischen durch.

Ich finde ja, oft kommt es nicht so richtig rüber wie weit und unermesslich das Weltall ist. In dem Video „Riding light“ sieht der Betrachter wie das Licht der Sonne vom inneren unseres Sonnensystems bis zum Planeten Jupiter sich in Echtzeit bewegt. Einen anderen Ansatz verfolgte das Video „Power of Ten“ aus dem Jahr 1977, in dem in 10s die Entfernung immer um 10 mulitipliziert wurde.

Durch einen wunderbaren Mix von pEtEr Withoutfield bin ich auf Lomovolokno gestoßen der sehr sehr schöne beats baut. Absolute Höhrempfehlung!

Ich habe gestern im Krautspace ein paar Takte zu DNS im Allgemeinen und DNSSEC im Speziellen erzählt.

Ziel des Abends war es, die Schibboleth vorzustellen, die es braucht um DNSSEC mit Bind und OVH zum laufen zu bekommen und diese will ich hier nochmal für die Nachwelt hinterlassen. Ich habe das ganze für die Domain „kaoskinder.de“ gemacht.

Zurest erzeugt man einen „zone signing key“:

dnssec-keygen -a RSASHA512 -b 4096 -n ZONE kaoskinder.de

Danach brauchts noch einen „key signing key“:

dnssec-keygen -f KSK -a RSASHA512 -b 4096 -n ZONE kaoskinder.de

Diese Befehle erzeugen 4 Dateien:

  • Kkaoskinder.de.+010+11091.key
  • Kkaoskinder.de.+010+11091.private
  • Kkaoskinder.de.+010+13430.key
  • Kkaoskinder.de.+010+13430.private

Die key-Dateien enthalten die öffentlichen Schlüssel und die private-Dateien aus offensichtlichen Gründen die privaten Schlüssel.

Als nächstes inkludiert man die key-Dateien in die Zone-Datei:

$INCLUDE Kkaoskinder.de.+010+11091.key
$INCLUDE Kkaoskinder.de.+010+13430.key

Danach muss man die zone-Datei unterschreiben:

dnssec-signzone -A -3 $(head -c 1000 /dev/random | sha1sum | cut -b 1-16) -N INCREMENT -o kaoskinder.de -t db.kaoskinder.de.zone

Diesen Schritt muss man alle 30 Tage wiederholen, da dann die Signaturen auslaufen.

Der letzte Schritt erzeugt eine unterschriebene Zonen-Datei „db.kaoskinder.de.zone.signed“, diese muss dann noch in die bind-Konfiguration eintragen.

Jetzt kann man z.B. mit dem Verisign DNSSEC Debugger schonmal testen ob DNSSEC funktioniert. Es wird noch eine Fehlermeldung kommen, das kein DS-Record in der übergeordneten Zone existiert. Dieser Fehler wird in dem nächsten Schritt behoben, in dem wir unseren öffentlichen Schlüssel bei OVH eintragen.

Dazu loggt man sich im alten OVH Interface ein. Danach wählt man oben die gewünschte Domain, wählt im linken Menü „Domain & DNS“, dann rechts oben „Sichere Delegation (DNSSEC)“. Dort klickt man auf „Änderung“.

Jetzt sucht man sich eine der beiden key-Dateien aus, ich habe jetzt die Datei „Kkaoskinder.de.+010+11091.key“ ausgewählt. Die Datei sieht wie folgt aus:

; This is a key-signing key, keyid 11091, for kaoskinder.de.
; Created: 20150407191914 (Tue Apr  7 21:19:14 2015)
; Publish: 20150407191914 (Tue Apr  7 21:19:14 2015)
; Activate: 20150407191914 (Tue Apr  7 21:19:14 2015)
kaoskinder.de. IN DNSKEY 257 3 10 AwEAAZ5v3RLmjVMcjEodqam6IXkkG9NQp3G88hddDY1VClGtIsJtgU42 6t61fDrKoHFRn607lbn06OkCre9fWBophP4xTt9sX877yNb1LRtOpLAS lEYY8p4w6OiDv3CMoyT6oO7j+L3g3puYc+57NmFa4hzWFrEF4RuVis4b argcPudoTISwA+/DB3C5UNwOQB5WsnSEXd4krVO/49Gs2FIOCj3/4Ja6 g/v3x0R3axkLZV1PnawYlDVpAI0qI3xXhxlzZvT64GI+HYQds3Im+Bvs aMO1S224xm/99v0TKwSLfPenX3DW0VpRY5efvUgVUu8zl6HaEQolLLmu ZaKVe9kEn/9mzDX30SkBtNNc0athdNDRofd710n86SnybDpn5K0qME7W qcW6n53voAaObv1yR3dmvFsVeu2dRhYHHqOzMH94JnqixsjTAGH80DKR ZjMEK666Va1jgBY928XPRx3zH8thQe+FrOK4Ad/kihZYwi9kovKeGBdl VVZDoI/CaRjdhSzpBShyXakNhNWtSo/qs7QN4TjxDdN9TYPKLSToIc2m mzvG/u5saTh/oTDSkP9Xh3bOceFKAV5iJJDVo5oDEUYNCyQL5YvcYJ1R tD2Fb1mzIrvPyOq5q3MDDhTjPEqBqiiVYwDKJ4eMy81AuxLUG4+Bekbc iprdIfcp3HdR6QAZ

Der Wert nach keyid trägt man bei Kennung ein, die Zahl nach DNSKEY wählt man bei Flags aus. Als Algorithmus wählt man 10. Bei „öffentlicher Schlüssel“ trägt man den ganzen Kram hinter der 10 ein, also von „AwEAAZ5v“ bis „HdR6QAZ“. Dann klickt man auf „Bestätigen“ und wartet auf die Erfolgsmeldung.

Jetzt da die Zone per DNSSEC gesichert ist, kann man sich auch den schönen Sachen wie DANE oder SSHFP hinwenden.