Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Proteja los recursos que no son de Firebase con App Check en Android

Puedes proteger los recursos de tu aplicación que no son de Firebase, como los backends autohospedados, con App Check. Para hacerlo, deberá modificar su cliente de aplicación para enviar un token de verificación de aplicación junto con cada solicitud a su backend, y modificar su backend para requerir un token de verificación de aplicación válido con cada solicitud; ambas tareas se describen a continuación.

Antes de que empieces

Añadir App cheque a su aplicación, ya sea usando el predeterminado proveedor de SafetyNet , o un proveedor personalizado .

Enviar tokens de App Check con solicitudes de backend

Para garantizar que sus peticiones de back-end incluyen un válido y vigente, App Check modo, envolver cada solicitud en una llamada a getAppCheckToken() . La biblioteca App Check actualizará el token si es necesario, y puede acceder al token en el detector de éxito del método.

Una vez que tenga un token válido, envíelo junto con la solicitud a su backend. Los detalles de cómo se logra esto son de usted, pero no envían App Verificar fichas como parte de la URL, incluso en los parámetros de consulta, ya que esto los hace vulnerables a la fuga accidental e intercepción. El enfoque recomendado es enviar el token en un encabezado HTTP personalizado.

Por ejemplo, si usa Retrofit:

Java

public class ApiWithAppCheckExample {
    private interface YourExampleBackendService {
        @GET("yourExampleEndpoint")
        Call<List<String>> exampleData(
                @Header("X-Firebase-AppCheck") String appCheckToken);
    }

    YourExampleBackendService yourExampleBackendService = new Retrofit.Builder()
            .baseUrl("https://yourbackend.example.com/")
            .build()
            .create(YourExampleBackendService.class);

    public void callApiExample() {
        FirebaseAppCheck.getInstance()
                .getAppCheckToken(false)
                .addOnSuccessListener(new OnSuccessListener<AppCheckToken>() {
                    @Override
                    public void onSuccess(@NonNull AppCheckToken tokenResponse) {
                        String appCheckToken = tokenResponse.getToken();
                        Call<List<String>> apiCall =
                                yourExampleBackendService.exampleData(appCheckToken);
                        // ...
                    }
                });
    }
}

Kotlin + KTX

class ApiWithAppCheckExample {
    interface YourExampleBackendService {
        @GET("yourExampleEndpoint")
        fun exampleData(
            @Header("X-Firebase-AppCheck") appCheckToken: String
        ): Call<List<String>>
    }

    var yourExampleBackendService: YourExampleBackendService = Retrofit.Builder()
        .baseUrl("https://yourbackend.example.com/")
        .build()
        .create(YourExampleBackendService::class.java)

    fun callApiExample() {
        FirebaseAppCheck.getInstance()
            .getAppCheckToken(false)
            .addOnSuccessListener { tokenResponse ->
                val appCheckToken = tokenResponse.token
                val apiCall = yourExampleBackendService.exampleData(appCheckToken)
                // ...
            }
    }
}

Verifique los tokens de verificación de aplicaciones en el backend

En su código de fondo, si aún no lo ha instalado el SDK del administrador Node.js , que lo hagan. Luego, agregue lógica a sus puntos finales de API que haga lo siguiente:

  • Compruebe que cada solicitud incluya un token de verificación de aplicaciones.

  • Verificar la aplicación Comprobar símbolo utilizando el SDK de administración appCheck().verifyToken() método.

    Si la verificación tiene éxito, verifyToken() devuelve el App decodificado Compruebe token. La verificación exitosa indica que el token se originó en una aplicación que pertenece a su proyecto de Firebase.

Rechace cualquier solicitud que falle en cualquiera de las dos comprobaciones. Por ejemplo, usando el middleware Express.js:

const express = require('express');
const app = express();

const firebaseAdmin = require('firebase-admin');
const firebaseApp = firebaseAdmin.initializeApp();

const appCheckVerification = async (req, res, next) => {
    const appCheckToken = req.header('X-Firebase-AppCheck');

    if (!appCheckToken) {
        res.status(401);
        return next('Unauthorized');
    }

    try {
        const appCheckClaims = await firebaseAdmin.appCheck().verifyToken(appCheckToken);

        // If verifyToken() succeeds, continue with the next middleware
        // function in the stack.
        return next();
    } catch (err) {
        res.status(401);
        return next('Unauthorized');
    }
}

app.get('/yourApiEndpoint', [appCheckVerification], (req, res) => {
    // Handle request.
});