Verifica tokens de ID

Si tu app cliente de Firebase se comunica con un servidor de back-end 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 a tu servidor con HTTPS. Luego, en el servidor, verifica la integridad y la autenticidad del token de ID y recupera el uid de él. Puedes usar el uid que se transmite de esta manera para identificar de forma segura al usuario con una sesión activa en tu servidor.

Antes de comenzar

Para verificar los tokens de ID con el SDK de administrador de Firebase, 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 inicializar el SDK de administrador 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:

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 != nullptr) {
  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 vez que tienes un token de ID, puedes enviar ese JWT a tu back-end y validarlo con el SDK de administrador de Firebase 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 administrador de Firebase

El SDK de administrador de Firebase 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 el 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:

Node.js

// idToken comes from the client app (shown above)

admin.auth().verifyIdToken(idToken)
  .then(function(decodedToken) {
    var uid = decodedToken.uid;
    // ...
  }).catch(function(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(context.Background())
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 verificación de ID de tokens requiere un ID del proyecto. El SDK de Firebase Admin intenta obtener un ID del proyecto a través de uno de los siguientes métodos:

  • Si el SDK se inicializó con una opción explícita de app projectId, este usa el valor de esa opción.
  • Si el SDK se inicializó con credenciales de cuenta de servicio, este usa el campo project_id del objeto JSON de la cuenta de servicio.
  • Si la variable de entorno GOOGLE_CLOUD_PROJECT se define, el SDK usa su valor como el ID del proyecto. Esta variable de entorno está disponible para la ejecución de códigos en infraestructura de Google como Google App Engine y Google 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 administrador de Firebase, 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:

Reclamaciones del encabezado del token de ID
alg Algoritmo "RS256"
kid ID de clave Debe corresponder a una de las claves públicas que aparecen en https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com

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

Reclamaciones de la carga útil del token de ID
exp Hora de vencimiento Debe ser en el futuro. El tiempo se mide en segundos transcurridos desde el punto de inicio del tiempo UNIX.
iat Hora de emisión Debe ser en el pasado. El tiempo se mide en segundos transcurridos desde el punto de inicio del tiempo UNIX.
aud Público Debe ser el ID de tu proyecto de Firebase, el identificador único de tu proyecto de Firebase, que se encuentra en la URL de la consola de ese proyecto.
iss Emisor Debe ser "https://securetoken.google.com/<projectId>", donde <projectId> es el mismo ID de proyecto que se usó para aud previamente.
sub Asunto Debe ser una string que no esté vacía y debe ser el uid del usuario o el dispositivo.
auth_time Fecha de autenticación Debe ser en el pasado. La hora en que se autenticó el usuario.

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 JWT para verificar la firma. Usa el valor de max-age en el encabezado Cache-Control de la respuesta proveniente de ese extremo para saber cuándo actualizar las claves públicas.

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

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.