Ajoutez la fonction de connexion à votre application .NET Android et iOS

Utilisez l’IA pour intégrer Auth0

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

Installation :

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

Demandez ensuite à votre assistant IA :

Add Auth0 authentication to my .NET Android & iOS app

Votre assistant IA créera automatiquement votre application Auth0, récupérera les identifiants, installera le SDK Auth0 OidcClient, configurera les paramètres propres à chaque plateforme 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 .NET

   Créez un projet .NET MAUI ou .NET Android/iOS pour ce Quickstart.

   .NET MAUI

   Dans Visual Studio 2022 ou une version ultérieure :

   1. File → New → Project
   2. Sélectionnez le modèle .NET MAUI App
   3. Configurez votre projet :
      • Project name : Auth0MauiSample
      • Location : Choisissez l’emplacement de votre choix
      • Framework : .NET 8.0 ou version ultérieure
   4. Cliquez sur Create

   .NET Android

   Dans Visual Studio 2022 ou une version ultérieure :

   1. File → New → Project
   2. Sélectionnez le modèle Android App (.NET)
   3. Configurez votre projet :
      • Project name : Auth0AndroidSample
      • Framework : .NET 8.0 ou version ultérieure
   4. Cliquez sur Create

   .NET iOS

   Dans Visual Studio 2022 (Mac) ou Visual Studio for Mac :

   1. File → New → Project
   2. Sélectionnez le modèle iOS App (.NET)
   3. Configurez votre projet :
      • Project name : Auth0iOSSample
      • Framework : .NET 8.0 ou version ultérieure
   4. Cliquez sur Create

   Ce Quickstart porte sur .NET Android et iOS, la nouvelle génération de Xamarin.Android et Xamarin.iOS. Si vous utilisez encore Xamarin, vous pouvez suivre ce guide, car l’intégration est identique et les SDKs sont compatibles.

2. Installer le SDK Auth0

   Ajoutez le SDK Auth0 OIDC Client à votre projet.

   Console du gestionnaire de packages

   Ouvrez la console du gestionnaire de packages (View → Other Windows → Package Manager Console) et installez le package approprié :

   Pour .NET Android :

   Package Manager Console

   Install-Package Auth0.OidcClient.AndroidX
   

   Pour .NET iOS :

   Package Manager Console

   Install-Package Auth0.OidcClient.iOS
   

   Pour .NET MAUI (les deux plateformes) :

   Package Manager Console

   Install-Package Auth0.OidcClient.MAUI
   

   Visual Studio pour Mac

   1. Dans le Solution Pad, faites un Ctrl+clic (ou un clic droit) sur le dossier Packages
   2. Sélectionnez Add Packages…
   3. Recherchez :
      • Auth0.OidcClient.AndroidX pour Android
      • Auth0.OidcClient.iOS pour iOS
      • Auth0.OidcClient.MAUI pour les projets MAUI
   4. Sélectionnez le package, puis cliquez sur Add Package

   .NET CLI

   Exécutez la commande suivante dans le répertoire de votre projet :

   Pour .NET Android :

   Terminal

   dotnet add package Auth0.OidcClient.AndroidX
   

   Pour .NET iOS :

   Terminal

   dotnet add package Auth0.OidcClient.iOS
   

   Pour .NET MAUI :

   Terminal

   dotnet add package Auth0.OidcClient.MAUI
   

   Le SDK Auth0 OIDC Client prend en charge tous les détails du protocole OAuth 2.0 et d’OIDC, et fournit une API simple pour l’authentification.

3. Configurez votre Auth0 App

   Créez une nouvelle application dans votre tenant Auth0 et configurez-la pour le mobile.

   1. Accédez à l’Auth0 Dashboard
   2. Cliquez sur Applications → Applications → Create Application
   3. Saisissez un nom pour votre application, sélectionnez Native comme type d’application, puis cliquez sur Create
   4. Allez à l’onglet Settings dans la page Details de l’application
   5. Prenez en note votre Domain et votre Client ID — vous en aurez besoin à l’étape suivante

   Configurer les URL de rappel :

   Dans l’onglet Settings, ajoutez les URL suivantes :

   Allowed Callback URLs :

   Android

   YOUR_ANDROID_PACKAGE_NAME://{yourDomain}/android/YOUR_ANDROID_PACKAGE_NAME/callback
   

   Remplacez :

   • YOUR_ANDROID_PACKAGE_NAME par le nom du package de votre application (p. ex., com.mycompany.myapp)
   • {yourDomain} par votre domaine Auth0 (p. ex., dev-abc123.us.auth0.com)

   Exemple : com.mycompany.myapp://dev-abc123.us.auth0.com/android/com.mycompany.myapp/callback

   iOS

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

   Remplacez :

   • YOUR_BUNDLE_IDENTIFIER par l’identifiant du bundle de votre application (p. ex., com.mycompany.myapp)
   • {yourDomain} par votre domaine Auth0 (p. ex., dev-abc123.us.auth0.com)

   Exemple : com.mycompany.myapp://dev-abc123.us.auth0.com/ios/com.mycompany.myapp/callback

   Allowed Logout URLs :

   Utilisez les mêmes URL que pour vos callback URLs.

   Assurez-vous que les URL de rappel et de logout sont en minuscules. Si les URL ne correspondent pas, l’authentification échouera.

   Les Allowed Callback URLs sont essentielles à la sécurité — elles garantissent que les utilisateurs sont redirigés de façon sécuritaire vers votre application après l’authentification. Sans URL correspondante, le processus de connexion échouera.

   Les Allowed Logout URLs assurent une expérience fluide lorsque les utilisateurs se déconnectent, en les redirigeant vers votre application plutôt que de les laisser sur une page Auth0.

4. Initialiser le client Auth0

   Créez une instance de Auth0Client pour communiquer avec Auth0.

   Android - MainActivity

   MainActivity.cs

   using Auth0.OidcClient;
   using Android.App;
   using Android.Content;
   
   [Activity(Label = "Auth0Sample", MainLauncher = true, Icon = "@drawable/icon",
       LaunchMode = LaunchMode.SingleTask)]
   [IntentFilter(
       new[] { Intent.ActionView },
       Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable },
       DataScheme = "YOUR_ANDROID_PACKAGE_NAME",
       DataHost = "{yourDomain}",
       DataPathPrefix = "/android/YOUR_ANDROID_PACKAGE_NAME/callback")]
   public class MainActivity : Activity
   {
       private Auth0Client auth0Client;
   
       protected override void OnCreate(Bundle savedInstanceState)
       {
           base.OnCreate(savedInstanceState);
   
           // Initialiser le client Auth0
           auth0Client = new Auth0Client(new Auth0ClientOptions
           {
               Domain = "{yourDomain}",
               ClientId = "{yourClientId}"
           }, this);
       }
   
       protected override async void OnNewIntent(Intent intent)
       {
           base.OnNewIntent(intent);
           Auth0.OidcClient.ActivityMediator.Instance.Send(intent.DataString);
       }
   }
   

   Remplacez YOUR_ANDROID_PACKAGE_NAME, {yourDomain} et {yourClientId} par vos valeurs réelles. Assurez-vous que tout le texte dans DataScheme, DataHost et DataPathPrefix est en minuscules.

   Le IntentFilter enregistre votre application pour qu’elle puisse gérer l’URL de rappel. LaunchMode.SingleTask garantit qu’Android ne crée pas de nouvelle instance d’activité lorsque le rappel est déclenché.

   iOS - AppDelegate

   Commencez par enregistrer le schéma d’URL dans votre Info.plist :

   Info.plist

   <key>CFBundleURLTypes</key>
   <array>
       <dict>
           <key>CFBundleTypeRole</key>
           <string>None</string>
           <key>CFBundleURLName</key>
           <string>Auth0</string>
           <key>CFBundleURLSchemes</key>
           <array>
               <string>YOUR_BUNDLE_IDENTIFIER</string>
           </array>
       </dict>
   </array>
   

   Ensuite, configurez votre AppDelegate.cs :

   AppDelegate.cs

   using Auth0.OidcClient;
   using Foundation;
   using UIKit;
   
   [Register("AppDelegate")]
   public class AppDelegate : UIApplicationDelegate
   {
       private Auth0Client auth0Client;
   
       public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
       {
           // Initialiser le client Auth0
           auth0Client = new Auth0Client(new Auth0ClientOptions
           {
               Domain = "{yourDomain}",
               ClientId = "{yourClientId}"
           });
   
           return true;
       }
   
       public override bool OpenUrl(UIApplication application, NSUrl url,
           string sourceApplication, NSObject annotation)
       {
           ActivityMediator.Instance.Send(url.AbsoluteString);
           return true;
       }
   }
   

   Remplacez YOUR_BUNDLE_IDENTIFIER, {yourDomain} et {yourClientId} par vos valeurs réelles.

   Stockez votre domaine Auth0 et votre ID client dans un fichier de configuration ou dans les paramètres de l’application au lieu de les coder en dur, afin d’en faciliter la maintenance.

5. Implémenter la connexion et la déconnexion

   Ajoutez des méthodes pour gérer l’authentification des utilisateurs.

   Implement Login :

   Authentication.cs

   public async Task LoginAsync()
   {
       var loginResult = await auth0Client.LoginAsync();
   
       if (!loginResult.IsError)
       {
           // Authentification réussie
           var accessToken = loginResult.AccessToken;
           var idToken = loginResult.IdentityToken;
           var user = loginResult.User;
   
           // Stocker les identifiants et mettre à jour l'interface
           Console.WriteLine($"Logged in as: {user.FindFirst("name")?.Value}");
       }
       else
       {
           // Gérer l'erreur d'authentification
           Console.WriteLine($"Login error: {loginResult.Error}");
       }
   }
   

   Implement Logout :

   Authentication.cs

   public async Task LogoutAsync()
   {
       var logoutResult = await auth0Client.LogoutAsync();
   
       if (logoutResult == BrowserResultType.Success)
       {
           // Effacer les informations d'identification stockées
           // Mettre à jour l'interface utilisateur vers l'état déconnecté
           Console.WriteLine("Logged out successfully");
       }
   }
   

   La méthode LoginAsync() lance le navigateur système (ou Chrome Custom Tabs sur Android) pour afficher la page Universal Login d’Auth0. Après l’authentification, l’utilisateur est redirigé vers votre application au moyen de l’URL de rappel.

   Ajoutez ces méthodes à votre MainActivity (Android) ou à un ViewController (iOS), puis appelez-les quand les utilisateurs touchent aux boutons Login/Logout.

6. Exécutez votre application

   Compilez et exécutez votre application.

   Visual Studio (Windows)

   Pour Android :

   1. Sélectionnez un émulateur Android ou un appareil connecté dans la liste déroulante des appareils
   2. Appuyez sur F5 ou cliquez sur le bouton Run
   3. L’application sera compilée, déployée et lancée

   Pour iOS (nécessite un hôte de compilation Mac) :

   1. Connectez-vous à votre hôte de compilation Mac
   2. Sélectionnez un simulateur iOS ou un appareil dans la liste déroulante des appareils
   3. Appuyez sur F5 ou cliquez sur le bouton Run

   Visual Studio for Mac

   1. Sélectionnez votre plateforme cible (Android/iOS) dans la liste déroulante des appareils
   2. Sélectionnez un émulateur/simulateur ou un appareil connecté
   3. Appuyez sur ⌘+Return ou cliquez sur le bouton Run
   4. L’application sera compilée et lancée

   .NET CLI

   Pour Android :

   Terminal

   dotnet build -f net8.0-android
   dotnet run -f net8.0-android
   

   Pour iOS :

   Terminal

   dotnet build -f net8.0-ios
   dotnet run -f net8.0-ios
   

   Déroulement prévu :

   1. L’application s’ouvre avec un bouton Se connecter
   2. Touchez Se connecter → Le navigateur ou un onglet personnalisé Chrome s’ouvre → Terminez l’authentification
   3. Redirection automatique vers votre application
   4. L’utilisateur est authentifié avec succès

   Au premier lancement, iOS peut vous demander de confirmer l’ouverture du navigateur pour l’authentification. Il s’agit d’un comportement normal et attendu.

Point de contrôle

Vous disposez maintenant d’une expérience de connexion Auth0 entièrement fonctionnelle dans votre application .NET Android ou iOS. L’application utilise le navigateur du système pour assurer une authentification sécurisée et gère automatiquement le flux de retour.

---

​

Accéder aux renseignements de l’utilisateur

Après une authentification réussie, vous pouvez accéder aux renseignements de l’utilisateur dans le résultat de la connexion.

​

Résultat d’authentification

La méthode LoginAsync() renvoie un objet LoginResult contenant :

UserInfo.cs

var loginResult = await auth0Client.LoginAsync();

if (!loginResult.IsError)
{
    // Jetons d'accès
    var accessToken = loginResult.AccessToken;
    var idToken = loginResult.IdentityToken;
    var refreshToken = loginResult.RefreshToken;

    // Accéder aux claims de l'utilisateur
    var user = loginResult.User;
    var name = user.FindFirst("name")?.Value;
    var email = user.FindFirst("email")?.Value;
    var picture = user.FindFirst("picture")?.Value;

    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Email: {email}");
}

​

Parcourir l’ensemble des claims

Pour voir toutes les informations utilisateur disponibles :

UserClaims.cs

if (!loginResult.IsError)
{
    foreach (var claim in loginResult.User.Claims)
    {
        Console.WriteLine($"{claim.Type}: {claim.Value}");
    }
}

Les claims renvoyés dépendent des scopes demandés. Pour en savoir plus, consultez Utilisation des scopes dans la documentation d’Auth0 OIDC Client.

​

Demander des scopes personnalisés

Pour demander des renseignements supplémentaires sur l’utilisateur, précisez les scopes lors de la création de l’Auth0Client :

CustomScopes.cs

var auth0Client = new Auth0Client(new Auth0ClientOptions
{
    Domain = "{yourDomain}",
    ClientId = "{yourClientId}",
    Scope = "openid profile email offline_access read:posts"
});

---

​

Dépannage et options avancées

Problèmes courants et solutions

​

Le navigateur ne redirige pas vers l’application

Solutions :

1. Vérifiez que les URL de rappel dans l’Auth0 Dashboard correspondent exactement au nom du package ou à l’identificateur de bundle de votre application
2. Assurez-vous que les URL de rappel sont en minuscules
3. Vérifiez que DataScheme, DataHost et DataPathPrefix (Android) ou le schéma d’URL (iOS) correspondent à votre configuration
4. Nettoyez et regénérez votre projet

​

L’authentication échoue avec l’erreur « Invalid Callback URL »

Correctif :

• Vérifiez de nouveau que votre URL de rappel dans l’Auth0 Dashboard respecte le format suivant :
  • Android: packagename://yourdomain/android/packagename/callback
  • iOS: bundleidentifier://yourdomain/ios/bundleidentifier/callback
• Assurez-vous que l’URL est en minuscules
• Vérifiez que le Domain dans votre code correspond au Domain dans l’Auth0 Dashboard

​

LoginAsync() se bloque ou ne se termine jamais

Solutions :

• Assurez-vous que le filtre d’intention (Android) ou le schéma d’URL (iOS) est correctement configuré
• Vérifiez que OnNewIntent() (Android) ou OpenUrl() (iOS) appelle ActivityMediator
• Vérifiez que votre application peut ouvrir le navigateur système
• Vérifiez la connectivité réseau

​

Error : « Default App must use Token Endpoint Authentication Method ‘None’ »

Correctif :

1. Accédez à Application Settings de votre Auth0 Application dans le Dashboard
2. Faites défiler jusqu’à Application Properties
3. Réglez Application Type sur Native
4. Réglez Token Endpoint Authentication Method sur None
5. Cliquez sur Save Changes

​

iOS : le navigateur ne s’ouvre pas

Solutions :

• Vérifiez que Info.plist contient la bonne configuration de schéma d’URL
• Vérifiez que OpenUrl() est implémenté dans AppDelegate
• Assurez-vous que la cible de déploiement iOS est compatible avec la version de votre Auth0 SDK

Considérations pour la production

​

Bonnes pratiques de sécurité

• Stockage sécurisé des jetons : utilisez un stockage sécurisé propre à la plateforme (Android Keystore, iOS Keychain) pour stocker les jetons
• Actualisation des jetons : implémentez la gestion des jetons d’actualisation pour maintenir les sessions utilisateur
• Certificate Pinning : envisagez l’épinglage de certificat pour renforcer la sécurité de l’API
• ProGuard/obscurcissement du code : ajoutez les règles appropriées si vous utilisez l’obscurcissement du code sur Android

​

Exigences des boutiques d’applications

• Politique de confidentialité : assurez-vous que votre application a une politique de confidentialité qui décrit l’utilisation d’Auth0
• Gestion des données utilisateur : suivez les directives de la plateforme pour le traitement des données d’authentication des utilisateurs
• Liens profonds : testez en profondeur la gestion des URL de rappel dans différents scénarios
• Exigences réseau : gérez adéquatement les scénarios hors ligne

​

Optimisation des performances

• Mettre Auth0Client en cache : créez une seule instance et réutilisez-la dans toute votre application
• Chargement différé : initialisez Auth0Client seulement au besoin
• Actualisation en arrière-plan : implémentez l’actualisation des jetons en arrière-plan pour les sessions de longue durée

Configuration avancée

​

Scopes personnalisés et audience

Demandez des scopes précis et définissez une audience pour votre API :

AdvancedAuth.cs

var auth0Client = new Auth0Client(new Auth0ClientOptions
{
    Domain = "{yourDomain}",
    ClientId = "{yourClientId}",
    Scope = "openid profile email offline_access read:posts write:posts",
    Audience = "https://myapi.example.com"
});

var loginResult = await auth0Client.LoginAsync();

​

Paramètres supplémentaires

Ajoutez des paramètres supplémentaires à la demande d’autorisation :

ExtraParams.cs

var extraParameters = new Dictionary<string, string>
{
    { "prompt", "login" },
    { "ui_locales", "es" },
    { "custom_param", "value" }
};

var loginResult = await auth0Client.LoginAsync(extraParameters);

​

Jetons d’actualisation

Utilisez des jetons d’actualisation pour obtenir de nouveaux jetons d’accès sans intervention de l’utilisateur :

RefreshToken.cs

var refreshResult = await auth0Client.RefreshTokenAsync(loginResult.RefreshToken);

if (!refreshResult.IsError)
{
    var newAccessToken = refreshResult.AccessToken;
    var newIdToken = refreshResult.IdentityToken;
    // Enregistrer les nouveaux jetons
}

Pour recevoir un jeton d’actualisation, incluez le scope offline_access dans votre demande d’authentification.

​

Configuration du navigateur propre à la plateforme

Android - Utilisez Chrome Custom Tabs avec des couleurs personnalisées :

AndroidBrowser.cs

var auth0Client = new Auth0Client(new Auth0ClientOptions
{
    Domain = "{yourDomain}",
    ClientId = "{yourClientId}",
    Browser = new AndroidBrowser
    {
        ToolbarColor = Android.Graphics.Color.ParseColor("#FF6B35")
    }
}, this);

iOS - Utilisez SFSafariViewController avec une présentation personnalisée :

iOSBrowser.cs

var auth0Client = new Auth0Client(new Auth0ClientOptions
{
    Domain = "{yourDomain}",
    ClientId = "{yourClientId}",
    Browser = new ASWebAuthenticationSessionBrowser
    {
        PrefersEphemeralWebBrowserSession = false
    }
});

---

​

Prochaines étapes

Configurer les fournisseurs d’identité

Ajoutez des fournisseurs de connexion sociale comme Google, Facebook et GitHub

Activer l’authentification multifacteur

Ajoutez une couche de sécurité supplémentaire grâce à la MFA

Protection contre les attaques

Découvrez comment vous protéger contre les attaques par force brute et par bots

Personnaliser l’expérience de connexion

Personnalisez la page Universal Login pour l’harmoniser avec votre image de marque