Ajouter l’authentification à votre application iOS ou macOS à l’aide du SDK Auth0.swift

Utiliser l’IA pour intégrer Auth0

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

Installer :

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

Demandez ensuite à votre assistant IA :

Add Auth0 authentication to my iOS app

Votre assistant IA créera automatiquement votre application Auth0, récupérera les informations d’identification, ajoutera la dépendance au SDK Auth0.swift, configurera Auth0.plist, définira les URL de rappel et implémentera les flux de connexion et de déconnexion. Documentation complète sur les agent skills →

​

Pour commencer

1. Créer un nouveau projet

   Créez un nouveau projet iOS ou macOS dans le cadre de ce guide de démarrage rapide.

   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 standard avec la prise en charge de SwiftUI et de Swift Package Manager, idéale pour l’intégration d’Auth0.

2. Ajouter le SDK Auth0

   Ajoutez le SDK Auth0 à votre projet avec le gestionnaire de paquets de votre choix.

   Gestionnaire de paquets Swift

   Dans Xcode :

   1. File → Add Package Dependencies… (ou ⌘+Shift+K)
   2. Saisissez 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', '~> 2.0'
      end
      
   2. Installez les dépendances :
      pod install
      
   3. Ouvrez le fichier .xcworkspace généré (et non le .xcodeproj)

   Carthage

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

      github "auth0/Auth0.swift" ~> 2.0
      
   2. Exécutez Carthage :
      carthage update --platform iOS --use-xcframeworks
      
      Pour macOS, utilisez --platform macOS
   3. Glissez 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 à Auth0 Dashboard
   2. Applications > Create Application > Donnez-lui un nom, sélectionnez Native > Create
   3. Dans l’onglet Settings, prenez en note 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 du 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>
   

   Glissez 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 :

   1. Cliquez avec le bouton droit sur votre projet → Nouveau fichier… → Fichier Swift
   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: User?
       @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
           // Obtenir les informations de l'utilisateur à partir du jeton d'identité
           user = credentials.user
       }
       
       func login() async {
           isLoading = true
           errorMessage = nil
           defer { isLoading = false }
           
           do {
               let credentials = try await Auth0
                   .webAuth()
                   .scope("openid profile email offline_access")
                   .start()
               
               _ = credentialsManager.store(credentials: credentials)
               isAuthenticated = true
               // Obtenir les informations de l'utilisateur à partir du jeton d'identité
               user = credentials.user
           } catch {
               errorMessage = "Login failed: \(error.localizedDescription)"
           }
       }
       
       func logout() async {
           isLoading = true
           defer { isLoading = false }
           
           do {
               try await Auth0
                 .webAuth()
                 .clearSession()
               _ = credentialsManager.clear()
               isAuthenticated = false
               user = nil
           } catch {
               errorMessage = "Logout failed: \(error.localizedDescription)"
           }
       }
   }
   
6. Configurer le flux 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 ‘Ouvrir dans “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 l’authentification unique (SSO) et les témoins partagés.

   Sautez cette étape pour utiliser le comportement par défaut avec une alerte d’autorisation. Vous pourrez configurer cela 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}

   Nécessite : un compte Apple Developer payant, iOS 17.4+/macOS 14.4+

   Recommandé pour les applications en production.

   Session éphémère

   Ajoutez .useEphemeralSession() à l’appel de connexion dans AuthenticationService.swift :

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

   Lorsque vous utilisez des sessions éphémères, vous n’avez pas besoin d’appeler clearSession() à la déconnexion. Effacez simplement les informations d’identification de votre application : il n’y a aucun témoin 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 avez maintenant une connexion Auth0 entièrement fonctionnelle dans votre application iOS ou macOS !

---

​

Dépannage et notions avancées

Problèmes courants et solutions

​

Erreurs de compilation : 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 est ajouté à Frameworks, Libraries, and Embedded Content
4. Nettoyez et recompilez : ⌘+Shift+K puis ⌘+R
5. Redémarrez Xcode au besoin

​

Plantage de l’application : « Auth0.plist introuvable »

Correctif :

1. Vérifiez que Auth0.plist se trouve dans le navigateur de projet Xcode
2. Sélectionnez le fichier → Inspector → Assurez-vous que la cible de votre application est cochée
3. Confirmez qu’il contient les clés ClientId et Domain avec vos valeurs
4. Autre option : Utilisez une configuration par programmation (voir la section Intégration avancée ci-dessous)

​

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

Correctif :

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

​

L’alerte d’autorisation s’affiche chaque fois

Il s’agit du comportement de sécurité standard d’iOS/macOS lors de l’utilisation de schémas d’URL personnalisés. Consultez l’étape 6 pour éliminer cette alerte à l’aide de liens universels ou de 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 fonctionnent correctement :

• Mettez à jour Auth0.plist avec votre domaine personnalisé
• Utilisez le domaine personnalisé dans les URL de rappel/de déconnexion
• 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
• Implémentez une gestion appropriée des erreurs en cas d’échec réseau
• Ajoutez des descriptions d’utilisation liées à la confidentialité si vous utilisez le trousseau avec la biométrie
• Suivez les directives de révision de l’App Store pour les flux d’authentification

​

Bonnes pratiques de sécurité

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

​

Optimisation des performances

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

Intégration avancée

​

Configuration programmatique

Au lieu d’utiliser Auth0.plist, vous pouvez transmettre les informations d’identification directement dans votre code. C’est utile lorsque les informations d’identification doivent être dynamiques ou propres à l’environnement (p. ex., différents locataires Auth0 pour dev/staging/production).

Remplacez les appels Auth0.webAuth() par Auth0.webAuth(clientId:domain:) :

// Dans AuthenticationService.swift - fonction de connexion
func login() async {
    isLoading = true
    errorMessage = nil
    defer { isLoading = false }
    
    do {
        let credentials = try await Auth0
            .webAuth(clientId: "{yourClientId}", domain: "{yourDomain}")
            .scope("openid profile email offline_access")
            .start()
        
        _ = credentialsManager.store(credentials: credentials)
        isAuthenticated = true
        user = credentials.user
    } catch {
        errorMessage = "Échec de la connexion : \(error.localizedDescription)"
    }
}

// Dans AuthenticationService.swift - fonction de déconnexion
func logout() async {
    isLoading = true
    defer { isLoading = false }
    
    do {
        try await Auth0.webAuth(clientId: "{yourClientId}", domain: "{yourDomain}").clearSession()
        _ = credentialsManager.clear()
        isAuthenticated = false
        user = nil
    } catch {
        errorMessage = "Échec de la déconnexion : \(error.localizedDescription)"
    }
}

​

Sécurité renforcée du Trousseau grâce à la biométrie

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

private let credentialsManager: CredentialsManager = {
    let manager = CredentialsManager(authentication: Auth0.authentication())
    manager.enableBiometrics(
        withTitle: "Déverrouiller avec Face ID", 
        cancelTitle: "Annuler", 
        fallbackTitle: "Utiliser le code d’accès"
    )
    return manager
}()

Lorsque cette option est activée, les utilisateurs doivent s’authentifier par biométrie avant que le SDK puisse récupérer les informations d’identification stockées.

​

Actualisation automatique des jetons

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

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

Utilisez ce modèle lorsque vous effectuez des appels API qui exigent un jeton d’accès.

​

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

Pour les widgets, les extensions d’application ou les tâches en arrière-plan qui ont besoin de jetons d’accès :

// Créer un gestionnaire d’informations d’identification partagé avec un groupe d’applications
let credentialsManager = CredentialsManager(
    authentication: Auth0.authentication(),
    storeKey: "credentials",
    storage: .shared(withIdentifier: "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’applications 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 (aucun message de redirection)	Aucune	Affiche toutes les alertes
Prise en charge du SSO	Oui	Non	Oui
Compte développeur Apple	Requis	Non requis	Non requis
Expérience utilisateur	Optimale	Bonne	Acceptable
Complexité de configuration	Moyenne	Facile	Facile
Prise en charge de la navigation privée	Oui	Oui	Non

Recommandations :

• Applications de production avec SSO : Liens universels (meilleure UX, prise en charge du SSO, compte développeur Apple requis)
• Applications de production sans SSO : Sessions éphémères (aucune alerte, configuration plus simple)
• Tests/Développement : Sessions éphémères (configuration rapide, UX la plus épurée)
• Démarrage rapide/Prototypage : Option par défaut avec alertes (aucune configuration, migration possible plus tard)