control "Guards" {
  description = "Trained guards patrol tower"
  risk_reduction = 75
}

Siehe [Data Flow Diagram](#data-flow-diagram) für weitere Informationen zum Erstellen von Datenflussdiagrammen, die automatisch in PNGs konvertiert werden können.

Ein Beispiel, wie auf vordefinierte Steuerungsbibliotheken für die [OWASP Proactive Controls](https://owasp.org/www-project-proactive-controls/) und die [AWS Security Checklist](https://d1.awsstatic.com/whitepapers/Security/AWS_Security_Checklist.pdf) verwiesen wird, finden Sie in [examples/tm3.hcl](https://github.com/threatcl/threatcl/blob/HEAD/examples/tm3.hcl). Wir haben auch die [MITRE ATT&CK Controls](https://attack.mitre.org/mitigations/enterprise/) [hier](https://github.com/threatcl/threatcl/blob/HEAD/examples/MITRE_ATTACK_controls.hcl).

Sie können auch ein externes Bedrohungsmodell in Ihr eigenes einbinden, um auf all seine Informationen zuzugreifen und sie zu nutzen. Ein Beispiel finden Sie in [examples/including-example/corp-app.hcl](https://github.com/threatcl/threatcl/blob/HEAD/examples/including-example/corp-app.hcl).

Eine vollständige Beschreibung der Spezifikation finden Sie [hier](https://github.com/threatcl/threatcl/blob/HEAD/spec.hcl) oder führen Sie Folgendes aus:```bash
threatcl generate boilerplate

## Mit Docker ausführen```bash
docker run --rm -it ghcr.io/threatcl/threatcl:latest

Überprüfen Sie das Container-Image (der Tag wird automatisch zu seinem Digest aufgelöst):```bash
gh attestation verify oci://ghcr.io/threatcl/threatcl:<version> --repo threatcl/threatcl

Siehe [docs/SLSA.md](https://github.com/threatcl/threatcl/blob/HEAD/docs/SLSA.md) für die vollständige Lieferketten-Position.

## Ausführen mit GitHub Actions

`threatcl` kann direkt in Ihre GitHub-Repos integriert werden mit https://github.com/threatcl/threatcl-action. Dies ist eine der idealen Methoden, um Ihre Bedrohungsmodelle zu verwalten, und hilft, das Ziel der Integration in Ihre Versionskontrollsysteme zu erreichen.

## Erstellen aus dem Quellcode

1. Klonen Sie dieses Repository.
2. Wechseln Sie in das Verzeichnis `threatcl`
3. `make bootstrap`
4. `make build`

Für weitere Hilfe zum Beitragen zu `threatcl` siehe die [CHANGELOG.md](https://github.com/threatcl/threatcl/blob/HEAD/CHANGELOG.md).

## Verwendung

Für Hilfe zu Unterbefehlen verwenden Sie das Flag `-h`.```bash
$ threatcl
Usage: threatcl [--version] [--help] <command> [<args>]

Available commands are:
    cloud        Interact with ThreatCL Cloud services
    dashboard    Generate markdown files from existing HCL threatmodel file(s)
    dfd          Generate Data Flow Diagram PNG or DOT files from existing HCL threatmodel file(s)
    export       Export threat models into other formats
    generate     Generate an HCL Threat Model
    list         List Threatmodels found in HCL file(s)
    mcp          Model Context Protocol (MCP) server for threatcl
    mermaid      Output raw mermaid source from 'mermaid' blocks in existing HCL threatmodel file(s)
    query        Execute GraphQL queries against threat model data
    server       Start a GraphQL API server for threat models
    terraform    Parse output from 'terraform show -json'
    validate     Validate existing HCL Threatmodel file(s)
    view         View existing HCL Threatmodel file(s)

Wenn Sie diese Attribute ändern, müssen Sie daran denken, die Konfigurationsdatei für andere Vorgänge bereitzustellen, da dies die Validierung oder die Dashboard-Erstellung beeinträchtigen kann.

## Cloud-Befehle

Besuchen Sie https://threatcl.dev/cloud/overview/, um mehr über die Unterbefehle von `cloud` zu erfahren.

## Auflisten und Anzeigen

Die Befehle `threatcl list` und `threatcl view` können verwendet werden, um Daten aus HCL-Dateien der `threatcl`-Spezifikation aufzulisten und anzuzeigen.```bash
$ threatcl list examples/*
#  File              Threatmodel      Author
1  examples/tm1.hcl  Tower of London  @xntrik
2  examples/tm1.hcl  Fort Knox        @xntrik
3  examples/tm2.hcl  Modelly model    @xntrik

### Invariants

`threatcl validate` kann auch organisationsweite Invarianten durchsetzen – maschinell geprüfte Regeln wie „keine öffentlichen Endpunkte sollten ohne Authentifizierung sein“ oder „alle internetfähigen Funktionen müssen Audit-Logging dokumentieren“ – für jedes validierte Bedrohungsmodell:```bash
$ threatcl validate -invariants=invariants.hcl ./models/
Validated 4 threatmodels in 3 files
Invariant violation [error] 'threats_have_implemented_controls': threat 'Credential theft' in threatmodel 'Payments' (models/payments.hcl): Every threat must have at least one implemented control
Checked 3 invariants against 4 threatmodels: 1 errors, 0 warnings, 1 exemptions

## Generate

Der Befehl `threatcl generate` wird verwendet, um entweder eine generische `boilerplate`-Datei für die `threatcl`-Spezifikation im HCL-Format auszugeben oder interaktiv Fragen an den Benutzer zu stellen, um dann eine `threatcl`-Spezifikations-HCL-Datei auszugeben.

### Generate Interactive

Siehe folgendes Beispiel von:```bash
threatcl generate interactive

Dies öffnet Ihren Editor mit einem rudimentären HCL-Bedrohungsmodell. Wenn Sie das Modell nach der Erstellung validieren möchten, verwenden Sie das Flag `-validate`.

## MCP

Der Befehl `threatcl mcp` startet einen lokalen [MCP](https://modelcontextprotocol.io/introduction)-Server, sodass Sie über einen MCP-Host mit threatcl-HCL-Dateien interagieren können, z. B. über KI/LLM-Anwendungen wie [Claude Desktop](https://claude.ai/download), [Cursor](https://www.cursor.com/) oder andere Anwendungen, die MCP unterstützen.

Der Befehl akzeptiert ein optionales Argument, `-dir=<Pfad>`, das zusätzlichen MCP-Tools ermöglicht, mit Dateien innerhalb dieses Pfades zu interagieren. Ohne diese Einstellung können die MCP-Tools mit Zeichenketten interagieren, verlassen sich jedoch auf andere Mechanismen innerhalb des MCP-Hosts, um mit dem zugrunde liegenden Dateisystem zu interagieren.

Es ist fair zu sagen, dass diese Funktionalität derzeit noch ziemlich experimentell ist.

## LSP (Language Server)

Der Befehl `threatcl lsp` startet einen [Language Server Protocol](https://microsoft.github.io/language-server-protocol/)-Server über stdio und bietet LSP-fähigen Editoren Live-Diagnosen, Vervollständigung, Hover-, Dokumentensymbole- und Formatierungsfunktionen für threatcl-HCL-Bedrohungsmodelle.

Er wird vom LSP-Client Ihres Editors gestartet und nicht von Hand ausgeführt. Da threatcl-Dateien die Erweiterung `.hcl` mit Terraform und anderen HCL-Dialekten teilen, vermeidet die Übereinstimmung mit `*.tm.hcl` (oder die Beschränkung des Clients auf Ihren Bedrohungsmodell-Arbeitsbereich) Konflikte mit einem Terraform-Sprachserver.

Siehe [docs/lsp.md](https://github.com/threatcl/threatcl/blob/HEAD/docs/lsp.md) für die Einrichtung in Editoren (Neovim, Helix, VS Code, Zed) und aktuelle Einschränkungen.

## Server (GraphQL-API)

Der Befehl `threatcl server` startet einen GraphQL-API-Server, der Ihre Bedrohungsmodelle über HTTP zur programmatischen Abfrage und Integration bereitstellt.

### Grundlegende Nutzung```bash
# Start the server
$ threatcl server -dir ./examples

# With file watching for auto-reload
$ threatcl server -dir ./examples -watch

# Custom port
$ threatcl server -dir ./examples -port 3000

### Dokumentation

Für die vollständige API-Dokumentation, das Schema-Referenz, erweiterte Abfragen und Integrationsbeispiele siehe:
- **Vollständige API-Dokumentation**: [docs/graphql-api.md](https://github.com/threatcl/threatcl/blob/HEAD/docs/graphql-api.md)
- **Abfragebeispiele**: [examples/graphql-queries.md](https://github.com/threatcl/threatcl/blob/HEAD/examples/graphql-queries.md)

## Abfrage (GraphQL CLI)

Der Befehl `threatcl query` führt GraphQL-Abfragen direkt von der Kommandozeile aus, ohne einen Server zu starten. Dies ist ideal für Automatisierung, CI/CD-Pipelines und Shell-Scripting.

### Grundlegende Verwendung```bash
# Get statistics
$ threatcl query -dir ./examples -query '{ stats { totalThreats } }'

# Query from file
$ threatcl query -dir ./examples -file queries/get-stats.graphql

# Use in scripts
$ THREATS=$(threatcl query -dir ./examples \
    -query '{ stats { totalThreats } }' \
    -output compact | jq -r '.data.stats.totalThreats')
$ echo "Found $THREATS threats"

### CI/CD-Beispiel```bash
#!/bin/bash
# Check if all controls are implemented before deployment

UNIMPLEMENTED=$(threatcl query -dir ./threatmodels \
  -query '{ stats { totalControls implementedControls } }' \
  -output compact | jq -r '.data.stats.totalControls - .data.stats.implementedControls')

if [ "$UNIMPLEMENTED" -gt 0 ]; then
  echo "ERROR: $UNIMPLEMENTED controls are not yet implemented"
  exit 1
fi

echo "All controls implemented, proceeding with deployment"

### Benutzerdefinierte Markdown-Vorlagen

Der Befehl `threatcl dashboard` kann auch optionale Flags verwenden, um benutzerdefinierte Vorlagen anzugeben (gemäß Golangs [text/template](https://pkg.go.dev/text/template)).

Um eine Dashboard-Vorlagendatei anzugeben, verwenden Sie das Flag `-dashboard-template`. Ein Beispiel finden Sie unter [dashboard-template.tpl](https://github.com/threatcl/threatcl/blob/HEAD/examples/dashboard-template.tpl).

Um eine Threatmodel-Vorlagendatei anzugeben, verwenden Sie das Flag `-threatmodel-template`. Ein Beispiel finden Sie unter [threatmodel-template.tpl](https://github.com/threatcl/threatcl/blob/HEAD/examples/threatmodel-template.tpl).

### Benutzerdefinierter Dateiname für die Dashboard-Indexdatei

Der Befehl `threatcl dashboard` kann auch ein optionales Flag verwenden, um einen Dateinamen für die generierte Dashboard-Indexdatei anzugeben. Standardmäßig ist diese Datei `dashboard.md`. Verwenden Sie das Flag `-dashboard-filename` ohne Erweiterung, um diesen Dateinamen zu ändern.

## Datenflussdiagramm

Gemäß der [Spezifikation](https://github.com/threatcl/threatcl/blob/HEAD/spec.hcl) kann ein `threatmodel` `data_flow_diagram_v2`-Blöcke enthalten. Ein Beispiel für ein einfaches DFD ist [hier](https://github.com/threatcl/threatcl/blob/HEAD/examples/tm2.hcl) verfügbar. Der alte, einmalig verwendbare Block `data_flow_diagram` wird irgendwann veraltet sein, daher ist es besser, benannte Blöcke von `data_flow_diagram_v2` zu verwenden, damit Sie mehrere zugehörige DFDs haben können.

Der Befehl `threatcl dfd` nimmt `threatcl`-Spezifikations-HCL-Dateien entgegen und generiert mehrere PNG-Dateien, die in einem ausgewählten Ordner abgelegt werden.

Wenn die HCL-Datei keinen `threatmodel`-Block mit einem `data_flow_diagram`- oder `data_flow_diagram_v2`-Block enthält, wird nichts ausgegeben.

Der Befehl selbst ist dem Dashboard-Befehl sehr ähnlich.```bash
$ threatcl dfd -overwrite -outdir testout examples/*
Successfully created 'testout/tm2-modellymodel.png'

Dies erleichtert die Weiterleitung an einen Renderer wie [mermaid-cli](https://github.com/mermaid-js/mermaid-cli):```bash
$ threatcl mermaid model.hcl | mmdc -o diagram.svg -i -

## Terraform

Der Befehl `threatcl terraform` ist in der Lage, Datenressourcen aus der Ausgabe von `terraform show -json` [Dokumentation hier](https://www.terraform.io/docs/cli/commands/show.html) von Plan-Dateien oder aktiven Zustandsdateien zu extrahieren und diese in entworfene `information_asset`-Blöcke zur Aufnahme in `threatcl`-Dateien umzuwandeln.

Wenn Sie sich in einem Ordner mit vorhandenem Zustand befinden, können Sie Folgendes ausführen:```bash
terraform show -json | threatcl terraform -stdin

Sie können auch eine ähnliche Ausgabe aus einer Plan-Datei sehen, die noch nicht mit Terraform angewendet wurde, indem Sie Folgendes ausführen:```bash
terraform show -json <plan-file> | threatcl terraform -stdin

Mit dem `-add-to-existing`-Flag können Sie auch `-tm-name=<string>` angeben, wenn Sie ein bestimmtes Bedrohungsmodell aus der Quelldatei angeben müssen, falls mehrere vorhanden sind. Sie können auch eine Standardklassifizierung mit dem `-default-classification=Confidential`-Flag anwenden.

Diese Befehle können auch eine Datei als Eingabe akzeptieren, in diesem Fall lassen Sie das `-stdin`-Flag weg.

Die Terraform-Ressourcen, die `threatcl` kennt, sind in [pkg/terraform/terraform.go](https://github.com/threatcl/threatcl/blob/HEAD/pkg/terraform/terraform.go) fest codiert. Wenn Sie möchten, dass der Befehl `threatcl terraform` andere `information_asset`-Ressourcen ausgibt, die nicht dort enthalten sind, können Sie Ihre eigene Version dieser JSON-Datei über das `-tf-collection=<json file>`-Flag bereitstellen.