Vérifier les jetons d'ID

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

Remarque :De nombreux cas d'utilisation de vérification des jetons d'identification sur le serveur peuvent être réalisés à l'aide de règles de sécurité pour Firebase Realtime Database et Cloud Storage. Vérifiez si ces solutions résolvent votre problème avant de valider vous-même les jetons d'ID.

Avertissement : Les méthodes de validation des jetons d'ID incluses dans les SDK Firebase Admin sont destinées à valider les jetons d'ID provenant des SDK client, et non les jetons personnalisés que vous créez avec les SDK Admin. Pour en savoir plus, consultez la section Jetons d'authentification.

Avant de commencer

Pour valider les jetons d'ID avec le SDK Admin Firebase, vous devez disposer d'un compte de service. Suivez les instructions de configuration du SDK Admin pour savoir comment initialiser le SDK Admin avec un compte de service.

Récupérer des jetons d'ID sur les clients

Lorsqu'un utilisateur ou un appareil se connecte avec succès, Firebase crée un jeton d'ID correspondant qui les identifie de manière unique et leur accorde l'accès à plusieurs ressources, telles que Firebase Realtime Database et Cloud Storage. Vous pouvez réutiliser ce jeton d'ID 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é :

iOS+

Objective-C

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
          // ...
}];

Swift

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
  // ...
}

Android

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();
            }
        }
    });

Unity

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

C++

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
  // ...
}

Web

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'ID, vous pouvez envoyer ce jeton JWT à votre backend et le valider à l'aide du SDK Admin Firebase ou d'une bibliothèque JWT tierce si votre serveur est écrit dans un langage non compatible de manière native avec Firebase.

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

Le SDK Admin Firebase intègre une méthode permettant de vérifier et de décoder les jetons d'ID. Si le jeton d'ID fourni est au bon format, qu'il n'a pas expiré et qu'il est correctement signé, la méthode renvoie le jeton d'ID décodé. Vous pouvez récupérer le uid de l'utilisateur ou de l'appareil à partir du jeton décodé.

Remarque : Cette opération ne vérifie pas si le jeton a été révoqué ou non. Consultez la section Détecter la révocation d'un jeton d'ID.

Suivez les instructions de configuration du SDK Admin pour l'initialiser avec un compte de service. Utilisez ensuite la méthode verifyIdToken() pour valider un jeton d'ID :

Node.js

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

Java

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

Python

# id_token comes from the client app (shown above)

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

Go

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

C#

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

La validation des jetons d'ID nécessite un ID de projet. Le SDK Admin 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, il utilise la valeur de cette option.
• Si le SDK a été initialisé avec des identifiants de compte de service, il 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, comme 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 compatible avec le SDK Firebase Admin, vous pouvez toujours valider les jetons d'identification. Commencez par trouver une bibliothèque JWT tierce pour votre langage. Vérifiez ensuite l'en-tête, la charge utile et la signature du jeton d'ID.

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

Revendications d'en-tête du jeton d'ID
alg	Algorithme	"RS256"
kid	ID de clé	Doit correspondre à l'une des clés publiques listées sur https://www.googleapis.com/robot/v1/metadata/x509/[e-mail]

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

Revendications de charge utile du jeton d'ID
exp	Date/Heure d'expiration	Il doit s'agir d'une date future. Le temps est mesuré en secondes depuis l'époque UNIX.
iat	Date/Heure d'émission	Il doit s'agir d'une date antérieure. Le temps est mesuré en secondes depuis l'époque UNIX.
aud	Public visé	Doit correspondre à l'ID de votre projet Firebase, l'identifiant unique de votre projet Firebase, qui se trouve dans l'URL de la console de ce projet.
iss	Émetteur	Doit être "https://securetoken.google.com/<projectId>", où <projectId> est le même ID de projet que celui utilisé pour aud ci-dessus.
sub	Objet	Doit être une chaîne non vide et correspondre à l'uid de l'utilisateur ou de l'appareil.
auth_time	Heure d'authentification	Il doit s'agir d'une date antérieure. Heure à laquelle l'utilisateur s'est authentifié.

Enfin, assurez-vous que le jeton d'ID a été signé par la clé privée correspondant à la revendication kid du jeton. Récupérez la clé publique dans https://www.googleapis.com/robot/v1/metadata/x509/[e-mail] et utilisez une bibliothèque JWT pour valider 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 l'objet (sub) du jeton d'ID comme uid de l'utilisateur ou de l'appareil correspondant.