StaticCodeAudit

by CodeFixture

Eigenständiges Werkzeug für Compliance-, Sicherheits- und Codequalitätsaudits von Webprojekten (Python, JavaScript/TypeScript, HTML, Java, C#, PHP, YAML).

Inhaltsverzeichnis

1. Installation
2. Schnellstart
3. CLI-Optionen
4. Projektverwaltung
5. Konfiguration
   • brand
   • project
   • languages
   • paths
   • reports
   • categories
   • rules
   • fixtures
   • thresholds
   • sla
   • retention
6. Auditkategorien
7. Berichte
8. CI/CD-Integration
9. Internationalisierung (i18n)
10. Eigene Regeln
11. Lizenz

Installation

StaticCodeAudit wird als eigenständige Binärdatei pro Plattform geliefert. Keine externe Abhängigkeit erforderlich, kein Netzwerkzugriff zur Laufzeit.

1. Laden Sie das Archiv für Ihre Plattform aus Ihrem Kundenbereich herunter:

   • macOS Apple Silicon: staticcodeaudit-macos-arm64.tar.gz
   • macOS Intel: staticcodeaudit-macos-x64.tar.gz
   • Linux x64: staticcodeaudit-linux-x64.tar.gz
   • Windows x64: staticcodeaudit-windows-x64.zip

2. Entpacken Sie das Archiv in das Verzeichnis Ihrer Wahl.

3. Führen Sie die Binärdatei aus, um die Installation zu prüfen:

./staticcodeaudit-macos-arm64 --help

Sie können die Binärdatei optional in Ihrem PATH unter dem Namen staticcodeaudit ablegen, um die nachfolgenden Beispiele zu vereinfachen.

Schnellstart

# Erster Lauf: erzeugt automatisch audit.config.json und registriert das Projekt
./staticcodeaudit-macos-arm64 /path/to/my-project --init

# Audit ausführen
./staticcodeaudit-macos-arm64 /path/to/my-project

Das --init-Flag erstellt interaktiv audit.config.json und erkennt:

• Projektsprachen (Python, JavaScript/TypeScript, HTML, Java, C#, PHP)
• Quellcode-Verzeichnisse (app/, src/, etc.)

Wichtig: Zur Laufzeit verwendet die Binärdatei ausschließlich die Konfigurationsdatei audit.config.json — keine automatische Erkennung.

CLI-Optionen

Beispiele:

# Vollständiges Audit
./staticcodeaudit-macos-arm64 /path/to/project

# Schnellmodus (nur Sicherheit)
./staticcodeaudit-macos-arm64 /path/to/project --quick

# CI/CD-Modus (SARIF-Export + Exit-Code 1 bei HIGH)
./staticcodeaudit-macos-arm64 /path/to/project --sarif --fail-on-high

# Mit Unit-Tests (erkennt automatisch pytest, jest, mvn etc.)
./staticcodeaudit-macos-arm64 /path/to/project --with-tests

# Mit Schwachstellen-Scan der Abhängigkeiten
./staticcodeaudit-macos-arm64 /path/to/project --with-deps

# Französischer Bericht
./staticcodeaudit-macos-arm64 /path/to/project --lang=fr

# Eigene Regel erstellen (interaktiver Assistent)
./staticcodeaudit-macos-arm64 /path/to/project --create-rule

# Anonymisierter Demo-Bericht
./staticcodeaudit-macos-arm64 /path/to/project --demo

# Projektverwaltung
./staticcodeaudit-macos-arm64 --list-projects                        # Alle Projekte auflisten
./staticcodeaudit-macos-arm64 /path/to/project --project-info        # Projektinformationen
./staticcodeaudit-macos-arm64 /path/to/project --init-fixtures       # Fixture-Verzeichnis anlegen
./staticcodeaudit-macos-arm64 /path/to/project --unregister          # Projekt deregistrieren

# Auditkategorien auflisten
./staticcodeaudit-macos-arm64 --list-categories
./staticcodeaudit-macos-arm64 --list-categories --script-lang=fr

# Alle Regeln nach Kategorie auflisten
./staticcodeaudit-macos-arm64 --list-rules
./staticcodeaudit-macos-arm64 /path/to/project --list-rules --script-lang=fr

Ausgabeformate

Jeder Audit-Lauf erzeugt standardmäßig HTML + JSON. Zusätzliche Formate sind auf Anfrage verfügbar:

# Erzeugt HTML + JSON + anonymisierten Demo-Bericht
./staticcodeaudit-macos-arm64 /path/to/project --demo

# Erzeugt HTML + JSON + SARIF
./staticcodeaudit-macos-arm64 /path/to/project --sarif

# Erzeugt HTML + JSON + SBOM
./staticcodeaudit-macos-arm64 /path/to/project --sbom

# Erzeugt alle Formate
./staticcodeaudit-macos-arm64 /path/to/project --sarif --sbom --demo

Demo-Modus: Das --demo-Flag erzeugt einen zusätzlichen anonymisierten Bericht (*-demo.html) neben dem vollständigen Bericht. Dateipfade werden durch path_to/{filename}:## ersetzt, der Quellcode wird ausgeblendet und Lösungen werden gekürzt. Ideal, um den Bericht mit Interessenten zu teilen oder als Beispiel zu veröffentlichen.

Projektverwaltung

Jedes auditierte Projekt wird durch eine eindeutige UUID identifiziert, die beim ersten Audit (--init) automatisch erzeugt wird. Dieses System ermöglicht es:

• Unterscheiden von Projekten mit gleichem Verzeichnisnamen an unterschiedlichen Speicherorten
• Isolieren projektspezifischer Fixtures
• Verfolgen der Audit-Historie pro Projekt
• Erkennen, ob ein Projekt verschoben wurde

Erstes Audit eines Projekts

# Die Binärdatei erkennt das Projekt automatisch und erzeugt eine UUID
./staticcodeaudit-macos-arm64 /path/to/my-project --init

# Ausgabe:
#  Automatische Erkennung des Projekts "my-project"...
#    Typ: Python + JavaScript
#    Pfade: app/, src/
#  Eindeutige Kennung erzeugt: a1b2c3d4
#  Konfiguration erzeugt: /path/to/my-project/audit.config.json
#  Projekt registriert

Registrierte Projekte auflisten

./staticcodeaudit-macos-arm64 --list-projects

# Ausgabe:
#  Registrierte Projekte (2):
#
# [a1b2c3d4] MyProject
#   Pfad: /path/to/my-project
#   Beschreibung: Beispiel-Webanwendung
#   Letztes Audit: 2026-02-25 10:30
#   Audits: 15 | Fixtures: 12 spezifische
#
# [b5c6d7e8] My-API
#   Pfad: /Users/dev/my-api
#   Letztes Audit: Niemals
#   Audits: 0 | Fixtures: nur generische

Detaillierte Projektinformationen

./staticcodeaudit-macos-arm64 /path/to/project --project-info

# Ausgabe:
#  Projektinformationen
#
# ID:           a1b2c3d4-e5f6-7890-abcd-ef1234567890
# Name:         MyProject
# Beschreibung: Beispiel-Webanwendung
# Version:      3.0
# Pfad:         /path/to/my-project
#
# Registriert:   2026-01-15 14:30
# Letztes Audit: 2026-02-25 10:30
# Audits gesamt: 15

Erkennung verschobener Projekte

Wird ein Projekt an einen anderen Speicherort verschoben, erkennt die Binärdatei die Änderung automatisch und aktualisiert den registrierten Pfad:

  Warnung: Pfad dieses Projekts hat sich geändert
    Vorher: /Users/dev/old-path/my-project
    Neu:    /Users/dev/new-path/my-project

    project.json aktualisiert

Ein Projekt deregistrieren

./staticcodeaudit-macos-arm64 /path/to/project --unregister

# Die internen Metadaten werden gelöscht
# Fixtures werden beibehalten (sofern vorhanden)
# Die audit.config.json des Projekts wird nicht verändert

Konfiguration

Die Datei audit.config.json wird beim ersten Audit automatisch im Stammverzeichnis des Zielprojekts erstellt.

brand

Branding-Konfiguration. Ermöglicht es, die Identität des Werkzeugs pro Projekt anzupassen (z. B. für Berichte an Kunden).

{
  "brand": {
    "tool_name": "Acme Code Audit",
    "company_name": "Acme Corp",
    "prefix": "ACM",
    "logo": "assets/acme-logo.svg"
  }
}

Hinweis: Verweist brand.logo auf eine fehlende Datei oder ein nicht unterstütztes Format, fällt das Werkzeug mit einer Konsolen-Warnung auf seine Standardsymbole zurück. Das Logo wird als base64 in den HTML-Bericht eingebettet, damit dieser eigenständig bleibt.

project

Im Bericht angezeigte Projektinformationen.

{
  "project": {
    "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "name": "My Project",
    "version": "1.0.0",
    "description": "FastAPI + Vue.js web application"
  }
}

Wichtig: Die UUID (id) wird automatisch erzeugt und sollte nicht manuell verändert werden. Sie dient zur eindeutigen Identifikation des Projekts und zur Zuordnung der projektspezifischen Fixtures.

languages

ERFORDERLICH — Deklariert die Sprachen des Projekts. Steuert, welche Auditregeln ausgeführt werden.

{
  "languages": ["python", "javascript", "html", "java", "csharp", "php", "yaml"]
}

Wichtig: Wird eine Sprache nicht deklariert, werden die zugehörigen Regeln nicht ausgeführt. TypeScript-Dateien (.ts, .tsx) und JSX (.jsx, .mjs) werden als JavaScript behandelt — es gelten dieselben Regeln. Eine separate Sprache "typescript" ist nicht erforderlich.

paths

Konfiguration der Scan-Pfade.

Hinweis: paths.include wird für alle deklarierten Sprachen verwendet. Die Filterung der Dateitypen erfolgt anhand der Erweiterung. Während --init wird die Konfiguration automatisch mit den erkannten Pfaden erzeugt.

{
  "paths": {
    "include": [
      "app/",
      "src/",
      "UI-FRONT/js/",
      "UI-ADMIN/js/"
    ],
    "exclude": [
      "**/node_modules/**",
      "**/vendor/**",
      "**/__pycache__/**",
      "**/.venv/**",
      "*.min.js",
      "*.bundle.js"
    ]
  }
}

reports

Konfiguration der Berichtgenerierung.

{
  "reports": {
    "output_dir": "docs/audit-reports",
    "history_dir": "docs/audit-reports/audit-datas",
    "max_history": 10,
    "language": "en"
  }
}

categories

Aktivierung und Gewichtung der Auditkategorien.

{
  "categories": {
    "security": { "enabled": true, "weight": 3 },
    "architecture": { "enabled": true, "weight": 2 },
    "ui": { "enabled": true, "weight": 1 },
    "ux": { "enabled": true, "weight": 1 },
    "maintenance": { "enabled": true, "weight": 1 }
  }
}

Empfohlene Gewichtungen:

• security: 3 (kritisch)
• architecture: 2 (wichtig)
• ui, ux, maintenance: 1 (Standard)

rules

Konfiguration der Erkennungsregeln.

{
  "rules": {
    "disabled": [
      "TODO/FIXME",
      "console.log"
    ]
  }
}

Eine vollständige Liste der Regeln finden Sie in SUMMARY.md und im Bericht unter --list-rules.

fixtures

Fixture-Konfiguration zur Validierung der eigenen Regeln.

{
  "fixtures": {
    "include_generic": true,
    "parallel": true,
    "parallel_workers": 4,
    "fixture_timeout": 30
  }
}

Eigene Fixtures hinzufügen:

./staticcodeaudit-macos-arm64 /path/to/project --init-fixtures

Anschließend Dateien ablegen unter:

• custom-fixtures/vulnerable/ — Dateien, die erkannt werden sollen
• custom-fixtures/clean/ — Dateien ohne Schwachstellen

thresholds

Schwellwerte für Health-Score und CI/CD-Integration.

{
  "thresholds": {
    "max_high": 0,
    "max_medium": 10,
    "min_health": 80,
    "health_good": 90,
    "health_warning": 70
  }
}

Exit-Codes:

• 0: Audit bestanden, Schwellwerte eingehalten
• 1: Schwellwerte überschritten (HIGH-Schwachstellen oder unzureichender Score)
• 2: Fehler bei der Fixture-Validierung

sla

SLA-Konfiguration nach Schweregrad (optional).

{
  "sla": {
    "enabled": true,
    "rules": {
      "CRITICAL": { "delay": "4h", "escalation": "CTO" },
      "HIGH": { "delay": "24h", "escalation": "Tech Lead" },
      "MEDIUM": { "delay": "1 sprint", "escalation": "Team Lead" },
      "LOW": { "delay": "Backlog", "escalation": "Developer" }
    }
  }
}

retention

Konfiguration der Berichts-Aufbewahrung (optional). Steuert die automatische Bereinigung alter Berichte.

{
  "retention": {
    "mode": "both",
    "max_count": 10,
    "max_days": 90
  }
}

Modi:

• "count": Nur die N neuesten Berichte aufbewahren (max_count)
• "days": Berichte älter als N Tage löschen (max_days)
• "both": Beide Regeln anwenden (ein Bericht muss beide erfüllen, um aufbewahrt zu werden)
• null: Keine automatische Bereinigung (Standard)

Sicherheit: Mindestens ein Bericht wird stets aufbewahrt. Berichte werden in HTML+JSON-Paaren gelöscht. Verwenden Sie --retention-dry-run, um eine Vorschau der zu löschenden Dateien zu erhalten, ohne sie tatsächlich zu entfernen.

Hinweis: Die bestehende Einstellung reports.max_history steuert nur die Anzeigelimits der Diagramme — sie löscht keine Dateien. Verwenden Sie retention für die tatsächliche Dateibereinigung.

Auditkategorien

Eine vollständige Aufschlüsselung aller Regeln nach Kategorie, mit Schweregraden und zugeordneten Standards (OWASP, CWE, WCAG, ASVS, ISO 27001, NIST CSF), finden Sie in SUMMARY.md.

Berichte

Berichte werden in <project>/docs/audit-reports/ erzeugt:

docs/audit-reports/
  SCA-REPORT-2026-02-22-15-30.html    # Interaktiver HTML-Bericht
  audit-datas/
    SCA-DATA-2026-02-22-15-30.json    # JSON-Daten (Historie)

Jeder Bericht ist eine eigenständige HTML-Datei — sämtliche CSS, JavaScript, Diagramme und Favicons sind inline eingebettet (keine externen Abhängigkeiten). Öffnen Sie ihn in einem beliebigen Browser, teilen oder archivieren Sie ihn.

Der HTML-Bericht enthält:

• Projektinformationen (Name, Version, Beschreibung, UUID, Pfad)
• Audit-Parameter: Sprachen, gescannte Erweiterungen pro Sprache, include/exclude-Pfade, Kategorien
• Globaler Health-Score (logarithmisch, sicherheitsgewichtet, LOC-normiert) mit visuellem Indikator
• Aufschlüsselung nach Schweregrad (CRITICAL, HIGH, MEDIUM, LOW, INFO)
• Aufschlüsselung nach Kategorie
• Detaillierte Liste der Findings mit Quellcode
• Git-Committer-Zuordnung pro Finding (wenn --git-blame aktiviert ist)
• Vergleich mit dem vorherigen Audit (neu/behoben)
• Heatmap der problematischsten Dateien
• ISO-27001-Compliance-Matrix (Annex A, 93 Kontrollen)
• Glossar mit 36 Akronymen

CI/CD-Integration

# GitHub Actions
- name: Run Audit
  run: |
    ./staticcodeaudit-linux-x64 . --fail-on-high --sarif

# GitLab CI
audit:
  script:
    - ./staticcodeaudit-linux-x64 . --fail-on-high --sarif
  allow_failure: false

Die Binärdatei liefert einen Exit-Code ungleich Null, wenn:

• HIGH-Schwachstellen erkannt werden (--fail-on-high oder max_high: 0)
• Der Health-Score unter dem Schwellwert liegt (min_health)

Internationalisierung (i18n)

Das Audit-Werkzeug unterstützt vier Sprachen: Französisch (fr), Englisch (en), Spanisch (es) und Deutsch (de).

Zwei unabhängige Konfigurationen:

Skript-Sprache (CLI)

Die Sprache der Konsolen-Meldungen wird über die Option --script-lang konfiguriert:

# Meldungen auf Englisch (Standard)
./staticcodeaudit-macos-arm64 /path/to/project

# Meldungen auf Französisch
./staticcodeaudit-macos-arm64 /path/to/project --script-lang=fr

# Meldungen auf Spanisch
./staticcodeaudit-macos-arm64 /path/to/project --script-lang=es

# Meldungen auf Deutsch
./staticcodeaudit-macos-arm64 /path/to/project --script-lang=de

Bericht-Sprache (audit.config.json)

Die Sprache des erzeugten HTML-Berichts wird in der audit.config.json des Projekts konfiguriert:

{
  "reports": {
    "output_dir": "docs/audit-reports",
    "history_dir": "docs/audit-reports/audit-datas",
    "max_history": 10,
    "language": "es"
  }
}

Unterstützte Werte: fr (Französisch), en (Englisch), es (Spanisch), de (Deutsch)

Der Bericht zeigt im Kopf ein Sprach-Badge an (z. B. Francais, English, Espanol, Deutsch).

Fallback: Wird eine nicht unterstützte Sprache angegeben, fällt das Werkzeug automatisch auf Englisch (en) zurück.

Kombinationsbeispiele

# Skript EN + Bericht EN (Standard)
./staticcodeaudit-macos-arm64 /path/to/project

# Skript FR + Bericht EN
./staticcodeaudit-macos-arm64 /path/to/project --script-lang=fr

# Skript EN + Bericht FR ("language": "fr" in audit.config.json setzen)
./staticcodeaudit-macos-arm64 /path/to/project

# Skript FR + Bericht FR
./staticcodeaudit-macos-arm64 /path/to/project --script-lang=fr
# (mit audit.config.json, die "language": "fr" enthält)

Eigene Regeln

StaticCodeAudit ermöglicht es Ihnen, eigene Erkennungsregeln über einen interaktiven Assistenten anzulegen.

Schnellstart

./staticcodeaudit-macos-arm64 . --create-rule        # Eine eigene Regel erstellen oder bearbeiten
./staticcodeaudit-macos-arm64 . --custom-rules-match # Abdeckung prüfen (Regeln ↔ Fixtures)

Der interaktive Assistent führt Sie in 7 Schritten: 1. Name, Sprache, Kategorie, Schweregrad — mit Duplikatsprüfung (Name + Pattern) 2. Zu erkennendes Pattern (Text oder Regex) + was es neutralisiert (optional) 3. Risikobeschreibung — EN erforderlich, FR/ES/DE optional 4. Lösung — EN erforderlich, FR/ES/DE optional 5. Nutzen — optional 6. Code-Beispiel vorher/nachher (fix_before + fix_after) — optional 7. Vorschau → Validierung → Schreiben in custom-rules/{lang}/{cat}/{rule_id}.sca

Existiert bereits eine Regel mit demselben Namen, schlägt der Assistent vor, diese zu bearbeiten (mit aktuellen Werten vorausgefüllt).

Speicherort

Eigene Regeln werden im Verzeichnis custom-rules/ Ihres Projekts gespeichert (neben der Binärdatei oder im Stammverzeichnis des Projekts) und werden bei Updates der Binärdatei niemals überschrieben.

custom-rules/
  python/
    security/
      my_custom_rule.sca
  javascript/
    maintenance/
      no_legacy_api.sca

Eine vollständige Spezifikation des .sca-Formats finden Sie in CUSTOM-RULES-SPEC.md.

Lizenz-Limits

Lizenz

Kommerzielle Lizenz CodeFixture. Die Bedingungen entnehmen Sie bitte Ihrer Lizenzvereinbarung.