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 App Check personalizado. 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 App Check com o provedor padrão da Play Integrity, consulte Ativar App Check com a Play Integrity no Android.

Antes de começar

1. Adicionar a biblioteca App Check ao 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. Recomendamos o uso do Firebase Android BoM para lidar com o controle de versões da biblioteca. 

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

    // 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 o Firebase Android BoM, 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 o BoM

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

Se você usa várias bibliotecas do Firebase no app, recomendamos utilizar o 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 (Firebase BoM 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 App Check

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

A classe AppCheckProvider precisa ter um método getToken(), que colete todas as informações exigidas pelo provedor personalizado do App Check como prova de autenticidade e as envie ao serviço de aquisição de tokens em troca de um token App Check. O SDK App Check lida com o armazenamento em cache de tokens. Portanto, 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)
    }
}
CustomProvider.kt

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

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)
    }
}
CustomProvider.kt

Java 

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

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(),
)
CustomProvider.kt

Java 

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

Próximas etapas

Depois que a biblioteca 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 App Check

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

Usar 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 App Check com o provedor de depuração no Android.