Parent : [[INDEX-CYBERSECU]]

OPSEC staff - Compartimentage, Telegram, faux numéros, bénévolat et compromission

Problème

L'analyse de l'organisation YGG révèle un modèle de compartimentage, de bénévolat du staff, et de communication exclusive via Telegram avec faux numéros de téléphone. Ce modèle a permis à l'administrateur principal (Oracle) de rester invisible pendant 7 ans, tandis que le staff bénévole gérait 73% des actions de modération sans connaître la structure financière.

Contexte archive Ygg

Source : https://yggleak.top/fr/home/ygg-dossier
Staff : ~20 modérateurs bénévoles
Communication : Telegram obligatoire, groupe privé BLABLAROOM (https://t.me/+0W1AvzqXYdUwNjU0)
Recrutement : Macha64 repère les candidats → YggFlop envoie les règles → candidat rejoint le groupe Telegram
Règle #3 : Ne jamais poser de questions sur l'administration (Oracle)
Faux numéros : Fournis par le "service web de YGG" via des SIM prépayées
Support email : user@example.com
Oracle : Jamais communiqué directement avec un modérateur (seulement avec YggFlop)

Technique de l'organisation

1. Compartimentage

Oracle (admin principal)
  → YggFlop (exécutant technique)
    → Staff modérateurs (bénévoles)

Règle : Aucun modérateur n'a jamais échangé un message direct avec Oracle.

2. Bénévolat du staff

Dom0552 (2ème plus actif) : "Et je ne suis pas payé. Totalement bénévole."
YggFlop : Refuse de répondre sur sa propre rémunération
73% des actions de modération par 5 comptes
Le reste du staff (20 personnes) se partage les 27% restants

3. Faux numéros de téléphone

YggFlop fournit des faux numéros via "le service web de YGG"
Bar666 a perdu l'accès à son ancien compte Telegram quand sa SIM prépayée a expiré

4. Recrutement systématique

1. Modérateur (souvent Macha64) repère un candidat actif sur le forum
2. Il en parle à YggFlop
3. YggFlop envoie les règles par MP
4. Le candidat rejoint le groupe Telegram BLABLAROOM
5. Turnover réel : Jocker03 parti en novembre 2025, Zitoune69 parti puis revenu, BoutrosBoutros renvoyé puis repris

Solution protectif — Détection d'organisation suspecte

1. Détecter le compartimentage

# detect_compartmentalization.py
from collections import defaultdict
import networkx as nx

def analyze_staff_communications(messages):
    """
    messages : liste de dicts {sender, recipient, timestamp, content}
    """
    G = nx.DiGraph()
    
    for msg in messages:
        sender = msg['sender']
        recipient = msg['recipient']
        
        if G.has_edge(sender, recipient):
            G[sender][recipient]['weight'] += 1
        else:
            G.add_edge(sender, recipient, weight=1)
    
    # Détecter les hubs (personnes centrales)
    betweenness = nx.betweenness_centrality(G)
    
    # Détecter les îlots (compartimentage)
    communities = nx.community.greedy_modularity_communities(G.to_undirected())
    
    alerts = []
    
    # 1. Si un hub central contrôle TOUTE la communication
    top_hub = max(betweenness, key=betweenness.get)
    if betweenness[top_hub] > 0.8:
        alerts.append({
            'type': 'central_hub_control',
            'user': top_hub,
            'betweenness': betweenness[top_hub],
            'description': 'Un utilisateur contrôle 80%+ des communications'
        })
    
    # 2. Si des communautés sont isolées (compartimentage)
    if len(communities) > 2:
        alerts.append({
            'type': 'isolated_communities',
            'count': len(communities),
            'description': f'{len(communities)} groupes isolés détectés (compartimentage)'
        })
    
    # 3. Si un utilisateur n'est jamais contacté directement par certains
    all_users = set(G.nodes())
    for user in all_users:
        neighbors = set(G.neighbors(user))
        isolated_from = all_users - neighbors - {user}
        
        if len(isolated_from) > len(all_users) * 0.8:
            alerts.append({
                'type': 'isolated_user',
                'user': user,
                'isolated_from_count': len(isolated_from),
                'description': f'{user} est isolé de {len(isolated_from)} utilisateurs'
            })
    
    return alerts

2. Détecter le bénévolat forcé

# detect_volunteer_exploitation.py
import statistics

def analyze_moderation_distribution(actions):
    """
    actions : liste de {user, action_type, timestamp, effort_score}
    """
    user_actions = defaultdict(list)
    for action in actions:
        user_actions[action['user']].append(action)
    
    action_counts = [len(v) for v in user_actions.values()]
    
    # Statistiques
    mean = statistics.mean(action_counts)
    std = statistics.stdev(action_counts) if len(action_counts) > 1 else 0
    
    # Détecter la concentration
    sorted_counts = sorted(action_counts, reverse=True)
    top_5_sum = sum(sorted_counts[:5])
    total = sum(action_counts)
    
    alerts = []
    
    if top_5_sum / total > 0.7:
        alerts.append({
            'type': 'work_concentration',
            'top_5_percentage': top_5_sum / total * 100,
            'description': '70%+ du travail par 5 personnes (possible exploitation)'
        })
    
    # Détecter les outliers (travail excessif)
    for user, user_acts in user_actions.items():
        if len(user_acts) > mean + 3 * std:
            alerts.append({
                'type': 'excessive_work',
                'user': user,
                'action_count': len(user_acts),
                'mean': mean,
                'description': f'{user} fait {len(user_acts)} actions (moyenne: {mean:.0f})'
            })
    
    return alerts

3. Détecter les faux numéros

# detect_fake_phones.py
import re

def analyze_phone_numbers(phone_numbers):
    """
    Détecter les numéros de téléphone suspects (prépayés, virtuels)
    """
    suspicious_patterns = [
        # Prépayés / virtuels
        r'^\+447',   # UK mobile (facilement accessible)
        r'^\+337',   # FR mobile (prépayé)
        r'^\+1\d{10}$',  # US/Canada (nombreux services virtuels)
        # Services en ligne
        r'^\+44\d{7,10}$',  # UK virtual
        # SMS services
        r'^\+372',  # Estonie (services virtuels)
    ]
    
    alerts = []
    
    for phone in phone_numbers:
        for pattern in suspicious_patterns:
            if re.match(pattern, phone):
                alerts.append({
                    'type': 'suspicious_phone',
                    'phone': phone,
                    'pattern': pattern,
                    'description': 'Numéro potentiellement virtuel/prépayé'
                })
    
    # Détecter les numéros non réutilisés (usage unique)
    # (nécessite une base de données de numéros vus)
    
    return alerts

4. Pour les utilisateurs — Détecter une organisation opaque

## Signaux d'alerte d'une organisation suspecte

1. **Compartimentage** : L'admin principal n'est jamais accessible
2. **Bénévolat forcé** : Le staff "bénévole" fait 70%+ du travail
3. **Communication fermée** : Telegram obligatoire, pas d'alternatives
4. **Faux identités** : Numéros de téléphone virtuels, emails jetables
5. **Rotation** : Turnover élevé, recrutement constant
6. **Opacité financière** : Refus de répondre sur la rémunération
7. **Règles restrictives** : "Ne jamais poser de questions sur l'administration"
8. **Proxies multiples** : Plusieurs noms de domaine, structures opaques
9. **Pas de transparence** : Pas de rapport financier, pas de statuts
10. **Pression sociale** : "Si tu poses des questions, tu es renvoyé"

Checklist de validation

Pas de compartimentage excessif (tous les membres peuvent communiquer)
Distribution équitable des responsabilités (pas de concentration 70%+)
Transparence sur la structure financière (si revenus)
Pas de numéros de téléphone virtuels pour l'administration
Pas de règle "ne jamais poser de questions"
Pas de recrutement systématique de bénévoles pour gérer des revenus
Communication via des canaux traçables (pas uniquement Telegram secret)
Turnover normal (pas de renvois/rentrées fréquentes)
Identités vérifiables des administrateurs
Rapports financiers transparents (si organisation à but lucratif)

Références

Archive Ygg : L'organisation (YGGLeak)
Telegram : https://telegram.org