Threat intelligence pour Wazuh en listes CDB d’IP et de domaines malveillants, rafraîchies par cron

Une liste CDB est une base sur disque sans limite de taille documentée. Chaque liste ci-dessous devient une liste CDB, nommée dans sa ligne.

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.
#

• Wazuh manager 4.3 ou ultérieur, vérifié sur la documentation 4.14 (avant 4.3, l’utilisateur du service était ossec). Les listes se rechargent sans redémarrage à partir de 4.13.
• Un accès root au manager, le nœud master dans un cluster, avec curl et awk.
• Une clé API et son secret isMalicious, dans Compte › Accès API.
• Un accès HTTPS sortant (TCP 443) en IPv4 depuis le manager Wazuh 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 le manager

   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-wazuh-lists.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.
   • Wazuh ignore toute ligne sans deux-points, c’est-à-dire chaque ligne d’une liste simple : le script écrit donc chaque entrée en ligne clé:, met les clés IPv6 entre guillemets et écrit chacune deux fois, compressée et en entier, car l’EVE de Suricata écrit les adresses en entier.
   • Il écrit /var/ossec/etc/lists/ismalicious-*, propriété de wazuh:wazuh, en mode 660.
   • Une liste qui échoue à une vérification arrête l’exécution : elle et les listes suivantes gardent leur copie précédente.

   #!/bin/sh
   # Download isMalicious lists and write them as Wazuh CDB lists. A list that
   # fails a check stops the run: it and the lists after it keep their copy.
   set -eu
   LISTS=/var/ossec/etc/lists
   NETRC=/etc/ismalicious/netrc
   RAW=$(mktemp)
   NEW=
   trap 'rm -f "$RAW" $NEW' 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
   }
   
   # convert <ip|domain> FILE: one CDB key per entry. IPv6 keys are quoted and
   # written twice, compressed and in full, since Suricata's EVE writes them in full.
   convert() {
     case "$1" in
       ip) /var/ossec/framework/python/bin/python3 -c '
   import ipaddress, sys
   for line in open(sys.argv[1]):
       f = line.split()
       if not f or f[0][0] in "#!":
           continue
       a = ipaddress.ip_address(f[0])
       if a.version == 4:
           print(f"{a}:")
       else:
           print(f"\"{a.compressed}\":\n\"{a.exploded}\":")
   ' "$2" ;;
       domain) awk '!/^[#!]/ && NF { printf "%s:\n", $1 }' "$2" ;;
     esac
   }
   
   # load <isMalicious file> <CDB list name> <ip|domain>
   load() {
     fetch_list "$1" "$RAW"
     # .swp: not the compiler's own <list>.tmp, and never synced by the cluster.
     NEW=$(mktemp --suffix=.swp "$LISTS/.$2.XXXXXX")
     convert "$3" "$RAW" > "$NEW"
     chown wazuh:wazuh "$NEW"
     chmod 660 "$NEW"
     mv -f "$NEW" "$LISTS/$2"
     NEW=
   }
   
   load blocklist-ips-critical.txt        ismalicious-ips                ip
   load blocklist-domains-c2.txt          ismalicious-domains-c2         domain
   load blocklist-domains-ransomware.txt  ismalicious-domains-ransomware domain

4. 4

   Déclarer les listes dans ossec.conf

   Ajoutez une ligne list par liste dans le bloc ruleset de /var/ossec/etc/ossec.conf. Dans un cluster, faites-le sur chaque nœud : le master synchronise etc/lists/ vers les workers, mais pas ossec.conf.

   <!-- Inside the existing <ruleset> block, on every node: -->
   <list>etc/lists/ismalicious-ips</list>
   <list>etc/lists/ismalicious-domains-c2</list>
   <list>etc/lists/ismalicious-domains-ransomware</list>

5. 5

   Ajouter les règles

   Ajoutez les règles à /var/ossec/etc/rules/local_rules.xml, avec des identifiants libres dans votre jeu de règles. Les champs IP demandent la recherche address_match_key. La règle 100200 reprend le modèle de réputation d’IP documenté par Wazuh pour les journaux d’accès web ; les règles 100201 et 100202 vérifient la destination et la source des alertes EVE de Suricata. Pour une liste de domaines, utilisez la recherche match_key sur le champ décodé qui contient le nom demandé, que montre wazuh-logtest.

   <group name="ismalicious,">
   
     <!-- Web access logs: Wazuh's documented IP reputation pattern. -->
     <rule id="100200" level="10">
       <if_group>web|attack|attacks</if_group>
       <list field="srcip" lookup="address_match_key">etc/lists/ismalicious-ips</list>
       <description>isMalicious: source IP $(srcip) is on the critical IP list.</description>
     </rule>
   
     <!-- Suricata EVE alerts (rule 86601). Dynamic fields src_ip / dest_ip. -->
     <rule id="100201" level="10">
       <if_sid>86601</if_sid>
       <list field="dest_ip" lookup="address_match_key">etc/lists/ismalicious-ips</list>
       <description>isMalicious: Suricata alert towards listed IP $(dest_ip).</description>
     </rule>
   
     <rule id="100202" level="10">
       <if_sid>86601</if_sid>
       <list field="src_ip" lookup="address_match_key">etc/lists/ismalicious-ips</list>
       <description>isMalicious: Suricata alert from listed IP $(src_ip).</description>
     </rule>
   
   </group>

6. 6

   Charger les listes

   • Redémarrez le manager avec systemctl restart wazuh-manager, quelle que soit la version.
   • À partir de 4.13, le script de rechargement charge les listes sans redémarrage : il se connecte à l’API Wazuh avec des identifiants lus dans /root/.wazuh-api.netrc (mode 600 ; l’utilisateur de l’API doit avoir manager:read et manager:restart, ou cluster:*), garde le jeton dans une configuration curl en mode 600, appelle PUT /manager/analysisd/reload, et sort en erreur quand la réponse signale un élément en échec ou une liste non chargée : le point d’accès répond 200 dans tous les cas.
   • Dans un cluster, remplacez manager/ par cluster/ dans le script : manager/ ne recharge que le master, et les workers en 4.14.2 l’ignorent (corrigé en 4.14.3).
   • Avant 4.13, redémarrez chaque nœud une fois que le master a synchronisé etc/lists/.
   • L’option -k accepte le certificat propre de l’API sur localhost, comme dans le guide de l’API Wazuh.

   machine localhost
   login <WAZUH_API_USER>
   password <WAZUH_API_PASSWORD>

   #!/bin/sh
   # Wazuh 4.13 and later: hot reload, no restart. In a cluster, replace
   # manager/ with cluster/ below: manager/ reloads the master only.
   set -eu
   API=https://localhost:55000
   CFG=$(mktemp)
   trap 'rm -f "$CFG"' EXIT
   TOKEN=$(curl -fsS -k --netrc-file /root/.wazuh-api.netrc -X POST \
     "$API/security/user/authenticate?raw=true")
   # The token goes in a mode-600 curl config, not on the command line.
   printf 'header = "Authorization: Bearer %s"\n' "$TOKEN" > "$CFG"
   R=$(curl -fsS -k -K "$CFG" -X PUT "$API/manager/analysisd/reload?wait_for_complete=true")
   echo "$R"
   case "$R" in *'"total_failed_items": 0'*) ;; *) echo "Wazuh reload failed" >&2; exit 1 ;; esac
   case "$R" in *'(7616)'*) echo "a CDB list did not load: its rules are ignored" >&2; exit 1 ;; esac
   
   # Older than 4.13, replace the calls above with:
   # systemctl restart wazuh-manager

7. 7

   Planifier les deux scripts

   Lancez le téléchargement, puis le rechargement, toutes les 12 heures depuis /etc/cron.d/ismalicious-wazuh : les listes sont régénérées toutes les 12 heures. Un téléchargement raté arrête l’exécution avant le rechargement, et les listes précédentes restent en place.

   17 3,15 * * *  root  /usr/local/sbin/ismalicious-wazuh-lists.sh && /usr/local/sbin/ismalicious-wazuh-reload.sh

• wc -l sur une liste convertie donne à peu près son count dans /blocklist/stats, et head montre des lignes clé:, les clés IPv6 entre guillemets.
• Après un redémarrage ou un rechargement, le fichier .cdb de la liste porte un horodatage récent.
• wazuh-logtest affiche la règle 100200, 100201 ou 100202 en phase 3 pour une ligne de journal contenant une IP listée. Il relit les fichiers et compile lui-même les listes : il ne prouve donc pas que le moteur en service a rechargé, ce que montre ossec.log avec wazuh-analysisd: INFO: Ruleset reloaded successfully.
• Les alertes apparaissent dans le tableau de bord sous les identifiants des règles ou le groupe ismalicious, et dans alerts.json.
• Les premières lignes d’un téléchargement direct montrent Total entries sans Lite Version.

# The converted list and its compiled file:
wc -l /var/ossec/etc/lists/ismalicious-ips
head -3 /var/ossec/etc/lists/ismalicious-ips
ls -l /var/ossec/etc/lists/ismalicious-ips.cdb

# The running engine took the new ruleset:
grep 'Ruleset reloaded successfully' /var/ossec/logs/ossec.log | tail -1

# Paste a log line that holds a listed IP; phase 3 shows the rule:
/var/ossec/bin/wazuh-logtest

# Alerts raised by the rules:
grep ismalicious /var/ossec/logs/alerts/alerts.json

# 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

• Wazuh n’a pas d’intégration de flux pour isMalicious et ne télécharge rien lui-même : la mise à jour passe par le script cron, puis un redémarrage ou un rechargement.
• Les recherches CDB sont exactes. Aucune liste CIDR ou à jokers n’est servie, et la correspondance par préfixe IPv4 ne vaut que pour les clés finissant par un point, que les listes ne contiennent jamais.
• Une entrée IPv6 ne correspond qu’aux chaînes exactes listées : le script écrit chaque clé IPv6 compressée et en entier, les formes qu’utilisent des décodeurs comme l’EVE de Suricata ; toute autre notation ne correspond pas.
• Un domaine ne correspond qu’au nom exact de l’événement : evil.example listé ne correspond pas à www.evil.example. Aucune règle de domaines n’est publiée ici, car le champ qui contient une requête DNS dépend du décodeur.
• Les listes d’empreintes ne sont pas couvertes : leur taille n’est pas publiée, et leur téléchargement n’a pas été vérifié face à la fenêtre de 30 secondes de l’hôte api.
• 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

• SU

  Blocklist Suricata en datasets

  IP et domaines malveillants en datasets Suricata

• 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 d’IP

  Vérifier une adresse avant de la bloquer