Niveau 10 — Conformité | Automatisation | CIS Benchmark | Annexes

13. Niveau 10 — Conformité Réglementaire

13.1 Conformité RGPD

Le RGPD impose des obligations précises sur la gestion des données personnelles. Un audit Google Workspace doit évaluer la conformité article par article.

def calculate_gdpr_score(findings):
    """Calcule un score de conformité RGPD basé sur les findings."""
    score = 100
    violations = []

    # Art. 5(1)(e) — Vieux fichiers
    old_ratio = findings.get("drive", {}).get("old_files_ratio", 0)
    if old_ratio > 0.3:
        score -= 10
        violations.append(("Art. 5(1)(e)", "MOYEN", f"{old_ratio:.0%} de fichiers > 3 ans"))

    # Art. 5(1)(f) — Fichiers publics
    public_files = findings.get("drive", {}).get("public_files_count", 0)
    if public_files > 0:
        score -= 15
        violations.append(("Art. 5(1)(f)", "ÉLEVÉ", f"{public_files} fichiers publics"))

    # Art. 32 — Transfert email
    if findings.get("gmail", {}).get("has_forwarding"):
        score -= 20
        violations.append(("Art. 32", "CRITIQUE", "Transfert automatique email vers tiers"))

    # Art. 9 & 32 — Données RH
    sensitive_files = findings.get("drive", {}).get("sensitive_files_count", 0)
    if sensitive_files > 100:
        score -= 20
        violations.append(("Art. 9 & 32", "CRITIQUE", f"{sensitive_files} fichiers sensibles non chiffrés"))

    return max(0, score), violations

13.2 Conformité NIS2

La directive NIS2 s'applique aux entités importantes et essentielles, notamment les ESN/prestataires IT. Les obligations clés à auditer :

13.3 CIS Benchmark Google Workspace

Le Center for Internet Security publie un benchmark de sécurité spécifique à Google Workspace. Voir la Section 16 pour le détail complet.

Un score < 50% indique une posture de sécurité insuffisante.

---

14. Automatisation et Outillage

14.1 Architecture du framework d'audit

audit-workspace/
├── config.py              # Configuration centralisée
├── auth.py                # Authentification Service Account
├── main.py                # Orchestrateur principal
├── run_full_audit.py      # Exécution de tous les modules
│
├── audit_users.py         # Niveau 1 — IAM
├── audit_gmail.py         # Niveau 2 — Gmail
├── audit_drive.py         # Niveau 3 — Drive (partages)
├── audit_drive_files.py   # Niveau 3 — Drive (fichiers)
├── audit_dns.py           # Niveau 4 — DNS
├── audit_oauth_apps.py    # Niveau 5 — OAuth
├── audit_less_secure.py   # Niveau 1 — Tokens + Recovery
├── audit_devices.py       # Niveau 6 — MDM
├── audit_groups.py        # Niveau 7 — Groupes
├── audit_alerts.py        # Niveau 8 — Alert Center
├── audit_admin_logs.py    # Niveau 8 — Logs admin
├── audit_login.py         # Niveau 8 — Logs connexion
├── audit_calendar.py      # Niveau 2 — Calendar
├── audit_recon.py         # Niveau 9 — Recon passive
├── audit_hibp.py          # Niveau 9 — HIBP
├── audit_darkweb.py       # Niveau 9 — Dark web
├── audit_compliance.py    # Niveau 10 — RGPD/NIS2
│
└── reports/
    ├── AUDIT_SECURITE_YYYYMMDD.md
    ├── extra_modules.json
    ├── levels_1_4.json
    ├── login_audit.json
    ├── calendar_audit.json
    └── drive_files_analysis.json

14.2 Orchestrateur principal

# run_full_audit.py
import os, sys, json
os.environ["PYTHONUTF8"] = "1"

from auth import get_directory_service, get_reports_service
from audit_users import audit_all_users
from audit_gmail import audit_gmail_all_users
from audit_drive import audit_drive_shares
from audit_drive_files import audit_drive_files_deep
from audit_dns import check_all_dns
from audit_oauth_apps import audit_oauth_apps
from audit_less_secure import audit_user_security_settings, audit_user_recovery_info
from audit_devices import audit_mobile_devices
from audit_groups import audit_groups
from audit_alerts import audit_alert_center
from audit_admin_logs import audit_admin_logs
from audit_login import audit_login_activity
from audit_calendar import audit_all_calendars
from audit_recon import check_certificate_transparency, check_mx_blacklists
from audit_compliance import assess_rgpd_compliance, assess_nis2_compliance

def run_full_audit():
    """Exécute l'audit complet en lecture seule."""
    print("[*] Démarrage de l'audit Google Workspace...")

    service = get_directory_service()
    reports_service = get_reports_service()

    # Récupération de la liste des utilisateurs
    users = get_all_users(service)
    emails = [u["primaryEmail"] for u in users]
    print(f"[*] {len(emails)} utilisateurs trouvés")

    results = {}

    # Niveaux 1-8 : APIs Google
    results["users"] = audit_all_users(service)
    results["gmail"] = audit_gmail_all_users(emails)
    results["drive"] = audit_drive_shares(emails)
    results["drive_files"] = audit_drive_files_deep(emails[:10])  # Limiter pour les premiers
    results["dns"] = check_all_dns(DOMAIN)
    results["oauth"] = audit_oauth_apps()
    results["security"] = audit_user_security_settings(emails)
    results["recovery"] = audit_user_recovery_info(emails)
    results["devices"] = audit_mobile_devices(service)
    results["groups"] = audit_groups(service)
    results["alerts"] = audit_alert_center(alert_service)
    results["admin_logs"] = audit_admin_logs(reports_service)
    results["logins"] = audit_login_activity(reports_service)
    results["calendar"] = audit_all_calendars(emails)

    # Niveau 9 : Recon et Threat Intel
    results["recon"] = {
        "crt": check_certificate_transparency(DOMAIN),
        "blacklists": check_mx_blacklists(DOMAIN),
    }

    # Niveau 10 : Conformité
    results["rgpd"] = assess_rgpd_compliance(results)
    results["nis2"] = assess_nis2_compliance()

    # Sauvegarde
    with open(f"reports/audit_{DOMAIN}_{datetime.now().strftime('%Y%m%d')}.json", "w") as f:
        json.dump(results, f, ensure_ascii=False, indent=2, default=str)

    print("[+] Audit terminé.")
    return results

14.3 Gestion des erreurs courantes

15. Rapport et Feuille de Route

15.1 Structure du rapport

Un rapport d'audit Google Workspace complet doit contenir :

1. Synthèse Exécutive (1 page)
   - Score global de sécurité
   - Top 5 risques immédiats
   - Métriques clés

2. Findings par niveau de sévérité
   - CRITIQUE : action sous 48h
   - ÉLEVÉ : action sous 7 jours
   - MOYEN : action sous 30 jours
   - INFORMATIF : à planifier

3. Audits détaillés par domaine
   - IAM, Gmail, Drive, DNS, OAuth, MDM, Groupes, Logs

4. Conformité
   - RGPD (score + violations par article)
   - NIS2 (matrice d'obligations)
   - CIS Benchmark (score détaillé)

5. Chemins d'attaque (Kill Chains)
   - Scénarios réalistes basés sur les findings

6. Feuille de route de sécurisation
   - Matrice priorité / effort / impact
   - Planning par semaine/mois

7. Annexes
   - Données brutes
   - Méthodologie
   - Outils utilisés

15.2 Scoring de sécurité

def calculate_security_score(findings):
    """Calcule un score de sécurité global de 0 à 100."""
    score = 100
    deductions = {
        "no_2fa_users": (-5, "par utilisateur sans 2FA"),
        "public_files": (-10, "par fichier public"),
        "active_forwarding": (-20, "transfert email actif"),
        "external_sa_writer": (-15, "service account externe WRITER"),
        "super_admin_external_recovery": (-10, "par Super Admin avec récup externe"),
        "php_eol_server": (-8, "serveur PHP EOL exposé"),
    }
    # ... calcul basé sur les findings
    return max(0, score)

15.3 Matrice de priorisation

Priorité = f(Impact, Probabilité, Effort de correction)

P1 (Immédiat) : Impact CRITIQUE + Probabilité HAUTE + Effort FAIBLE
P2 (J+7)      : Impact ÉLEVÉ  + Probabilité MOYENNE + Effort MOYEN
P3 (J+30)     : Impact MOYEN  + Probabilité BASSE   + Effort ÉLEVÉ
P4 (J+90)     : Gouvernance, processus, formation

15.4 Chemins d'attaque types

Phishing ou insider malveillant
→ Activation d'un transfert automatique Gmail
→ Copie en temps réel de tous les emails vers un tiers
→ Fuite continue de données confidentielles
→ Impact : RGPD, concurrentiel, contractuel

Email de récupération présent dans un stealer log
→ Attaquant accède au compte Gmail/Yahoo de récupération
→ Procédure "mot de passe oublié" sur le compte Workspace
→ Bypass de la 2FA via le code envoyé sur l'email compromis
→ Accès complet au compte (emails, Drive, calendrier)
→ Escalade si compte Super Admin

Email malveillant : "Autorisez cette app pour accéder à votre planning"
→ Utilisateur clique et autorise l'app OAuth
→ L'app obtient les scopes accordés (Gmail, Drive)
→ Exfiltration silencieuse continue
→ Aucune trace dans les logs Gmail standards
→ Persiste même après changement de mot de passe

Clé de service account externe volée ou fuitée
→ Accès aux fichiers Drive partagés avec ce SA
→ Lecture de données confidentielles
→ Injection de code malveillant dans des scripts partagés
→ Exécution par un employé → RCE sur son poste
→ Pivot vers le réseau interne

---

16. Référentiel CIS Benchmark Google Workspace

Le CIS Benchmark for Google Workspace définit 40+ contrôles de sécurité. Voici les contrôles les plus critiques avec leur méthode de vérification :

Section 1 — Gestion des Identités et des Accès

Section 2 — Google Drive

Section 3 — Gmail

Section 4 — Sécurité Email DNS

Section 5 — Applications Tierces

Section 6 — Appareils Mobiles

Section 7 — Groupes

Section 8 — Journalisation

17. Annexes Techniques

Annexe A — Scopes OAuth par module d'audit

Annexe B — Commandes de référence rapide

# Lancer l'audit complet
python -X utf8 run_full_audit.py

# Lancer un module spécifique
python -X utf8 -c "from audit_users import *; print(audit_all_users())"

# Synchroniser l'horloge (Windows)
w32tm /resync /force

# Vérifier DNS manuellement
python -c "import dns.resolver; print(dns.resolver.resolve('cyrias.com','TXT'))"

# Lister les fichiers publics Drive d'un utilisateur
python -X utf8 -c "
from audit_drive import audit_public_files
from auth import get_drive_service
service = get_drive_service('user@domain.com')
print(audit_public_files(service, 'user@domain.com'))
"

Annexe C — Checklist d'audit condensée

• [ ] Service Account créé et clé JSON générée
• [ ] APIs GCP activées (Admin SDK, Gmail, Drive, Calendar, Alert Center)
• [ ] Domain-Wide Delegation configurée sans espaces dans les scopes
• [ ] Horloge système synchronisée
• [ ] Environnement Python configuré (PYTHONUTF8=1)

• [ ] Nombre de Super Admins (≤ 4 recommandé)
• [ ] 2FA enrollée et enforced sur tous les comptes
• [ ] Emails de récupération internes ou absents
• [ ] Comptes inactifs > 90 jours identifiés
• [ ] Comptes suspendus avec offboarding documenté

• [ ] Aucun transfert automatique actif
• [ ] Aucune délégation externe
• [ ] Aucun App Password actif
• [ ] Filtres Gmail avec actions de redirection revus

• [ ] Fichiers publics ("anyone with link") inventoriés
• [ ] Partages externes documentés et justifiés
• [ ] Service accounts tiers avec accès Drive identifiés
• [ ] Fichiers sensibles inventoriés (RH, paie, BDD)

• [ ] SPF -all (hard fail)
• [ ] DKIM actif (2048 bits recommandé)
• [ ] DMARC p=reject avec reporting
• [ ] IP MX non listées sur blacklists

• [ ] Volume de tokens par utilisateur
• [ ] Scopes accordés (Gmail complet, Drive complet = CRITIQUE)
• [ ] Applications AI avec accès données d'entreprise

• [ ] Sous-domaines via crt.sh
• [ ] Serveurs exposés (Shodan)
• [ ] Emails compromis (HIBP)
• [ ] Emails de récupération dans stealer logs

• [ ] Clé Service Account révoquée
• [ ] Délégation domain-wide retirée
• [ ] Rapport livré et discuté
• [ ] Roadmap validée avec le client

Annexe D — Audit Google Chat et Meet

Google Chat est souvent négligé dans les audits alors qu'il constitue un canal de communication sensible et un vecteur de partage de données non maîtrisé.

D.1 Risques spécifiques à Google Chat

D.2 Vérifications Chat via admin.google.com

Admin Console → Apps → Google Workspace → Chat
→ Paramètres Chat :
   - Autoriser les utilisateurs externes dans les espaces : À restreindre
   - Historique par défaut : Configurer la rétention
   - Bots : Vérifier la liste des bots autorisés
   - Imports de fichiers : Vérifier les types autorisés

D.3 Audit Google Meet

---

Annexe E — Intégration SIEM et Monitoring Continu

Un audit ponctuel fournit une photographie de la posture de sécurité à un instant T. Pour une protection continue, il est essentiel d'exporter les logs Google Workspace vers un SIEM.

E.1 Options d'export des logs

E.2 Logs prioritaires à collecter

# Applications prioritaires dans l'API Reports
LOG_APPLICATIONS = [
    "login",          # Connexions : succès, échecs, suspicions
    "admin",          # Actions admin : droits, configurations
    "drive",          # Accès fichiers : téléchargements, partages
    "gmail",          # Actions Gmail : forwarding, délégation
    "token",          # Autorisations OAuth
    "groups_enterprise",  # Modifications de groupes
    "meet",           # Réunions enregistrées, participants externes
    "chat",           # Messages (si activé)
    "calendar",       # Partages calendriers, événements sensibles
]

E.3 Règles de détection recommandées

# Exemples de règles SIEM pour Google Workspace

Rule: Super Admin Login Outside Business Hours
  Source: login logs
  Condition: actor.isAdmin = true AND hour(timestamp) NOT IN (8..20)
  Severity: HIGH

Rule: New OAuth Grant with Sensitive Scope
  Source: token logs
  Condition: scope CONTAINS "mail.google.com" OR scope CONTAINS "auth/drive"
  Severity: HIGH

Rule: Gmail Forwarding Activation
  Source: admin logs
  Condition: eventName = "CHANGE_MAIL_FORWARDING_SETTING"
  Severity: CRITICAL

Rule: Multiple Failed Logins
  Source: login logs
  Condition: eventName = "login_failure" AND COUNT > 5 WITHIN 1 hour
  Severity: MEDIUM

Rule: File Shared Publicly
  Source: drive logs
  Condition: eventName = "change_user_access" AND visibility = "people_with_link"
  Severity: HIGH

Rule: Super Admin Role Grant
  Source: admin logs
  Condition: eventName = "ASSIGN_ROLE" AND role = "SUPER_ADMIN"
  Severity: CRITICAL

Rule: Login from New Country
  Source: login logs
  Condition: country NOT IN user_historical_countries AND eventName = "login_success"
  Severity: MEDIUM

E.4 Métriques de maturité SOC pour Workspace

Annexe F — Politique de Mots de Passe et Authentification Avancée

F.1 Vérification de la politique de mots de passe

La politique de mots de passe Workspace se configure dans admin.google.com → Sécurité → Authentification → Politique de mots de passe. Elle n'est pas accessible via API, mais les paramètres à vérifier manuellement sont :

F.2 Context-Aware Access

Context-Aware Access permet de conditionner l'accès aux services Google à des critères contextuels (localisation géographique, appareil géré, plage horaire).

Politique 1 : Accès admin depuis appareils gérés uniquement
  Condition : isAdminUser = true
  Exigence : deviceManagementLevel = MANAGED
  Action si non conforme : Bloquer

Politique 2 : Restriction géographique
  Condition : ALL users
  Exigence : country IN [FR, BE, LU, CH, ...pays_autorisés]
  Action si non conforme : Bloquer ou MFA supplémentaire

Politique 3 : Accès données sensibles depuis IP de confiance
  Condition : Access to Vault or Admin Console
  Exigence : ipRange IN [IP_bureau, IP_VPN]
  Action si non conforme : Bloquer

Politique 4 : Horaires de bureau pour accès admin
  Condition : isAdminUser = true
  Exigence : time IN [08:00-20:00 CET] AND dayOfWeek IN [MON-FRI]
  Action : MFA supplémentaire hors plage

F.3 Passkeys et FIDO2

Les passkeys remplacent le mot de passe par une paire de clés cryptographiques stockées sur l'appareil. Elles sont résistantes au phishing car liées au domaine lors de la création.

Phase 1 : Déployer les clés physiques FIDO2 (YubiKey 5 NFC) pour les Super Admins
          → Blocage complet de toute connexion sans clé physique

Phase 2 : Activer les passkeys pour les utilisateurs à haut risque
          → Dirigeants, équipes financières, équipes IT

Phase 3 : Déployer les passkeys à l'ensemble des utilisateurs
          → Migration progressive, support utilisateurs
          → Conserver SMS OTP comme fallback temporaire uniquement

Phase 4 : Désactiver SMS OTP et backup codes comme facteurs principaux
          → Uniquement FIDO2, TOTP app, ou passkey

---

Annexe G — Gestion des Incidents liés à Workspace

G.1 Procédure d'urgence — Compte compromis

DÉTECTION
└── Alerte Google, signalement utilisateur, ou détection SOC
        ↓
CONFINEMENT IMMÉDIAT (< 15 minutes)
└── 1. Révoquer toutes les sessions actives
       Admin Console → Utilisateurs → [compte] → Réinitialiser l'authentification
    2. Désactiver le compte temporairement
    3. Révoquer tous les tokens OAuth du compte
    4. Si Super Admin : retirer les privilèges admin temporairement
        ↓
INVESTIGATION (< 2 heures)
└── 1. Analyser les logs Login sur 30 jours
    2. Identifier les IPs, heures, pays de connexion
    3. Vérifier si un forwarding a été activé
    4. Vérifier les nouveaux partages Drive créés
    5. Vérifier les OAuth grants créés
    6. Identifier le vecteur initial (phishing ? credential stuffing ?)
        ↓
REMEDIATION
└── 1. Réinitialiser le mot de passe via canal sécurisé hors-bande
    2. Forcer la reconfiguration de la 2FA
    3. Révoquer définitivement les tokens OAuth suspects
    4. Supprimer les forwardings créés
    5. Vérifier et corriger les partages Drive créés pendant l'incident
        ↓
NOTIFICATION (si violation RGPD avérée)
└── 1. Évaluer si des données personnelles ont été compromises
    2. Si oui : notification CNIL dans les 72h (Art. 33 RGPD)
    3. Si risque élevé pour les personnes : notification individuelle (Art. 34)
    4. Documenter : nature, volume, catégories de données affectées
        ↓
RETOUR D'EXPÉRIENCE
└── 1. Rapport post-incident
    2. Identification de la cause racine
    3. Mesures préventives pour éviter la récurrence
    4. Mise à jour de la politique de sécurité

G.2 Indicateurs de Compromission (IoC) spécifiques Workspace

G.3 Commandes d'urgence — Réponse rapide

# Révoquer toutes les sessions d'un utilisateur (lecture + écriture requise)
def revoke_all_sessions(service, user_email):
    """ATTENTION : Action d'écriture — à utiliser en cas d'incident confirmé."""
    service.users().signOut(userKey=user_email).execute()

# Lister les tokens actifs d'un utilisateur (lecture seule)
def list_active_tokens(security_service, user_email):
    tokens = security_service.tokens().list(userKey=user_email).execute()
    return tokens.get("items", [])

# Vérifier le forwarding actif (lecture seule)
def check_active_forwarding(gmail_service, user_email):
    result = gmail_service.users().settings().getAutoForwarding(
        userId=user_email
    ).execute()
    return result if result.get("enabled") else None

---

Annexe H — Scoring et Benchmarking

H.1 Grille de scoring détaillée

La pondération ci-dessous reflète l'impact réel des contrôles sur la posture de sécurité :

H.2 Comparaison sectorielle

H.3 Évolution et suivi dans le temps

Un audit unique n'a que peu de valeur sans suivi. Les indicateurs à suivre trimestriellement :

Tableau de bord trimestriel Google Workspace
┌─────────────────────────────────────────────┐
│ Score global de sécurité         : [  /100] │
│ Conformité CIS Benchmark         : [  %   ] │
│ Emails compromis HIBP (domaine)  : [  /55 ] │
│ Tokens OAuth non revus (> 90j)   : [  #   ] │
│ Partages externes actifs         : [  #   ] │
│ Utilisateurs sans 2FA            : [  #   ] │
│ Super Admins                     : [  #   ] │
│ Alertes Alert Center (30j)       : [  #   ] │
│ Fichiers publics ("anyone")      : [  #   ] │
└─────────────────────────────────────────────┘

Annexe D — Ressources et Références

Annexe E — Modèle de feuille de route

---

Conclusion — Vers une Sécurité Google Workspace Durable

L'audit Google Workspace n'est pas une fin en soi : c'est le point de départ d'un programme de sécurité continu. Les organisations qui traitent cet exercice comme une vérification annuelle ponctuelle resteront exposées entre deux audits. Celles qui intègrent les contrôles automatisés, le monitoring continu et la culture de sécurité dans leur ADN réduiront durablement leur surface d'attaque.

Les cinq leviers de la maturité Workspace

Priorités universelles — Quel que soit le tenant

Quelle que soit la taille de l'organisation ou son niveau de maturité initial, trois actions produisent le plus grand effet de protection en un minimum de temps :

1. Enforcer la 2FA sur tous les comptes, sans exception
   → Réduit de 99% le risque d'account takeover par credential stuffing

2. Supprimer ou remplacer par des emails internes
   tous les emails de récupération externes sur les comptes admins
   → Élimine le bypass 2FA via récupération de compte

3. Désactiver le transfert automatique de messagerie
   et activer une alerte sur toute future activation
   → Stoppe l'exfiltration silencieuse en temps réel

Ces trois contrôles, appliqués en moins d'une heure par un Super Admin, ferment les trois vecteurs d'attaque les plus fréquents et les plus dommageables sur Google Workspace.

---