Add files via upload

Author: juergen2025sys

.github/workflows/asn_reputation_scorer.yml

@@ -162,11 +162,24 @@ jobs:
               if et_text:
                   print(f"  ET-Quelle: {et_url.split('/')[-1]}")
                   break
-          et_ips = set()
-          # FIX: strikte IPV4_RE aus netshield_common nutzen statt inline
-          # \b-Regex – konsistent mit der Versions-String-Filterung.
-          for m in IPV4_RE.finditer(et_text):
-              et_ips.add(m.group(1))
+          # FIX BUG-WF5-IPV6-ASN: Vorher direkte IPV4_RE.finditer-Schleife –
+          # IPV4_RE hat einen Lookbehind '(?<![\d.])' der ':' als Trenner
+          # zulaesst. Folge: '::ffff:1.2.3.4' (IPv4-mapped IPv6) matchte den
+          # IPv4-Suffix '1.2.3.4' und fuegte ihn als Phantom-Eintrag ein.
+          # parse_entries() loest das via _is_in_ipv6_token-Heuristik
+          # (Token enthaelt '::' oder >=2 Doppelpunkte → kein Match).
+          # Konsequenz vor Fix: ASN-Reputation-Score wurde durch IPv6-mapped
+          # Eintraege in ET-Feeds verzerrt – mit reproduzierbarem
+          # asymmetrischen Effekt fuer ASN-Holder die viele AAAA-Records
+          # haben. Jetzt: Konsistent mit dem Rest der Pipeline.
+          # CIDR-Filter ('/' not in e): Vertrag bewahren – die alte Schleife
+          # gab nur Plain-IPs zurueck, et_ips wird unten mit 'ip_str in et_ips'
+          # verglichen wo ip_str eine Plain-IP ist. Ein '1.2.3.0/24' im Set
+          # wuerde diesen Vergleich nicht treffen aber die set-Groesse
+          # verzerren. Use_protected_check=False (Validierungs-Modus):
+          # Whitelist-IPs bleiben drin, weil ASN-Scoring sie ueberhaupt
+          # mitsehen soll.
+          et_ips = {e for e in _parse_entries(et_text) if "/" not in e}
           print(f"  Emerging Threats: {len(et_ips):,} IPs" if et_ips else "  Emerging Threats: FEHLER – alle Quellen nicht erreichbar")
 
           # Hilfsfunktion: Binary-Search CIDR-Check (sortierte Ranges)

.github/workflows/auto_feed_discovery.yml

@@ -375,8 +375,27 @@ jobs:
           if not db and os.path.exists(BACKUP_FILE):
               try:
                   import gzip
+                  # FIX BUG-GZIP-BACKUP-LIMIT: identisch zu update_combined_blacklist.
+                  # Ohne Pre-Size + Streaming-Limit wuerde eine zip-Bombe im
+                  # Backup den Workflow per OOM kippen bevor _MIN_BACKUP_ENTRIES
+                  # je greift. Layer 1: 200 MB komprimiert hard-cap.
+                  # Layer 2: 2 GB Streaming-Read auf den dekomprimierten Text.
+                  _BACKUP_COMPRESSED_LIMIT   = 200 * 1024 * 1024
+                  _BACKUP_DECOMPRESSED_LIMIT = 2 * 1024 * 1024 * 1024
+                  _bsize = os.path.getsize(BACKUP_FILE)
+                  if _bsize > _BACKUP_COMPRESSED_LIMIT:
+                      raise ValueError(
+                          f"Backup zu gross: {_bsize / 1024 / 1024:.1f} MB "
+                          f"> {_BACKUP_COMPRESSED_LIMIT / 1024 / 1024:.0f} MB "
+                          f"(moegliche zip-Bombe oder Repo-Korruption)")
                   with gzip.open(BACKUP_FILE, "rt", encoding="utf-8") as _bf:
-                      db = json.load(_bf)
+                      _raw = _bf.read(_BACKUP_DECOMPRESSED_LIMIT + 1)
+                      if len(_raw) > _BACKUP_DECOMPRESSED_LIMIT:
+                          raise ValueError(
+                              f"Backup-Stream > "
+                              f"{_BACKUP_DECOMPRESSED_LIMIT / 1024 / 1024:.0f} MB "
+                              f"nach Dekomprimierung (zip-Bombe), verworfen")
+                      db = json.loads(_raw)
                   # FIX BUG-BACKUP-GUARD: Backup-Plausibilitaet pruefen vor Restore.
                   # Ein winziges/leeres Backup wuerde sonst die Cache-Recovery
                   # mit kaputtem Stand zementieren - besser leer starten und

.github/workflows/feed_health_monitor.yml

@@ -150,7 +150,13 @@ jobs:
                       code   = r.status
                       sample = r.read(2 * 1024 * 1024).decode("utf-8", errors="ignore")  # 2 MB reichen für IP-Sample-Check; 25 MB war unnötiger Netzwerk-/Speicherdruck bei 15 parallelen Requests
                   elapsed = round(time.time() - t0, 2)
-                  ip_count = len(set(IP_RE.findall(sample)))
+                  # FIX BUG-WF6-IPV6-HEALTH: vorher IP_RE.findall ohne IPv6-
+                  # Token-Schutz. ::ffff:1.2.3.4 haette den has_ips-Boolean
+                  # faelschlich auf True gesetzt (= Feed gilt als gesund).
+                  # parse_entries() filtert IPv6-Tokens via _is_in_ipv6_token.
+                  # Niedrige Praxis-Relevanz weil ip_count nur fuer Health-
+                  # Watchdog (Boolean), nicht fuer Datenfluss in Blacklists.
+                  ip_count = len(_parse_entries(sample))
                   has_ips  = ip_count > 0
                   return {"name": name, "url": url, "status": code, "ok": code == 200,
                           "has_ips": has_ips, "sample_ips": ip_count, "ms": int(elapsed*1000)}

.github/workflows/update_combined_blacklist.yml

@@ -184,6 +184,7 @@ jobs:
               safe_get_date, parse_date, sort_ips, write_ip_list,
               write_json_atomic, write_text_atomic,
               fetch_url, check_local_feed_age,
+              validate_auto_feeds,
               IPV4_RE, CIDR_RE, TIMESTAMP_RE,
           )
           import ipaddress, json, os, re, sys, urllib.request
@@ -639,6 +640,19 @@ jobs:
           BACKUP_FILE = "seen_db_backup.json.gz"
           if os.path.exists(DB_FILE):
               try:
+                  # FIX BUG-SEENDB-LIMIT: Pre-Size-Check vor json.load.
+                  # seen_db.json ist heute ~600 MB. 5 GB Hard-Cap erlaubt
+                  # 8x Wachstum, schuetzt aber gegen ein versehentlich
+                  # oder boeswillig korruptes seen_db (z.B. via Cache-
+                  # Restore aus einem anderen Repo) das den Runner mit
+                  # 7 GB RAM via json.load OOM kippen wuerde.
+                  _SEENDB_LIMIT = 5 * 1024 * 1024 * 1024
+                  _dsize = os.path.getsize(DB_FILE)
+                  if _dsize > _SEENDB_LIMIT:
+                      raise ValueError(
+                          f"seen_db.json zu gross: {_dsize / 1024 / 1024:.1f} MB "
+                          f"> {_SEENDB_LIMIT / 1024 / 1024 / 1024:.0f} GB "
+                          f"(moegliche Korruption oder Cache-Mismatch)")
                   with open(DB_FILE) as f:
                       db = json.load(f)
                   print(f"seen_db geladen: {len(db)} IPs")
@@ -648,8 +662,36 @@ jobs:
           if not db and os.path.exists(BACKUP_FILE):
               try:
                   import gzip
+                  # FIX BUG-GZIP-BACKUP-LIMIT: Pre-Size + Streaming-Limit.
+                  # Vorher: gzip.open + json.load ohne irgendeine Groessen-
+                  # Pruefung. Wenn ein Angreifer mit Repo-Schreibrechten das
+                  # Backup durch eine zip-Bombe ersetzt (z.B. 100 MB
+                  # komprimiert -> 50 GB expandiert), erleidet der Workflow
+                  # OOM bevor der nachgelagerte _MIN_BACKUP_ENTRIES-Check
+                  # je greift. Realistisch: Repo-Write erforderlich, also
+                  # Insider-Threat-Vektor – Hardung lohnt trotzdem.
+                  # Layer 1: komprimierte Groesse hard-cap bei 200 MB
+                  #          (aktuelles Backup ist ~70 MB, 200 MB ist 3x
+                  #          headroom fuer normales Wachstum).
+                  # Layer 2: Streaming-Read mit 2 GB-Limit auf den
+                  #          dekomprimierten JSON-Text. Das echte JSON
+                  #          ist heute ~600 MB – 2 GB erlaubt 3x Wachstum.
+                  _BACKUP_COMPRESSED_LIMIT   = 200 * 1024 * 1024
+                  _BACKUP_DECOMPRESSED_LIMIT = 2 * 1024 * 1024 * 1024
+                  _bsize = os.path.getsize(BACKUP_FILE)
+                  if _bsize > _BACKUP_COMPRESSED_LIMIT:
+                      raise ValueError(
+                          f"Backup zu gross: {_bsize / 1024 / 1024:.1f} MB "
+                          f"> {_BACKUP_COMPRESSED_LIMIT / 1024 / 1024:.0f} MB "
+                          f"(moegliche zip-Bombe oder Repo-Korruption)")
                   with gzip.open(BACKUP_FILE, "rt", encoding="utf-8") as _bf:
-                      db = json.load(_bf)
+                      _raw = _bf.read(_BACKUP_DECOMPRESSED_LIMIT + 1)
+                      if len(_raw) > _BACKUP_DECOMPRESSED_LIMIT:
+                          raise ValueError(
+                              f"Backup-Stream > "
+                              f"{_BACKUP_DECOMPRESSED_LIMIT / 1024 / 1024:.0f} MB "
+                              f"nach Dekomprimierung (zip-Bombe), verworfen")
+                      db = json.loads(_raw)
                   # FIX BUG-BACKUP-GUARD: Backup ist nur dann nutzbar wenn es
                   # eine plausible Anzahl Eintraege enthaelt. Ein winziges
                   # Backup (durch frueheren BUG-BACKUP-GUARD-Schreibfehler oder
@@ -1010,7 +1052,16 @@ jobs:
               try:
                   with open(AUTO_FEEDS_FILE) as af:
                       auto_data = json.load(af)
-                  auto_feeds = auto_data.get("feeds", [])
+                  # FIX BUG-AUTOFEEDS-VALIDATE: validate_auto_feeds() filtert
+                  # auf safe Schema (dict mit name/url als String) und URL-
+                  # Whitelist (nur http/https). Vorher: direkter
+                  # auto_data.get("feeds", []) ohne Pruefung – ein Angreifer
+                  # mit Repo-Schreibrechten konnte malicious URLs in den
+                  # Feed-Loop einschleusen ohne Code-Review-Pfad ueber SOURCES.
+                  auto_feeds, _rejected = validate_auto_feeds(auto_data)
+                  if _rejected:
+                      print(f"  WARNUNG: {_rejected} auto-feed Eintraege wegen "
+                            f"Schema-/URL-Check verworfen")
                   print(f"  Auto-discovered Feeds: {len(auto_feeds)}")
 
                   def fetch_auto(feed):