Vérifier les jetons d'identification

Si votre application cliente Firebase communique avec un serveur principal 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érifier l'intégrité et l' authenticité de l'ID de jeton et récupérer le uid de celui - ci. Vous pouvez utiliser le uid transmis de cette manière d'identifier en toute sécurité le haut -signé utilisateur actuellement 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 d'installation Admin SDK pour plus d' informations sur la façon d'initialiser le Admin SDK 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 donne accès à plusieurs ressources, telles que Firebase Realtime Database et Cloud Storage. Vous pouvez réutiliser ce jeton d'identification pour identifier l'utilisateur ou l'appareil sur votre serveur principal 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

Objectif 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
          // ...
}];
Rapide
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();
            }
        }
    });

Unité

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 != nullptr) {
  firebase::Future<std::string> idToken = user->GetToken(true);

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

la toile

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 avez un jeton d'identification, vous pouvez envoyer ce JWT à votre backend et le valider à l'aide du SDK Firebase Admin ou à l'aide d'une bibliothèque JWT tierce si votre serveur est écrit dans une langue que Firebase ne prend pas en charge nativement.

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

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'ID fourni a le format correct, n'a pas expiré et est correctement signé, la méthode renvoie le jeton d'ID décodé. Vous pouvez saisir le uid de l'utilisateur ou d'un dispositif à partir du jeton décodé.

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

Node.js

// idToken comes from the client app
admin
  .auth()
  .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']

Va

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)

C#

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 Firebase Admin tente d'obtenir un ID de projet via l'une des méthodes suivantes :

  • Si le SDK a été initialisé avec une explicite projectId option application, le SDK utilise la valeur de cette option.
  • Si le SDK a été initialisé avec les informations d' identification de compte de service, le SDK utilise le project_id champ du compte de service objet JSON.
  • Si la GOOGLE_CLOUD_PROJECT variable d'environnement est définie, le SDK utilise sa valeur comme l'ID du projet. Cette variable d'environnement est disponible pour le code exécuté sur l'infrastructure Google telle qu'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 Firebase Admin, vous pouvez toujours vérifier les jetons d'identification. Tout d' abord, trouver une bibliothèque de JWT tiers pour votre langue . Ensuite, vérifiez 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 :

Revendications d'en-tête de jeton d'identification
alg Algorithme "RS256"
kid Identifiant de clé Doit correspondre à l' une des clés publiques énumérées à https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com

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

Revendications de charge utile de jeton d'identification
exp Date d'expiration Doit être dans le futur. Le temps est mesuré en secondes depuis l'époque UNIX.
iat Émis à l'heure Doit être dans le passé. Le temps est mesuré en secondes depuis l'époque UNIX.
aud Public Il doit s'agir de votre ID de 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 utilisé pour aud ci - dessus.
sub Matière Doit être une chaîne non vide et doit être le uid de l'utilisateur ou le périphérique.
auth_time Heure d'authentification Doit être dans le passé. L'heure à laquelle l'utilisateur s'est authentifié.

Enfin, assurez -vous que le jeton d'identité a été signé par la clé privée correspondant à l'jeton kid la demande. Prenez la clé publique de https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com et utiliser une bibliothèque de JWT pour vérifier la signature. Utilisez la valeur de max-age dans le Cache-Control en- tête de la réponse de ce point final à savoir quand rafraîchir les clés publiques.

Si toutes les vérifications ci - dessus sont couronnées de succès, vous pouvez utiliser le sujet ( sub ) de l'ID de jeton comme uid de l'utilisateur ou un dispositif correspondant.