> ## 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. # Ajouter l’authentification à votre application iOS ou macOS à l’aide du 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 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](https://agentskills.io/home). **Installer :** ```bash theme={null} npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-swift ``` **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 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 →](/fr-CA/docs/quickstart/agent-skills)
## Pour commencer
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. Ajoutez le SDK Auth0 à votre projet avec le gestionnaire de paquets de votre choix. **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** 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', '~> 2.0' end ``` 2. Installez les dépendances : ```bash theme={null} pod install ``` 3. Ouvrez le fichier `.xcworkspace` généré (et non le `.xcodeproj`) 1. Créez un `Cartfile` dans le répertoire de votre projet : ```text Cartfile theme={null} github "auth0/Auth0.swift" ~> 2.0 ``` 2. Exécutez Carthage : ```bash theme={null} 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** Créez une nouvelle application Auth0 et configurez les URL de rappel. 1. Accédez à [Auth0 Dashboard](https://manage.auth0.com/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** : ``` 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 du projet : ```xml Auth0.plist theme={null} ClientId YOUR_AUTH0_CLIENT_ID Domain {yourDomain} ``` Glissez `Auth0.plist` dans Xcode et assurez-vous que l’option "Add to target" est cochée. Créez `AuthenticationService.swift` pour gérer Login, Logout et le stockage des jetons. **Utilisez `CredentialsManager` pour le stockage des jetons.** La classe `CredentialsManager` stocke les identifiants de manière sécurisée dans le trousseau et actualise automatiquement les jetons d’accès expirés. Utilisez-la toujours — ne stockez pas de jetons en mémoire, dans `UserDefaults` ou dans `localStorage`. 1. Cliquez avec le bouton droit sur votre projet → **Nouveau fichier...** → **Fichier Swift** 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: 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)" } } } ``` 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. 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. Ajoutez `.useEphemeralSession()` à l’appel de connexion dans `AuthenticationService.swift` : ```swift theme={null} // 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). 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
### 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 ### 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. Si vous utilisez un [domaine personnalisé](/fr-CA/docs/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 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` ### 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](/fr-CA/docs/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’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) ### 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 : ```swift theme={null} 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 : ```swift theme={null} // 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 : ```swift theme={null} // 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)