NIS2 et authentification : ce que la directive impose à votre IAM

La directive NIS2 (effective octobre 2024) impose des exigences sur la sécurité IAM. Configurez Auth0 pour satisfaire les obligations de gestion des identités et incidents.

Par Auth0.Expert · 2025-06-02 · 11 min de lecture

NIS2 Conformité Sécurité Auth0

NIS2 et authentification : ce que la directive impose

TL;DR

La directive NIS2 (Network and Information Security 2), transposée en France par l'ANSSI, impose aux entités essentielles et importantes des exigences de cybersécurité incluant la gestion des identités, l'authentification forte et la notification des incidents dans les 24h/72h.

Qui est concerné ?

Ce tableau liste les secteurs et seuils concernés par NIS2, facilitant l’identification des entreprises concernés.

Entités Essentielles (EE) — secteurs critiques :
- Énergie, Transport, Banque/Finance
- Santé, Eau potable, Infrastructure numérique
- Administration publique

Entités Importantes (EI) — secteurs importants :
- Services postaux, Gestion des déchets
- Chimie, Alimentation
- Fabrication industrielle
- Fournisseurs numériques (cloud, moteurs de recherche)

Seuils : > 50 employés ou > 10M€ CA pour EI
          > 250 employés ou > 50M€ CA pour EE

Obligations NIS2 × Auth0

Authentification forte (Article 21)

Ce code impose l’authentification multi-facteur (MFA) pour les applications critiques identifiées par NIS2, priorisant les méthodes résistantes au phishing.

// NIS2 Art. 21 : "Politiques et procédures relatives aux mesures de sécurité"
// Impose l'authentification multi-facteur pour les systèmes critiques

exports.onExecutePostLogin = async (event, api) => {
  // Identifier les applications critiques NIS2
  const criticalApps = process.env.NIS2_CRITICAL_APPS?.split(",") || [];

  if (!criticalApps.includes(event.client.client_id)) return;

  // MFA obligatoire - phishing-resistant préféré pour systèmes critiques
  const mfaUsed = event.authentication?.methods?.some(m => m.name === "mfa");

  if (!mfaUsed) {
    api.authentication.challengeWithAny([
      { type: "webauthn-roaming" },  // Clé FIDO2 — préféré NIS2
      { type: "webauthn-platform" }, // Biométrie
      { type: "totp" }               // TOTP — minimum acceptable
    ]);
  }

  // Logger pour traçabilité NIS2
  api.accessToken.setCustomClaim("nis2_auth_level", {
    mfa_used: mfaUsed,
    mfa_method: event.authentication?.methods,
    risk_level: "critical"
  });
};

Ce script vérifie et impose la MFA sur les applications critiques, puis log le niveau d’authentification pour assurer la traçabilité.

Gestion des accès privilégiés

La section suivante contrôle l'accès des administrateurs selon les exigences NIS2, en renforçant la sécurité et la traçabilité.

// NIS2 : contrôle strict des accès administrateurs
exports.onExecutePostLogin = async (event, api) => {
  const isAdminRole = event.user.app_metadata?.roles?.includes("admin");

  if (!isAdminRole) return;

  // Vérifications supplémentaires pour les admins
  const checks = {
    mfa_used: event.authentication?.methods?.some(m => m.name === "mfa"),
    ip_allowed: isIPAllowed(event.request.ip),
    working_hours: isWorkingHours(),
    account_active: !event.user.blocked
  };

  if (!checks.mfa_used) {
    api.access.deny("MFA required for administrative access (NIS2 compliance)");
    return;
  }

  if (!checks.ip_allowed) {
    // Alerter mais ne pas bloquer (peut être du remote work)
    await notifySecurityTeam({
      event: "admin_login_unusual_ip",
      user: event.user.email,
      ip: event.request.ip
    });
  }

  // Durée de session réduite pour admins
  api.session.setExpiration(3600); // 1h max
};

Ce code met en place un contrôle d’accès renforcé pour les comptes admin, avec MFA obligatoire et surveillance des connexions inhabituelles.

Notification d'incidents (Article 23)

Cette partie montre comment automatiser la détection et la notification rapide des incidents selon NIS2, en utilisant Auth0 Log Streaming et un webhook.

# NIS2 Art. 23 : notification dans les 24h (alerte initiale) / 72h (rapport)
# Implémenter via Auth0 Log Streaming + webhook

class NIS2IncidentNotifier:
    def __init__(self, anssi_portal_url: str, api_key: str):
        self.portal_url = anssi_portal_url
        self.api_key = api_key

    def assess_incident(self, auth0_log_event: dict) -> dict | None:
        """Évaluer si un événement Auth0 constitue un incident NIS2"""

        # Événements déclenchant une notification NIS2
        nis2_trigger_types = {
            "pwd_leak": "high",      # Credential breach
            "anomaly": "medium",     # Anomalie détectée
            "limit_mu": "medium",    # Rate limiting massif
            "f": None,               # Failed login — évaluer le volume
        }

        event_type = auth0_log_event.get("type")

        if event_type == "f":
            # Brute force si > 100 échecs en 5 minutes
            if auth0_log_event.get("_count", 0) > 100:
                return {
                    "type": "brute_force_attack",
                    "severity": "high",
                    "affected_users": auth0_log_event.get("affected_users", 0)
                }
            return None

        if event_type in nis2_trigger_types and nis2_trigger_types[event_type]:
            return {
                "type": event_type,
                "severity": nis2_trigger_types[event_type],
                "affected_users": 1
            }

        return None

    def submit_24h_notification(self, incident: dict) -> str:
        """Soumission notification initiale 24h (ANSSI)"""

        notification = {
            "incident_id": f"NIS2-{datetime.utcnow().strftime('%Y%m%d%H%M%S')}",
            "notification_type": "initial",  # < 24h
            "incident_date": datetime.utcnow().isoformat(),
            "incident_type": incident["type"],
            "severity": incident["severity"],
            "affected_services": ["authentication", "user_access"],
            "affected_users_estimate": incident.get("affected_users", 0),
            "initial_containment": "Auth0 Attack Protection activated",
            "ongoing": True
        }

        resp = requests.post(
            f"{self.portal_url}/api/incidents/notify",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json=notification
        )

        return notification["incident_id"]

Cette classe automatise le traitement et la soumission des notifications d’incident NIS2 à l’ANSSI, assurant la conformité temporelle.

Registre des incidents NIS2

Pour répondre à NIS2, il est indispensable de tenir un registre détaillé des incidents pour assurer la documentation et l’audit.

# Maintenir un registre des incidents conforme NIS2
class NIS2IncidentRegistry:

    INCIDENT_LOG_PATH = "/var/log/nis2/incidents.jsonl"

    def log_incident(self, incident_data: dict):
        entry = {
            "id": incident_data["incident_id"],
            "detected_at": datetime.utcnow().isoformat(),
            "type": incident_data["type"],
            "severity": incident_data["severity"],
            "source": "Auth0",
            "notifications": {
                "24h_sent": None,
                "72h_sent": None,
                "final_sent": None
            },
            "remediation": {
                "actions_taken": [],
                "resolved_at": None
            },
            "lessons_learned": None
        }

        with open(self.INCIDENT_LOG_PATH, "a") as f:
            f.write(json.dumps(entry) + "
")

        return entry

Ce script consigne chaque incident dans un fichier journal, garantissant la traçabilité exigée par NIS2.

Mesures NIS2 supportées par Auth0

Ce tableau synthétise comment les fonctionnalités Auth0 couvrent les exigences NIS2 sur le plan technique et organisationnel.

| Exigence NIS2 (Art. 21) | Feature Auth0 | Configuration | |---|---|---| | Politiques sécurité accès | Password Policy | Dashboard | | Gestion des incidents | Log Streaming | SIEM + alertes | | Continuité activité | Auth0 SLA 99.9% | Tenant EU | | Sécurité chaîne approvisionnement | DPA Okta | Signé automatiquement | | MFA | Auth0 MFA | Policies + Actions | | Cryptographie | TLS 1.3 + at-rest | Natif | | Contrôle accès | RBAC | Roles + Rules | | Formation sécurité | N/A | Programme interne |

Checklist NIS2 pour votre RSSI

Voici une checklist NIS2 pour guider les responsables sécurité dans l’application des bonnes pratiques sur l’IAM.

Gouvernance :
✅ Cartographie des actifs numériques (inclure Auth0)
✅ Évaluation des risques IAM documentée
✅ Politique MFA formalisée et approuvée CODIR
✅ Plan de réponse aux incidents (< 24h notification)

Technique :
✅ MFA obligatoire sur tous les systèmes critiques
✅ Authentification phishing-resistant (WebAuthn) pour admins
✅ Log streaming vers SIEM avec alertes automatiques
✅ Gestion des accès privilégiés (PAM) documentée
✅ Tests de pénétration annuels incluant IAM

Incident :
✅ Procédure notification ANSSI documentée
✅ Contact ANSSI identifié (cert.ssi.gouv.fr)
✅ Critères de déclenchement notification définis
✅ Registre des incidents tenu à jour

NIS2 est en vigueur depuis octobre 2024. Auth0.Expert réalise des audits de conformité NIS2 de votre IAM et vous accompagne dans la mise en œuvre des mesures requises.

Autres articles