Zero Trust avec Auth0 : ne jamais faire confiance, toujours vérifier

Le modèle Zero Trust appliqué à Auth0 : step-up auth, continuous verification, device trust et micro-segmentation des accès.

Par Auth0.Expert · 2025-02-05 · 12 min de lecture

Zero Trust Sécurité Architecture

Zero Trust avec Auth0 : guide pratique

TL;DR

Zero Trust signifie : "Ne jamais faire confiance à une identité sur la base de sa localisation réseau." Avec Auth0, cela se traduit par une vérification continue à chaque accès, pas seulement au login.

---

Les 4 piliers Zero Trust avec Auth0

Voici les principaux axes d’un modèle Zero Trust appliqué avec Auth0.

Identity : vérifier qui est l'utilisateur (MFA, anomaly detection)
Device : vérifier l'état de l'appareil (MDM compliance, posture)
Least Privilege : scopes minimaux par ressource
Continuous Verification : re-vérifier à chaque action sensible

---

Pilier 1 : Vérification d'identité forte

Ce code calcule dynamiquement un score de risque lors du login pour déterminer s’il faut activer MFA, en analysant le pays, Tor, l’heure du login et l’appareil.

// Action : score de risque calculé à la volée
exports.onExecutePostLogin = async (event, api) => {
  let riskScore = 0;

  // +20 si premier login depuis ce pays
  const lastCountry = event.user.app_metadata?.last_country;
  if (lastCountry && lastCountry !== event.request.geoip?.country_code) {
    riskScore += 20;
  }

  // +30 si login depuis Tor
  if (event.request.geoip?.is_tor) riskScore += 30;

  // +15 si heure inhabituelle (2h-5h du matin)
  const hour = new Date().getUTCHours();
  if (hour >= 2 && hour <= 5) riskScore += 15;

  // +25 si nouvel appareil (user-agent jamais vu)
  const knownAgents = event.user.app_metadata?.known_agents || [];
  const ua = event.request.user_agent;
  if (ua && !knownAgents.some(a => a === ua.substring(0, 50))) {
    riskScore += 25;
  }

  // Décision basée sur le score
  if (riskScore >= 50) {
    api.multifactor.enable('any', { allowRememberBrowser: false });
  } else if (riskScore >= 20) {
    api.multifactor.enable('any', { allowRememberBrowser: true });
  }

  // Stocker le pays pour référence future
  api.user.setAppMetadata('last_country', event.request.geoip?.country_code);
};

Ce bloc applique un MFA adaptatif selon le risque, basé sur plusieurs critères dynamiques.

---

Pilier 2 : Device Trust

Dans cette section, Auth0 vérifie la conformité MDM de l’appareil avant d’accorder l'accès.

// Action : vérifier la conformité MDM via votre endpoint
exports.onExecutePostLogin = async (event, api) => {
  if (event.client.metadata?.require_device_compliance !== 'true') return;

  const deviceId = event.request.query?.device_id;
  if (!deviceId) {
    api.access.deny('Appareil non enregistré');
    return;
  }

  // Appel à votre endpoint MDM (Jamf, Intune, etc.)
  const mdmResponse = await fetch(
    `${event.secrets.MDM_ENDPOINT}/compliance/${deviceId}`,
    {
      headers: { Authorization: `Bearer ${event.secrets.MDM_TOKEN}` }
    }
  );
  const { compliant } = await mdmResponse.json();

  if (!compliant) {
    api.access.deny('Appareil non conforme — mise à jour requise');
  }
};

Ce code refuse l’accès si l’appareil n’est pas conforme ou non enregistré en MDM.

---

Pilier 3 : Least Privilege avec des scopes granulaires

Ce tableau montre comment définir des scopes précis pour contrôler l’accès aux ressources selon chaque profil utilisateur.

// Resource Server avec scopes fins
const scopes = {
  // Lecture
  'read:own_profile':    'Voir son propre profil',
  'read:team_profiles':  'Voir les profils de son équipe',
  'read:all_profiles':   'Voir tous les profils (admin)',

  // Écriture
  'write:own_profile':   'Modifier son propre profil',
  'write:team_profiles': "Modifier les profils de son équipe",

  // Actions
  'delete:records':      'Supprimer des enregistrements',
  'export:data':         'Exporter des données',
  'manage:billing':      'Gérer la facturation',
};

---

Pilier 4 : Continuous Verification (Step-up)

Cette logique gère la vérification additionnelle lors d’une action sensible, en imposant une nouvelle authentification ou MFA si nécessaire.

// Côté client : déclencher step-up pour action sensible
async function performSensitiveAction() {
  try {
    // Tenter l'action
    await apiCall('/delete-account');
  } catch (err) {
    if (err.status === 403 && err.code === 'insufficient_authentication') {
      // Redemander MFA
      const token = await auth0.getTokenWithPopup({
        authorizationParams: {
          scope: 'openid delete:account',
          max_age: 0, // Forcer re-auth
        }
      });
      await apiCall('/delete-account', token);
    }
  }
}

// Côté API : vérifier l'âge de l'authentification
function requireRecentAuth(payload, maxAgeSeconds = 300) {
  const authAge = Date.now() / 1000 - payload.auth_time;
  if (authAge > maxAgeSeconds) {
    throw new Error('Re-authentication requise');
  }
}

Ce bloc assure que les actions sensibles nécessitent toujours une authentification récente ou un step-up MFA.

---

Architecture Zero Trust complète

Ce schéma synthétise comment Auth0 s’intègre dans une architecture Zero Trust, en centralisant les vérifications d’identité, de device et de scope pour chaque requête.

Browser / App
    ↓
Auth0 (Identity Verification + MFA + Device Trust)
    ↓
API Gateway (Token Validation + Scope Check)
    ↓
Microservice A (read:data scope) → Resource
Microservice B (write:data scope) → Resource
    ↑
    Tous les tokens validés à chaque requête
    Pas de session inter-services
    Logs centralisés dans le SIEM

---

Intégration avec BeyondCorp / Google Cloud IAP

Cette étape montre comment ajouter des claims personnalisés dans le token pour la compatibilité avec Google Cloud IAP/BeyondCorp.

// Action Auth0 : ajouter des claims compatibles Cloud IAP
exports.onExecutePostLogin = async (event, api) => {
  api.accessToken.setCustomClaim('https://auth0.expert/device_trust', {
    managed: event.request.query?.mdm_compliant === 'true',
    encrypted: event.request.query?.disk_encrypted === 'true',
  });
};

---

> 🏛️ Architecture Zero Trust : nos experts conçoivent votre modèle Zero Trust complet (identité, appareil, réseau) compatible avec votre infrastructure cloud.

📧 [email protected]