Verifica tokens de ID

Si tu app cliente de Firebase se comunica con un servidor de backend personalizado, es posible que debas identificar al usuario con una sesión activa en ese servidor. Para hacerlo de forma segura, después de un acceso correcto, envía el token de ID del usuario al servidor mediante HTTPS. Luego, en el servidor, verifica la integridad y la autenticidad del token de ID y recupera su uid. Puedes utilizar el uid transmitido de esta manera para identificar de forma segura al usuario con una sesión activa en el servidor.

Antes de comenzar

Para verificar los tokens de ID con el SDK de Firebase Admin, debes tener una cuenta de servicio. Sigue las instrucciones de configuración del SDK de administrador para obtener más información sobre cómo inicializarlo con una cuenta de servicio.

Recupera tokens de ID en los clientes

Cuando un usuario o un dispositivo accede correctamente, Firebase crea un token de ID correspondiente que lo identifica de forma única y le otorga acceso a varios recursos, como Firebase Realtime Database y Cloud Storage. Puedes volver a usar el token de ID para identificar al usuario o dispositivo en tu servidor de back-end personalizado. Para recuperar el token de ID del cliente, asegúrate de que el usuario haya accedido y después obtén el token de ID del usuario con sesión activa:

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

Una vez que tienes un token de ID, puedes enviar ese JWT a tu back-end y validarlo con el SDK de Firebase Admin o usar una biblioteca JWT de terceros si tu servidor está escrito en un lenguaje no compatible con Firebase de forma nativa.

Verifica los tokens de ID con el SDK de Firebase Admin

El SDK de Firebase Admin tiene un método integrado para verificar y decodificar tokens de ID. Si el token de ID proporcionado tiene el formato correcto, no está vencido y tiene la firma adecuada, el método muestra el token de ID decodificado. Puedes obtener el uid del usuario o dispositivo a partir del token decodificado.

Sigue las instrucciones de configuración del SDK de Admin para inicializarlo con una cuenta de servicio. Luego, usa el método verifyIdToken() para verificar un token de ID:

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

Para verificar tokens de ID, es obligatorio contar con un ID del proyecto. El SDK de Firebase Admin intenta obtenerlo a través de uno de los siguientes métodos:

• Si se inicializó el SDK con la opción projectId explícita de la app, este usa el valor de esa opción.
• Si se inicializó el SDK con credenciales de cuenta de servicio, este usa el campo project_id del objeto JSON de la cuenta de servicio.
• Si se definió la variable de entorno GOOGLE_CLOUD_PROJECT, el SDK usa su valor como ID del proyecto. Esta variable de entorno se encuentra disponible para el código que se ejecuta en una infraestructura de Google, como App Engine o Compute Engine.

Verifica los tokens de ID con una biblioteca de JWT de terceros

Si tu back-end está en un lenguaje no compatible con el SDK de Firebase Admin, puedes verificar tokens de ID de todas formas. En primer lugar, busca una biblioteca JWT de terceros para tu lenguaje. A continuación, verifica el encabezado, la carga útil y la firma del token de ID.

Verifica que el encabezado del token de ID cumpla con las siguientes restricciones:

Verifica que la carga útil del token de ID cumpla con las siguientes restricciones:

Por último, asegúrate de que el token de ID tenga la firma de la clave privada correspondiente a la reclamación kid del token. Obtén la clave pública de https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com y usa una biblioteca de JWT para verificar la firma. Usa el valor de max-age en el encabezado Cache-Control de la respuesta proveniente de ese extremo para determinar cuándo actualizar las claves públicas.

Si se ejecutan correctamente todas las verificaciones anteriores, puedes usar el asunto (sub) del token de ID como el uid del usuario o dispositivo correspondiente.