GUIDE COMPLETOPEN SOURCE

Maîtriser TheHive

La plateforme de référence pour la gestion d'incidents de sécurité, la collaboration SOC et l'automatisation de la réponse aux menaces

Qu'est-ce que TheHive ?

TheHive est une plateforme open-source de Security Incident Response Platform (SIRP)conçue pour centraliser, orchestrer et automatiser la gestion des incidents de sécurité. Développée par StrangeBee, elle est devenue la solution de référence pour les SOC, CERT et équipes de cybersécurité du monde entier.

Avec plus de 10,000 organisations utilisatrices et une communauté active, TheHive excelle dans la collaboration temps réel, l'automatisation via Cortex, et l'intégration avec MISP pour une gestion complète du cycle de vie des incidents.

Fonctionnalités principales

6 capacités essentielles

Gestion d'incidents

Centralisation complète des incidents de sécurité avec tracking, timeline et attribution

Cases management
Timeline tracking
IOCs correlation
Evidence collection
Temps de réponse-40%

Collaboration équipe

Travail collaboratif temps réel avec assignation, commentaires et notifications

Multi-user support
Task assignment
Real-time updates
Comment threads
Productivité+60%

Automatisation

Workflows automatisés, responders Cortex et orchestration avancée

Cortex responders
Custom workflows
Auto-enrichment
Playbooks
Tâches auto75%

Intégrations

Connexion native avec Cortex, MISP, SIEM et 100+ outils de sécurité

MISP sync
Cortex analyzers
SIEM integration
Custom APIs
Connecteurs100+

Alertes temps réel

Notification instantanée par email, webhook, Slack et systèmes personnalisés

Email alerts
Webhooks
Slack integration
Custom notifications
Réactivité<1min

Reporting

Génération automatique de rapports, métriques et dashboards personnalisables

Custom templates
Metrics dashboard
Export formats
KPI tracking
FormatsPDF/JSON/CSV
Architecture technique

Composants de l'architecture

TheHive

Application web principale de gestion d'incidents

Play Framework (Scala)
REST API
WebSocket
Elastic backend
9000 (HTTP)

Cortex

Moteur d'analyse et d'enrichissement d'observables

Analyzers (120+)
Responders (50+)
Python/Docker
API-driven
9001 (HTTP)

Elasticsearch

Base de données NoSQL pour le stockage et la recherche

Index management
Full-text search
Clustering
Backup support
9200 (HTTP)9300 (Transport)

Cassandra (opt)

Base de données distribuée alternative à Elasticsearch

Distributed DB
High availability
Scalability
Replication
9042 (CQL)
Installation

3 Méthodes d'installation

Docker Compose

RECOMMANDÉ
📊 Facile⏱️ 15 min
1

Cloner le repo

git clone https://github.com/TheHive-Project/Docker-Templates.git
2

Configuration

cd Docker-Templates/docker/thehive4-cortex3-misp
cp .env.sample .env
3

Variables d'environnement

nano .env  # Configurer les paramètres
4

Lancement

docker-compose up -d
5

Vérification

docker-compose ps

Installation DEB/RPM

📊 Intermédiaire⏱️ 30 min
1

Ajouter le repository

curl -fsSL https://archives.strangebee.com/keys/strangebee.gpg | sudo gpg --dearmor -o /usr/share/keyrings/strangebee.gpg
2

Installation Java

sudo apt install openjdk-11-jre-headless
3

Installation Elasticsearch

sudo apt install elasticsearch
4

Installation TheHive

sudo apt install thehive
5

Configuration

sudo nano /etc/thehive/application.conf

Kubernetes

📊 Avancé⏱️ 1-2h
1

Helm repo

helm repo add strangebee https://helm.strangebee.com
2

Values custom

helm show values strangebee/thehive > values.yaml
3

Configuration

nano values.yaml  # Personnaliser
4

Déploiement

helm install thehive strangebee/thehive -f values.yaml
5

Vérification

kubectl get pods -n thehive
Connecteurs

Intégrations disponibles

Connectez TheHive à votre écosystème de sécurité

Cortex

Moteur d'analyse et d'enrichissement puissant

Analyzers

120+ analyseurs (VirusTotal, MISP, Shodan, etc.)

Responders

50+ responders (block IP, send email, create ticket)

Observable enrichment

Enrichissement automatique d'IOCs

Custom jobs

Création de jobs personnalisés

Configuration

cortex {
  servers = [{
    name = "local"
    url = "http://cortex:9001"
    auth {
      type = "bearer"
      key = "YOUR_API_KEY"
    }
  }]
}

MISP

Plateforme de partage de Threat Intelligence

Event import

Import automatique d'événements MISP

IOC sync

Synchronisation bidirectionnelle des IOCs

Taxonomies

Support des taxonomies et galaxies

Auto-export

Export automatique vers MISP

Configuration

misp {
  servers = [{
    name = "local-misp"
    url = "https://misp.local"
    auth {
      type = "key"
      key = "YOUR_MISP_KEY"
    }
    wsConfig {
      ssl {
        loose {
          acceptAnyCertificate = true
        }
      }
    }
  }]
}

Email

Réception et parsing automatique d'emails

IMAP/POP3

Connexion aux serveurs email

Auto-parsing

Extraction automatique d'IOCs

Attachments

Gestion des pièces jointes

Case creation

Création automatique de cas

Configuration

email {
  enabled = true
  server = "imap.gmail.com"
  port = 993
  ssl = true
  username = "alerts@company.com"
  password = "YOUR_PASSWORD"
}

SIEM/SOAR

Intégration avec systèmes SIEM et SOAR

REST API

API complète pour intégration

Webhooks

Notifications webhook personnalisées

Splunk

App Splunk disponible

ELK Stack

Intégration native Elasticsearch

Configuration

webhook {
  endpoints = [{
    name = "soar-platform"
    url = "https://soar.company.com/webhook"
    version = 0
    wsConfig {
      ssl.loose.acceptAnyCertificate = true
    }
  }]
}
API REST

Exemples d'utilisation de l'API

Automatisez vos workflows avec l'API REST complète de TheHive

Authentification API

bash

Obtenir un token d'API pour l'authentification

# Login et récupération du token
curl -X POST http://localhost:9000/api/v1/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "admin@thehive.local",
    "password": "secret"
  }'

# Réponse
{
  "success": true,
  "token": "YOUR_API_TOKEN_HERE"
}

Créer un cas

python

Création d'un nouveau cas d'incident

import requests

url = "http://localhost:9000/api/v1/case"
headers = {
    "Authorization": "Bearer YOUR_API_TOKEN",
    "Content-Type": "application/json"
}

data = {
    "title": "Phishing Campaign Detected",
    "description": "Multiple phishing emails detected targeting finance team",
    "severity": 3,  # 1=Low, 2=Medium, 3=High, 4=Critical
    "tlp": 2,       # 0=White, 1=Green, 2=Amber, 3=Red
    "pap": 2,       # 0=White, 1=Green, 2=Amber, 3=Red
    "tags": ["phishing", "email", "finance"],
    "customFields": {
        "businessUnit": {
            "string": "Finance Department"
        }
    }
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Ajouter des observables

python

Ajout d'IOCs à un cas existant

# Ajouter des observables (IOCs) à un cas
case_id = "~123456"
url = f"http://localhost:9000/api/v1/case/{case_id}/artifact"

observables = [
    {
        "dataType": "ip",
        "data": "192.168.1.100",
        "tlp": 2,
        "ioc": True,
        "tags": ["malicious", "c2"],
        "message": "C2 server IP"
    },
    {
        "dataType": "domain",
        "data": "malicious.com",
        "tlp": 2,
        "ioc": True,
        "tags": ["phishing"]
    },
    {
        "dataType": "hash",
        "data": "d41d8cd98f00b204e9800998ecf8427e",
        "tlp": 2,
        "ioc": True
    }
]

for obs in observables:
    response = requests.post(url, headers=headers, json=obs)
    print(f"Observable created: {response.json()['_id']}")

Créer une tâche

javascript

Ajout d'une tâche à un cas

const axios = require('axios');

const caseId = '~123456';
const url = `http://localhost:9000/api/v1/case/${caseId}/task`;

const task = {
  title: "Analyze malware sample",
  description: "Submit sample to sandbox and analyze behavior",
  status: "Waiting",
  flag: false,
  startDate: Date.now(),
  dueDate: Date.now() + (24 * 60 * 60 * 1000), // 24h
  assignee: "analyst1@company.com"
};

axios.post(url, task, {
  headers: {
    'Authorization': 'Bearer YOUR_API_TOKEN',
    'Content-Type': 'application/json'
  }
})
.then(response => console.log('Task created:', response.data))
.catch(error => console.error('Error:', error));

Rechercher des cas

python

Recherche avancée avec filtres et pagination

# Recherche de cas avec filtres
url = "http://localhost:9000/api/v1/query"

query = {
    "query": [
        {
            "_name": "listCase"
        },
        {
            "_name": "filter",
            "_and": [
                {
                    "_field": "severity",
                    "_value": 3
                },
                {
                    "_field": "status",
                    "_value": "Open"
                },
                {
                    "_field": "tags",
                    "_value": "phishing"
                }
            ]
        },
        {
            "_name": "sort",
            "_fields": [
                {
                    "startDate": "desc"
                }
            ]
        },
        {
            "_name": "page",
            "from": 0,
            "to": 10
        }
    ]
}

response = requests.post(url, headers=headers, json=query)
cases = response.json()

for case in cases:
    print(f"Case: {case['title']} - Severity: {case['severity']}")

Lancer une analyse Cortex

bash

Déclencher une analyse sur un observable

# Analyser un observable avec Cortex
OBSERVABLE_ID="~789012"
ANALYZER_ID="VirusTotal_GetReport_3_0"

curl -X POST http://localhost:9000/api/v1/connector/cortex/job \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "cortexId": "local-cortex",
    "artifactId": "'$OBSERVABLE_ID'",
    "analyzerId": "'$ANALYZER_ID'"
  }'

# Vérifier le résultat
JOB_ID="returned_job_id"
curl -X GET http://localhost:9000/api/v1/connector/cortex/job/$JOB_ID \
  -H "Authorization: Bearer YOUR_API_TOKEN"
Bonnes pratiques

Best practices pour TheHive

📋 Organisation

Taxonomie cohérente

Définir et appliquer une classification standardisée

TLP & PAP standards
Tags hiérarchiques
Custom fields métier
Templates réutilisables

Templates de cas

Créer des modèles pour chaque type d'incident

Phishing template
Malware analysis
Data breach
DDoS response

Severity matrix

Matrice de criticité claire et documentée

1: Low - Info only
2: Medium - Investigation
3: High - Immediate action
4: Critical - Emergency

👥 Collaboration

Assignation claire

Responsabilités définies pour chaque tâche

1 owner par cas
Tasks assignées
Escalation process
Backup analysts

Documentation continue

Documenter toutes les actions et décisions

Task logs détaillés
Screenshots attachés
Timeline précise
Lessons learned

Communication

Notifier et partager l'information

Notifications configurées
Status updates réguliers
Stakeholder comms
Post-incident reports

⚙️ Automatisation

Workflows automatisés

Automatiser les tâches répétitives

Auto-enrichment IOCs
Response playbooks
Status transitions
Notification triggers

Cortex responders

Actions automatiques de réponse

Block IP at firewall
Quarantine email
Disable account
Create SIEM alert

Intégrations API

Connecter avec l'écosystème de sécurité

SIEM bidirectionnel
Ticketing system
Asset management
Threat intel feeds
Cas d'usage

Scénarios d'utilisation

SOC Operations

Gestion quotidienne des alertes et incidents

Scénarios :

Alert triageIncident responseThreat huntingIOC management

Bénéfices :

Centralisation
Collaboration
Métriques SOC

CERT/CSIRT

Coordination d'incidents majeurs

Scénarios :

Crisis managementMulti-team coordinationExecutive reportingPost-mortem analysis

Bénéfices :

Timeline précise
Communication
Evidence tracking

Threat Intelligence

Analyse et partage de CTI

Scénarios :

IOC correlationMISP integrationCampaign trackingAttribution analysis

Bénéfices :

MISP sync
IOC enrichment
Knowledge base

Forensics

Investigation forensique approfondie

Scénarios :

Evidence collectionChain of custodyTimeline reconstructionLegal reporting

Bénéfices :

Documentation
Audit trail
Export formats
Ressources

Ressources complémentaires

Prêt à déployer TheHive ?

Commencez dès maintenant avec Docker Compose et transformez votre gestion d'incidents de sécurité