Wenn Ihre Firebase-Clientanwendung mit einem benutzerdefinierten Back-End-Server kommuniziert, müssen Sie den aktuell angemeldeten Nutzer auf diesem Server möglicherweise identifizieren. Um dies sicher zu machen, senden Sie nach einer erfolgreichen Anmeldung das ID-Token des Nutzers über HTTPS an Ihren Server. Prü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 aktuell angemeldeten Nutzer auf Ihrem Server sicher zu identifizieren.
Hinweis
Wenn Sie ID-Tokens mit dem Firebase Admin SDK prüfen möchten, benötigen Sie ein Dienstkonto. Weitere Informationen zum Initialisieren des Admin SDK mit einem Dienstkonto finden Sie in der Anleitung für die Admin SDK-Einrichtung.
ID-Tokens auf Clients abrufen
Wenn sich ein Nutzer oder ein Gerät erfolgreich anmeldet, erstellt Firebase ein entsprechendes ID-Token, das den Nutzer oder das Gerät eindeutig identifiziert und ihm Zugriff auf verschiedene Ressourcen wie Firebase Realtime Database und Cloud Storage gewährt. Sie können dieses ID-Token wiederverwenden, um den Nutzer oder das Gerät auf Ihrem benutzerdefinierten Back-End-Server zu identifizieren. Damit du das ID-Token vom Client abrufen kannst, muss der Nutzer angemeldet sein. Rufe dann das ID-Token vom angemeldeten Nutzer ab:
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();
}
}
});
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
// ...
}
Web
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 es an Ihr Backend 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 Prüfen und Decodieren von ID-Tokens. Wenn das bereitgestellte ID-Token das richtige Format hat, nicht abgelaufen und ordnungsgemäß signiert ist, gibt die Methode das decodierte ID-Token zurück. Du kannst die uid
des Nutzers oder Geräts aus dem decodierten Token abrufen.
Folgen Sie der Anleitung zum Einrichten des Admin SDK, um das Admin SDK mit einem Dienstkonto zu initialisieren. Verwenden Sie dann die Methode verifyIdToken()
, um ein ID-Token zu verifizieren:
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)
C#
FirebaseToken decodedToken = await FirebaseAuth.DefaultInstance
.VerifyIdTokenAsync(idToken);
string uid = decodedToken.Uid;
Für die Bestätigung 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
-Anwendungsoption initialisiert wurde, verwendet das SDK den Wert dieser Option. - Wenn das SDK mit Anmeldedaten für ein Dienstkonto initialisiert wurde, verwendet es das Feld
project_id
des JSON-Objekts des Dienstkontos. - Wenn die Umgebungsvariable
GOOGLE_CLOUD_PROJECT
festgelegt ist, verwendet das SDK deren Wert als Projekt-ID. Diese Umgebungsvariable ist für Code verfügbar, der in einer Google-Infrastruktur wie App Engine und Compute Engine ausgeführt wird.
ID-Tokens mit einer JWT-Bibliothek eines Drittanbieters bestätigen
Wenn Ihr Back-End in einer Sprache geschrieben ist, die vom Firebase Admin SDK nicht unterstützt wird, können Sie trotzdem ID-Tokens bestätigen. Suchen Sie zuerst nach einer JWT-Bibliothek eines Drittanbieters für Ihre Sprache. Prüfen Sie dann den Header, die Nutzlast und die Signatur des ID-Tokens.
Prüfen Sie, ob der Header des ID-Tokens den folgenden Anforderungen genügt:
Claims im Header des ID-Tokens | ||
---|---|---|
alg |
Algorithmus | "RS256" |
kid |
Schlüssel-ID |
Muss mit einem der öffentlichen Schlüssel übereinstimmen, die unter https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com aufgeführt sind.
|
Überprüfen Sie, ob die Nutzlast des ID-Tokens die folgenden Einschränkungen einhält:
Claims in der Nutzlast des ID-Tokens | ||
---|---|---|
exp |
Ablaufzeit | Muss in der Zukunft liegen. Die Zeit wird in Sekunden seit der UNIX-Epoche gemessen. |
iat |
Ausstellungszeit | Muss in der Vergangenheit liegen.j Die Zeit wird in Sekunden seit der UNIX-Epoche gemessen. |
aud |
Zielgruppe | Dies muss die Firebase-Projekt-ID sein, die eindeutige Kennung für Ihr Firebase-Projekt. Sie finden sie in der URL der Console des Projekts. |
iss |
Aussteller |
Muss "https://securetoken.google.com/<projectId>" sein. Dabei ist <projectId> dieselbe Projekt-ID wie oben für aud verwendet.
|
sub |
Betreff |
Muss ein nicht leerer String sein und muss der uid des Nutzers oder Geräts sein.
|
auth_time
|
Authentifizierungszeit | Muss in der Vergangenheit liegen.j Die Zeit, zu der sich der Nutzer authentifiziert hat. |
Prüfen Sie abschließend, ob das ID-Token mit dem privaten Schlüssel signiert wurde, der der Anforderung kid
des Tokens entspricht. Rufe den öffentlichen Schlüssel von https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com
ab und verwende eine JWT-Bibliothek, um die Signatur zu überprüfen. Anhand des Werts von max-age
im Cache-Control
-Header der Antwort von diesem Endpunkt kannst du ermitteln, wann die öffentlichen Schlüssel aktualisiert werden müssen.
Wenn alle oben genannten Prüfungen erfolgreich abgeschlossen wurden, kannst du den Antragsteller (sub
) des ID-Tokens als uid
des entsprechenden Nutzers oder Geräts verwenden.