Cette page a été traduite par l'API Cloud Translation.

Vérifier les jetons App Check à partir d'un backend personnalisé

Vous pouvez utiliser App Check pour protéger les ressources de backend personnalisées non Google de votre application, comme votre propre backend auto-hébergé. Pour ce faire, vous devez effectuer les deux opérations suivantes :

Modifiez le client de votre application pour envoyer un jeton App Check avec chaque requête à votre backend, comme décrit sur les pages pour iOS+, Android, Web, Flutter, Unity ou C++.
Modifiez votre backend pour exiger un jeton App Check valide pour chaque requête, comme décrit sur cette page.

Validation des jetons

Pour valider les jetons App Check sur votre backend, ajoutez une logique à vos points de terminaison d'API qui effectue les opérations suivantes :

Vérifiez que chaque requête inclut un jeton App Check.
Validez le jeton App Check à l'aide du SDK Admin.

Si la validation réussit, l'Admin SDK renvoie le jeton App Check décodé. Si la validation réussit, cela signifie que le jeton provient d'une application appartenant à votre projet Firebase.

Refusez toute demande qui échoue à l'une ou l'autre des vérifications. Exemple :

Node.js

Si vous ne l'avez pas déjà fait, installez le SDK Admin Node.js.

Ensuite, en utilisant l'intergiciel Express.js comme exemple :

import express from "express";
import { initializeApp } from "firebase-admin/app";
import { getAppCheck } from "firebase-admin/app-check";

const expressApp = express();
const firebaseApp = 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 getAppCheck().verifyToken(appCheckToken);

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

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

Python

Si vous ne l'avez pas déjà fait, installez le SDK Admin Python.

Ensuite, dans les gestionnaires de points de terminaison de votre API, appelez app_check.verify_token() et rejetez la requête en cas d'échec. Dans l'exemple suivant, une fonction décorée avec @before_request effectue cette tâche pour toutes les requêtes :

import firebase_admin
from firebase_admin import app_check
import flask
import jwt

firebase_app = firebase_admin.initialize_app()
flask_app = flask.Flask(__name__)

@flask_app.before_request
def verify_app_check() -> None:
    app_check_token = flask.request.headers.get("X-Firebase-AppCheck", default="")
    try:
        app_check_claims = app_check.verify_token(app_check_token)
        # If verify_token() succeeds, okay to continue to route handler.
    except (ValueError, jwt.exceptions.DecodeError):
        flask.abort(401)

@flask_app.route("/yourApiEndpoint")
def your_api_endpoint(request: flask.Request):
    # Handle request.
    ...

Accéder

Si vous ne l'avez pas déjà fait, installez le SDK Admin pour Go.

Ensuite, dans les gestionnaires de points de terminaison de votre API, appelez appcheck.Client.VerifyToken() et rejetez la requête en cas d'échec. Dans l'exemple suivant, une fonction wrapper ajoute cette logique aux gestionnaires de points de terminaison :

package main

import (
    "context"
    "log"
    "net/http"

    firebaseAdmin "firebase.google.com/go/v4"
    "firebase.google.com/go/v4/appcheck"
)

var (
    appCheck *appcheck.Client
)

func main() {
    app, err := firebaseAdmin.NewApp(context.Background(), nil)
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    appCheck, err = app.AppCheck(context.Background())
    if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
    }

    http.HandleFunc("/yourApiEndpoint", requireAppCheck(yourApiEndpointHandler))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func requireAppCheck(handler func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
    wrappedHandler := func(w http.ResponseWriter, r *http.Request) {
        appCheckToken, ok := r.Header[http.CanonicalHeaderKey("X-Firebase-AppCheck")]
        if !ok {
            w.WriteHeader(http.StatusUnauthorized)
            w.Write([]byte("Unauthorized."))
            return
        }

        _, err := appCheck.VerifyToken(appCheckToken[0])
        if err != nil {
            w.WriteHeader(http.StatusUnauthorized)
            w.Write([]byte("Unauthorized."))
            return
        }

        // If VerifyToken() succeeds, continue with the provided handler.
        handler(w, r)
    }
    return wrappedHandler
}

func yourApiEndpointHandler(w http.ResponseWriter, r *http.Request) {
    // Handle request.
}

Autre

Si votre backend est écrit dans une autre langue, vous pouvez utiliser une bibliothèque JWT à usage général, telle que celle disponible sur jwt.io, pour valider les jetons App Check.

La logique de validation de votre jeton doit effectuer les étapes suivantes :

Obtenez le jeu de clés Web JSON (JWKS) public de Firebase App Check à partir du point de terminaison JWKS App Check : https://firebaseappcheck.googleapis.com/v1/jwks
Vérifiez la signature du jeton App Check pour vous assurer qu'il est légitime.
Assurez-vous que l'en-tête du jeton utilise l'algorithme RS256.
Assurez-vous que l'en-tête du jeton est de type JWT.
Assurez-vous que le jeton est émis par Firebase App Check dans votre projet.
Assurez-vous que le jeton n'a pas expiré.
Assurez-vous que l'audience du jeton correspond à votre projet.
Facultatif : Vérifiez que l'objet du jeton correspond à l'ID d'application de votre application.

Les fonctionnalités des bibliothèques JWT peuvent varier. Veillez à effectuer manuellement toutes les étapes qui ne sont pas gérées par la bibliothèque de votre choix.

L'exemple suivant effectue les étapes nécessaires en Ruby à l'aide du gem jwt en tant que couche middleware Rack.

require 'json'
require 'jwt'
require 'net/http'
require 'uri'

class AppCheckVerification
def initialize(app, options = {})
    @app = app
    @project_number = options[:project_number]
end

def call(env)
    app_id = verify(env['HTTP_X_FIREBASE_APPCHECK'])
    return [401, { 'Content-Type' => 'text/plain' }, ['Unauthenticated']] unless app_id
    env['firebase.app'] = app_id
    @app.call(env)
end

def verify(token)
    return unless token

    # 1. Obtain the Firebase App Check Public Keys
    # Note: It is not recommended to hard code these keys as they rotate,
    # but you should cache them for up to 6 hours.
    uri = URI('https://firebaseappcheck.googleapis.com/v1/jwks')
    jwks = JSON(Net::HTTP.get(uri))

    # 2. Verify the signature on the App Check token
    payload, header = JWT.decode(token, nil, true, jwks: jwks, algorithms: 'RS256')

    # 3. Ensure the token's header uses the algorithm RS256
    return unless header['alg'] == 'RS256'

    # 4. Ensure the token's header has type JWT
    return unless header['typ'] == 'JWT'

    # 5. Ensure the token is issued by App Check
    return unless payload['iss'] == "https://firebaseappcheck.googleapis.com/#{@project_number}"

    # 6. Ensure the token is not expired
    return unless payload['exp'] > Time.new.to_i

    # 7. Ensure the token's audience matches your project
    return unless payload['aud'].include? "projects/#{@project_number}"

    # 8. The token's subject will be the app ID, you may optionally filter against
    # an allow list
    payload['sub']
rescue
end
end

class Application
def call(env)
    [200, { 'Content-Type' => 'text/plain' }, ["Hello app #{env['firebase.app']}"]]
end
end

use AppCheckVerification, project_number: 1234567890
run Application.new

Protection contre le rejeu (bêta)

Pour protéger un point de terminaison contre les attaques par rejeu, vous pouvez consommer le jeton App Check après l'avoir validé afin qu'il ne puisse être utilisé qu'une seule fois.

L'utilisation de la protection contre la relecture ajoute un aller-retour réseau à l'appel verifyToken() et, par conséquent, ajoute de la latence à tout point de terminaison qui l'utilise. Pour cette raison, nous vous recommandons d'activer la protection contre la réutilisation uniquement sur les points de terminaison particulièrement sensibles.

Pour utiliser la protection contre la relecture, procédez comme suit :

Dans la console Cloud, attribuez le rôle "Validateur de jetons Firebase App Check" au compte de service utilisé pour valider les jetons.
- Si vous avez initialisé le SDK Admin avec les identifiants du compte de service du SDK Admin que vous avez téléchargés depuis la console Firebase, le rôle requis est déjà accordé.
- Si vous utilisez Cloud Functions de première génération avec la configuration par défaut du SDK Admin, accordez le rôle au compte de service App Engine par défaut. Consultez Modifier les autorisations des comptes de service.
- Si vous utilisez Cloud Functions de deuxième génération avec la configuration par défaut du SDK Admin, attribuez le rôle au compte de service Compute par défaut.
Ensuite, pour consommer un jeton, transmettez { consume: true } à la méthode verifyToken() et examinez l'objet de résultat. Si la propriété alreadyConsumed est true, refusez la requête ou prenez une mesure corrective, par exemple en demandant à l'appelant de passer d'autres vérifications.

Exemple :
```
const appCheckClaims = await getAppCheck().verifyToken(appCheckToken, { consume: true });

if (appCheckClaims.alreadyConsumed) {
    res.status(401);
    return next('Unauthorized');
}

// If verifyToken() succeeds and alreadyConsumed is not set, okay to continue.
```
Cette opération permet de valider le jeton et de l'indiquer comme utilisé. Les futures invocations de verifyToken(appCheckToken, { consume: true }) sur le même jeton définiront alreadyConsumed sur true. (Notez que verifyToken() ne rejette pas un jeton consommé et ne vérifie même pas s'il est consommé si consume n'est pas défini.)

Lorsque vous activez cette fonctionnalité pour un point de terminaison spécifique, vous devez également mettre à jour le code client de votre application pour acquérir des jetons à usage limité consommables à utiliser avec le point de terminaison. Consultez la documentation côté client pour les plates-formes Apple, Android et Web.