Zweryfikuj tokeny tożsamości

Jeśli aplikacja kliencka Firebase komunikuje się z niestandardowym serwerem backendu, może być konieczne zidentyfikowanie aktualnie zalogowanego użytkownika na tym serwerze. Aby to zrobić w bezpieczny sposób, po udanym zalogowaniu wyślij token identyfikacyjny użytkownika na serwer za pomocą protokołu HTTPS. Następnie na serwerze zweryfikuj integralność i autentyczność tokena identyfikacyjnego oraz pobierz z niego wartość uid. W ten sposób możesz bezpiecznie zidentyfikować aktualnie zalogowanego użytkownika na serwerze za pomocą przesłanego identyfikatora uid.

Zanim zaczniesz

Aby weryfikować tokeny identyfikacyjne 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 zaloguje się, Firebase utworzy odpowiedni token identyfikacyjny, który jednoznacznie identyfikuje użytkownika i przyznaje mu dostęp do kilku zasobów, takich jak Firebase Realtime Database i Cloud Storage. Możesz ponownie użyć tego tokena identyfikacyjnego, aby zidentyfikować użytkownika lub urządzenie na niestandardowym serwerze backendu. Aby pobrać token identyfikacyjny od klienta, upewnij się, że użytkownik jest zalogowany, a następnie pobierz token identyfikacyjny od 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 identyfikacyjny, możesz wysłać ten token sieciowy JSON (JWT) do backendu i zweryfikować go za pomocą pakietu Firebase Admin SDK lub biblioteki JWT innej firmy, jeśli serwer jest napisany w języku, którego Firebase nie obsługuje natywnie.

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

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

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

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

Do weryfikacji tokena identyfikacyjnego wymagany jest identyfikator 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, używa on wartości tej opcji.
• Jeśli pakiet SDK został zainicjowany za pomocą danych logowania konta usługi, używa on pola project_id obiektu JSON konta usługi.
• Jeśli ustawiona jest zmienna środowiskowa GOOGLE_CLOUD_PROJECT, pakiet SDK używa jej wartości jako identyfikatora projektu. Ta zmienna środowiskowa jest dostępna w przypadku kodu działającego w infrastrukturze Google, takiej jak App Engine i Compute Engine.

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

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

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

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

Na koniec upewnij się, że token identyfikacyjny został podpisany kluczem prywatnym odpowiadającym deklaracji kid tokena. Pobierz klucz publiczny ze strony 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ę pomyślnie, możesz użyć tematu (sub) tokena identyfikacyjnego jako identyfikatora uid odpowiedniego użytkownika lub urządzenia.