Tutoriales

Tutorial: Sign In with Apple

Descubre cómo implementar el registro mediante el Apple ID

Resumen del artículo
  • En la pasado WWDC Apple lanzó su sistema de registro mediante el Apple ID. Ahora podemos autenticar a los usuarios de nuestras apps de forma segura y respetando su privacidad.

En la pasada WWDC, Apple sorprendió a propios y extraños presentado un sistema de registro de usuarios utilizando el Apple ID. La diferencia con otros método de registro es que éste ponía el foco en la privacidad y en la seguridad de lo usuarios.

Hace unos días, tal y como os comentamos, anunciaron que a partir del 30 de Abril será de obligada implementación en aplicaciones que utilicen algún login mediante redes sociales. Si es tu caso y aún no lo has implementado, no te preocupes, a continuación te mostramos las claves para hacerlo de forma sencilla.

Los cimientos del registro de Apple

Tal y como os hemos adelantado, todas las aplicaciones que dispongan de un sistema de registro mediante redes sociales, deberán implementar el Sign in with Apple y además este debe estar situado como la primera opción por encima de ellas.

Los principios del funcionamiento se basan en utilizar los métodos de autenticación biométrica (como el FaceID y el Touch ID) del que disponen los terminales de la manzana, para realizar el registro de usuarios de forma cómoda pero también segura para ellos.

También es posible utilizar autenticación mediante envío de códigos para aplicaciones web u otras plataformas, pero se sale de la implementación dentro de los sistemas de Apple y del tema que vamos a tratar hoy.

No nos olvidemos que los datos del usuario que nos ofrece este sistema se obtienen de su Apple ID y por el momento son bastante limitados. Además la interfaz del sistema mostrarán al usuario cada uno de ellos para que verifique la información y sepa en todo momento lo que está compartiendo con nosotros. Sin duda estas medidas hacen este sistema muy confiable y seguro que usuarios agradecen su implementación.

Configuración previa

En este tutorial usaremos la autenticación de Apple sobre una aplicación para iOS. Lo primero que necesitamos es añadir el framework al proyecto mediante un nueva Capability del mismo. Entramos en la configuración del target, pestaña Signing & Capabilities, pulsamos ‘+ Capability’ y añadimos Sing In with Apple.

Si todo ha ido bien, Xcode los incluirá los permisos necesarios en los certificados de nuestra aplicación y podremos empezar a usarlo. Ahora sí, importamos la librería en los ficheros que en lo que vayamos a realizar la implementación.

import AuthenticationServices

Creamos la petición

Como paso inicial en el código, añadiremos el botón a la interfaz. Imaginemos que tenemos varios métodos de registro con sus correspondientes botones dentro de una pila implementada con un UIStackView.

    let button = ASAuthorizationAppleIDButton()
    button.addTarget(self, action: #selector(registerWithApple), for: .touchUpInside)
    self.stackRegistro.addArrangedSubview(button)

Un vez creado el botón, indicamos que debe ejecutar la función registerWithApple cuando detecte una pulsación y por último añadimos el botón a la pila. El siguiente paso es implementar la función destino.

@objc
func registerWithApple() {
    let appleIDRequest = ASAuthorizationAppleIDProvider().createRequest()
    request.requestedScopes = [.fullName, .email]
    let passwordResquest = ASAuthorizationPasswordProvider().createRequest()

    let requests = [appleIDRequest, passwordResquest]
    
    let authController = ASAuthorizationController(authorizationRequests: requests)
    authController.delegate = self
    authController.presentationContextProvider = self
    authController.performRequest()
}

Debemos crear la petición y asignar el delegado donde recibiremos el resultado. Para ello primero creamos una petición appleIDRequest y mediante la propiedad requestedScopes indicamos los datos de usuario a los que queremos acceder. Después otra con passwordResquest que nos permitirá leer datos de login que pudiese haber guardado en el llavero de iCloud porque el usuario se haya registrado desde otro terminal o la web.

Agrupamos las peticiones, inicializamos el controlador para ellas y le asignamos los delegados. Uno para la respuesta y otro para la presentación de la interfaz. En la línea final ejecutamos las solicitudes.

Recibimos los datos

Veamos ahora el delegado para mostrar la interfaz. El framework presenta una vista modal dentro de un tipo UIWindow que le indicaremos mediante una función como la siguiente:

func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
    return self.view.window!
}
Demo de funcionalidad

Esto hace que al usuario se le presente la opción para el login, y si es la primera vez le aparecerá una pantalla informativa, donde podrá verificar y/o modificar los datos que está solicitando la aplicación. En las siguientes ocasiones simplemente se pedirá la verificación biométrica.

Si la identidad del usuario es correcta, recibiremos la llamada al delegado con la respuesta. De todo esto se encarga el propio sistema por lo que el desarrollador no tiene responsabilidad a la hora de realizar las verificaciones.

func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
        switch authorization.credential {
        case let credentials as ASAuthorizationAppleIDCredential:
            let userIdentifier = credentials.user
            let fullName = credentials.fullName
            let email = credentials.email

            self.saveUserInKeychain(userIdentifier)
            self.register(userIdentifier: userIdentifier, fullName: fullName, email: email)
        case let password as ASPasswordCredential:
            let username = password.user
            let password = password.password
            
            DispatchQueue.main.async {
                self.login(username: username, password: password)
            }
        default: break
        }
    }

El parámetro fundamental de esta delegación es authorization, cuya propiedad credential contiene enumeración con el tipo de acceso encontrado. Tenemos dos opciones: la primera es que sean unas credenciales proporcionadas por Sign In with Apple y la segunda es que se hayan encontrado credenciales almacenadas en el llavero de iCloud. Como se observa en el código, para la segunda opción usamos directamente las credenciales para iniciar sesión y no tiene mucho más misterio.

Pero para el primer caso, el tipo retornado ASAuthorizationAppleIDCredential nos devuelve los datos de usuario para realizar el registro. Además, debemos almacenar la propiedad user de cara al futuro para poder loguear al usuario de forma segura en posteriores ocasiones. Es importante saber que no es posible guardar el valor en los UserDefaults al tratarse de información privada. Habrá que recurrir al almacén de claves seguras.

Después podemos enviar los datos solicitados a nuestra plataforma para realizar el registro del usuario. Lo último, pero no menos importante, es que sólo se nos devolverá la información del usuario (correo, nombre…) en la primera llamada, si usamos el mismo código en posteriores ocasiones, tendremos el valor de la propiedad user pero no los datos del usuario.

Estado de la autenticación

Ya tenemos nuestro registro preparado, pero necesitamos conocer si el usuario está autenticado cuando intente volver a acceder a la aplicación. Para ello tenemos el método getCredentialState. Debemos indicarle como argumento el identificador que nos hemos guardado anteriormente que nos venía en la propiedad user.

let appleIDProvider = ASAuthorizationAppleIDProvider()
        appleIDProvider.getCredentialState(forUserID: KeychainItem.userIdentifier) { state, error in
            switch state {
            case .authorized:
                break
            case .revoked, .notFound:
                DispatchQueue.main.async {
                    self.window?.rootViewController?.goToLogin()
                }
            default: break
            }
        }

La respuesta nos devuelve un error si hay salido algo mal y un state donde una enumeración nos indica el estado actual de las credenciales. Tenemos los siguientes valores:

  • authorized La autenticación es correcta y podemos dar acceso usuario.
  • revoked El usuario ha eliminado el permiso para usar esta autenticación. Podemos hacer también durante el desarrollo entrando en Ajustes > iCloud > Contraseña y seguridad > Apps que utilizan tu ID de Apple.
  • notFound No se ha encontrado ninguna autenticación para ese identificador de usuario.

Manejaremos cada uno de los estados para dejar acceder o denegar el acceso a nuestra aplicación según corresponda.

Ya lo hemos logrado

Después de este tutorial podemos decir que el registro mediante Apple ID no es tan fiero como lo pintan. Su implementación es sencilla y proporciona un nivel de seguridad y privacidad para los usuarios que seguramente elimine la fricción existente en las aplicaciones a la hora de registrarse y compartir datos.

A este respecto, y al contrario que en otras ocasiones, Apple proporciona una documentación bastante extensa e incluso un proyecto de demostración. Podéis echarle un vistazo si necesitáis ampliar la información.

Esperamos que este tutorial haya sido de utilidad y que si tu aplicación se encuentra entre las que necesitan este registro de forma obligatoria, aún estés a tiempo de implementarlo. Un saludo y Good Apple Coding.

Arturo Rivas

Líder técnico especializado en mobile. Analista y desarrollador software. Apasionado de la tecnología, el deporte y la música.

Artículos relacionados

Botón volver arriba