> ## Documentation Index > Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Ajoutez la connexion à votre application iOS ou macOS avec le SDK Auth0.swift export const HowToSchema = () => ; export const AuthCodeGroup = ({children, dropdown}) => { const [processedChildren, setProcessedChildren] = useState(children); useEffect(() => { let unsubscribe = null; function init() { unsubscribe = window.autorun(() => { const processChildren = node => { if (typeof node === "string") { let processedNode = node; for (const [key, value] of window.rootStore.variableStore.values.entries()) { const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`); processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value); } return processedNode; } else if (Array.isArray(node)) { return node.map(processChildren); } else if (node && node.props && node.props.children) { return { ...node, props: { ...node.props, children: processChildren(node.props.children) } }; } return node; }; setProcessedChildren(processChildren(children)); }); } if (window.rootStore) { init(); } else { window.addEventListener("adu:storeReady", init); } return () => { window.removeEventListener("adu:storeReady", init); unsubscribe?.(); }; }, [children]); return {processedChildren}; }; 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](https://agentskills.io/home). **Installez :** ```bash theme={null} npx skills add auth0/agent-skills --skill auth0 ``` **Demandez ensuite à votre assistant IA :** ```text theme={null} 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 →](/docs/fr-ca/quickstart/agent-skills)
## Pour commencer
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. Ajoutez le SDK Auth0 à votre projet à l’aide du gestionnaire de paquets de votre choix. **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** 1. Créez un `Podfile` dans le répertoire de votre projet : ```ruby Podfile theme={null} 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 : ```bash theme={null} pod install ``` 3. Ouvrez le fichier `.xcworkspace` généré (et non le fichier `.xcodeproj`) 1. Créez un `Cartfile` dans le répertoire de votre projet : ```text Cartfile theme={null} github "auth0/Auth0.swift" ~> 3.0 ``` 2. Exécutez Carthage : ```bash theme={null} 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** Créez une nouvelle application Auth0 et configurez les URL de rappel. 1. Accédez au [Auth0 Dashboard](https://manage.auth0.com/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** : ``` https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback, YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback ``` ``` https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback, YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback ``` 5. Ajoutez les URL suivantes à **Allowed Logout URLs** : ``` https://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback, YOUR_BUNDLE_IDENTIFIER://{yourDomain}/ios/YOUR_BUNDLE_IDENTIFIER/callback ``` ``` https://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback, YOUR_BUNDLE_IDENTIFIER://{yourDomain}/macos/YOUR_BUNDLE_IDENTIFIER/callback ``` 6. Cliquez sur **Save Changes** Créez `Auth0.plist` dans le répertoire de votre projet : ```xml Auth0.plist theme={null} ClientId YOUR_AUTH0_CLIENT_ID Domain {yourDomain} ``` Faites glisser `Auth0.plist` dans Xcode et assurez-vous que l’option "Add to target" est cochée. 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 : ```swift AuthenticationService.swift expandable lines theme={null} 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)" } } } ``` 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. 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. Ajoutez `.useEphemeralSession()` à la requête de login dans `AuthenticationService.swift` : ```swift theme={null} // 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). 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é
### 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. Si vous utilisez un [domaine personnalisé](/docs/fr-ca/customize/custom-domains), 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` ### 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](/docs/fr-ca/troubleshoot/product-lifecycle/past-migrations#avoid-pinning-or-fingerprinting-tls-certificates-for-auth0-endpoints) ### 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) ### 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 : ```swift theme={null} 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 : ```swift theme={null} // 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 : ```swift theme={null} // 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)