RedOps Vault

Self-hosted engagement tracker for red team operators. Centralizes what a team collects during an assessment — encrypted loot and credentials, infrastructure/network mapping, ATT&CK-mapped findings, and kill chain activity (Lockheed Martin or Unified Kill Chain) — and exports a client-ready report. Engagements move through a Kanban board (Backlog → Planning → Active → Completed); access is role-based (operator full access, admin also manages users).

No CDN dependencies, no telemetry. Built with Flask, Postgres, and Bootstrap 5.

Screenshots

Engagements board	Engagement overview
Kill chain timeline	Attack map — replays the kill chain across target infrastructure
Findings	Credentials — with live TOTP codes
Targets & victims	ATT&CK matrix — live-synced from MITRE
Kill chain report — client-ready HTML/PDF export	Threat model & attack plan
Loot — encrypted file storage	IOCs
Agent scaffolding — ready-to-paste system prompt for an AI agent to drive an engagement	Operator CLI — every domain above, from the terminal (see Operator CLI)

Features

• Loot & credentials — files and structured credential records, encrypted at rest with AES-256-GCM, loot stored as streamed Postgres Large Objects (up to 4 TB each).
• MITRE ATT&CK — live-synced Enterprise matrix; map any loot file or kill chain entry to a technique.
• Kill chain tracking — Lockheed Martin or Unified Kill Chain, chosen per engagement; export as an HTML or PDF report.
• Findings — severity, remediation, rich-text editor, exports to clean Markdown.
• Infrastructure & network map — attacker infrastructure and target assets as an interactive graph, with a timeline scrubber and PNG export.
• Agent scaffolding — generates a ready-to-paste system prompt so an AI agent can drive an engagement via the MCP server.
• Backup & restore — scheduled or on-demand backups to S3-compatible storage, Azure, GCP, or SFTP; browse and restore from any configured destination (admin-only).
• API, CLI & MCP server — a Bearer-token JSON API at /api/v1, a terminal CLI (redops.py), and an MCP server for AI agent access. See Operator CLI and MCP server.

Setup with Docker Compose

Docker Compose builds the app image and runs the app and Postgres together.

cp .env.example .env
openssl rand -hex 32
docker compose up --build -d

Before starting Compose, put independently generated values from the command above into SECRET_KEY and JWT_SECRET_KEY in .env. Also change the Postgres password for any non-local deployment. Set JWT_COOKIE_SECURE=true when serving over HTTPS in production.

Migrations run automatically on startup. Visit http://localhost:5000 and create the first admin account via the setup wizard. The app runs under a dedicated non-root user, and the postgres_data and app_instance volumes persist database data and the encryption key respectively.

The app generates instance/encryption.key on first boot, used to encrypt loot and credential fields. Back up the app_instance volume alongside Postgres — losing it makes existing loot/credentials unrecoverable.

To run the app directly on the host for development, install Python 3.11+, install requirements.txt, start only Postgres with docker compose up -d postgres, and run python app.py. The DATABASE_URL in .env.example points at that host-exposed Postgres port.

Migrating from an old SQLite-based install? See scripts/migrate_sqlite_to_postgres.py.

Running tests

pip install pytest
pytest

Tests run against a temporary SQLite database — no Postgres required.

Operator CLI

cli/ is a terminal alternative to the web UI, built on the same /api/v1 API as the MCP server, covering every operator-facing domain except Admin and Backups (web-only).

pip install -r requirements.txt
python redops.py config set-key rov_...
python redops.py config test

python redops.py engagement list
python redops.py finding create -e 3 --title "SQL Injection" --severity high --details "Found in login form."
python redops.py loot upload -e 3 ./screenshot.png --category screenshot
python redops.py killchain report -e 3 --pdf -o report.pdf

Get an API key from /api-keys as an agent/operator/admin user. Every resource follows <noun> <list|create|get|update|delete>; add --json for scripting. Run python redops.py <resource> --help for full options. Access mirrors the API key's owning user — blueteam keys are read-only, restricted to assigned engagements.

MCP server (AI agent access)

mcp_server/ exposes the same /api/v1 API as MCP tools, so an AI agent can drive engagements directly — create/update, log findings, upload/ download loot, record kill chain activity and infrastructure, manage credentials and the task checklist, map ATT&CK techniques. Admin and Backups are intentionally excluded.

pip install -r requirements.txt
export REDOPS_API_KEY=rov_...
python mcp_server/server.py

Create the key at /api-keys as a dedicated agent-role user (or reuse an existing operator/admin). This repo ships a project-level .mcp.json for Claude Code — export REDOPS_API_KEY and (re)start Claude Code from this directory to pick up the redops-vault tools automatically. For other clients, add an equivalent server entry using the same command/env.

Loot tools take a local file path rather than embedding bytes, resolved on whichever machine runs mcp_server/server.py. Treat an API key like a password — revoke it at /api-keys if exposed.

Notes on the ATT&CK sync

Admin > Refresh from MITRE fetches the current Enterprise ATT&CK bundle from MITRE's public GitHub repo at request time — no bundled offline copy, so it requires outbound internet access. For air-gapped installs, mirror enterprise-attack.json and point MITRE_ATTACK_URL in config.py at it.

Security notes

• Loot and credential fields are encrypted at rest (AES-256-GCM); the key at instance/encryption.key needs the same protection as any secret.
• Deactivating a user or changing their role takes effect immediately, even on an already-issued session.
• This is a small-team tool with no per-engagement access control: any authenticated operator or admin can see every engagement.
• A full-vault restore wipes and replaces the entire database from the archive, including users and API keys — it's a point-in-time restore, not a merge. instance/encryption.key must match between backup and restore for loot/credential data to stay decryptable.

Contributing

Issues and PRs are welcome, including AI-assisted ones — see CONTRIBUTING.md for the ground rules (in particular, every operator-facing feature is expected to stay in sync across the web UI, JSON API, MCP server, and CLI — read that before wiring up a new feature). Security vulnerabilities should be reported privately per SECURITY.md, not as a public issue. This project follows the Code of Conduct.

License

Copyright 2026 FalconSpy.

Licensed under the Apache License, Version 2.0. Third-party assets vendored under app/static/vendor/ (Bootstrap, Cytoscape, dagre, cytoscape-dagre, G6) keep their own original MIT licenses — see THIRD_PARTY_LICENSES.md.