ISO 27001 et Auth0 : contrôles IAM pour votre SMSI

Alignez votre configuration Auth0 avec les contrôles ISO 27001:2022 relatifs à la gestion des identités et accès. Preuves, documentation et questionnaire auditeur.

Par Auth0.Expert · 2025-06-09 · 12 min de lecture

ISO27001 SMSI Conformité Auth0

ISO 27001 et Auth0 : contrôles IAM pour votre SMSI

TL;DR

ISO 27001:2022 inclut des contrôles spécifiques à la gestion des identités et accès (Annexe A, domaine 5 et 8). Auth0, certifié SOC2/ISO27001, peut vous aider à satisfaire ces contrôles dans votre propre SMSI.

Contrôles ISO 27001:2022 × Auth0

Ce tableau récapitule les contrôles ISO 27001 essentiels liés à l’IAM et leur correspondance avec Auth0.

Annexe A — Contrôles pertinents pour l'IAM :

5.15 : Contrôle d'accès
5.16 : Gestion des identités
5.17 : Informations d'authentification
5.18 : Droits d'accès
8.2  : Droits d'accès privilégiés
8.3  : Restriction d'accès aux informations
8.4  : Accès au code source
8.5  : Authentification sécurisée
8.6  : Gestion des capacités

Contrôle 5.15 : Contrôle d'accès

Ici, vous limitez les accès aux ressources selon le rôle utilisateur, par une règle Post-Login Auth0.

// Evidence : politique d'accès implémentée dans Auth0
// Actions → Post-Login Rule documentée

// Politique d'accès basée sur le rôle et le contexte
exports.onExecutePostLogin = async (event, api) => {
  const user = event.user;
  const role = user.app_metadata?.role;
  const resource = event.client.name;

  // Matrice d'accès documentée (joindre à votre SMSI)
  const accessMatrix = {
    "employee": ["intranet", "email", "crm-read"],
    "manager": ["intranet", "email", "crm-write", "hr-portal"],
    "admin": ["*"],  // Avec MFA obligatoire
    "contractor": ["project-portal"],  // Accès limité
  };

  const allowedResources = accessMatrix[role] || [];

  if (!allowedResources.includes("*") && !allowedResources.includes(resource)) {
    api.access.deny(`Access to ${resource} not authorized for role ${role}`);
  }
};

Ce bloc implémente un contrôle d'accès centralisé après connexion, en refusant l'accès aux ressources non autorisées selon la matrice d'accès.

Contrôle 5.17 : Informations d'authentification

Ce code définit une politique de mot de passe conforme aux exigences ISO 27001, à configurer dans Auth0.

// Politique de mots de passe ISO 27001
// Auth0 Password Policy via Management API

const iso27001PasswordPolicy = {
  // 5.17 : Gestion des informations d'authentification secrètes
  password_complexity_options: {
    min_length: 12,
    requires_uppercase: true,
    requires_lowercase: true,
    requires_numbers: true,
    requires_symbols: true,
  },
  password_history: {
    enable: true,
    size: 12  // Interdire 12 derniers MDP
  },
  password_dictionary: {
    enable: true  // Bloquer MDP compromis
  },

  // Correspondance documentaire
  "iso_control": "5.17",
  "policy_ref": "SMSI-POL-ACCES-001"
};

Contrôle 8.2 : Droits d'accès privilégiés

Ce bout de code démontre comment renforcer les accès administrateurs via MFA, une session temporaire et une traçabilité.

// Contrôle strict des accès administrateurs
exports.onExecutePostLogin = async (event, api) => {
  if (!event.user.app_metadata?.is_admin) return;

  // 8.2 : Les droits d'accès privilégiés doivent être restreints et contrôlés

  // 1. MFA obligatoire
  const mfaUsed = event.authentication?.methods?.some(m => m.name === "mfa");
  if (!mfaUsed) {
    api.access.deny("MFA required for privileged access (ISO 27001:2022 8.2)");
    return;
  }

  // 2. Durée de session limitée (Just-in-Time access)
  api.session.setExpiration(3600); // 1h

  // 3. Ajouter timestamp d'accès privilégié au token
  api.accessToken.setCustomClaim("privileged_access", {
    granted_at: new Date().toISOString(),
    expires_at: new Date(Date.now() + 3600000).toISOString(),
    mfa_verified: true,
    policy_ref: "SMSI-POL-PRIV-001"
  });

  // 4. Notifier le SOC
  await api.cache.set("privileged_access_" + event.user.user_id, {
    timestamp: new Date().toISOString(),
    user: event.user.email
  }, { ttl: 3600 });
};

Ce script gère de façon automatisée l’accès privilégié : MFA, session limitée, journalisation, et notification SOC.

Contrôle 8.5 : Authentification sécurisée

Ce bloc décrit comment structurer la politique d’authentification selon le profil dans votre SMSI.

// 8.5 : Procédures d'authentification sécurisée
// Documentation pour votre SMSI :

const authenticSecureProcedures = {
  "standard_users": {
    primary: "password",
    mfa: "optional",
    min_strength: "strong"
  },
  "privileged_users": {
    primary: "password",
    mfa: "required",
    mfa_methods: ["webauthn", "totp"],
    min_strength: "very_strong"
  },
  "external_access": {
    primary: "sso_or_password",
    mfa: "required",
    ip_restriction: "optional"
  },
  "api_access": {
    primary: "client_credentials",
    type: "m2m",
    secret_rotation: "90_days"
  }
};

// À documenter dans votre SMSI comme Policy Statement

Revue trimestrielle des accès (5.18)

Ici, un exemple de script Python pour réaliser la revue périodique des droits, conformément à ISO 27001:2022.

# Script pour revue trimestrielle des droits d'accès
# ISO 27001:2022 - Contrôle 5.18 : Droits d'accès

def generate_access_review_report(mgmt_token: str, domain: str) -> dict:
    headers = {"Authorization": f"Bearer {mgmt_token}"}
    base = f"https://{domain}/api/v2"

    # Récupérer tous les utilisateurs
    users = requests.get(
        f"{base}/users",
        headers=headers,
        params={"per_page": 100, "fields": "user_id,email,app_metadata,last_login,created_at,blocked"}
    ).json()

    review_date = datetime.utcnow().isoformat()
    ninety_days_ago = (datetime.utcnow() - timedelta(days=90)).isoformat()

    report = {
        "review_date": review_date,
        "reviewer": "RSSI",
        "iso_control": "5.18",
        "next_review": (datetime.utcnow() + timedelta(days=90)).isoformat(),
        "summary": {
            "total_users": len(users),
            "active_users": 0,
            "inactive_users": 0,
            "privileged_users": 0,
            "blocked_users": 0
        },
        "users": []
    }

    for user in users:
        last_login = user.get("last_login", "never")
        is_inactive = last_login == "never" or last_login < ninety_days_ago
        is_privileged = user.get("app_metadata", {}).get("is_admin", False)
        is_blocked = user.get("blocked", False)

        user_entry = {
            "user_id": user["user_id"],
            "email": user["email"],
            "role": user.get("app_metadata", {}).get("role", "standard"),
            "is_privileged": is_privileged,
            "last_login": last_login,
            "status": "blocked" if is_blocked else ("inactive" if is_inactive else "active"),
            "action_required": "REVIEW" if is_inactive and is_privileged else "OK"
        }

        # Compteurs
        if is_blocked:
            report["summary"]["blocked_users"] += 1
        elif is_inactive:
            report["summary"]["inactive_users"] += 1
        else:
            report["summary"]["active_users"] += 1

        if is_privileged:
            report["summary"]["privileged_users"] += 1

        report["users"].append(user_entry)

    return report

Ce script génère un rapport complet facilitant la revue formelle des droits d’accès, triant les comptes inactifs, bloqués et privilégiés.

Tableau de correspondance ISO 27001 × Auth0

Ce tableau de synthèse met en relation les exigences ISO 27001 avec les fonctionnalités Auth0 et leur documentation type.

| Contrôle | Description | Feature Auth0 | Documentation SMSI | |---|---|---|---| | 5.15 | Contrôle accès | RBAC + Actions | Matrice d'accès | | 5.16 | Gestion identités | User Management | Procédure onboarding | | 5.17 | Authentification | Password Policy | Politique MDP | | 5.18 | Droits accès | Roles + Audit | Rapport revue trimestrielle | | 8.2 | Accès privilégiés | Admin + MFA | Procédure accès admin | | 8.5 | Auth sécurisée | MFA + WebAuthn | Policy authentification | | 8.6 | Gestion capacité | Rate limiting | Plan capacité |

Questionnaire auditeur ISO 27001

Voici les questions classiques des auditeurs et comment y répondre avec Auth0.

Questions typiques d'un auditeur × Auth0 :

1. "Comment gérez-vous le cycle de vie des comptes ?"
   → Montrer : onboarding Action + offboarding script

2. "Comment sont révoqués les accès à la fin de contrat ?"
   → Montrer : DELETE /users/{id} + script RH automatisé

3. "Quelle est votre politique MFA ?"
   → Montrer : Auth0 Actions + MFA Policies Dashboard

4. "Comment tracez-vous les accès administrateurs ?"
   → Montrer : Log Streaming + Datadog dashboard

5. "Comment effectuez-vous la revue des droits ?"
   → Montrer : script revue trimestrielle + rapport signé

6. "Auth0 est-il lui-même certifié ?"
   → trust.okta.com : SOC2 Type II + ISO27001 + autres

Auth0.Expert vous accompagne dans la préparation de votre certification ISO 27001 en fournissant toute la documentation IAM nécessaire pour votre SMSI.

Autres articles