Analyser les logs Auth0 : patterns, requêtes et détection d'anomalies

Comment analyser efficacement les logs Auth0 ? Requêtes Lucene, export vers BigQuery/Splunk et patterns d'analyse pour la sécurité et le business.

Par Auth0.Expert · 2025-05-05 · 10 min de lecture

Logs Analyse SIEM

Analyser les logs Auth0 : guide complet

TL;DR

Les logs Auth0 contiennent des informations précieuses : sécurité, comportement utilisateur, performance des Actions. Ce guide présente les patterns d'analyse les plus utiles avec des requêtes prêtes à l'emploi.

---

Types de logs Auth0 importants

Ce dictionnaire recense les principaux types de logs générés par Auth0, pour comprendre la signification des codes lors de l'analyse.

LOG_TYPES = {
    # Authentication
    "s":     "Success Login",
    "f":     "Failed Login",
    "fp":    "Wrong Password",
    "fu":    "User Not Found",
    "frd":   "Rule/Action Rejected",
    "limit_wc": "Too Many Attempts",

    # Sessions
    "slo":   "Single Log Out",
    "ss":    "Sign Up Success",
    "ssa":   "Sign Up Failure",

    # Password
    "pwd_leak": "Breached Password",
    "scp":   "Change Password",

    # MFA
    "gd_start_auth":    "MFA Started",
    "gd_auth_succeed":  "MFA Success",
    "gd_auth_failed":   "MFA Failed",

    # M2M
    "sce":   "Client Credentials Exchange",
    "fce":   "Failed Client Credentials",

    # API
    "mgmt_api_operation": "Management API Operation",
}

---

Requêtes Lucene pour le dashboard Auth0

Voici des exemples de filtres Lucene permettant d'extraire rapidement les événements importants dans le dashboard Auth0.

# Connexions depuis un pays spécifique
type:s AND _exists_:location_info.country_code AND location_info.country_code:"FR"

# Toutes les erreurs des 24 dernières heures
type:f AND date:[now-24h TO *]

# Pic d'erreurs pour un utilisateur
user_name:"[email protected]" AND type:(f OR fp OR fu)

# Actions ayant généré des erreurs
type:frd AND date:[now-7d TO *]

# Mots de passe compromis
type:pwd_leak

# Connexions depuis Tor
ip_metadata.tor:true

# Tous les logins admin
user_name:*@yourcompany.com AND type:s

# M2M exchanges pour un client spécifique
type:sce AND client_id:"CLIENT_ID_HERE"

# Erreurs de validation JWT
type:(fcoa OR fui)

---

Export vers BigQuery : analyse à grande échelle

Ce pipeline exporte les logs Auth0 vers BigQuery pour permettre des analyses à grande échelle, via un process typique utilisant Pub/Sub et des webhooks.

# Pipeline : Auth0 → Pub/Sub → BigQuery
# (via Log Streaming → HTTP webhook → votre pipeline)

import json
from google.cloud import bigquery

BQ_DATASET = "auth0_logs"
BQ_TABLE = "events"

client = bigquery.Client()
table_ref = client.dataset(BQ_DATASET).table(BQ_TABLE)

def process_auth0_event(event: dict):
    """Transformer un event Auth0 pour BigQuery."""
    return {
        "event_id": event.get("_id"),
        "timestamp": event.get("date"),
        "type": event.get("type"),
        "user_id": event.get("user_id"),
        "user_name": event.get("user_name"),
        "ip": event.get("ip"),
        "country_code": event.get("location_info", {}).get("country_code"),
        "country_name": event.get("location_info", {}).get("country_name"),
        "city": event.get("location_info", {}).get("city_name"),
        "client_id": event.get("client_id"),
        "client_name": event.get("client_name"),
        "connection": event.get("connection"),
        "user_agent": event.get("user_agent"),
        "is_mobile": "Mobile" in event.get("user_agent", ""),
        "is_tor": event.get("ip_metadata", {}).get("is_tor", False),
        "error_code": event.get("code"),
        "error_description": event.get("description"),
    }

Ce code reçoit un événement Auth0, le transforme et le structure pour l'insérer dans une table BigQuery, facilitant ainsi son exploitation analytique.

---

Requêtes BigQuery pour l'analyse

Ces requêtes SQL permettent d’extraire des insights directement à partir des logs stockés dans BigQuery, par exemple pour mesurer l'activité ou détecter des anomalies.

-- 1. Top 10 pays par volume de logins (30 derniers jours)
SELECT
  country_name,
  country_code,
  COUNT(*) as total_attempts,
  COUNTIF(type = 's') as successes,
  COUNTIF(type = 'f') as failures,
  ROUND(100 * COUNTIF(type = 's') / COUNT(*), 1) as success_rate_pct
FROM `project.auth0_logs.events`
WHERE DATE(timestamp) >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
GROUP BY 1, 2
ORDER BY total_attempts DESC
LIMIT 10;

-- 2. Tendance quotidienne des signups
SELECT
  DATE(timestamp) as date,
  COUNT(*) as new_signups,
  COUNTIF(connection = 'google-oauth2') as via_google,
  COUNTIF(connection = 'Username-Password-Authentication') as via_password
FROM `project.auth0_logs.events`
WHERE type = 'ss'
  AND DATE(timestamp) >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
GROUP BY 1
ORDER BY 1;

-- 3. Détection d'anomalies : IPs avec beaucoup d'échecs
WITH ip_stats AS (
  SELECT
    ip,
    COUNT(*) as total_attempts,
    COUNTIF(type = 'f') as failures,
    COUNT(DISTINCT user_name) as unique_users_attempted,
    DATE(MIN(timestamp)) as first_seen
  FROM `project.auth0_logs.events`
  WHERE DATE(timestamp) = CURRENT_DATE()
  GROUP BY ip
)
SELECT *,
  ROUND(100 * failures / total_attempts, 1) as failure_rate_pct
FROM ip_stats
WHERE total_attempts > 20 AND failures / total_attempts > 0.7
ORDER BY total_attempts DESC;

-- 4. Utilisateurs les plus actifs (potentiel: bots ou power users)
SELECT
  user_name,
  COUNT(*) as login_count,
  COUNT(DISTINCT DATE(timestamp)) as active_days,
  COUNT(DISTINCT ip) as distinct_ips
FROM `project.auth0_logs.events`
WHERE type = 's'
  AND DATE(timestamp) >= DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY)
GROUP BY 1
ORDER BY login_count DESC
LIMIT 20;

Ces quatre requêtes illustrent comment extraire des statistiques d'usage, suivre la croissance, identifier des comportements suspects, ou isoler les utilisateurs avec une activité inhabituelle.

---

Pattern de détection : credential stuffing

Cette requête détecte un schéma d’attaque “credential stuffing” en repérant de nombreux échecs de connexion répartis sur beaucoup d’IPs, chacune effectuant peu de tentatives.

-- Détection signature credential stuffing :
-- Beaucoup d'IPs différentes, chacune avec peu de tentatives
WITH hourly_stats AS (
  SELECT
    TIMESTAMP_TRUNC(timestamp, HOUR) as hour,
    COUNT(DISTINCT ip) as unique_ips,
    COUNT(*) as total_attempts,
    COUNTIF(type = 'f') as failures,
    AVG(COUNT(*)) OVER (PARTITION BY ip) as avg_per_ip
  FROM `project.auth0_logs.events`
  WHERE DATE(timestamp) = CURRENT_DATE()
  GROUP BY hour, ip
)
SELECT
  hour,
  COUNT(*) as involved_ips,
  SUM(total_attempts) as total_attempts,
  AVG(total_attempts) as avg_attempts_per_ip,
  'Possible credential stuffing' as alert
FROM hourly_stats
WHERE failures / total_attempts > 0.8  -- 80%+ d'échecs
  AND avg_per_ip < 5  -- Chaque IP n'essaie que 1-4 fois (distribué)
HAVING COUNT(*) > 100  -- Plus de 100 IPs impliquées
GROUP BY hour;

Ce pattern permet d’automatiser la détection en quasi temps réel de tentatives d’attaque par injection massive d’identifiants.

---

Dashboard business : métriques produit

Ce code extrait des KPIs business pertinents (DAU, signups, adoption Google/Enterprise, taux de succès) directement depuis les logs Auth0, idéal pour piloter un produit SaaS sécurisé.

# KPIs produit extraits des logs Auth0

async def get_product_kpis(start_date: str, end_date: str) -> dict:
    logs = await bigquery_query(f"""
        SELECT
          DATE(timestamp) as date,
          COUNT(DISTINCT CASE WHEN type = 's' THEN user_id END) as dau,
          COUNT(DISTINCT CASE WHEN type = 'ss' THEN user_id END) as new_signups,
          COUNTIF(type = 's' AND connection = 'google-oauth2') as google_logins,
          COUNTIF(type = 's' AND connection LIKE '%waad%') as enterprise_logins,
          COUNTIF(type = 's') / NULLIF(COUNTIF(type IN ('s', 'f')), 0) as login_success_rate
        FROM auth0_logs.events
        WHERE DATE(timestamp) BETWEEN '{start_date}' AND '{end_date}'
        GROUP BY 1
        ORDER BY 1
    """)

    return {
        "dau_avg": sum(r['dau'] for r in logs) / len(logs),
        "total_signups": sum(r['new_signups'] for r in logs),
        "google_adoption": sum(r['google_logins'] for r in logs) / sum(r['dau'] for r in logs),
        "enterprise_adoption": sum(r['enterprise_logins'] for r in logs) / sum(r['dau'] for r in logs),
        "login_success_rate": sum(r['login_success_rate'] for r in logs) / len(logs),
    }

Ce bloc permet d'obtenir les métriques business clés sur la base des logs d'authentification et de création de compte.

---

> 📊 Analyse des logs Auth0 : nous mettons en place votre pipeline d'analyse (BigQuery/Snowflake/Splunk) avec dashboards métier et alertes sécurité en 1 semaine.

📧 [email protected]