Habilitar a autenticação em seu próprio aplicativo Android usando o Azure AD B2C

Este artigo mostra como adicionar a autenticação do Azure Ative Directory B2C (Azure AD B2C) ao seu próprio aplicativo móvel Android.

Use este artigo com Configurar autenticação em um aplicativo Android de exemplo usando o Azure AD B2C, substituindo o aplicativo Android de exemplo pelo seu próprio aplicativo Android. Depois de concluir as instruções neste artigo, seu aplicativo aceitará entradas por meio do Azure AD B2C.

Pré-requisitos

Analise os pré-requisitos e as instruções de integração em Configurar a autenticação em um aplicativo Android de exemplo usando o Azure AD B2C.

Criar um projeto de aplicativo Android

Se você ainda não tiver um aplicativo Android, configure um novo projeto fazendo o seguinte:

1. No Android Studio, selecione Iniciar um novo projeto do Android Studio.
2. Selecione Atividade básica e, em seguida, selecione Avançar.
3. Dê um nome à aplicação.
4. Salve o nome do pacote. Você o inserirá posteriormente no portal do Azure.
5. Mude o idioma de Kotlin para Java.
6. Defina o nível mínimo da API como API 19 ou superior e selecione Concluir.
7. Na visualização do projeto, escolha Projeto na lista suspensa para exibir arquivos de projeto de origem e não origem, abra app/build.gradle e defina targetSdkVersion como 28.

Etapa 1: Instalar as dependências

Na janela do projeto do Android Studio, vá para o aplicativo>build.gradle e adicione o seguinte:

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

Etapa 2: Adicionar os componentes de autenticação

O código de exemplo é composto pelos seguintes componentes. Adicione esses componentes do aplicativo Android de exemplo ao seu próprio aplicativo.

Componente	Type	Origem	Description
B2CUser	Classe	Kotlin Java |	Representa um usuário B2C. Essa classe permite que os usuários entrem com várias políticas.
B2CModeFragment	Classe de fragmento	Kotlin Java |	Um fragmento representa uma parte modular da entrada com a interface do usuário do Azure AD B2C em sua atividade principal. Este fragmento contém a maior parte do código de autenticação.
fragment_b2c_mode.xml	Layout do fragmento	Kotlin Java |	Define a estrutura de uma interface de usuário para o componente de fragmento B2CModeFragment.
B2CConfiguração	Classe	Kotlin Java |	Um arquivo de configuração contém informações sobre seu provedor de identidade do Azure AD B2C. O aplicativo móvel usa essas informações para estabelecer uma relação de confiança com o Azure AD B2C, entrar e sair de usuários, adquirir tokens e validá-los. Para obter mais definições de configuração, consulte o arquivo auth_config_b2c.json.
auth_config_b2c.json	Ficheiro JSON	Kotlin Java |	Um arquivo de configuração contém informações sobre seu provedor de identidade do Azure AD B2C. O aplicativo móvel usa essas informações para estabelecer uma relação de confiança com o Azure AD B2C, entrar e sair de usuários, adquirir tokens e validá-los. Para obter mais definições de configuração, consulte a classe B2CConfiguration.

Etapa 3: configurar seu aplicativo Android

Depois de adicionar os componentes de autenticação, configure seu aplicativo Android com as configurações do Azure AD B2C. As configurações do provedor de identidade do Azure AD B2C são definidas no arquivo auth_config_b2c.json e na classe B2CConfiguration.

Para obter orientação, consulte Configurar o aplicativo móvel de exemplo.

Etapa 4: Definir o URI de redirecionamento

Configure onde seu aplicativo escuta a resposta de token do Azure AD B2C.

1. Gere um novo hash de assinatura de desenvolvimento. Isso mudará para cada ambiente de desenvolvimento.

   Para Windows:

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

   Para o iOS:

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

   Para um ambiente de produção, use o seguinte comando:

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

   Para obter mais ajuda com a assinatura de seus aplicativos, consulte Assinar seu aplicativo Android.

2. Selecione o AndroidManifest.xml principal>do aplicativo>src>e adicione a seguinte BrowserTabActivity atividade ao corpo do aplicativo:

   <!--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. Substitua Signature_Hash pelo hash gerado.

4. Substitua Package_Name pelo nome do pacote Android.

Para atualizar o registro do aplicativo móvel com o URI de redirecionamento do aplicativo, faça o seguinte:

1. Inicie sessão no portal do Azure.
2. Se você tiver acesso a vários locatários, selecione o ícone Configurações no menu superior para alternar para seu locatário do Azure AD B2C no menu Diretórios + assinaturas .
3. Procure e selecione Azure AD B2C.
4. Selecione Registos da aplicação e, em seguida, selecione a aplicação que registou no Passo 2.3: Registar a aplicação móvel.
5. Selecione Autenticação.
6. Em Android, selecione Adicionar URI.
7. Insira o hash Nome do pacote e Assinatura.
8. Selecione Guardar.

Seu URI de redirecionamento e a BrowserTabActivity atividade devem ser semelhantes ao exemplo a seguir:

Kotlin

O URL de redirecionamento para o Android de exemplo tem esta aparência:

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

O filtro de intenção usa o mesmo padrão, conforme mostrado no seguinte trecho XML:

<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

O URL de redirecionamento para o Android de exemplo tem esta aparência:

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

O filtro de intenção usa o mesmo padrão, conforme mostrado no seguinte trecho XML:

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

Etapa 5: Personalizar seus blocos de construção de código

Esta seção descreve os blocos de construção de código que habilitam a autenticação para seu aplicativo Android. A tabela a seguir lista os métodos B2CModeFragment e como personalizar seu código.

Etapa 5.1: Instanciar um aplicativo cliente público

Os aplicativos cliente públicos não são confiáveis para manter segredos de aplicativos com segurança e não têm segredos de cliente. Em onCreate ou onCreateView, instancie o MSAL usando o objeto de aplicativo cliente público de várias contas.

A MultipleAccountPublicClientApplication classe é usada para criar aplicativos baseados em MSAL que permitem que várias contas sejam conectadas ao mesmo tempo. A classe permite entrar com vários fluxos de usuário do Azure AD B2C ou políticas personalizadas. Por exemplo, os usuários entram com um fluxo de usuário de inscrição ou entrada e, posteriormente, executam um fluxo de usuário de perfil de edição.

O trecho de código a seguir demonstra como iniciar a biblioteca MSAL com o auth_config_b2c.json arquivo JSON de configuração.

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

Passo 5.2: Carregar contas

Quando o aplicativo chega ao primeiro plano, o aplicativo carrega a conta existente para determinar se os usuários estão conectados. Use esse método para atualizar a interface do usuário com o estado de autenticação. Por exemplo, você pode habilitar ou desabilitar o botão de saída.

O trecho de código a seguir demonstra como carregar as contas.

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

Etapa 5.3: Iniciar uma solicitação de autorização interativa

Uma solicitação de autorização interativa é um fluxo em que os usuários são solicitados a se inscrever ou entrar. O initializeUI método configura o runUserFlowButton evento click. Quando os usuários selecionam o botão Executar fluxo de usuário, o aplicativo os leva ao Azure AD B2C para concluir o fluxo de entrada.

O runUserFlowButton.setOnClickListener método prepara o AcquireTokenParameters objeto com dados relevantes sobre a solicitação de autorização. Em acquireToken seguida, o método solicita que os usuários concluam o fluxo de inscrição ou entrada.

O trecho de código a seguir demonstra como iniciar a solicitação de autorização interativa:

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

Etapa 5.4: Fazer um retorno de chamada de solicitação de autorização interativo

Depois que os usuários concluírem o fluxo de autorização, com ou sem êxito, o resultado será retornado para o método de retorno de getAuthInteractiveCallback() chamada.

O método de retorno de chamada passa o AuthenticationResult objeto ou uma mensagem de erro no MsalException objeto. Use este método para:

• Atualize a interface do usuário do aplicativo móvel com informações após a conclusão do login.
• Recarregue o objeto accounts.
• Chame um serviço de API da Web com um token de acesso.
• Manipule erros de autenticação.

O trecho de código a seguir demonstra o uso do retorno de chamada de autenticação interativo.

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

Etapa 6: Chamar uma API da Web

Para chamar uma API Web de autorização baseada em token, o aplicativo precisa ter um token de acesso válido. O aplicativo faz o seguinte:

1. Adquire um token de acesso com as permissões (escopos) necessárias para o ponto de extremidade da API Web.
2. Passa o token de acesso como um token de portador no cabeçalho de autorização da solicitação HTTP usando este formato:

Authorization: Bearer <access-token>

Quando os usuários entram interativamente, o aplicativo recebe um token de acesso no método de retorno de getAuthInteractiveCallback chamada. Para chamadas consecutivas de API da Web, use o procedimento silencioso de token de aquisição conforme descrito nesta seção.

Antes de chamar uma API da Web, chame o método com os escopos acquireTokenSilentAsync apropriados para seu ponto de extremidade da API da Web. A biblioteca MSAL faz o seguinte:

1. Tenta buscar um token de acesso com os escopos solicitados do cache de token. Se o token estiver presente, o token será retornado.
2. Se o token não estiver presente no cache de tokens, o MSAL tentará usar seu token de atualização para adquirir um novo token.
3. Se o token de atualização não existir ou tiver expirado, uma exceção será retornada. Recomendamos que você solicite que o usuário entre interativamente.

O trecho de código a seguir demonstra como adquirir um token de acesso:

Kotlin

O acquireTokenSilentButton evento button click adquire um token de acesso com os escopos fornecidos.

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

O authSilentCallback método de retorno de chamada retorna um token de acesso e chama uma API da Web:

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 */
            }
        }
    }

O exemplo a seguir demonstra como chamar uma API da Web protegida com um token de portador:

@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

O acquireTokenSilentButton evento button click adquire um token de acesso com os escopos fornecidos.

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

O authSilentCallback método de retorno de chamada retorna um token de acesso e chama uma API da Web:

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 */
            }
        }
    };
}

O exemplo a seguir demonstra como chamar uma API da Web protegida com um token de portador:

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

Adicionar permissão para executar operações de rede

Para executar operações de rede em seu aplicativo, adicione a seguinte permissão ao seu manifesto. Para obter mais informações, consulte Conectar-se à rede.

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

Próximos passos

Aprenda a:

• Configurar opções de autenticação em um aplicativo Android usando o Azure AD B2C
• Habilitar a autenticação em sua própria API Web usando o Azure AD B2C