Ta strona została przetłumaczona przez Cloud Translation API.

Zweryfikuj tokeny tożsamości

Jeśli aplikacja kliencka Firebase komunikuje się z niestandardowym serwerem zaplecza, konieczne może być zidentyfikowanie aktualnie zalogowanego użytkownika na tym serwerze. Aby to zrobić w bezpieczny sposób, po pomyślnym zalogowaniu się wyślij token identyfikacyjny użytkownika do serwera za pomocą protokołu HTTPS. Następnie na serwerze sprawdź integralność i autentyczność tokena identyfikatora i pobierz z niego uid. Dzięki przekazywanym w ten sposób danym uid możesz bezpiecznie zidentyfikować aktualnie zalogowanego użytkownika na serwerze.

Zanim zaczniesz

Aby weryfikować tokeny identyfikatora za pomocą pakietu Firebase Admin SDK, musisz mieć konto usługi. Aby dowiedzieć się więcej o inicjowaniu pakietu Admin SDK za pomocą konta usługi, postępuj zgodnie z instrukcjami konfiguracji pakietu Admin SDK.

Pobieranie tokenów identyfikacyjnych na klientach

Gdy użytkownik lub urządzenie zaloguje się, Firebase tworzy odpowiedni token identyfikatora, który jednoznacznie go identyfikuje i pozwala na dostęp do kilku zasobów, takich jak Firebase Realtime Database i Cloud Storage. Możesz ponownie użyć tego tokena identyfikatora, aby zidentyfikować użytkownika lub urządzenie na niestandardowym serwerze backendu. Aby pobrać token identyfikatora z klienta, zaloguj się, a potem pobierz token identyfikatora od zalogowanego użytkownika:

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

Sieć

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

Gdy masz już token identyfikacyjny, możesz wysłać go w formacie JWT do backendu i potwierdzić za pomocą pakietu Firebase Admin SDK lub biblioteki JWT innej firmy, jeśli Twój serwer jest napisany w języku, którego Firebase nie obsługuje natywnie.

Weryfikowanie tokenów identyfikacyjnych za pomocą pakietu Firebase Admin SDK

Pakiet Admin SDK Firebase zawiera wbudowaną metodę weryfikacji i dekodowania tokenów identyfikacyjnych. Jeśli podany token identyfikacji ma prawidłowy format, nie wygasł i jest prawidłowo podpisany, metoda zwraca odkodowany token identyfikacji. Możesz pobrać uid użytkownika lub urządzenia ze zdekodowanego tokena.

Postępuj zgodnie z instrukcjami konfiguracji pakietu Admin SDK, aby zainicjować pakiet Admin SDK za pomocą konta usługi. Następnie użyj metody verifyIdToken() do zweryfikowania tokena identyfikacyjnego:

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;

Weryfikacja tokena identyfikacyjnego wymaga identyfikatora projektu. Pakiet Firebase Admin SDK próbuje uzyskać identyfikator projektu za pomocą jednej z tych metod:

Jeśli pakiet SDK został zainicjowany za pomocą opcji aplikacji projectId, pakiet SDK używa wartości tej opcji.
Jeśli pakiet SDK został zainicjowany za pomocą danych logowania do konta usługi, używa on pola project_id obiektu JSON konta usługi.
Jeśli zmienna środowiskowa GOOGLE_CLOUD_PROJECT jest ustawiona, pakiet SDK używa jej wartości jako identyfikatora projektu. Ta zmienna środowiskowa jest dostępna dla kodu działającego w infrastrukturze Google, np. App Engine i Compute Engine.

Weryfikowanie tokenów tożsamości za pomocą biblioteki JWT innej firmy

Jeśli backend jest w języku, który nie jest obsługiwany przez pakiet SDK Firebase Admin, nadal możesz weryfikować tokeny identyfikacyjne. Najpierw znajdź bibliotekę JWT innej firmy w odpowiednim języku. Następnie zweryfikuj nagłówek, ładunek i podpis tokena ID.

Sprawdź, czy nagłówek tokena ID jest zgodny z tymi ograniczeniami:

Deklaracje w nagłówku tokena identyfikacyjnego
`alg`	Algorytm	`"RS256"`
`kid`	Identyfikator klucza	Musi być zgodny z jednym z kluczy publicznych wymienionych na stronie `https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com`

Sprawdź, czy ładunek tokenu ID jest zgodny z tymi ograniczeniami:

Deklaracje w załadunku tokena identyfikacyjnego
`exp`	Okres ważności	Musi być w przyszłości. Czas jest mierzony w sekundach od początku epoki UNIX.
`iat`	Issued-at time	Musi być w przeszłości. Czas jest mierzony w sekundach od początku epoki UNIX.
`aud`	Odbiorcy	Musi to być identyfikator Twojego projektu Firebase, czyli unikalny identyfikator Twojego projektu Firebase, który znajdziesz w adresie URL konsoli tego projektu.
`iss`	Wystawca	Musi być to `"https://securetoken.google.com/<projectId>"`, gdzie `<projectId>` to identyfikator projektu użyty w przypadku `aud` powyżej.
`sub`	Temat	Musi być niepustym ciągiem znaków i musi być `uid` użytkownika lub urządzenia.
`auth_time`	Czas uwierzytelniania	Musi być w przeszłości. Czas, w którym użytkownik został uwierzytelniony.

Na koniec sprawdź, czy token ID został podpisany kluczem prywatnym odpowiadającym twierdzeniu kid w tokenie. Pobierz klucz publiczny z poziomu https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com i użyj biblioteki JWT do zweryfikowania podpisu. Aby wiedzieć, kiedy odświeżyć klucze publiczne, użyj wartości max-age w nagłówku Cache-Control odpowiedzi z tego punktu końcowego.

Jeśli wszystkie powyższe weryfikacje się zakończą, możesz użyć tematu (sub) tokena tożsamości jako elementu uid odpowiedniego użytkownika lub urządzenia.