Verifica i token ID

Se la tua app client Firebase comunica con un server backend personalizzato, potrebbe essere necessario identificare l'utente attualmente connesso su quel server. Per farlo in modo sicuro, dopo aver effettuato correttamente l'accesso, invia il token ID dell'utente al tuo server utilizzando HTTPS. Quindi, sul server, verificare l'integrità e l'autenticità del token ID e recuperare l' uid da esso. Puoi utilizzare l' uid trasmesso in questo modo per identificare in modo sicuro l'utente attualmente connesso al tuo server.

Prima di iniziare

Per verificare i token ID con Firebase Admin SDK, devi disporre di un account di servizio. Segui le istruzioni di configurazione dell'Admin SDK per ulteriori informazioni su come inizializzare l'Admin SDK con un account di servizio.

Recupera i token ID sui client

Quando un utente o un dispositivo accede correttamente, Firebase crea un token ID corrispondente che lo identifica in modo univoco e concede loro l'accesso a diverse risorse, come Firebase Realtime Database e Cloud Storage. Puoi riutilizzare quel token ID per identificare l'utente o il dispositivo sul tuo server backend personalizzato. Per recuperare il token ID dal client, assicurati che l'utente abbia effettuato l'accesso, quindi ottieni il token ID dall'utente che ha effettuato l'accesso:

iOS+

Obiettivo-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
          // ...
}];
Veloce
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
  // ...
}

Androide

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

Unità

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

ragnatela

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

Una volta ottenuto un token ID, puoi inviare quel JWT al tuo backend e convalidarlo utilizzando Firebase Admin SDK o utilizzando una libreria JWT di terze parti se il tuo server è scritto in una lingua che Firebase non supporta nativamente.

Verifica i token ID utilizzando l'SDK Admin Firebase

Firebase Admin SDK dispone di un metodo integrato per verificare e decodificare i token ID. Se il token ID fornito ha il formato corretto, non è scaduto ed è firmato correttamente, il metodo restituisce il token ID decodificato. Puoi prendere l' uid dell'utente o del dispositivo dal token decodificato.

Segui le istruzioni di configurazione dell'Admin SDK per inizializzare l'Admin SDK con un account di servizio. Quindi, utilizza il metodo verifyIdToken() per verificare un token ID:

Node.js

// idToken comes from the client app
getAuth()
  .verifyIdToken(idToken)
  .then((decodedToken) => {
    const uid = decodedToken.uid;
    // ...
  })
  .catch((error) => {
    // Handle error
  });

Giava

// idToken comes from the client app (shown above)
FirebaseToken decodedToken = FirebaseAuth.getInstance().verifyIdToken(idToken);
String uid = decodedToken.getUid();

Pitone

# id_token comes from the client app (shown above)

decoded_token = auth.verify_id_token(id_token)
uid = decoded_token['uid']

Andare

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;

La verifica del token ID richiede un ID progetto. L'SDK Admin Firebase tenta di ottenere un ID progetto tramite uno dei seguenti metodi:

  • Se l'SDK è stato inizializzato con un'opzione app projectId esplicita, l'SDK utilizza il valore di tale opzione.
  • Se l'SDK è stato inizializzato con le credenziali dell'account di servizio, l'SDK utilizza il campo project_id dell'oggetto JSON dell'account di servizio.
  • Se la variabile di ambiente GOOGLE_CLOUD_PROJECT è impostata, l'SDK utilizza il suo valore come ID progetto. Questa variabile di ambiente è disponibile per il codice in esecuzione sull'infrastruttura Google come App Engine e Compute Engine.

Verifica i token ID utilizzando una libreria JWT di terze parti

Se il tuo backend è in una lingua non supportata dall'SDK Admin Firebase, puoi comunque verificare i token ID. Innanzitutto, trova una libreria JWT di terze parti per la tua lingua . Quindi, verifica l'intestazione, il payload e la firma del token ID.

Verifica che l'intestazione del token ID sia conforme ai seguenti vincoli:

Attestazioni di intestazione del token ID
alg Algoritmo "RS256"
kid ID chiave Deve corrispondere a una delle chiavi pubbliche elencate su https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com

Verifica che il payload del token ID sia conforme ai seguenti vincoli:

Richieste di payload del token ID
exp Data di scadenza Deve essere in futuro. Il tempo è misurato in secondi dall'epoca UNIX.
iat Rilasciato in tempo Deve essere nel passato. Il tempo è misurato in secondi dall'epoca UNIX.
aud Pubblico Deve essere l'ID del tuo progetto Firebase, l'identificatore univoco del tuo progetto Firebase, che può essere trovato nell'URL della console di quel progetto.
iss Emittente Deve essere "https://securetoken.google.com/<projectId>" , dove <projectId> è lo stesso ID progetto utilizzato per aud sopra.
sub Soggetto Deve essere una stringa non vuota e deve essere l' uid dell'utente o del dispositivo.
auth_time Orario di autenticazione Deve essere nel passato. L'ora in cui l'utente si è autenticato.

Infine, assicurati che il token ID sia stato firmato dalla chiave privata corrispondente all'attestazione kid del token. Prendi la chiave pubblica da https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com e utilizza una libreria JWT per verificare la firma. Utilizza il valore di max-age nell'intestazione Cache-Control della risposta da quell'endpoint per sapere quando aggiornare le chiavi pubbliche.

Se tutte le verifiche di cui sopra hanno esito positivo, è possibile utilizzare l'oggetto ( sub ) del token ID come uid dell'utente o dispositivo corrispondente.