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

Consulte el [Diagrama de flujo de datos](#data-flow-diagram) para obtener más información sobre cómo construir diagramas de flujo de datos que puedan convertirse automáticamente a PNG.

Para ver un ejemplo de cómo hacer referencia a bibliotecas de control predefinidas para los [Controles Proactivos de OWASP](https://owasp.org/www-project-proactive-controls/) y la [Lista de Verificación de Seguridad de AWS](https://d1.awsstatic.com/whitepapers/Security/AWS_Security_Checklist.pdf), consulte [examples/tm3.hcl](https://github.com/threatcl/threatcl/blob/HEAD/examples/tm3.hcl). También tenemos los [Controles MITRE ATT&CK](https://attack.mitre.org/mitigations/enterprise/) [aquí](https://github.com/threatcl/threatcl/blob/HEAD/examples/MITRE_ATTACK_controls.hcl).

También puede incluir un modelo de amenazas externo en el suyo propio, para hacer referencia y utilizar toda su información. Puede ver [examples/including-example/corp-app.hcl](https://github.com/threatcl/threatcl/blob/HEAD/examples/including-example/corp-app.hcl) como un ejemplo.

Para ver una descripción completa de la especificación, consulte [aquí](https://github.com/threatcl/threatcl/blob/HEAD/spec.hcl) o ejecute:```bash
threatcl generate boilerplate

## Ejecutar con Docker```bash
docker run --rm -it ghcr.io/threatcl/threatcl:latest

Verifica la imagen del contenedor (la etiqueta se resuelve automáticamente a su digest):```bash
gh attestation verify oci://ghcr.io/threatcl/threatcl:<version> --repo threatcl/threatcl

Consulte [docs/SLSA.md](https://github.com/threatcl/threatcl/blob/HEAD/docs/SLSA.md) para conocer la postura completa de la cadena de suministro.

## Ejecutar con GitHub Actions

`threatcl` se puede integrar directamente en tus repositorios de GitHub con https://github.com/threatcl/threatcl-action. Este es uno de los métodos ideales para gestionar tus modelos de amenazas y ayuda a cumplir el objetivo de integrarse en tus sistemas de control de versiones.

## Compilar desde el código fuente

1. Clona este repositorio.
2. Cambia al directorio `threatcl`
3. `make bootstrap`
4. `make build`

Para obtener más ayuda sobre cómo contribuir a `threatcl`, consulta [CHANGELOG.md](https://github.com/threatcl/threatcl/blob/HEAD/CHANGELOG.md).

## Uso

Para obtener ayuda sobre cualquier subcomando, usa el 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)

Si modificas estos atributos, deberás recordar proporcionar el archivo de configuración para otras operaciones, ya que esto puede afectar la validación o la creación del panel de control.

## Comandos de Cloud

Visita https://threatcl.dev/cloud/overview/ para obtener más información sobre los subcomandos `cloud`.

## List y View

Los comandos `threatcl list` y `threatcl view` se pueden usar para listar y ver datos de archivos HCL de especificación `threatcl`.```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` también puede hacer cumplir invariantes a nivel de organización — reglas verificadas por máquina como "ningún endpoint público debe ser no autenticado" o "todas las funciones expuestas a internet deben documentar el registro de auditoría" — contra cada modelo de amenaza validado:```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

El comando `threatcl generate` se utiliza para generar un archivo HCL de especificación `threatcl` `boilerplate` genérico, o bien, para preguntar interactivamente al usuario preguntas y luego generar un archivo HCL de especificación `threatcl`.

### Generate Interactive

Vea el siguiente ejemplo de:```bash
threatcl generate interactive

Esto abrirá tu editor con un modelo de amenazas HCL básico. Si deseas validar el modelo después de crearlo, usa la bandera `-validate`.

## MCP

El comando `threatcl mcp` expone un servidor [MCP](https://modelcontextprotocol.io/introduction) local para que puedas interactuar con archivos HCL de threatcl a través de un host MCP, por ejemplo aplicaciones de IA/LLM como [Claude Desktop](https://claude.ai/download), [Cursor](https://www.cursor.com/) o cualquier otra aplicación que soporte MCP.

El comando acepta un argumento opcional, `-dir=<ruta>`, que permite que las herramientas MCP adicionales interactúen con archivos dentro de esa ruta. Sin esta configuración, las herramientas MCP pueden interactuar con cadenas, pero dependerán de otros mecanismos dentro del host MCP para interactuar con el sistema de archivos subyacente.

Es justo decir que esta funcionalidad está bastante en beta en este momento.

## LSP (Servidor de Lenguaje)

El comando `threatcl lsp` ejecuta un servidor del [Protocolo de Servidor de Lenguaje](https://microsoft.github.io/language-server-protocol/) sobre stdio, proporcionando a los editores con capacidad LSP diagnósticos en vivo, autocompletado, información al pasar el cursor, símbolos del documento y formato para modelos de amenazas HCL de threatcl.

Lo lanza el cliente LSP de tu editor, no se ejecuta manualmente. Debido a que los archivos de threatcl comparten la extensión `.hcl` con Terraform y otros dialectos HCL, hacer coincidir `*.tm.hcl` (o delimitar el cliente a tu espacio de trabajo de modelos de amenazas) evita conflictos con un servidor de lenguaje de Terraform.

Consulta [docs/lsp.md](https://github.com/threatcl/threatcl/blob/HEAD/docs/lsp.md) para la configuración del editor (Neovim, Helix, VS Code, Zed) y las limitaciones actuales.

## Servidor (API GraphQL)

El comando `threatcl server` inicia un servidor de API GraphQL que expone tus modelos de amenazas a través de HTTP para consultas programáticas e integración.

### Uso Básico```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

### Documentación

Para obtener la documentación completa de la API, la referencia del esquema, consultas avanzadas y ejemplos de integración, consulte:
- **Documentación completa de la API**: [docs/graphql-api.md](https://github.com/threatcl/threatcl/blob/HEAD/docs/graphql-api.md)
- **Ejemplos de consultas**: [examples/graphql-queries.md](https://github.com/threatcl/threatcl/blob/HEAD/examples/graphql-queries.md)

## Consulta (CLI de GraphQL)

El comando `threatcl query` ejecuta consultas GraphQL directamente desde la línea de comandos sin iniciar un servidor. Esto es ideal para automatización, pipelines de CI/CD y scripting de shell.

### Uso básico```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"

### Ejemplo de CI/CD```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"

### Plantillas Markdown Personalizadas

El comando `threatcl dashboard` también puede tomar flags opcionales para especificar plantillas personalizadas (según el [text/template](https://pkg.go.dev/text/template) de Golang).

Para especificar un archivo de plantilla de dashboard, use la bandera `-dashboard-template`. Para un ejemplo, vea [dashboard-template.tpl](https://github.com/threatcl/threatcl/blob/HEAD/examples/dashboard-template.tpl).

Para especificar un archivo de plantilla de threatmodel, use la bandera `-threatmodel-template`. Para un ejemplo, vea [threatmodel-template.tpl](https://github.com/threatcl/threatcl/blob/HEAD/examples/threatmodel-template.tpl).

### Nombre de Archivo Personalizado para el Archivo de Índice del Dashboard

El comando `threatcl dashboard` también puede tomar una bandera opcional para especificar un nombre de archivo para el archivo de dashboard generado "index". Por defecto este archivo es `dashboard.md`. Use la bandera `-dashboard-filename` sin extensión para cambiar este nombre de archivo.

## Diagrama de Flujo de Datos

Según la [especificación](https://github.com/threatcl/threatcl/blob/HEAD/spec.hcl), un `threatmodel` puede incluir bloques `data_flow_diagram_v2`. Un ejemplo de un DFD simple está disponible [aquí](https://github.com/threatcl/threatcl/blob/HEAD/examples/tm2.hcl). El antiguo bloque de un solo uso `data_flow_diagram` será obsoleto en algún momento, por lo que es mejor usar bloques nombrados `data_flow_diagram_v2`, de esa manera puede tener múltiples DFDs asociados.

El comando `threatcl dfd` toma archivos HCL de especificación `threatcl`, y genera varios archivos png, colocándolos en una carpeta seleccionada.

Si el archivo HCL no incluye un bloque `threatmodel` con un bloque `data_flow_diagram` o `data_flow_diagram_v2`, entonces no se genera nada.

El comando en sí es muy similar al comando Dashboard.```bash
$ threatcl dfd -overwrite -outdir testout examples/*
Successfully created 'testout/tm2-modellymodel.png'

Esto facilita hacer pipe hacia un renderizador como [mermaid-cli](https://github.com/mermaid-js/mermaid-cli):```bash
$ threatcl mermaid model.hcl | mmdc -o diagram.svg -i -

## Terraform

El comando `threatcl terraform` es capaz de extraer recursos de datos de la salida `terraform show -json` [documentación aquí](https://www.terraform.io/docs/cli/commands/show.html) de archivos de plan, o archivos de estado activos, y convertirlos en bloques `information_asset` redactados para su inclusión en archivos `threatcl`.

Si te encuentras en una carpeta con un estado existente, puedes ejecutar lo siguiente:```bash
terraform show -json | threatcl terraform -stdin

También puedes ver una salida similar de un archivo de plan que aún no se ha aplicado con Terraform ejecutando:```bash
terraform show -json <plan-file> | threatcl terraform -stdin

Con la bandera `-add-to-existing`, también puede especificar `-tm-name=<string>` si necesita especificar un modelo de amenaza particular del archivo fuente, si hay varios. Y también puede aplicar una clasificación predeterminada, con la bandera `-default-classification=Confidential`.

Estos comandos también pueden aceptar un archivo como entrada, en cuyo caso, omita la bandera `-stdin`.

Los recursos de terraform que `threatcl` conoce están codificados en [pkg/terraform/terraform.go](https://github.com/threatcl/threatcl/blob/HEAD/pkg/terraform/terraform.go). Si desea que el comando `threatcl terraform` genere otros recursos `information_asset` que no están allí, puede proporcionar su propia versión de este json a través de la bandera `-tf-collection=<json file>`.