Auth0 pour la FinTech : conformité FCA, PSD2 et authentification forte

Configurez Auth0 pour répondre aux exigences FCA et PSD2 : authentification forte du client (SCA), transaction signing et conformité Open Banking.

Par Auth0.Expert · 2025-07-14 · 12 min de lecture

FinTech FCA PSD2 SCA Auth0

Auth0 pour la FinTech : FCA, PSD2 et SCA

TL;DR

PSD2 et les réglementations FCA/ACPR imposent la Strong Customer Authentication (SCA) pour les paiements en ligne. Auth0 peut implémenter les exigences SCA avec MFA contextuel, mais doit être complété par une solution de transaction signing dédiée.

Exigences SCA (Strong Customer Authentication)

Ce bloc détaille les trois catégories d’authentification requises par la SCA et indique la couverture native d’Auth0.

PSD2 Article 97 — SCA requiert 2 facteurs parmi :
┌─────────────────────────────────────────────────────┐
│  Possession  │  Connaissance  │  Inhérence           │
│  (have)      │  (know)        │  (are)               │
├─────────────────────────────────────────────────────┤
│ - Téléphone  │ - Mot de passe │ - Empreinte          │
│ - Token OTP  │ - PIN          │ - Face ID            │
│ - Carte      │ - Questions    │ - Comportement       │
│ - Clé FIDO2  │   secrètes     │   biométrique        │
└─────────────────────────────────────────────────────┘

Auth0 couvre : Connaissance + Possession/Inhérence via MFA
Manquant dans Auth0 : Transaction signing (montant + bénéficiaire)

Implémentation SCA avec Auth0

Voici une Action Auth0 qui déclenche l'authentification multifacteur contextuelle lors des paiements, pour respecter les seuils PSD2.

// Auth0 Action : SCA contextuelle pour paiements
exports.onExecutePostLogin = async (event, api) => {
  const isPaymentApp = event.client.name === "payment-portal";

  if (!isPaymentApp) return;

  // Extraire le contexte de transaction depuis le state
  let transactionContext = null;
  try {
    const state = JSON.parse(atob(event.request.query?.state || "{}"));
    transactionContext = state.transaction;
  } catch (e) {}

  const mfaUsed = event.authentication?.methods?.some(m => m.name === "mfa");

  // SCA obligatoire si :
  // - Montant > 30€ (seuil PSD2)
  // - Nouveau bénéficiaire
  // - Accès depuis nouveau device

  const requiresSCA = (
    (transactionContext?.amount || 0) > 30 ||
    transactionContext?.new_beneficiary === true ||
    !isKnownDevice(event)
  );

  if (requiresSCA && !mfaUsed) {
    api.authentication.challengeWithAny([
      { type: "webauthn-roaming" },  // Meilleur pour SCA
      { type: "webauthn-platform" }, // TouchID / FaceID
      { type: "totp" }               // OTP app
    ]);
  }
};

function isKnownDevice(event) {
  // Vérifier si le device est connu via les métadonnées utilisateur
  const knownDevices = event.user.user_metadata?.known_devices || [];
  const currentDevice = {
    user_agent: event.request.user_agent,
    ip_prefix: event.request.ip?.split(".").slice(0, 3).join(".")
  };

  return knownDevices.some(d =>
    d.user_agent === currentDevice.user_agent &&
    d.ip_prefix === currentDevice.ip_prefix
  );
}

Ce code applique les règles SCA lors de la connexion sur le portail de paiement, selon le montant ou le contexte, et déclenche le MFA approprié.

Transaction Signing (PSD2 compliant)

Cette Action illustre comment rediriger vers un service de signature de transaction, indispensable pour être 100% compliant PSD2.

// Auth0 ne gère pas nativement le transaction signing
// Utiliser une Action pour rediriger vers votre service de signing

exports.onExecutePostLogin = async (event, api) => {
  const transaction = getTransactionFromState(event);

  if (!transaction) return; // Pas de transaction à signer

  // Créer un challenge de transaction
  const challenge = {
    transaction_id: transaction.id,
    amount: transaction.amount,
    currency: transaction.currency,
    beneficiary: transaction.beneficiary,
    iban: transaction.iban,
    timestamp: new Date().toISOString()
  };

  // Signer le challenge avec votre clé privée
  const signedChallenge = await signChallenge(challenge, process.env.SIGNING_KEY);

  // Rediriger vers votre page de confirmation de transaction
  api.redirect.sendUserTo("https://votre-app.com/confirm-transaction", {
    query: {
      session_token: api.redirect.encodeToken({
        expiresInSeconds: 120,  // 2 minutes pour confirmer
        payload: {
          challenge: signedChallenge,
          transaction_id: transaction.id
        }
      })
    }
  });
};

// Page de confirmation : afficher les détails et demander confirmation MFA
// Puis retourner à Auth0 avec /continue

Cette logique permet de signer chaque transaction et de recueillir la confirmation utilisateur de manière conforme.

Open Banking — FAPI Compliance

Cette section montre comment configurer un client Open Banking conforme FAPI avec Auth0, avec support PKCE et PAR.

// FAPI (Financial-grade API) Profile
// Auth0 supporte PKCE + PAR (Pushed Authorization Requests)

// Client configuration pour FAPI compliance
const fapiClientConfig = {
  name: "Open Banking Client",
  app_type: "regular_web",

  // FAPI Profile requirements
  token_endpoint_auth_method: "private_key_jwt",  // Pas client_secret_basic

  jwt_configuration: {
    alg: "RS256",
    lifetime_in_seconds: 300,   // Token courte durée
    scopes_key: "permissions"
  },

  // PKCE obligatoire
  require_pkce: true,

  // Restricted response types
  grant_types: ["authorization_code", "refresh_token"],
  response_types: ["code"]  // Pas de token en implicit flow
};

// PAR (Pushed Authorization Request) - FAPI 2.0
// Auth0 supporte via /oauth/par endpoint
const parRequest = await fetch(`https://${AUTH0_DOMAIN}/oauth/par`, {
  method: "POST",
  headers: {
    "Content-Type": "application/x-www-form-urlencoded"
  },
  body: new URLSearchParams({
    client_id: CLIENT_ID,
    response_type: "code",
    scope: "openid accounts payments",
    redirect_uri: REDIRECT_URI,
    code_challenge: codeChallenge,
    code_challenge_method: "S256",
    // Paramètre spécifique Open Banking
    acr_values: "urn:openbanking:psd2:sca"
  })
});

const { request_uri } = await parRequest.json();
// Utiliser request_uri dans l'authorization request

Ce bloc configure un client conforme au profil FAPI et met en œuvre une requête d’autorisation poussée obligatoire pour la sécurité Open Banking.

Exemptions SCA (Art. 10-18 RTS)

Cette Action montre comment appliquer automatiquement les exemptions prévues par la réglementation et documenter celles-ci.

// Auth0 Action : appliquer les exemptions SCA
exports.onExecutePostLogin = async (event, api) => {
  const transaction = getTransaction(event);
  if (!transaction) return;

  // Exemptions PSD2 / RTS
  const exemptions = {
    // Art. 16 : Transactions à faible montant (≤ 30€)
    low_value: transaction.amount <= 30,

    // Art. 18 : Transactions récurrentes même montant
    recurring: transaction.is_recurring &&
               transaction.amount === transaction.previous_amount,

    // Art. 15 : Bénéficiaire de confiance (whitelisté)
    trusted_beneficiary: isTrustedBeneficiary(
      event.user.user_metadata?.trusted_beneficiaries,
      transaction.iban
    ),

    // Art. 17 : Corporate payments (B2B)
    corporate: event.user.app_metadata?.account_type === "corporate"
  };

  const isExempted = Object.values(exemptions).some(Boolean);

  if (!isExempted) {
    // SCA obligatoire
    api.authentication.challengeWithAny([...]);
  } else {
    // Logger l'exemption utilisée
    api.accessToken.setCustomClaim("sca_exemption", {
      type: Object.keys(exemptions).find(k => exemptions[k]),
      transaction_id: transaction.id
    });
  }
};

Ce code applique la logique des exemptions SCA et ajoute les informations d’exemption dans le token pour audit.

Checklist conformité FinTech × Auth0

La checklist ci-dessous récapitule les points clés de conformité à valider pour un usage FinTech d’Auth0.

PSD2 / SCA :
✅ MFA obligatoire pour transactions > 30€
✅ WebAuthn (possession + inhérence) pour SCA forte
✅ Gestion des exemptions documentée
✅ Transaction signing (service externe)
✅ Session timeout strict (5-15 min inactivité)

Open Banking / FAPI :
✅ PKCE obligatoire
✅ PAR (Pushed Authorization Requests)
✅ Token courte durée (< 5 min)
✅ mTLS ou private_key_jwt pour clients

FCA / ACPR :
✅ Logging complet des transactions
✅ Rapport incidents < 4h (FCA)
✅ Plan de continuité testé
✅ Senior Manager Function (SMF) designé

Fraude :
✅ Attack Protection activé
✅ Device fingerprinting
✅ Monitoring comportemental
✅ Alertes anomalies en temps réel

Auth0.Expert accompagne les FinTech et institutions financières dans leur mise en conformité PSD2/FCA avec Auth0.