TheHive: Open-Source Case Management
TheHive is the most widely deployed open-source IR case management platform — free to run, highly extensible via Cortex analyzers, and purpose-built for the alert-to-case workflow that defines SOC operations.
A medium-sized security team has been tracking incidents in a shared Jira board and a Google Sheet for IOCs. The Jira board is a graveyard of old tickets with no standard structure. The IOC sheet has hundreds of rows that nobody maintains. When a new incident comes in, analysts spend 15 minutes searching through old tickets to see if the IP or domain appeared before. There's no way to link alerts to cases to observables. Reporting to the CISO requires manually pulling data from three systems. The team needs a purpose-built case management system and has no budget for a commercial platform. This chapter explains how TheHive works and how to get useful value from it quickly.
TheHive Architecture and Components
TheHive is a case management platform designed specifically for security operations. It handles the full alert-to-case-to-close workflow and integrates with Cortex — a separate but companion tool — for automated artifact analysis. Understanding the component relationships is necessary before deployment.
TheHive Ecosystem
══════════════════════════════════════════════════════════════════════
Alert Sources ──────────────────────────────────┐
EDR platform (webhook) │
SIEM (alert API) │
Email (IMAP connector for phishing inbox) │
SOAR platform (TheHive integration) │
Manual analyst entry ▼
┌──────────┐
Alerts ──────▶ │ │
│ TheHive │◀──── Analyst
Cases ────────▶ │ │ interface
│ │
Tasks ────────▶ │ │
│ │
Observables ──▶ │ │──────▶ Reports
(IPs, hashes, └────┬─────┘ Metrics
domains, │ IOC export
files) │
▼ Observables
┌──────────────┐
│ Cortex │
│ Analyzers │
│ │
│ VirusTotal │
│ Shodan │
│ MISP │
│ AbuseIPDB │
│ (100+ more) │
└──────────────┘
Results flow back
to TheHive observable
MISP (Malware Information Sharing Platform):
Optional third component — threat intel database
Bidirectional: push IOCs from TheHive to MISP;
pull threat intel from MISP to enrich TheHive observables
TheHive Data Model: Alerts, Cases, Tasks, Observables
Understanding the data model before configuring TheHive prevents the most common implementation mistake: treating every alert as a case, which produces thousands of single-event cases with no meaningful grouping. TheHive's data model is designed around the distinction between an alert (an event that may need investigation) and a case (a confirmed investigation with scope, tasks, and timeline).
| Object type | What it represents | Key fields | Workflow position |
|---|---|---|---|
| Alert | A raw event or detection from a source system that may or may not need investigation | Source, type, severity, observables, description, status (New/Acknowledged/Ignored/Imported) | Entry point — all incoming events land here first; analyst triages and either ignores, merges to existing case, or promotes to new case |
| Case | A formal investigation — contains all evidence, tasks, and observables for one incident or related group of incidents | Title, severity, TLP, PAP, owner, tasks, observables, timeline, tags, custom fields | Created from one or more alerts; the primary work unit for the IR team |
| Task | A specific action item within a case | Title, description, owner, status (Waiting/InProgress/Completed/Cancelled), logs (task log entries) | Created inside cases; analysts log work done on each task; task logs are the detailed work record |
| Observable | A piece of evidence tied to a case or alert — an artifact that can be analyzed and shared | Data type (IP, domain, hash, email, URL, filename), value, TLP, tags, Cortex analysis results | Linked to cases; Cortex runs analyzers on observables; IOC sharing exports from observables |
| Template | A predefined case structure that pre-populates tasks when a case is created | Title, description, tasks with owners and descriptions | Applied at case creation — "create case from Phishing template" creates the case with the standard phishing tasks already in place |
The Alert-to-Case Workflow
The core workflow in TheHive is the progression from alert to case. Implementing this workflow correctly requires deciding how alerts flow in and what the triage decision rules are. The most important workflow discipline: all alerts must flow through the alert queue, not be created directly as cases.
Alert Triage Decision Process in TheHive
══════════════════════════════════════════════════════════════════════
1. Alert arrives in TheHive (via API, webhook, or manual entry)
↓
2. Analyst reviews alert:
Context available: source, severity, type, observables,
any automatic enrichment from SOAR or TheHive rules
↓
3. Triage decision (analyst):
├── FALSE POSITIVE → Mark "Ignored" with justification
│ (retained for metrics, not discarded)
│
├── KNOWN PATTERN → Merge to existing open case
│ Example: second alert with same C2 IP as case IR-2026-023
│ This is how related alerts get linked to one investigation
│
├── DUPLICATE → Mark as duplicate of existing alert
│ (reduces noise without losing information)
│
└── NEW INVESTIGATION NEEDED → Promote to Case
Pick template (Phishing / Ransomware / BEC / General)
Template creates standard tasks automatically
Assign severity, owner, TLP
All observables from alert transfer to case
↓
4. Case work begins: analysts work tasks, log findings,
add observables as they're discovered, run Cortex analyzers
↓
5. Case close: status = Resolved/FalsePositive/Duplicate
Final metrics recorded: open time, severity, type, resolution
Cortex Analyzers: Automating Enrichment
Cortex is the analysis engine that TheHive connects to for automated observable enrichment. It runs analyzers — scripts that query external services — against any observable type. Cortex is what makes TheHive more than a ticketing system: every IOC can be automatically enriched from dozens of sources with one click or automatically when the observable is created.
| Observable type | Useful Cortex analyzers | What they return |
|---|---|---|
| IP address | VirusTotal, AbuseIPDB, Shodan, MaxMind GeoIP, MISP, GreyNoise | Malware association count, abuse reports, open ports/services, geolocation, threat intel match, noise classification |
| Domain | VirusTotal, MISP, Maltiverse, DomainTools, URLScan | Malware distribution, threat intel match, passive DNS, registrar history, current page screenshot/content |
| URL | URLScan, VirusTotal, Maltiverse, PhishTank | Page content analysis, screenshot, linked domains, malware detection, phishing database match |
| File hash (MD5/SHA1/SHA256) | VirusTotal, MISP, Maltiverse, Manalyze, HybridAnalysis | AV detection rate, sandbox behavior report, MITRE ATT&CK mapping from dynamic analysis |
| Email address | HaveIBeenPwned, Hunter.io, EmailRep | Known breach exposure, deliverability assessment, reputation score |
| File (binary) | Cuckoo, Joe Sandbox, Any.run, MalwareBazaar | Full dynamic analysis: dropped files, network connections, registry changes, MITRE technique mapping |
Cortex has two types of integrations: analyzers and responders. Analyzers are read-only — they query external services and return data (enrichment). Responders are write operations — they take an action in an external system (containing a host in EDR, blocking an IP in the firewall, disabling a user account in AD). Analyzers are always safe to run; responders are the containment automation actions from the SOAR chapter, and carry the same risks discussed there. The distinction matters because the TheHive/Cortex interface presents both types — it is easy to accidentally trigger a responder when you meant to run an analyzer. Build explicit confirmation workflows before any responder action, and restrict which analysts have permission to trigger containment responders.
TheHive vs Jira for IR Case Management
Many organizations default to Jira for incident tracking because they already use it for project management. Understanding why purpose-built IR case management differs from generic project management tools clarifies when the investment in TheHive (or similar) is worthwhile.
| Capability | TheHive | Jira |
|---|---|---|
| Observable management | Native — typed observables with automated enrichment and IOC export | No native concept — requires custom fields and manual copy-paste |
| Alert ingestion | Native API — SIEM/EDR alerts flow in automatically | Requires custom integration; alerts become generic tickets |
| Cortex integration | Native — one-click analyzer run from any observable | Not available |
| Case templates | Built-in playbook templates that auto-create standard task structures | Issue templates exist but lack the security-specific structure |
| MISP integration | Native bidirectional integration | Not available |
| TLP/PAP tagging | Native — standard classification built in for every object | Custom fields required |
| IR metrics | Built-in reports: MTTR by case type, analyst workload, IOC distribution | Requires dashboard configuration or external analytics tool |
| Cost | Free (open source) | Commercial license; TheHive 5 has a commercial version too |
| When Jira makes sense | — | When the IR team is part of a larger IT org where everything is in Jira; when integration with non-security workflows is more important than IR-specific capabilities; when the organization already has Jira ServiceManagement with security workflows |
Deployment Considerations
TheHive is a Java application that requires careful sizing and network placement for operational use. The most common deployment mistakes — running it on a laptop, using the default embedded storage, not backing up regularly — undermine the core purpose of case management: durable record keeping.
TheHive Deployment Checklist
══════════════════════════════════════════════════════════════════════
INFRASTRUCTURE
✓ Dedicated VM or container (not a shared workstation)
✓ 4+ vCPU, 8+ GB RAM for small team (<20 analysts)
16+ GB RAM for larger deployments
✓ 500+ GB storage (cases, observables, and attachments accumulate fast)
✓ External database: Elasticsearch (v7/v8) instead of embedded
Embedded storage = data loss risk on restart/crash
✓ Separate Cortex deployment (can be same host for small teams)
NETWORK PLACEMENT
✓ On isolated security operations network or VLAN
✓ NOT on the same network as systems being investigated
(you're investigating a compromise — your IR tools should not
be on the compromised network)
✓ HTTPS only — TLS certificate from internal CA or Let's Encrypt
✓ Access restricted to IR team IPs / VPN
BACKUP
✓ Daily backup of Elasticsearch indices
✓ Backup of case attachments (file storage)
✓ Test restore at least monthly
✓ Backup stored off-box (not on the TheHive host itself)
AUTHENTICATION
✓ SSO integration (LDAP/AD or SAML) — individual analyst accounts,
not a shared "thehive" credential everyone uses
✓ MFA if supported (TheHive 5 supports TOTP)
✓ Role-based access: analyst, senior analyst, admin — not everyone admin
Q & A
Q: You've been using TheHive for 6 months and the alert queue has 2,000 unresolved alerts. Analysts are ignoring the queue and working directly in cases. How do you fix this?
This is a common adoption failure pattern and it requires both process and tool changes: (1) First: understand why the queue is being ignored. Is the alert volume too high? Are the alerts too low-quality to triage? Is the enrichment insufficient for triage decisions? Are analysts creating cases directly because it's faster than the alert workflow? The fix depends on the root cause. (2) Alert quality: if most alerts are low-fidelity noise, the fix is upstream in the detection engineering — tuning the SIEM/EDR rules to reduce false positives, adding suppression for known false positive patterns. Analysts abandon queues that are 95% garbage. (3) Bulk resolution: for the 2,000 backlog, do not try to triage each individually. Sample a few hundred, understand the distribution (what percentage are each type), and use bulk operations to close categories of clearly irrelevant alerts. Get to a manageable queue size before asking analysts to engage with it regularly. (4) Process: establish a queue discipline — assigned analyst reviews queue for their shift, triages all New alerts before starting case work. This only works if the queue is manageable (under 50 new alerts per shift). If volume is higher, the problem is upstream alert quality. (5) Tool: configure auto-acknowledgment rules for known false positive patterns so they don't even reach the analyst queue as new items — they arrive pre-acknowledged with justification.
Q: How do you use TheHive's TLP and PAP classifications, and why do they matter?
TLP (Traffic Light Protocol) and PAP (Permissible Actions Protocol) are tagging standards that control how information is shared outside your organization: (1) TLP defines who can receive the information: TLP:RED (recipient only, no sharing), TLP:AMBER (limited sharing within organization and trusted partners), TLP:GREEN (community sharing), TLP:CLEAR (public). Apply TLP based on the sensitivity of the case and its observables. A case involving an active nation-state attack is TLP:RED. Indicators from a commodity phishing campaign may be TLP:GREEN and can be shared widely. (2) PAP defines what actions analysts can take with the information: PAP:RED (passive, do not touch), PAP:AMBER (limited active engagement, no direct contact with attacker infrastructure), PAP:GREEN (active engagement permitted). PAP:RED on a C2 IP means do not query it directly — you may alert the attacker that you're investigating. (3) In practice: set these classifications at case creation based on sensitivity. When exporting IOCs for sharing (to MISP, to an ISAC, to another organization), the TLP/PAP tags travel with the IOC and inform the recipient of handling requirements. This is how threat intel sharing remains responsible — you don't accidentally share RED-tagged attacker TTPs with the public, and recipients know they shouldn't either.
Q: You want to integrate TheHive with your SIEM (Splunk) so that Splunk notable events automatically create TheHive alerts. How does this work?
This integration uses TheHive's REST API from a Splunk alert action: (1) TheHive side: generate an API key for an integration service account (not a named analyst — a service account used only for SIEM integration). Note the TheHive base URL and API endpoint for alert creation: POST /api/v1/alert. (2) Splunk side: install the Splunk Add-on for TheHive (available on Splunkbase) or use the custom alert action functionality. Configure the integration with your TheHive URL and API key. (3) Alert mapping: configure which Splunk notable event fields map to TheHive alert fields. The most important mappings: notable event title → alert title; severity (Splunk 1-10 or High/Medium/Low/Info) → TheHive severity; src_ip / dest_ip / user / host → TheHive observables (typed); event time → alert date; notable event description → alert description. (4) Observable extraction: configure the add-on or custom action to extract all observable values (IPs, domains, hashes, usernames) from the Splunk event and create them as typed observables in the TheHive alert. This is what allows Cortex analyzers to run automatically on incoming alert observables. (5) Test with a low-volume Splunk saved search first. Verify that the alert structure in TheHive contains all the context analysts need to triage without going back to Splunk. (6) Rate limiting: add a throttle or deduplication to prevent 50 alerts for the same event from flooding TheHive. Splunk can fire many notable events for a single underlying incident. The SIEM should aggregate before sending to TheHive, not the other way around.