What it does. Deploy OpenCTI (Filigran) via Docker Compose and use the pycti Python client to model threat actors, intrusion sets, campaigns, and indicators as a STIX 2.1 knowledge graph with relationships (uses, attributed-to, targets). Use when building a centralized threat-intel knowledge base, correlating IOCs from multiple feeds into one adversary graph, or producing STIX bundles for detection engineering. Part of mukul975/Anthropic-Cybersecurity-Skills (817 security skills) (mukul975/Anthropic-Cybersecurity-Skills).

Install

• npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill modeling-threats-with-opencti, or copy the skill folder into ~/.claude/skills/modeling-threats-with-opencti/.
• Raw file: curl -sL https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/HEAD/skills/modeling-threats-with-opencti/SKILL.md

SKILL.md (verbatim)

name: modeling-threats-with-opencti
description: Deploy OpenCTI (Filigran) via Docker Compose and use the pycti Python client to model threat actors, intrusion sets, campaigns, and indicators as a STIX 2.1 knowledge graph with relationships (uses, attributed-to, targets). Use when building a centralized threat-intel knowledge base, correlating IOCs from multiple feeds into one adversary graph, or producing STIX bundles for detection engineering.
domain: cybersecurity
subdomain: threat-intelligence
tags:
- opencti
- threat-intelligence
- stix2
- pycti
- knowledge-graph
- threat-modeling
- mitre-attack
- cti
version: '1.0'
author: mahipal
license: Apache-2.0
nist_csf:
- ID.RA-03
mitre_attack:
- T1589

Modeling Threats with OpenCTI

Overview

OpenCTI (Open Cyber Threat Intelligence) is an open-source threat-intelligence platform developed by Filigran that lets analysts store, organize, visualize, and share structured cyber threat intelligence as a knowledge graph. Every object — Threat Actors, Intrusion Sets, Campaigns, Attack Patterns, Malware, Indicators, Observables, Vulnerabilities — is modeled on the STIX 2.1 standard, and the relationships between them (uses, attributed-to, targets, indicates) form a graph that reveals how adversaries operate end to end.

Architecturally, OpenCTI is built from a GraphQL API backed by Elasticsearch/OpenSearch and a graph database, a Redis stream, RabbitMQ message broker, import/export workers, and connectors. Connectors retrieve information from external sources (MITRE ATT&CK, MISP, AlienVault OTX, CISA, abuse.ch, etc.), convert it into STIX 2.1 bundles, and submit those bundles to the platform; workers then ingest the bundles into the graph. The official Python client, pycti (OpenCTIApiClient), is the programmatic interface analysts use to create entities, build relationships, and push STIX bundles.

This skill follows the official OpenCTI documentation (docs.opencti.io) and the OpenCTI-Platform/client-python (pycti) repository. It maps to MITRE ATT&CK T1589 (Gather Victim Identity Information) as part of the broader CTI analysis lifecycle — OpenCTI is where reconnaissance and adversary tradecraft observed across reporting is consolidated, deduplicated, and modeled so detection and response teams can act on it. The threat context is the volume and fragmentation of modern CTI: hundreds of vendor reports, IOC feeds, and ATT&CK updates that are useless until correlated into a single, queryable adversary picture.

When to Use

• Building a centralized, STIX-native knowledge base of threat actors, campaigns, and TTPs
• Correlating IOCs and reports from multiple feeds into a single adversary graph
• Mapping observed activity to MITRE ATT&CK techniques for coverage and gap analysis
• Producing structured intelligence (STIX bundles) for downstream detection engineering
• Tracking attribution: which intrusion sets are attributed to which threat actors and campaigns
• Automating CTI ingestion via connectors and the pycti API

Prerequisites

• Docker and Docker Compose (OpenCTI is deployed as a container stack)
• Python 3.8+ for the pycti client:

  pip install pycti stix2
  

• An OpenCTI instance and an API token (Profile > API access in the UI)
• Familiarity with the STIX 2.1 data model (SDOs, SROs, observables)
• RabbitMQ, Redis, and Elasticsearch/OpenSearch reachable by the platform (handled by the reference compose)

Objectives

• Deploy an OpenCTI platform with workers via Docker Compose
• Authenticate to the GraphQL API with pycti using an API token
• Create core STIX domain objects: Threat Actor, Intrusion Set, Campaign, Attack Pattern, Malware
• Build relationships (uses, attributed-to, targets) to form the adversary graph
• Enable connectors (MITRE ATT&CK, MISP) to auto-ingest intelligence
• Submit STIX 2.1 bundles via send_stix2_bundle
• Query the graph and export an actor's full TTP profile

MITRE ATT&CK Mapping

Workflow

Step 1: Deploy the OpenCTI platform

Use the official Docker Compose stack. Generate the required tokens/UUIDs and start the platform, workers, and dependencies.

git clone https://github.com/OpenCTI-Platform/docker.git opencti-docker
cd opencti-docker

# Generate required secrets (UUID v4 for tokens, base64 for app secret)
cat > .env <<EOF
OPENCTI_ADMIN_EMAIL=admin@opencti.local
OPENCTI_ADMIN_PASSWORD=$(openssl rand -hex 16)
OPENCTI_ADMIN_TOKEN=$(cat /proc/sys/kernel/random/uuid)
OPENCTI_BASE_URL=http://localhost:8080
MINIO_ROOT_USER=$(cat /proc/sys/kernel/random/uuid)
MINIO_ROOT_PASSWORD=$(cat /proc/sys/kernel/random/uuid)
RABBITMQ_DEFAULT_USER=guest
RABBITMQ_DEFAULT_PASS=guest
ELASTIC_MEMORY_SIZE=4G
CONNECTOR_HISTORY_ID=$(cat /proc/sys/kernel/random/uuid)
CONNECTOR_EXPORT_FILE_STIX_ID=$(cat /proc/sys/kernel/random/uuid)
EOF

# Increase vm.max_map_count for Elasticsearch, then start the stack
sudo sysctl -w vm.max_map_count=1048575
docker compose up -d

Access the UI at http://localhost:8080 and log in with the admin credentials from .env.

Step 2: Authenticate with pycti

Create an OpenCTIApiClient instance using your platform URL and API token.

from pycti import OpenCTIApiClient

opencti = OpenCTIApiClient(
    "http://localhost:8080",
    "YOUR_API_TOKEN",  # from Profile > API access, or OPENCTI_ADMIN_TOKEN
)

Step 3: Create core STIX domain objects

Create a Threat Actor, an Intrusion Set, a Campaign, and an Attack Pattern. pycti create() calls act as upserts when update=True.

# Threat Actor (group)
actor = opencti.threat_actor_group.create(
    name="APT-EXAMPLE",
    description="Financially motivated intrusion group tracked in this case.",
    threat_actor_types=["crime-syndicate"],
)

# Intrusion Set
intrusion_set = opencti.intrusion_set.create(
    name="EXAMPLE-SET",
    description="Cluster of activity sharing infrastructure and TTPs.",
)

# Campaign
campaign = opencti.campaign.create(
    name="Operation Example 2026",
    description="Spearphishing campaign targeting the finance sector.",
)

# Attack Pattern linked to MITRE ATT&CK (x_mitre_id maps to the technique)
technique = opencti.attack_pattern.create(
    name="Spearphishing Attachment",
    x_mitre_id="T1566.001",
)

Step 4: Build relationships to form the graph

Connect the objects with STIX relationships so the graph reflects how the adversary operates.

# Intrusion set attributed to the threat actor
opencti.stix_core_relationship.create(
    fromId=intrusion_set["id"],
    toId=actor["id"],
    relationship_type="attributed-to",
)

# Campaign attributed to the intrusion set
opencti.stix_core_relationship.create(
    fromId=campaign["id"],
    toId=intrusion_set["id"],
    relationship_type="attributed-to",
)

# Intrusion set uses the technique
opencti.stix_core_relationship.create(
    fromId=intrusion_set["id"],
    toId=technique["id"],
    relationship_type="uses",
)

Step 5: Add indicators and observables

Create an indicator with a STIX pattern and tie it to the intrusion set via an indicates relationship.

from dateutil.parser import parse

date = parse("2026-06-01").strftime("%Y-%m-%dT%H:%M:%SZ")

indicator = opencti.indicator.create(
    name="C2 domain for Operation Example",
    pattern_type="stix",
    pattern="[domain-name:value = 'malicious-c2.example']",
    x_opencti_main_observable_type="Domain-Name",
    valid_from=date,
)

opencti.stix_core_relationship.create(
    fromId=indicator["id"],
    toId=intrusion_set["id"],
    relationship_type="indicates",
)

Step 6: Submit a STIX 2.1 bundle directly

For bulk ingestion, build a STIX bundle and submit it with send_stix2_bundle — the recommended bulk-ingest path.

import json

with open("threat_report_bundle.json") as f:
    bundle = json.load(f)

opencti.stix2.import_bundle_from_json(
    json.dumps(bundle),
    update=True,
)

Step 7: Enable connectors for automated ingestion

Add connectors to the compose stack so external intelligence (MITRE ATT&CK, MISP) is ingested continuously. Each connector needs its own token.

# Append to docker-compose.yml under services:
  connector-mitre:
    image: opencti/connector-mitre:latest
    environment:
      - OPENCTI_URL=http://opencti:8080
      - OPENCTI_TOKEN=${CONNECTOR_MITRE_TOKEN}
      - CONNECTOR_ID=${CONNECTOR_MITRE_ID}
      - CONNECTOR_TYPE=EXTERNAL_IMPORT
      - CONNECTOR_NAME=MITRE ATT&CK
      - CONNECTOR_SCOPE=tool,report,malware,identity,attack-pattern,intrusion-set,campaign
      - MITRE_INTERVAL=7   # days
    restart: always

docker compose up -d connector-mitre

Step 8: Query the graph and export an actor profile

Read back the adversary's full picture for reporting and detection engineering.

# Resolve all techniques an intrusion set uses
iset = opencti.intrusion_set.read(filters={
    "mode": "and",
    "filters": [{"key": "name", "values": ["EXAMPLE-SET"]}],
    "filterGroups": [],
})

rels = opencti.stix_core_relationship.list(
    fromId=iset["id"],
    relationship_type="uses",
)
for r in rels:
    print(r["to"]["name"], r["to"].get("x_mitre_id"))

Tools and Resources

STIX Object Cheat Sheet (pycti entities)

Validation Criteria

• OpenCTI platform and workers deployed and reachable at the base URL
• pycti authenticates with a valid API token
• Threat Actor, Intrusion Set, Campaign, and Attack Pattern objects created
• Relationships (attributed-to, uses, indicates) built between objects
• At least one indicator created and linked to an intrusion set
• A STIX 2.1 bundle ingested via import_bundle_from_json
• MITRE ATT&CK connector enabled and importing techniques
• Intrusion-set TTP profile queryable and exportable

Other files in this skill

• LICENSE
• references/api-reference.md
• references/standards.md
• scripts/agent.py

references/api-reference.md (verbatim)

API Reference — OpenCTI / pycti

Client initialization

from pycti import OpenCTIApiClient
opencti = OpenCTIApiClient("http://localhost:8080", "API_TOKEN")

Core entity creators (upsert with update=True)

Relationships

opencti.stix_core_relationship.create(
    fromId=..., toId=..., relationship_type="uses")

Reading / listing

Bundle ingestion

Connector environment variables (compose)

Deployment quick reference

references/standards.md (verbatim)

Standards Mapping — Modeling Threats with OpenCTI

MITRE ATT&CK

NIST Cybersecurity Framework (CSF 2.0)

Supporting References

• OpenCTI documentation: https://docs.opencti.io/latest/
• pycti Python client: https://github.com/OpenCTI-Platform/client-python
• OpenCTI connectors library: https://github.com/OpenCTI-Platform/connectors
• OpenCTI Docker deployment: https://github.com/OpenCTI-Platform/docker
• OASIS STIX 2.1 specification: https://oasis-open.github.io/cti-documentation/
• MITRE ATT&CK: https://attack.mitre.org/

Back to mukul975/Anthropic-Cybersecurity-Skills (817 security skills) or Agent skills.