Dop2Mop

Un collecteur OpenGraph de preuve de concept pour BloodHound qui cartographie les chemins d'attaque entre l'infrastructure DevOps et MLOps.

Basé sur Pipelines of Privilege: Attack Paths from DevOps to MLOps Infrastructure par Brett Hawkins (@h4wkst3r).

Table des matières

• Remerciements
• Aperçu
  • Plateformes prises en charge
  • Périmètres de confiance cartographiés
• Installation
  • Dépendances optionnelles
• Démarrage rapide
  • Générer des données de démonstration
  • Importer dans BloodHound
• Configuration
  • Fichier de configuration
  • Validation des identifiants
• Référence CLI
  • Aperçu des commandes
  • Options globales
  • dop2mop collect
  • dop2mop demo
• Exemples d'utilisation CLI
  • Collecte de base
  • Collecte sur une seule plateforme
  • Collecte sur plusieurs plateformes
  • Exemples de collecte GitHub
  • Exemples de collecte Azure DevOps
  • Exemples de collecte Azure ML
  • Exemples de collecte AWS SageMaker
  • Collecte complète de l'environnement
• Variables d'environnement
• Types de nœuds
  • Nœuds DevOps
  • Nœuds MLOps
  • Nœuds d'identité
  • Nœuds d'artefact
• Types d'arêtes
  • Arêtes de chemin d'attaque
  • Arêtes structurelles
• Exemples de requêtes
• Icônes personnalisées
  • Téléchargement des icônes dans BloodHound
• API Python
  • Utilisation des collecteurs individuels
  • Construction de graphes personnalisés
• Dépannage
  • Problèmes courants
• Licence

Remerciements

• SpecterOps pour BloodHound et OpenGraph

Aperçu

Dop2Mop collecte des données provenant des plateformes DevOps et MLOps afin d'identifier les chemins d'attaque permettant un mouvement latéral depuis les pipelines CI/CD vers l'infrastructure d'entraînement de machine learning. Il génère du JSON OpenGraph compatible avec BloodHound pour la visualisation et l'analyse.

Plateformes prises en charge

Périmètres de confiance cartographiés

Dop2Mop modélise les cinq périmètres de confiance critiques identifiés dans la recherche :

1. P1 : Dépôt de code vers pipeline CI/CD - Déclenchement automatique des pipelines à partir des commits de code
2. P2 : Authentification du principal de service - Identifiants NHI utilisés par les pipelines pour accéder aux plateformes ML
3. P3 : Confiance dans les artefacts conteneurisés - Confiance implicite dans les images conteneur provenant de registres internes
4. P4 : Exécution des définitions de tâches - Les plateformes ML exécutent des définitions de tâches sans validation
5. P5 : Désérialisation de code - Désérialisation non sécurisée des ensembles de données (pickle, joblib)

Installation```bash

git clone https://github.com/h4wkst3r/dop2mop.git cd dop2mop pip install -r requirements.txt pip install -e .

## Ce qui est collecté

Chaque collecteur rassemble des ressources spécifiques à la plateforme et cartographie les limites de confiance entre elles :

| Collecteur | Ressources collectées |
|-----------|-------------------|
| **GitHub** | Organisations, dépôts, workflows, secrets, règles de protection de branches, configurations OIDC, références d'images de conteneurs, références de buckets S3 |
| **Azure DevOps** | Organisations, projets, pipelines (YAML), connexions de service (avec détails de portée), groupes de variables, pools d'agents, dépôts |
| **Azure ML** | Espaces de travail, clusters/instances de calcul, magasins de données, environnements ML, modèles enregistrés, jobs/expériences, endpoints en ligne et par lots |
| **SageMaker** | Jobs d'entraînement, modèles, endpoints, domaines, instances de notebooks, rôles d'exécution IAM (avec analyse de politique), dépôts/images ECR, buckets S3 (filtrés pour le ML) |

## Démarrage rapide

### Générer des données de démonstration

Le moyen le plus rapide de voir Dop2Mop en action est de générer des données de démonstration montrant les scénarios d'attaque issus de la recherche :```bash
dop2mop demo -o demo.json

Ingestion dans BloodHound

1. Ouvrir BloodHound CE (v8.0+)

2. Naviguer vers Administration → Import de fichiers

3. Télécharger le fichier JSON généré

4. Interroger avec Cypher :

   root@kitploit:~

   MATCH (g:Group {highvalue: true})
   OPTIONAL MATCH (g)-[:Contains*1..]->(n:User)
   RETURN g.name, COUNT(n) AS MemberCount
   ``````cypher
   

// Azure DevOps to Azure ML Lateral Movement MATCH p=(repo)-[:TriggersPipeline]->(pipeline)-[:UsesServiceConnection]->(svcconn)-[:AuthenticatesAs]->(workspace)-[:CodeExecution]->(compute) RETURN p

// Container Image Poisoning (Supply Chain Attack) MATCH p=(workflow)-[:CanPoisonImage]->(image)<-[:PullsImage]-(job) RETURN p

// OIDC/Federated Identity Abuse (confirmed edges) MATCH p=(workflow)-[:OIDCTrust]->(oidc)-[:CanAssumeRole]->(role)-[:SubmitsJob]->(job) RETURN p

// OIDC abuse including inferred paths MATCH p=(workflow)-[:OIDCTrust]->(oidc)-[:InferredCanAssumeRole]->(role) RETURN p

// Dataset Poisoning via Pickle Deserialization MATCH p=(workflow)-[:CanPoisonDataset]->(dataset)<-[:LoadsDataset]-(job) RETURN p

// Find repos with weak/no branch protection (TB1 exploitable) MATCH (repo)-[:BypassesProtection]->(repo) RETURN repo.name, repo.default_branch

// Find overprivileged SageMaker IAM roles MATCH (role:IAMRole) WHERE role.is_admin = true OR role.has_s3_full_access = true RETURN role.name, role.attached_policies

// Find SageMaker notebooks with root + internet access MATCH (nb:SMNotebook) WHERE nb.root_access = 'Enabled' AND nb.direct_internet_access = 'Enabled' RETURN nb.name, nb.status

// Find self-hosted ADO agent pools MATCH (agent:ADOAgent) WHERE agent.is_hosted = false RETURN agent.name, agent.pool_type

---

## Configuration

### Fichier de configuration

Au lieu de passer les identifiants à chaque exécution, vous pouvez les sauvegarder dans un fichier de configuration. Copiez l'exemple inclus et remplissez vos valeurs :```bash
cp dop2mop.yaml.example dop2mop.yaml
# Edit dop2mop.yaml with your credentials

Dop2Mop vérifie ces emplacements dans l'ordre :

1. Chemin spécifié par --config
2. dop2mop.yaml / dop2mop.yml / .dop2mop.yaml dans le répertoire courant
3. ~/.dop2mop.yaml

Note : dop2mop.yaml est dans .gitignore pour éviter de commettre accidentellement des informations d'identification. Le fichier d'exemple (dop2mop.yaml.example) peut être commité en toute sécurité.

Voir dop2mop.yaml.example pour toutes les options disponibles avec commentaires.

Ordre de priorité : arguments CLI > fichier de configuration > variables d'environnement.

Validation des identifiants

Testez les identifiants avant d'exécuter une collecte complète :```bash

Validate all configured collectors

dop2mop collect --validate -v

Validate specific collectors

dop2mop collect --validate --collectors github,sagemaker -v

Cela effectue un appel API léger par plateforme pour vérifier que les jetons sont valides avant de commencer la collecte.

### Alias des collecteurs

Vous pouvez utiliser des noms courts au lieu des noms de classe complets avec `--collectors` :

| Alias | Collecteur |
|-------|------------|
| `github`, `gh` | GitHubCollector |
| `ado`, `azuredevops`, `azure-devops` | AzureDevOpsCollector |
| `azureml`, `azure-ml` | AzureMLCollector |
| `sagemaker`, `sm` | SageMakerCollector |```bash
# These are equivalent:
dop2mop collect --collectors GitHubCollector,SageMakerCollector
dop2mop collect --collectors github,sagemaker
dop2mop collect --collectors gh,sm

Référence CLI

Vue d'ensemble des commandes```

dop2mop [options]

Commands: collect Collect data from DevOps/MLOps platforms demo Generate demo data with attack scenarios

### Options globales

| Option | Description |
|--------|-------------|
| `-v, --verbose` | Activer la sortie détaillée (journalisation niveau INFO) |
| `--debug` | Activer la sortie de débogage (journalisation niveau DEBUG) |

---

### `dop2mop collect`

Collecter les données depuis les plateformes DevOps et MLOps configurées.```bash
dop2mop collect [OPTIONS]

Options Générales

Options GitHub

Options Azure DevOps

Options Azure ML

Options AWS SageMaker

Collecteurs Disponibles

dop2mop demo

Générer des données de démonstration illustrant les quatre scénarios d'attaque issus de la recherche.```bash dop2mop demo [OPTIONS]

| Option | Description |
|--------|-------------|
| `-o, --output FILE` | Chemin du fichier de sortie (par défaut : `dop2mop_demo.json`) |

---

### `dop2mop icons`

Générer une configuration d'icônes personnalisée pour les types de nœuds BloodHound.```bash
dop2mop icons [OPTIONS]

Exemples d'utilisation en CLI

Collecte de base```bash

Collect from all configured platforms (uses environment variables)

dop2mop collect -o output.json

Use a config file

dop2mop collect --config dop2mop.yaml -o output.json -v

Validate credentials first, then collect

dop2mop collect --validate -o output.json -v

Collect with verbose logging

dop2mop collect -o output.json -v

Collect with debug logging

dop2mop collect -o output.json --debug

Collect and compress to ZIP

dop2mop collect -o output.json --zip

Limit collection size

dop2mop collect --max-items 100 -o output.json

Skip secret enumeration

dop2mop collect --no-secrets -o output.json

### Collection mono-plateforme```bash
# GitHub only (aliases: github, gh)
dop2mop collect --collectors github -o github.json -v

# Azure DevOps only (aliases: ado, azuredevops)
dop2mop collect --collectors ado -o ado.json -v

# Azure ML only (aliases: azureml, azure-ml)
dop2mop collect --collectors azureml -o azureml.json -v

# SageMaker only (aliases: sagemaker, sm)
dop2mop collect --collectors sm -o sagemaker.json -v

Collection multi-plateforme```bash

GitHub + SageMaker

dop2mop collect --collectors github,sagemaker -o output.json -v

GitHub + Azure DevOps

dop2mop collect --collectors github,ado -o output.json -v

Azure DevOps + Azure ML (full Azure stack)

dop2mop collect --collectors ado,azureml -o azure.json -v

All collectors explicitly

dop2mop collect --collectors github,ado,azureml,sagemaker -o full.json -v

### Exemples de collection GitHub```bash
# Using environment variables
export GITHUB_TOKEN="ghp_xxxxxxxxxxxx"
export GITHUB_ORG="your-org"
dop2mop collect --collectors GitHubCollector -o github.json -v

# Using command-line arguments
dop2mop collect --collectors GitHubCollector \
  --github-token ghp_xxxxxxxxxxxx \
  --github-org your-org \
  -o github.json -v

# GitHub Enterprise Server
dop2mop collect --collectors GitHubCollector \
  --github-token ghp_xxxxxxxxxxxx \
  --github-org your-org \
  --github-enterprise-url https://github.yourcompany.com/api/v3 \
  -o github.json -v

# Skip secret enumeration
dop2mop collect --collectors GitHubCollector \
  --github-token ghp_xxxxxxxxxxxx \
  --github-org your-org \
  --no-secrets \
  -o github.json -v

# Limit to 50 repositories
dop2mop collect --collectors GitHubCollector \
  --github-token ghp_xxxxxxxxxxxx \
  --github-org your-org \
  --max-items 50 \
  -o github.json -v

Exemples de la collection Azure DevOps```bash

Using environment variables

export AZURE_DEVOPS_TOKEN="your-pat" export AZURE_DEVOPS_ORG="your-org" dop2mop collect --collectors AzureDevOpsCollector -o ado.json -v

Using command-line arguments (PAT)

dop2mop collect --collectors AzureDevOpsCollector
--azure-devops-token your-pat
--azure-devops-org your-org
-o ado.json -v

Using access token (Bearer auth)

dop2mop collect --collectors AzureDevOpsCollector
--azure-devops-access-token eyJ0...
--azure-devops-org your-org
-o ado.json -v

> **Remarque :** Priorité d'authentification Azure DevOps : jeton d'accès (Bearer) > PAT (Basic).
> Les jetons d'accès peuvent être obtenus via `az account get-access-token --resource 499b84ac-1321-427f-aa17-267ca6975798`.

### Exemples de la collection Azure ML```bash
# Using environment variables
export AZURE_SUBSCRIPTION_ID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
export AZURE_TENANT_ID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
dop2mop collect --collectors AzureMLCollector -o azureml.json -v

# Using DefaultAzureCredential (az login)
dop2mop collect --collectors AzureMLCollector \
  --azure-subscription-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  --azure-tenant-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  -o azureml.json -v

# Using Service Principal
dop2mop collect --collectors AzureMLCollector \
  --azure-subscription-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  --azure-tenant-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  --azure-client-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  --azure-client-secret your-secret \
  -o azureml.json -v

# Using Access Token
dop2mop collect --collectors AzureMLCollector \
  --azure-subscription-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  --azure-tenant-id xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx \
  --azure-access-token eyJ0... \
  -o azureml.json -v

Remarque : Priorité d'authentification Azure ML : jeton d'accès > principal de service > DefaultAzureCredential (az login). Les jetons d'accès peuvent être obtenus via az account get-access-token --resource https://management.azure.com/.

Exemples de collection AWS SageMaker```bash

Using AWS profile (environment variable)

export AWS_PROFILE="your-profile" dop2mop collect --collectors SageMakerCollector -o sagemaker.json -v

Using AWS profile (command-line)

dop2mop collect --collectors SageMakerCollector
--aws-profile your-profile
-o sagemaker.json -v

Using access keys

dop2mop collect --collectors SageMakerCollector
--aws-access-key-id AKIAXXXXXXXXXXXXXXXX
--aws-secret-access-key xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--aws-region us-east-1
-o sagemaker.json -v

Different AWS region

dop2mop collect --collectors SageMakerCollector
--aws-profile your-profile
--aws-region us-west-2
-o sagemaker.json -v

### Collecte complète de l'environnement```bash
# Set all environment variables
export GITHUB_TOKEN="ghp_xxxxxxxxxxxx"
export GITHUB_ORG="your-org"
export AZURE_DEVOPS_TOKEN="your-pat"
export AZURE_DEVOPS_ORG="your-org"
export AZURE_SUBSCRIPTION_ID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
export AZURE_TENANT_ID="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
export AWS_PROFILE="your-profile"

# Collect from all platforms (auto-detects configured collectors)
dop2mop collect -o full_collection.json -v

# Or with explicit collectors
dop2mop collect \
  --collectors GitHubCollector,AzureDevOpsCollector,AzureMLCollector,SageMakerCollector \
  -o full_collection.json -v

Variables d'environnement

Toutes les options de ligne de commande peuvent être définies via des variables d'environnement :

Priorité : Arguments CLI > fichier de configuration > variables d'environnement.

Types de nœuds

Nœuds DevOps

Nœuds MLOps

Nœuds d'identité

Nœuds d'artéfact

Types d'arêtes

Arêtes de chemin d'attaque

Arêtes inférées

Ces arêtes sont créées par analyse heuristique lorsque les données d'API explicites ne sont pas disponibles (par exemple, les ARN de rôles stockés dans des secrets). Elles utilisent des types d'arêtes distincts afin que vous puissiez les filtrer dans les requêtes BloodHound.

Arêtes structurelles

Exemples de requêtes

Consultez queries/dop2mop_queries.cypher pour des exemples complets de requêtes.

Icônes personnalisées

Dop2Mop inclut un fichier d'icônes préconfiguré pour les types de nœuds personnalisés BloodHound dans data/custom_icons.json.

Téléchargement des icônes vers BloodHound

Option 1 : Explorateur d'API (Plus simple)

1. Ouvrez BloodHound CE et allez dans Paramètres → API Explorer
2. Trouvez POST /api/v2/custom-nodes
3. Cliquez sur « Try it out »
4. Collez le contenu de custom_icons.json
5. Cliquez sur « Execute »

Option 2 : Authentification HMAC (Recommandé pour l'automatisation)

D'abord, créez un jeton API dans BloodHound :

1. Allez dans Paramètres → Administration → Gérer les utilisateurs
2. Cliquez sur votre utilisateur → Créer un jeton
3. Sauvegardez l'ID du jeton et la Clé du jeton

Ensuite, utilisez ce script Python pour télécharger :```python #!/usr/bin/env python3 """Upload custom icons to BloodHound CE using HMAC authentication."""

import base64 import hashlib import hmac import json from datetime import datetime, timezone import requests

Configuration

BLOODHOUND_URL = "http://localhost:8080" TOKEN_ID = "your-token-id" TOKEN_KEY = "your-token-key" ICONS_FILE = "custom_icons.json"

def hmac_auth(method: str, uri: str, body: bytes = b"") -> dict: """Generate HMAC authentication headers.""" digester = hmac.new( base64.b64decode(TOKEN_KEY), msg=None, digestmod=hashlib.sha256 )

now = datetime.now(timezone.utc)
timestamp = now.strftime("%Y-%m-%dT%H:%M:%SZ")

digester.update(f"{method}".encode())
digester.update(f"{uri}".encode())
digester.update(timestamp.encode())
if body:
    digester.update(body)

signature = base64.b64encode(digester.digest()).decode()

return {
    "Authorization": f"bhesignature {TOKEN_ID}",
    "RequestDate": timestamp,
    "Signature": signature,
    "Content-Type": "application/json",
}

def upload_icons(): """Upload custom icons to BloodHound.""" uri = "/api/v2/custom-nodes" url = f"{BLOODHOUND_URL}{uri}"

with open(ICONS_FILE, "rb") as f:
    body = f.read()

headers = hmac_auth("POST", uri, body)
response = requests.post(url, headers=headers, data=body)

print(f"Status: {response.status_code}")
print(f"Response: {response.text}")
return response.status_code == 200

if name == "main": upload_icons()

#### Option 3: Bearer Token (Test rapide)

Obtenez un JWT depuis l'onglet Réseau des DevTools de votre navigateur tout en étant connecté à BloodHound :```bash
curl -X POST http://localhost:8080/api/v2/custom-nodes \
  -H "Authorization: Bearer eyJ..." \
  -H "Content-Type: application/json" \
  -d @custom_icons.json

API Python```python

from dop2mop import Dop2MopCollector, CollectorConfig

Configure collection

config = CollectorConfig( github_token="ghp_xxx", github_org="myorg", aws_profile="default", )

Validate credentials first

collector = Dop2MopCollector(config) results = collector.validate_all() print(results) # {'GitHubCollector': True, 'SageMakerCollector': True, ...}

Run collection (supports aliases)

collector.run(collectors=["github", "sm"])

Save output

collector.save("output.json")

Get statistics

print(collector.get_stats())

Get per-collector failure/skip details

print(collector.get_collection_summary())

### Utilisation des collecteurs individuels```python
from dop2mop import CollectorConfig, GitHubCollector, SageMakerCollector
from dop2mop.graph import OpenGraphBuilder

# Create shared builder
builder = OpenGraphBuilder(source_kind="MLOpsBase")

# Configure
config = CollectorConfig(
    github_token="ghp_xxx",
    github_org="myorg",
    aws_profile="default",
)

# Run individual collectors
github = GitHubCollector(config, builder)
github.collect()

sagemaker = SageMakerCollector(config, builder)
sagemaker.collect()

# Save combined output
builder.save("combined.json")

Construire des graphes personnalisés```python

from dop2mop.graph import OpenGraphBuilder from dop2mop.models import NodeKind, EdgeType

builder = OpenGraphBuilder(source_kind="CustomSource")

Add nodes

builder.create_node( id="my-pipeline", kinds=[NodeKind.AZURE_DEVOPS_PIPELINE.value], name="My Pipeline", displayname="Production Pipeline", )

builder.create_node( id="my-ml-workspace", kinds=[NodeKind.AZURE_ML_WORKSPACE.value], name="ML Workspace", displayname="Training Workspace", )

Add edge

builder.create_edge( start_id="my-pipeline", end_id="my-ml-workspace", kind=EdgeType.SUBMITS_JOB, properties={"trust_boundary": "TB4"} )

Export

builder.save("custom_graph.json")

---

## Dépannage

### Valider d'abord

Commencez toujours par la validation des identifiants pour détecter rapidement les problèmes d'authentification :```bash
dop2mop collect --validate --collectors github,sm -v

La sortie affichera OK/ÉCHEC par collecteur avant le début de toute collecte.

Résumé de la collecte

Après chaque exécution, Dop2Mop imprime un résumé indiquant ce qui a été collecté et ce qui a échoué :```

Dop2Mop Collection Summary

Total Nodes: 142 DevOps: 45 MLOps: 38 Identity: 12 Artifact: 47

Total Edges: 201 Contains: 62 TriggersPipeline: 15 ...

──────────────────────────────────────────────────────── Collection Issues: GitHubCollector: 45 collected, 3 failed, 1 skipped FAIL: branch_protection:org/repo - 404 Not Found SKIP: branch_protection:org/private - Insufficient permissions

Output: output.json

### Problèmes courants

**"Collecteur GitHub non configuré, ignoré"**
- Assurez-vous que les variables d'environnement `GITHUB_TOKEN` et `GITHUB_ORG` sont définies, ou passez `--github-token` et `--github-org`

**"Collecteur Azure ML non configuré, ignoré"**
- Assurez-vous que `AZURE_SUBSCRIPTION_ID` et `AZURE_TENANT_ID` sont définies
- Exécutez `az login` si vous utilisez DefaultAzureCredential
- Alternativement, passez `--azure-access-token` avec un jeton valide provenant de `az account get-access-token`

**"Collecteur SageMaker non configuré, ignoré"**
- Définissez `AWS_PROFILE` ou les deux `AWS_ACCESS_KEY_ID` et `AWS_SECRET_ACCESS_KEY`
- Assurez-vous que les identifiants disposent des permissions de lecture SageMaker

**La protection de branche renvoie 403**
- L'API GitHub nécessite un accès admin pour lire les règles de protection de branche
- Les jetons non-admin ignoreront la collecte de la protection de branche (signalé dans le résumé)

**Limitation de débit (erreurs 429)**
- Dop2Mop réessaie automatiquement avec un backoff exponentiel en cas de réponse de limitation de débit
- Pour les grandes organisations, utilisez `--max-items` pour réduire les appels API
- Limites de débit GitHub : 5 000 requêtes/heure pour les utilisateurs authentifiés

**Aucun résultat dans la console Cypher de BloodHound**
- Assurez-vous que les requêtes renvoient des nœuds complets (`RETURN a, b`) et non des propriétés (`RETURN a.name, b.name`)
- La console Cypher de BloodHound est destinée à la visualisation de graphes, pas aux données tabulaires
- Utilisez Neo4j Browser (localhost:7474) pour les requêtes basées sur les propriétés

**Filtrage des arêtes inférées par rapport aux arêtes collectées**
- Les arêtes inférées utilisent des types distincts (par exemple, `InferredCanAssumeRole` au lieu de `CanAssumeRole`)
- Interrogez uniquement les arêtes confirmées : `MATCH p=()-[:CanAssumeRole]->() RETURN p`
- Interrogez les arêtes inférées : `MATCH p=()-[:InferredCanAssumeRole]->() RETURN p`

---

## Licence

Licence MIT - Voir [LICENSE](https://github.com/h4wkst3r/dop2mop/blob/HEAD/LICENSE) pour plus de détails.