Aktivera autentisering i din egen iOS Swift-app med hjälp av Azure AD B2C

Artikel
01/11/2024

Den här artikeln visar hur du lägger till Azure Active Directory B2C-autentisering (Azure AD B2C) i din egen iOS Swift-mobilapp. Lär dig hur du integrerar ett iOS Swift-program med Microsoft Authentication Library (MSAL) för iOS.

Använd den här artikeln med Konfigurera autentisering i ett iOS Swift-exempelprogram och ersätt iOS Swift-exempelappen med din egen iOS Swift-app. När du har slutfört anvisningarna i den här artikeln accepterar programmet inloggningar via Azure AD B2C.

Krav

Gå igenom förutsättningarna och integreringsanvisningarna i Konfigurera autentisering i en iOS Swift-exempelapp med hjälp av Azure AD B2C.

Skapa ett Swift-appprojekt för iOS

Om du inte redan har ett iOS Swift-program konfigurerar du ett nytt projekt genom att göra följande:

Öppna Xcode och välj sedan Arkiv>Nytt>projekt.
För iOS-appar väljer du iOS-app> och sedan Nästa.
För Välj alternativ för det nya projektet anger du följande:
1. Produktnamn, till exempel MSALiOS.
2. Organisationsidentifierare, till exempel contoso.com.
3. För Gränssnitt väljer du Storyboard.
4. För Livscykel väljer du UIKit-appdelegat.
5. För Språk väljer du Swift.
Välj Nästa.
Välj en mapp där du vill skapa din app och välj sedan Skapa.

Steg 1: Installera MSAL-biblioteket

Använd CocoaPods för att installera MSAL-biblioteket. Om podfilfilen inte finns i samma mapp som projektets .xcodeproj-fil skapar du en tom fil och ger den namnet podfile. Lägg till följande kod i podfile-filen :
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Ersätt <your-target-here> med namnet på projektet (till exempel MSALiOS). Mer information finns i Podfile-syntaxreferens.
I ett terminalfönster går du till mappen som innehåller podfile-filen och kör sedan poddinstallationen för att installera MSAL-biblioteket.
När du har kört pod install kommandot skapas en< projektnamn.xcworkspace-fil>. Om du vill läsa in projektet i Xcode igen stänger du Xcode och öppnar <sedan filen project name.xcworkspace>.

Steg 2: Ange appens URL-schema

När användarna autentiserar skickar Azure AD B2C en auktoriseringskod till appen med hjälp av omdirigerings-URI:n som konfigurerats på Azure AD B2C-programregistrering.

MSAL-standardformatet för omdirigerings-URI är msauth.[Your_Bundle_Id]://auth. Ett exempel är msauth.com.microsoft.identitysample.MSALiOS://auth, där msauth.com.microsoft.identitysample.MSALiOS är URL-schemat.

I det här steget registrerar du ditt URL-schema med hjälp av matrisen CFBundleURLSchemes . Programmet lyssnar på URL-schemat för återanropet från Azure AD B2C.

I Xcode öppnar du info.plist-filen som en källkodsfil. I avsnittet <dict> lägger du till följande XML-kodfragment:

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

Steg 3: Lägg till autentiseringskoden

Exempelkoden består av en UIViewController klass. Klassen:

Definierar strukturen för ett användargränssnitt.
Innehåller information om din Azure AD B2C-identitetsprovider. Appen använder den här informationen för att upprätta en förtroenderelation med Azure AD B2C.
Innehåller autentiseringskoden för att autentisera användare, hämta token och verifiera dem.

Välj en UIViewController plats där användare autentiserar. I din sammanfogar du UIViewControllerkoden med koden som finns i GitHub.

Steg 4: Konfigurera din iOS Swift-app

När du har lagt till autentiseringskoden konfigurerar du iOS Swift-appen med dina Azure AD B2C-inställningar. Azure AD inställningarna för B2C-identitetsprovidern konfigureras i den UIViewController klass som valdes i föregående avsnitt.

Information om hur du konfigurerar din iOS Swift-app finns i Konfigurera autentisering i en iOS Swift-exempelapp med hjälp av Azure AD B2C.

Steg 5: Kör och testa mobilappen

Skapa och kör projektet med en simulator för en ansluten iOS-enhet.
Välj Logga in och registrera dig eller logga in med ditt lokala eller sociala Azure AD B2C-konto.
När du har autentiserats visas visningsnamnet i navigeringsfältet.

Steg 6: Anpassa kodbyggblocken

I det här avsnittet beskrivs de kodbyggstenar som aktiverar autentisering för din iOS Swift-app. Den listar UIViewControllers metoder och beskriver hur du anpassar din kod.

Steg 6.1: Instansiera ett offentligt klientprogram

Offentliga klientprogram är inte betrodda för att på ett säkert sätt behålla programhemligheter och de har inga klienthemligheter. I viewDidLoad instansierar du en MSAL med hjälp av ett offentligt klientprogramobjekt.

Följande Swift-kodfragment visar hur du initierar MSAL med ett MSALPublicClientApplicationConfig konfigurationsobjekt.

Konfigurationsobjektet innehåller information om din Azure AD B2C-miljö. Den tillhandahåller till exempel klient-ID, omdirigerings-URI och behörighet för att skapa autentiseringsbegäranden till Azure AD B2C. Information om konfigurationsobjektet finns i Konfigurera exempelmobilappen.

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

Metoden initWebViewParams konfigurerar den interaktiva autentiseringsupplevelsen .

Följande Swift-kodfragment initierar klassmedlemmen med systemets webViewParameters webbvy. Mer information finns i Anpassa webbläsare och webbvyer för iOS/macOS.

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

Steg 6.2: Starta en interaktiv auktoriseringsbegäran

En interaktiv auktoriseringsbegäran är ett flöde där användare uppmanas att registrera sig eller logga in med hjälp av systemets webbvy. När användarna väljer knappen authorizationButtonLogga in anropas metoden .

Metoden authorizationButton förbereder objektet MSALInteractiveTokenParameters med relevanta data om auktoriseringsbegäran. Metoden acquireToken använder för att autentisera MSALInteractiveTokenParameters användare via systemets webbvy.

Följande kodfragment visar hur du startar den interaktiva auktoriseringsbegäran:

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

När användarna har slutfört auktoriseringsflödet, antingen utan framgång eller utan framgång, returneras resultatet till stängningenacquireToken av metoden.

Metoden acquireToken returnerar - och error -objektenresult. Använd den här stängningen för att:

Uppdatera mobilappens användargränssnitt med information när autentiseringen har slutförts.
Anropa en webb-API-tjänst med en åtkomsttoken.
Hantera autentiseringsfel (till exempel när en användare avbryter inloggningsflödet).

Steg 6.3: Anropa ett webb-API

Om du vill anropa ett webb-API för tokenbaserad auktorisering behöver appen en giltig åtkomsttoken. Appen gör följande:

Hämtar en åtkomsttoken med nödvändiga behörigheter (omfång) för webb-API-slutpunkten.
Skickar åtkomsttoken som en ägartoken i auktoriseringshuvudet för HTTP-begäran med hjälp av följande format:

Authorization: Bearer <access-token>

När användare autentiserar interaktivt får appen en åtkomsttoken i stängningen acquireToken . För efterföljande webb-API-anrop använder du metoden hämta token tyst (acquireTokenSilent) enligt beskrivningen i det här avsnittet.

Metoden acquireTokenSilent utför följande åtgärder:

Den försöker hämta en åtkomsttoken med de begärda omfången från tokencachen. Om token finns och inte har upphört att gälla returneras token.
Om token inte finns i tokencachen eller om den har upphört att gälla försöker MSAL-biblioteket använda uppdateringstoken för att hämta en ny åtkomsttoken.
Om uppdateringstoken inte finns eller har upphört att gälla returneras ett undantag. I det här fallet bör du uppmana användaren att logga in interaktivt.

Följande kodfragment visar hur du hämtar en åtkomsttoken:

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

Metoden callGraphAPI hämtar åtkomsttoken och anropar webb-API:et enligt följande:

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

Steg 6.4: Logga ut användare

När du loggar ut med MSAL tar du bort all känd information om användare från programmet. Använd utloggningsmetoden för att logga ut användare och uppdatera användargränssnittet. Du kan till exempel dölja skyddade gränssnittselement, dölja utloggningsknappen eller visa inloggningsknappen.

Följande kodfragment visar hur du loggar ut användare:

@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ästa steg

Lär dig att:

Share via