Verificatie inschakelen in uw eigen iOS Swift-app met behulp van Azure AD B2C

  • Artikel

In dit artikel wordt beschreven hoe u Azure Active Directory B2C-verificatie (Azure AD B2C) toevoegt aan uw eigen mobiele iOS Swift-toepassing. Meer informatie over het integreren van een iOS Swift-toepassing met de Microsoft Authentication Library (MSAL) voor iOS.

Gebruik dit artikel met Verificatie configureren in een iOS Swift-voorbeeldtoepassing, waarbij u de voorbeeld-iOS Swift-app vervangt door uw eigen iOS Swift-app. Nadat u de instructies in dit artikel hebt voltooid, accepteert uw toepassing aanmeldingen via Azure AD B2C.

Vereisten

Bekijk de vereisten en integratie-instructies in Verificatie configureren in een iOS Swift-voorbeeld-app met behulp van Azure AD B2C.

Een iOS Swift-app-project maken

Als u nog geen iOS Swift-toepassing hebt, kunt u een nieuw project instellen door de volgende stappen uit te voeren:

  1. Open Xcodeen selecteer> bestandNieuw>project.
  2. Voor iOS-apps selecteert u iOS-app> en selecteert u vervolgensVolgende.
  3. Geef bij Opties kiezen voor uw nieuwe project het volgende op:
    1. Productnaam, zoals MSALiOS.
    2. Organisatie-id, zoals contoso.com.
    3. Selecteer storyboard voor de interface.
    4. Selecteer UIKit App Delegate voor de levenscyclus.
    5. Selecteer Swift voor de taal.
  4. Selecteer Next.
  5. Selecteer een map waarin u uw app wilt maken en selecteer vervolgens Maken.

Stap 1: de MSAL-bibliotheek installeren

  1. Gebruik CocoaPods om de MSAL-bibliotheek te installeren. Als het podfile-bestand niet bestaat in dezelfde map als het .xcodeproj-bestand van uw project, maakt u een leeg bestand en geeft u dit de naam podfile. Voeg de volgende code toe aan het podfile-bestand :

    use_frameworks!

target '<your-target-here>' do
   pod 'MSAL'
end

  2. Vervang door <your-target-here> de naam van uw project (bijvoorbeeld MSALiOS). Zie Naslaginformatie over de podbestandsyntaxis voor meer informatie.

  3. Ga in een terminalvenster naar de map met het podfile-bestand en voer pod install uit om de MSAL-bibliotheek te installeren.

  4. Nadat u de pod install opdracht hebt uitgevoerd, wordt een <projectnaam.xcworkspace-bestand> gemaakt. Als u het project opnieuw wilt laden in Xcode, sluit u Xcode en opent u het bestand met de <projectnaam.xcworkspace>.

Stap 2: het APP-URL-schema instellen

Wanneer gebruikers zich verifiëren, verzendt Azure AD B2C een autorisatiecode naar de app met behulp van de omleidings-URI die is geconfigureerd voor de registratie van de Azure AD B2C-toepassing.

De MSAL-standaardomleidings-URI-indeling is msauth.[Your_Bundle_Id]://auth. Een voorbeeld is msauth.com.microsoft.identitysample.MSALiOS://auth, waarbij msauth.com.microsoft.identitysample.MSALiOS het URL-schema is.

In deze stap registreert u uw URL-schema met behulp van de CFBundleURLSchemes matrix. Uw toepassing luistert naar het URL-schema voor de callback van Azure AD B2C.

Open in Xcode het bestand Info.plist als broncodebestand. Voeg in de <dict> sectie het volgende XML-fragment toe:

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

Stap 3: de verificatiecode toevoegen

De voorbeeldcode bestaat uit een UIViewController klasse. De klasse:

  • Definieert de structuur voor een gebruikersinterface.
  • Bevat informatie over uw Azure AD B2C-id-provider. De app gebruikt deze informatie om een vertrouwensrelatie tot stand te brengen met Azure AD B2C.
  • Bevat de verificatiecode om gebruikers te verifiëren, tokens te verkrijgen en te valideren.

Kies een UIViewController waar gebruikers zich verifiëren. Voeg in uw UIViewControllerde code samen met de code die is opgegeven in GitHub.

Stap 4: uw iOS Swift-app configureren

Nadat u de verificatiecode hebt toegevoegd, configureert u uw iOS Swift-app met uw Azure AD B2C-instellingen. Azure AD instellingen van de B2C-id-provider worden geconfigureerd in de UIViewController klasse die in de vorige sectie is gekozen.

Zie Verificatie configureren in een iOS Swift-voorbeeld-app met behulp van Azure AD B2C voor meer informatie over het configureren van uw iOS Swift-app.

Stap 5: De mobiele app uitvoeren en testen

  1. Bouw en voer het project uit met een simulator van een verbonden iOS-apparaat.
  2. Selecteer Aanmelden en registreer u of meld u vervolgens aan met uw lokaal of sociale account van Azure AD B2C.
  3. Nadat u bent geverifieerd, ziet u uw weergavenaam in de navigatiebalk.

Stap 6: uw codebouwstenen aanpassen

In deze sectie worden de codebouwstenen beschreven die verificatie voor uw iOS Swift-app mogelijk maken. Hierin worden de methoden van UIViewController weergegeven en wordt besproken hoe u uw code kunt aanpassen.

Stap 6.1: Een openbare clienttoepassing instantiëren

Openbare clienttoepassingen worden niet vertrouwd om toepassingsgeheimen veilig te bewaren en ze hebben geen clientgeheimen. Maak in viewDidLoad een MSAL-exemplaar met behulp van een openbaar clienttoepassingsobject.

Het volgende Swift-codefragment laat zien hoe u msal initialiseert met een MSALPublicClientApplicationConfig configuratieobject.

Het configuratieobject biedt informatie over uw Azure AD B2C-omgeving. Het biedt bijvoorbeeld de client-id, omleidings-URI en instantie voor het bouwen van verificatieaanvragen voor Azure AD B2C. Zie De mobiele voorbeeld-app configureren voor meer informatie over het configuratieobject.

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

Met initWebViewParams de methode wordt de interactieve verificatie-ervaring geconfigureerd.

Het volgende Swift-codefragment initialiseert het webViewParameters klasselid met de systeemwebweergave. Zie Browsers en webweergaven voor iOS/macOS aanpassen voor meer informatie.

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

Stap 6.2: Een interactieve autorisatieaanvraag starten

Een interactieve autorisatieaanvraag is een stroom waarin gebruikers wordt gevraagd zich te registreren of zich aan te melden met behulp van de systeemwebweergave. Wanneer gebruikers de knop Aanmelden selecteren, wordt de authorizationButton methode aangeroepen.

De authorizationButton methode bereidt het MSALInteractiveTokenParameters object voor met relevante gegevens over de autorisatieaanvraag. De acquireToken methode gebruikt de MSALInteractiveTokenParameters om gebruikers te verifiëren via de systeemwebweergave.

Het volgende codefragment laat zien hoe u de interactieve autorisatieaanvraag start:

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

Nadat gebruikers de autorisatiestroom hebben voltooid, hetzij met succes of zonder succes, wordt het resultaat geretourneerd naar de afsluiting van de acquireToken methode.

De acquireToken methode retourneert de result objecten en error . Gebruik deze sluiting om het volgende te doen:

  • Werk de gebruikersinterface van de mobiele app bij met informatie nadat de verificatie is voltooid.
  • Een web-API-service aanroepen met een toegangstoken.
  • Verificatiefouten verwerken (bijvoorbeeld wanneer een gebruiker de aanmeldingsstroom annuleert).

Stap 6.3: Een web-API aanroepen

Als u een web-API voor autorisatie op basis van tokens wilt aanroepen, heeft de app een geldig toegangstoken nodig. De app zorgt voor het volgende:

  1. Hiermee verkrijgt u een toegangstoken met de vereiste machtigingen (bereiken) voor het eindpunt van de web-API.
  2. Geeft het toegangstoken door als bearer-token in de autorisatieheader van de HTTP-aanvraag met behulp van deze indeling:
Authorization: Bearer <access-token>

Wanneer gebruikers interactief verifiëren, krijgt de app een toegangstoken in de acquireToken sluiting. Gebruik voor volgende web-API-aanroepen de methode token op de achtergrond verkrijgen (acquireTokenSilent), zoals beschreven in deze sectie.

De acquireTokenSilent methode voert de volgende acties uit:

  1. Er wordt geprobeerd een toegangstoken op te halen met de aangevraagde bereiken uit de tokencache. Als het token aanwezig is en niet is verlopen, wordt het token geretourneerd.
  2. Als het token niet aanwezig is in de tokencache of als het is verlopen, probeert de MSAL-bibliotheek het vernieuwingstoken te gebruiken om een nieuw toegangstoken te verkrijgen.
  3. Als het vernieuwingstoken niet bestaat of is verlopen, wordt er een uitzondering geretourneerd. In dit geval moet u de gebruiker vragen zich interactief aan te melden.

Het volgende codefragment laat zien hoe u een toegangstoken verkrijgt:

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

De callGraphAPI methode haalt het toegangstoken op en roept de web-API aan, zoals hier wordt weergegeven:

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

Stap 6.4: Gebruikers afmelden

Als u zich afmeldt met MSAL, verwijdert u alle bekende informatie over gebruikers uit de toepassing. Gebruik de afmeldingsmethode om gebruikers af te melden en de gebruikersinterface bij te werken. U kunt bijvoorbeeld beveiligde UI-elementen verbergen, de afmeldingsknop verbergen of de aanmeldingsknop weergeven.

Het volgende codefragment laat zien hoe u gebruikers afmeldt:

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

Volgende stappen

Leer hoe u het volgende doet: