# 25 - SMTP

SMTP steht für "Simple Mail Transfer Protocol" und wird verwendet, um den Versand von E-Mails zu verwalten. Es arbeitet in Verbindung mit POP oder IMAP, um sowohl den Versand als auch den Empfang von E-Mails zu ermöglichen.

#### **SMTP Functions:**

1. **Verifizierung:** Der SMTP-Server überprüft, wer E-Mails über ihn sendet
2. **Versand:** Er versendet die ausgehende E-Mail
3. **Fehlermeldung:** Wenn die E-Mail nicht zugestellt werden kann, wird eine Nachricht an den Absender zurückgesendet

#### **POP vs. IMAP:**

* **POP (Post Office Protocol):** Lädt die gesamte Mailbox vom Server herunter und speichert sie lokal.
* **IMAP (Internet Message Access Protocol):** Synchronisiert die Mailbox zwischen dem Server und dem Client, sodass Änderungen an der Mailbox auf allen Geräten sichtbar sind.

## Ablauf SMTP

#### **1. SMTP Handshake**

* **Verbindung:** Dein E-Mail-Client (Mail User Agent) verbindet sich mit dem SMTP-Server deines E-Mail-Anbieters, z.B. `smtp.google.com`, über den SMTP-Port (normalerweise 25).
* **Handshake:** Der SMTP-Server und dein Client führen einen Handshake durch, bei dem die Verbindung und die Identität des Absenders validiert werden.
* **Sitzung:** Nach erfolgreichem Handshake beginnt die SMTP-Sitzung, in der E-Mails gesendet werden können.

#### **2. Senden der E-Mail**

* **Übermittlung:** Dein E-Mail-Client übermittelt dem SMTP-Server den Absender (MAIL FROM), den Empfänger (RCPT TO), den Inhalt der E-Mail und eventuelle Anhänge.
* **Validierung:** Der SMTP-Server prüft, ob die E-Mail korrekt formatiert ist und ob alle erforderlichen Informationen vorhanden sind.

#### **3. Prüfung der Domain**

* **Interne Zustellung:** Der SMTP-Server prüft, ob die Domain des Empfängers mit der des Absenders übereinstimmt.
  * **Gleiche Domain:** Wenn die Domains übereinstimmen (z.B. beide E-Mail-Adressen gehören zu `example.com`), wird die E-Mail direkt intern zugestellt.
  * **Unterschiedliche Domains:** Wenn die Domains unterschiedlich sind, wird die E-Mail an den SMTP-Server des Empfängers weitergeleitet.

#### **4. Weiterleitung und SMTP Queue**

* **Verbindung zum Empfänger-Server:** Der SMTP-Server des Absenders stellt eine Verbindung zum SMTP-Server des Empfängers her.
* **Fehlerbehandlung:** Wenn der Empfänger-Server nicht erreichbar ist oder es andere Probleme gibt, wird die E-Mail in eine **SMTP Queue** gestellt.
  * **SMTP Queue:** Dies ist ein temporärer Speicher auf dem Server, in dem die E-Mail verbleibt, bis der SMTP-Server des Empfängers erreichbar ist. Der SMTP-Server versucht regelmäßig, die E-Mail erneut zuzustellen.

#### **5. Zustellung der E-Mail**

* **Verifikation durch den Empfänger-Server:** Der SMTP-Server des Empfängers prüft, ob die Domain und der Benutzername existieren und gültig sind.
* **Weiterleitung an POP/IMAP:** Wenn die E-Mail verifiziert ist, leitet der SMTP-Server sie an den entsprechenden POP- oder IMAP-Server weiter.
* **E-Mail im Posteingang:** Die E-Mail erscheint schließlich im Posteingang des Empfängers.

## SMTP Pentest

### 1. Service Enumeration (Dienst-Erkennung)

Der erste Schritt in einem Penetrationstest ist das Sammeln von Informationen über den SMTP-Dienst. Hierbei werden Tools wie **Nmap** verwendet, um die SMTP-Kommandos und -Funktionen zu ermitteln, die vom Server unterstützt werden.

#### Nmap-Skript: `smtp-commands`

```bash
$ sudo nmap -sC -sV -p25 10.129.14.128
PORT   STATE SERVICE VERSION
25/tcp open  smtp    Postfix smtpd
|_smtp-commands: mail.example.com, PIPELINING, SIZE 10240000, VRFY, ETRN, ENHANCEDSTATUSCODES
MAC Address: 00:00:00:00:00:00 (VMware)
```

* `-sC`: Führt Standard-NSE-Skripte aus.
* `-sV`: Identifiziert den SMTP-Dienst und seine Version.
* `-p25`: Scannt den SMTP-Port (25).

Diese Information zeigt, welche **SMTP-Kommandos** der Server unterstützt. Interessant sind hier insbesondere **VRFY** (User Verification), **PIPELINING** und **STARTTLS** (für verschlüsselte Verbindungen).

***

### 2. Interaktion mit dem SMTP-Server über Telnet

Um manuell mit dem SMTP-Server zu interagieren, wird häufig **Telnet** verwendet. Dies ermöglicht es, Befehle direkt an den Server zu senden, um Schwachstellen wie Benutzerenumeration oder Open Relays zu überprüfen.

#### Verbindung zum SMTP-Server herstellen:

```bash
$ telnet 10.129.14.128 25
```

* Dies stellt eine unverschlüsselte Verbindung zum SMTP-Server auf **Port 25** her.

#### HELO und EHLO Kommandos

* **HELO**: Initiiert die Kommunikation und stellt den Hostnamen des Clients vor.
* **EHLO**: Eine erweiterte Version von HELO für ESMTP (Extended SMTP), die zusätzliche Funktionen wie STARTTLS und Authentifizierung ermöglicht.

```bash
HELO example.com
250 example.com

EHLO example.com
250-example.com
250-PIPELINING
250-SIZE 10240000
250-STARTTLS
250-ENHANCEDSTATUSCODES
```

* **HELO** oder **EHLO** sind notwendig, um die Kommunikation mit dem Server zu beginnen.
* Die Ausgabe zeigt die unterstützten **ESMTP-Erweiterungen** wie **PIPELINING** (Erlaubt mehrere Befehle ohne Wartezeit), **STARTTLS** (für verschlüsselte Verbindungen) und **VRFY** (Benutzerüberprüfung).

***

### 3. Benutzerenumeration (User Enumeration)

Eine häufige Schwachstelle bei SMTP ist die **Benutzerenumeration**. Diese kann ausgenutzt werden, um festzustellen, ob bestimmte Benutzer auf dem System existieren. Der **VRFY**-Befehl (Verify) wird häufig für diesen Zweck verwendet, aber alternative Methoden wie **RCPT TO** können ebenfalls angewendet werden. Diese Techniken helfen dabei, gültige Benutzerkonten zu finden, was nützlich für weitere Angriffe sein kann.

#### VRFY-Kommando

Der **VRFY**-Befehl überprüft, ob ein bestimmter Benutzer auf dem SMTP-Server existiert.

**Beispiel:**

<pre class="language-bash"><code class="lang-bash">$ telnet 10.236.214.258 25
<strong>VRFY admin
</strong>252 2.0.0 admin
</code></pre>

* **VRFY admin**: Der Server bestätigt, dass der Benutzer **admin** existiert (Antwortcode: **252**).

```bash
$ telnet 10.236.214.258 25
VRFY nonexistentuser
550 5.1.1 <nonexistentuser>: Recipient address rejected: User unknown in virtual mailbox table
```

* **VRFY nonexistentuser**: Der Server lehnt die Existenz eines Benutzers ab (Antwortcode: **550**).

**Hinweis:**

Manche Server deaktivieren den **VRFY**-Befehl oder geben immer eine positive Antwort zurück (Code 252), um Enumeration zu verhindern.

#### Alternative Methode: RCPT TO

Falls der **VRFY**-Befehl deaktiviert oder limitiert ist, kann die Benutzerüberprüfung auch über das **RCPT TO**-Kommando erfolgen. Diese Methode nutzt die Überprüfung der E-Mail-Empfänger, um die Existenz von Benutzern zu validieren.

**Beispiel:**

```bash
$ telnet 10.236.214.258 25
MAIL FROM: <test@example.com>
250 2.1.0 Ok

RCPT TO: <validuser@example.com>
250 2.1.5 Ok
```

* **RCPT TO**: Der Server bestätigt, dass der Benutzer existiert.

```bash
$ telnet 10.236.214.258 25
RCPT TO: <invaliduser@example.com>
550 5.1.1 <invaliduser@example.com>: Recipient address rejected: User unknown in local recipient table
```

* **RCPT TO**: Der Server lehnt den Benutzer ab (Antwortcode: **550**).

#### Automatisierte Benutzerbruteforce mit `smtp-user-enum`

Um den Brute-Force-Prozess zu automatisieren und eine Liste von Benutzern auf einem SMTP-Server zu testen, eignet sich das Tool **`smtp-user-enum`**. Es unterstützt die Brute-Force-Überprüfung über **VRFY**, **EXPN** und **RCPT TO**-Befehle.

**Beispiel für die Verwendung von `smtp-user-enum` mit RCPT TO:**

```bash
$ smtp-user-enum -M RCPT -U /path/to/userlist.txt -t 10.129.14.128 -D example.com
| 10.129.14.128 | testuser        | User found |
| 10.129.14.128 | admin           | User found |
| 10.129.14.128 | invaliduser     | User not found |
```

**Erklärung:**

* `-M RCPT`: Methode zur Überprüfung (in diesem Fall über **RCPT TO**).
* `-U /path/to/userlist.txt`: Der Pfad zur Liste von Benutzernamen, die bruteforced werden soll.
* `-t 10.129.14.128`: Ziel-SMTP-Server (IP-Adresse).
* `-D example.com`: Die Domain, gegen die die Benutzernamen getestet werden sollen (in diesem Fall **example.com**).

**Erweiterte Optionen:**

* **Parallelisierung**: Mit `-m 5` kannst du 5 parallele Verbindungen nutzen, um den Prozess zu beschleunigen.
* **Port**: Der SMTP-Port kann mit `-p 25` festgelegt werden.

#### Metasploit

1\. **Starte Metasploit**

```bash
$ msfconsole
```

2\. **Suche das Modul `smtp_enum`**

```bash
msf > search smtp_enum
```

3\. **Wähle das Modul aus**

```bash
msf > use auxiliary/scanner/smtp/smtp_enum
```

4\. **Zeige die verfügbaren Optionen**

```bash
msf > options
```

5\. **Setze die Ziel-IP-Adresse (RHOSTS)**

```bash
msf > set RHOSTS <Ziel-IP-Adresse>
```

6\. **Setze die Benutzerdatei (USER\_FILE)**

```bash
msf > set USER_FILE /path/to/footprinting-wordlist.txt
```

7\. **Starte den Exploit**

```bash
msf > exploit
```

***

### 4. Open Relay Testing

Ein **Open Relay** ist ein SMTP-Server, der E-Mails von jedem Absender an jeden Empfänger weiterleitet, ohne Authentifizierung zu verlangen. Dies kann für **Spam-Versand** oder **E-Mail-Spoofing** missbraucht werden.

#### Open Relay Test mit Nmap

Mit Nmap kannst du überprüfen, ob ein SMTP-Server als Open Relay fungiert:

```bash
$ sudo nmap -p25 --script smtp-open-relay 10.129.14.128
PORT   STATE SERVICE
25/tcp open  smtp
| smtp-open-relay: Server is an open relay (16/16 tests)
```

* Diese Ausgabe zeigt, dass der Server als Open Relay konfiguriert ist und potenziell für Spam missbraucht werden kann.

**Unsichere Open Relay-Konfiguration in Postfix:**

```bash
mynetworks = 0.0.0.0/0
```

* Diese Einstellung erlaubt allen Hosts, E-Mails über den Server zu versenden.

***

### 5. E-Mail-Spoofing

Ein weiteres Problem mit falsch konfigurierten SMTP-Servern ist **E-Mail-Spoofing**, bei dem gefälschte Absenderadressen verwendet werden, um den Anschein zu erwecken, dass eine E-Mail von einer vertrauenswürdigen Quelle stammt.

#### E-Mail-Spoofing über Telnet

```bash
MAIL FROM: <fake.sender@example.com>
250 2.1.0 Ok

RCPT TO: <victim@example.com>
250 2.1.5 Ok

DATA
354 End data with <CR><LF>.<CR><LF>
From: fake.sender@example.com
To: victim@example.com
Subject: Test Spoofing
This is a spoofed email.
.
250 2.0.0 Ok: queued as 12345
```

* **MAIL FROM**: Falsche Absenderadresse.
* **RCPT TO**: Zieladresse.
* **DATA**: Der Inhalt der E-Mail.

***

### 6. Abwehrmechanismen: SPF, DKIM, DMARC

Um Angriffe wie **E-Mail-Spoofing** und **Spam** zu verhindern, werden oft folgende Mechanismen implementiert:

1. **SPF (Sender Policy Framework)**: Definiert, welche Server E-Mails im Namen einer Domain senden dürfen.
2. **DKIM (DomainKeys Identified Mail)**: Signiert E-Mails digital, um die Echtheit des Absenders zu bestätigen.
3. **DMARC (Domain-based Message Authentication, Reporting & Conformance)**: Verknüpft SPF und DKIM und gibt Richtlinien zur Handhabung von fehlgeschlagenen Überprüfungen vor.

**Prüfung eines SPF-Eintrags mit `dig`:**

```bash
$ dig TXT example.com
example.com.  600 IN TXT "v=spf1 include:_spf.google.com ~all"
```

* Dieser SPF-Eintrag erlaubt es nur den Servern, die im SPF-Record von Google definiert sind, E-Mails zu senden.
