Esta página se ha traducido con Cloud Translation API.

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 iniciar sesión correctamente, 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 identificación y recupere el uid del mismo. Puede utilizar el uid transmitido de esta manera para identificar de forma segura al usuario que actualmente ha iniciado sesión en su servidor.

Antes de que empieces

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

Recuperar tokens de identificación de clientes

Cuando un usuario o dispositivo inicia sesión correctamente, Firebase crea un token de identificación correspondiente que lo identifica de forma única y le otorga acceso a varios recursos, como Firebase Realtime Database y Cloud Storage. Puede reutilizar ese token de identificación para identificar al usuario o dispositivo en su servidor backend personalizado. Para recuperar el token de identificación del cliente, asegúrese de que el usuario haya iniciado sesión y luego obtenga el token de identificación del usuario que inició 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.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 vez que tenga un token de identificación, puede enviar ese JWT a su backend y validarlo usando el SDK de administrador de Firebase o usando una biblioteca JWT de terceros si su servidor está escrito en un lenguaje que Firebase no admite de forma nativa.

Verificar tokens de identificación mediante el SDK de administrador de Firebase

El SDK de Firebase Admin tiene un método integrado para verificar y decodificar tokens de identificación. 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 obtener el uid del usuario o dispositivo del token decodificado.

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

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

Ir

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 verificación del token de identificación requiere una identificación del proyecto. El SDK de Firebase Admin intenta obtener un ID de proyecto mediante 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 utiliza el campo project_id del objeto JSON de la cuenta de servicio.
Si se establece la variable de entorno GOOGLE_CLOUD_PROJECT , el SDK utiliza 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 identificación utilizando una biblioteca JWT de terceros

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

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 tokens de identificación
`exp`	Tiempo de expiración	Debe ser en el futuro. El tiempo se mide en segundos desde la época UNIX.
`iat`	Emitido en el momento	Debe ser en el pasado. El tiempo se mide en segundos desde la época UNIX.
`aud`	Audiencia	Debe ser el ID de tu proyecto de Firebase, el identificador único de tu 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 que no esté vacía y debe ser el `uid` del usuario o dispositivo.
`auth_time`	tiempo de autenticación	Debe ser en el pasado. La hora en que el usuario se autenticó.

Finalmente, asegúrese de que el token de identificación esté firmado con la clave privada correspondiente al reclamo kid del token. Obtenga 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 punto final 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.