Zweryfikuj tokeny tożsamości

Jeśli aplikacja kliencka Firebase komunikuje się z niestandardowym serwerem backendu, może być konieczne zidentyfikowanie użytkownika aktualnie zalogowanego na tym serwerze. Aby bezpiecznie to zrobić, po udanym zalogowaniu się wyślij token identyfikatora użytkownika na swój serwer przy użyciu HTTPS. Następnie na serwerze sprawdź integralność i autentyczność tokena identyfikatora i pobierz z niego uid. Możesz korzystać z uid przesyłanych w ten sposób do bezpiecznej identyfikacji obecnie zalogowanego użytkownika na serwerze.

Zanim zaczniesz

Aby weryfikować tokeny tożsamości za pomocą pakietu Firebase Admin SDK, musisz mieć konto usługi. Postępuj zgodnie z instrukcjami konfiguracji pakietu Admin SDK, aby dowiedzieć się więcej o tym, jak zainicjować pakiet Admin SDK na koncie usługi.

Pobieranie tokenów tożsamości z klientów

Gdy użytkownik lub urządzenie poprawnie się zaloguje, Firebase tworzy odpowiedni token identyfikatora, który jednoznacznie identyfikuje go i przyznaje dostęp do kilku zasobów, takich jak Baza danych czasu rzeczywistego Firebase 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
  // ...
}

Internet

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

Po uzyskaniu tokena identyfikatora możesz wysłać go do backendu i zweryfikować za pomocą pakietu SDK Firebase Admin lub użyć biblioteki JWT innej firmy, jeśli serwer jest napisany w języku, którego Firebase nie obsługuje natywnie.

Weryfikowanie tokenów tożsamości za pomocą pakietu SDK Firebase Admin

Pakiet SDK Firebase Admin ma wbudowaną metodę weryfikacji i dekodowania tokenów identyfikacyjnych. Jeśli podany token identyfikatora ma prawidłowy format, nie stracił ważności i jest prawidłowo podpisany, metoda zwraca zdekodowany token identyfikatora. 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 za pomocą metody verifyIdToken() zweryfikuj token tożsamości:

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 tożsamości wymaga identyfikatora projektu. Pakiet SDK Firebase Admin próbuje uzyskać identyfikator projektu, korzystając z jednej z tych metod:

Jeśli pakiet SDK został zainicjowany z użyciem jawnej opcji aplikacji projectId, pakiet SDK używa wartości tej opcji.
Jeśli pakiet SDK został zainicjowany z użyciem danych logowania konta usługi, używa 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 do kodu działającego w infrastrukturze Google, takiej jak App Engine i Compute Engine.

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

Nawet jeśli język backendu nie jest obsługiwany przez pakiet SDK Firebase Admin, możesz weryfikować tokeny identyfikatorów. Najpierw znajdź zewnętrzną bibliotekę JWT dla swojego języka. Następnie zweryfikuj nagłówek, ładunek i podpis tokena identyfikatora.

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

Żądania nagłówka tokena identyfikatora
`alg`	Algorytm	`"RS256"`
`kid`	Identyfikator klucza	Musi odpowiadać jednemu z kluczy publicznych wymienionych w `https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com`

Sprawdź, czy ładunek tokena identyfikatora jest zgodny z tymi ograniczeniami:

Żądania ładunku tokena identyfikatora
`exp`	Okres ważności	Musi być w przyszłości. Czas jest mierzony w sekundach od początku epoki UNIX.
`iat`	Wystawiony w momencie	Musi przypadać w przeszłości. Czas jest mierzony w sekundach od początku epoki UNIX.
`aud`	Odbiorcy	Musi to być identyfikator projektu Firebase, czyli unikalny identyfikator projektu Firebase, który znajdziesz w adresie URL konsoli tego projektu.
`iss`	Wystawca	Musi to być `"https://securetoken.google.com/<projectId>"`, gdzie `<projectId>` to ten sam identyfikator projektu, który został użyty w projekcie `aud` powyżej.
`sub`	Temat	Nie może być pusty i musi być identyfikatorem `uid` użytkownika lub urządzenia.
`auth_time`	Czas uwierzytelniania	Musi przypadać w przeszłości. Czas uwierzytelnienia użytkownika.

Na koniec sprawdź, czy token identyfikatora został podpisany przez klucz prywatny odpowiadający deklaracji 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. Użyj wartości max-age w nagłówku Cache-Control odpowiedzi z tego punktu końcowego, aby dowiedzieć się, kiedy odświeżać klucze publiczne.

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.