netverdict 0.5.0__py3-none-any.whl

netverdict/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

netverdict/capture/capture.ps1

@@ -0,0 +1,130 @@
+<#
+.SYNOPSIS
+Capture assistee netverdict (Windows) : trafic reseau + etat hote, en un coup.
+
+.DESCRIPTION
+Lance une capture pktmon (natif Windows 10+/Server 2019+, rien a installer)
+et prend un snapshot de l'etat de la machine AU MILIEU de la capture :
+connexions TCP avec process proprietaire, CPU, memoire, disque.
+Le pcap dit ce qui passe sur le fil ; le snapshot dit QUI tenait la socket
+et dans quel etat etait la machine — c'est le croisement des deux qui permet
+de trancher APP vs OS.
+
+Par defaut la capture est TRONQUEE a 128 octets/paquet : suffisant pour
+l'analyse netverdict et fichiers legers. -FullPackets pour les paquets entiers.
+
+ATTENTION : la troncature n'est PAS une garantie d'absence de secret. Elle coupe
+a 128 octets DEPUIS LE DEBUT DE LA TRAME, donc tout paquet plus court est
+capture EN ENTIER, payload compris. Mesure du 25/07/2026 : "PASS hunter2", un
+login FTP complet et un jeton JSON court passent INTACTS. La troncature elimine
+les gros transferts, pas les secrets courts — et l'authentification en clair est
+precisement courte. Traiter le bundle comme une donnee sensible.
+
+.EXAMPLE
+.\capture.ps1 -DurationSec 60 -TargetIP 10.0.0.5
+netverdict analyze <bundle>\capture.pcapng --snapshot <bundle>\snapshot.json
+#>
+[CmdletBinding()]
+param(
+    [int]$DurationSec = 60,
+    [string]$OutDir = "",
+    [string]$TargetIP = "",
+    [int]$TargetPort = 0,
+    [switch]$FullPackets
+)
+
+$ErrorActionPreference = "Stop"
+
+$isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()
+           ).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+if (-not $isAdmin) {
+    Write-Error "pktmon exige une console Administrateur. Relancer en admin."
+    exit 2
+}
+
+if (-not $OutDir) {
+    $OutDir = Join-Path (Get-Location) ("netverdict-capture-" + (Get-Date -Format "yyyyMMdd-HHmmss"))
+}
+New-Item -ItemType Directory -Force $OutDir | Out-Null
+$etl  = Join-Path $OutDir "capture.etl"
+$pcap = Join-Path $OutDir "capture.pcapng"
+$snap = Join-Path $OutDir "snapshot.json"
+
+# --- Filtres pktmon (reset puis cible eventuelle) ---------------------------
+pktmon filter remove | Out-Null
+if ($TargetIP)  { pktmon filter add -i $TargetIP  | Out-Null }
+if ($TargetPort -gt 0) { pktmon filter add -p $TargetPort | Out-Null }
+
+$pktSize = if ($FullPackets) { 0 } else { 128 }
+Write-Host "Capture pktmon ${DurationSec}s (pkt-size=$pktSize) -> $etl"
+# --comp nics : capturer au niveau des cartes reseau UNIQUEMENT. Par defaut
+# pktmon capture a CHAQUE couche NDIS -> le meme paquet apparait plusieurs
+# fois et fabrique de faux echantillons RTT (~0 ms) dans l'analyse
+# (constate sur capture reelle). Limite connue et assumee : le trafic
+# loopback pur (127.0.0.1) est invisible a pktmon de toute facon — le TCP
+# Loopback Fast Path de Windows court-circuite la pile NDIS.
+pktmon start --capture --comp nics --pkt-size $pktSize --file-name $etl | Out-Null
+
+# --- Snapshot hote au milieu de la fenetre de capture -----------------------
+Start-Sleep -Seconds ([math]::Max(1, [int]($DurationSec / 2)))
+Write-Host "Snapshot etat hote..."
+
+# Connexions TCP -> process. CIM plutot que Get-Counter : les noms de
+# compteurs Get-Counter sont LOCALISES (piege classique des Windows FR).
+$procNames = @{}
+Get-Process | ForEach-Object { $procNames[$_.Id] = $_.ProcessName }
+$conns = Get-NetTCPConnection -ErrorAction SilentlyContinue | ForEach-Object {
+    [pscustomobject]@{
+        local_ip    = $_.LocalAddress
+        local_port  = [int]$_.LocalPort
+        remote_ip   = $_.RemoteAddress
+        remote_port = [int]$_.RemotePort
+        state       = "$($_.State)"
+        pid         = [int]$_.OwningProcess
+        process     = $procNames[[int]$_.OwningProcess]
+    }
+}
+
+$cpu = (Get-CimInstance Win32_Processor | Measure-Object -Property LoadPercentage -Average).Average
+$os  = Get-CimInstance Win32_OperatingSystem
+$memFreeMb = [math]::Round($os.FreePhysicalMemory / 1024, 0)
+$disk = Get-CimInstance Win32_PerfFormattedData_PerfDisk_PhysicalDisk |
+        Where-Object Name -eq "_Total" | Select-Object -First 1
+$topCpu = Get-CimInstance Win32_PerfFormattedData_PerfProc_Process |
+          Where-Object { $_.Name -notin @("Idle", "_Total") } |
+          Sort-Object PercentProcessorTime -Descending |
+          Select-Object -First 10 | ForEach-Object {
+              [pscustomobject]@{
+                  pid     = [int]$_.IDProcess
+                  process = $_.Name
+                  cpu_pct = [double]$_.PercentProcessorTime
+              }
+          }
+
+$snapshot = [pscustomobject]@{
+    host          = $env:COMPUTERNAME
+    os            = "windows"
+    taken_at      = (Get-Date).ToString("o")
+    cpu_pct       = [double]$cpu
+    mem_free_mb   = [double]$memFreeMb
+    disk_busy_pct = if ($disk) { [double]$disk.PercentDiskTime } else { $null }
+    connections   = @($conns)
+    top_cpu       = @($topCpu)
+}
+$snapshot | ConvertTo-Json -Depth 4 | Out-File -Encoding utf8 $snap
+
+# --- Fin de capture et conversion -------------------------------------------
+Start-Sleep -Seconds ([math]::Max(1, $DurationSec - [int]($DurationSec / 2)))
+pktmon stop | Out-Null
+Write-Host "Conversion etl -> pcapng..."
+pktmon etl2pcap $etl -o $pcap | Out-Null
+pktmon filter remove | Out-Null
+Remove-Item $etl -ErrorAction SilentlyContinue
+
+Write-Host ""
+Write-Host "Bundle pret :"
+Write-Host "  $pcap"
+Write-Host "  $snap"
+Write-Host ""
+Write-Host "Analyse :"
+Write-Host "  netverdict analyze `"$pcap`" --snapshot `"$snap`""

netverdict/capture/capture.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# Capture assistee netverdict (Linux) : trafic + etat hote, en un coup.
+#
+# tcpdump tronque (-s 96 : de quoi lire IP+TCP+options) + snapshot au milieu de
+# la fenetre : sockets avec process (ss -tnp), charge CPU, memoire, disque.
+#
+# ATTENTION : -s 96 n'est PAS une garantie d'absence de secret. tcpdump coupe a
+# 96 octets DEPUIS LE DEBUT DE LA TRAME, donc tout paquet plus court est capture
+# EN ENTIER, payload compris. Mesure du 25/07/2026 : "PASS hunter2", un login
+# FTP complet et un jeton JSON court passent INTACTS. La troncature elimine les
+# gros transferts, pas les secrets courts — et l'authentification en clair est
+# precisement courte. Traiter le bundle comme une donnee sensible.
+#
+# Usage : sudo ./capture.sh [-d 60] [-o outdir] [-i host_cible] [-p port]
+set -euo pipefail
+
+DURATION=60
+OUTDIR=""
+TARGET_IP=""
+TARGET_PORT=""
+
+while getopts "d:o:i:p:" opt; do
+  case "$opt" in
+    d) DURATION="$OPTARG" ;;
+    o) OUTDIR="$OPTARG" ;;
+    i) TARGET_IP="$OPTARG" ;;
+    p) TARGET_PORT="$OPTARG" ;;
+    *) echo "usage: $0 [-d sec] [-o dir] [-i ip] [-p port]" >&2; exit 2 ;;
+  esac
+done
+
+if [ "$(id -u)" -ne 0 ]; then
+  echo "tcpdump exige root : relancer avec sudo." >&2
+  exit 2
+fi
+command -v tcpdump >/dev/null || { echo "tcpdump absent (apt install tcpdump)" >&2; exit 2; }
+# ss etait suppose present : sur une image minimale (conteneur, Alpine) son
+# absence etait avalee par un `|| true` et produisait un snapshot avec
+# "connections": [] — que netverdict accepte sans broncher. Le rapport
+# affichait alors un etat hote credible SANS jamais pouvoir attribuer un
+# process : capacite silencieusement inerte (audit du 26/07).
+command -v ss >/dev/null || { echo "ss absent (apt install iproute2) : sans lui le snapshot n'aurait aucune connexion" >&2; exit 2; }
+
+OUTDIR="${OUTDIR:-./netverdict-capture-$(date +%Y%m%d-%H%M%S)}"
+mkdir -p "$OUTDIR"
+PCAP="$OUTDIR/capture.pcap"
+SNAP="$OUTDIR/snapshot.json"
+
+FILTER="tcp or icmp"
+[ -n "$TARGET_IP" ] && FILTER="($FILTER) and host $TARGET_IP"
+[ -n "$TARGET_PORT" ] && FILTER="($FILTER) and port $TARGET_PORT"
+
+echo "Capture tcpdump ${DURATION}s -> $PCAP  (filtre: $FILTER)"
+tcpdump -i any -s 96 -w "$PCAP" $FILTER &
+TCPDUMP_PID=$!
+# Sans ce trap, une sortie anticipee (erreur du snapshot, Ctrl-C) laissait
+# tcpdump orphelin en train d'ecrire indefiniment dans le fichier.
+trap 'kill "$TCPDUMP_PID" 2>/dev/null' EXIT INT TERM
+
+sleep "$(( DURATION / 2 > 0 ? DURATION / 2 : 1 ))"
+echo "Snapshot etat hote..."
+
+# ss -H -tnp : etat + pid/process par socket, parse en python (present partout)
+ss -H -tnp > "$OUTDIR/.ss.txt" || true
+python3 - "$OUTDIR/.ss.txt" "$SNAP" <<'PYEOF'
+import json, os, re, sys, time
+
+ss_file, out = sys.argv[1], sys.argv[2]
+conns = []
+for line in open(ss_file, encoding="utf-8", errors="replace"):
+    parts = line.split()
+    if len(parts) < 5:
+        continue
+    state, _, _, local, peer = parts[0], parts[1], parts[2], parts[3], parts[4]
+    m = re.search(r'pid=(\d+)', line)
+    proc = re.search(r'users:\(\("([^"]+)"', line)
+    def split_hp(s):
+        host, _, port = s.rpartition(":")
+        return host.strip("[]"), int(port) if port.isdigit() else 0
+    lh, lp = split_hp(local)
+    rh, rp = split_hp(peer)
+    conns.append({"local_ip": lh, "local_port": lp, "remote_ip": rh,
+                  "remote_port": rp, "state": state,
+                  "pid": int(m.group(1)) if m else None,
+                  "process": proc.group(1) if proc else None})
+
+load1 = open("/proc/loadavg").read().split()[0]
+mem = {}
+for l in open("/proc/meminfo"):
+    k, v = l.split(":", 1)
+    mem[k] = int(v.strip().split()[0])
+
+snapshot = {
+    "host": os.uname().nodename,
+    "os": "linux",
+    "taken_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
+    "cpu_pct": None,                       # load1 ci-dessous, plus parlant sous Linux
+    "load1": float(load1),
+    "mem_free_mb": mem.get("MemAvailable", 0) // 1024,
+    "disk_busy_pct": None,
+    "connections": conns,
+    "top_cpu": [],
+}
+with open(out, "w", encoding="utf-8") as f:
+    json.dump(snapshot, f, indent=2)
+PYEOF
+rm -f "$OUTDIR/.ss.txt"
+
+sleep "$(( DURATION - DURATION / 2 ))"
+kill "$TCPDUMP_PID" 2>/dev/null || true
+wait "$TCPDUMP_PID" 2>/dev/null || true
+
+echo ""
+echo "Bundle pret :"
+echo "  $PCAP"
+echo "  $SNAP"
+echo ""
+echo "Analyse :"
+echo "  netverdict analyze \"$PCAP\" --snapshot \"$SNAP\""

netverdict/capture/sysmon-netverdict.xml

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Configuration Sysmon MINIMALE pour netverdict.
+
+  But : ne journaliser QUE l'evenement 3 (NetworkConnect), qui porte la
+  jointure process <-> connexion dont l'analyse a besoin :
+      SourceIp / SourcePort / DestinationIp / DestinationPort
+      + ProcessId + Image + Protocol + Initiated
+
+  C'est tout l'interet de Sysmon face a l'audit natif WFP (evenements
+  Securite 5156/5157) : le WFP journalise CHAQUE connexion autorisee dans le
+  journal Securite et le fait tourner en quelques heures sur un poste actif —
+  au moment ou l'on analyse un incident, les evenements utiles ont deja
+  disparu. Ici on cible, et le journal Sysmon est un canal separe, dimensionne
+  independamment.
+
+  IDIOME UTILISE, a ne pas "corriger" :
+    onmatch="include" SANS aucune regle  =  ne matche jamais  =  type d'evenement
+    eteint. C'est la facon documentee de desactiver un type d'evenement, plus
+    fiable que de compter sur ses valeurs par defaut (qui varient d'une version
+    a l'autre). Les 21 autres types sont donc explicitement eteints ci-dessous.
+
+    onmatch="exclude" SANS aucune regle  =  n'exclut rien  =  tout journalise.
+    C'est ce qu'on veut pour NetworkConnect : filtrer par port ou par process
+    risquerait d'ecarter precisement le flux de l'incident.
+
+  Verifie le 2026-07-25 contre le schema du binaire livre avec Windows
+  (C:\Windows\System32\sysmon.exe -s) : schemaversion 4.91, et les 22 noms
+  d'elements ci-dessous sont ceux que ce binaire declare. Un nom inconnu fait
+  rejeter TOUT le fichier.
+
+  Installation (terminal ADMINISTRATEUR) :
+      sysmon -accepteula -i capture\sysmon-netverdict.xml
+  Mise a jour d'une instance deja installee :
+      sysmon -c capture\sysmon-netverdict.xml
+  Desinstallation complete (driver + service + canal) :
+      sysmon -u force
+
+  Volume : sur un poste de bureau, compter quelques centaines a quelques
+  milliers d'evenements par heure. Verifier la taille du canal apres une
+  journee, et le reduire si besoin :
+      wevtutil sl Microsoft-Windows-Sysmon/Operational /ms:67108864
+-->
+<Sysmon schemaversion="4.91">
+  <!-- Aucun hachage calcule : on ne veut que la jointure reseau, et le hachage
+       coute du CPU a chaque process demarre pour rien ici. -->
+  <HashAlgorithms>*</HashAlgorithms>
+  <CheckRevocation>false</CheckRevocation>
+
+  <EventFiltering>
+    <!-- ============ LE SEUL EVENEMENT QUI NOUS INTERESSE ============ -->
+    <!-- exclude sans regle : tout est journalise. -->
+    <NetworkConnect onmatch="exclude" />
+
+    <!-- ============ TOUT LE RESTE ETEINT ============ -->
+    <!-- include sans regle : ne matche jamais, donc rien n'est journalise. -->
+    <ClipboardChange onmatch="include" />
+    <CreateRemoteThread onmatch="include" />
+    <DnsQuery onmatch="include" />
+    <DriverLoad onmatch="include" />
+    <FileBlockExecutable onmatch="include" />
+    <FileBlockShredding onmatch="include" />
+    <FileCreate onmatch="include" />
+    <FileCreateStreamHash onmatch="include" />
+    <FileCreateTime onmatch="include" />
+    <FileDelete onmatch="include" />
+    <FileDeleteDetected onmatch="include" />
+    <FileExecutableDetected onmatch="include" />
+    <ImageLoad onmatch="include" />
+    <PipeEvent onmatch="include" />
+    <ProcessAccess onmatch="include" />
+    <ProcessCreate onmatch="include" />
+    <ProcessTampering onmatch="include" />
+    <ProcessTerminate onmatch="include" />
+    <RawAccessRead onmatch="include" />
+    <RegistryEvent onmatch="include" />
+    <WmiEvent onmatch="include" />
+  </EventFiltering>
+</Sysmon>