Bauen Sie Ihren eigenen Telegram Bot auf, um IPv4 Blacklists auf einem VPS zu überwachen

Die Eintragung Ihrer IP-Adresse auf Spam-Blacklisten zu vermeiden ist entscheidend für die E-Mail-Zustellbarkeit, den Dienstruf und den reibungslosen Betrieb. Egal ob Sie einen Mail-Server, eine SaaS-Plattform oder eine Web-Anwendung betreiben – ein einzelner Blacklist-Eintrag kann Ihre ausgehenden E-Mails stillschweigend blockieren und das Kundenvertrauen über Nacht untergraben. In diesem umfassenden Leitfaden erfahren Sie, wie Sie einen vollständig funktionsfähigen Telegram-Bot erstellen und bereitstellen, der automatisch jede IPv4-Adresse gegen große Spam-Datenbanken prüft – alles auf einem zuverlässigen VPS.

Warum IPv4-Blacklist-Überwachung automatisieren?

Manuelle Blacklist-Checks sind mühsam und leicht zu vergessen. Durch die Automatisierung des Prozesses über einen Telegram-Bot erhalten Sie:

• Sofortige On-Demand-Checks — fragen Sie jede IP direkt von Ihrem Telefon oder Desktop ab
• Echtzeit-Feedback — Ergebnisse werden innerhalb von Sekunden in Telegram bereitgestellt
• Null Infrastruktur-Overhead — der Bot läuft persistent im Hintergrund auf Ihrem Server
• Skalierbarkeit — erweitern Sie den Bot später mit geplanten Benachrichtigungen, Webhook-Integrationen oder Batch-Checks mit mehreren IPs

Eine IP, die in Datenbanken wie Spamhaus, SpamCop, StopForumSpam oder Blocklist.de aufgelistet ist, kann zu E-Mail-Zustellungsfehlern, Dienstsuspensionen und Reputationsschäden führen. Proaktive Überwachung ist weitaus günstiger als reaktive Schadenskontrolle.

Warum auf einer AlexHost VPS bereitstellen?

Das Ausführen eines Telegram-Bots erfordert einen Server, der 24/7 online bleibt, schnell reagiert und vollständigen Root-Zugriff für die Installation benutzerdefinierter Abhängigkeiten bietet. AlexHost VPS Hosting bietet genau das — NVMe SSD-Speicher für schnelle I/O, Enterprise-Grade DDoS-Schutz und vollständigen Root-Zugriff, damit Sie Python, Selenium, Browser-Treiber und andere Tools ohne Einschränkungen installieren können.

Im Gegensatz zu gemeinsamen Umgebungen, in denen Ressourcenlimits die Leistung Ihres Bots drosseln können, bietet eine dedizierte VPS konsistente CPU- und RAM-Zuordnung für Ihre Anwendung. Wenn Sie eine verwaltete Control-Panel-Erfahrung bevorzugen, ist auch VPS mit cPanel verfügbar, was die Serververwaltung auch für diejenigen zugänglich macht, die sich mit der Befehlszeile weniger wohlfühlen.

Voraussetzungen

Bevor Sie eine einzige Codezeile schreiben, stellen Sie sicher, dass folgende Voraussetzungen auf Ihrem Server erfüllt sind:

Systemanforderungen

Python-Bibliotheken installieren

Verbinden Sie sich über SSH mit Ihrem VPS und führen Sie die folgenden Befehle aus, um die erforderlichen Python-Pakete zu installieren:

pip install selenium
pip install aiogram==3.4.1

• Selenium — automatisiert Browser-Interaktionen zum Scraping von Blacklist-Überprüfungsergebnissen von MXToolbox
• aiogram 3.4.1 — ein modernes, async-first Python-Framework für die Telegram Bot API

Google Chrome und ChromeDriver installieren (Headless)

Selenium benötigt einen echten Browser zum Rendern von JavaScript-lastigen Seiten. Installieren Sie Chrome im Headless-Modus auf Ihrem Linux-Server:

# Install dependencies
sudo apt update
sudo apt install -y wget curl unzip fonts-liberation libappindicator3-1 libasound2 
  libatk-bridge2.0-0 libatk1.0-0 libcups2 libdbus-1-3 libgdk-pixbuf2.0-0 
  libnspr4 libnss3 libx11-xcb1 libxcomposite1 libxdamage1 libxrandr2 
  xdg-utils libgbm1

# Download and install Chrome
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo dpkg -i google-chrome-stable_current_amd64.deb
sudo apt --fix-broken install -y

# Verify installation
google-chrome --version

Installieren Sie dann den passenden ChromeDriver:

# Get your Chrome version number first
CHROME_VERSION=$(google-chrome --version | grep -oP 'd+.d+.d+.d+')
CHROME_MAJOR=$(echo $CHROME_VERSION | cut -d. -f1)

# Download matching ChromeDriver
wget "https://chromedriver.storage.googleapis.com/LATEST_RELEASE_${CHROME_MAJOR}" -O latest_release
DRIVER_VERSION=$(cat latest_release)
wget "https://chromedriver.storage.googleapis.com/${DRIVER_VERSION}/chromedriver_linux64.zip"
unzip chromedriver_linux64.zip
sudo mv chromedriver /usr/local/bin/
sudo chmod +x /usr/local/bin/chromedriver

Schritt 1 — Erstellen Sie Ihren Telegram-Bot mit BotFather

Jeder Telegram-Bot beginnt mit BotFather — dem offiziellen Telegram-Bot zur Registrierung und Verwaltung von Bots.

1.1 Öffnen Sie Telegram und suchen Sie nach @BotFather (achten Sie auf das verifizierte blaue Häkchen).

1.2 Starten Sie eine Konversation und senden Sie den Befehl:

/newbot

1.3 Folgen Sie den Anweisungen:

• Geben Sie einen Anzeigenamen für Ihren Bot ein (z. B. IP Blacklist Monitor)
• Geben Sie einen eindeutigen Benutzernamen ein, der auf bot endet (z. B. ip_blacklist_monitor_bot)

1.4 BotFather antwortet mit einer Bestätigungsmeldung ähnlich wie:

Done! Congratulations on your new bot.
You will find it at t.me/ip_blacklist_monitor_bot.

Use this token to access the HTTP API:
7123456789:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Keep your token secure and store it safely — it can be used by anyone to control your bot.

Kopieren und speichern Sie dieses API-Token sicher. Sie benötigen es im nächsten Schritt. Committen Sie es niemals in ein öffentliches Repository.

Schritt 2 — Bot-Code schreiben

Erstellen Sie auf Ihrem VPS eine neue Python-Datei:

nano ~/my_bot.py

Fügen Sie den folgenden vollständigen, produktionsreifen Code ein:

import asyncio
import time
from aiogram import Bot, Dispatcher, F
from aiogram.filters import CommandStart
from aiogram.types import Message
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options

# ─── Configuration ────────────────────────────────────────────────────────────
BOT_TOKEN = 'YOUR_BOT_TOKEN_HERE'  # Replace with your BotFather token
# ──────────────────────────────────────────────────────────────────────────────

bot = Bot(BOT_TOKEN)
dp = Dispatcher()

def get_chrome_driver():
    """Initialize a headless Chrome driver for server environments."""
    chrome_options = Options()
    chrome_options.add_argument('--headless')
    chrome_options.add_argument('--no-sandbox')
    chrome_options.add_argument('--disable-dev-shm-usage')
    chrome_options.add_argument('--disable-gpu')
    chrome_options.add_argument('--window-size=1920,1080')
    return webdriver.Chrome(options=chrome_options)

def get_results(ip: str) -> list:
    """
    Use Selenium to check an IPv4 address against blacklists via MXToolbox.
    Returns a list of [status, blacklist_name] pairs.
    """
    results = []
    driver = get_chrome_driver()

    try:
        # Navigate to MXToolbox blacklist checker
        url = f"https://mxtoolbox.com/SuperTool.aspx?action=blacklist%3a{ip}&run=toolpage"
        driver.get(url)
        time.sleep(6)  # Allow the page and results to fully load

        # Locate the IP input field and submit the query
        input_field = driver.find_element(By.NAME, 'ctl00$ContentPlaceHolder1$txtInput2')
        input_field.clear()
        input_field.send_keys(ip)
        time.sleep(3)

        search_button = driver.find_element(By.ID, 'btnAction3')
        search_button.click()
        time.sleep(6)  # Wait for results to render

        # Scrape up to 60 status and name columns
        status_results = driver.find_elements(By.CLASS_NAME, 'table-column-Status')[:60]
        name_results = driver.find_elements(By.CLASS_NAME, 'table-column-Name')[:60]

        if len(status_results) == len(name_results):
            for status, name in zip(status_results, name_results):
                results.append([status.text, name.text])
        else:
            print(f"[WARNING] Status/name count mismatch for IP: {ip}")

    except Exception as e:
        print(f"[ERROR] Failed to retrieve results for {ip}: {e}")
    finally:
        driver.quit()

    return results

@dp.message(CommandStart())
async def handle_start(message: Message):
    """Handle the /start command — greet the user and explain usage."""
    await message.answer(
        f"👋 Hello, {message.from_user.first_name}!nn"
        f"Send me any IPv4 address and I will check it against major spam blacklists.nn"
        f"Example: <code>192.168.1.1</code>",
        parse_mode="HTML"
    )

@dp.message(F.text)
async def handle_ip_check(message: Message):
    """Receive an IP address, run the blacklist check, and return formatted results."""
    ip = message.text.strip()
    await message.answer(f"🔍 Checking <code>{ip}</code> against blacklists. Please wait...", parse_mode="HTML")

    loop = asyncio.get_event_loop()
    # Run the blocking Selenium call in a thread pool to avoid blocking the event loop
    raw_results = await loop.run_in_executor(None, get_results, ip)

    if not raw_results:
        await message.answer("⚠️ No results returned. Please verify the IP address and try again.")
        return

    output_lines = []
    blacklisted_count = 0

    for status, name in raw_results:
        if status.strip().upper() == 'OK':
            output_lines.append(f"✅ {name}")
        else:
            output_lines.append(f"❌ {name}")
            blacklisted_count += 1

    summary = f"📊 <b>Results for {ip}</b>n"
    summary += f"🚫 Listed on {blacklisted_count} blacklist(s)nn"
    summary += "n".join(output_lines)

    # Telegram messages have a 4096-character limit — split if necessary
    if len(summary) > 4096:
        for i in range(0, len(summary), 4096):
            await message.answer(summary[i:i+4096], parse_mode="HTML")
    else:
        await message.answer(summary, parse_mode="HTML")

async def main():
    print("✅ Bot is running. Listening for messages...")
    await dp.start_polling(bot)

if __name__ == '__main__':
    asyncio.run(main())

Speichern und beenden (Ctrl+O, Enter, Ctrl+X in nano).

Schritt 3 — Bot-Token sicher konfigurieren

Ersetzen Sie YOUR_BOT_TOKEN_HERE im Skript durch das Token, das Sie von BotFather erhalten haben. Für Produktionsbereitstellungen wird dringend empfohlen, eine Umgebungsvariable zu verwenden, anstatt das Token hartcodiert einzugeben:

export TELEGRAM_BOT_TOKEN="7123456789:AAFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

Aktualisieren Sie dann die Codezeile zu:

import os
BOT_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN')

Dies verhindert versehentliche Token-Offenlegung, falls Ihr Code jemals freigegeben oder versionskontrolliert wird.

Schritt 4 — Bot als Hintergrunddienst ausführen

Um den Bot persistent nach dem Schließen Ihrer SSH-Sitzung auszuführen, richten Sie ihn als systemd-Dienst ein:

sudo nano /etc/systemd/system/ipblacklist-bot.service

Fügen Sie die folgende Konfiguration ein:

[Unit]
Description=IPv4 Blacklist Monitor Telegram Bot
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root
ExecStart=/usr/bin/python3 /root/my_bot.py
Restart=on-failure
RestartSec=10
Environment="TELEGRAM_BOT_TOKEN=YOUR_BOT_TOKEN_HERE"

[Install]
WantedBy=multi-user.target

Aktivieren und starten Sie den Dienst:

sudo systemctl daemon-reload
sudo systemctl enable ipblacklist-bot
sudo systemctl start ipblacklist-bot

# Verify it is running
sudo systemctl status ipblacklist-bot

Ihr Bot wird nun automatisch neu gestartet, wenn er abstürzt, und startet bei jedem Server-Neustart.

Schritt 5 — Bot testen

1. Öffnen Sie Telegram und suchen Sie nach Ihrem Bot anhand seines Benutzernamens
2. Senden Sie /start — Sie sollten die Willkommensnachricht erhalten
3. Senden Sie eine beliebige IPv4-Adresse (z. B. 8.8.8.8)
4. Innerhalb von 15–20 Sekunden erhalten Sie eine formatierte Liste, die zeigt, auf welchen Blacklists die IP aufgeführt ist (❌) und welche sie bestanden hat (✅)

Code-Architektur-Übersicht

Sicherheits- und Compliance-Überlegungen

Das Ausführen eines Bots, der von einem VPS aus mit externen Diensten interagiert, ist mit Verantwortung verbunden:

• Schützen Sie Ihr Bot-Token — behandeln Sie es wie ein Passwort. Rotieren Sie es sofort über BotFather, falls es kompromittiert wurde.
• Validieren Sie Benutzereingaben — fügen Sie eine IP-Adressformat-Validierung hinzu, bevor Sie Benutzereingaben an Selenium übergeben, um unerwartetes Verhalten zu verhindern.
• Rate Limiting — erwägen Sie, pro-Benutzer-Rate-Limits hinzuzufügen, um Missbrauch Ihres Bots und der Ressourcen Ihres Servers zu verhindern.
• Halten Sie Abhängigkeiten aktuell — aktualisieren Sie regelmäßig aiogram, selenium und Chrome, um Sicherheitslücken zu beheben.
• Firewall Ihren VPS — beschränken Sie eingehende Ports auf das Notwendigste (SSH und die ausgehenden Verbindungen Ihres Bots).

Falls Ihre Infrastruktur auch E-Mail verarbeitet, ist die Kopplung dieses Bots mit einer ordnungsgemäß gesicherten Mail-Umgebung unerlässlich. AlexHost Email Hosting bietet eine verwaltete, Spam-Policy-konforme Umgebung, die das Risiko verringert, dass Ihre Sende-IPs von Anfang an auf Blacklisten erscheinen.

Für Projekte, die eine SSL-gesicherte Domain neben Ihrer Bot-Infrastruktur benötigen, machen AlexHost SSL-Zertifikate und Domain-Registrierung es einfach, eine vollständig vertrauenswürdige Web-Präsenz zu etablieren.

AlexHost's Spam and Blacklist Policy

AlexHost setzt eine strikte No-Spam-Richtlinie in seinem gesamten Netzwerk durch. Jede Aktivität, die zu einer IP-Blacklistung führt — einschließlich Massen-Unaufgeforderte E-Mails, Forum-Spam oder Missbrauch, der von Spamhaus, SpamCop, StopForumSpam, Blocklist.de oder ähnlichen Datenbanken gekennzeichnet wird — ist strengstens verboten. Dienste, die gegen diese Richtlinie verstoßen, werden umgehend ausgesetzt, um die Integrität der gemeinsamen Netzwerkinfrastruktur und den Ruf aller Kunden zu schützen.

Dies macht proaktive Überwachung mit einem Tool wie dem in diesem Leitfaden beschriebenen Bot nicht nur nützlich, sondern unverzichtbar für einen verantwortungsvollen Serverbetrieb.

Erweiterung des Bots — Ideen für zukünftige Entwicklung

Sobald Ihr grundlegender Bot läuft, sollten Sie diese Verbesserungen in Betracht ziehen:

• Geplante Überwachung — verwenden Sie apscheduler, um Ihre Server-IPs automatisch alle 6 oder 24 Stunden zu überprüfen und Sie nur zu benachrichtigen, wenn ein neuer Eintrag erkannt wird
• Mehrfach-IP-Batch-Checks — akzeptieren Sie eine kommagetrennte Liste von IPs in einer einzelnen Nachricht
• Persistente Protokollierung — speichern Sie Prüfergebnisse in einer SQLite- oder PostgreSQL-Datenbank für historische Trendanalysen
• Webhook-Modus — wechseln Sie von Long Polling zu Webhooks für niedrigere Latenz und reduzierte Serverauslastung
• Zusätzliche Datenquellen — integrieren Sie APIs von AbuseIPDB oder Spamhaus direkt für zuverlässigere Ergebnisse ohne Browser-Automatisierung

Fazit

Das Erstellen eines Telegram-Bots zur Überwachung von IPv4-Blacklisten ist ein praktisches, hochwertiges Automatisierungsprojekt, das jeder Systemadministrator oder Entwickler an einem Nachmittag abschließen kann. Mit Python, aiogram und Selenium auf einem AlexHost VPS erhalten Sie ein persistentes, reaktionsschnelles Überwachungstool, das Ergebnisse direkt an Ihren Telegram-Client liefert – keine Dashboards zum Überprüfen, keine manuellen Abfragen erforderlich.

Proaktives IP-Reputationsmanagement schützt Ihre E-Mail-Zustellbarkeit, das Vertrauen Ihrer Kunden und die Verfügbarkeit Ihres Dienstes. Stellen Sie diesen Bot heute bereit, halten Sie Ihre Abhängigkeiten aktualisiert und erweitern Sie ihn im Laufe der Zeit, wenn Ihre Überwachungsanforderungen wachsen.