Habilitar verificação de aplicativo com um provedor personalizado no Android

Esta página mostra-lhe como para permitir App Check-in de um aplicativo Android, usando o seu costume App check provedor . Ao habilitar o App Check, você ajuda a garantir que apenas o seu aplicativo possa acessar os recursos do Firebase do seu projeto.

Se você quiser usar o App Verifique com o provedor padrão SafetyNet, consulte Ativar App Verifique com SafetyNet em Android .

Antes de você começar

• Adicionar Firebase ao seu projeto Android , se você não tiver feito isso.

• Implementar a lógica do lado do servidor o seu costume App verificação do provedor .

1. Adicione a biblioteca App Check ao seu aplicativo

Em seu módulo (app-level) arquivo Gradle (geralmente app/build.gradle ), declarar a dependência para o App Verifique biblioteca Android:

dependencies {
    implementation 'com.google.firebase:firebase-appcheck:16.0.0-beta04'
}

dependencies {
    implementation 'com.google.firebase:firebase-appcheck:16.0.0-beta04'
}

2. Implementar as interfaces App Check

Primeiro, você precisa criar classes que implementam a AppCheckProvider e AppCheckProviderFactory interfaces.

Seu AppCheckProvider classe deve ter um getToken() método, que recolhe todas as informações que o seu costume App check provedor requer como prova de autenticidade, e envia-o para o seu serviço de aquisição de sinal em troca de uma App Verifique token. A App Verifique SDK alças cache de token, por isso sempre obter um novo token em sua implementação de getToken() .

public class YourCustomAppCheckToken extends AppCheckToken {
    private String token;
    private long expiration;

    YourCustomAppCheckToken(String token, long expiration) {
        this.token = token;
        this.expiration = expiration;
    }

    @NonNull
    @Override
    public String getToken() {
        return token;
    }

    @Override
    public long getExpireTimeMillis() {
        return expiration;
    }
}

public class YourCustomAppCheckProvider implements AppCheckProvider {
    @Override
    public Task<AppCheckToken> getToken() {
        // Logic to exchange proof of authenticity for an App Check token and
        //   expiration time.
        // ...

        // Refresh the token early to handle clock skew.
        long expMillis = expirationFromServer * 1000 - 60000;

        // Create AppCheckToken object.
        AppCheckToken appCheckToken =
                YourCustomAppCheckToken(tokenFromServer, expMillis);

        return appCheckToken;
    }
}

class YourCustomAppCheckToken(
    private val token: String,
    private val expiration: Long
) : AppCheckToken() {
    override fun getToken(): String {
        return token
    }

    override fun getExpireTimeMillis(): Long {
        return expiration
    }
}

class YourCustomAppCheckProvider : AppCheckProvider {
    val token: Task<AppCheckToken>
        get() {
            // Logic to exchange proof of authenticity for an App Check token.
            // ...

            // Refresh the token early to handle clock skew.
            val expMillis: Long = expirationFromServer * 1000 - 60000

            // Create AppCheckToken object.
            val appCheckToken: AppCheckToken =
                    YourCustomAppCheckToken(tokenFromServer, expMillis)

            return appCheckToken!
        }
}

Além disso, implementar uma AppCheckProviderFactory classe que cria instâncias do seu AppCheckProvider implementação:

public class YourCustomAppCheckProviderFactory implements AppCheckProviderFactory {
  @Override
  public AppCheckProvider create(FirebaseApp firebaseApp) {
    // Create and return an AppCheckProvider object.
    return new YourCustomAppCheckProvider(firebaseApp);
  }
}

class YourCustomAppCheckProviderFactory : AppCheckProviderFactory {
    fun create(firebaseApp: FirebaseApp): AppCheckProvider {
        // Create and return an AppCheckProvider object.
        return YourCustomAppCheckProvider(firebaseApp)
    }
}

3. Inicialize a verificação do aplicativo

Adicione o seguinte código de inicialização ao seu aplicativo para que ele seja executado antes de você usar qualquer outro SDK do Firebase:

FirebaseApp.initializeApp(/*context=*/ this);
FirebaseAppCheck firebaseAppCheck = FirebaseAppCheck.getInstance();
firebaseAppCheck.installAppCheckProviderFactory(
    YourCustomAppCheckProviderFactory.getInstance());

FirebaseApp.initializeApp(/*context=*/ this)
val firebaseAppCheck = FirebaseAppCheck.getInstance()
firebaseAppCheck.installAppCheckProviderFactory(
    YourCustomAppCheckProviderFactory.getInstance())

Depois que a biblioteca App Check estiver instalada em seu aplicativo, comece a distribuir o aplicativo atualizado para seus usuários.

O aplicativo cliente atualizado começará a enviar tokens de verificação de aplicativo junto com todas as solicitações feitas ao Firebase, mas os produtos Firebase não exigirão que os tokens sejam válidos até que você habilite a aplicação na seção Verificação de aplicativo do console do Firebase. Consulte as próximas duas seções para obter detalhes.

4. Monitore as métricas de solicitação

Agora que seu aplicativo atualizado está nas mãos dos usuários, você pode ativar a aplicação da Verificação de aplicativo para os produtos Firebase que você usa. Antes de fazer isso, no entanto, certifique-se de que isso não atrapalhe os usuários legítimos existentes.

Realtime Database, Cloud Firestore e Cloud Storage

Uma ferramenta importante que você pode usar para tomar essa decisão para o Realtime Database, Cloud Firestore e Cloud Storage é a tela de métricas de solicitação de verificação de aplicativo.

Para visualizar o aplicativo métricas check pedido de produto, abra o Configurações do projeto> App check seção do console Firebase. Por exemplo:

As métricas de solicitação para cada produto são divididas em quatro categorias:

• Pedidos verificados são aqueles que têm uma App válido Verifique token. Depois de habilitar a aplicação da Verificação de aplicativo, apenas as solicitações nesta categoria serão bem-sucedidas.

• Pedidos de clientes desatualizados são aqueles que estão faltando uma verificação de token App. Essas solicitações podem ser de uma versão mais antiga do Firebase SDK antes de o App Check ser incluído no aplicativo.

• Solicitações de origem desconhecida são aqueles que estão faltando uma App Verifique forma, e não se parecem com eles vêm do Firebase SDK. Podem ser de solicitações feitas com chaves de API roubadas ou solicitações falsificadas feitas sem o SDK do Firebase.

• Pedidos inválidos são aqueles que têm uma App inválido Verifique token, que pode ser de um cliente inauthentic tentando personificar a sua aplicação, ou de ambientes emulados.

A distribuição dessas categorias para seu aplicativo deve informar quando você decidir habilitar a aplicação. Aqui estão algumas diretrizes:

• Se quase todas as solicitações recentes forem de clientes verificados, considere habilitar a aplicação para começar a proteger seus recursos de back-end.

• Se uma parte significativa das solicitações recentes forem de clientes provavelmente desatualizados, para evitar interromper os usuários, considere esperar que mais usuários atualizem seu aplicativo antes de habilitar a aplicação. Aplicar a verificação de aplicativo em um aplicativo lançado interromperá as versões anteriores do aplicativo que não estão integradas ao SDK do App Check.

• Se seu aplicativo ainda não foi iniciado, você deve habilitar a aplicação da Verificação de aplicativo imediatamente, uma vez que não há nenhum cliente desatualizado em uso.

Cloud Functions

Para Cloud Functions, você pode obter métricas de verificação de aplicativo examinando os registros de suas funções. Cada invocação de uma função que pode ser chamada emite uma entrada de registro estruturada como o exemplo a seguir:

{
  "severity": "INFO",    // INFO, WARNING, or ERROR
  "logging.googleapis.com/labels": {"firebase-log-type": "callable-request-verification"},
  "jsonPayload": {
    "message": "Callable header verifications passed.",
    "verifications": {
      // ...
      "app": "MISSING",  // VALID, INVALID, or MISSING
    }
  }
}

Você pode analisar essas métricas no Google Cloud Console por criar um registos à base de contra-métrica com o filtro de métrica seguinte:

resource.type="cloud_function"
resource.labels.function_name="YOUR_CLOUD_FUNCTION"
resource.labels.region="us-central1"
labels.firebase-log-type="callable-request-verification"

Rotular a métrica usando o campo jsonPayload.verifications.appCheck .

5. Habilite a aplicação

Para habilitar a aplicação, siga as instruções para cada produto, abaixo. Depois de habilitar a aplicação de um produto, todas as solicitações não verificadas para esse produto serão rejeitadas.

Realtime Database, Cloud Firestore e Cloud Storage

Para ativar a aplicação do Realtime Database, Cloud Firestore (iOS e Android) e Cloud Storage:

1. Abra o check Configurações do projeto> App seção do console Firebase.

2. Expanda a visualização das métricas do produto para o qual deseja ativar a aplicação.

3. Clique em Aplicar e confirme a sua escolha.

Observe que pode levar até 10 minutos após a ativação da aplicação para que ela entre em vigor.

Cloud Functions

Veja Ativar App Verifique a aplicação das Funções de nuvem .