Eigener produktiver Mailserver (Postfix, Dovecot & DMARC)

Erstellt: 05.11.2026 Aktualisiert: 06.11.2026

Der Betrieb einer eigenen E-Mail-Infrastruktur gilt zu Recht als Königsdisziplin der Linux-Systemadministration. Im Gegensatz zu einem einzelnen Webserver ist E-Mail ein global föderiertes System, das auf striktem kryptografischem Vertrauen, IP-Reputation und mehrstufiger Protokollvalidierung beruht.

Während kommerzielle Anbieter (Gmail, Microsoft 365) Metadaten analysieren und dich an proprietäre Ökosysteme binden, garantiert dir der Betrieb eines eigenen gehärteten Mailstacks 100 % Souveränität über deine private Kommunikation, unbegrenzte Aliase, eigene serverseitige Sieve-Filter und vollständigen Schutz vor Data-Mining durch Dritte.

1. Architektur, Protokolle & Voraussetzungen

Ein professioneller Linux-Mailserver besteht nicht aus einem einzelnen monolithischen Programm, sondern aus einer modularen Pipeline spezialisierter Dienste, die Hand in Hand arbeiten:

📥 1. Eingehende Delivery-Pipeline

```mermaid

%%{init: {'flowchart': {'wrappingWidth': 350, 'subGraphTitleMargin': {'top': 15, 'bottom': 15}}}}%% flowchart TB Sender["🌐 Externer Absender-MTA
(Gmail / Corporate)"] Postfix["📮 Postfix Listener (:25)
TLS 1.3 · DNSBL · SPF"] Filter["🔐 Spam- & Malware-Filter
Rspamd & ClamAV"] Dovecot["📬 Dovecot LMTP
Serverseitiges Sieve"] Maildir[("💾 Maildir-Speicher
/var/vmail/domain/user/")]

    Sender ==>|"SMTP :25 (STARTTLS)"| Postfix
    Postfix -->|"Milter Scan"| Filter
    Filter -->|"Geprüfte E-Mail"| Dovecot
    Dovecot ==>|"Atomare Speicherung"| Maildir
```

📤 2. Client-Zugriff & Ausgehender Versand

%%{init: {'flowchart': {'wrappingWidth': 350, 'subGraphTitleMargin': {'top': 15, 'bottom': 15}}}}%%
flowchart TB
    Client["💻 Mail-Client<br/>(Thunderbird / Mobil)"]

    subgraph InboundAccess ["Postfach-Zugriff (IMAP)"]
        DovecotImap["📬 Dovecot IMAPS (:993)<br/>Verschlüsselter Zugriff"]
        MaildirStore[("💾 Maildir-Speicher<br/>/var/vmail/")]
        DovecotImap <==> MaildirStore
    end

    subgraph OutboundFlow ["E-Mail-Versand (SMTP)"]
        PostfixOut["📮 Postfix Submission (:587)<br/>SASL-Auth + TLS 1.3"]
        DKIM["✍️ OpenDKIM Milter<br/>Kryptografische Signatur"]
        Recipient["🌍 Empfänger-MTA (:25)<br/>Internet-Zustellung"]
        PostfixOut --> DKIM --> Recipient
    end

    Client <==>|"Mail abrufen (:993)"| InboundAccess
    Client ==>|"Mail senden (:587)"| OutboundFlow
    InboundAccess ==> OutboundFlow

Die vier Kernkomponenten

MTA — Mail Transfer Agent (Postfix)

Der SMTP-Router. Nimmt eingehende Nachrichten auf Port 25 an, authentifiziert ausgehende Benutzerverbindungen auf den Ports 587/465, erzwingt TLS und leitet E-Mails über DNS-MX-Lookups durch das Internet weiter.
MDA & IMAP — (Dovecot)

Speichert eingehende E-Mails im strukturierten Maildir-Format, führt serverseitige Sieve-Sortierregeln aus, stellt Postfächer für Clients über IMAPS (993) bereit und dient als zentrales SASL-Authentifizierungs-Backend.
Vertrauens- & Krypto-Ebene (SPF / DKIM / DMARC)

Beweist Gmail, Outlook und Yahoo kryptografisch, dass dein Server berechtigt ist, E-Mails für deine Domain zu versenden (SPF), und dass Header sowie Inhalte unterwegs nicht gefälscht wurden (DKIM + DMARC).
Spam- & Malware-Abwehr (Amavis / Rspamd + ClamAV)

Prüft jede eingehende Nachricht gegen Echtzeit-DNS-Blocklisten (DNSBLs), Bayes'sche Spam-Heuristiken und ClamAV-Virensignaturdatenbanken vor der Zustellung.

Übersicht der Netzwerkports

Protokoll / Rolle	Port	Transport & Verschlüsselung	Zweck & Freigabe
SMTP (Server-zu-Server)	`25/tcp`	Opportunistisches `STARTTLS`	Zwingend erforderlich für den Empfang von anderen MTAs und den ausgehenden Versand.
SMTPS (Submission Wrapper)	`465/tcp`	Implizites `TLS 1.3` (RFC 8314)	Moderner Standard für Mail-Clients (MUAs) beim Einliefern ausgehender E-Mails.
SMTP Submission	`587/tcp`	Zwingendes `STARTTLS`	Klassischer authentifizierter Port für Mail-Clients beim Einliefern ausgehender E-Mails.
IMAPS (Postfach-Zugriff)	`993/tcp`	Implizites `TLS 1.3` (RFC 8314)	Verschlüsselte Postfach-Synchronisation für Thunderbird, iOS, Android und Webmail.

Pre-Flight-Checkliste: Überspringe keinesfalls diese 4 Voraussetzungen!

Offener Port 25: Viele Cloud-Provider blockieren ausgehenden TCP-Port 25 standardmäßig zur Spam-Prävention. Prüfe vor dem Start, ob ausgehender Port 25 offen ist:
```
nc -zv -w 5 gmail-smtp-in.l.google.com 25
```
Statische öffentliche IPv4- (und IPv6-) Adresse: Dynamische Privatkunden-IPs stehen auf Spam-Blocklisten (Spamhaus PBL) und werden von 99 % aller empfangenden Mailserver abgewiesen.
Forward-Confirmed Reverse DNS (FCrDNS / PTR): Der Reverse-DNS-Eintrag (PTR) deiner IP-Adresse beim VPS-Provider muss auf mail.deinedomain.de auflösen, und mail.deinedomain.de (A/AAAA) muss exakt auf diese IP zurückzeigen!
Saubere IP-Reputation: Prüfe die IP-Adresse deines Servers vorab beim MXToolbox Blacklist Check, um sicherzustellen, dass kein Vorbesitzer des VPS die Reputation der IP verbrannt hat.

Architektur-Entscheidung: Nativer Stack vs. Container-Mail-Suites

In diesem Leitfaden bauen wir den nativen Postfix + Dovecot Stack Schritt für Schritt auf, damit du jeden Socket, jede Konfigurationsdatei und jede Protokollschicht beherrschst. Wenn du später eine vorkonfigurierte Container-Suite für Multi-Domain-Setups bevorzugst, wirf einen Blick auf Docker Mailserver (DMS), Mailcow oder den in Rust geschriebenen Stalwart Mail Server.

2. DNS-Fundament: `A`, `AAAA`, `MX` & `PTR`

Konfiguriere noch vor der Installation des ersten Pakets die DNS-Zone deiner Domain sowie den Reverse-DNS-Eintrag (PTR) bei deinem VPS-Provider. Ersetze deinedomain.de und 198.51.100.10 durch deine echte Domain und IP-Adresse.

DNS-Zonentabelle (Cloudflare / Registrar-UI) BIND-Zonendatei-Syntax Verifikation im Terminal (dig Pre-Flight-Check)

Record-Typ	Name / Host	Wert / Ziel	Priorität	TTL
`A`	`mail`	`198.51.100.10`	—	`3600`
`AAAA`	`mail`	`2001:db8::10` (falls IPv6 aktiv)	—	`3600`
`MX`	`@` (Root-Domain)	`mail.deinedomain.de.`	`10`	`3600`
`PTR` (beim VPS-Hoster)	`198.51.100.10`	`mail.deinedomain.de.`	—	—

Zonendatei-Ausschnitt für deinedomain.de

mail.deinedomain.de.    3600    IN    A       198.51.100.10
mail.deinedomain.de.    3600    IN    AAAA    2001:db8::10
deinedomain.de.         3600    IN    MX  10  mail.deinedomain.de.

Terminal: Forward- & Reverse-DNS-Auflösung prüfen

# 1. dig-Werkzeug installieren, falls noch nicht vorhanden
sudo apt update && sudo apt install -y dnsutils

# 2. A-Record und MX-Record prüfen
dig A mail.deinedomain.de +short
dig MX deinedomain.de +short

# 3. Prüfen, ob der Reverse DNS (PTR) exakt zum Mail-Hostnamen passt!
dig -x 198.51.100.10 +short

3. Core-Stack: Postfix & Dovecot installieren und konfigurieren

Schritt 1: System-Hostnamen setzen & Pakete installieren

Der System-Hostname (FQDN) deines Servers muss exakt mit deinem PTR- und A-Record übereinstimmen (mail.deinedomain.de):

Terminal: Hostnamen setzen & Postfix + Dovecot installieren

# 1. FQDN-Hostnamen setzen
sudo hostnamectl set-hostname mail.deinedomain.de

# 2. Postfix, Dovecot (IMAP + LMTP + Sieve) und Testwerkzeuge installieren
sudo apt update
sudo DEBIAN_PRIORITY=low apt install -y \
  postfix dovecot-core dovecot-imapd dovecot-lmtpd dovecot-sieve mailutils swaks

(Wähle während des Postfix-Dialogs Internet-Site und setze den System-Mail-Namen auf deinedomain.de).

Schritt 2: Postfix (`main.cf`) & Dovecot-Mailboxen konfigurieren

Anstelle des veralteten Einzeldatei-Formats mbox konfigurieren wir das robuste Maildir/-Format (eine atomare Datei pro E-Mail) und richten die native automatische Ordnererstellung von Dovecot 2.3+ (Trash, Sent, Drafts, Junk) ein.

Terminal: Postfix-Basisparameter konfigurieren

sudo postconf -e "myhostname = mail.deinedomain.de"
sudo postconf -e "mydomain = deinedomain.de"
sudo postconf -e "myorigin = \$mydomain"
sudo postconf -e "mydestination = \$myhostname, \$mydomain, localhost.\$mydomain, localhost"
sudo postconf -e "inet_interfaces = all"
sudo postconf -e "home_mailbox = Maildir/"
sudo postconf -e "recipient_delimiter = +"

Sub-Addressing (recipient_delimiter = +)

Durch recipient_delimiter = + stehen dir sofort flexible Wegwerf-Aliase ohne Zusatzkonfiguration zur Verfügung! Jede E-Mail an nejat+github@deinedomain.de oder nejat+shopping@deinedomain.de wird direkt in das Postfach nejat@deinedomain.de zugestellt.

Konfiguriere nun den Maildir-Pfad von Dovecot in /etc/dovecot/conf.d/10-mail.conf und prüfe die automatische Ordnererstellung in /etc/dovecot/conf.d/15-mailboxes.conf:

/etc/dovecot/conf.d/10-mail.conf

mail_location = maildir:~/Maildir

/etc/dovecot/conf.d/15-mailboxes.conf (Natives Dovecot 2.3+ Auto-Subscribe)

namespace inbox {
  mailbox Drafts {
    auto = subscribe
    special_use = \Drafts
  }
  mailbox Junk {
    auto = subscribe
    special_use = \Junk
  }
  mailbox Trash {
    auto = subscribe
    special_use = \Trash
  }
  mailbox Sent {
    auto = subscribe
    special_use = \Sent
  }
}

4. Transportverschlüsselung (Let's Encrypt TLS 1.3) & Firewall

Übertrage niemals Passwörter oder E-Mails im Klartext. Wir beziehen über certbot ein vertrauenswürdiges Let's-Encrypt-Zertifikat und erzwingen modernes TLS 1.2 / TLS 1.3 in Postfix und Dovecot.

Schritt 1: Firewall-Ports öffnen & Zertifikat beziehen

Terminal: UFW-Firewall konfigurieren & Let's Encrypt Zertifikat ausstellen

# 1. Mail-Ports (25=SMTP, 465=SMTPS, 587=Submission, 993=IMAPS) & HTTP (für Certbot) freigeben
sudo ufw allow 25,80,465,587,993/tcp

# 2. Certbot installieren und Zertifikat für mail.deinedomain.de beziehen
sudo apt install -y certbot
sudo certbot certonly --standalone -d mail.deinedomain.de \
  --non-interactive --agree-tos --email admin@deinedomain.de \
  --deploy-hook "systemctl reload postfix; systemctl reload dovecot"

Automatische Zero-Downtime-Zertifikatserneuerung

Der Parameter --deploy-hook "systemctl reload postfix; systemctl reload dovecot" schreibt einen dauerhaften Hook in /etc/letsencrypt/renewal/mail.deinedomain.de.conf. Jedes Mal, wenn Certbot dein Zertifikat im Hintergrund erneuert, laden Postfix und Dovecot automatisch die neuen Schlüssel, ohne eine einzige aktive Verbindung zu trennen!

Schritt 2: Postfix- & Dovecot-TLS-Ciphers härten

Wende moderne TLS-Parameter über postconf auf Postfix an:

Terminal: Gehärtetes TLS 1.2/1.3 in Postfix konfigurieren

sudo postconf -e "smtpd_tls_cert_file = /etc/letsencrypt/live/mail.deinedomain.de/fullchain.pem"
sudo postconf -e "smtpd_tls_key_file = /etc/letsencrypt/live/mail.deinedomain.de/privkey.pem"
sudo postconf -e "smtpd_tls_security_level = may"
sudo postconf -e "smtpd_tls_protocols = !SSLv2, !SSLv3, !TLSv1, !TLSv1.1"
sudo postconf -e "smtpd_tls_mandatory_protocols = !SSLv2, !SSLv3, !TLSv1, !TLSv1.1"
sudo postconf -e "smtpd_tls_mandatory_ciphers = high"
sudo postconf -e "smtp_tls_security_level = may"
sudo postconf -e "smtp_tls_protocols = !SSLv2, !SSLv3, !TLSv1, !TLSv1.1"
sudo postconf -e "smtp_tls_CApath = /etc/ssl/certs"

Und konfiguriere /etc/dovecot/conf.d/10-ssl.conf:

/etc/dovecot/conf.d/10-ssl.conf

ssl = required
ssl_cert = </etc/letsencrypt/live/mail.deinedomain.de/fullchain.pem
ssl_key = </etc/letsencrypt/live/mail.deinedomain.de/privkey.pem
ssl_min_protocol = TLSv1.2
ssl_prefer_server_ciphers = yes

5. SASL-Authentifizierung & Open-Relay-Schutz

Ein nicht authentifizierter Mailserver, der E-Mails an externe Domains weiterleitet, ist ein Open Relay – Bots spüren ihn innerhalb weniger Minuten auf, fluten das Internet mit Spam und zerstören deine IP-Reputation.

Statt zwei getrennte Benutzerdatenbanken zu pflegen, delegiert Postfix die SMTP-Authentifizierung an den SASL-Socket von Dovecot:

%%{init: {'flowchart': {'wrappingWidth': 350}}}%%
flowchart TB
    Client["💻 Mail-Client (MUA)"] ==>|"1. Port 587/465"| Postfix["📮 Postfix smtpd"]
    Postfix <==>|"2. UNIX-Socket"| DovecotAuth["🔐 Dovecot Auth Dienst"]
    DovecotAuth <==>|"3. Verifizieren"| Backend[("🗄️ PAM / Virtuelle SQL-DB")]
    Postfix ==>|"4. Auth OK"| Outbound(("🌍 Ausgehender Versand"))

Schritt 1: Dovecot-SASL-Socket für Postfix bereitstellen

Bearbeite /etc/dovecot/conf.d/10-auth.conf, um plain und login über verschlüsselte TLS-Verbindungen zu erlauben:

/etc/dovecot/conf.d/10-auth.conf

disable_plaintext_auth = yes
auth_mechanisms = plain login

Und aktiviere den Postfix-UNIX-Socket innerhalb von /etc/dovecot/conf.d/10-master.conf:

/etc/dovecot/conf.d/10-master.conf (Innerhalb des service auth Blocks)

service auth {
  unix_listener /var/spool/postfix/private/auth {
    mode = 0660
    user = postfix
    group = postfix
  }
}

Schritt 2: Postfix mit Dovecot SASL verbinden & Ports 587 / 465 aktivieren

Terminal: Postfix SASL & Relay-Restriktionen konfigurieren

sudo postconf -e "smtpd_sasl_type = dovecot"
sudo postconf -e "smtpd_sasl_path = private/auth"
sudo postconf -e "smtpd_sasl_auth_enable = yes"
sudo postconf -e "smtpd_sasl_security_options = noanonymous"
sudo postconf -e "smtpd_relay_restrictions = permit_mynetworks, permit_sasl_authenticated, reject_unauth_destination"

Kommentiere die Blöcke submission (587) und smtps (465) in /etc/postfix/master.cf ein:

/etc/postfix/master.cf (Authentifizierte Submission-Ports aktivieren)

submission inet n       -       y       -       -       smtpd
  -o syslog_name=postfix/submission
  -o smtpd_tls_security_level=encrypt
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_tls_auth_only=yes
  -o smtpd_relay_restrictions=permit_sasl_authenticated,reject

smtps     inet  n       -       y       -       -       smtpd
  -o syslog_name=postfix/smtps
  -o smtpd_tls_wrappermode=yes
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_relay_restrictions=permit_sasl_authenticated,reject

Terminal: Postfix & Dovecot neu starten und Socket prüfen

sudo systemctl restart dovecot postfix
sudo ls -la /var/spool/postfix/private/auth

Hands-On Lab 1: Authentifizierten TLS-Versand mit swaks testen

Lege einen Testbenutzer an und verifiziere die Ende-zu-Ende-STARTTLS- und SASL-Authentifizierung auf Port 587 mit dem Schweizer Taschenmesser für SMTP (swaks):

Terminal: Verschlüsselten SASL-Login & Mail-Versand testen

# 1. STARTTLS + SASL-Authentifizierung auf Port 587 testen
swaks --server mail.deinedomain.de --port 587 \
      --tls \
      --auth LOGIN \
      --auth-user testuser \
      --auth-password 'DeinStarkesPasswort' \
      --from testuser@deinedomain.de \
      --to externer.empfaenger@gmail.com \
      --header "Subject: TLS + SASL Test vom eigenen Mailserver" \
      --body "Authentifiziert über TLS 1.3 via Dovecot SASL!"

# 2. TLS 1.3 Handshake auf dem IMAPS-Port 993 verifizieren
openssl s_client -connect mail.deinedomain.de:993 -servername mail.deinedomain.de </dev/null 2>/dev/null | grep -E "Protocol|Cipher|Verify return code"

6. Zustellbarkeit & Reputation: SPF, DKIM & DMARC

Ohne kryptografische Absenderauthentifizierung sortieren Gmail, Microsoft Outlook und Apple iCloud deine ausgehenden E-Mails sofort in den Spam-Ordner oder weisen sie direkt mit dem Fehlercode 550-5.7.26 ab.

Wie das kryptografische Vertrauensdreieck funktioniert

%%{init: {'flowchart': {'wrappingWidth': 350}}}%%
flowchart TB
    Email["📧 Ausgehende E-Mail<br/>user@deinedomain.de"]
    RecvServer["🛡️ Empfangender Mailserver<br/>Inbound-Validierung"]

    SPF["1️⃣ SPF-Prüfung (DNS TXT)<br/>IP-Autorisierung"]
    DKIM["2️⃣ DKIM-Prüfung (Krypto)<br/>Signatur-Abgleich DNS"]
    DMARC["3️⃣ DMARC-Alignment<br/>Richtlinie durchsetzen"]

    Inbox["🟢 Zustellung in Posteingang<br/>Authentifizierung bestanden"]
    Reject["🔴 Quarantäne oder Reject<br/>SMTP 550 Ablehnung"]

    Email ==>|"SMTP :25 Zustellung"| RecvServer
    RecvServer --> SPF
    RecvServer --> DKIM
    SPF --> DMARC
    DKIM --> DMARC
    DMARC ==>|"PASS"| Inbox
    DMARC ==>|"FAIL"| Reject

Schritt 1: SPF-Record im DNS veröffentlichen

Erstelle einen TXT-Record auf deiner Root-Domain (@ / deinedomain.de), der ausschließlich deinen MX-Server autorisiert und alle gefälschten Absender-IPs explizit abweist (-all):

DNS TXT Record: SPF-Richtlinie

Name:  @ (oder deinedomain.de)
Type:  TXT
Value: "v=spf1 mx a:mail.deinedomain.de -all"

Schritt 2: OpenDKIM installieren & konfigurieren (2048-Bit RSA-Signierung)

Terminal: OpenDKIM installieren & kryptografische Schlüssel erzeugen

# 1. OpenDKIM und Werkzeuge installieren
sudo apt install -y opendkim opendkim-tools

# 2. Postfix-Benutzer Zugriff auf den OpenDKIM-Socket im Postfix-Chroot gewähren
sudo usermod -aG opendkim postfix
sudo mkdir -p /var/spool/postfix/opendkim
sudo chown opendkim:postfix /var/spool/postfix/opendkim
sudo chmod 750 /var/spool/postfix/opendkim

# 3. Schlüsselverzeichnis anlegen und 2048-Bit RSA-Schlüsselpaar mit Selektor 'default' generieren
sudo mkdir -p /etc/opendkim/keys/deinedomain.de
sudo opendkim-genkey -b 2048 -d deinedomain.de -s default -D /etc/opendkim/keys/deinedomain.de/
sudo chown -R opendkim:opendkim /etc/opendkim
sudo chmod 600 /etc/opendkim/keys/deinedomain.de/default.private

Konfiguriere /etc/opendkim.conf für den chroot-sicheren UNIX-Socket /var/spool/postfix/opendkim/opendkim.sock:

/etc/opendkim.conf

Syslog                  yes
UMask                   007
Mode                    sv
Canonicalization        relaxed/simple
Socket                  local:/var/spool/postfix/opendkim/opendkim.sock
UserID                  opendkim
PidFile                 /run/opendkim/opendkim.pid
KeyTable                refile:/etc/opendkim/KeyTable
SigningTable            refile:/etc/opendkim/SigningTable
InternalHosts           refile:/etc/opendkim/TrustedHosts
ExternalIgnoreList      refile:/etc/opendkim/TrustedHosts

Befülle die drei Zuordnungstabellen:

Terminal: KeyTable, SigningTable und TrustedHosts anlegen

cat << 'EOF' | sudo tee /etc/opendkim/KeyTable
default._domainkey.deinedomain.de deinedomain.de:default:/etc/opendkim/keys/deinedomain.de/default.private
EOF

cat << 'EOF' | sudo tee /etc/opendkim/SigningTable
*@deinedomain.de default._domainkey.deinedomain.de
EOF

cat << 'EOF' | sudo tee /etc/opendkim/TrustedHosts
127.0.0.1
localhost
::1
*.deinedomain.de
EOF

sudo chown opendkim:opendkim /etc/opendkim/KeyTable /etc/opendkim/SigningTable /etc/opendkim/TrustedHosts

Verbinde Postfix mit dem OpenDKIM-Milter:

Terminal: OpenDKIM-Milter in Postfix einbinden

sudo postconf -e "milter_default_action = accept"
sudo postconf -e "milter_protocol = 6"
sudo postconf -e "smtpd_milters = local:opendkim/opendkim.sock"
sudo postconf -e "non_smtpd_milters = \$smtpd_milters"

sudo systemctl restart opendkim postfix

Lass dir deinen generierten öffentlichen DKIM-Schlüssel anzeigen und trage ihn als TXT-Record unter default._domainkey.deinedomain.de im DNS ein:

Terminal: Öffentlichen DKIM-DNS-Record anzeigen

sudo cat /etc/opendkim/keys/deinedomain.de/default.txt

Schritt 3: DMARC-Record im DNS veröffentlichen

Erstelle einen TXT-Record für _dmarc.deinedomain.de. Starte mit p=quarantine (oder p=none während der ersten Tests) und wechsle nach erfolgreicher Verifikation auf p=reject:

DNS TXT Record: DMARC-Richtlinie

Name:  _dmarc
Type:  TXT
Value: "v=DMARC1; p=quarantine; rua=mailto:postmaster@deinedomain.de; adkim=r; aspf=r; pct=100"

7. Spam- & Malware-Abwehr-Pipeline

Ein öffentlich erreichbarer Port 25 wird permanent von automatisierten Spam- und Malware-Bots gescannt. Wir filtern eingehende E-Mails daher über eine mehrstufige Inspektions-Pipeline:

%%{init: {'flowchart': {'wrappingWidth': 350}}}%%
flowchart TB
    In(("🌐 Port :25")) --> RBL["1️⃣ Postfix DNSBLs<br/>(Botnet-IPs abweisen)"]
    RBL --> DKIM_V["2️⃣ OpenDKIM<br/>(Signatur prüfen)"]
    DKIM_V --> AV["3️⃣ ClamAV Daemon<br/>(Malware blockieren)"]
    AV --> Spam["4️⃣ SpamAssassin / Rspamd<br/>(Heuristik-Scoring)"]
    Spam --> Sieve["5️⃣ Dovecot Sieve<br/>(In Junk verschieben)"]

Option A: Klassisches Amavis + SpamAssassin + ClamAV Option B: Moderner Rspamd-Milter (High-Performance-Alternative)

Terminal: Amavis, SpamAssassin & ClamAV installieren

sudo apt install -y amavisd-new spamassassin clamav-daemon clamav-freshclam \
  pyzor razor libnet-dns-perl libmail-dkim-perl

# ClamAV und Amavis gegenseitigen Socket-Zugriff gewähren
sudo adduser clamav amavis
sudo adduser amavis clamav

# SpamAssassin-Regel-Updates aktivieren und Dienste starten
sudo sa-update
sudo systemctl enable --now clamav-daemon clamav-freshclam spamassassin amavis

Aktiviere die Viren- und Spam-Prüfung in /etc/amavis/conf.d/15-content_filter_mode:

/etc/amavis/conf.d/15-content_filter_mode

use strict;
@bypass_virus_checks_maps = (
   \%bypass_virus_checks, \@bypass_virus_checks_acl, \$bypass_virus_checks_re);
@bypass_spam_checks_maps = (
   \%bypass_spam_checks, \@bypass_spam_checks_acl, \$bypass_spam_checks_re);
1;

Auf Servern mit begrenztem Arbeitsspeicher ersetzt Rspamd (in C geschrieben) sowohl Amavis, SpamAssassin als auch OpenDKIM in einem einzigen, extrem schnellen Daemon inklusive integriertem Web-Dashboard (127.0.0.1:11334):

Terminal: Rspamd & Redis-Backend installieren

sudo apt install -y rspamd redis-server
sudo postconf -e "smtpd_milters = inet:127.0.0.1:11332"
sudo postconf -e "non_smtpd_milters = inet:127.0.0.1:11332"
sudo postconf -e "milter_mail_macros = i {mail_addr} {client_addr} {client_name} {auth_authen}"
sudo systemctl restart rspamd postfix

Hands-On Lab 2: Anti-Spam- (GTUBE) & Anti-Virus-Erkennung (EICAR) testen

Teste deine Filter niemals mit echter Schadsoftware! Verwende stattdessen die weltweit standardisierten, völlig harmlosen Prüf-Signaturen GTUBE (Spam-Trigger) und EICAR (Antivirus-Trigger):

Terminal: GTUBE- & EICAR-Test-Payloads abfeuern

# 1. Spam-Filter mit der standardisierten GTUBE-Signatur testen
swaks --to testuser@deinedomain.de --from spamtest@example.org --server localhost \
      --header "Subject: GTUBE Spam Filter Test" \
      --body "XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X"

# 2. ClamAV Antivirus mit der standardisierten EICAR-Signatur testen
swaks --to testuser@deinedomain.de --from virustest@example.org --server localhost \
      --header "Subject: EICAR Antivirus Test" \
      --body 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*'

# 3. /var/log/mail.log inspizieren, um die Erkennung zu verifizieren
sudo tail -n 25 /var/log/mail.log

8. Webmail-Zugang mit Roundcube

Um von jedem Browser aus über eine moderne Oberfläche auf deine Postfächer zuzugreifen, stellen wir Roundcube Webmail bereit und verbinden es lokal mit Dovecot (IMAPS :993) und Postfix (Submission :587):

Docker-Compose-Deployment (Sauber & Isoliert) Native Paketinstallation unter Debian / Ubuntu

Da auf deinem VPS bereits Nginx läuft, hält der Betrieb von Roundcube in einem isolierten Container auf 127.0.0.1:8090 dein Host-System frei von zusätzlichen PHP- und Apache-Abhängigkeiten:

~/roundcube-stack/docker-compose.yml

services:
  roundcube:
    image: docker.io/roundcube/roundcubemail:latest
    container_name: roundcube-webmail
    restart: unless-stopped
    ports:
      - "127.0.0.1:8090:80"
    environment:
      - ROUNDCUBEMAIL_DEFAULT_HOST=ssl://mail.deinedomain.de
      - ROUNDCUBEMAIL_DEFAULT_PORT=993
      - ROUNDCUBEMAIL_SMTP_SERVER=tls://mail.deinedomain.de
      - ROUNDCUBEMAIL_SMTP_PORT=587
      - ROUNDCUBEMAIL_UPLOAD_MAX_FILESIZE=25M
    volumes:
      - roundcube_db:/var/roundcube/db
      - roundcube_config:/var/roundcube/config

volumes:
  roundcube_db:
  roundcube_config:

Terminal: Roundcube nativ mit MariaDB installieren

sudo apt install -y roundcube roundcube-mysql roundcube-plugins

Setze in /etc/roundcube/config.inc.php:

/etc/roundcube/config.inc.php

$config['imap_host'] = 'ssl://mail.deinedomain.de:993';
$config['smtp_host'] = 'tls://mail.deinedomain.de:587';
$config['smtp_user'] = '%u';
$config['smtp_pass'] = '%p';

9. Betrieb: Queue-Management, Logs & Fehlersuche

Postfix Queue-Management Cheat-Sheet

Befehl	Aktion & Einsatzzweck
`mailq` oder `postqueue -p`	Alle Nachrichten auflisten, die aktuell in den Warteschlangen `active`, `deferred` oder `hold` liegen.
`sudo postcat -q <QUEUE_ID>`	Vollständige Header und den Body einer bestimmten Nachricht in der Queue inspizieren.
`sudo postqueue -f`	Queue leeren (Flush): Sofortigen Zustellversuch für alle verzögerten Nachrichten erzwingen.
`sudo postsuper -h <QUEUE_ID>`	Eine verdächtige Nachricht auf hold setzen, damit Postfix keine weiteren Zustellversuche unternimmt.
`sudo postsuper -d <QUEUE_ID>`	Eine bestimmte Nachricht dauerhaft aus der Queue löschen.
`sudo postsuper -d ALL deferred`	Notfall-Bereinigung: Alle verzögerten (`deferred`) Nachrichten aus der Queue löschen.

Häufige Fehlerszenarien

1. Gmail lehnt ausgehende E-Mails mit 550-5.7.1 oder 550-5.7.26 ab

Ursache: Google setzt für alle einliefernden Mailserver strikt zwei Anforderungen durch: 1. Einen gültigen Forward-Confirmed Reverse DNS (PTR)-Eintrag, der exakt zum EHLO-Hostnamen (mail.deinedomain.de) passt. 2. Gültige SPF- (v=spf1 ...) UND DKIM-Signaturen (2048-Bit RSA) samt veröffentlichter _dmarc-Richtlinie.

Lösung: Teste deinen Live-Score unter mail-tester.com und prüfe, ob dig -x <DEINE_IP> +short exakt mail.deinedomain.de. zurückgibt.

2. Mail-Client kann nicht senden: SASL authentication failure: cannot connect to Dovecot auth

Ursache: Postfix läuft unter Debian/Ubuntu standardmäßig in einem Chroot-Gefängnis unter /var/spool/postfix. Wenn Dovecot seinen Socket unter /var/run/dovecot/auth-client statt innerhalb des Postfix-Chroots anlegt, kann Postfix ihn nicht erreichen.

Lösung: Stelle sicher, dass /etc/dovecot/conf.d/10-master.conf den Listener unter /var/spool/postfix/private/auth mit user = postfix, group = postfix und mode = 0660 anlegt.

3. Ausgehende E-Mails hängen in der deferred-Queue fest (Connection timed out on port 25)

Ursache: Dein Cloud-/VPS-Provider blockiert ausgehenden TCP-Port 25 in seiner vorgeschalteten Plattform-Firewall.

Lösung: Eröffne ein Support-Ticket bei deinem VPS-Provider (z. B. Hetzner, Netcup, DigitalOcean), um ausgehenden Port 25 nach Kontoverifizierung freischalten zu lassen, oder richte ein authentifiziertes SMTP-Relay (relayhost = [smtp.relayprovider.com]:587) in der main.cf ein.

4. Wie prüfe ich, ob mein Server einen 10/10 Deliverability-Score erreicht?

Führe diese schnelle Verifikations-Checkliste direkt in deinem Terminal aus:

Terminal: Vollständiges DNS-Auth-Audit

dig TXT deinedomain.de +short                      # SPF prüfen
dig TXT default._domainkey.deinedomain.de +short   # Öffentlichen DKIM-Schlüssel prüfen
dig TXT _dmarc.deinedomain.de +short               # DMARC-Richtlinie prüfen