Autenticar usando Apple no Android

Você pode permitir que seus usuários se autentiquem com o Firebase usando o ID Apple usando o SDK do Firebase para realizar o fluxo de login do OAuth 2.0 de ponta a ponta.

Antes de você começar

Para fazer login de usuários que usam a Apple, primeiro configure Sign In with Apple no site do desenvolvedor da Apple e, em seguida, ative a Apple como provedor de login para seu projeto do Firebase.

Participe do Programa de Desenvolvedores Apple

O Sign In with Apple só pode ser configurado por membros do Apple Developer Program .

Configurar login com Apple

No site do desenvolvedor Apple , faça o seguinte:

  1. Associe seu site ao seu aplicativo conforme descrito na primeira seção de Configurar login com a Apple para a web . Quando solicitado, registre o seguinte URL como URL de retorno:

    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

    Você pode obter o ID do projeto do Firebase na página de configurações do console do Firebase .

    Quando terminar, anote seu novo ID de serviço, que você precisará na próxima seção.

  2. Crie uma chave privada de login com Apple . Você precisará de sua nova chave privada e ID de chave na próxima seção.
  3. Se você usar algum dos recursos do Firebase Authentication que enviam e-mails aos usuários, incluindo login com link de e-mail, verificação de endereço de e-mail, revogação de alteração de conta e outros, configure o serviço de retransmissão de e-mail privado da Apple e registre-se noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (ou seu domínio de modelo de e-mail personalizado) para que a Apple possa retransmitir e-mails enviados pelo Firebase Authentication para endereços de e-mail anônimos da Apple.

Habilite a Apple como provedor de login

  1. Adicione o Firebase ao seu projeto Android . Certifique-se de registrar a assinatura SHA-1 do seu aplicativo ao configurá-lo no Console do Firebase.
  2. No console do Firebase , abra a seção Auth . Na guia Método de login , habilite o provedor Apple . Especifique o ID do serviço que você criou na seção anterior. Além disso, na seção de configuração do fluxo de código OAuth , especifique seu Apple Team ID e a chave privada e o ID de chave que você criou na seção anterior.

Cumpra os requisitos de dados anonimizados da Apple

Sign In with Apple oferece aos usuários a opção de anonimizar seus dados, incluindo seu endereço de e-mail, ao fazer login. Os usuários que escolhem esta opção possuem endereços de e-mail com o domínio privaterelay.appleid.com . Ao usar o Sign In with Apple em seu aplicativo, você deve cumprir quaisquer políticas ou termos de desenvolvedor aplicáveis ​​da Apple em relação a esses IDs Apple anônimos.

Isso inclui obter qualquer consentimento necessário do usuário antes de associar qualquer informação pessoal de identificação direta a um ID Apple anônimo. Ao usar o Firebase Authentication, isso pode incluir as seguintes ações:

  • Vincule um endereço de e-mail a um ID Apple anônimo ou vice-versa.
  • Vincule um número de telefone a um ID Apple anônimo ou vice-versa
  • Vincule uma credencial social não anônima (Facebook, Google, etc.) a um ID Apple anônimo ou vice-versa.

A lista acima não é exaustiva. Consulte o Contrato de licença do Apple Developer Program na seção Assinatura da sua conta de desenvolvedor para garantir que seu aplicativo atenda aos requisitos da Apple.

Lidar com o fluxo de login com o SDK do Firebase

No Android, a maneira mais fácil de autenticar seus usuários no Firebase usando suas contas Apple é lidar com todo o fluxo de login com o Firebase Android SDK.

Para lidar com o fluxo de login com o Firebase Android SDK, siga estas etapas:

  1. Construa uma instância de um OAuthProvider usando seu Builder com o ID do provedor apple.com :

    Kotlin+KTX

    val provider = OAuthProvider.newBuilder("apple.com")
    

    Java

    OAuthProvider.Builder provider = OAuthProvider.newBuilder("apple.com");
    
  2. Opcional: Especifique escopos adicionais do OAuth 2.0 além do padrão que você deseja solicitar do provedor de autenticação.

    Kotlin+KTX

    provider.setScopes(arrayOf("email", "name"))
    

    Java

    List<String> scopes =
        new ArrayList<String>() {
          {
            add("email");
            add("name");
          }
        };
    provider.setScopes(scopes);
    

    Por padrão, quando Uma conta por endereço de e-mail está ativada, o Firebase solicita escopos de e-mail e nome. Se você alterar essa configuração para Várias contas por endereço de e-mail , o Firebase não solicitará escopos da Apple, a menos que você os especifique.

  3. Opcional: se desejar exibir a tela de login da Apple em um idioma diferente do inglês, defina o parâmetro locale . Consulte os documentos Sign In with Apple para obter as localidades suportadas.

    Kotlin+KTX

    // Localize the Apple authentication screen in French.
    provider.addCustomParameter("locale", "fr")
    

    Java

    // Localize the Apple authentication screen in French.
    provider.addCustomParameter("locale", "fr");
    
  4. Autentique-se com o Firebase usando o objeto do provedor OAuth. Observe que, diferentemente de outras operações FirebaseAuth , isso assumirá o controle da sua IU abrindo uma guia personalizada do Chrome. Conseqüentemente, não faça referência à sua atividade no OnSuccessListener e OnFailureListener que você anexa, pois eles serão desconectados imediatamente quando a operação iniciar a IU.

    Você deve primeiro verificar se já recebeu uma resposta. O login com esse método coloca sua atividade em segundo plano, o que significa que ela pode ser recuperada pelo sistema durante o fluxo de login. Para ter certeza de que o usuário não tentará novamente se isso acontecer, você deve verificar se um resultado já está presente.

    Para verificar se há um resultado pendente, chame getPendingAuthResult() :

    Kotlin+KTX

    val pending = auth.pendingAuthResult
    if (pending != null) {
        pending.addOnSuccessListener { authResult ->
            Log.d(TAG, "checkPending:onSuccess:$authResult")
            // Get the user profile with authResult.getUser() and
            // authResult.getAdditionalUserInfo(), and the ID
            // token from Apple with authResult.getCredential().
        }.addOnFailureListener { e ->
            Log.w(TAG, "checkPending:onFailure", e)
        }
    } else {
        Log.d(TAG, "pending: null")
    }
    

    Java

    mAuth = FirebaseAuth.getInstance();
    Task<AuthResult> pending = mAuth.getPendingAuthResult();
    if (pending != null) {
        pending.addOnSuccessListener(new OnSuccessListener<AuthResult>() {
            @Override
            public void onSuccess(AuthResult authResult) {
                Log.d(TAG, "checkPending:onSuccess:" + authResult);
                // Get the user profile with authResult.getUser() and
                // authResult.getAdditionalUserInfo(), and the ID
                // token from Apple with authResult.getCredential().
            }
        }).addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "checkPending:onFailure", e);
            }
        });
    } else {
        Log.d(TAG, "pending: null");
    }
    

    Se não houver nenhum resultado pendente, inicie o fluxo de login chamando startActivityForSignInWithProvider() :

    Kotlin+KTX

    auth.startActivityForSignInWithProvider(this, provider.build())
            .addOnSuccessListener { authResult ->
                // Sign-in successful!
                Log.d(TAG, "activitySignIn:onSuccess:${authResult.user}")
                val user = authResult.user
                // ...
            }
            .addOnFailureListener { e ->
                Log.w(TAG, "activitySignIn:onFailure", e)
            }
    

    Java

    mAuth.startActivityForSignInWithProvider(this, provider.build())
            .addOnSuccessListener(
                    new OnSuccessListener<AuthResult>() {
                        @Override
                        public void onSuccess(AuthResult authResult) {
                            // Sign-in successful!
                            Log.d(TAG, "activitySignIn:onSuccess:" + authResult.getUser());
                            FirebaseUser user = authResult.getUser();
                            // ...
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            Log.w(TAG, "activitySignIn:onFailure", e);
                        }
                    });
    

    Ao contrário de outros provedores suportados pelo Firebase Auth, a Apple não fornece um URL de foto.

    Além disso, quando o usuário opta por não compartilhar seu e-mail com o aplicativo, a Apple fornece um endereço de e-mail exclusivo para esse usuário (no formato xyz@privaterelay.appleid.com ), que ele compartilha com seu aplicativo. Se você configurou o serviço de retransmissão de e-mail privado, a Apple encaminha os e-mails enviados para o endereço anônimo para o endereço de e-mail real do usuário.

    A Apple só compartilha informações do usuário, como o nome de exibição, com os aplicativos na primeira vez que um usuário faz login. Normalmente, o Firebase armazena o nome de exibição na primeira vez que um usuário faz login na Apple, que você pode obter com getCurrentUser().getDisplayName() . No entanto, se você usou anteriormente a Apple para fazer login de um usuário no aplicativo sem usar o Firebase, a Apple não fornecerá ao Firebase o nome de exibição do usuário.

Reautenticação e vinculação de conta

O mesmo padrão pode ser usado com startActivityForReauthenticateWithProvider() que você pode usar para recuperar uma nova credencial para operações confidenciais que exigem login recente:

Kotlin+KTX

// The user is already signed-in.
val firebaseUser = auth.getCurrentUser()

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener( authResult -> {
        // User is re-authenticated with fresh tokens and
        // should be able to perform sensitive operations
        // like account deletion and email or password
        // update.
    })
    .addOnFailureListener( e -> {
        // Handle failure.
    })

Java

// The user is already signed-in.
FirebaseUser firebaseUser = mAuth.getCurrentUser();

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener(
        new OnSuccessListener<AuthResult>() {
          @Override
          public void onSuccess(AuthResult authResult) {
            // User is re-authenticated with fresh tokens and
            // should be able to perform sensitive operations
            // like account deletion and email or password
            // update.
          }
        })
    .addOnFailureListener(
        new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception e) {
            // Handle failure.
          }
        });

E você pode usar linkWithCredential() para vincular diferentes provedores de identidade a contas existentes.

Observe que a Apple exige que você obtenha o consentimento explícito dos usuários antes de vincular suas contas Apple a outros dados.

Por exemplo, para vincular uma conta do Facebook à conta atual do Firebase, use o token de acesso obtido ao fazer login do usuário no Facebook:

Kotlin+KTX

// Initialize a Facebook credential with a Facebook access token.
val credential = FacebookAuthProvider.getCredential(token.getToken())

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, task -> {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      });

Java

// Initialize a Facebook credential with a Facebook access token.
AuthCredential credential = FacebookAuthProvider.getCredential(token.getToken());

// Assuming the current user is an Apple user linking a Facebook provider.
mAuth.getCurrentUser().linkWithCredential(credential)
    .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
      @Override
      public void onComplete(@NonNull Task<AuthResult> task) {
        if (task.isSuccessful()) {
          // Facebook credential is linked to the current Apple user.
          // The user can now sign in to the same account
          // with either Apple or Facebook.
        }
      }
    });

Avançado: lidar com o fluxo de login manualmente

Você também pode autenticar com o Firebase usando uma conta Apple gerenciando o fluxo de login usando o SDK JS de login da Apple, criando manualmente o fluxo OAuth ou usando uma biblioteca OAuth como AppAuth .

  1. Para cada solicitação de login, gere uma string aleatória — um "nonce" — que você usará para garantir que o token de ID obtido foi concedido especificamente em resposta à solicitação de autenticação do seu aplicativo. Esta etapa é importante para evitar ataques de repetição.

    Você pode gerar um nonce criptograficamente seguro no Android com SecureRandom , como no exemplo a seguir:

    Kotlin+KTX

    private fun generateNonce(length: Int): String {
        val generator = SecureRandom()
    
        val charsetDecoder = StandardCharsets.US_ASCII.newDecoder()
        charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE)
        charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE)
    
        val bytes = ByteArray(length)
        val inBuffer = ByteBuffer.wrap(bytes)
        val outBuffer = CharBuffer.allocate(length)
        while (outBuffer.hasRemaining()) {
            generator.nextBytes(bytes)
            inBuffer.rewind()
            charsetDecoder.reset()
            charsetDecoder.decode(inBuffer, outBuffer, false)
        }
        outBuffer.flip()
        return outBuffer.toString()
    }
    

    Java

    private String generateNonce(int length) {
        SecureRandom generator = new SecureRandom();
    
        CharsetDecoder charsetDecoder = StandardCharsets.US_ASCII.newDecoder();
        charsetDecoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
        charsetDecoder.onMalformedInput(CodingErrorAction.IGNORE);
    
        byte[] bytes = new byte[length];
        ByteBuffer inBuffer = ByteBuffer.wrap(bytes);
        CharBuffer outBuffer = CharBuffer.allocate(length);
        while (outBuffer.hasRemaining()) {
            generator.nextBytes(bytes);
            inBuffer.rewind();
            charsetDecoder.reset();
            charsetDecoder.decode(inBuffer, outBuffer, false);
        }
        outBuffer.flip();
        return outBuffer.toString();
    }
    

    Em seguida, obtenha o hash SHA246 do nonce como uma string hexadecimal:

    Kotlin+KTX

    private fun sha256(s: String): String {
        val md = MessageDigest.getInstance("SHA-256")
        val digest = md.digest(s.toByteArray())
        val hash = StringBuilder()
        for (c in digest) {
            hash.append(String.format("%02x", c))
        }
        return hash.toString()
    }
    

    Java

    private String sha256(String s) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] digest = md.digest(s.getBytes());
        StringBuilder hash = new StringBuilder();
        for (byte c: digest) {
            hash.append(String.format("%02x", c));
        }
        return hash.toString();
    }
    

    Você enviará o hash SHA256 do nonce com sua solicitação de login, que a Apple transmitirá inalterada na resposta. O Firebase valida a resposta fazendo hash do nonce original e comparando-o com o valor passado pela Apple.

  2. Inicie o fluxo de login da Apple usando sua biblioteca OAuth ou outro método. Certifique-se de incluir o nonce com hash como parâmetro em sua solicitação.

  3. Depois de receber a resposta da Apple, obtenha o token de ID da resposta e use-o junto com o nonce sem hash para criar um AuthCredential :

    Kotlin+KTX

    val credential =  OAuthProvider.newCredentialBuilder("apple.com")
        .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
        .build()
    

    Java

    AuthCredential credential =  OAuthProvider.newCredentialBuilder("apple.com")
        .setIdTokenWithRawNonce(appleIdToken, rawUnhashedNonce)
        .build();
    
  4. Autentique-se com o Firebase usando a credencial do Firebase:

    Kotlin+KTX

    auth.signInWithCredential(credential)
          .addOnCompleteListener(this) { task ->
              if (task.isSuccessful) {
                // User successfully signed in with Apple ID token.
                // ...
              }
          }
    

    Java

    mAuth.signInWithCredential(credential)
        .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
          @Override
          public void onComplete(@NonNull Task<AuthResult> task) {
            if (task.isSuccessful()) {
              // User successfully signed in with Apple ID token.
              // ...
            }
          }
        });
    

Se a chamada para signInWithCredential for bem-sucedida, você poderá usar o método getCurrentUser para obter os dados da conta do usuário.

Revogação de token

A Apple exige que os aplicativos que oferecem suporte à criação de contas permitam que os usuários iniciem a exclusão de suas contas no aplicativo, conforme descrito nas Diretrizes de revisão da App Store

Além disso, os aplicativos compatíveis com Sign in with Apple devem usar a API REST Sign in with Apple para revogar tokens de usuário.

Para atender a esse requisito, implemente as seguintes etapas:

  1. Use o método startActivityForSignInWithProvider() para fazer login usando Apple e obter AuthResult .

  2. Obtenha o token de acesso do provedor Apple.

    Kotlin+KTX

    val oauthCredential: OAuthCredential =  authResult.credential
    val accessToken = oauthCredential.accessToken
    

    Java

    OAuthCredential oauthCredential = (OAuthCredential) authResult.getCredential();
    String accessToken = oauthCredential.getAccessToken();
    
  3. Revogue o token usando a API revokeAccessToken .

    Kotlin+KTX

    mAuth.revokeAccessToken(accessToken)
      .addOnCompleteListener(this) { task ->
        if (task.isSuccessful) {
          // Access token successfully revoked
          // for the user ...
        }
    }
    

    Java

    mAuth.revokeAccessToken(accessToken)
        .addOnCompleteListener(this, new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
              if (task.isSuccessful()) {
                // Access token successfully revoked
                // for the user ...
              }
            }
      });
    
  1. Finalmente, exclua a conta do usuário (e todos os dados associados)

    Próximos passos

    Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais (ou seja, nome de usuário e senha, número de telefone ou informações do provedor de autenticação) com as quais o usuário fez login. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em todos os aplicativos do seu projeto, independentemente de como o usuário faz login.

    • Nos seus aplicativos, você pode obter informações básicas do perfil do usuário no objeto FirebaseUser . Consulte Gerenciar usuários .

    • Nas regras de segurança do Firebase Realtime Database e do Cloud Storage , você pode obter o ID de usuário exclusivo do usuário conectado na variável auth e usá-lo para controlar quais dados um usuário pode acessar.

    Você pode permitir que os usuários façam login no seu aplicativo usando vários provedores de autenticação vinculando as credenciais do provedor de autenticação a uma conta de usuário existente.

    Para desconectar um usuário, chame signOut :

    Kotlin+KTX

    Firebase.auth.signOut()

    Java

    FirebaseAuth.getInstance().signOut();