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

In dit artikel leest u hoe u Verificatie van Azure Active Directory B2C (Azure AD B2C) toevoegt aan uw eigen mobiele Android-toepassing.

Gebruik dit artikel met Verificatie configureren in een Android-voorbeeld-app met behulp van Azure AD B2C, waarbij u de voorbeeld-Android-app vervangt door uw eigen Android-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 Android-voorbeeld-app met behulp van Azure AD B2C.

Een Android-app-project maken

Als u nog geen Android-toepassing hebt, stelt u als volgt een nieuw project in:

1. Selecteer Start a new Android Studio project in Android Studio.
2. Selecteer Basisactiviteit en selecteer vervolgens Volgende.
3. Geef uw toepassing een naam.
4. Sla de naam van het pakket op. U voert deze later in Azure Portal in.
5. Wijzig de taal van Kotlin in Java.
6. Stel het minimale API-niveau in op API 19 of hoger en selecteer Voltooien.
7. Kies in de projectweergave Project in de vervolgkeuzelijst om bron- en niet-bronprojectbestanden weer te geven, open app/build.gradle en stel targetSdkVersion in op 28.

Stap 1: De afhankelijkheden installeren

Ga in het projectvenster van Android Studio naar app>build.gradle en voeg het volgende toe:

apply plugin: 'com.android.application'

allprojects {
    repositories {
    mavenCentral()
    google()
    mavenLocal()
    maven {
        url 'https://pkgs.dev.azure.com/MicrosoftDeviceSDK/DuoSDK-Public/_packaging/Duo-SDK-Feed/maven/v1'
    }
    maven {
        name "vsts-maven-adal-android"
        url "https://identitydivision.pkgs.visualstudio.com/_packaging/AndroidADAL/maven/v1"
        credentials {
            username System.getenv("ENV_VSTS_MVN_ANDROIDADAL_USERNAME") != null ? System.getenv("ENV_VSTS_MVN_ANDROIDADAL_USERNAME") : project.findProperty("vstsUsername")
            password System.getenv("ENV_VSTS_MVN_ANDROIDADAL_ACCESSTOKEN") != null ? System.getenv("ENV_VSTS_MVN_ANDROIDADAL_ACCESSTOKEN") : project.findProperty("vstsMavenAccessToken")
        }
    }
    jcenter()
    }
}
dependencies{
    implementation 'com.microsoft.identity.client:msal:2.+'
    }
packagingOptions{
    exclude("META-INF/jersey-module-version")
}

Stap 2: De verificatieonderdelen toevoegen

De voorbeeldcode bestaat uit de volgende onderdelen. Voeg deze onderdelen uit de Android-voorbeeld-app toe aan uw eigen app.

Onderdeel	Type	Source	Omschrijving
B2CUser	Klasse	KotlinJava	Vertegenwoordigt een B2C-gebruiker. Met deze klasse kunnen gebruikers zich aanmelden met meerdere beleidsregels.
B2CModeFragment	Fragmentklasse	KotlinJava	Een fragment vertegenwoordigt een modulair deel van de aanmelding met de Azure AD B2C-gebruikersinterface binnen uw hoofdactiviteit. Dit fragment bevat de meeste verificatiecode.
fragment_b2c_mode.xml	Fragmentindeling	KotlinJava	Definieert de structuur voor een gebruikersinterface voor het fragmentonderdeel B2CModeFragment.
B2CConfiguration	Klasse	KotlinJava	Een configuratiebestand bevat informatie over uw Azure AD B2C-id-provider. De mobiele app gebruikt deze informatie om een vertrouwensrelatie tot stand te brengen met Azure AD B2C, gebruikers aan te melden en af te melden, tokens te verkrijgen en deze te valideren. Zie het bestand auth_config_b2c.json voor meer configuratie-instellingen.
auth_config_b2c.json	JSON-bestand	KotlinJava	Een configuratiebestand bevat informatie over uw Azure AD B2C-id-provider. De mobiele app gebruikt deze informatie om een vertrouwensrelatie tot stand te brengen met Azure AD B2C, gebruikers aan te melden en af te melden, tokens te verkrijgen en deze te valideren. Zie de B2CConfiguration-klasse voor meer configuratie-instellingen.

Stap 3: Uw Android-app configureren

Nadat u de verificatieonderdelen hebt toegevoegd, configureert u uw Android-app met uw Azure AD B2C-instellingen. Azure AD B2C-id-providerinstellingen worden geconfigureerd in de klasse auth_config_b2c.json en B2CConfiguration.

Zie De mobiele voorbeeld-app configureren voor hulp.

Stap 4: de omleidings-URI instellen

Configureer waar uw toepassing luistert naar het antwoord van het Azure AD B2C-token.

1. Genereer een nieuwe hash voor de ontwikkelingshandtekening. Dit verandert voor elke ontwikkelomgeving.

   Voor Windows:

   keytool -exportcert -alias androiddebugkey -keystore %HOMEPATH%\.android\debug.keystore | openssl sha1 -binary | openssl base64
   

   Voor iOS:

   keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64
   

   Gebruik voor een productieomgeving de volgende opdracht:

   keytool -exportcert -alias SIGNATURE_ALIAS -keystore PATH_TO_KEYSTORE | openssl sha1 -binary | openssl base64
   

   Zie Uw Android-app ondertekenen voor meer hulp bij het ondertekenen van uw apps.

2. Selecteer de hoofd-app>>src>AndroidManifest.xml en voeg vervolgens de volgende BrowserTabActivity activiteit toe aan de hoofdtekst van de toepassing:

   <!--Intent filter to capture System Browser or Authenticator calling back to our app after sign-in-->
   <activity
       android:name="com.microsoft.identity.client.BrowserTabActivity">
       <intent-filter>
           <action android:name="android.intent.action.VIEW" />
           <category android:name="android.intent.category.DEFAULT" />
           <category android:name="android.intent.category.BROWSABLE" />
           <data android:scheme="msauth"
               android:host="Package_Name"
               android:path="/Signature_Hash" />
       </intent-filter>
   </activity>
   

3. Vervang door Signature_Hash de hash die u hebt gegenereerd.

4. Vervang door Package_Name de naam van uw Android-pakket.

Ga als volgt te werk om de registratie van mobiele apps bij te werken met de omleidings-URI van uw app:

1. Meld u aan bij de Azure-portal.
2. Als u toegang hebt tot meerdere tenants, selecteert u het pictogram Instellingen in het bovenste menu om over te schakelen naar uw Azure AD B2C-tenant in het menu Mappen en abonnementen.
3. Zoek Azure AD B2C en selecteer deze.
4. Selecteer App-registraties en selecteer vervolgens de toepassing die u hebt geregistreerd in stap 2.3: De mobiele app registreren.
5. Selecteer Verificatie.
6. Selecteer onder Android de optie URI toevoegen.
7. Voer de pakketnaam en handtekening-hash in.
8. Selecteer Opslaan.

Uw omleidings-URI en de BrowserTabActivity activiteit moeten er ongeveer uitzien als in het volgende voorbeeld:

Kotlin

De omleidings-URL voor het voorbeeld van Android ziet er als volgt uit:

msauth://com.azuresamples.msalandroidkotlinapp/1wIqXSqBj7w%2Bh11ZifsnqwgyKrY%3D

Het intentiefilter gebruikt hetzelfde patroon, zoals wordt weergegeven in het volgende XML-fragment:

<activity android:name="com.microsoft.identity.client.BrowserTabActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:host="com.azuresamples.msalandroidkotlinapp"
            android:path="/1wIqXSqBj7w+h11ZifsnqwgyKrY="
            android:scheme="msauth" />
    </intent-filter>
</activity>

Java

De omleidings-URL voor het voorbeeld van Android ziet er als volgt uit:

msauth://com.azuresamples.msalandroidapp/1wIqXSqBj7w%2Bh11ZifsnqwgyKrY%3D

Het intentiefilter gebruikt hetzelfde patroon, zoals wordt weergegeven in het volgende XML-fragment:

<activity android:name="com.microsoft.identity.client.BrowserTabActivity">
<intent-filter>
    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

    <data
        android:host="com.azuresamples.msalandroidapp"
        android:path="/1wIqXSqBj7w+h11ZifsnqwgyKrY="
        android:scheme="msauth" />
</intent-filter>
</activity>

Stap 5: De bouwstenen van uw code aanpassen

In deze sectie worden de codebouwstenen beschreven waarmee verificatie voor uw Android-app mogelijk is. De volgende tabel bevat de methoden B2CModeFragment en het aanpassen van uw code.

Stap 5.1: Een openbare clienttoepassing instantiëren

Openbare clienttoepassingen worden niet vertrouwd om toepassingsgeheimen veilig te bewaren en ze hebben geen clientgeheimen. In onCreate of onCreateView instantieert u de MSAL met behulp van het object voor openbare clienttoepassing met meerdere accounts.

De klasse MultipleAccountPublicClientApplication wordt gebruikt om op MSAL gebaseerde apps te maken waarmee meerdere accounts tegelijkertijd kunnen worden aangemeld. De klasse staat aanmelding toe met meerdere Azure AD B2C-gebruikersstromen of aangepaste beleidsregels. Gebruikers melden zich bijvoorbeeld aan met een aanmeldings- of aanmeldingsgebruikersstroom en later voeren ze een gebruikersstroom voor het profiel bewerken uit.

Het volgende codefragment laat zien hoe u de MSAL-bibliotheek kunt initiëren met het auth_config_b2c.json JSON-configuratiebestand.

Kotlin

PublicClientApplication.createMultipleAccountPublicClientApplication(context!!,
    R.raw.auth_config_b2c,
    object : IMultipleAccountApplicationCreatedListener {
        override fun onCreated(application: IMultipleAccountPublicClientApplication) {
            // Set the MultipleAccountPublicClientApplication to the class member b2cApp
            b2cApp = application
            // Load the account (if there is any)
            loadAccounts()
        }

        override fun onError(exception: MsalException) {
            // Error handling
            displayError(exception)
        }
    })

Java

PublicClientApplication.createMultipleAccountPublicClientApplication(getContext(),
    R.raw.auth_config_b2c,
    new IPublicClientApplication.IMultipleAccountApplicationCreatedListener() {
        @Override
        public void onCreated(IMultipleAccountPublicClientApplication application) {
            // Set the MultipleAccountPublicClientApplication to the class member b2cApp
            b2cApp = application;

            // Load the account (if there is any)
            loadAccounts();
        }

        @Override
        public void onError(MsalException exception) {
            // Error handling
            displayError(exception);
        }
    });

Stap 5.2: Accounts laden

Wanneer de app op de voorgrond komt, laadt de app het bestaande account om te bepalen of gebruikers zijn aangemeld. Gebruik deze methode om de gebruikersinterface bij te werken met de verificatiestatus. U kunt bijvoorbeeld de afmeldingsknop in- of uitschakelen.

Het volgende codefragment laat zien hoe u de accounts laadt.

Kotlin

private fun loadAccounts() {
    if (b2cApp == null) {
        return
    }
    b2cApp!!.getAccounts(object : LoadAccountsCallback {
        override fun onTaskCompleted(result: List<IAccount>) {
            users = B2CUser.getB2CUsersFromAccountList(result)
            updateUI(users)
        }
    
        override fun onError(exception: MsalException) {
            displayError(exception)
        }
    })
    }

Java

private void loadAccounts() {
    if (b2cApp == null) {
        return;
    }

    b2cApp.getAccounts(new IPublicClientApplication.LoadAccountsCallback() {
        @Override
        public void onTaskCompleted(final List<IAccount> result) {
            users = B2CUser.getB2CUsersFromAccountList(result);
            updateUI(users);
        }

        @Override
        public void onError(MsalException exception) {
            displayError(exception);
        }
    });
}

Stap 5.3: Een interactieve autorisatieaanvraag starten

Een interactieve autorisatieaanvraag is een stroom waarin gebruikers worden gevraagd zich te registreren of zich aan te melden. De initializeUI methode configureert de runUserFlowButton klik-gebeurtenis. Wanneer gebruikers de knop Gebruikersstroom uitvoeren selecteren, worden ze door de app naar Azure AD B2C geleid om de aanmeldingsstroom te voltooien.

De runUserFlowButton.setOnClickListener methode bereidt het AcquireTokenParameters object voor met relevante gegevens over de autorisatieaanvraag. De acquireToken methode vraagt gebruikers vervolgens om de aanmeldings- of aanmeldingsstroom te voltooien.

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

Kotlin

val parameters = AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(activity)
        .fromAuthority(getAuthorityFromPolicyName(policy_list.getSelectedItem().toString()))
        .withScopes(B2CConfiguration.scopes)
        .withPrompt(Prompt.LOGIN)
        .withCallback(authInteractiveCallback)
        .build()

b2cApp!!.acquireToken(parameters)

Java

AcquireTokenParameters parameters = new AcquireTokenParameters.Builder()
        .startAuthorizationFromActivity(getActivity())
        .fromAuthority(B2CConfiguration.getAuthorityFromPolicyName(policyListSpinner.getSelectedItem().toString()))
        .withScopes(B2CConfiguration.getScopes())
        .withPrompt(Prompt.LOGIN)
        .withCallback(getAuthInteractiveCallback())
        .build();

b2cApp.acquireToken(parameters);

Stap 5.4: Een interactieve autorisatieaanvraag terugbellen

Nadat gebruikers de autorisatiestroom hebben voltooid, of het nu gelukt of mislukt is, wordt het resultaat geretourneerd naar de getAuthInteractiveCallback() callback-methode.

De callback-methode geeft het AuthenticationResult object of een foutbericht in het MsalException object door. Gebruik deze methode om:

• Werk de gebruikersinterface van de mobiele app bij met informatie nadat de aanmelding is voltooid.
• Laad het accountobject opnieuw.
• Roep een web-API-service aan met een toegangstoken.
• Verificatiefouten afhandelen.

In het volgende codefragment ziet u het gebruik van de interactieve verificatie-callback.

Kotlin

private val authInteractiveCallback: AuthenticationCallback
    private get() = object : AuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            /* Successfully got a token, use it to call a protected resource; web API  */
            Log.d(TAG, "Successfully authenticated")

            /* display result info */
            displayResult(authenticationResult)

            /* Reload account asynchronously to get the up-to-date list. */
            loadAccounts()
        }

        override fun onError(exception: MsalException) {
            val B2C_PASSWORD_CHANGE = "AADB2C90118"
            if (exception.message!!.contains(B2C_PASSWORD_CHANGE)) {
                txt_log!!.text = """
                    Users click the 'Forgot Password' link in a sign-up or sign-in user flow.
                    Your application needs to handle this error code by running a specific user flow that resets the password.
                    """.trimIndent()
                return
            }

            /* Failed to acquireToken */Log.d(TAG, "Authentication failed: $exception")
            displayError(exception)
            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        override fun onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.")
        }
    }

Java

private AuthenticationCallback getAuthInteractiveCallback() {
    return new AuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            /* Successfully got a token, use it to call a protected resource - MSGraph */
            Log.d(TAG, "Successfully authenticated");

            /* display result info */
            displayResult(authenticationResult);

            /* Reload account asynchronously to get the up-to-date list. */
            loadAccounts();
        }

        @Override
        public void onError(MsalException exception) {
            final String B2C_PASSWORD_CHANGE = "AADB2C90118";
            if (exception.getMessage().contains(B2C_PASSWORD_CHANGE)) {
                logTextView.setText("Users click the 'Forgot Password' link in a sign-up or sign-in user flow.\n" +
                        "Your application needs to handle this error code by running a specific user flow that resets the password.");
                return;
            }

            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());
            displayError(exception);

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            }
        }

        @Override
        public void onCancel() {
            /* User canceled the authentication */
            Log.d(TAG, "User cancelled login.");
        }
    };
}

Stap 6: Een web-API aanroepen

Als u een autorisatieweb-API op basis van tokens wilt aanroepen, moet de app een geldig toegangstoken hebben. 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 zich interactief aanmelden, krijgt de app een toegangstoken in de getAuthInteractiveCallback callback-methode. Voor opeenvolgende web-API-aanroepen gebruikt u de procedure voor het verkrijgen van tokens op de achtergrond, zoals beschreven in deze sectie.

Voordat u een web-API aanroept, roept u de acquireTokenSilentAsync methode aan met de juiste bereiken voor uw web-API-eindpunt. De MSAL-bibliotheek doet het volgende:

1. Probeert een toegangstoken op te halen met de aangevraagde bereiken uit de tokencache. Als het token aanwezig is, wordt het token geretourneerd.
2. Als het token niet aanwezig is in de tokencache, probeert MSAL het vernieuwingstoken te gebruiken om een nieuw token te verkrijgen.
3. Als het vernieuwingstoken niet bestaat of is verlopen, wordt er een uitzondering geretourneerd. Het is raadzaam om de gebruiker te vragen zich interactief aan te melden.

Het volgende codefragment laat zien hoe u een toegangstoken verkrijgt:

Kotlin

De acquireTokenSilentButton knop klikt op gebeurtenis verkrijgt een toegangstoken met de opgegeven bereiken.

btn_acquireTokenSilently.setOnClickListener(View.OnClickListener {
    if (b2cApp == null) {
        return@OnClickListener
    }
    val selectedUser = users!![user_list.getSelectedItemPosition()]
    selectedUser.acquireTokenSilentAsync(b2cApp!!,
            policy_list.getSelectedItem().toString(),
            B2CConfiguration.scopes,
            authSilentCallback)
})

De authSilentCallback callback-methode retourneert een toegangstoken en roept een web-API aan:

private val authSilentCallback: SilentAuthenticationCallback
    private get() = object : SilentAuthenticationCallback {
        override fun onSuccess(authenticationResult: IAuthenticationResult) {
            Log.d(TAG, "Successfully authenticated")

            /* Call your web API here*/
            callWebAPI(authenticationResult)
        }

        override fun onError(exception: MsalException) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: $exception")
            displayError(exception)
            if (exception is MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception is MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception is MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }
    }

In het volgende voorbeeld ziet u hoe u een beveiligde web-API aanroept met een Bearer-token:

@Throws(java.lang.Exception::class)
private fun callWebAPI(authenticationResult: IAuthenticationResult) {
    val accessToken = authenticationResult.accessToken
    val thread = Thread {
        try {
            val url = URL("https://your-app-service.azurewebsites.net/helo")
            val conn = url.openConnection() as HttpsURLConnection
            conn.setRequestProperty("Accept", "application/json")
            
            // Set the bearer token
            conn.setRequestProperty("Authorization", "Bearer $accessToken")
            if (conn.responseCode == HttpURLConnection.HTTP_OK) {
                val br = BufferedReader(InputStreamReader(conn.inputStream))
                var strCurrentLine: String?
                while (br.readLine().also { strCurrentLine = it } != null) {
                    Log.d(TAG, strCurrentLine)
                }
            }
            conn.disconnect()
        } catch (e: IOException) {
            e.printStackTrace()
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }
    thread.start()
}

Java

De acquireTokenSilentButton knop klikt op gebeurtenis verkrijgt een toegangstoken met de opgegeven bereiken.

acquireTokenSilentButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        if (b2cApp == null) {
            return;
        }

        final B2CUser selectedUser = users.get(b2cUserList.getSelectedItemPosition());
        selectedUser.acquireTokenSilentAsync(b2cApp,
                policyListSpinner.getSelectedItem().toString(),
                B2CConfiguration.getScopes(),
                getAuthSilentCallback());
    }
});

De authSilentCallback callback-methode retourneert een toegangstoken en roept een web-API aan:

private SilentAuthenticationCallback getAuthSilentCallback() {
    return new SilentAuthenticationCallback() {

        @Override
        public void onSuccess(IAuthenticationResult authenticationResult) {
            Log.d(TAG, "Successfully authenticated");

            /* Call your web API here*/
            callWebAPI(authenticationResult);
        }

        @Override
        public void onError(MsalException exception) {
            /* Failed to acquireToken */
            Log.d(TAG, "Authentication failed: " + exception.toString());
            displayError(exception);

            if (exception instanceof MsalClientException) {
                /* Exception inside MSAL, more info inside MsalError.java */
            } else if (exception instanceof MsalServiceException) {
                /* Exception when communicating with the STS, likely config issue */
            } else if (exception instanceof MsalUiRequiredException) {
                /* Tokens expired or no session, retry with interactive */
            }
        }
    };
}

In het volgende voorbeeld ziet u hoe u een beveiligde web-API aanroept met een Bearer-token:

private void callWebAPI(IAuthenticationResult authenticationResult) throws Exception {
    final String accessToken = authenticationResult.getAccessToken();
    
    
    Thread thread = new Thread(new Runnable() {
    
        @Override
        public void run() {
            try {
                URL url = new URL("https://your-app-service.azurewebsites.net/helo");
                HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
                conn.setRequestProperty("Accept", "application/json");
                
                // Set the bearer token
                conn.setRequestProperty("Authorization", "Bearer " +  accessToken);
    
                if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
                    BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                    String strCurrentLine;
                    while ((strCurrentLine = br.readLine()) != null) {
                        Log.d(TAG, strCurrentLine);
                    }
                }
                conn.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
    
    thread.start();
    
    }

Machtiging toevoegen om netwerkbewerkingen uit te voeren

Als u netwerkbewerkingen in uw toepassing wilt uitvoeren, voegt u de volgende machtiging toe aan uw manifest. Zie Verbinding maken naar het netwerk voor meer informatie.

<uses-permission android:name="android.permission.INTERNET"/>

Volgende stappen

Leer hoe u het volgende doet:

• Verificatieopties configureren in een Android-app met behulp van Azure AD B2C
• Verificatie inschakelen in uw eigen web-API met behulp van Azure AD B2C