获取我们在 Firebase 峰会上发布的所有信息,了解 Firebase 可如何帮助您加快应用开发速度并满怀信心地运行应用。了解详情

Verificar tokens de identificación

Si su aplicación cliente de Firebase se comunica con un servidor backend personalizado, es posible que deba identificar al usuario que actualmente inició sesión en ese servidor. Para hacerlo de forma segura, después de un inicio de sesión exitoso, envíe el token de identificación del usuario a su servidor mediante HTTPS. Luego, en el servidor, verifique la integridad y autenticidad del token de ID y recupere el uid de él. Puede utilizar el uid transmitido de esta manera para identificar de forma segura al usuario que ha iniciado sesión actualmente en su servidor.

Antes de que empieces

Para verificar los tokens de ID con el SDK de administrador de Firebase, debe tener una cuenta de servicio. Siga 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.

Recuperar tokens de ID en clientes

Cuando un usuario o dispositivo inicia sesión con éxito, Firebase crea un token de ID correspondiente que los identifica de manera única y les otorga acceso a varios recursos, como Firebase Realtime Database y Cloud Storage. Puede reutilizar ese token de ID para identificar al usuario o dispositivo en su servidor back-end personalizado. Para recuperar el token de ID del cliente, asegúrese de que el usuario haya iniciado sesión y luego obtenga el token de ID del usuario que ha iniciado sesión:

iOS+

C objetivo
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
          // ...
}];
Rápido
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();
            }
        }
    });

Unidad

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 tenga un token de ID, puede enviar ese JWT a su backend y validarlo con el SDK de administración de Firebase o con una biblioteca de JWT de terceros si su servidor está escrito en un idioma que Firebase no admite de forma nativa.

Verifica los tokens de ID con el SDK de administrador de Firebase

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 ha caducado y está firmado correctamente, el método devuelve el token de ID decodificado. Puede tomar el uid del usuario o dispositivo del token decodificado.

Siga las instrucciones de configuración del SDK de administrador para inicializar el SDK de administrador con una cuenta de servicio. Luego, use el método verificarIdToken verifyIdToken() para verificar un token de ID:

Nodo.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();

Pitón

# id_token comes from the client app (shown above)

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

Vamos

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 verificación del token de ID requiere un ID de proyecto. El SDK de Firebase Admin intenta obtener un ID de proyecto a través de uno de los siguientes métodos:

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

Verificar tokens de ID usando una biblioteca JWT de terceros

Si su backend está en un idioma que no es compatible con el SDK de administración de Firebase, aún puede verificar los tokens de ID. Primero, busque una biblioteca JWT de terceros para su idioma . Luego, verifique el encabezado, la carga útil y la firma del token de ID.

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

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

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

Reclamaciones de carga útil de token de identificación
exp Tiempo de expiración Debe ser en el futuro. El tiempo se mide en segundos desde la época de UNIX.
iat Emitido a tiempo Debe estar en el pasado. El tiempo se mide en segundos desde la época de UNIX.
aud Audiencia Debe ser su ID de proyecto de Firebase, el identificador único para su proyecto de Firebase, que se puede encontrar en la URL de la consola de ese proyecto.
iss Editor Debe ser "https://securetoken.google.com/<projectId>" , donde <projectId> es el mismo ID de proyecto utilizado para aud arriba.
sub Sujeto Debe ser una cadena no vacía y debe ser el uid del usuario o dispositivo.
auth_time tiempo de autenticación Debe estar en el pasado. La hora en que el usuario se autenticó.

Finalmente, asegúrese de que el token de ID haya sido firmado por la clave privada correspondiente al reclamo de kid del token. Tome la clave pública de https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com y use una biblioteca JWT para verificar la firma. Utilice el valor de max-age en el encabezado Cache-Control de la respuesta de ese extremo para saber cuándo actualizar las claves públicas.

Si todas las verificaciones anteriores son exitosas, puede usar el asunto ( sub ) del token de identificación como el uid del usuario o dispositivo correspondiente.