Verifica token ID

Se l'app client Firebase comunica con un server di backend personalizzato, potresti dover identificare l'utente attualmente connesso su quel server. Per farlo in modo sicuro, dopo un accesso riuscito, invia l'ID token dell'utente al tuo server utilizzando HTTPS. Poi, sul server, verifica l'integrità e l'autenticità del token ID e recupera da esso il valore uid. Puoi utilizzare il uid trasmesso in questo modo per identificare in modo sicuro l'utente che ha eseguito l'accesso al tuo server.

Nota: molti casi d'uso per la verifica dei token ID sul server possono essere eseguiti utilizzando le regole di sicurezza per Firebase Realtime Database e Cloud Storage. Verifica se questi metodi risolvono il problema prima di verificare autonomamente gli ID token.

Avviso: i metodi di verifica degli ID token inclusi negli SDK Firebase Admin sono destinati a verificare gli ID token provenienti dagli SDK client, non i token personalizzati che crei con gli SDK Admin. Per ulteriori informazioni, consulta la sezione Token di autenticazione.

Prima di iniziare

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

Recuperare i token di identità sui client

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

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

Web

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 il JWT al tuo backend e convalidarlo utilizzando l'SDK Firebase Admin o una libreria JWT di terze parti se il tuo server è scritto in un linguaggio non supportato in modo nativo da Firebase.

Verificare i token ID utilizzando l'SDK Firebase Admin

L'SDK Firebase Admin dispone di un metodo integrato per la verifica e la decodifica dei token ID. Se il token ID fornito ha il formato corretto, non è scaduto ed è firmato correttamente, il metodo restituisce il token ID decodificato. Puoi recuperare il valore uid dell'utente o del dispositivo dal token decodificato.

Nota: non viene controllato se il token è stato revocato o meno. Consulta Rilevare la revoca del token ID.

Segui le istruzioni di configurazione dell'SDK Admin per inizializzare l'SDK Admin 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
  });

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']

Vai

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;

La verifica del token di identità richiede un ID progetto. L'SDK Firebase Admin 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 questa opzione.
• Se l'SDK è stato inizializzato con le credenziali dell'account di servizio, 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 di Google, ad esempio App Engine e Compute Engine.

Verificare i token ID utilizzando una libreria JWT di terze parti

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

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

Claim dell'intestazione dell'ID token
alg	Algoritmo	"RS256"
kid	ID chiave	Deve corrispondere a una delle chiavi pubbliche elencate in https://www.googleapis.com/robot/v1/metadata/x509/[e-mail]

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

Dichiarazioni del payload dell'ID token
exp	Scadenza	Deve essere una data futura. Il tempo viene misurato in secondi dall'epoca UNIX.
iat	Data/ora di emissione	Deve essere nel passato. Il tempo viene misurato in secondi dall'epoca UNIX.
aud	Pubblico	Deve essere l'ID progetto Firebase, ovvero l'identificatore univoco del progetto Firebase, che puoi trovare nell'URL della console del progetto.
iss	Emittente	Deve essere "https://securetoken.google.com/<projectId>", dove <projectId> è lo stesso ID progetto utilizzato per aud sopra.
sub	Oggetto	Deve essere una stringa non vuota e deve essere il uid dell'utente o del dispositivo.
auth_time	Ora 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 alla rivendicazione kid del token. Recupera la chiave pubblica da https://www.googleapis.com/robot/v1/metadata/x509/[e-mail] e utilizza una libreria JWT per verificare la firma. Utilizza il valore di max-age nell'intestazione Cache-Control della risposta dell'endpoint per sapere quando aggiornare le chiavi pubbliche.

Se tutte le verifiche precedenti sono andate a buon fine, puoi utilizzare l'oggetto (sub) del token ID come uid dell'utente o del dispositivo corrispondente.