RGPD & Gouvernance IA
Conformité · AI Act · Éthique · DPO

1. Les 6 bases légales du traitement (Art. 6 RGPD)

Tout traitement de données personnelles doit reposer sur une et une seule base légale. Choisir la mauvaise base invalide l’intégralité du traitement.

2. Responsable de traitement vs Sous-traitant

• Responsable de traitement : détermine les finalités et les moyens du traitement. Porte la responsabilité juridique principale. Ex : l’entreprise qui entraîne un modèle sur les données de ses clients.
• Sous-traitant : traite les données pour le compte du responsable. Doit signer un Data Processing Agreement (DPA) — Art. 28. Ex : OpenAI, AWS, Google Cloud si vous leur envoyez des données personnelles.
• Piège fréquent : utiliser l’API d’un LLM externe (OpenAI, Anthropic) avec des données personnelles sans DPA signé = violation RGPD. Vérifier le DPA et les clauses contractuelles types (CCT).

3. Données sensibles — Art. 9 RGPD

Les données de catégorie spéciale nécessitent une base légale renfocée : consentement explicite, intérêt public substantiel ou traitement nécessaire à la santé.

# Catégories de données sensibles Art. 9 — à traiter avec précaution
DONNEES_SENSIBLES = [
    "origine_raciale_ethnique",
    "opinions_politiques",
    "convictions_religieuses",
    "donnees_genetiques",
    "donnees_biometriques",  # reconnaissance faciale !
    "donnees_sante",
    "vie_sexuelle",
    "condamnations_penales",  # Art. 10
]

def check_dataset_rgpd(df: pd.DataFrame) -> dict:
    """Audit rapide d'un DataFrame pour détecter colonnes à risque."""
    risques = {}
    colonnes_risque = {
        "age": "potentiellement discriminatoire",
        "genre": "données personnelles",
        "email": "identifiant direct",
        "ip": "identifiant indirect (CJUE 2016)",
        "photo": "données biométriques potentielles",
        "sante": "Art. 9 — catégorie spéciale",
    }
    for col in df.columns:
        for mot_cle, risque in colonnes_risque.items():
            if mot_cle in col.lower():
                risques[col] = risque
    return risques

4. Registre des activités de traitement (Art. 30)

Obligatoire pour toute organisation >250 salariés ou traitant des données sensibles. Doit documenter : finalité, catégories de données, durées de conservation, destinataires, mesures de sécurité.

# Exemple d'entrée dans le registre — format Python/JSON
REGISTRE_TRAITEMENT = [
    {
        "id": "T-001",
        "nom": "Modèle de scoring crédit",
        "responsable": "Direction Risques",
        "finalite": "Évaluation automatisée solvabilité clients",
        "base_legale": "Art. 6.1.b — exécution du contrat",
        "categories_donnees": ["revenus", "historique_bancaire"],
        "duree_conservation": "5 ans après fin de relation",
        "transferts_hors_ue": "Aucun",
        "decision_automatisee": True,  # → DPIA obligatoire (Art. 22)
        "mesures_securite": ["chiffrement AES-256", "accès RBAC"],
    }
]

1. Privacy by Design — 7 principes fondateurs (Ann Cavoukian)

• Proactif, pas réactif : intégrer la protection des données avant de coder, pas après une violation.
• Vie privée par défaut : les paramètres les plus protecteurs doivent être activés par défaut.
• Intégrée dans la conception : la protection fait partie de l’architecture, pas un add-on.
• Fonctionnalité totale : sécurité ET utilité ne sont pas antagonistes.
• Sécurité de bout en bout : chiffrement tout au long du cycle de vie de la donnée.
• Visibilité et transparence : les traitements doivent être auditable et documentables.
• Respect de la vie privée des utilisateurs : contrôle donné à la personne concernée.

2. Pseudonymisation vs Anonymisation — différence clé

import hashlib, hmac, os
import pandas as pd

# ── Pseudonymisation ────────────────────────────────────────
# Réversible avec la clé secrète — toujours soumis au RGPD
SECRET_KEY = os.environ["PSEUDO_KEY"].encode()

def pseudonymiser(valeur: str) -> str:
    """HMAC-SHA256 : même entrée → même hash, réversible avec la clé."""
    return hmac.new(SECRET_KEY, valeur.encode(), hashlib.sha256).hexdigest()[:16]

df["user_id_pseudo"] = df["email"].apply(pseudonymiser)
df = df.drop(columns=["email", "nom", "prenom"])

# ── Anonymisation ───────────────────────────────────────────
# Irréversible — sort du champ d'application du RGPD
# Techniques : k-anonymat, l-diversité, differential privacy

from sklearn.preprocessing import KBinsDiscretizer

# k-anonymat : généraliser l'âge en tranches
enc = KBinsDiscretizer(n_bins=5, encode="ordinal", strategy="quantile")
df["tranche_age"] = enc.fit_transform(df[["age"]])
# Supprimer les quasi-identifiants (nom, code postal précis...)
df = df.drop(columns=["age", "code_postal"])

3. DPIA — Analyse d’Impact relative à la Protection des Données (Art. 35)

La DPIA est obligatoire pour : profilage systématique, traitement de données sensibles à grande échelle, surveillance systématique d’espaces publics, décisions automatisées avec effet légal (scoring crédit, recrutement IA).

1. Tableau des droits et délais réglementaires

2. Machine Unlearning — droit à l’effacement sur les modèles

Quand une personne demande l’effacement de ses données, si elles ont servi à entraîner un modèle, celui-ci a potentiellement mémorisé ces informations. Deux approches :

# Approche 1 : Réentraînement complet sans les données effacées
# Simple mais coûteux pour les grands modèles

def retrain_without(dataset, ids_to_remove, model_class):
    clean_df = dataset[~dataset["user_id"].isin(ids_to_remove)]
    model = model_class()
    model.fit(clean_df.drop("target", axis=1), clean_df["target"])
    return model

# Approche 2 : SISA (Sharded, Isolated, Sliced, Aggregated)
# Entraîner sur des shards indépendants → ne réentraîner que le shard concerné
class SISAModel:
    def __init__(self, n_shards=10):
        self.shards = [{} for _ in range(n_shards)]
        self.models = [None] * n_shards

    def unlearn(self, user_id: str):
        shard_idx = hash(user_id) % len(self.shards)
        # Supprimer l'utilisateur et réentraîner uniquement ce shard
        self.shards[shard_idx].pop(user_id, None)
        self._retrain_shard(shard_idx)

3. Décisions automatisées — Art. 22 RGPD

Toute décision produisant des effets juridiques ou affectant significativement une personne et fondée exclusivement sur un traitement automatisé est en principe interdite, sauf : consentement explicite, nécessité contractuelle, autorisation légale. Obligation de prévoir une procédure de contestation humaine.

1. Chiffrement des données au repos et en transit

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

# ── Chiffrement symétrique AES-GCM (recommandé ANSSI) ───────
key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)
nonce = os.urandom(12)  # 96 bits — unique par chiffrement

donnee_sensible = "email:jean.dupont@example.com".encode()
chiffre = aesgcm.encrypt(nonce, donnee_sensible, None)
dechiffre = aesgcm.decrypt(nonce, chiffre, None)

# ── Chiffrement colonne Pandas pour stockage ────────────────
f = Fernet(Fernet.generate_key())

def chiffrer_colonne(df: pd.DataFrame, col: str) -> pd.DataFrame:
    df = df.copy()
    df[col + "_enc"] = df[col].apply(
        lambda x: f.encrypt(x.encode()).decode()
    )
    return df.drop(columns=[col])

df_securise = chiffrer_colonne(df, "email")

2. Violation de données — obligation de notification 72h (Art. 33-34)

• Notification CNIL (Art. 33) : dans les 72 heures après la découverte, si le risque pour les personnes est probable. Sur le portail notifications.cnil.fr.
• Notification aux personnes (Art. 34) : obligatoire si le risque est élevé (données de santé, données financières, mots de passe non hachés).
• Contenu de la notification CNIL : nature de la violation, catégories et nombre approximatif de personnes touchées, coordonnées du DPO, conséquences probables, mesures prises.

# Procédure de réponse à incident — à automatiser en astreinte
from datetime import datetime, timedelta

class IncidentRGPD:
    def __init__(self, description: str):
        self.detected_at = datetime.utcnow()
        self.deadline_cnil = self.detected_at + timedelta(hours=72)
        self.description = description
        self.severity = None
        self.actions_log = []

    def evaluer_severite(self, donnees_sensibles: bool,
                         nb_personnes: int) -> str:
        if donnees_sensibles or nb_personnes > 10000:
            self.severity = "ÉLEVÉ"  # → notifier CNIL + personnes
        elif nb_personnes > 100:
            self.severity = "MODÉRÉ"  # → notifier CNIL
        else:
            self.severity = "FAIBLE"  # → documenter en interne
        return self.severity

3. Contrôle d’accès RBAC sur les données personnelles

from enum import Enum
from functools import wraps

class Role(Enum):
    ANALYSTE = "analyste"       # données pseudonymisées
    DATA_ENGINEER = "data_eng"  # données brutes non-sensibles
    DPO = "dpo"                 # accès complet pour audit

PERMISSIONS = {
    Role.ANALYSTE: {"pseudo", "agregats"},
    Role.DATA_ENGINEER: {"pseudo", "raw_non_sensible"},
    Role.DPO: {"pseudo", "raw_sensible", "audit_logs"},
}

def require_permission(permission: str):
    def decorator(func):
        @wraps(func)
        def wrapper(user_role: Role, *args, **kwargs):
            if permission not in PERMISSIONS[user_role]:
                raise PermissionError(
                    f"Rôle {user_role.value} non autorisé pour {permission}"
                )
            return func(user_role, *args, **kwargs)
        return wrapper
    return decorator

@require_permission("raw_sensible")
def acceder_donnees_sante(role, patient_id): ...

1. Les 4 niveaux de risque de l’AI Act (en vigueur 2024–2026)

2. Obligations pour les systèmes IA à haut risque

# Checklist AI Act — système à haut risque
class AIActComplianceChecker:
    """Vérifie la conformité AI Act pour un système à haut risque."""

    CHECKLIST_HAUT_RISQUE = {
        "systeme_gestion_risques": "Processus continu d'identification des risques",
        "gouvernance_donnees": "Données d'entraînement exemptes de biais documentés",
        "documentation_technique": "Fiche technique complète (architecture, métriques, limites)",
        "journaux_automatiques": "Logs horodatés des décisions sur 10 ans minimum",
        "transparence_utilisateurs": "Notice claire sur capacités et limites",
        "supervision_humaine": "Mécanisme d'override humain opérationnel",
        "robustesse_securite": "Résistance aux adversarial attacks testée",
        "enregistrement_bd_ue": "Enregistré dans la base de données UE (art. 71)",
    }

    def audit(self, model_doc: dict) -> list[str]:
        manquants = []
        for item, desc in self.CHECKLIST_HAUT_RISQUE.items():
            if not model_doc.get(item):
                manquants.append(f"MANQUANT : {desc}")
        return manquants

3. GPT-4, Claude, Gemini — modèles à usage général (GPAI)

Les modèles d’IA à usage général avec plus de 10²⁵ FLOPs d’entraînement sont soumis à des obligations supplémentaires : transparence envers l’autorité de supervision, évaluation de risques systémiques, signalement des incidents graves.

1. Rôle du DPO (Délégué à la Protection des Données)

Le DPO est obligatoire pour : organismes publics, entreprises dont l’activité principale implique un suivi régulier et systématique des personnes à grande échelle, ou un traitement à grande échelle de données sensibles.

• Conseille le responsable de traitement et les employés
• Contrôle le respect du RGPD et détermine les risques
• Coopère avec la CNIL et est le point de contact pour les exercices de droits
• Ne peut pas recevoir d’instructions sur la manière d’exercer ses missions (indépendance garantie Art. 38)

2. Détection de biais dans les modèles ML — Fairlearn

from fairlearn.metrics import (
    demographic_parity_difference,
    equalized_odds_difference,
    MetricFrame
)
from sklearn.metrics import accuracy_score
import numpy as np

# Données exemple : modèle de scoring crédit
y_true = np.array([1,0,1,1,0,1,0,1])
y_pred = np.array([1,0,1,0,0,1,0,0])
genre = np.array(["H","H","F","F","H","F","H","F"])

# Parité démographique : différence de taux de prédiction positive
dpd = demographic_parity_difference(y_true, y_pred,
                                    sensitive_features=genre)
print(f"Parité démographique : {dpd:.3f}")
# Seuil RGPD/AI Act : |dpd| < 0.1 recommandé

# MetricFrame : métriques détaillées par groupe
mf = MetricFrame(
    metrics=accuracy_score,
    y_true=y_true,
    y_pred=y_pred,
    sensitive_features=genre
)
print(mf.by_group)  # accuracy par genre
print(f"Écart max : {mf.difference():.3f}")

3. Audit de conformité d’un pipeline ML — checklist opérationnelle

# Audit RGPD + AI Act d'un pipeline ML — à lancer avant déploiement
AUDIT_ML_PIPELINE = {
    # ── Données ─────────────────────────────────────────────
    "origine_donnees_documentee": False,   # source, date, consentement
    "base_legale_identifiee": False,
    "minimisation_appliquee": False,       # pas de features superflues
    "donnees_sensibles_absentes": False,    # ou base Art. 9 justifiée
    "pseudonymisation_faite": False,

    # ── Modèle ───────────────────────────────────────────────
    "biais_evalues_fairlearn": False,
    "explicabilite_shap_lime": False,
    "metriques_par_groupe": False,
    "decision_automatisee_flag": False,    # → DPIA si True

    # ── Déploiement ──────────────────────────────────────────
    "supervision_humaine_prevue": False,
    "procedure_droits_personnes": False,   # effacement, rectification
    "monitoring_derive_prevu": False,
    "dpa_sous_traitants_signe": False,     # AWS, Azure, OpenAI...
    "registre_traitement_mis_a_jour": False,
}

score = sum(AUDIT_ML_PIPELINE.values()) / len(AUDIT_ML_PIPELINE)
print(f"Score conformité : {score:.0%}")
if score < 0.8:
    print("⚠ Déploiement non recommandé — risques RGPD/AI Act identifiés")