Vérifier les jetons d'identification

Si votre application client Firebase communique avec un serveur backend personnalisé, vous devrez peut-être identifier l'utilisateur actuellement connecté sur ce serveur. Pour le faire en toute sécurité, après une connexion réussie, envoyez le jeton d'identification de l'utilisateur à votre serveur via HTTPS. Ensuite, sur le serveur, vérifiez l'intégrité et l'authenticité du jeton d'identification et récupérez-en l' uid . Vous pouvez utiliser l' uid transmis de cette manière pour identifier en toute sécurité l'utilisateur actuellement connecté sur votre serveur.

Avant que tu commences

Pour vérifier les jetons d'identification avec le SDK Firebase Admin, vous devez disposer d'un compte de service. Suivez les instructions de configuration du SDK Admin pour plus d'informations sur la façon d'initialiser le SDK Admin avec un compte de service.

Récupérer les jetons d'identification sur les clients

Lorsqu'un utilisateur ou un appareil se connecte avec succès, Firebase crée un jeton d'identification correspondant qui l'identifie de manière unique et lui accorde l'accès à plusieurs ressources, telles que la base de données en temps réel Firebase et le stockage cloud. Vous pouvez réutiliser ce jeton d'identification pour identifier l'utilisateur ou l'appareil sur votre serveur backend personnalisé. Pour récupérer le jeton d'ID du client, assurez-vous que l'utilisateur est connecté, puis récupérez le jeton d'ID de l'utilisateur connecté :

FIRUser *currentUser = [FIRAuth auth].currentUser;
[currentUser getIDTokenForcingRefresh:YES
                           completion:^(NSString *_Nullable idToken,
                                        NSError *_Nullable error) {
          if (error) {
            // Handle error
            return;
          }

          // Send token to your backend via HTTPS
          // ...
}];

let currentUser = FIRAuth.auth()?.currentUser
currentUser?.getIDTokenForcingRefresh(true) { idToken, error in
  if let error = error {
    // Handle error
    return;
  }

  // Send token to your backend via HTTPS
  // ...
}

FirebaseUser mUser = FirebaseAuth.getInstance().getCurrentUser();
mUser.getIdToken(true)
    .addOnCompleteListener(new OnCompleteListener<GetTokenResult>() {
        public void onComplete(@NonNull Task<GetTokenResult> task) {
            if (task.isSuccessful()) {
                String idToken = task.getResult().getToken();
                // Send token to your backend via HTTPS
                // ...
            } else {
                // Handle error -> task.getException();
            }
        }
    });

Firebase.Auth.FirebaseUser user = auth.CurrentUser;
user.TokenAsync(true).ContinueWith(task => {
  if (task.IsCanceled) {
    Debug.LogError("TokenAsync was canceled.");
   return;
  }

  if (task.IsFaulted) {
    Debug.LogError("TokenAsync encountered an error: " + task.Exception);
    return;
  }

  string idToken = task.Result;

  // Send token to your backend via HTTPS
  // ...
});

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  firebase::Future<std::string> idToken = user.GetToken(true);

  // Send token to your backend via HTTPS
  // ...
}

firebase.auth().currentUser.getIdToken(/* forceRefresh */ true).then(function(idToken) {
  // Send token to your backend via HTTPS
  // ...
}).catch(function(error) {
  // Handle error
});

Une fois que vous disposez d'un jeton d'identification, vous pouvez envoyer ce JWT à votre backend et le valider à l'aide du SDK d'administration Firebase ou à l'aide d'une bibliothèque JWT tierce si votre serveur est écrit dans un langage que Firebase ne prend pas en charge nativement.

Vérifier les jetons d'identification à l'aide du SDK d'administration Firebase

Le SDK Firebase Admin dispose d'une méthode intégrée pour vérifier et décoder les jetons d'identification. Si le jeton d'identification fourni a le format correct, n'a pas expiré et est correctement signé, la méthode renvoie le jeton d'identification décodé. Vous pouvez récupérer l' uid de l'utilisateur ou de l'appareil à partir du jeton décodé.

Suivez les instructions de configuration du SDK Admin pour initialiser le SDK Admin avec un compte de service. Ensuite, utilisez la méthode verifyIdToken() pour vérifier un jeton d'identification :

// idToken comes from the client app
getAuth()
  .verifyIdToken(idToken)
  .then((decodedToken) => {
    const uid = decodedToken.uid;
    // ...
  })
  .catch((error) => {
    // Handle error
  });

// idToken comes from the client app (shown above)
FirebaseToken decodedToken = FirebaseAuth.getInstance().verifyIdToken(idToken);
String uid = decodedToken.getUid();

# id_token comes from the client app (shown above)

decoded_token = auth.verify_id_token(id_token)
uid = decoded_token['uid']

client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

token, err := client.VerifyIDToken(ctx, idToken)
if err != nil {
	log.Fatalf("error verifying ID token: %v\n", err)
}

log.Printf("Verified ID token: %v\n", token)
auth.go

FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance
    .VerifyIdTokenAsync(idToken);
string uid = decodedToken.Uid;

La vérification du jeton d'identification nécessite un ID de projet. Le SDK d'administration Firebase tente d'obtenir un ID de projet via l'une des méthodes suivantes :

• Si le SDK a été initialisé avec une option d’application projectId explicite, le SDK utilise la valeur de cette option.
• Si le SDK a été initialisé avec les informations d'identification du compte de service, le SDK utilise le champ project_id de l'objet JSON du compte de service.
• Si la variable d'environnement GOOGLE_CLOUD_PROJECT est définie, le SDK utilise sa valeur comme ID de projet. Cette variable d'environnement est disponible pour le code exécuté sur l'infrastructure Google telle que App Engine et Compute Engine.

Vérifier les jetons d'identification à l'aide d'une bibliothèque JWT tierce

Si votre backend est dans une langue non prise en charge par le SDK d'administration Firebase, vous pouvez toujours vérifier les jetons d'identification. Tout d'abord, recherchez une bibliothèque JWT tierce pour votre langue . Vérifiez ensuite l'en-tête, la charge utile et la signature du jeton d'identification.

Vérifiez que l'en-tête du jeton d'ID est conforme aux contraintes suivantes :

Vérifiez que la charge utile du jeton d'ID est conforme aux contraintes suivantes :

Enfin, assurez-vous que le jeton d'identification a été signé par la clé privée correspondant à la revendication kid du jeton. Récupérez la clé publique sur https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com et utilisez une bibliothèque JWT pour vérifier la signature. Utilisez la valeur de max-age dans l'en-tête Cache-Control de la réponse de ce point de terminaison pour savoir quand actualiser les clés publiques.

Si toutes les vérifications ci-dessus réussissent, vous pouvez utiliser le sujet ( sub ) du jeton d'identification comme uid de l'utilisateur ou de l'appareil correspondant.