Ajoutez la connexion à votre application iOS ou macOS avec le SDK Auth0.swift

Utilisez l’IA pour intégrer Auth0

Si vous utilisez un assistant de codage IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter l’authentification Auth0 automatiquement en quelques minutes à l’aide d’Agent Skills.

Installez :

npx skills add auth0/agent-skills --skill auth0

Demandez ensuite à votre assistant IA :

Add Auth0 authentication to my iOS app

Votre assistant IA créera automatiquement votre application Auth0, récupérera l’information d’identification, ajoutera la dépendance du SDK Auth0.swift, configurera Auth0.plist, mettra en place les URL de rappel et implémentera les flux de connexion et de déconnexion. Documentation complète sur Agent Skills →

​

Pour commencer

1. Créer un nouveau projet

   Créez un nouveau projet iOS ou macOS pour ce Quickstart.

   Dans Xcode :

   1. File → New → Project (ou ⌘+Shift+N)
   2. Sélectionnez l’une des options suivantes :
      • Onglet iOS → modèle App
      • Onglet macOS → modèle App
   3. Configurez votre projet :
      • Product Name : Auth0-Sample
      • Interface : SwiftUI
      • Language : Swift
      • Use Core Data : décoché
      • Include Tests : coché (recommandé)
   4. Choisissez un emplacement, puis cliquez sur Create

   Cela crée une application SwiftUI standard avec la prise en charge de Swift Package Manager, idéale pour l’intégration d’Auth0.

2. Ajouter le SDK Auth0

   Ajoutez le SDK Auth0 à votre projet à l’aide du gestionnaire de paquets de votre choix.

   Swift Package Manager

   Dans Xcode :

   1. File → Add Package Dependencies… (ou ⌘+Shift+K)
   2. Entrez l’URL du SDK Auth0 :
      https://github.com/auth0/Auth0.swift
      
   3. Add Package → Sélectionnez la cible de votre application → Add Package

   CocoaPods

   1. Créez un Podfile dans le répertoire de votre projet :
      Podfile

      platform :ios, '14.0' # Ou platform :osx, '11.0' pour macOS
      use_frameworks!
      
      target 'YourApp' do
        pod 'Auth0', '~> 3.0'
      end
      
   2. Installez les dépendances :
      pod install
      
   3. Ouvrez le fichier .xcworkspace généré (et non le fichier .xcodeproj)

   Carthage

   1. Créez un Cartfile dans le répertoire de votre projet :
      Cartfile

      github "auth0/Auth0.swift" ~> 3.0
      
   2. Exécutez Carthage :
      carthage update --platform iOS --use-xcframeworks
      
      Pour macOS, utilisez --platform macOS
   3. Faites glisser le fichier Auth0.xcframework généré depuis Carthage/Build dans votre projet Xcode
   4. Dans les paramètres General de votre cible, ajoutez Auth0.xcframework à Frameworks, Libraries, and Embedded Content
3. Configurer Auth0

   Créez une nouvelle application Auth0 et configurez les URL de rappel.

   1. Accédez au Auth0 Dashboard
   2. Applications > Create Application > Attribuez-lui un nom, sélectionnez Native > Create
   3. Dans l’onglet Settings, notez votre Client ID et votre Domain
   4. Ajoutez les URL suivantes à Allowed Callback URLs :

   iOS

   https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
   

   macOS

   https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback
   

   5. Ajoutez les URL suivantes à Allowed Logout URLs :

   iOS

   https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
   

   macOS

   https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback,
   YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback
   

   6. Cliquez sur Save Changes
4. Configurer les identifiants de l’application

   Créez Auth0.plist dans le répertoire de votre projet :

   Auth0.plist

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
   <plist version="1.0">
   <dict>
       <key>ClientId</key>
       <string>YOUR_AUTH0_CLIENT_ID</string>
       <key>Domain</key>
       <string>{yourDomain}</string>
   </dict>
   </plist>
   

   Faites glisser Auth0.plist dans Xcode et assurez-vous que l’option “Add to target” est cochée.

5. Créer le service d’authentification

   Créez AuthenticationService.swift pour gérer la connexion, la déconnexion et le stockage des jetons.

   Utilisez CredentialsManager pour le stockage des jetons. La classe CredentialsManager stocke les informations d’identification de manière sécurisée dans le Keychain et actualise automatiquement les jetons d’accès expirés. Utilisez-la toujours — ne stockez jamais de jetons en mémoire, dans UserDefaults ou dans localStorage.

   1. Cliquez avec le bouton droit sur votre projet → New File… → Swift File
   2. Nommez-le AuthenticationService
   3. Remplacez le contenu par :

   AuthenticationService.swift

   import Foundation
   import Auth0
   import Combine
   
   @MainActor
   class AuthenticationService: ObservableObject {
       @Published var isAuthenticated = false
       @Published var user: UserProfile?
       @Published var isLoading = false
       @Published var errorMessage: String?
       
       private let credentialsManager = CredentialsManager(authentication: Auth0.authentication())
       
       init() {
           Task {
               await checkAuthenticationStatus()
           }
       }
       
       private func checkAuthenticationStatus() async {
           isLoading = true
           defer { isLoading = false }
           
           guard let credentials = try? await credentialsManager.credentials() else {
               isAuthenticated = false
               return
           }
           
           isAuthenticated = true
           // Récupérer le profil de l'utilisateur à partir du jeton d'ID stocké
           user = try? credentialsManager.userProfile()
       }
       
       func login() async {
           isLoading = true
           errorMessage = nil
           defer { isLoading = false }
           
           do {
               // offline_access est inclus dans le scope par défaut depuis la v3; indiqué ici par souci de clarté
               _ = try await Auth0
                   .webAuth()
                   .scope("openid profile email offline_access")
                   .useCredentialsManager(credentialsManager)
                   .start()
               
               isAuthenticated = true
               // Récupérer le profil de l'utilisateur à partir du jeton d'ID stocké
               user = try? credentialsManager.userProfile()
           } catch {
               errorMessage = "Login failed: \(error.localizedDescription)"
           }
       }
       
       func logout() async {
           isLoading = true
           defer { isLoading = false }
           
           do {
               try await Auth0
                 .webAuth()
                 .useCredentialsManager(credentialsManager)
                 .logout()
               isAuthenticated = false
               user = nil
           } catch {
               errorMessage = "Logout failed: \(error.localizedDescription)"
           }
       }
   }
   
6. Configurer le processus d’authentification (facultatif)

   Pour améliorer l’expérience utilisateur, vous pouvez réduire les alertes système des façons suivantes :

   1. Utilisez Universal Links : cela élimine l’invite ‘Open in “AppName”?’ qui s’affiche pendant la redirection. Remarque : l’alerte d’autorisation d’ASWebAuthenticationSession s’affichera quand même.
   2. Utilisez des sessions éphémères : cela élimine toutes les alertes d’autorisation. Remarque : cela désactive le Single Sign-On (SSO) et les cookie partagés.

   Ignorez cette étape pour utiliser le comportement par défaut avec une alerte d’autorisation. Vous pourrez le configurer plus tard.

   Universal Links

   1. Auth0 Dashboard → Applications → votre application → Settings → Advanced Settings → Device Settings
   2. Ajoutez Apple Team ID et bundle identifier → Save
   3. Xcode : Target → Signing & Capabilities → + Capability → Associated Domains
   4. Ajoutez : webcredentials:{yourDomain}

   Requiert : un compte Apple Developer payant, iOS 17.4+/macOS 14.4+

   Idéal pour les applications en production.

   Ephemeral Session

   Ajoutez .useEphemeralSession() à la requête de login dans AuthenticationService.swift :

   // Dans la fonction login()
   let credentials = try await Auth0
       .webAuth()
       .scope("openid profile email offline_access")
       .useCredentialsManager(credentialsManager)
       .useEphemeralSession()
       .start()
   

   Lorsque vous utilisez des sessions éphémères, vous n’avez pas besoin d’appeler logout() sur le client Web Auth. Effacez simplement les credentials de votre application — il n’y a pas de cookie partagé à supprimer.

   Configuration rapide, aucune alerte, mais les utilisateurs doivent se connecter chaque fois (pas de SSO).

7. Lancez votre application

   Appuyez sur ⌘+R dans Xcode.

   1. Touchez “Se connecter” → alerte d’autorisation (si vous utilisez l’option par défaut) → Touchez “Continuer”
   2. Terminez la connexion dans le navigateur
   3. Consultez votre profil !

Vérification

Vous disposez maintenant d’une connexion avec Auth0 entièrement fonctionnelle dans votre application iOS ou macOS !

---

​

Dépannage et avancé

Problèmes courants et solutions

​

Erreurs de build : module « Auth0 » introuvable

Solutions :

1. Swift Package Manager : vérifiez Package Dependencies → assurez-vous que Auth0.swift figure dans la liste
2. CocoaPods : assurez-vous d’ouvrir le fichier .xcworkspace, et non .xcodeproj
3. Carthage : vérifiez que Auth0.xcframework a bien été ajouté à Frameworks, Libraries, and Embedded Content
4. Nettoyez et reconstruisez : ⌘+Shift+K puis ⌘+R
5. Redémarrez Xcode au besoin

​

Plantage de l’application : « Auth0.plist not found »

Correctif :

1. Vérifiez que Auth0.plist se trouve dans le navigateur de projet d’Xcode
2. Sélectionnez le fichier → Inspector → assurez-vous que la cible de votre application est cochée
3. Vérifiez qu’il contient les clés ClientId et Domain avec vos valeurs

​

Le navigateur s’ouvre, mais ne revient jamais à l’application

Correctif :

1. Vérifiez que les URL de rappel dans le Auth0 Dashboard correspondent exactement à votre identificateur de bundle et à votre plateforme
2. Pour iOS : les URL doivent contenir /ios/, pour macOS : /macos/
3. Vérifiez que l’identificateur de bundle dans Xcode correspond aux paramètres d’Auth0
4. Assurez-vous qu’il n’y a pas de fautes de frappe dans les URL (p. ex. : deux-points manquants, mauvais format de domaine)
5. Utilisateurs d’un domaine personnalisé : vérifiez que vous utilisez bien votre domaine personnalisé, et non le domaine Auth0

​

L’alerte d’autorisation apparaît chaque fois

Il s’agit du comportement de sécurité normal d’iOS/macOS lors de l’utilisation de schémas d’URL personnalisés. Consultez l’étape 6 pour éliminer cette alerte à l’aide des liens universels ou des sessions éphémères.

Configuration du domaine personnalisé

Si vous utilisez un domaine personnalisé, utilisez-le partout à la place de votre domaine Auth0.

Exemple : utilisez login.example.com au lieu de tenant.auth0.com

Cela est obligatoire pour que certaines fonctionnalités marchent correctement :

• Mettez à jour Auth0.plist avec votre domaine personnalisé
• Utilisez le domaine personnalisé dans les URL de rappel/de logout
• Pour les liens universels, utilisez : webcredentials:login.example.com

Déploiement en production

​

Préparation pour l’App Store

• Configurez les liens universels pour éliminer l’alerte d’autorisation
• Testez sur plusieurs versions de plateforme et tailles d’écran
• Mettez en place une gestion adéquate des erreurs en cas d’échec réseau
• Ajoutez les descriptions d’utilisation relatives à la confidentialité si vous utilisez le Keychain avec la biométrie
• Suivez les directives de révision de l’App Store pour les flux d’authentification

​

Meilleures pratiques de sécurité

• N’inscrivez jamais de données d’authentification sensibles dans les logs en production
• Assurez la conformité à App Transport Security (ATS)
• Utilisez HTTPS pour toutes les requêtes réseau
• N’épinglez PAS les certificats de l’Auth0 API - Auth0 ne recommande pas cette pratique

​

Optimisation des performances

• Toutes les opérations asynchrones utilisent correctement @MainActor pour les mises à jour de l’UI
• Les propriétés @Published utilisent une gestion adéquate de la mémoire
• Les informations d’identification sont mises en cache de façon sécuritaire dans le Keychain pour l’accès hors ligne
• Le profil utilisateur est récupéré à partir du ID token (aucune requête réseau supplémentaire)

Intégration avancée

​

Sécurité renforcée du Keychain avec la biométrie

Exigez Face ID ou Touch ID pour accéder aux informations d’identification enregistrées :

private let credentialsManager: CredentialsManager = {
    var manager = CredentialsManager(authentication: Auth0.authentication())
    manager.enableBiometrics(
        withTitle: "Unlock with Face ID", 
        cancelTitle: "Cancel", 
        fallbackTitle: "Use Passcode"
    )
    return manager
}()

Lorsqu’elle est activée, les utilisateurs doivent s’authentifier par biométrie avant que le SDK puisse récupérer les informations d’identification enregistrées.

​

Actualisation automatique des jetons

Le CredentialsManager actualise automatiquement les jetons d’accès expirés :

// Obtenir les informations d’identification - actualisation automatique si elles ont expiré
func getAccessToken() async throws -> String {
    let credentials = try await credentialsManager.credentials()
    return credentials.accessToken
}

Utilisez ce modèle pour effectuer des appels d’API nécessitant un jeton d’accès.

​

Informations d’identification partagées entre les extensions d’app

Pour les widgets, les extensions d’app ou les tâches en arrière-plan nécessitant des jetons d’accès :

// Créer un gestionnaire d’informations d’identification partagé avec un groupe d’apps
let credentialsManager = CredentialsManager(
    authentication: Auth0.authentication(),
    storeKey: "credentials",
    storage: SimpleKeychain(accessGroup: "group.com.example.myapp")
)

Exigences :

1. Activez la fonctionnalité App Groups dans Xcode pour toutes les cibles.
2. Utilisez le même identifiant de groupe d’apps pour toutes les cibles.
3. Configurez le CredentialsManager partagé dans chaque cible.

​

Comparaison des options de flux d’authentification

Fonctionnalité	Liens universels	Session éphémère	Par défaut (alerte)
Alerte d’autorisation	Réduite (pas d’invite de redirection)	Aucune	Affiche toutes les alertes
Prise en charge du SSO	Oui	Non	Oui
Compte Apple Developer	Obligatoire	Non obligatoire	Non obligatoire
Expérience utilisateur	Optimale	Bonne	Acceptable
Complexité de configuration	Moyenne	Simple	Simple
Prise en charge de la navigation privée	Oui	Oui	Non

Recommandations :

• Apps de production avec SSO : Liens universels (meilleure expérience utilisateur, prise en charge du SSO, compte Apple Developer requis)
• Apps de production sans SSO : Sessions éphémères (aucune alerte, configuration plus simple)
• Tests/développement : Sessions éphémères (configuration rapide, expérience utilisateur épurée)
• Démarrage rapide/prototypage : Par défaut avec alertes (aucune configuration requise, migration possible ultérieurement)