Povolení ověřování ve vlastní aplikaci Swift pro iOS pomocí Azure AD B2C

Článek
01/11/2024

V tomto článku se dozvíte, jak přidat ověřování Azure Active Directory B2C (Azure AD B2C) do vlastní mobilní aplikace Swift pro iOS. Zjistěte, jak integrovat aplikaci Swift pro iOS s knihovnou Microsoft Authentication Library (MSAL) pro iOS.

Tento článek najdete v článku Konfigurace ověřování v ukázkové aplikaci Swift pro iOS, ve které ukázkovou aplikaci Swift pro iOS nahraďte vlastní aplikací pro iOS Swift. Po dokončení pokynů v tomto článku bude vaše aplikace přijímat přihlášení prostřednictvím Azure AD B2C.

Požadavky

Projděte si požadavky a pokyny k integraci v tématu Konfigurace ověřování v ukázkové aplikaci Swift pro iOS pomocí Azure AD B2C.

Vytvoření projektu aplikace Swift pro iOS

Pokud ještě nemáte aplikaci Swift pro iOS, nastavte nový projekt pomocí následujících kroků:

Otevřete Xcode a pak vyberte File NewProject (Nový>projekt souboru>).
U aplikací pro iOS vyberteAplikacepro iOS> a pak vyberte Další.
V části Zvolit možnosti pro nový projekt zadejte následující:
1. Název produktu, například MSALiOS.
2. Identifikátor organizace, například contoso.com.
3. V části Rozhraní vyberte Storyboard.
4. V části Životní cyklus vyberte UIKit – Delegát aplikace.
5. Jako Jazyk vyberte Swift.
Vyberte Další.
Vyberte složku, ve které chcete aplikaci vytvořit, a pak vyberte Vytvořit.

Krok 1: Instalace knihovny MSAL

Pomocí CocoaPods nainstalujte knihovnu MSAL. Pokud soubor podfile neexistuje, vytvořte ve stejné složce jako soubor .xcodeproj vašeho projektu prázdný soubor a pojmenujte ho podfile. Do souboru souboru podfile přidejte následující kód:
```
use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end
```
Nahraďte <your-target-here> názvem projektu (například MSALiOS). Další informace najdete v tématu Referenční informace k syntaxi souboru podfile.
V okně terminálu přejděte do složky, která obsahuje soubor podfile , a pak spusťte instalaci podu pro instalaci knihovny MSAL.
Po spuštění pod install příkazu se <vytvoří soubor s názvem> projektu.xcworkspace . Pokud chcete projekt znovu načíst v Xcode, zavřete Xcode a otevřete <soubor název> projektu.xcworkspace .

Krok 2: Nastavení schématu adres URL aplikace

Při ověřování uživatelů odešle Azure AD B2C do aplikace autorizační kód pomocí identifikátoru URI přesměrování nakonfigurovaného v registraci aplikace Azure AD B2C.

Výchozí formát identifikátoru URI přesměrování knihovny MSAL je msauth.[Your_Bundle_Id]://auth. Příkladem může být msauth.com.microsoft.identitysample.MSALiOS://auth, kde msauth.com.microsoft.identitysample.MSALiOS je schéma adresy URL.

V tomto kroku zaregistrujte schéma adres URL pomocí CFBundleURLSchemes pole . Vaše aplikace naslouchá na schématu adres URL zpětného volání z Azure AD B2C.

V Xcode otevřete soubor Info.plist jako soubor se zdrojovým kódem. <dict> V části přidejte následující fragment kódu XML:

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

Krok 3: Přidání ověřovacího kódu

Vzorový kód se skládá z UIViewController třídy. Třída:

Definuje strukturu uživatelského rozhraní.
Obsahuje informace o zprostředkovateli identity Azure AD B2C. Aplikace tyto informace použije k navázání vztahu důvěryhodnosti s Azure AD B2C.
Obsahuje ověřovací kód pro ověřování uživatelů, získání tokenů a jejich ověření.

Zvolte, kde se UIViewController uživatelé ověřují. V souboru UIViewControllersloučíte kód s kódem, který je k dispozici na GitHubu.

Krok 4: Konfigurace aplikace Swift pro iOS

Po přidání ověřovacího kódu nakonfigurujte aplikaci Swift pro iOS s nastavením Azure AD B2C. Azure AD nastavení zprostředkovatele identity B2C se konfigurují ve UIViewController třídě, která byla zvolena v předchozí části.

Informace o konfiguraci aplikace Swift pro iOS najdete v tématu Konfigurace ověřování v ukázkové aplikaci Swift pro iOS pomocí Azure AD B2C.

Krok 5: Spuštění a testování mobilní aplikace

Sestavte a spusťte projekt pomocí simulátoru připojeného zařízení s iOSem.
Vyberte Přihlásit se a pak se zaregistrujte nebo přihlaste pomocí místního účtu Azure AD B2C nebo účtu na sociálních sítích.
Po úspěšném ověření se na navigačním panelu zobrazí vaše zobrazované jméno.

Krok 6: Přizpůsobení stavebních bloků kódu

Tato část popisuje stavební bloky kódu, které umožňují ověřování pro aplikaci Swift pro iOS. Uvádí metody UIViewController a popisuje, jak přizpůsobit kód.

Krok 6.1: Vytvoření instance veřejné klientské aplikace

Veřejné klientské aplikace nejsou důvěryhodné pro bezpečné uchovávání tajných kódů aplikací a nemají tajné kódy klienta. V viewDidLoad vytvořte instanci knihovny MSAL pomocí objektu veřejné klientské aplikace.

Následující fragment kódu Swiftu ukazuje, jak inicializovat knihovnu MSAL pomocí objektu MSALPublicClientApplicationConfig konfigurace.

Konfigurační objekt poskytuje informace o prostředí Azure AD B2C. Poskytuje například ID klienta, identifikátor URI přesměrování a autoritu k sestavení žádostí o ověření pro Azure AD B2C. Informace o objektu konfigurace najdete v tématu Konfigurace ukázkové mobilní aplikace.

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

Metoda initWebViewParams konfiguruje prostředí interaktivního ověřování .

Následující fragment kódu Swift inicializuje webViewParameters člen třídy pomocí systémového webového zobrazení. Další informace najdete v tématu Přizpůsobení prohlížečů a zobrazení WebView pro iOS/macOS.

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

Krok 6.2: Spuštění interaktivní žádosti o autorizaci

Interaktivní žádost o autorizaci je tok, ve kterém jsou uživatelé vyzváni k registraci nebo přihlášení pomocí systémového webového zobrazení. Když uživatelé vyberou tlačítko Přihlásit se , zavolá se authorizationButton metoda .

Metoda authorizationButton připraví objekt s MSALInteractiveTokenParameters relevantními daty o žádosti o autorizaci. Metoda acquireToken používá MSALInteractiveTokenParameters k ověřování uživatelů prostřednictvím systémového webového zobrazení .

Následující fragment kódu ukazuje, jak spustit interaktivní žádost o autorizaci:

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

Jakmile uživatelé úspěšně nebo neúspěšně dokončí autorizační tok, vrátí se výsledek do uzavřeníacquireToken metody .

Metoda acquireToken vrátí objekty result a error . Toto uzavření použijte k:

Po dokončení ověřování aktualizujte uživatelské rozhraní mobilní aplikace informacemi.
Volání služby webového rozhraní API s přístupovým tokenem
Zpracování chyb ověřování (například když uživatel zruší tok přihlášení).

Krok 6.3: Volání webového rozhraní API

K volání webového rozhraní API pro autorizaci založeného na tokenu potřebuje aplikace platný přístupový token. Aplikace provede následující:

Získá přístupový token s požadovanými oprávněními (obory) pro koncový bod webového rozhraní API.
Přístupový token předá jako nosný token v autorizační hlavičce požadavku HTTP pomocí tohoto formátu:

Authorization: Bearer <access-token>

Když se uživatelé ověřují interaktivně, aplikace získá v acquireToken uzavření přístupový token. Pro následná volání webového rozhraní API použijte metodu získání tichého tokenu (acquireTokenSilent), jak je popsáno v této části.

Metoda acquireTokenSilent provede následující akce:

Pokusí se načíst přístupový token s požadovanými obory z mezipaměti tokenů. Pokud token existuje a nevypršela jeho platnost, vrátí se token.
Pokud se token v mezipaměti tokenů nenachází nebo vypršela jeho platnost, knihovna MSAL se pokusí použít obnovovací token k získání nového přístupového tokenu.
Pokud obnovovací token neexistuje nebo vypršela jeho platnost, vrátí se výjimka. V takovém případě byste měli uživatele vyzvat k interaktivnímu přihlášení.

Následující fragment kódu ukazuje, jak získat přístupový token:

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

Metoda callGraphAPI načte přístupový token a zavolá webové rozhraní API, jak je znázorněno tady:

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

Krok 6.4: Odhlášení uživatelů

Odhlášení pomocí KNIHOVNY MSAL odebere z aplikace všechny známé informace o uživatelích. Pomocí metody odhlášení odhlašujte uživatele a aktualizujte uživatelské rozhraní. Můžete například skrýt chráněné prvky uživatelského rozhraní, skrýt tlačítko pro odhlášení nebo zobrazit tlačítko pro přihlášení.

Následující fragment kódu ukazuje, jak odhlásit uživatele:

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

Další kroky

Naučte se:

Sdílet prostřednictvím