ID-Tokens verifizieren

Wenn Ihre Firebase-Clientanwendung mit einem benutzerdefinierten Back-End-Server kommuniziert, müssen Sie den derzeit angemeldeten Nutzer auf diesem Server möglicherweise identifizieren. Senden Sie dazu nach einer erfolgreichen Anmeldung das ID-Token des Nutzers sicher über HTTPS an Ihren Server. Überprüfen Sie dann auf dem Server die Integrität und Authentizität des ID-Tokens und rufen Sie die uid daraus ab. Sie können die auf diese Weise übertragene uid verwenden, um den derzeit angemeldeten Nutzer sicher auf Ihrem Server zu identifizieren.

Hinweis

Zum Überprüfen von ID-Tokens mit dem Firebase Admin SDK benötigen Sie ein Dienstkonto. Weitere Informationen zum Initialisieren des Admin SDK mit einem Dienstkonto finden Sie in der Einrichtungsanleitung für das Admin SDK für.

ID-Tokens auf Clients abrufen

Wenn sich ein Nutzer oder Gerät erfolgreich anmeldet, erstellt Firebase ein entsprechendes ID-Token, das ihn bzw. es eindeutig identifiziert und Zugriff auf mehrere Ressourcen gewährt, z. B. Firebase Realtime Database und Cloud Storage. Sie können dieses ID-Token wiederverwenden, um den Nutzer oder das Gerät auf Ihrem benutzerdefinierten Back-End-Server zu identifizieren. Wenn Sie das ID-Token vom Client abrufen möchten, muss der Nutzer angemeldet sein. Rufen Sie dann das ID-Token vom angemeldeten Nutzer ab:

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

Sobald Sie ein ID-Token haben, können Sie dieses JSON Web Token (JWT) an Ihr Back-End senden und mit dem Firebase Admin SDK oder einer JWT-Bibliothek eines Drittanbieters validieren, wenn Ihr Server in einer Sprache geschrieben ist, die von Firebase nicht nativ unterstützt wird.

ID-Tokens mit dem Firebase Admin SDK überprüfen

Das Firebase Admin SDK hat eine integrierte Methode zum Überprüfen und Decodieren von ID-Tokens. Wenn das angegebene ID-Token das richtige Format hat, nicht abgelaufen ist und ordnungsgemäß signiert wurde, gibt die Methode das decodierte ID-Token zurück. Sie können die uid des Nutzers oder Geräts aus dem decodierten Token abrufen.

Folgen Sie der Einrichtungsanleitung für das Admin SDK, um das Admin SDK mit einem Dienstkonto zu initialisieren. Verwenden Sie dann die Methode verifyIdToken(), um ein ID-Token zu überprüfen:

// 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;

Für die Überprüfung von ID-Tokens ist eine Projekt-ID erforderlich. Das Firebase Admin SDK versucht, eine Projekt-ID mit einer der folgenden Methoden abzurufen:

• Wenn das SDK mit einer expliziten projectId-App-Option initialisiert wurde, verwendet das SDK den Wert dieser Option.
• Wenn das SDK mit Dienstkontoanmeldedaten initialisiert wurde, verwendet das SDK das Feld project_id des JSON-Objekts des Dienstkontos.
• Wenn die Umgebungsvariable GOOGLE_CLOUD_PROJECT festgelegt ist, verwendet das SDK ihren Wert als Projekt-ID. Diese Umgebungsvariable ist für Code verfügbar, der in der Google-Infrastruktur ausgeführt wird, z. B. in App Engine und Compute Engine.

ID-Tokens mit einer JWT-Bibliothek eines Drittanbieters überprüfen

Wenn Ihr Back-End in einer Sprache geschrieben ist, die vom Firebase Admin SDK nicht unterstützt wird, können Sie trotzdem ID-Tokens überprüfen. Suchen Sie zuerst nach einer JWT-Bibliothek eines Drittanbieters für Ihre Sprache. Überprüfen Sie dann den Header, die Nutzlast und die Signatur des ID-Tokens.

Prüfen Sie, ob der Header des ID-Tokens die folgenden Anforderungen erfüllt:

Überprüfen Sie, ob die Nutzlast des ID-Tokens die folgenden Einschränkungen einhält:

Prüfen Sie schließlich, ob das ID-Token mit dem privaten Schlüssel signiert wurde, der der Anforderung kid des Tokens entspricht. Rufen Sie den öffentlichen Schlüssel unter https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com ab und überprüfen Sie die Signatur mit einer JWT-Bibliothek. Verwenden Sie den Wert von max-age im Cache-Control-Header der Antwort von diesem Endpunkt, um zu erfahren, wann die öffentlichen Schlüssel aktualisiert werden müssen.

Wenn alle oben genannten Prüfungen erfolgreich abgeschlossen wurden, können Sie den Betreff (sub) des ID-Tokens als uid des entsprechenden Nutzers oder Geräts verwenden.