Passer au contenu principal

Premiers pas

1

Créer un projet

Créez un nouveau projet iOS ou macOS pour ce démarrage rapide.Dans Xcode :
  1. FileNewProject (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 et cliquez sur Create
Cela crée une application standard avec prise en charge de SwiftUI et de Swift Package Manager, idéale pour l’intégration à Auth0.
2

Ajouter la trousse de développement logiciel (SDK) d’Auth0

Ajoutez la trousse de développement logiciel (SDK) Auth0 à votre projet à l’aide du gestionnaire de paquets de votre choix.
Dans Xcode :
  1. FileAdd 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
3

Configurer Auth0

Créez une nouvelle Application Auth0 et configurez les URL de redirection (callback).
  1. Accédez à Auth0 Dashboard
  2. Applications > Create Application > Donnez-lui un nom, sélectionnez Native, puis Create
  3. Dans l’onglet Settings, notez votre Client ID et votre Domaine
  4. Ajoutez les URL suivantes à URL de redirection autorisées :
https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
  1. Ajoutez les URL suivantes à URL de déconnexion autorisées :
https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback,
YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback
  1. Cliquez sur Save Changes
4

Configurer les identifiants de l’application

Créez Auth0.plist dans le dossier 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 le fichier AuthenticationService.swift :
  1. Cliquez avec le bouton droit sur votre projet → New File…Swift File
  2. Nommez-le AuthenticationService
  3. Remplacez-en 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 = "Échec de la connexion : \(error.localizedDescription)"
        }
    }
    
    func logout() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            try await Auth0.webAuth().clearSession()
            _ = credentialsManager.clear()
            isAuthenticated = false
            user = nil
        } catch {
            errorMessage = "Échec de la déconnexion : \(error.localizedDescription)"
        }
    }
}
6

Créer des composants d’interface utilisateur

Créez les fichiers d’interface utilisateur et ajoutez du code :
touch AuthenticatedView.swift UnauthenticatedView.swift ProfileCard.swift LoadingView.swift
7

Configurer le flux d’authentification (facultatif)

Pour améliorer l’expérience utilisateur, vous pouvez réduire les alertes système de différentes façons :
  1. Utilisez les Universal Links : cela élimine l’invite « Ouvrir dans “AppName” ? » qui apparaît pendant la redirection. Remarque : l’alerte d’autorisation ASWebAuthenticationSession s’affichera tout de 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 cookies partagés.
Passez cette étape pour utiliser le comportement par défaut avec une alerte d’autorisation. Vous pourrez configurer cela plus tard.
8

Lancez votre application

Appuyez sur ⌘+R dans Xcode.
  1. Touchez « Se connecter » → Alerte d’autorisation (si vous utilisez les paramètres par défaut) → Touchez « Continuer »
  2. Terminez la connexion dans le navigateur
  3. Affichez votre profil!
Point de contrôleVous avez maintenant une connexion Auth0 entièrement fonctionnelle dans votre application iOS ou macOS !

Dépannage et fonctions avancées

Erreurs de compilation : module ‘Auth0’ introuvable

Solutions :
  1. Swift Package Manager : Vérifiez Package Dependencies → Assurez-vous que Auth0.swift y figure
  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 reconstruisez : ⌘+Shift+K puis ⌘+R
  5. Redémarrez Xcode au besoin

L’app plante : ‘Auth0.plist not found’

Correctif :
  1. Vérifiez que Auth0.plist se trouve dans l’explorateur de projet Xcode
  2. Sélectionnez le fichier → Inspector → Assurez-vous que la cible de votre app 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’app

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 (fréquent : deux-points manquants, format de domaine incorrect)
  5. Utilisateurs de domaine personnalisé : vérifiez que vous utilisez votre domaine personnalisé, et non le domaine Auth0

L’alerte d’autorisation apparaît à chaque fois

Il s’agit du comportement de sécurité standard d’iOS/macOS lorsque vous utilisez des schémas d’URL personnalisés. Consultez l’étape 6 pour éliminer cette alerte en utilisant Universal Links ou des sessions éphémères.
Si vous utilisez un domaine personnalisé, utilisez sa valeur partout à la place de votre domaine Auth0.Exemple : Utilisez login.example.com au lieu de tenant.auth0.comCeci 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 Universal Links, utilisez : webcredentials:login.example.com

Préparation pour l’App Store

  • Configurez les Universal Links pour éliminer l’alerte d’autorisation
  • Testez sur plusieurs versions de plateforme et tailles d’appareils
  • Mettez en œuvre une gestion adéquate des erreurs pour les pannes réseau
  • Ajoutez des descriptions d’utilisation de la confidentialité si vous utilisez le trousseau (Keychain) avec les données biométriques
  • Suivez les App Store Review Guidelines pour les flux d’authentification

Bonnes pratiques de sécurité

  • Ne journalisez jamais de données d’authentification sensibles en production
  • Mettez en œuvre la conformité App Transport Security (ATS)
  • Utilisez HTTPS pour toutes les requêtes réseau
  • NE PAS épingler les 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
  • Les propriétés @Published utilisent une gestion de mémoire appropriée
  • Les informations d’identification sont mises en cache de façon sécurisée dans le trousseau (Keychain) pour l’accès hors ligne
  • Le profil de l’utilisateur est récupéré à partir du jeton ID (aucune requête réseau supplémentaire)

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 à un environnement (par exemple, différents tenants Auth0 pour le développement, la préproduction et la 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 = "Login failed: \(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 = "Logout failed: \(error.localizedDescription)"
    }
}

Sécurité renforcée du trousseau avec les données biométriques

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: "Unlock with Face ID", 
        cancelTitle: "Cancel", 
        fallbackTitle: "Use Passcode"
    )
    return manager
}()
Une fois activée, l’authentification biométrique est requise avant que le SDK puisse récupérer les informations d’identification stockées.

Actualisation automatique du jeton d’accès

CredentialsManager actualise automatiquement les jetons d’accès expirés :
// Obtenir les informations d’identification - actualise automatiquement si 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 d’API qui exigent un jeton d’accès.

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

Pour les widgets, extensions d’app ou 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’apps
let credentialsManager = CredentialsManager(
    authentication: Auth0.authentication(),
    storeKey: "credentials",
    storage: .shared(withIdentifier: "group.com.example.myapp")
)
Exigences :
  1. Activer la fonctionnalité App Groups dans Xcode pour toutes les cibles
  2. Utiliser le même identifiant de groupe d’apps pour toutes les cibles
  3. Configurer le CredentialsManager partagé dans chaque cible

Comparaison des options de flux d’authentification

FonctionnalitéUniversal LinksSession éphémèreValeur par défaut (alerte)
Alertes d’autorisationRéduites (aucune invite de redirection)AucuneAffiche toutes les alertes
Prise en charge de la SSOOuiNonOui
Compte Apple DeveloperRequisNon requisNon requis
Expérience utilisateurMeilleureBonneAcceptable
Complexité de configurationMoyenneSimpleSimple
Prise en charge de la navigation privéeOuiOuiNon
Recommandations :
  • Applications de production avec SSO : Universal Links (meilleure UX, prise en charge de la SSO, nécessite un compte Apple Developer)
  • 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 : valeur par défaut avec alertes (aucune configuration, migration possible plus tard)