Aktivieren der Authentifizierung in Ihrer eigenen iOS Swift-App mithilfe von Azure AD B2C

Artikel
01/11/2024

In diesem Artikel wird beschrieben, wie Sie Ihrer eigenen mobilen iOS Swift-Anwendung die Authentifizierung von Azure Active Directory B2C (Azure AD B2C) hinzufügen. Erfahren Sie, wie Sie eine iOS Swift-Anwendung in die Microsoft-Authentifizierungsbibliothek (MSAL) für iOS integrieren.

Verwenden Sie diesen Artikel mit dem Artikel Konfigurieren der Authentifizierung in einer iOS Swift-Beispielwebanwendung, und ersetzen Sie dabei die iOS Swift-Beispiel-App durch Ihre eigene iOS Swift-App. Nachdem Sie die Anleitung in diesem Artikel ausgeführt haben, akzeptiert Ihre Anwendung Anmeldungen über Azure AD B2C.

Voraussetzungen

Berücksichtigen Sie die Voraussetzungen und Integrationsschritte unter Konfigurieren der Authentifizierung in einer iOS Swift-Beispielanwendung mithilfe von Azure AD B2C.

Erstellen eines iOS Swift-App-Projekts

Falls Sie noch nicht über eine iOS Swift-Anwendung verfügen, richten Sie wie folgt ein neues Projekt ein:

Öffnen Sie Xcode, und wählen Sie Datei>Neu>Projekt aus.
Für iOS-Apps: Wählen Sie iOS>App und dann Weiter aus.
Geben Sie für Optionen für Ihr neues Projekt auswählen Folgendes an:
1. Product name (Produktname) z. B. MSALiOS.
2. Organization identifier (Organisations-ID), z. B. contoso.com.
3. Wählen Sie unter Interface (Schnittstelle) Storyboard aus.
4. Wählen Sie unter Life cycle (Lebenszyklus) UIKit App Delegate (UIKit-App-Delegat) aus.
5. Wählen Sie unter Language (Sprache) Swift aus.
Wählen Sie Weiter aus.
Wählen Sie einen Ordner für das Erstellen Ihrer App und dann die Option Erstellen aus.

Schritt 1: Installieren der MSAL-Bibliothek

Installieren Sie die MSAL-Bibliothek mithilfe von CocoaPods. Erstellen Sie im Ordner mit der Datei .xcodeproj Ihres Projekts, wenn die Datei podfile nicht vorhanden ist, eine leere Datei, und nennen Sie sie podfile. Fügen Sie der podfile-Datei den folgenden Code hinzu:
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Ersetzen Sie <your-target-here> durch den Namen Ihres Projekts (z. B. MSALiOS). Weitere Informationen finden Sie in der Referenz zur Podfile-Syntax.
Navigieren Sie in einem Terminalfenster zu dem Ordner, der die podfile-Datei enthält, und führen Sie dann pod install zum Installieren der MSAL-Bibliothek aus.
Nachdem Sie den Befehl pod install ausgeführt haben, wird eine Datei <Ihr Projektname>.xcworkspace erstellt. Um das Projekt in Xcode neu zu laden, schließen Sie Xcode und öffnen Sie dann die Datei <Ihr Projektname>.xcworkspace.

Schritt 2: Festlegen des URL-Schemas der App

Wenn sich ein Benutzer authentifiziert, sendet Azure AD B2C einen Autorisierungscode an die App, und zwar über den in der Azure AD B2C-Anwendungsregistrierung konfigurierten Umleitungs-URI.

Das MSAL-Standardformat für den Umleitungs-URI ist msauth.[Your_Bundle_Id]://auth. Beispielsweise msauth.com.microsoft.identitysample.MSALiOS://auth, wobei msauth.com.microsoft.identitysample.MSALiOS das URL-Schema ist

Registrieren Sie in diesem Schritt Ihr URL-Schema mithilfe des CFBundleURLSchemes-Arrays. Ihre Anwendung lauscht beim URL-Schema auf den Rückruf von Azure AD B2C.

Öffnen Sie in Xcode die Datei Info.plist als Quellcodedatei. Fügen Sie in Abschnitt <dict> den folgenden XML-Codeausschnitt hinzu:

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

Schritt 3: Hinzufügen des Authentifizierungscodes

Der Beispielcode besteht aus einer UIViewController-Klasse. Die Klasse hat folgende Merkmale:

Definiert die Struktur einer Benutzeroberfläche.
Enthält Informationen zu Ihrem Azure AD B2C-Identitätsanbieter. Die App stellt mithilfe dieser Informationen eine Vertrauensstellung mit Azure AD B2C her.
Enthält den Authentifizierungscode, um Benutzer zu authentifizieren, Token zu beziehen und zu überprüfen

Wählen Sie einen UIViewController aus, bei dem sich die Benutzer authentifizieren. Führen Sie in Ihrem UIViewController den Code mit dem Code zusammen, der in GitHub bereitgestellt wird.

Schritt 4: Konfigurieren Ihrer iOS Swift-App

Nachdem Sie den Authentifizierungscode hinzugefügt haben, konfigurieren Sie Ihre iOS Swift-App mit Ihren Azure AD B2C-Einstellungen. Einstellungen des Azure AD B2C-Identitätsanbieters werden in der im vorherigen Abschnitt gewählten UIViewController-Klasse konfiguriert.

Informationen zum Konfigurieren Ihrer iOS Swift-App finden Sie unter Konfigurieren der Authentifizierung in einer iOS Swift-Beispiel-App mit Azure AD B2C.

Schritt 5: Ausführen und Testen der mobilen App

Erstellen Sie das Projekt, und führen Sie es mit einem Simulator eines verbundenen iOS-Geräts aus.
Wählen Sie Registrieren, und melden Sie sich mit Ihrem lokalen oder Social Media-Konto für Azure AD B2C an.
Nachdem Sie sich erfolgreich authentifiziert haben, wird Ihr Anzeigename auf der Navigationsleiste angezeigt.

Schritt 6: Anpassen Ihrer Codebausteine

In diesem Abschnitt werden die Codebausteine beschrieben, die Ihrer iOS Swift-App die Authentifizierung ermöglichen. Hier finden Sie eine Liste der UiViewController-Methoden und erfahren, wie Sie Ihren Code anpassen.

Schritt 6.1: Instanziieren einer öffentlichen Clientanwendung

Öffentlichen Clientanwendungen sind nicht vertrauenswürdig genug, um Anwendungsgeheimnisse sicher aufzubewahren, deshalb enthalten sie keine geheimen Clientschlüssel. Instanziieren Sie eine MSAL in viewDidLoad mithilfe eines öffentlichen Clientanwendungsobjekts.

Der folgende Codeausschnitt veranschaulicht, wie die MSAL-Bibliothek mit einem MSALPublicClientApplicationConfig-Konfigurationsobjekt initialisiert wird.

Das Konfigurationsobjekt stellt Informationen zu Ihrer Azure AD B2C-Umgebung zur Verfügung. Sie stellt beispielsweise die Client-ID, den Umleitungs-URI und die Autorität zum Erstellen von Authentifizierungsanforderungen für Azure AD B2C bereit. Informationen zum Konfigurationsobjekt finden Sie unter Konfigurieren der mobilen Beispiel-App.

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)")
    }

Mit der initWebViewParams-Methode wird die Umgebung zur interaktiver Authentifizierung konfiguriert.

Der folgende Swift-Codeausschnitt initialisiert den Klassenmember webViewParameters mit der Systemwebansicht. Weitere Informationen finden Sie im Artikel Anpassen von Browsern und Webansichten für iOS/macOS.

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

Schritt 6.2: Starten einer interaktiven Autorisierungsanforderung

Eine interaktive Autorisierungsanforderung ist ein Flow, bei dem Benutzer mithilfe der Systemwebansicht zur Registrierung oder Anmeldung aufgefordert werden. Wenn Benutzer auf die Schaltfläche Anmelden klicken, wird die authorizationButton-Methode aufgerufen.

Die authorizationButton-Methode bereitet das Objekt MSALInteractiveTokenParameters mit relevanten Daten zur Autorisierungsanforderung vor. Die acquireToken-Methode verwendet MSALInteractiveTokenParameters, um den Benutzer mithilfe der Systemwebansicht zu authentifizieren.

Der folgende Codeausschnitt veranschaulicht, wie die interaktive Autorisierungsanforderung gestartet wird.

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")")
}

Sobald die Benutzer den Autorisierungsflow abgeschlossen haben (erfolgreich oder nicht), wird das Ergebnis an den Abschluss der acquireToken-Methode zurückgegeben.

Die acquireToken-Methode gibt die Objekte result und error zurück. Verwenden Sie diesen Abschluss für Folgendes:

Aktualisieren der Benutzeroberfläche der mobilen App mit Informationen nach Abschluss der Authentifizierung
Aufrufen eines Web-API-Diensts mit einem Zugriffstoken
Behandeln von Authentifizierungsfehlern, z. B. wenn ein Benutzer den Anmeldeflow abbricht

Schritt 6.3: Aufrufen einer Web-API

Zum Aufrufen einer tokenbasierten Autorisierungs-Web-API benötigt die App ein gültiges Zugriffstoken. Die App führt folgende Schritte aus:

Beziehen eines Zugriffstokens mit den erforderlichen Berechtigungen (Bereichen) für den Web-API-Endpunkt
Übergeben des Zugriffstokens als Bearertoken im Autorisierungsheader der HTTP-Anforderung in folgendem Format:

Authorization: Bearer <access-token>

Wenn sich Benutzer interaktiv authentifizieren, erhält die App im Abschluss acquireToken ein Zugriffstoken. Verwenden Sie für nachfolgende Web-API-Aufrufe die automatische Methode zum Abrufen des Tokens (acquireTokenSilent), wie in diesem Abschnitt beschrieben.

Die Methode „acquireTokenSilent“ bewirkt Folgendes:

Sie versucht, ein Zugriffstoken mit den angeforderten Bereichen aus dem Tokencache abzurufen. Wenn das Token vorhanden und nicht abgelaufen ist, wird es zurückgegeben.
Wenn das Token nicht im Tokencache vorhanden oder abgelaufen ist, versucht die MSAL-Bibliothek, mithilfe des Aktualisierungstokens ein neues Zugriffstoken zu beziehen.
Wenn das Aktualisierungstoken nicht vorhanden oder abgelaufen ist, wird eine Ausnahme zurückgegeben. In diesem Fall müssen Sie den Benutzer auffordern, sich interaktiv anzumelden.

Der folgende Codeausschnitt veranschaulicht das Beziehen eines Zugriffstokens:

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)")
}

Die callGraphAPI-Methode ruft das Zugriffstoken ab und die Web-API auf, wie Sie hier sehen können:

@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()
}

Schritt 6.4: Abmelden von Benutzern

Bei der Abmeldung mit MSAL werden alle bekannten Informationen über einen Benutzer aus der Anwendung entfernt. Verwenden Sie die Abmeldemethode, um Benutzer abzumelden und die Benutzeroberfläche zu aktualisieren. Sie können beispielsweise geschützte Benutzeroberflächenelemente und die Abmeldeschaltfläche ausblenden, oder die Anmeldeschaltfläche anzeigen.

Im folgenden Codeausschnitt wird das Abmelden von Benutzern veranschaulicht:

@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)")
}
}

Nächste Schritte

In diesem Artikel werden folgende Themen erläutert:

Freigeben über