Datasets Suricata d’IP et de domaines malveillants, rechargés avec les règles

Chaque liste devient un fichier de dataset, deux pour les IP. Un dataset chargé depuis un fichier lève lui-même son plafond de mémoire, sauf si datasets.defaults.memcap est fixé ; son hashsize doit rester proche du nombre d’entrées.

Nombres arrondis d’après la génération du 2026-10-01 ; chaque liste est régénérée toutes les 12 heures. Les chiffres du jour sont publics et ne demandent aucune clé.

# IsMalicious.com Blocklist - IPs (Critical)
# Format: Plain
# Generated: <BUILD_TIME>
# Total entries: <COUNT>
# Update frequency: every 12 hours
# Category: All
# Threat level: Critical
# Website: https://ismalicious.com
# © <YEAR> IsMalicious (compilation). Licensed to the downloading account under https://ismalicious.com/terms; redistribution of the compilation prohibited. Third-party entries remain under their providers' licences — see https://ismalicious.com/sources.
#

• Suricata 7.0 ou 8.0, vérifié sur 7.0.17 et 8.0.7. Les règles DNS et TLS mettent le nom en minuscules avec to_lowercase, qui demande 7.0.3 ou ultérieur.
• Un accès root à la sonde, avec curl, awk et perl.
• Une clé API et son secret isMalicious, dans Compte › Accès API.
• Un accès HTTPS sortant (TCP 443) en IPv4 depuis la sonde vers api.ismalicious.com, qui n’a pas d’adresse IPv6.

1. 1

   Copier la clé API et le secret

   Ouvrez Compte › Accès API et copiez la Clé API et le Secret API. Les listes complètes demandent une offre Basic, Pro ou Enterprise ; avec une clé Free, le script reçoit l’échantillon de 10 % et le refuse.
2. 2

   Stocker les identifiants sur la sonde

   Créez /etc/ismalicious/netrc, réservé à root, avec les commandes ci-dessous, puis écrivez-y les trois lignes avec un éditeur : tapées dans un shell, elles finiraient dans son historique. curl y lit la clé et le secret : ils n’apparaissent jamais sur une ligne de commande.

   install -d -m 700 /etc/ismalicious
   [ -e /etc/ismalicious/netrc ] || install -m 600 /dev/null /etc/ismalicious/netrc
   chmod 600 /etc/ismalicious/netrc
   # Then write the three lines below into it with an editor, unless it holds them already.

   machine api.ismalicious.com
   login <API_KEY>
   password <API_SECRET>

3. 3

   Installer le script de conversion et l’exécuter une fois

   • Enregistrez le script sous /usr/local/sbin/ismalicious-suricata.sh, en mode 700, et exécutez-le.
   • Il refuse une erreur, un contenu qui n’est pas une liste, l’échantillon de 10 % et un fichier dont le nombre d’entrées diffère de son en-tête, retire les lignes d’en-tête #, écrit les adresses IPv4 et IPv6 dans deux fichiers, car Suricata 8.0 refuse l’IPv4 dans un dataset de type ip, et le base64 de chaque domaine pour les datasets string, comme Suricata l’exige.
   • Il déplace ensuite les fichiers dans /etc/suricata/ismalicious/ ; en cas d’échec, les fichiers en service restent tels quels.

   #!/bin/sh
   # Download isMalicious lists and write Suricata dataset files. On any failure
   # the files in service stay as they are.
   set -eu
   DIR=/etc/suricata/ismalicious
   NETRC=/etc/ismalicious/netrc
   mkdir -p "$DIR"
   # Temporary directory on the same file system, so the final mv is atomic.
   T=$(mktemp -d "$DIR/.tmp.XXXXXX")
   trap 'rm -rf "$T"' EXIT
   
   # fetch_list LIST OUT: download one list to OUT and check it.
   # On any failure OUT is removed and the function returns 1.
   fetch_list() {
     if ! code=$(curl --silent --show-error --fail --netrc-file "$NETRC" \
         --proto '=https' --max-time 300 --retry 2 \
         --output "$2" --write-out '%{http_code}' "https://api.ismalicious.com/blocklist/download/$1"); then
       rm -f "$2"; echo "$1: download failed" >&2; return 1
     fi
     if [ "$code" != 200 ]; then
       rm -f "$2"; echo "$1: HTTP $code" >&2; return 1
     fi
     if ! head -n 1 "$2" | grep -q '^[#!] IsMalicious.com Blocklist'; then
       rm -f "$2"; echo "$1: not an isMalicious list" >&2; return 1
     fi
     if grep -q 'Lite Version' "$2"; then
       rm -f "$2"; echo "$1: lite list received, check the API key and the plan" >&2
       return 1
     fi
     # Every entry ends with a newline, and one header counts them: refuse a
     # cut, doubled or empty file.
     if [ -n "$(tail -c 1 "$2")" ]; then
       rm -f "$2"; echo "$1: cut short, no final newline" >&2; return 1
     fi
     if [ "$(grep -c '^[#!] Total entries:' "$2")" != 1 ]; then
       rm -f "$2"; echo "$1: not one Total entries line" >&2; return 1
     fi
     total=$(sed -n 's/^[#!] Total entries: \([0-9,]*\)$/\1/p' "$2" | tr -d ,)
     got=$(grep -c '^[^#!]' "$2" || true)
     if [ -z "$total" ] || [ "$total" = 0 ] || [ "$got" != "$total" ]; then
       rm -f "$2"; echo "$1: $got entries, the header says ${total:-none}" >&2
       return 1
     fi
   }
   
   fetch_list blocklist-ips-critical.txt       "$T/ips-critical"
   fetch_list blocklist-domains-c2.txt         "$T/domains-c2"
   fetch_list blocklist-domains-ransomware.txt "$T/domains-ransomware"
   
   # Suricata 8.0 reads every line of a type ip set as IPv6 and rejects IPv4
   # (OISF bug 9006): IPv4 goes to a type ipv4 set, IPv6 to a type ip set.
   awk '!/^[#!]/ && NF && !index($1, ":") { print $1 }' "$T/ips-critical" > "$T/ismalicious-ips4.lst"
   awk '!/^[#!]/ && NF &&  index($1, ":") { print $1 }' "$T/ips-critical" > "$T/ismalicious-ips6.lst"
   
   # Dataset type string: base64 of each domain, no trailing newline in the value.
   for l in c2 ransomware; do
     awk '!/^[#!]/ && NF { print $1 }' "$T/domains-$l" \
       | perl -MMIME::Base64 -ne 'chomp; print encode_base64($_, ""), "\n"' \
       > "$T/ismalicious-$l-domains.lst"
   done
   
   for f in ismalicious-ips4.lst ismalicious-ips6.lst \
            ismalicious-c2-domains.lst ismalicious-ransomware-domains.lst; do
     chmod 644 "$T/$f"
     mv "$T/$f" "$DIR/$f"
   done

4. 4

   Ajouter les règles

   Enregistrez les règles sous /etc/suricata/ismalicious/ismalicious.rules, à côté des fichiers de datasets : un chemin load est relatif au fichier de règles. Prenez les SID dans votre plage locale. Les règles d’IP visent le sens client vers serveur de chaque session (flow:to_server) et n’alertent qu’une fois par heure par paire d’adresses ; décommentez la paire IPv6 dès que ismalicious-ips6.lst contient des entrées. Sous Suricata 7.0.0 à 7.0.2, retirez to_lowercase;. En mode IPS, remplacez alert par drop.

   # IPv4, both directions (Suricata 7.0 and later)
   alert ip $HOME_NET any -> $EXTERNAL_NET any (msg:"isMalicious critical IP outbound"; flow:to_server; ip.dst; dataset:isset,ismalicious-ips4, type ipv4, load ismalicious-ips4.lst, hashsize 65536; threshold:type limit, track by_both, count 1, seconds 3600; classtype:bad-unknown; sid:1900001; rev:2;)
   alert ip $EXTERNAL_NET any -> $HOME_NET any (msg:"isMalicious critical IP inbound"; flow:to_server; ip.src; dataset:isset,ismalicious-ips4, type ipv4, load ismalicious-ips4.lst, hashsize 65536; threshold:type limit, track by_both, count 1, seconds 3600; classtype:bad-unknown; sid:1900002; rev:2;)
   
   # IPv6: uncomment when ismalicious-ips6.lst is not empty.
   # alert ip $HOME_NET any -> $EXTERNAL_NET any (msg:"isMalicious critical IPv6 outbound"; flow:to_server; ip.dst; dataset:isset,ismalicious-ips6, type ip, load ismalicious-ips6.lst, hashsize 4096; threshold:type limit, track by_both, count 1, seconds 3600; classtype:bad-unknown; sid:1900003; rev:1;)
   # alert ip $EXTERNAL_NET any -> $HOME_NET any (msg:"isMalicious critical IPv6 inbound"; flow:to_server; ip.src; dataset:isset,ismalicious-ips6, type ip, load ismalicious-ips6.lst, hashsize 4096; threshold:type limit, track by_both, count 1, seconds 3600; classtype:bad-unknown; sid:1900004; rev:1;)
   
   # Domains (on Suricata 7.0.0 to 7.0.2, remove "to_lowercase;")
   alert dns $HOME_NET any -> any any (msg:"isMalicious C2 domain in DNS query"; dns.query; to_lowercase; dataset:isset,ismalicious-c2-domains, type string, load ismalicious-c2-domains.lst, hashsize 32768; classtype:trojan-activity; sid:1900010; rev:1;)
   alert http $HOME_NET any -> any any (msg:"isMalicious C2 domain in HTTP Host"; flow:established,to_server; http.host; dataset:isset,ismalicious-c2-domains, type string, load ismalicious-c2-domains.lst, hashsize 32768; classtype:trojan-activity; sid:1900011; rev:1;)
   alert dns $HOME_NET any -> any any (msg:"isMalicious ransomware domain in DNS query"; dns.query; to_lowercase; dataset:isset,ismalicious-ransomware-domains, type string, load ismalicious-ransomware-domains.lst, hashsize 4096; classtype:trojan-activity; sid:1900012; rev:1;)
   alert tls $HOME_NET any -> any any (msg:"isMalicious C2 domain in TLS SNI"; flow:established,to_server; tls.sni; to_lowercase; dataset:isset,ismalicious-c2-domains, type string, load ismalicious-c2-domains.lst, hashsize 32768; classtype:trojan-activity; sid:1900013; rev:1;)

5. 5

   Ajouter le fichier de règles à suricata.yaml

   Ajoutez le fichier de règles à rule-files dans suricata.yaml, testez la configuration avec suricata -T, qui charge les règles et les datasets sans lancer la capture (avec -vvv, il affiche aussi chaque dataset chargé), puis redémarrez Suricata une fois.

   # Merge into the existing key:
   rule-files:
     - suricata.rules
     - /etc/suricata/ismalicious/ismalicious.rules

   suricata -T -c /etc/suricata/suricata.yaml
   # The datasets as loaded, at config verbosity:
   suricata -T -c /etc/suricata/suricata.yaml -vvv 2>&1 | grep 'dataset:'

6. 6

   Planifier le script et un rechargement des règles

   Lancez le script, puis un rechargement des règles, toutes les 12 heures depuis /etc/cron.d/ismalicious-suricata : les listes sont régénérées toutes les 12 heures, et un rechargement relit sur le disque les datasets définis seulement par load. cron tourne avec un PATH court, d’où la ligne PATH pour suricatasc, qui a besoin du socket unix, actif par défaut ; sans lui, envoyez plutôt kill -USR2 à Suricata.

   PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
   17 3,15 * * *  root  /usr/local/sbin/ismalicious-suricata.sh && suricatasc -c reload-rules

• suricata -T se termine sans erreur de dataset.
• suricata -T … -vvv affiche dataset: ismalicious-c2-domains loading from pour chaque dataset (le niveau par défaut de suricata.log ne l’enregistre pas), et suricatasc -c ruleset-failed-rules ne liste aucune règle isMalicious après un rechargement.
• Les deux fichiers d’IP contiennent ensemble le count de la liste dans /blocklist/stats, à une régénération près, et chaque fichier de domaines celui de sa liste.
• dataset-lookup via suricatasc trouve un domaine listé, donné en base64.
• Résoudre un domaine C2 listé depuis un hôte de $HOME_NET écrit une alerte avec le signature_id 1900010 dans eve.json.
• Les premières lignes d’un téléchargement direct montrent Total entries sans Lite Version.

# Entries per dataset file:
wc -l /etc/suricata/ismalicious/*.lst

# Rules the last reload dropped (none expected):
suricatasc -c ruleset-failed-rules

# Is a domain in the dataset? (unix socket, 7.0 and 8.0)
suricatasc -c "dataset-lookup ismalicious-c2-domains string $(printf '%s' <LISTED_DOMAIN> | base64 -w0)"

# As root (the netrc file is root-only): the key reaches isMalicious when
# Total entries has no "Lite Version".
sudo curl -sS --netrc-file /etc/ismalicious/netrc \
  https://api.ismalicious.com/blocklist/download/blocklist-ips-critical.txt | head -12

• Les datasets ne correspondent qu’à la valeur listée. La correspondance des sous-domaines demande match subdomain avec des entrées préfixées d’un point, qui existe à partir de Suricata 8.0.7 (absent en 8.0.6) ; ces fichiers contiennent des noms exacts.
• La réputation d’IP (iprep) n’est pas couverte : chaque entrée occupe une place dans la table des hôtes, dont Suricata ne documente pas la taille, et une table pleine arrête le chargement du fichier.
• Un rechargement construit un second moteur de détection avant de libérer le premier : les datasets sont un instant en mémoire deux fois.
• Aucun fichier CIDR, RPZ, CSV ou JSON n’est servi : le script construit les fichiers dont Suricata a besoin à partir des listes simples.
• Les listes d’empreintes ne sont pas couvertes : les mots-clés d’empreintes de fichiers de Suricata demandent des réglages d’inspection de fichiers que ce guide n’a pas vérifiés.
• L’échantillon de 10 % est le premier dixième d’un fichier non trié, pas le dixième le plus risqué : le script le refuse.

• SP

  Lookups de menaces pour Splunk

  Listes en lookups, threat lists ES, envoi par HEC

• ES

  Flux TAXII de menaces pour Elastic Security

  Collections TAXII 2.1 pour les règles indicator match

• WZ

  Threat intelligence pour Wazuh (listes CDB)

  IP et domaines malveillants en listes CDB pour les règles Wazuh

• QR

  Reference set QRadar d’IP malveillantes

  IP et domaines malveillants en reference sets QRadar

• Renseignement sur les menaces pour Microsoft Sentinel

  Indicateurs TAXII 2.1 dans Sentinel

• Blocklist IP et domaines

  Toutes les listes, niveaux et catégories

• Flux de menaces STIX/TAXII

  Collections TAXII 2.1 pour SIEM et TIP

• Documentation de l’API

  Authentification, endpoints et limites

• Réputation de domaine

  Vérifier un domaine avant de le bloquer