Realizar autenticaciones usando el Firebase Server SDK

Puedes usar el Firebase Server SDK para crear y verificar los tokens empleados para comunicar de manera segura información de autenticación entre apps y servidores de clientes, de la siguiente manera:

  • Creando tokens personalizados adecuados para integrar sistemas de autenticación personalizados con apps de Firebase. Consulta: Uso de un sistema personalizado de autenticación (iOS, Android y la Web).
  • Verificando tokens de ID, que se usan para pasar el usuario con sesión activa de una app cliente a un servidor de backend.

Nota: Los métodos de verificación de tokens de ID incluidos en el Firebase Server SDK no están pensados para verificar los tokens personalizados que crees con el Firebase Server SDK. Consulta Tokens de autenticación.

Antes de comenzar

Configura tu proyecto para que use el SDK del servidor Firebase. Al configurar tu proyecto, creas una nueva cuenta de servicio propia e inicializas un objeto FirebaseApp con las credenciales de esta.

Crear un token personalizado

Para agregar compatibilidad con Firebase Authentication para tu sistema de autenticación existente (iOS, Android o web), debes agregar un terminal al servidor de autenticación que acepte las credenciales de inicio de sesión, como un nombre de usuario y una contraseña. Si estas son válidas, se muestra un token personalizado. Este token es un token web JSON (JWT) firmado con la clave privada de tu cuenta de servicio.

El JWT personalizado que se obtiene de tu servidor se usa para autenticar un dispositivo de cliente. El contenido del JWT se incluirá en el objeto auth de tus reglas de seguridad de Firebase Realtime Database y del objeto request.auth de tus reglas de seguridad de Firebase Storage cuando dicho cliente intenta leer o escribir datos.

Puedes crear fácilmente un token personalizado con el SDK del servidor de Firebase para Java y Node.js o puedes usar una biblioteca JWT de propósito general.

Usa el SDK del servidor Firebase

Para crear un token personalizado con el Firebase Server SDK, pasar el ID de usuario único empleado por tu sistema de autenticación al método createCustomToken:

Java
String token = FirebaseAuth.getInstance().createCustomToken(userId);
Node.js
var token = firebase.auth().createCustomToken(userId);

Después de crear el token personalizado, envíalo a tu app cliente para aplicarlo a la autenticación con Firebase. La app cliente se autentica con el token personalizado llamando a signInWithCustomToken:

iOS

Objective-C
[[FIRAuth auth] signInWithCustomToken:customToken
                           completion:^(FIRUser *_Nullable user,
                                        NSError *_Nullable error) {
                             // ...
                           }];
Swift
FIRAuth.auth()?.signIn(withCustomToken: customToken ?? "") { (user, error) in
  // ...
}

Android

mAuth.signInWithCustomToken(mCustomToken)
        .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                Log.d(TAG, "signInWithCustomToken:onComplete:" + task.isSuccessful());

                // If sign in fails, display a message to the user. If sign in succeeds
                // the auth state listener will be notified and logic to handle the
                // signed in user can be handled in the listener.
                if (!task.isSuccessful()) {
                    Log.w(TAG, "signInWithCustomToken", task.getException());
                    Toast.makeText(CustomAuthActivity.this, "Authentication failed.",
                            Toast.LENGTH_SHORT).show();
                }
            }
        });

Web

firebase.auth().signInWithCustomToken(token).catch(function(error) {
  // Handle Errors here.
  var errorCode = error.code;
  var errorMessage = error.message;
  // ...
});

Si el acceso se produce con éxito, el objeto auth de tus reglas de seguridad de Firebase Realtime Database y el objeto request.auth de tus reglas de seguridad de Firebase Storage se definen y completan con el elemento uid del usuario.

También puedes especificar de forma opcional las reclamaciones adicionales para que se incluyan en el token personalizado. Estas reclamaciones estarán disponibles en los objetos auth y request.auth de tus reglas de seguridad. Por ejemplo:

Java
HashMap<String, Object> additionalClaims = new HashMap<String, Object>();
additionalClaims.put("premium_account", true);
token = FirebaseAuth.getInstance().createCustomToken(userId, additionalClaims);
Node.js
var auth = firebase.auth();
var token = auth.createCustomToken(userId, {"premium_account": true});

Luego, en tus reglas de seguridad de Firebase Realtime Database , puedes usar la reclamación adicional:

{
  "rules": {
    "premium_content": {
      ".read": "auth.premium_account === true"
    }
  }
}

Usa una biblioteca JWT

Puedes crear un token personalizado que sea adecuado para la autenticación con Firebase mediante cualquier biblioteca de creación de JWT. Crea un JWT que incluya las siguientes reclamaciones y esté firmado con RS256.

Reclamaciones de JWT
iss Dirección de correo electrónico de la cuenta de servicio de tu proyecto
sub Dirección de correo electrónico de la cuenta de servicio de tu proyecto
aud https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit
iat La hora actual en segundos
exp La hora, en segundos, en que el token caduca. Puede ser como máximo 3600 segundos posterior a iat.
uid Identificador único del usuario con sesión activa (debe ser una string que contenga entre 1 y 36 caracteres)
claims (opcional) Reclamaciones personalizadas que deben incluirse en la variable auth de las reglas de seguridad.
PHP

Usa php-jwt:

// Get your service account's email address and private key from the
// JSON key file
$service_account_email = "abc-123@a-b-c-123.iam.gserviceaccount.com";
$private_key = "-----BEGIN PRIVATE KEY-----...";

function create_custom_token($uid) {
  $now_seconds = time();
  $payload = array(
      "iss" => $service_account_email,
      "sub" => $service_account_email,
      "aud" => "https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit",
      "iat" => $now_seconds,
      "exp" => $now_seconds+(60*60),  // Maximum expiration time is one hour
      "uid" => $uid
  );
  return JWT::encode($payload, $private_key, "RS256");
}
Ruby

Uso de : ruby-jwt:

require 'jwt'

# Get your service account's email address and private key from the
# JSON key file
service_account_email = 'abc-123@a-b-c-123.iam.gserviceaccount.com'
private_key = '-----BEGIN PRIVATE KEY-----...'

def create_custom_token(uid)
  now_seconds = Time.now.to_i
  payload = {:iss => service_account_email,
             :sub => service_account_email,
             :aud => 'https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit',
             :iat => now_seconds,
             :exp => now_seconds+(60*60),  // Maximum expiration time is one hour
             :uid => uid}
  JWT.encode payload, private_key, 'RS256'
end

Después de crear el token personalizado, envíalo a tu app cliente para aplicarlo a la autenticación con Firebase.

Verificar tokens de ID

Si tu app de Firebase se comunica con un servidor de backend personalizado, podría ser necesario que identifiques el usuario con sesión activa actualmente en el servidor. Para hacerlo de manera segura, después de que un usuario inicie sesión con éxito, envía el token de ID a tu servidor usando HTTPS. Luego, en el servidor, verifica la integridad del token y recupera el ID único del usuario del token de ID. Puedes usar los uid de esta manera para identificar de manera segura el usuario con sesión iniciada actualmente en el backend.

Para verificar y decodificar un token de ID con el Firebase Server SDK, pasa el token de ID al método verifyIdToken. Si el token de ID no caducó y está firmado de manera adecuada, el método decodifica el token de ID.

Java
String idToken;  // Get the user's ID token from the client app

FirebaseAuth.getInstance().verifyIdToken(idToken)
    .addOnSuccessListener(new OnSuccessListener<FirebaseToken>() {
        @Override
        public void onSuccess(FirebaseToken decodedToken) {
          String uid = decodedToken.getUid();
          // ...
        }
});
Node.js
var firebase = require("firebase");
var auth = firebase.auth();
var idToken;  // Get the user's ID token from the client app

auth.verifyIdToken(idToken).then(function(decodedToken) {
  var uid = decodedToken.sub;
});

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.