Activer l’authentification dans votre propre application iOS Swift à l’aide d’Azure AD B2C

Important

À compter du 1er mai 2025, Azure AD B2C ne sera plus disponible pour les nouveaux clients. Pour plus d’informations, consultez notre FAQ.

Cet article explique comment ajouter l’authentification Azure Active Directory B2C (Azure AD B2C) à votre propre application mobile iOS Swift. Découvrez comment intégrer une application iOS Swift à la bibliothèque d’authentification Microsoft (MSAL) pour iOS.

Utilisez cet article avec Configurer l’authentification dans un exemple d’application iOS Swift, en remplaçant l’exemple d’application Swift iOS par votre propre application iOS Swift. Une fois les instructions de cet article terminées, votre application accepte les connexions via Azure AD B2C.

Conditions préalables

Passez en revue les prérequis et les instructions d’intégration dans Configurer l’authentification dans un exemple d’application iOS Swift à l’aide d’Azure AD B2C.

Créer un projet d’application iOS Swift

Si vous n’avez pas encore d’application iOS Swift, configurez un nouveau projet en procédant comme suit :

Ouvrez Xcode, puis sélectionnezNouveau>projet de >.
Pour les applications iOS, sélectionnezApplication>, puis Sélectionnez Suivant.
Pour choisir les options de votre nouveau projet, fournissez les éléments suivants :
1. Nom du produit, tel que MSALiOS.
2. Identificateur de l’organisation, tel que contoso.com.
3. Pour l’interface, sélectionnez Storyboard.
4. Pour le cycle de vie, sélectionnez Délégué d’application UIKit.
5. Pour la langue, sélectionnez Swift.
Cliquez sur Suivant.
Sélectionnez un dossier dans lequel créer votre application, puis sélectionnez Créer.

Étape 1 : Installer la bibliothèque MSAL

Utilisez CocoaPods pour installer la bibliothèque MSAL. Dans le même dossier que le fichier .xcodeproj de votre projet, si le fichier podfile n’existe pas, créez un fichier vide et nommez-le podfile. Ajoutez le code suivant au fichier podfile :
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Remplacez <your-target-here> par le nom de votre projet (par exemple, MSALiOS). Pour plus d’informations, consultez La référence de la syntaxe Podfile.
Dans une fenêtre de terminal, accédez au dossier qui contient le fichier podfile , puis exécutez l’installation du pod pour installer la bibliothèque MSAL.
Après avoir exécuté la pod install commande, un <fichier name.xcworkspace> de votre projet est créé. Pour recharger le projet dans Xcode, fermez Xcode, puis ouvrez le <fichier name.xcworkspace> de votre projet .

Étape 2 : Définir le schéma d’URL de l’application

Lorsque les utilisateurs s’authentifient, Azure AD B2C envoie un code d’autorisation à l’application à l’aide de l’URI de redirection configuré sur l’inscription de l’application Azure AD B2C.

Le format d’URI de redirection par défaut MSAL est msauth.[Your_Bundle_Id]://auth. Un exemple serait msauth.com.microsoft.identitysample.MSALiOS://auth, où msauth.com.microsoft.identitysample.MSALiOS est le schéma d’URL.

Dans cette étape, enregistrez votre schéma d’URL à l’aide du tableau de données CFBundleURLSchemes. Votre application écoute le modèle d'URL du rappel à partir d'Azure AD B2C.

Dans Xcode, ouvrez le fichier Info.plist en tant que fichier de code source. Dans la <dict> section, ajoutez l’extrait de code XML suivant :

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>msauth.com.microsoft.identitysample.MSALiOS</string>
        </array>
    </dict>
</array>
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>msauthv2</string>
    <string>msauthv3</string>
</array>

Étape 3 : Ajouter le code d’authentification

L’exemple de code est constitué d’une UIViewController classe. La classe :

Définit la structure d’une interface utilisateur.
Contient des informations sur votre fournisseur d’identité Azure AD B2C. L’application utilise ces informations pour établir une relation d’approbation avec Azure AD B2C.
Contient le code d’authentification pour authentifier les utilisateurs, acquérir des jetons et les valider.

Choisissez un UIViewController emplacement où les utilisateurs s’authentifient. Dans votre UIViewController, fusionnez le code avec le code fourni dans GitHub.

Étape 4 : Configurer votre application iOS Swift

Après avoir ajouté le code d’authentification, configurez votre application iOS Swift avec vos paramètres Azure AD B2C. Les paramètres du fournisseur d’identité Azure AD B2C sont configurés dans la UIViewController classe choisie dans la section précédente.

Pour savoir comment configurer votre application iOS Swift, consultez Configurer l’authentification dans un exemple d’application iOS Swift à l’aide d’Azure AD B2C.

Étape 5 : Exécuter et tester l’application mobile

Générez et exécutez le projet avec un simulateur d’un appareil iOS connecté.
Sélectionnez Se connecter, puis inscrivez-vous ou connectez-vous avec votre compte local ou social Azure AD B2C.
Une fois que vous avez correctement authentifié, vous verrez votre nom complet dans la barre de navigation.

Étape 6 : Personnaliser vos blocs de construction de code

Cette section décrit les blocs de construction de code qui activent l’authentification pour votre application iOS Swift. Il répertorie les méthodes de UIViewController et explique comment personnaliser votre code.

Étape 6.1 : Instancier une application cliente publique

Les applications clientes publiques ne sont pas approuvées pour conserver en toute sécurité les secrets d’application et n’ont pas de secrets client. Dans viewDidLoad, instanciez un MSAL à l’aide d’un objet d’application cliente publique.

L’extrait de code Swift suivant montre comment initialiser MSAL avec un MSALPublicClientApplicationConfig objet de configuration.

L’objet de configuration fournit des informations sur votre environnement Azure AD B2C. Par exemple, il fournit l’ID client, l’URI de redirection et l’autorité pour générer des demandes d’authentification vers Azure AD B2C. Pour plus d’informations sur l’objet de configuration, consultez Configurer l’exemple d’application mobile.

do {

    let signinPolicyAuthority = try self.getAuthority(forPolicy: self.kSignupOrSigninPolicy)
    let editProfileAuthority = try self.getAuthority(forPolicy: self.kEditProfilePolicy)
    
    let pcaConfig = MSALPublicClientApplicationConfig(clientId: kClientID, redirectUri: kRedirectUri, authority: signinPolicyAuthority)
    pcaConfig.knownAuthorities = [signinPolicyAuthority, editProfileAuthority]
    
    self.applicationContext = try MSALPublicClientApplication(configuration: pcaConfig)
    self.initWebViewParams()
    
    } catch {
        self.updateLoggingText(text: "Unable to create application \(error)")
    }

La initWebViewParams méthode configure l’expérience d’authentification interactive .

L’extrait de code Swift suivant initialise le membre de webViewParameters classe avec la vue web système. Pour plus d’informations, consultez Personnaliser les navigateurs et webViews pour iOS/macOS.

func initWebViewParams() {
    self.webViewParameters = MSALWebviewParameters(authPresentationViewController: self)
    self.webViewParameters?.webviewType = .default
}

Étape 6.2 : Démarrer une demande d’autorisation interactive

Une demande d’autorisation interactive est un flux dans lequel les utilisateurs sont invités à s’inscrire ou à se connecter à l’aide de la vue web système. Lorsque les utilisateurs sélectionnent le bouton Se connecter , la authorizationButton méthode est appelée.

La authorizationButton méthode prépare l’objet MSALInteractiveTokenParameters avec des données pertinentes sur la demande d’autorisation. La acquireToken méthode utilise la MSALInteractiveTokenParameters méthode pour authentifier les utilisateurs via la vue web système.

L’extrait de code suivant montre comment démarrer la demande d’autorisation interactive :

let parameters = MSALInteractiveTokenParameters(scopes: kScopes, webviewParameters: self.webViewParameters!)
parameters.promptType = .selectAccount
parameters.authority = authority

applicationContext.acquireToken(with: parameters) { (result, error) in

// On error code    
guard let result = result else {
    self.updateLoggingText(text: "Could not acquire token: \(error ?? "No error information" as! Error)")
    return
}

// On success code
self.accessToken = result.accessToken
self.updateLoggingText(text: "Access token is \(self.accessToken ?? "Empty")")
}

Une fois que les utilisateurs ont terminé le flux d’autorisation, avec succès ou échec, le résultat est retourné à la fermeture de la acquireToken méthode.

La méthode acquireToken retourne les objets result et error. Utilisez cette fermeture pour :

Mettez à jour l’interface utilisateur de l’application mobile avec des informations une fois l’authentification terminée.
Appelez un service d’API web avec un jeton d’accès.
Gérez les erreurs d’authentification (par exemple, lorsqu’un utilisateur annule le flux de connexion).

Étape 6.3 : Appeler une API web

Pour appeler une API web d’autorisation basée sur un jeton, l’application a besoin d’un jeton d’accès valide. L’application effectue les opérations suivantes :

Il obtient un jeton d’accès avec les autorisations requises (étendues) pour le point de terminaison de l’API web.
Transmet le jeton d’accès en tant que jeton du porteur dans l’en-tête d’autorisation de la requête HTTP à l’aide de ce format :

Authorization: Bearer <access-token>

Lorsque les utilisateurs s’authentifient de manière interactive, l’application obtient un jeton d’accès dans la acquireToken clôture. Pour les appels d'API web suivants, utilisez la méthode d'obtention de jeton sans assistance (acquireTokenSilent), comme décrit dans cette section.

La acquireTokenSilent méthode effectue les actions suivantes :

Il tente de récupérer un jeton d'accès avec les étendues demandées à partir du cache de jetons. Si le jeton est présent et n’a pas expiré, le jeton est retourné.
Si le jeton n’est pas présent dans le cache du jeton ou qu’il a expiré, la bibliothèque MSAL tente d’utiliser le jeton d’actualisation pour acquérir un nouveau jeton d’accès.
Si le jeton d’actualisation n’existe pas ou a expiré, une exception est retournée. Dans ce cas, vous devez inviter l’utilisateur à se connecter de manière interactive.

L’extrait de code suivant montre comment acquérir un jeton d’accès :

do {

// Get the authority using the sign-in or sign-up user flow
let authority = try self.getAuthority(forPolicy: self.kSignupOrSigninPolicy)

// Get the current account from the application context
guard let thisAccount = try self.getAccountByPolicy(withAccounts: applicationContext.allAccounts(), policy: kSignupOrSigninPolicy) else {
    self.updateLoggingText(text: "There is no account available!")
    return
}

// Configure the acquire token silent parameters
let parameters = MSALSilentTokenParameters(scopes: kScopes, account:thisAccount)
parameters.authority = authority
parameters.loginHint = "username"

// Acquire token silent
self.applicationContext.acquireTokenSilent(with: parameters) { (result, error) in
    if let error = error {
        
        let nsError = error as NSError
        
        // interactionRequired means we need to ask the user to sign in. This usually happens
        // when the user's Refresh Token is expired or if the user has changed their password
        // among other possible reasons.
        
        if (nsError.domain == MSALErrorDomain) {
            
            if (nsError.code == MSALError.interactionRequired.rawValue) {
                
                // Start an interactive authorization code
                // Notice we supply the account here. This ensures we acquire token for the same account
                // as we originally authenticated.
                
                ...
            }
        }
        
        self.updateLoggingText(text: "Could not acquire token: \(error)")
        return
    }
    
    guard let result = result else {
        
        self.updateLoggingText(text: "Could not acquire token: No result returned")
        return
    }
    
    // On success, set the access token to the accessToken class member. 
    // The callGraphAPI method uses the access token to call a web API  
    self.accessToken = result.accessToken
    ...
}
} catch {
self.updateLoggingText(text: "Unable to construct parameters before calling acquire token \(error)")
}

La callGraphAPI méthode récupère le jeton d’accès et appelle l’API web, comme illustré ici :

@objc func callGraphAPI(_ sender: UIButton) {
    guard let accessToken = self.accessToken else {
        self.updateLoggingText(text: "Operation failed because could not find an access token!")
        return
    }
    
    let sessionConfig = URLSessionConfiguration.default
    sessionConfig.timeoutIntervalForRequest = 30
    let url = URL(string: self.kGraphURI)
    var request = URLRequest(url: url!)
    request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
    let urlSession = URLSession(configuration: sessionConfig, delegate: self, delegateQueue: OperationQueue.main)
    
    self.updateLoggingText(text: "Calling the API....")
    
    urlSession.dataTask(with: request) { data, response, error in
        guard let validData = data else {
            self.updateLoggingText(text: "Could not call API: \(error ?? "No error information" as! Error)")
            return
        }
        
        let result = try? JSONSerialization.jsonObject(with: validData, options: [])
        
        guard let validResult = result as? [String: Any] else {
            self.updateLoggingText(text: "Nothing returned from API")
            return
        }
        
        self.updateLoggingText(text: "API response: \(validResult.debugDescription)")
        }.resume()
}

Étape 6.4 : Déconnecter les utilisateurs

La déconnexion avec MSAL supprime toutes les informations connues sur les utilisateurs de l’application. Utilisez la méthode de déconnexion pour déconnecter les utilisateurs et mettre à jour l’interface utilisateur. Par exemple, vous pouvez masquer les éléments d’interface utilisateur protégés, masquer le bouton de déconnexion ou afficher le bouton de connexion.

L’extrait de code suivant montre comment déconnecter les utilisateurs :

@objc func signoutButton(_ sender: UIButton) {
do {
    
    
    let thisAccount = try self.getAccountByPolicy(withAccounts: applicationContext.allAccounts(), policy: kSignupOrSigninPolicy)
    
    if let accountToRemove = thisAccount {
        try applicationContext.remove(accountToRemove)
    } else {
        self.updateLoggingText(text: "There is no account to signing out!")
    }
    
    ...
    
} catch  {
    self.updateLoggingText(text: "Received error signing out: \(error)")
}
}

Étapes suivantes

Découvrez comment :

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-05-07