Activation de l’authentification dans votre propre application iOS Swift avec Azure AD B2C

Article
01/11/2024

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

Utilisez cet article avec l'article Configuration de l'authentification dans un exemple d'application iOS Swift, en remplaçant l'exemple d'application iOS Swift par votre propre application iOS Swift. Une fois que vous avez suivi les instructions de cet article, votre application acceptera les connexions via Azure AD B2C.

Prérequis

Passez en revue les conditions préalables et les instructions d’intégration dans Configuration de l’authentification dans un exemple d’application iOS Swift avec 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 suivant ces étapes :

Ouvrez Xcode, puis sélectionnez Fichier>Nouveau>Projet.
Pour les applications iOS, sélectionnez iOS>Application, puis sélectionnez Suivant.
Sous Choisissez les options de votre nouveau projet, fournissez les informations suivantes :
1. Nom du produit, par exemple MSALiOS.
2. Identificateur de l'organisation, par exemple contoso.com.
3. Dans le champ Interface, sélectionnez Storyboard.
4. Dans le champ Cycle de vie, sélectionnez UIKit App Delegate.
5. Dans le champ Langage, sélectionnez Swift.
Sélectionnez 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 dossier où se trouve le fichier .xcodeproj de votre projet, si le fichier podfile n'existe pas, créez un fichier vide et appelez-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 Informations de référence sur la syntaxe Podfile.
Dans une fenêtre de terminal, accédez au dossier qui contient le fichier podfile, puis exécutez pod install pour installer la bibliothèque MSAL.
Après avoir exécuté la commande pod install, un fichier <votre nom de projet>.xcworkspace est créé. Pour recharger le projet dans Xcode, fermez Xcode, puis ouvrez le fichier <votre nom de projet>.xcworkspace.

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

Lorsqu'un utilisateur s'authentifie, Azure AD B2C envoie un code d'autorisation à l'application à l'aide de l'URI de redirection configuré lors de l'inscription de l'application Azure AD B2C.

Le format de l'URI de redirection par défaut de MSAL est msauth.[Your_Bundle_Id]://auth. Par exemple, msauth.com.microsoft.identitysample.MSALiOS://auth, où msauth.com.microsoft.identitysample.MSALiOS correspond au modèle d'URL.

Lors de cette étape, inscrivez votre modèle d'URL à l'aide du tableau 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 section <dict>, 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 classe UIViewController. 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 de confiance avec Azure AD B2C ;
Contient le code d'authentification qui permet d'authentifier les utilisateurs, d'acquérir les jetons et de les valider.

Choisissez un UIViewController où les utilisateurs s'authentifieront. Dans votre UIViewController, fusionnez le code avec le code fourni dans GitHub.

Étape 4 : Configurer votre application iOS Swift

Après avoirajouté 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 classe UIViewController choisie à 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 de Azure AD B2C.

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

Générez et exécutez le projet avec un simulateur d'appareil iOS connecté.
Sélectionnez Se connecter, puis inscrivez-vous ou connectez-vous avec votre compte Azure AD B2C local ou avec un compte social.
Une fois que vous vous êtes correctement authentifié, vous verrez votre nom d’affichage 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 permettent l'authentification de votre application iOS Swift. Elle 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. Elles ne disposent pas de clé secrète client. Dans viewDidLoad, instanciez une MSAL à l'aide d'un objet d'application cliente publique.

L'extrait de code Swift suivant montre comment initialiser la bibliothèque MSAL avec un objet de configuration MSALPublicClientApplicationConfig.

L’objet de configuration fournit des informations sur votre environnement de Azure AD B2C. Par exemple, il fournit l’ID client, l’URI de redirection et l’autorité pour créer des demandes d’authentification à 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 méthode initWebViewParams configure l'expérience d'authentification interactive.

L'extrait de code Swift suivant initialise le membre de la classe webViewParameters avec l’affichage web du 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 requête d’autorisation interactive

Une requête d’autorisation interactive est un flux dans lequel les utilisateurs sont invités à s’inscrire ou à se connecter à l’aide de l’affichage web du système. Lorsque l'utilisateur clique sur le bouton Se connecter, la méthode authorizationButton est appelée.

La méthode authorizationButton prépare l'objet MSALInteractiveTokenParameters avec les données pertinentes sur la requête d'autorisation. La méthode acquireToken utilise le MSALInteractiveTokenParameters pour authentifier les utilisateurs dans la vue web du système.

L’extrait de code suivant montre comment démarrer la requête 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 non), le résultat est retourné à la fermeture de la méthode acquireToken.

La méthode acquireToken renvoie les objets result et error. Utilisez cette clôture pour :

Mettre à jour l'interface utilisateur de l'application mobile avec les informations une fois l'authentification effectuée
Appeler un service d'API web avec un jeton d'accès
Gérer 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 par jeton, l'application a besoin d'un jeton d'accès valide. L’application effectue les opérations suivantes :

Elle obtient un jeton d'accès avec les autorisations (étendues) requises pour le point de terminaison de l'API web.
Elle transmet le jeton d’accès en tant que porteur dans l’en-tête d’autorisation de la requête HTTP en utilisant le format suivant :

Authorization: Bearer <access-token>

Lorsque les utilisateurs s'authentifient de manière interactive, l'application obtient un jeton d'accès dans la clôture acquireToken. 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 méthode acquireTokenSilent exécute les actions suivantes :

Elle essaie de récupérer (fetch) un jeton d'accès avec les étendues demandées dans le cache des jetons. Si le jeton est présent et qu'il n'a pas expiré, il est renvoyé.
Si le jeton n'est pas présent dans le cache des jetons ou s'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 s'il a expiré, une exception est renvoyée. Dans ce cas, vous devez inviter l'utilisateur à se connecter de manière interactive.

L'extrait de code suivant montre comment obtenir 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 méthode callGraphAPI récupère le jeton d'accès et appelle l'API web, comme montré 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 entraîne la suppression de toutes les informations connues sur un utilisateur dans 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 protégés de l'interface utilisateur et le bouton de déconnexion, ou afficher le bouton de connexion.

L'extrait de code suivant montre comment déconnecter un utilisateur :

@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 :

Partager via