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

Viktigt!

Från och med den 1 maj 2025 är Azure AD B2C inte längre tillgängligt att köpa för nya kunder. Läs mer i våra vanliga frågor och svar.

Den här artikeln visar hur du lägger till Azure Active Directory B2C-autentisering (Azure AD B2C) i ditt eget iOS Swift-mobilprogram. 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 godkänner programmet inloggningar via Azure AD B2C.

Förutsättningar

Granska förutsättningarna och integreringsinstruktionerna i Konfigurera autentisering i en iOS Swift-exempelapp med hjälp av Azure AD B2C.

Skapa ett iOS Swift-appprojekt

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 ditt nya projekt, ange följande:
1. Produktnamn, till exempel MSALiOS.
2. Organisationsidentifierare, till exempel contoso.com.
3. För Gränssnittet väljer du Storyboard.
4. För Livscykel väljer du UIKit-appdelegat.
5. Som 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 podfile-filen 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 podfilfilen :
```
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 Referens för Podfile-syntax.
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 igen i Xcode, stänger du Xcode och öppnar sedan filen <your 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 i Azure AD B2C-programregistreringen.

MSAL-standardformatet för omdirigerings-URI är msauth.[Your_Bundle_Id]://auth. Ett exempel skulle vara 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 . Ditt program lyssnar på URL-schemat för återanropet från Azure AD B2C.

Öppna filen Info.plist som en källkodsfil i Xcode. 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ändarna autentiserar. I din UIViewControllersammanfogar du koden med koden som finns i GitHub.

Steg 4: Konfigurera din iOS Swift-app

När du har lagt till autentiseringskoden konfigurerar du din iOS Swift-app med dina Azure AD B2C-inställningar. Inställningarna för Azure AD 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 av en ansluten iOS-enhet.
Välj Logga in och registrera dig eller logga sedan in med ditt lokala eller sociala Azure AD B2C-konto.
Efter att du har autentiserat dig framgångsrikt, kommer du att se ditt visningsnamn i navigeringsfältet.

Steg 6: Anpassa kodbyggblocken

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

Steg 6.1: Instansiera ett offentligt klientprogram

Offentliga klientprogram är inte betrodda för att bevara programhemligheter på ett säkert sätt 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 utfärdare 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 webViewParameters klassmedlemmen med systemwebbvyn. Mer information finns i Anpassa webbläsare och WebViews 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ändarna uppmanas att registrera sig eller logga in med hjälp av systemwebbvyn. När användarna väljer knappen Logga in anropas authorizationButton metoden.

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

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 framgångsrikt eller misslyckat, returneras resultatet till closureacquireToken av metoden.

Metoden acquireToken returnerar objekten result och error . 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

För att anropa ett tokenbaserat auktoriseringswebb-API 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 bearertoken i auktoriseringshuvudet för HTTP-begäran med det här formatet:

Authorization: Bearer <access-token>

När användarna autentiserar interaktivt får appen en åtkomsttoken i stängningen acquireToken . För efterföljande webb-API-anrop använder du metoden för att hämta token utan interaktion (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 raderas 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:

Feedback

Var den här sidan till hjälp?

Last updated on 2025-05-01