IP-DB.com
Türkçe English Deutsch Español
Anmelden API-Schlüssel holen
Integrationen https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY API-Schlüssel
Integrationen

IP-Blocklist-Integrationen für Firewalls und SIEM

IP-DB ist eine einfache REST-API mit Schlüssel-Authentifizierung und funktioniert mit allem, was HTTP spricht: Live-Blockliste für die Firewall, Anreicherung für das SIEM, automatische Meldungen vom Server.

Feed-Adressen39.238stündlicher Snapshot
Kategorien12
Plattformen29Copy-paste-Anleitungen
Formate4plain · cidr · json · csv

Blocklist-Feed

Eine Live-Blockliste mit einer IP pro Zeile, die Ihre Firewall regelmäßig von einer URL abruft. Der Feed enthält die höchstbewerteten Adressen aus redistributierbaren Quellen, die von mindestens zwei unabhängigen Quellfamilien bestätigt wurden — ohne Rauschen und ohne unlizenzierte Daten. Erstellen Sie unten Ihre Feed-URL.

https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY

Kostenlos5.000 Adressen / Abruf
Verifiziert50.000 Adressen / Abruf
Mehrkostenlos auf Anfrage

Der Feed nutzt Ihren API-Schlüssel (Schlüssel erstellen) und zählt zu Ihrer täglichen Nutzung; jeder Abruf liefert den aktuellen Snapshot. Für den vollständigen Bulk-Download nutzen Sie /datasets (CSV, JSON, TXT, MMDB · CC BY-SA 4.0).

WordPress-Plugin

Ein fertiges Plugin für WordPress. Es spiegelt die IP-DB-Blockliste in Ihre Site, prüft die Adresse hinter Login-, Kommentar-, Registrierungs- und Checkout-Anfragen und meldet Angreifer zurück an den Pool. Außer dem API-Schlüssel gibt es nichts zu konfigurieren.

IP-DB Threat Protection WordPress 5.8+ · PHP 7.4+ · WooCommerce und Multisite
Plugin herunterladen (.zip) Kostenloser API-Schlüssel
Version
1.1.1
Größe
104 KB
Lizenz
GPL-2.0+
Updates
ip-db.com

SHA-256439fa9136209d5ed500e682da8222bbfa62c09245eed452fff48a177177af495

example.com/wp-admin/admin.php?page=ipdb
Das Dashboard des Plugins. Die Zahlen sind Beispielwerte.

Was es tut

Die Login-Seite

Verweigert listeten Adressen die Login-Seite und zählt fehlgeschlagene Anmeldungen pro Adresse.

Kommentare und Pingbacks

Markiert, hält zurück oder verweigert Kommentare und Pingbacks — ganz wie Sie wollen.

Eigene Schalter

Eigene Schalter für Registrierung, WooCommerce-Checkout, unauthentifizierte REST-Aufrufe und XML-RPC.

Dashboard und Protokoll

Ein Dashboard für Blockiertes, Zurückgehaltenes und Gemeldetes, dazu ein filterbares Aktivitätsprotokoll als CSV-Export.

Reverse-Proxys

Explizite Reverse-Proxy-Behandlung: Cloudflare, X-Forwarded-For und eine Liste vertrauter Proxys — denn was ein Client senden kann, kann er auch fälschen.

Im laufenden Betrieb

WP-CLI-Befehle, Website-Zustand-Prüfungen, übersetzte Oberfläche und Selbst-Update — Updates erscheinen wie gewohnt im Plugins-Bildschirm.

Wie es entscheidet

Zwei Entscheidungsquellen, bewusst getrennt.

heißer Pfad

Die gespiegelte Blockliste

Eine indizierte Abfrage. Sie kann auf dem heißen Pfad laufen — auf Wunsch bei jedem anonymen Seitenaufruf — und verbraucht nichts von Ihrem Kontingent.

verbraucht Kontingent

Ein Live-Lookup

Nur bei Anfragen, die einen Aufruf wert sind: Login, Kommentar, Registrierung, Checkout.

Es ist so gebaut, dass man es ohne Risiko einschalten kann. Der Monitor-Modus protokolliert jede Entscheidung, ohne zu blocken, sodass Sie einen Tag echten Verkehr lesen können, bevor Sie einem Schwellenwert vertrauen. Die Adresse, von der aus Sie aktivieren, landet auf der Allow-Liste, Administratoren sind ohnehin ausgenommen, und ein unbeantworteter Lookup lässt die Anfrage durch — das Plugin fällt nie geschlossen aus.

Installation

  1. Plugin herunterladen, über Plugins → Installieren → Plugin hochladen installieren und aktivieren.
  2. Ihren kostenlosen API-Schlüssel unter IP-DB → Einstellungen einfügen.
  3. Im Dashboard Blockliste jetzt synchronisieren drücken — danach übernimmt WP-Cron.
  4. Einen Tag im Monitor-Modus laufen lassen, das Protokoll lesen, dann auf Blocken umstellen.
  5. Wer etwas zurückgeben möchte, aktiviert das Melden im Reiter Meldungen.

Die Synchronisierung läuft über WP-Cron; auf einer ruhigen Site ist ein echter Cron-Eintrag auf wp-cron.php zuverlässiger. Wird die Liste alt, meldet das Plugin es im Website-Zustand — dort, wo Sie ohnehin nach Problemen sehen.

Mit aktiviertem Melden fließen die Brute-Force-Versuche und der Kommentar-Spam, den Ihre Site abfängt, zurück in den Pool — auch Kommentare, die ein Moderator selbst als Spam markiert, das zuverlässigste Signal einer Site. Meldungen zählen nicht gegen Ihr Lookup-Kontingent.

Sobald das Plugin seinen ersten Aufruf mit Ihrem Schlüssel macht, erscheint Ihre Website in Ihrem Dashboard unter Meine Schilde — mit der Markierung WordPress, Version, letzter Meldung und Aufrufzahl. Solange sie meldet, bleibt Ihr Konto auf der Beitragenden-Stufe.

WP-CLI
wp ipdb status wp ipdb sync wp ipdb check 185.220.101.45 wp ipdb report 203.0.113.9 --categories=brute_force --comment="20 failed logins" wp ipdb flush --blocklist

Updates kommen von ip-db.com: Das Plugin nutzt den Update URI-Header aus WordPress 5.8, deshalb erscheint eine neue Version wie bei jedem Verzeichnis-Plugin im Plugins-Bildschirm.

fail2ban

Lassen Sie fail2ban dieselbe IP automatisch auch an IP-DB melden, sobald sie gesperrt wird. Erstellen Sie /etc/fail2ban/action.d/ipdb-report.conf:

[Definition] actionban = curl -s -X POST https://ip-db.com/api/v1/report \ -H "Key: YOUR_API_KEY" -H "Content-Type: application/json" \ -d '{"ip":"<ip>","categories":["brute_force"],"comment":"fail2ban jail: <name>"}' actionunban =

Dann in der jail.local-Definition des jeweiligen Jails ergänzen, z. B. für sshd:

[sshd] enabled = true action = %(action_)s ipdb-report

Palo Alto Networks

Binden Sie unseren Pool direkt als External Dynamic List (EDL) in PAN-OS ein — kein separates Sync-Skript nötig, die Firewall zieht die Liste selbst periodisch.

  1. Objects → External Dynamic Lists → Add
  2. Type: IP List
  3. Source URL: https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY
  4. Repeat: Hourly (der Pool wird alle 30 Minuten aktualisiert)
  5. Die EDL im Quell-/Zielfeld einer Security-Policy-Regel verwenden

Um auf eine bestimmte Kategorie zu beschränken, &category=tor_exit anhängen (gültige Werte siehe API-Dokumentation).

Schritt für Schritt: Zertifikatsprofil, Service Route, Policy-Reihenfolge und Prüfung→

Fortinet FortiGate

Der Threat Feed-Konnektor von FortiGate konsumiert dieselbe Klartext-URL.

GUI: Security Fabric → External Connectors → Create New → Threat Feed → IP Address. Oder per CLI:

config system external-resource edit "ipdb-blacklist" set type address set resource "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" set refresh-rate 30 next end

Verwenden Sie diese external-resource anschließend als Quelladresse einer Firewall-Policy mit Deny-Aktion.

Schritt für Schritt: Policy-Design, Prüfbefehle und Fehlersuche→

iptables / ipset (generisches Linux)

Paginieren Sie /api/v1/blacklist, um den gesamten Pool in ein ipset zu laden, und blockieren Sie ihn dann mit einer einzigen iptables-Regel. Alle 30 Minuten per Cron ausführen genügt — der Pool wird ohnehin in diesem Takt aktualisiert.

sync_blacklist.py
#!/usr/bin/env python3 import subprocess, requests API_KEY = "YOUR_API_KEY" BASE = "https://ip-db.com/api/v1/blacklist" subprocess.run(["ipset", "create", "ipdb-blacklist", "hash:net", "-exist"]) page = 1 while True: r = requests.get(BASE, params={"page": page, "limit": 1000}, headers={"Key": API_KEY}) r.raise_for_status() payload = r.json() for entry in payload["data"]: subprocess.run(["ipset", "add", "ipdb-blacklist", entry["cidr"], "-exist"]) if page * payload["limit"] >= payload["total"]: break page += 1
crontab
*/30 * * * * /usr/bin/python3 /opt/scripts/sync_blacklist.py >> /var/log/ipdb-sync.log 2>&1

Einmalig die Regel hinzufügen, die das ipset tatsächlich durchsetzt:

iptables -I INPUT -m set --match-set ipdb-blacklist src -j DROP

Cisco Secure Firewall (FTD / FMC)

Cisco Secure Firewall (FTD) verarbeitet einen URL-Feed über FMC nativ — kein Skript nötig. Als Security-Intelligence-Netzwerkliste anlegen und im Reiter Security Intelligence der Access-Control-Policy blocken.

# FMC: Objects → Object Management → Security Intelligence # → Network Lists and Feeds → Add Network Feed Name: ipdb-blacklist Feed URL: https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY Update Frequency: 30 minutes # Access Control Policy → Security Intelligence → Networks # ipdb-blacklist -> Block list

Check Point

Check Point ab R80.20 zieht eine externe Indikatorquelle als Custom Intelligence Feed. Unser Feed enthält einen Wert pro Zeile, die Wertspalte ist also 1.

# Security Gateway CLI (R80.20+) ioc_feeds add \ --feed_name ipdb \ --transport "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ --format CSV --value_column 1 --feed_action Prevent ioc_feeds show # SmartConsole: Threat Prevention → Custom Policy → Threat Indicators

Juniper SRX

SRX kann eine externe Liste in eine dynamische Adressgruppe einspeisen. Feed-Server definieren und die Adressgruppe als Quelle in einer Security-Policy verwenden.

set security dynamic-address feed-server ipdb url "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" set security dynamic-address feed-server ipdb update-interval 1800 set security dynamic-address feed-server ipdb feed-name blocklist path "/" set security dynamic-address address-name ipdb-blocklist profile feed-name blocklist set security policies from-zone untrust to-zone trust policy block-ipdb \ match source-address ipdb-blocklist destination-address any application any set security policies from-zone untrust to-zone trust policy block-ipdb then deny

pfSense / pfBlockerNG

pfBlockerNG akzeptiert URL-basierte IPv4-Listen direkt: <span class="mono">Firewall → pfBlockerNG → IPv4 → Add</span>, mit der Feed-URL als Quelle.

Format: Auto Source: https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY Header/Label: ipdb_blacklist Update Frequency: Every 1 hour List Action: Deny Both

OPNsense

Legen Sie in OPNsense ein Alias vom Typ URL Table an; die Firewall aktualisiert die Liste selbstständig.

# Firewall → Aliases → Add Type: URL Table (IPs) Content: https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY Refresh: 1 # gun / day / Tag / dia # Firewall → Rules → WAN: Source = ipdb_blacklist, Action = Block

MikroTik RouterOS

Nutzen Sie auf RouterOS ein Skript, das die Liste in eine address-list lädt, und verwerfen Sie diese mit einer einzigen Firewall-Regel.

# RouterOS 7.x /tool fetch url="https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ mode=https dst-path=ipdb.rsc /ip firewall address-list remove [find list=ipdb] :foreach line in=[:toarray [/file get ipdb.rsc contents]] do={ /ip firewall address-list add list=ipdb address=$line } /ip firewall filter add chain=forward src-address-list=ipdb action=drop \ comment="ip-db.com blocklist"

nftables

Auf modernen Distributionen mit nftables ist ein benanntes Set das direkte Gegenstück zu einem ipset.

nft add table inet filter nft add set inet filter ipdb '{ type ipv4_addr; flags interval; }' nft add rule inet filter input ip saddr @ipdb drop # cron: her 30 dakikada bir / every 30 minutes curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | grep -E '^[0-9]' | paste -sd, - \ | xargs -I{} nft flush set inet filter ipdb \; add element inet filter ipdb { {} }

Windows Firewall

Erstellen Sie unter Windows Server per PowerShell eine Regel und aktualisieren Sie deren Remote-Adressliste. Nutzen Sie einen Kategoriefilter — eine Regel fasst nur begrenzt viele Adressen.

# PowerShell $ips = (Invoke-RestMethod "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2") ` -split "`n" | Where-Object { $_ -match '^\d' } if (Get-NetFirewallRule -Name ipdb-block -ErrorAction SilentlyContinue) { Set-NetFirewallRule -Name ipdb-block -RemoteAddress $ips } else { New-NetFirewallRule -Name ipdb-block -DisplayName "ip-db.com blocklist" ` -Direction Inbound -Action Block -RemoteAddress $ips }

Wazuh

Da Wazuh keine Firewall ist, funktioniert die Logik hier umgekehrt: Statt dass eine Firewall Daten von uns abruft, meldet Wazuh selbst bei einem Alarm an uns. Nutzen Sie den benutzerdefinierten Integrationsmechanismus von Wazuh — die folgende Grundstruktur sollte an Ihre Umgebung angepasst werden.

ossec.conf
<integration> <name>custom-ipdb-report</name> <hook_url>https://ip-db.com/api/v1/report</hook_url> <api_key>YOUR_API_KEY</api_key> <rule_id>5712,5720,5760</rule_id> <alert_format>json</alert_format> </integration>
/var/ossec/integrations/custom-ipdb-report.py
#!/usr/bin/env python3 import sys, json, requests alert_file, api_key = sys.argv[1], sys.argv[2] alert = json.load(open(alert_file)) src_ip = alert.get("data", {}).get("srcip") if src_ip: requests.post("https://ip-db.com/api/v1/report", headers={"Key": api_key}, json={ "ip": src_ip, "categories": ["brute_force"], "comment": f"Wazuh rule {alert['rule']['id']}: {alert['rule']['description']}", }, timeout=5)

Ersetzen Sie die rule_id-Liste durch die tatsächlichen Brute-Force-/Angriffs-Regel-IDs Ihrer Umgebung; das Skript ausführbar machen nicht vergessen (chmod +x).

Schritt für Schritt: CDB-Liste, Match-Regel und Active Response→

Splunk

Laden Sie den Feed in ein KV-Store-Lookup und gleichen Sie zur Suchzeit ab, sodass jedes Ereignis mit einer Quell-IP aus dem Pool markiert wird.

# $SPLUNK_HOME/etc/apps/ipdb/bin/sync.sh — cron, 30 dk / 30 min curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | awk 'BEGIN{print "cidr"} /^[0-9]/{print}' \ > $SPLUNK_HOME/etc/apps/ipdb/lookups/ipdb_blacklist.csv # SPL — kaynak IP havuzda mi? / is the source IP in the pool? index=firewall | lookup ipdb_blacklist cidr AS src_ip OUTPUT cidr AS ipdb_match | where isnotnull(ipdb_match) | stats count by src_ip, dest_port

Elastic Security

Für die Indicator-Match-Regel von Elastic Security schreiben Sie den Feed in einen Threat-Indicator-Index.

# gostergeleri indekse yaz / write indicators into the index curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ | grep -E '^[0-9]' | sed 's|/32$||' \ | while read ip; do echo '{"index":{}}' echo "{\"@timestamp\":\"$(date -u +%FT%TZ)\",\"threat\":{\"indicator\":{\"type\":\"ipv4-addr\",\"ip\":\"$ip\",\"provider\":\"ip-db.com\"}}}" done | curl -s -XPOST "$ES/logs-ti_ipdb-default/_bulk" -H 'Content-Type: application/x-ndjson' --data-binary @- # Security → Rules → Create → Indicator Match # Index: logs-ti_ipdb-* | Field: threat.indicator.ip ↔ source.ip

Microsoft Sentinel

In Microsoft Sentinel ist eine Watchlist der praktikable Weg, gegen die Analytics-Regeln joinen.

# Watchlist olarak yukle / upload as a watchlist curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ | awk 'BEGIN{print "IPAddress"} /^[0-9]/{sub("/32","");print}' > ipdb.csv # Sentinel → Watchlist → New → alias: ipdb, search key: IPAddress // KQL let ipdb = _GetWatchlist('ipdb') | project IPAddress; CommonSecurityLog | where SourceIP in (ipdb) | summarize count() by SourceIP, DestinationPort

IBM QRadar

Legen Sie in QRadar ein Reference Set an, befüllen Sie es über die API und prüfen Sie in Ihren Regeln dagegen.

# referans kumesi olustur / create the reference set curl -s -X POST -H "SEC: $QRADAR_TOKEN" \ "https://$QRADAR/api/reference_data/sets?name=ipdb_blacklist&element_type=IP" # toplu doldur / bulk load curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | grep -E '^[0-9]' | sed 's|/32$||' | jq -Rn '[inputs]' \ | curl -s -X POST -H "SEC: $QRADAR_TOKEN" -H "Content-Type: application/json" \ "https://$QRADAR/api/reference_data/sets/bulk_load/ipdb_blacklist" --data-binary @- # Rule: when the source IP is contained in any of ipdb_blacklist

Graylog

Definieren Sie in Graylog eine Lookup-Tabelle mit dem CSV-Dateiadapter und fragen Sie darin die Quell-IP in Ihrer Pipeline ab.

# /etc/graylog/server/ipdb.csv — cron ile yenile / refresh by cron curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | awk 'BEGIN{print "ip,listed"} /^[0-9]/{sub("/32","");print $0",true"}' \ > /etc/graylog/server/ipdb.csv # System → Lookup Tables: Data Adapter = CSV File, Cache = In-Memory # Pipeline rule: rule "ipdb lookup" when has_field("src_ip") then set_field("ipdb_listed", lookup_value("ipdb", to_string($message.src_ip))); end

SIEM /Automatisierungsplattformen

Es gibt kein offizielles Plugin — das brauchen Sie auch nicht. Die API ist reines JSON über REST mit einem Key-Header, daher funktioniert sie direkt mit dem generischen „HTTP-Request"/„Webhook"-Schritt in Zapier, Make, n8n, Splunk (per HEC-Skript) oder jedem SOAR-Playbook. Authentifizierung: benutzerdefinierter Header Key: YOUR_API_KEY.

Suricata

Suricata ab Version 6 kann Datasets direkt in einer Regel abgleichen.

# /var/lib/suricata/ipdb.list curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | grep -E '^[0-9]' | sed 's|/32$||' > /var/lib/suricata/ipdb.list # local.rules alert ip [!$HOME_NET] any -> $HOME_NET any (msg:"ip-db.com listed source"; \ dataset:isset,ipdb,type string,load ipdb.list; sid:9000001; rev:1;)

Snort

Der Reputation-Präprozessor von Snort 2.9 liest eine einfache IP-Listendatei.

# snort.conf preprocessor reputation: \ blacklist /etc/snort/rules/ipdb.blacklist, \ memcap 1000, \ nested_ip both # cron curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | grep -E '^[0-9]' > /etc/snort/rules/ipdb.blacklist

Zeek

Das Intel-Framework von Zeek erwartet eine tabulatorgetrennte Indikatordatei.

# /opt/zeek/share/zeek/site/intel/ipdb.dat (sekmeyle ayrilmis / tab separated) curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ | grep -E '^[0-9]' | sed 's|/32$||' \ | awk 'BEGIN{OFS="\t"; print "#fields","indicator","indicator_type","meta.source"} {print $1,"Intel::ADDR","ip-db.com"}' > intel/ipdb.dat # local.zeek @load frameworks/intel/seen redef Intel::read_files += { "/opt/zeek/share/zeek/site/intel/ipdb.dat" };

CrowdSec

Fügen Sie den Pool CrowdSec als eigene Blocklist hinzu; Ihre vorhandenen Bouncer setzen die Entscheidungen durch.

curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ | grep -E '^[0-9]' | sed 's|/32$||' \ | while read ip; do cscli decisions add --ip "$ip" --duration 24h \ --reason "ip-db.com blocklist"; done cscli decisions list --scope Ip | head

Nginx

Das geo-Modul von Nginx kann eine generierte Map-Datei direkt einbinden.

# /etc/nginx/conf.d/ipdb.map olustur / generate curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | awk '/^[0-9]/{print $1" 1;"}' > /etc/nginx/conf.d/ipdb.map # nginx.conf (http blogu / http block) geo $ipdb_blocked { default 0; include /etc/nginx/conf.d/ipdb.map; } server { if ($ipdb_blocked) { return 403; } }

Apache

Lesen Sie unter Apache 2.4 eine generierte Datei per RewriteMap und weisen Sie passende Anfragen ab.

curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | awk '/^[0-9]/{sub("/32","");print $1" deny"}' > /etc/apache2/ipdb.txt # httpd.conf RewriteEngine On RewriteMap ipdb "txt:/etc/apache2/ipdb.txt" RewriteCond ${ipdb:%{REMOTE_ADDR}|ok} =deny RewriteRule ^ - [F,L]

HAProxy

HAProxy liest eine ACL direkt aus einer Datei und kann sie über die Runtime-API auch ohne Reload aktualisieren.

curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY" \ | grep -E '^[0-9]' > /etc/haproxy/ipdb.lst # haproxy.cfg frontend web bind :443 ssl crt /etc/ssl/site.pem acl ipdb_blocked src -f /etc/haproxy/ipdb.lst http-request deny deny_status 403 if ipdb_blocked # yeniden yuklemeden guncelle / update without a reload echo "add map #0 <ip> 1" | socat stdio /var/run/haproxy.sock

Cloudflare

Legen Sie in Cloudflare eine IP-Liste an und referenzieren Sie sie in einer WAF-Regel. Die Listengröße ist tarifabhängig begrenzt — nutzen Sie einen Kategoriefilter.

# Rules → Lists → Create (kind: ip) curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ | grep -E '^[0-9]' | jq -Rn '[inputs | {ip: .}]' \ | curl -s -X PUT -H "Authorization: Bearer $CF_TOKEN" -H "Content-Type: application/json" \ "https://api.cloudflare.com/client/v4/accounts/$CF_ACCOUNT/rules/lists/$LIST_ID/items" \ --data-binary @- # WAF custom rule: (ip.src in $ipdb) → Block

AWS WAF

AWS-WAF-IP-Sets akzeptieren CIDRs. Es gibt ein Eintragslimit pro Set — grenzen Sie mit einer Kategorie ein.

ADDRS=$(curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=botnet_c2" \ | grep -E '^[0-9]' | jq -Rn '[inputs]') LOCK=$(aws wafv2 get-ip-set --name ipdb --scope REGIONAL --id $IPSET_ID \ --query LockToken --output text) aws wafv2 update-ip-set --name ipdb --scope REGIONAL --id $IPSET_ID \ --lock-token $LOCK --addresses "$ADDRS"

Postfix

Postfix kann eine CIDR-Tabelle als Client-Restriktion lesen und Verbindungen zu Ihrem Mailserver an der Quelle abweisen.

curl -fsS "https://ip-db.com/api/v1/feed.txt?key=YOUR_API_KEY&category=mail_abuse" \ | awk '/^[0-9]/{print $1"\tREJECT ip-db.com listed"}' > /etc/postfix/ipdb.cidr # main.cf smtpd_client_restrictions = check_client_access cidr:/etc/postfix/ipdb.cidr, permit_mynetworks, reject_unknown_client_hostname postfix reload

Minimaler Python-Client

import requests class IpDbClient: def __init__(self, api_key): self.session = requests.Session() self.session.headers["Key"] = api_key def check(self, ip): r = self.session.get(f"https://ip-db.com/api/v1/check/{ip}") r.raise_for_status() return r.json() def report(self, ip, categories, comment=None): r = self.session.post("https://ip-db.com/api/v1/report", json={"ip": ip, "categories": categories, "comment": comment}) r.raise_for_status() return r.json() client = IpDbClient("YOUR_API_KEY") print(client.check("185.220.101.45")["abuseConfidenceScore"])

API →