Catch up on everthing we announced at this year's Firebase Summit. Learn more

Verifica token ID ID

Se la tua 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 aver eseguito l'accesso, invia il token ID dell'utente al tuo server tramite HTTPS. Poi, sul server, verificare l'integrità e l'autenticità del ID token e recuperare uid da esso. È possibile utilizzare l' uid trasmesso in questo modo per identificare in modo sicuro al momento firmato-in utente sul server.

Prima di iniziare

Per verificare i token ID con Firebase Admin SDK, devi disporre di un account di servizio. Seguire le istruzioni di configurazione 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 di backend personalizzato. Per recuperare il token ID dal client, assicurati che l'utente abbia effettuato l'accesso e quindi ottieni il token ID dall'utente che ha eseguito 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
          // ...
}];
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();
            }
        }
    });

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 != nullptr) {
  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 che hai un token ID, puoi inviare quel JWT al tuo backend e convalidarlo utilizzando l'SDK di amministrazione di Firebase o utilizzando una libreria JWT di terze parti se il tuo server è scritto in una lingua che Firebase non supporta in modo nativo.

Verifica i token ID utilizzando l'SDK Firebase Admin

Firebase Admin SDK ha 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. È possibile afferrare uid dell'utente o dispositivo dal token decodificato.

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

Nodo.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. Firebase Admin SDK tenta di ottenere un ID progetto tramite uno dei seguenti metodi:

  • Se l'SDK è stato inizializzato con un esplicito projectId un'opzione app, l'SDK utilizza il valore di tale opzione.
  • Se l'SDK è stato inizializzato con credenziali di account di servizio, l'SDK utilizza il project_id campo dell'oggetto servizio di conto JSON.
  • Se il GOOGLE_CLOUD_PROJECT è impostato variabile d'ambiente, l'SDK utilizza il suo valore come l'ID del progetto. Questa variabile di ambiente è disponibile per il codice in esecuzione sull'infrastruttura di 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 da Firebase Admin SDK, puoi comunque verificare i token ID. In primo luogo, trovare una libreria JWT di terze parti per la propria lingua . Quindi, verifica l'intestazione, il payload e la firma del token ID.

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

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

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

Reclami sul carico utile del token ID
exp Data di scadenza Deve essere in futuro. Il tempo viene misurato in secondi dall'epoca UNIX.
iat Rilasciato al momento Deve essere nel passato. Il tempo viene misurato in secondi dall'epoca UNIX.
aud Pubblico Deve essere il tuo ID progetto Firebase, l'identificatore univoco per il 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 progetto ID utilizzato per aud sopra.
sub Soggetto Deve essere una stringa non vuota e deve essere uid dell'utente o dispositivo.
auth_time Tempo di autenticazione Deve essere nel passato. L'ora in cui l'utente si è autenticato.

Infine, assicurarsi che il token ID è stato firmato con la chiave privata corrispondente alla token kid reclamo. Prendete la chiave pubblica da https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com e utilizzare una libreria JWT per verificare la firma. Utilizzare il valore di max-age nella Cache-Control intestazione della risposta da quel punto finale di sapere quando per rinfrescare le chiavi pubbliche.

Se tutte le verifiche sopra sono successo, è possibile utilizzare l'oggetto ( sub ) dell'ID token come l' uid dell'utente o dispositivo corrispondente.