Diese Seite wurde von der Cloud Translation API übersetzt.

ID-Token überprüfen

Wenn Ihre Firebase-Client-App mit einem benutzerdefinierten Back-End-Server kommuniziert, müssen Sie möglicherweise den aktuell angemeldeten Benutzer auf diesem Server identifizieren. Um dies sicher zu tun, senden Sie nach einer erfolgreichen Anmeldung das ID-Token des Benutzers ü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. Mithilfe der so übermittelten uid können Sie den aktuell angemeldeten Benutzer auf Ihrem Server sicher identifizieren.

Bevor Sie beginnen

Um ID-Tokens mit dem Firebase Admin SDK zu überprüfen, müssen Sie über ein Dienstkonto verfügen. Befolgen Sie die Anweisungen zum Einrichten des Admin SDK , um weitere Informationen zum Initialisieren des Admin SDK mit einem Dienstkonto zu erhalten.

Rufen Sie ID-Tokens auf Clients ab

Wenn sich ein Benutzer oder ein Gerät erfolgreich anmeldet, erstellt Firebase ein entsprechendes ID-Token, das ihn eindeutig identifiziert und ihm Zugriff auf mehrere Ressourcen gewährt, beispielsweise die Firebase-Echtzeitdatenbank und den Cloud-Speicher. Sie können dieses ID-Token wiederverwenden, um den Benutzer oder das Gerät auf Ihrem benutzerdefinierten Backend-Server zu identifizieren. Um das ID-Token vom Client abzurufen, stellen Sie sicher, dass der Benutzer angemeldet ist, und holen Sie sich dann das ID-Token vom angemeldeten Benutzer:

iOS+

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

Schnell

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

Einheit

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

Netz

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

Sobald Sie über ein ID-Token verfügen, können Sie dieses JWT an Ihr Backend senden und es mithilfe des Firebase Admin SDK oder mithilfe einer JWT-Bibliothek eines Drittanbieters validieren, wenn Ihr Server in einer Sprache geschrieben ist, die Firebase nicht nativ unterstützt.

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

Das Firebase Admin SDK verfügt über eine integrierte Methode zum Überprüfen und Dekodieren von ID-Tokens. Wenn das bereitgestellte ID-Token das richtige Format hat, nicht abgelaufen ist und ordnungsgemäß signiert ist, gibt die Methode das dekodierte ID-Token zurück. Sie können die uid des Benutzers oder Geräts aus dem entschlüsselten Token abrufen.

Befolgen Sie die Setup-Anweisungen 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:

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']

Gehen

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;

Für die ID-Token-Verifizierung ist eine Projekt-ID erforderlich. Das Firebase Admin SDK versucht, über eine der folgenden Methoden eine Projekt-ID zu erhalten:

Wenn das SDK mit einer expliziten projectId App-Option initialisiert wurde, verwendet das SDK den Wert dieser Option.
Wenn das SDK mit Dienstkonto-Anmeldeinformationen initialisiert wurde, verwendet das SDK das Feld project_id des Dienstkonto-JSON-Objekts.
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 auf der Google-Infrastruktur wie App Engine und Compute Engine ausgeführt wird.

Überprüfen Sie ID-Token mithilfe einer JWT-Bibliothek eines Drittanbieters

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

Stellen Sie sicher, dass der Header des ID-Tokens den folgenden Einschränkungen entspricht:

ID-Token-Header-Ansprüche
`alg`	Algorithmus	`"RS256"`
`kid`	Schlüssel-ID	Muss einem der unter `https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com` aufgeführten öffentlichen Schlüssel entsprechen

Stellen Sie sicher, dass die Nutzlast des ID-Tokens den folgenden Einschränkungen entspricht:

ID-Token-Nutzlastansprüche
`exp`	Ablaufzeit	Muss in der Zukunft liegen. Die Zeit wird in Sekunden seit der UNIX-Epoche gemessen.
`iat`	Ausgestellt zum Zeitpunkt	Muss in der Vergangenheit liegen. Die Zeit wird in Sekunden seit der UNIX-Epoche gemessen.
`aud`	Publikum	Dies muss Ihre Firebase-Projekt-ID sein, die eindeutige Kennung für Ihr Firebase-Projekt, die in der URL der Konsole dieses Projekts zu finden ist.
`iss`	Aussteller	Muss `"https://securetoken.google.com/<projectId>"` sein, wobei `<projectId>` dieselbe Projekt-ID ist, die oben für `aud` verwendet wurde.
`sub`	Thema	Darf eine nicht leere Zeichenfolge sein und muss die `uid` des Benutzers oder Geräts sein.
`auth_time`	Authentifizierungszeit	Muss in der Vergangenheit liegen. Der Zeitpunkt, zu dem sich der Benutzer authentifiziert hat.

Stellen Sie abschließend sicher, dass das ID-Token mit dem privaten Schlüssel signiert wurde, der dem kid des Tokens entspricht. Besorgen Sie sich den öffentlichen Schlüssel von https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com und verwenden Sie eine JWT-Bibliothek, um die Signatur zu überprüfen. Verwenden Sie den Wert von max-age im Cache-Control Header der Antwort von diesem Endpunkt, um zu wissen, wann die öffentlichen Schlüssel aktualisiert werden müssen.

Wenn alle oben genannten Überprüfungen erfolgreich sind, können Sie den Betreff ( sub ) des ID-Tokens als uid des entsprechenden Benutzers oder Geräts verwenden.