Zweryfikuj tokeny tożsamości

Jeśli aplikacja kliencka Firebase komunikuje się z niestandardowym serwerem backendu, może być konieczne zidentyfikowanie na tym serwerze aktualnie zalogowanego użytkownika. Aby zrobić to bezpiecznie, po udanym zalogowaniu wyślij token identyfikacji użytkownika na swój serwer, używając protokołu HTTPS. Następnie na serwerze sprawdź integralność i autentyczność tokena identyfikatora i pobierz z niego uid. Możesz użyć przesłanego w ten sposób parametru uid, aby bezpiecznie zidentyfikować zalogowanego użytkownika na serwerze.

Zanim zaczniesz

Aby weryfikować tokeny identyfikacji za pomocą pakietu Firebase Admin SDK, musisz mieć konto usługi. Więcej informacji o inicjowaniu pakietu Admin SDK za pomocą konta usługi znajdziesz w instrukcjach konfiguracji pakietu Admin SDK.

Pobieranie tokenów identyfikacyjnych na klientach

Gdy użytkownik lub urządzenie pomyślnie się zaloguje, Firebase tworzy odpowiedni token identyfikacji, który jednoznacznie identyfikuje użytkownika lub urządzenie i przyznaje dostęp do kilku zasobów, takich jak Firebase Realtime Database i Cloud Storage. Możesz użyć tego tokena identyfikacji do zidentyfikowania użytkownika lub urządzenia na niestandardowym serwerze backendu. Aby pobrać token identyfikacji z klienta, upewnij się, że użytkownik jest zalogowany, a następnie pobierz token identyfikacji zalogowanego użytkownika:

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

Gdy masz już token identyfikacji, możesz wysłać ten token internetowy JSON (JWT) do backendu i zweryfikować go 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 identyfikatora za pomocą pakietu Firebase Admin SDK

Pakiet Firebase Admin SDK ma wbudowaną metodę weryfikacji i dekodowania tokenów identyfikacji. Jeśli podany token identyfikacji ma prawidłowy format, nie wygasł i jest prawidłowo podpisany, metoda zwraca zdekodowany token identyfikacji. Możesz pobrać uid użytkownika lub urządzenia z dekodowanego 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(), aby zweryfikować token identyfikacji:

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

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

• Jeśli pakiet SDK został zainicjowany z wyraźną opcją aplikacji projectId, używa wartości tej opcji.
• Jeśli pakiet SDK został zainicjowany przy użyciu 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, takiej jak App Engine i Compute Engine.

Weryfikowanie tokenów identyfikatora za pomocą biblioteki JWT innej firmy

Jeśli Twój backend jest w języku nieobsługiwanym przez pakiet Firebase Admin SDK, nadal możesz weryfikować tokeny identyfikacji. Najpierw znajdź bibliotekę JWT innej firmy dla swojego języka. Następnie zweryfikuj nagłówek, ładunek i podpis tokena identyfikacji.

Sprawdź, czy nagłówek tokena identyfikacji spełnia te wymagania:

Sprawdź, czy ładunek tokena identyfikacji spełnia te wymagania:

Na koniec sprawdź, czy token identyfikacji został podpisany kluczem prywatnym odpowiadającym twierdzeniu kid tokena. Pobierz klucz publiczny z https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com i użyj biblioteki JWT, aby zweryfikować podpis. Aby dowiedzieć się, 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 zakończą się powodzeniem, możesz użyć podmiotu (sub) tokena identyfikacji jako uid odpowiedniego użytkownika lub urządzenia.