How yeti-platform/yeti works
Based on our analysis of the file tree and README, Yeti Platform is a CTI/DFIR intelligence platform whose primary purpose is to store and correlate threat intelligence data (observables, TTPs, etc.), provide powerful search and enrichment capabilities over that data, and deliver results both via a web API and a web UI. The project is clearly highly modular, supporting plugins, contributors, and external data source integrations.
Main Components
• API & Web Interface – Represented mainly by the “core/web” folder. This includes:
• RESTful endpoints under “apiv2” (modules such as auth, audit, entities, indicators, observables, etc.)
• The web frontend (core/web/frontend) that provides the UI.
• Core Business Logic – Found in the “core” directory:
• Business and orchestration modules (core/helpers.py, core/interfaces.py, core/logger.py)
• Database interactions (core/database_arango.py, migrations)
• Schema definitions and entities (core/schemas) for handling CTI objects (attack patterns, malware, intrusion sets, etc.)
• Event processing and messaging (core/events, with producer and consumer components)
• Task management and scheduling (core/taskmanager.py, core/taskscheduler.py)
• Storage & External Resources – Under “core/clients/file_storage” you see support for both local and S3 storage.
• Plugin Architecture – With directories like “plugins/analytics”, “plugins/events”, “plugins/feeds”, and “plugins/inline”. These extend core functionality, providing:
• Additional analytics integrations
• Data feeds from external threat intelligence sources
• Custom event processing logic
• Contrib Integrations – The “contrib” folder includes third-party integrations (such as IVRE API in analytics and multiple feeds integrations) that can be seen as external plug-ins or connectors.
• Configuration and Dependencies – The “core/config” and various configuration files (e.g., yeti.conf.sample, .pylintrc) support environmental configuration and operational parameters.
• DevOps & Deployment – Notably, the “extras/docker” directory and GitHub workflows indicate a containerized deployment and CI/CD setup.
Relationships and Data Flow
• The Web API layer (REST endpoints) interacts with the core business logic to process incoming queries. Commands and data flow from the API layer to core modules that perform validations, business rules checks, and orchestrate tasks.
• The Event Bus (via core/events producer/consumer) facilitates asynchronous notifications and triggers internal actions (such as audit log writing, task scheduling, etc.).
• The plugin system sits on top of or alongside core components, allowing public and private plugins to intercept, extend, or add new processing capabilities (for instance, analytics or feed ingestion). These might be connected via clearly defined interfaces.
• File storage clients (local storage or S3) are used by the system when handling file persistence for artifacts or exported data.
• External sources (contrib integrations and plugins for feeds) import CTI data which is then normalized, stored, and made available via the API.
Important Architectural Patterns & Design Principles
• Modular and Extensible Architecture – The clear separation between “core”, “plugins”, and “contrib” enables adding or modifying features without disrupting the core application.
• API-Driven Design – The “core/web/apiv2” indicates a RESTful design to allow integration with incident management systems, DFIR applications, and external enrichment tools.
• Event-Driven & Task Scheduling – With components for event production/consumption and task management, the design supports asynchronous processing and scheduling.
• Separation of Concerns – Different directories and layered components (data storage, business logic, API, plugins) ensure maintainability and robustness.