Introdução ao App Check com um provedor personalizado no Android

Esta página mostra como ativar o App Check em um app Android usando seu provedor personalizado do App Check. Ao ativar o App Check, você ajuda a garantir que apenas seu app possa acessar os recursos do Firebase do seu projeto.

Se você quiser usar o App Check com o provedor Play Integrity padrão, consulte Ativar o App Check com a Play Integrity no Android.

Antes de começar

1. Adicionar a biblioteca do App Check ao seu app

No arquivo Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), adicione a dependência da biblioteca do App Check para Android Para gerenciar o controle de versões das bibliotecas, recomendamos usar a BoM do Firebase para Android.

dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.1"))

    // Add the dependency for the App Check library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-appcheck")
}

Com a BoM do Firebase para Android, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

(Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar a BoM

Se você preferir não usar a BoM do Firebase, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

Se você usa várias bibliotecas do Firebase no seu app, recomendamos utilizar a BoM para gerenciar as versões delas, porque isso ajuda a garantir a compatibilidade de todas as bibliotecas.

dependencies {
    // Add the dependency for the App Check library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-appcheck:18.0.0")
}
Está procurando um módulo de biblioteca específico do Kotlin? A partir de outubro de 2023 (BoM do Firebase 32.5.0), os desenvolvedores Kotlin e Java poderão depender do módulo da biblioteca principal. Para mais detalhes, consulte Perguntas frequentes sobre essa iniciativa).

2. Implementar as interfaces do App Check

Primeiro, você precisa criar classes que implementem as interfaces AppCheckProvider e AppCheckProviderFactory.

A classe AppCheckProvider precisa ter um método getToken(), que coleta todas as informações exigidas pelo provedor personalizado do App Check como prova de autenticidade e as envia ao serviço de aquisição de tokens em troca de um token do App Check. O SDK do App Check processa o armazenamento em cache de tokens. Por causa disso, sempre use um novo token na implementação do getToken().

Kotlin+KTX

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

class YourCustomAppCheckProvider(firebaseApp: FirebaseApp) : AppCheckProvider {
    override fun getToken(): Task<AppCheckToken> {
        // Logic to exchange proof of authenticity for an App Check token and
        //   expiration time.
        // ...

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

        // Create AppCheckToken object.
        val appCheckToken: AppCheckToken = YourCustomAppCheckToken(tokenFromServer, expMillis)
        return Tasks.forResult(appCheckToken)
    }
}

Java

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 {
    public YourCustomAppCheckProvider(FirebaseApp firebaseApp) {
        // ...
    }

    @NonNull
    @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 * 1000L - 60000L;

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

        return Tasks.forResult(appCheckToken);
    }
}

Além disso, implemente uma classe AppCheckProviderFactory que crie instâncias da implementação AppCheckProvider:

Kotlin+KTX

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

Java

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

3. Inicializar o App Check

Adicione o seguinte código de inicialização ao app para que ele seja executado antes de usar outros SDKs do Firebase:

Kotlin+KTX

Firebase.initialize(context)
Firebase.appCheck.installAppCheckProviderFactory(
    YourCustomAppCheckProviderFactory(),
)

Java

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

Próximas etapas

Depois que a biblioteca do App Check estiver instalada no seu app, comece a distribuir o app atualizado para os usuários.

O app cliente atualizado vai começar a enviar tokens do App Check em todas as solicitações feitas ao Firebase, mas os produtos dessa plataforma não exigirão que os tokens sejam válidos até que você ative a aplicação obrigatória na seção "App Check" do Console do Firebase.

Monitorar métricas e ativar a aplicação obrigatória

Antes de ativar a aplicação obrigatória, verifique se isso não vai afetar seus usuários legítimos. Por outro lado, se você perceber um uso suspeito dos recursos do seu app, convém ativar a aplicação obrigatória antes do previsto.

Para tomar essa decisão, analise as métricas do App Check nos serviços usados:

Ativar a aplicação obrigatória do App Check

Assim que você entender como o App Check vai afetar seus usuários, e se estiver tudo pronto para prosseguir com o processo, ative a aplicação obrigatória do App Check:

Usar o App Check em ambientes de depuração

Se, depois de registrar seu aplicativo no App Check, você quiser executá-lo em um ambiente que o App Check normalmente não classificaria como válido, como um emulador durante o desenvolvimento ou de uma integração contínua (CI), será possível criar um build de depuração do seu app que use o provedor de depuração do App Check em vez de um provedor de atestado real.

Consulte Usar o App Check com o provedor de depuração no Android.