Letzte Aktualisierung am 25.09.2024, 20:09:11 Uhr

Domain-based Message Authentication, Reporting and Conformance (DMARC) ist eine Spezifikation, die entwickelt wurde, um den Missbrauch von E-Mails zu reduzieren, wie er etwa bei Mail-Spoofing vorkommt. DMARC versucht einige seit langem bestehende Unzulänglichkeiten im Zusammenhang mit der Authentifizierung von E-Mails zu beheben und wurde bei der IETF zur Standardisierung eingereicht.

DMARC baut auf den Techniken Sender Policy Framework (SPF) und DomainKeys Identified Mail (DKIM) auf, indem es für eine Absender-Domain festlegt, wie das Empfänger-Mailsystem die Authentifizierung von E-Mails durchführen soll und wie im Falle eines Fehlers zu verfahren ist. Während die vorgenannten Techniken beschreiben, wer eine Mail versenden darf (SPF) bzw. sicherstellen, dass diese Mail in bestimmter Weise unverändert vom Absender stammt (DKIM), kann der Absender nach der DMARC-Spezifikation zusätzlich Empfehlungen geben, auf welche Art der Empfänger mit einer Mail umgeht, die in einem oder beiden Fällen nicht den Anforderungen entspricht. Sofern das Empfänger-Mailsystem die DMARC-Spezifikation bei E-Mail-Nachrichten anwendet, ist dadurch eine konsistente Überprüfung der Authentizität dieser E-Mails gesichert.

Die DMARC-Richtlinie für eine Absender-Domain kann das Empfänger-Mailsystem einem Eintrag im Domain Name System (DNS) entnehmen. (Quelle: Wikipedia)

parsedmarc kann auch inzwischen die Auswertung von SMTP TLS Reporting  (TLS-RPT) vornehmen. TLS-RPT ist ein relativ neuer Reportmechanismus, den es seit 2018 gibt (siehe RFC 8460). TLS Reporting ermöglicht Absendern die Weitergabe von Statistiken und spezifischen Informationen über mögliche Sicherheitsprobleme, auf die Server bei der Verbindung mit Ihren eingehenden E-Mail-Systemen stoßen, die mit der empfangenden Domain verbunden sind (Quelle).

Einleitung

parsedmarc ist ein Open Source DMARC- und TLS-RPT-Berichtsanalysator, welcher On-Premise (keine Teilung der Daten mit Dritten) installiert und betrieben werden kann. In diesem Artikel wird parsedmarc auf einem Server eingerichtet, so dass DMARC Berichte von Google, Microsoft, etc.. eingelesen und aufbereitet werden können.

Voraussetzungen

Eine Grundvoraussetzung ist es natürlich, dass für die entsprechende (Sub)Domain auch ein gültiger DMARC Eintrag in der DNZ-Zone angelegt ist. Falls dem nicht so ist, ist dies nun der passende Zeitpunkt dies nachzuholen.

Für die Visualisierung und Speicherung der Daten kommt Elasticsearch und Kibana zum Einsatz. Beide Applikationen benötigen teilweise Arbeitsspeicher (RAM). Daher ist es empfehlenswert, dass ein Server mindestens 8 GB Ram und 4 CPU Kerne hat. Ich habe mich für den Test für einen Server aus der Hetzner Cloud, CAX21 mit Ubuntu 24.04 entschieden.

Für die Erreichbarkeit des Servers habe ich bei meinem Domain Hoster einen A-Eintrag mit dem Namen dmarc01.wydler.eu angelegt.

Grundeinrichtung des Servers

Vorweg sind auch diesem Server grundlegende Konfigurationen vorzunehmen. Zuerst werden Paketquellen als auch installierte Pakete aktualisiert.

apt update
apt upgrade -y

Zeitzone für den Server setzen.

timedatectl
timedatectl set-timezone Europe/Berlin
timedatectl

Installation von Tools.

sudo apt install -y vim htop apt-transport-https gnupg2

Installation und Konfiguration der Firewall.

sudo apt install -y ufw

sudo ufw allow 22
sudo ufw allow 80
sudo ufw allow 443
sudo echo y | sudo ufw enable

Installieren von Elasticsearch und Kibana

parsedmarc ist ein Befehlszeilenprogramm für die Konsole. Daher sollt mit Hilfe von Elasticsearch und Kibana eine Visualisierung in einer Weboberfläche realisiert werden.

Einbinden der Paket Repository und Aktualisierung.

sudo wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

sudo echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list

sudo apt update

Installation von Elasticsearch und Kibana.

sudo apt install -y elasticsearch kibana

In der SSH Session wird nach der Installation von Elasticsearch die „Security autoconfiguration information“ ausgegeben. Dieser Abschnitt enthält u.a. das Passwort für den Superuser „elastic“, welches wir später benötigen.

Anschließend muss für die Kibana ein SSL-Zertifikat erstellt werden. Hierzu greife ich auf ein Self-Signed-Zertifikat zurück, da es später ausschließlich für die Kommunikation zwischen Reverse Proxy und Kibana dient.

openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout kibana.key -out kibana.crt

sudo mv kibana.* /etc/kibana
sudo chmod 660 /etc/kibana/kibana.key
sudo chown root:kibana /etc/kibana/kibana.key /etc/kibana/kibana.crt

Die Default Konfiguration von Kibana sichern.

cp /etc/kibana/kibana.yml /etc/kibana/kibana.yml.bak

Anschließend die Konfiguration „/etc/kibana/kibana.yml“ in Editor der Wahl öffnen und folgende Parameter ganz am Ende der Datei hinzufügen.

server.host: "127.0.0.1"
server.publicBaseUrl: "https://dmarc01.wydler.eu"
server.ssl.enabled: true
server.ssl.certificate: /etc/kibana/kibana.crt
server.ssl.key: /etc/kibana/kibana.key

Elasticsearch als Dienst einrichten, welcher auch dem Start des Servers auch wieder hochgefahren wird.

sudo systemctl enable elasticsearch.service
sudo systemctl start elasticsearch.service
sudo systemctl status elasticsearch.service

Nun muss Elasticsearch mit Kibana verbunden werden. Dies geschieht mit folgenden Befehlen.

token="$(/usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana)"
/usr/share/kibana/bin/kibana-setup --enrollment-token $token

Die Konfiguration von Kibana („/etc/kibana/kibana.yml“) wurde dadurch erweitert. Schaut man in die Konfiguration wird man feststellen, dass dort die öffentliche IPv4/6-Adresse des Servers in den Werten der Parameter zu finden ist. Die IP-Adresse jeweils durch 127.0.0.1 ersetzen.

Kibana als Dienst einrichten, welcher auch dem Start des Servers auch wieder hochgefahren wird.

systemctl daemon-reload
sudo systemctl enable kibana.service
sudo systemctl start kibana.service
sudo systemctl status kibana.service

Installation von GeoIP von MaxMind

parsedmarc greift für die Geolokation auf ein Python Modul zurück. Dieses Modul basiert auf MaxMind GeoIP-Datenbank. Der eine oder andere kennt evtl. die freie Version der GeoIP Datenbank. Diese gibt es nach wie vor. Um diese nutzen zu können, muss auf der Internetseite ein kostenloses Benutzerkonto angelegt werden.

Wenn das Benutzer angelegt und aktiviert ist, kann License Key erzeugt werden. Nach der Anmeldung gibt es auf der linken Seite das Navigationsmenü. Im Bereich Account gibts einen Eintrag „Manage License Keys“. Anschließend auf die Schaltfläche „generate new license key“ klicken und den Anweisungen folgen.

apt install -y geoipupdate
geoipupdate -V

Nach der Installation muss der erstellten License Key in der Konfiguration des Moduls hinterlegt werden. Zuerst wird eine Kopie der originalen Konfiguration erstellt. Nicht vergessen, in den Zeilen 2 & 3 eure Daten zu hinterlegen!

cp /etc/GeoIP.conf /etc/GeoIP.conf.bak
sed -i 's/# AccountID YOUR_ACCOUNT_ID_HERE/AccountID 876428/g' /etc/GeoIP.conf
sed -i 's/# LicenseKey YOUR_LICENSE_KEY_HERE/LicenseKey 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/g' /etc/GeoIP.conf

Manuelle Aktualisierung der Datenbank.

geoipupdate

Mit der Installation wurde auch automatisch ein Eintrag unter /etc/cron.d/ angelegt. Somit ist sichergestellt, dass die Datenbanken regelmäßig aktualisiert werden.

Nginx als Reverse Proxy einrichten

Für den Zugriff auf Kibana soll Nginx als Reverse Proxy verwendet werden. Eine Authentifizierung durch Nginx ist nicht mehr erforderlich, da  Kibana/Elasticsearch eine eigene Authentifizierung mitbringen.

Installation von Nginx und Certbot.

apt install -y nginx certbot python3-certbot-nginx

Abrufen des SSL-Zertifikats bei Let’s Encrypt mit Hilfe von certbot.

certbot certonly --nginx --agree-tos --email webmaster@wydler.eu -d dmarc01.wydler.eu --non-interactive --rsa-key-size 4096

Erstellen der Konfiguration für Nginx.

cat << 'EOF' > /etc/nginx/sites-available/kibana.conf
server {
        listen 80;
        listen [::]:80;
        server_name dmarc01.wydler.eu;
        return 301 https://$server_name$request_uri;
}
server {
        listen 443 ssl http2;
        listen [::]:443 ssl http2;
        server_name dmarc01.wydler.eu;


        add_header X-Frame-Options SAMEORIGIN;
        add_header X-Content-Type-Options nosniff;

        auth_basic "Login required";

        access_log /var/log/nginx/dmarc01.wydler.eu.access;
        error_log /var/log/nginx/dmarc01.wydler.eu.error;

        location / {
                proxy_pass https://127.0.0.1:5601;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        ssl_certificate /etc/letsencrypt/live/dmarc01.wydler.eu/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/dmarc01.wydler.eu/privkey.pem;

        ssl_ciphers "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES256-CCM8:DHE-RSA-AES256-CCM:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA";
        ssl_prefer_server_ciphers on;

        ssl_ecdh_curve secp521r1:secp384r1:prime256v1;

        resolver_timeout 5s;
        ssl_stapling on;
        ssl_stapling_verify on;

        ssl_session_cache shared:le_nginx_SSL:1m;
        #ssl_session_cache shared:SSL:50m;
        ssl_session_timeout 5m;
        ssl_buffer_size 1400;
        ssl_session_tickets off;

        add_header Strict-Transport-Security "max-age=31536000; includeSubdomains; preload" always;
}
EOF

Neue Konfiguration für Nginx aktivieren.

ln -s /etc/nginx/sites-available/kibana.conf /etc/nginx/sites-enabled/

Konfiguration prüfen und Nginx neu laden.

nginx -t
systemctl reload nginx

Importieren von parsedmarc-Objekten

Damit im Dashboard von Kibana auch die Daten sinnvoll visualisiert werden, stellen die Entwickler von parsedmarc eine Objektdatei von Haus aus zur Verfügung. Diese Objektdatei kann in der aktuellen Version hier direkt heruntergeladen werden.

Im Anschluss die Weboberfläche von Kibana anrufen und anmelden. Danach direkt in die Objektverwaltung wechseln (https://dmarc01.wydler.eu/app/management/kibana/objects).

Rechts oben gibt es die Möglichkeit die zuvor heruntergeladene Datei zu importieren. Den Anweisungen des Assistenten einfach folgen.

Um das Kibana-Dashboard mit parsedmarc zu verwenden, müssen Sie zuerst die Objekte importieren. Sie können den folgenden Befehl verwenden, um es auf Ihren lokalen Linux- oder Mac-Computer herunterzuladen.

Ist der Vorgang erfolgreich abgeschlossen, gibt es unter Home -> Dashboard drei neue Dashboards.

Benutzer für den Zugriff auf Elasticsearch

Es hat sich viel getan als der initiale Artikel erschienen ist. Inzwischen benötigt parsedmarc nicht nur die URL zu Elasticsearch, sondern auch Benutzername und Passwort. Alternativ kann auch ein API Key angegeben werden.

Im Browser der Wahl die Adresse https://dmarc01.wydler.eu/app/dashboards#/list aufrufen. Dort mit dem Benutzer „elastic“ und dem dazugehörigen Passwort anmelden. Die Infos wurden im Abschnitt „Installieren von Elasticsearch und Kibana“, nach der Installation von Elasticsearch ausgegeben. 🙂

Nach erfolgreich Anmeldung sollten drei Dashboards zu sehen sein.

Jedes Dashboard einmal im Browser aufrufen. Mehr ist an der Stelle nicht zu tun.

Nun erstellen wir für den Benutzer parsedmarc, welcher wir später noch erstellen, eine Rolle mit verschiedenen Berechtigungen. Dazu im Browser die Adresse „https://dmarc01.wydler.eu/app/management/security/roles“ aufrufen.

Oben rechts auf die Schaltfläche „Create role“ klicken. Nun wird die Maske für die neue Rolle angezeigt. Die Rolle heißt in meinem Fall identisch wie der Benutzer.

Wichtig sind die Index privileges. Dieses sind erforderlich, damit später parsedmarc problemlos seine Daten in Elasticsearch schreiben kann. Sind alle Werte gesetzt, ist am Seitenende die Schaltfläche „Ceate role“ zu finden.

Nachdem die Rolle nun existiert, muss der Benutzer noch angelegt werden. Dazu im Browser die Adresse https://dmarc01.wydler.eu/app/management/security/users aufrufen. Wieder oben rechts auf „Create user“ klicken.

In meinem Fall heißt der Benutzer parsedmarc und das Passwort stammt aus einem Passwort Generator. Zudem muss die soeben erstellte Rolle natürlich zugewiesen werden.

Den Benutzernamen und Passwort benötigen wir später im Abschnitt „parsedmarc“ konfigurieren“, genauer gesagt in der Konfigurationsdatei parsedmarc.ini.

Installation von parsedmarc

Installation der Voraussetzungen.

sudo apt install -y python3-pip python3-virtualenv python3-dev libxml2-dev libxslt-dev

Einen dedizierten Benutzer anlegen.

sudo useradd parsedmarc -r -s /bin/false -m -b /opt

Den Benutzer in die Gruppe „elasticsearch“ aufnehmen. Der Grund dafür ist, dass der Benutzer auf Self-Signed-Zertifikate im Verzeichnis „/etc/elasticsearch“ zugreifen muss.

sudo usermod -a -G elasticsearch parsedmarc

Installation von parsedmarc in einer virtuellen Umgebung.

sudo -u parsedmarc virtualenv /opt/parsedmarc/venv

Aktivieren der virtuellen Umgebung.

source /opt/parsedmarc/venv/bin/activate

Um parsedmarc in der virtuellen Umgebung zu installieren oder zu aktualisieren.

sudo -u parsedmarc /opt/parsedmarc/venv/bin/pip install -U parsedmarc

Deaktivieren der virtuellen Umgebung.

deactivate

Je nach Leistung des Servers kann der Vorgang ein bisschen Zeit in Anspruch nehmen.

parsedmarc konfigurieren

Der Applikation muss mitgeteilt werden, woher die Daten bezogen und wo die Daten gespeichert werden sollen.

Neue Konfiguration für ParseDMARC erstellen.

cat << 'EOF' > /etc/parsedmarc.ini
[general]
save_aggregate = True
save_forensic = True
save_smtp_tls = True
log_file = /var/log/parsedmarc/parsedmarc.log
silent = False
debug = True

[mailbox]
watch = True
test = False
delete = False

[imap]
host = server03.wydler.eu
port = 993
ssl = True
user = dmarc@blog.wydler.eu
password = testtest

[elasticsearch]
hosts = 127.0.0.1:9200
ssl = True
user = parsedmarc
password = testtest
cert_path = /etc/elasticsearch/certs/http_ca.crt

[smtp]
host = server03.wydler.eu
port = 587
ssl = True
user = dmarc@blog.wydler.eu
password = testtest
from = dmarc@blog.wydler.eu
to = info@blog.wydler.eu

EOF

Bitte nicht vergessen die entsprechenden Zugangsdaten, E-Mail-Adressen, etc. anzupassen. Beschreibung sowie weitere Parameter findet man in der Doku.

Die Zugangsdaten im Abschnitt „elasticsearch“ stammen aus dem Abschnitt „Benutzer für den Zugriff auf Elasticsearch“.

Der Bereich SMTP ist nur erforderlich, wenn auch DMARC Berichte jeden Tag an einen Empfänger verschickt werden soll.

Berechtigungen der Konfigurationsdatei anpassen.

chown root:parsedmarc /etc/parsedmarc.ini
chmod 640 /etc/parsedmarc.ini

Verzeichnis und Datei für das Logging anlegen.

mkdir /var/log/parsedmarc/
touch /var/log/parsedmarc/parsedmarc.log
chown parsedmarc:parsedmarc /var/log/parsedmarc/ -R

Logrotate für die Logfile anlegen.

cat << 'EOF' > /etc/logrotate.d/parsedmarc
/var/log/parsedmarc/*.log {
    rotate 12
    weekly
    compress
    missingok
}
EOF

Logrotate testen.

logrotate -d /etc/logrotate.d/parsedmarc

parsedmarc als systemd-Dienst einrichten, konfigurieren und starten.

cat << 'EOF' > /etc/systemd/system/parsedmarc.service
[Unit]
Description=parsedmarc mailbox watcher
Documentation=https://domainaware.github.io/parsedmarc/
Wants=network-online.target
After=network.target network-online.target elasticsearch.service

[Service]
ExecStart=/opt/parsedmarc/venv/bin/parsedmarc -c /etc/parsedmarc.ini
User=parsedmarc
Group=parsedmarc
Restart=always
RestartSec=5m

[Install]
WantedBy=multi-user.target
EOF

Änderungen anwenden, Dienste aktivieren und starten.

systemctl daemon-reload
systemctl enable parsedmarc.service

systemctl start parsedmarc 
systemctl status parsedmarc 

journalctl -u parsedmarc.service

tail -f /var/log/parsedmarc/parsedmarc.log

Viel Spaß beim Ausprobieren. 🙂