Blocklisten – Integrationsleitfaden

Jede Liste gibt es in drei Varianten; <id> durch die ID aus der Tabelle ersetzen:

• IPv4 und IPv6: https://ipv64.net/blocklists/ipv64_blocklist_<id>.txt
• nur IPv4: https://ipv64.net/blocklists/ipv64_blocklist_v4_<id>.txt
• nur IPv6: https://ipv64.net/blocklists/ipv64_blocklist_v6_<id>.txt
• MikroTik RouterOS: https://ipv64.net/blocklists/v64_mikrotik_v4_<id>.rsc und …_v6_<id>.rsc

Format: eine Adresse oder ein Netz (CIDR) je Zeile, ohne Kommentare. Die Listen werden mehrmals täglich neu erzeugt. Bitte höchstens alle 30 Minuten abrufen; alle 1 bis 6 Stunden reicht. Länder- und Kontinentlisten stehen auf der Listenseite. Für Skripte: index.json nennt jede Liste mit Anzahl, Stand, Quelle, Lizenz und Dateinamen.

https://ipv64.net/blocklists/live/<token>/ipv64_blocklist_v4_v64.txt

Für aktuelle Debian-, Ubuntu-, Fedora- und Proxmox-Systeme und die meisten Linux-Router. Das Skript lädt IPv4 und IPv6 in eine eigene Tabelle inet ipv64 und tauscht sie in einem Schritt aus. Deine übrigen Regeln bleiben unberührt. Schlägt ein Download fehl, bleibt die alte Liste aktiv. Auch Verkehr, der an Docker-Container oder per NAT weitergeleitet wird, wird gefiltert.

Einrichten (als root):

apt install -y nftables curl
curl -fsSo /usr/local/sbin/ipv64-blocklist-nft.sh https://ipv64.net/blocklists/tools/ipv64-blocklist-nft.sh
chmod +x /usr/local/sbin/ipv64-blocklist-nft.sh
/usr/local/sbin/ipv64-blocklist-nft.sh firehole_l1

Alle 4 Stunden und nach einem Neustart aktualisieren (cron):

cat > /etc/cron.d/ipv64-blocklist <<'EOF'
17 */4 * * * root /usr/local/sbin/ipv64-blocklist-nft.sh firehole_l1 >/dev/null
@reboot      root sleep 30 && /usr/local/sbin/ipv64-blocklist-nft.sh firehole_l1 >/dev/null
EOF

Prüfen und entfernen:

nft list chain inet ipv64 input     # counters show dropped packets
nft delete table inet ipv64          # remove the blocklist completely

#!/bin/sh
# IPv64.net blocklist for nftables (IPv4 + IPv6) - https://ipv64.net/v64_blocklist_integration_guide
# Usage: ipv64-blocklist-nft.sh [list]   (default: firehole_l1, see https://ipv64.net/v64_blocklists)
# Run as root. Replaces table "inet ipv64" atomically; on a failed download the old sets stay active.
set -eu
LIST="${1:-firehole_l1}"
BASE="https://ipv64.net/blocklists"
TMP="$(mktemp -d)"
trap 'rm -rf "$TMP"' EXIT

for v in 4 6; do
	curl -fsS --max-time 120 -o "$TMP/raw$v" "$BASE/ipv64_blocklist_v${v}_${LIST}.txt"
	# only keep lines that look like an address or network
	grep -E '^[0-9A-Fa-f:.]+(/[0-9]{1,3})?$' "$TMP/raw$v" > "$TMP/v$v" || true
done
if [ ! -s "$TMP/v4" ] && [ ! -s "$TMP/v6" ]; then
	echo "ipv64-blocklist: download empty, keeping the active sets" >&2
	exit 1
fi

elements() { # file -> "elements = { a, b, ... }" (nothing for an empty file)
	[ -s "$1" ] || return 0
	printf '\t\telements = { '
	paste -sd, "$1" | sed 's/,/, /g'
	printf ' }\n'
}

{
	echo "table inet ipv64"
	echo "delete table inet ipv64"
	echo "table inet ipv64 {"
	printf '\tset bl4 {\n\t\ttype ipv4_addr\n\t\tflags interval\n\t\tauto-merge\n'
	elements "$TMP/v4"
	printf '\t}\n\tset bl6 {\n\t\ttype ipv6_addr\n\t\tflags interval\n\t\tauto-merge\n'
	elements "$TMP/v6"
	printf '\t}\n'
	# drop traffic FROM listed networks to this host and to forwarded/NATed hosts (routers, Docker)
	printf '\tchain input {\n\t\ttype filter hook input priority -10; policy accept;\n\t\tip saddr @bl4 counter drop\n\t\tip6 saddr @bl6 counter drop\n\t}\n'
	printf '\tchain forward {\n\t\ttype filter hook forward priority -10; policy accept;\n\t\tip saddr @bl4 counter drop\n\t\tip6 saddr @bl6 counter drop\n\t}\n'
	echo "}"
} > "$TMP/ipv64.nft"

nft -f "$TMP/ipv64.nft"
echo "ipv64-blocklist: $LIST loaded ($(wc -l < "$TMP/v4") IPv4, $(wc -l < "$TMP/v6") IPv6 entries)"

Für Systeme, die noch iptables nutzen. Das Skript füllt je ein Set für IPv4 und IPv6 per ipset restore, tauscht es ein und legt die DROP-Regeln nur einmal an (INPUT, FORWARD und, falls vorhanden, Dockers Kette DOCKER-USER).

apt install -y ipset iptables curl
curl -fsSo /usr/local/sbin/ipv64-blocklist-ipset.sh https://ipv64.net/blocklists/tools/ipv64-blocklist-ipset.sh
chmod +x /usr/local/sbin/ipv64-blocklist-ipset.sh
/usr/local/sbin/ipv64-blocklist-ipset.sh firehole_l1
echo '17 */4 * * * root /usr/local/sbin/ipv64-blocklist-ipset.sh firehole_l1 >/dev/null' > /etc/cron.d/ipv64-blocklist
echo '@reboot root sleep 30 && /usr/local/sbin/ipv64-blocklist-ipset.sh firehole_l1 >/dev/null' >> /etc/cron.d/ipv64-blocklist

Die @reboot-Zeile stellt Sets und Regeln nach einem Neustart wieder her, ipset-persistent ist dafür nicht nötig. Docker legt seine Ketten beim Neustart des Dienstes neu an; danach das Skript einmal erneut ausführen.

#!/bin/sh
# IPv64.net blocklist for iptables + ipset (IPv4 + IPv6) - https://ipv64.net/v64_blocklist_integration_guide
# Usage: ipv64-blocklist-ipset.sh [list]   (default: firehole_l1, see https://ipv64.net/v64_blocklists)
# Run as root. Loads the list into a new set and swaps it in; on a failed download the old set stays active.
set -eu
LIST="${1:-firehole_l1}"
BASE="https://ipv64.net/blocklists"
TMP="$(mktemp -d)"
trap 'rm -rf "$TMP"' EXIT

for v in 4 6; do
	fam=inet; ipt=iptables
	[ "$v" = 6 ] && { fam=inet6; ipt=ip6tables; }
	set="ipv64-v$v"; new="ipv64-v$v-new"
	curl -fsS --max-time 120 -o "$TMP/raw" "$BASE/ipv64_blocklist_v${v}_${LIST}.txt"
	grep -E '^[0-9A-Fa-f:.]+(/[0-9]{1,3})?$' "$TMP/raw" > "$TMP/list" || true
	n=$(wc -l < "$TMP/list")
	if [ "$n" -eq 0 ] && [ "$v" = 4 ]; then
		echo "ipv64-blocklist: IPv4 download empty, keeping the active set" >&2
		exit 1
	fi
	ipset create -exist "$set" hash:net family "$fam" maxelem 1048576
	ipset destroy "$new" 2>/dev/null || true
	{ echo "create $new hash:net family $fam maxelem 1048576"; sed "s/^/add $new /" "$TMP/list"; } | ipset restore -exist
	ipset swap "$new" "$set"
	ipset destroy "$new"
	# rules only once: -C checks whether the rule exists already
	for chain in INPUT FORWARD; do
		$ipt -C "$chain" -m set --match-set "$set" src -j DROP 2>/dev/null || $ipt -I "$chain" -m set --match-set "$set" src -j DROP
	done
	# Docker publishes ports through DOCKER-USER, not INPUT
	if $ipt -nL DOCKER-USER >/dev/null 2>&1; then
		$ipt -C DOCKER-USER -m set --match-set "$set" src -j DROP 2>/dev/null || $ipt -I DOCKER-USER -m set --match-set "$set" src -j DROP
	fi
	echo "ipv64-blocklist: $set ($LIST) loaded with $n entries"
done

1. Firewall › Aliases › URLs › Add: Typ URL Table (IPs), Name z. B. IPv64_firehol, URL https://ipv64.net/blocklists/ipv64_blocklist_firehole_l1.txt, Aktualisierung 1 Tag. Speichern und Apply Changes.
2. Firewall › Rules › WAN › Add (Pfeil nach oben = ganz oben): Action Block, Address Family IPv4+IPv6, Protocol Any, Source: Single host or alias = IPv64_firehol, Destination any. Speichern und übernehmen.
3. Optional, für Spamhaus DROP empfohlen: Firewall › Rules › LAN, Block-Regel ganz oben mit Destination = Alias. So erreichen infizierte Geräte die gelisteten Netze nicht.

Große Listen (Länder) können Firewall Maximum Table Entries unter System › Advanced › Firewall & NAT überschreiten; den Wert erhöhen, wenn der Alias leer bleibt. Unter Diagnostics › Tables siehst du die geladenen Einträge. pfSense prüft URL-Tabellen einmal täglich, der Live-Stand der v64-Listen bringt hier also keinen Vorteil.

1. Firewall › Aliases › +: Typ URL Table (IPs), Name z. B. IPv64_firehol, Aktualisierung 0 Tage 4 Stunden, Inhalt https://ipv64.net/blocklists/ipv64_blocklist_firehole_l1.txt. Speichern und Apply.
2. Firewall › Rules › WAN › +: Action Block, Direction in, TCP/IP Version IPv4+IPv6, Protocol any, Source = IPv64_firehol, Destination any. Speichern, Regel ganz nach oben ziehen und übernehmen.
3. Optional auf LAN: Block-Regel mit Destination = Alias (ausgehend).

Unter Firewall › Diagnostics › Aliases siehst du die geladenen Einträge und die letzte Aktualisierung.

Diese Firewalls laden eine Textliste selbst von einer URL. Die Schritte folgen der Herstellerdoku (PAN-OS 11.1, FortiOS 7.6, Sophos Firewall 21.5). Die Beispiele nutzen die v64 Blocklist; jede andere Liste geht genauso. Für den Live-Stand die Adresse mit deinem Listen-Token eintragen. Das Aktualisierungsintervall auf 30 Minuten oder mehr stellen – FortiGate aktualisiert ab Werk alle 5 Minuten.

Palo Alto Networks (PAN-OS): External Dynamic List

1. Objects › External Dynamic Lists › Add: Name z. B. IPv64_v64, Type IP List, Source https://ipv64.net/blocklists/ipv64_blocklist_v64.txt, optional ein Certificate Profile mit der CA des ipv64.net-Zertifikats (Server-Prüfung), Check for updates Hourly. OK.
2. Policies › Security › Add: im Reiter Source die Liste als Source Address (eingehend aus der Internet-Zone), Action Deny. Die Regel über die Allow-Regeln schieben. Für ausgehenden Verkehr die Liste in einer zweiten Regel als Destination Address nutzen.
3. Commit. Import Now an der Liste lädt sie sofort.

PAN-OS nimmt IPv4- und IPv6-Adressen, Bereiche und Netze. Alle IP-Listen zusammen dürfen auf den meisten Modellen 50.000 Adressen enthalten (150.000 auf PA-3200, PA-5200 und PA-7000); siehe List Capacities unter Objects › External Dynamic Lists. Ist der Server nicht erreichbar, nutzt die Firewall die zuletzt geladene Liste.

Fortinet FortiGate (FortiOS): IP-Adress-Feed

1. Security Fabric › External Connectors › Create New, unter External Feeds (ältere Versionen: Threat Feeds) IP Address wählen: Name z. B. IPv64_v64, URL of external resource https://ipv64.net/blocklists/ipv64_blocklist_v64.txt, Refresh Rate 60 Minuten. OK.
2. Policy & Objects › Firewall Policy: Regel vom WAN-Interface mit Source = Feed (Abschnitt IP ADDRESS FEED), Action DENY, über den Allow-Regeln. Für ausgehenden Verkehr eine Regel mit dem Feed als Destination.

Dasselbe in der CLI, dazu eine Local-in-Policy, die auch die FortiGate selbst schützt (VPN, Admin-Zugang); eine freie Policy-Nummer verwenden:

config system external-resource
    edit "IPv64_v64"
        set type address
        set resource "https://ipv64.net/blocklists/ipv64_blocklist_v64.txt"
        set refresh-rate 60
        set server-identity-check full
    next
end
config firewall local-in-policy
    edit 100
        set intf "any"
        set srcaddr "IPv64_v64"
        set dstaddr "all"
        set service "ALL"
        set schedule "always"
    next
end

FortiOS nimmt IPv4- und IPv6-Adressen, Bereiche und Netze, je Zeile eine. server-identity-check prüft das Server-Zertifikat (Standard none).

Sophos Firewall: Third-party threat feeds

1. Active threat response › Third-party threat feeds › Add: Name z. B. IPv64_v64, Action Block, Indicator type IPv4 address, External URL https://ipv64.net/blocklists/ipv64_blocklist_v4_v64.txt, Authorization No authentication, Validate server certificate an, Polling interval 1 hour (oder 30 Minuten). Speichern.
2. Synchronize now lädt den Feed sofort; Treffer im Log prüfen.

Benötigt die Lizenz für Third-party threat feeds (Xstream Protection). Laut Sophos nehmen diese Feeds nur einzelne IPv4-Adressen, keine IPv6-Adressen, Bereiche oder Netze. Die Listen von ipv64.net enthalten Netze und schreiben einzelne Adressen als /32; ob Sophos diese Einträge annimmt, ist nicht getestet. XGS 87, 88 und 107 bieten als Polling interval nur 24 Stunden, 7 Tage oder 30 Tage.

ipv64.net stellt fertige Importdateien bereit. Jede Datei entfernt zuerst ihre eigenen alten Einträge und trägt dann die aktuellen in die Adressliste IPv64-<id> ein. Das folgende Skript lädt die Datei, importiert sie und läuft per Scheduler alle 6 Stunden. Im Terminal einfügen (Winbox › New Terminal):

/system script add name=ipv64-blocklist policy=read,write,test source={
  :foreach v in={"v4";"v6"} do={
    :local f ("ipv64-" . $v . ".rsc")
    /tool fetch url=("https://ipv64.net/blocklists/v64_mikrotik_" . $v . "_firehole_l1.rsc") dst-path=$f
    :delay 2s
    /import file-name=$f
    /file remove $f
  }
}
/system scheduler add name=ipv64-blocklist interval=6h start-time=startup on-event="/system script run ipv64-blocklist"
/system script run ipv64-blocklist
/ip firewall raw add chain=prerouting src-address-list=IPv64-firehole_l1 action=drop comment="IPv64 blocklist"
/ipv6 firewall raw add chain=prerouting src-address-list=IPv64-firehole_l1 action=drop comment="IPv64 blocklist"

Die raw-Regeln verwerfen den Verkehr vor dem Connection-Tracking, für Router und LAN. Hast du weitere raw-Regeln, diese nach oben schieben. Der Import großer Listen dauert einige Sekunden. /ip firewall address-list print count-only where list=IPv64-firehole_l1 zeigt die Anzahl der Einträge. Für den Live-Stand der v64 Blocklist die URL ("https://ipv64.net/blocklists/live/<token>/v64_mikrotik_" . $v . "_v64.rsc"), den Listennamen IPv64-v64 und interval=30m verwenden.

Für einen Webserver oder Reverse-Proxy ohne Zugriff auf die Firewall. Das Modul geo prüft Netze effizient, auch bei Zehntausenden Einträgen. Gesperrte Clients bekommen HTTP 403.

1. Liste als geo-Datei holen (cron, z. B. alle 4 Stunden):

curl -fsS https://ipv64.net/blocklists/ipv64_blocklist_blocklistde_all.txt \
  | awk '/^[0-9A-Fa-f:.]+(\/[0-9]+)?$/ {print $1" 1;"}' > /etc/nginx/ipv64-geo.conf.new \
  && [ -s /etc/nginx/ipv64-geo.conf.new ] && mv /etc/nginx/ipv64-geo.conf.new /etc/nginx/ipv64-geo.conf \
  && nginx -t -q && systemctl reload nginx

2. In der nginx.conf verwenden:

http {
    geo $ipv64_blocked { default 0; include /etc/nginx/ipv64-geo.conf; }
    server {
        # ...
        if ($ipv64_blocked) { return 403; }
    }
}

Hinter Cloudflare oder einem anderen Proxy zuerst real_ip_header einrichten, sonst sieht nginx die Adresse des Proxys.

Die Liste als Entscheidungen importieren; alle Bouncer (Firewall, nginx, Traefik …) setzen sie um. Die Entscheidungen laufen nach 6 Stunden ab, deshalb alle 4 Stunden per cron neu importieren:

curl -fsSo /tmp/ipv64.txt https://ipv64.net/blocklists/ipv64_blocklist_firehole_l1.txt \
  && cscli decisions import -i /tmp/ipv64.txt --format values --duration 6h --reason ipv64-blocklist

Der Node64-Container nutzt die IPv64-Blocklisten in seinem Reverse-Proxy CDN64 mit einem Klick: CDN64 › Zugriff › Blocklisten. Er aktualisiert sie alle 30 Minuten, Ausnahmen kannst du selbst festlegen. Mit dort hinterlegtem Listen-Token lädt er die v64-Listen live.

ipv64.net fasst öffentliche Listen zusammen und bereinigt sie: alles wird in Netze umgewandelt, Doppelte, enthaltene Netze und reservierte Bereiche fallen weg. Die Einträge selbst stammen aus diesen Projekten:

• Spamhaus DROP
• FireHOL Level 1
• blocklist.de
• DShield (SANS ISC)
• Tor Project
• abuse.ch Feodo Tracker (CC0)
• Emerging Threats
• CINS Army
• IPsum (Unlicense)
• DoH-IP-blocklists (GPL-3.0)
• Honeypot64 (ipv64.net, CC BY 4.0): v64 Blocklist und Teillisten
• Cloud-Netze, wie veröffentlicht von Cloudflare, AWS, Google Cloud

Ist eine deiner Adressen fälschlich gelistet, beantrage die Löschung beim jeweiligen Projekt; mit der nächsten Aktualisierung verschwindet sie auch aus den IPv64-Listen. Für die v64-Listen die Freigabe in der IP-Auskunft beantragen. Die Listen sind kostenlos nutzbar; bitte beachte die Bedingungen der Quellprojekte und verlass dich nicht allein auf sie.