Auth0.swift: Guardar y renovar tokens

Mantener la sesión del usuario iniciada con Auth0.swift

Si la autenticación se realiza con el scope offline_access, se devolverá un Token de actualización que puede usarse para solicitar un nuevo token sin volver a pedir credenciales.

Credentials Manager

Auth0.swift proporciona una clase de utilidad para simplificar el proceso de almacenamiento y renovación de credenciales. Puede acceder a las propiedades accessToken o idToken desde la instancia de Credentials. Este es el método preferido para gestionar las credenciales del usuario.

Primero, importe el módulo Auth0:

import Auth0

A continuación, muestre la página de Universal Login:

let credentialsManager = CredentialsManager(authentication: Auth0.authentication())

Auth0
    .webAuth()
    .scope("openid profile offline_access")
    .start { result in
        switch result {
        case .success(let credentials):
            // Pasar las credenciales al Credentials Manager
            credentialsManager.store(credentials: credentials)
        case .failure(let error):
            // Manejar el error
        }
}

Los elementos del Keychain no se eliminan al desinstalar la aplicación. Recomendamos borrar siempre todos los elementos del Keychain de tu aplicación en el primer inicio.

Verificación de credenciales

Puede ser útil realizar una comprobación rápida al iniciar la aplicación para asegurarse de que haya credenciales renovables almacenadas en el administrador. De lo contrario, se puede redirigir al usuario para que se autentique.

guard credentialsManager.canRenew() else {
    // Mostrar página de inicio de sesión
}

Recuperar las credenciales del usuario

Puedes recuperar las credenciales del usuario de la siguiente manera:

credentialsManager.credentials { result in 
    switch result {
    case .success(let credentials):
        // Credenciales válidas; puedes acceder a las propiedades del token como
        // `idToken`, `accessToken`
    case .failure(let error):
        // Manejar el error, mostrar la página de inicio de sesión
    }
}

Renovar las credenciales de un usuario funciona exactamente igual si el token ha expirado. El Credentials Manager renovará automáticamente las credenciales, almacenará las credenciales renovadas en el Keychain y luego devolverá un Result con las credenciales o un error.

Método alternativo - SimpleKeychain

Esta sección está dirigida a desarrolladores que prefieren no usar Credentials Manager. Incluimos la utilidad SimpleKeychain —una capa ligera sobre el Keychain del sistema— que puede usarse para almacenar los tokens de forma segura.

Primero, importe el módulo SimpleKeychain:

import SimpleKeychain

A continuación, cree una instancia y almacene los tokens que necesite. En este caso, almacenará el access_token y el refresh_token en el Keychain después de una autenticación correcta.

let keychain = SimpleKeychain(service: "Auth0")

Auth0
    .webAuth()
    .scope("openid profile offline_access")
    .start { result in
        switch result {
        case .success(let credentials):
            guard let refreshToken = credentials.refreshToken else { 
                // Manejar el error 
                return
            }
            // Almacenar los tokens
            do {
                try keychain.set(credentials.accessToken, forKey: "access_token")
                try keychain.set(refreshToken, forKey: "refresh_token")
            } catch {
                // Manejar el error
            }
            // En este punto, puede redirigir al flujo principal de su aplicación
        case .failure(let error):
            // Manejar el error
        }
}

Una vez almacenados, puedes solicitar en cualquier momento una nueva instancia de Credentials.

Renovar las credenciales del usuario

let keychain = SimpleKeychain(service: "Auth0")

Auth0
    .authentication()
    .renew(withRefreshToken: refreshToken)
    .start { result in
        switch(result) {
        case .success(let credentials):
            // Si tienes la rotación de Token de actualización habilitada, obtienes un 
            // nuevo token de actualización
            // De lo contrario, solo obtienes un nuevo token de acceso
            guard let refreshToken = credentials.refreshToken else { 
                // Gestionar el error 
                return
            }
            // Almacenar los nuevos tokens
            do {
                try keychain.set(credentials.accessToken, forKey: "access_token")
                try keychain.set(refreshToken, forKey: "refresh_token")
            } catch {
                // Gestionar el error
            }
        case .failure(let error):
            // Gestionar el error
        }
}