Comienza a usar la Verificación de aplicaciones mediante un proveedor personalizado en Android

En esta página, se muestra cómo habilitar App Check en una app para Android mediante tu proveedor personalizado de App Check. Cuando habilitas App Check, ayudas a garantizar que solo la app pueda acceder a los recursos de Firebase de tu proyecto.

Si quieres usar App Check con el proveedor predeterminado de Play Integrity, consulta Habilita App Check con Play Integrity en Android.

Antes de comenzar

1. Agrega la biblioteca App Check a tu app

En el archivo Gradle del módulo (nivel de la app) (generalmente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), agrega la dependencia de la biblioteca de App Check para Android. Te recomendamos usar Firebase Android BoM para controlar las versiones de las bibliotecas. 

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

Cuando usas Firebase Android BoM, tu app siempre usará versiones compatibles de las bibliotecas de Firebase para Android.

(Alternativa)  Agrega dependencias de la biblioteca de Firebase sin usar la BoM

Si eliges no usar la Firebase BoM, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que uses la BoM para administrar las versiones de las bibliotecas para garantizar que todas las versiones sean compatibles. 

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")
}
¿Buscas un módulo de biblioteca específico de Kotlin? A partir de octubre de 2023 (Firebase BoM 32.5.0), tanto los desarrolladores de Kotlin como los de Java pueden depender del módulo de la biblioteca principal (para obtener más información, consulta las Preguntas frecuentes sobre esta iniciativa).

2. Implementa las interfaces de App Check

Primero, debes crear las clases que implementen las interfaces AppCheckProvider y AppCheckProviderFactory.

La clase AppCheckProvider debe tener un método getToken(), que recopila toda la información que tu proveedor personalizado de App Check requiere como prueba de autenticidad. Luego, la envía al servicio de adquisición de tokens a cambio de un token de App Check. El SDK de App Check controla el almacenamiento en caché de tokens, por lo que siempre debes obtener un token nuevo en la implementación de 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

Además, implementa una clase AppCheckProviderFactory que cree instancias de la implementación 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. Inicializa App Check

Agrega el siguiente código de inicialización a la app para que se ejecute antes de usar cualquier otro SDK de 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óximos pasos

Una vez que esté instalada la biblioteca de App Check en la app, comienza a distribuir la app actualizada a tus usuarios.

La app cliente actualizada comenzará a enviar tokens de App Check junto con cada solicitud que realice a Firebase, pero los productos de Firebase no requerirán que los tokens sean válidos hasta que habilites la aplicación forzosa en la sección de App Check de Firebase console.

Supervisa las métricas y habilita la aplicación forzosa

Sin embargo, antes de habilitar la aplicación forzosa, debes asegurarte de que esto no interrumpa a tus usuarios legítimos existentes. Por otro lado, si ves un uso sospechoso de los recursos de tu app, te convendrá habilitar la aplicación más pronto.

Para ayudarte a tomar esta decisión, puedes consultar las métricas de App Check para los servicios que usas:

Habilita la aplicación forzosa de App Check

Cuando comprendas cómo App Check afectará a los usuarios y tengas todo listo para continuar, puedes habilitar la aplicación forzosa de App Check:

Usa App Check en entornos de depuración

Si, después de registrar la app en App Check, quieres ejecutarla en un entorno que App Check no suele clasificar como válido, como un emulador durante el desarrollo o desde un entorno de integración continua (CI), puedes crear una compilación de depuración de la app que use el proveedor de depuración de App Check, en lugar de un proveedor de certificación real.

Consulta Cómo usar App Check con el proveedor de depuración en Android.