Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Autenticar usando Apple y C++

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Puede permitir que sus usuarios se autentiquen con Firebase usando su ID de Apple mediante el SDK de Firebase para llevar a cabo el flujo de inicio de sesión de OAuth 2.0 de un extremo a otro.

Antes de que empieces

Para que los usuarios inicien sesión con Apple, primero configure Iniciar sesión con Apple en el sitio para desarrolladores de Apple y luego habilite Apple como proveedor de inicio de sesión para su proyecto de Firebase.

Únase al programa de desarrolladores de Apple

Solo los miembros del Programa para desarrolladores de Apple pueden configurar Iniciar sesión con Apple.

Configurar Iniciar sesión con Apple

El inicio de sesión de Apple debe estar habilitado y configurado correctamente en su proyecto de Firebase. La configuración varía según las plataformas Android y Apple. Siga la sección "Configurar inicio de sesión con Apple" de las guías de las plataformas Apple y/o Android antes de continuar.

Habilitar Apple como proveedor de inicio de sesión

  1. En Firebase console , abra la sección Auth . En la pestaña Método de inicio de sesión , habilite el proveedor de Apple .
  2. Configure los ajustes del proveedor de inicio de sesión de Apple:
    1. Si está implementando su aplicación solo en plataformas de Apple, puede dejar vacíos los campos ID de servicio, ID de equipo de Apple, clave privada e ID de clave.
    2. Para soporte en dispositivos Android:
      1. Agregue Firebase a su proyecto de Android . Asegúrese de registrar la firma SHA-1 de su aplicación cuando configure su aplicación en Firebase console.
      2. En Firebase console , abra la sección Auth . En la pestaña Método de inicio de sesión , habilite el proveedor de Apple . Especifique el ID de servicio que creó en la sección anterior. Además, en la sección de configuración del flujo de código de OAuth, especifique su ID de equipo de Apple y la clave privada y la ID de clave que creó en la sección anterior.

Cumplir con los requisitos de datos anónimos de Apple

Iniciar sesión con Apple ofrece a los usuarios la opción de anonimizar sus datos, incluida su dirección de correo electrónico, al iniciar sesión. Los usuarios que eligen esta opción tienen direcciones de correo electrónico con el dominio privaterelay.appleid.com . Cuando usa Iniciar sesión con Apple en su aplicación, debe cumplir con las políticas de desarrollador aplicables o los términos de Apple con respecto a estas ID de Apple anonimizadas.

Esto incluye obtener cualquier consentimiento de usuario requerido antes de asociar cualquier información personal de identificación directa con una ID de Apple anonimizada. Al usar Firebase Authentication, esto puede incluir las siguientes acciones:

  • Vincule una dirección de correo electrónico a una ID de Apple anónima o viceversa.
  • Vincular un número de teléfono a una ID de Apple anonimizada o viceversa
  • Vincule una credencial social no anónima (Facebook, Google, etc.) a una ID de Apple anónima o viceversa.

La lista de arriba no es exhaustiva. Consulte el Acuerdo de licencia del Programa para desarrolladores de Apple en la sección Membresía de su cuenta de desarrollador para asegurarse de que su aplicación cumpla con los requisitos de Apple.

Accede a la firebase::auth::Auth

La clase Auth es la puerta de enlace para todas las llamadas a la API.
  1. Agregue los archivos de encabezado Auth y App:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. En su código de inicialización, cree una clase firebase::App .
    #if defined(__ANDROID__)
      firebase::App* app =
          firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
    #else
      firebase::App* app = firebase::App::Create(firebase::AppOptions());
    #endif  // defined(__ANDROID__)
    
  3. Adquiera la firebase::auth::Auth para su firebase::App . Hay una asignación uno a uno entre App y Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Manejar el flujo de inicio de sesión con el SDK de Firebase

El proceso para iniciar sesión con Apple varía según las plataformas Apple y Android.

En las plataformas de Apple

Autentique a sus usuarios con Firebase a través del SDK de Objective-C de inicio de sesión de Apple invocado desde su código C++.

  1. Para cada solicitud de inicio de sesión, genere una cadena aleatoria, un "nonce", que usará para asegurarse de que el token de ID que obtenga se haya otorgado específicamente en respuesta a la solicitud de autenticación de su aplicación. Este paso es importante para evitar ataques de repetición.

      - (NSString *)randomNonce:(NSInteger)length {
        NSAssert(length > 0, @"Expected nonce to have positive length");
        NSString *characterSet = @"0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._";
        NSMutableString *result = [NSMutableString string];
        NSInteger remainingLength = length;
    
        while (remainingLength > 0) {
          NSMutableArray *randoms = [NSMutableArray arrayWithCapacity:16];
          for (NSInteger i = 0; i < 16; i++) {
            uint8_t random = 0;
            int errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random);
            NSAssert(errorCode == errSecSuccess, @"Unable to generate nonce: OSStatus %i", errorCode);
    
            [randoms addObject:@(random)];
          }
    
          for (NSNumber *random in randoms) {
            if (remainingLength == 0) {
              break;
            }
    
            if (random.unsignedIntValue < characterSet.length) {
              unichar character = [characterSet characterAtIndex:random.unsignedIntValue];
              [result appendFormat:@"%C", character];
              remainingLength--;
            }
          }
        }
      }
    
    

    Enviará el hash SHA256 del nonce con su solicitud de inicio de sesión, que Apple pasará sin cambios en la respuesta. Firebase valida la respuesta aplicando hash al nonce original y comparándolo con el valor pasado por Apple.

  2. Inicie el flujo de inicio de sesión de Apple, incluyendo en su solicitud el hash SHA256 del nonce y la clase delegada que manejará la respuesta de Apple (vea el siguiente paso):

      - (void)startSignInWithAppleFlow {
        NSString *nonce = [self randomNonce:32];
        self.currentNonce = nonce;
        ASAuthorizationAppleIDProvider *appleIDProvider = [[ASAuthorizationAppleIDProvider alloc] init];
        ASAuthorizationAppleIDRequest *request = [appleIDProvider createRequest];
        request.requestedScopes = @[ASAuthorizationScopeFullName, ASAuthorizationScopeEmail];
        request.nonce = [self stringBySha256HashingString:nonce];
    
        ASAuthorizationController *authorizationController =
            [[ASAuthorizationController alloc] initWithAuthorizationRequests:@[request]];
        authorizationController.delegate = self;
        authorizationController.presentationContextProvider = self;
        [authorizationController performRequests];
      }
    
      - (NSString *)stringBySha256HashingString:(NSString *)input {
        const char *string = [input UTF8String];
        unsigned char result[CC_SHA256_DIGEST_LENGTH];
        CC_SHA256(string, (CC_LONG)strlen(string), result);
    
        NSMutableString *hashed = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
        for (NSInteger i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
          [hashed appendFormat:@"%02x", result[i]];
        }
        return hashed;
      }
    
  3. Maneje la respuesta de Apple en su implementación de ASAuthorizationControllerDelegate`. Si el inicio de sesión fue exitoso, use el token de ID de la respuesta de Apple con el nonce sin hash para autenticarse con Firebase:

      - (void)authorizationController:(ASAuthorizationController *)controller
         didCompleteWithAuthorization:(ASAuthorization *)authorization API_AVAILABLE(ios(13.0)) {
        if ([authorization.credential isKindOfClass:[ASAuthorizationAppleIDCredential class]]) {
          ASAuthorizationAppleIDCredential *appleIDCredential = authorization.credential;
          NSString *rawNonce = self.currentNonce;
          NSAssert(rawNonce != nil, @"Invalid state: A login callback was received, but no login request was sent.");
    
          if (appleIDCredential.identityToken == nil) {
            NSLog(@"Unable to fetch identity token.");
            return;
          }
    
          NSString *idToken = [[NSString alloc] initWithData:appleIDCredential.identityToken
                                                    encoding:NSUTF8StringEncoding];
          if (idToken == nil) {
            NSLog(@"Unable to serialize id token from data: %@", appleIDCredential.identityToken);
          }
        }
    
  4. Use la cadena de token resultante y el nonce original para crear una credencial de Firebase e iniciar sesión en Firebase.

    firebase::auth::OAuthProvider::GetCredential(
            /*provider_id=*/"apple.com", token, nonce,
            /*access_token=*/nullptr);
    
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  5. Se puede usar el mismo patrón con Volver a Reauthenticate , que se puede usar para recuperar credenciales nuevas para operaciones confidenciales que requieren un inicio de sesión reciente.

    firebase::Future<firebase::auth::SignInResult> result =
        user->Reauthenticate(credential);
    
  6. Se puede usar el mismo patrón para vincular una cuenta con Apple Sign In. Sin embargo, es posible que encuentre un error cuando una cuenta existente de Firebase ya se vinculó a la cuenta de Apple que está intentando vincular. Cuando esto ocurra, el futuro devolverá un estado de kAuthErrorCredentialAlreadyInUse y el objeto UserInfo de SignInResult puede contener una updated_credential válida. Esta credencial se puede usar para iniciar sesión en la cuenta vinculada a Apple a través SignInWithCredential sin necesidad de generar otro token y nonce de inicio de sesión de Apple.

    Tenga en cuenta que debe usar LinkAndRetrieveDataWithCredential para que esta operación contenga la credencial, ya que updated_credential es miembro del objeto SignInResult.UserInfo .

    firebase::Future<firebase::auth::SignInResult> link_result =
        auth->current_user()->LinkAndRetrieveDataWithCredential(credential);
    
    // To keep example simple, wait on the current thread until call completes.
    while (link_result.status() == firebase::kFutureStatusPending) {
      Wait(100);
    }
    
    // Determine the result of the link attempt
    if (link_result.error() == firebase::auth::kAuthErrorNone) {
      // user linked correctly.
    } else if (link_result.error() ==
                   firebase::auth::kAuthErrorCredentialAlreadyInUse &&
               link_result.result()->info.updated_credential.is_valid()) {
      // Sign In with the new credential
      firebase::Future<firebase::auth::User*> result = auth->SignInWithCredential(
          link_result.result()->info.updated_credential);
    } else {
      // Another link error occurred.
    }
    

En Android

En Android, autentique a sus usuarios con Firebase integrando el inicio de sesión OAuth genérico basado en la web en su aplicación mediante el SDK de Firebase para llevar a cabo el flujo de inicio de sesión de extremo a extremo.

Para manejar el flujo de inicio de sesión con el SDK de Firebase, sigue estos pasos:

  1. Cree una instancia de FederatedOAuthProviderData configurada con el ID de proveedor apropiado para Apple.

    firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
    
  2. Opcional: especifique ámbitos adicionales de OAuth 2.0 más allá del valor predeterminado que desea solicitar al proveedor de autenticación.

    provider_data.scopes.push_back("email");
    provider_data.scopes.push_back("name");
    
  3. Opcional: si desea mostrar la pantalla de inicio de sesión de Apple en un idioma que no sea inglés, establezca el parámetro de locale . Consulte los documentos Iniciar sesión con Apple para conocer las configuraciones regionales admitidas.

    // Localize to French.
    provider_data.custom_parameters["language"] = "fr";
    ```
    
  4. Una vez que haya configurado los datos de su proveedor, utilícelos para crear un FederatedOAuthProvider.

    // Construct a FederatedOAuthProvider for use in Auth methods.
    firebase::auth::FederatedOAuthProvider provider(provider_data);
    
  5. Autenticarse con Firebase mediante el objeto del proveedor de autenticación. Tenga en cuenta que, a diferencia de otras operaciones de FirebaseAuth, esto tomará el control de su interfaz de usuario al mostrar una vista web en la que el usuario puede ingresar sus credenciales.

    Para iniciar el flujo de inicio de sesión, llame a signInWithProvider :

    firebase::Future<firebase::auth::SignInResult> result =
      auth->SignInWithProvider(provider_data);
    

    Su aplicación puede entonces esperar o registrar una devolución de llamada en el futuro .

  6. El mismo patrón se puede usar con ReauthenticateWithProvider , que se puede usar para recuperar credenciales nuevas para operaciones confidenciales que requieren un inicio de sesión reciente.

    firebase::Future<firebase::auth::SignInResult> result =
      user->ReauthenticateWithProvider(provider_data);
    

    Su aplicación puede entonces esperar o registrar una devolución de llamada en el futuro .

  7. Y puede usar linkWithCredential() para vincular diferentes proveedores de identidad a cuentas existentes.

    Tenga en cuenta que Apple requiere que obtenga el consentimiento explícito de los usuarios antes de vincular sus cuentas de Apple a otros datos.

    Por ejemplo, para vincular una cuenta de Facebook a la cuenta actual de Firebase, use el token de acceso que obtuvo al iniciar sesión el usuario en Facebook:

    // Initialize a Facebook credential with a Facebook access token.
    AuthCredential credential =
        firebase::auth::FacebookAuthProvider.getCredential(token);
    
    // Assuming the current user is an Apple user linking a Facebook provider.
    firebase::Future<firebase::auth::SignInResult> result =
        auth.getCurrentUser().linkWithCredential(credential);
    

Iniciar sesión con Notas de Apple

A diferencia de otros proveedores compatibles con Firebase Auth, Apple no proporciona una URL de foto.

Además, cuando el usuario elige no compartir su correo electrónico con la aplicación, Apple proporciona una dirección de correo electrónico única para ese usuario (de la forma xyz@privaterelay.appleid.com ), que comparte con su aplicación. Si configuró el servicio de retransmisión de correo electrónico privado, Apple reenvía los correos electrónicos enviados a la dirección anonimizada a la dirección de correo electrónico real del usuario.

Apple solo comparte información de usuario, como el nombre para mostrar, con las aplicaciones la primera vez que un usuario inicia sesión. Por lo general, Firebase almacena el nombre para mostrar la primera vez que un usuario inicia sesión con Apple, que puede obtener con getCurrentUser().getDisplayName() . Sin embargo, si anteriormente usó Apple para iniciar la sesión de un usuario en la aplicación sin usar Firebase, Apple no proporcionará a Firebase el nombre para mostrar del usuario.

Próximos pasos

Después de que un usuario inicia sesión por primera vez, se crea una nueva cuenta de usuario y se vincula a las credenciales (es decir, el nombre de usuario y la contraseña, el número de teléfono o la información del proveedor de autenticación) con las que el usuario inició sesión. Esta nueva cuenta se almacena como parte de su proyecto de Firebase y se puede usar para identificar a un usuario en cada aplicación de su proyecto, independientemente de cómo inicie sesión el usuario.

En sus aplicaciones, puede obtener la información básica del perfil del usuario del objeto firebase::auth::user. Consulte Administrar usuarios .

En sus Reglas de seguridad de Firebase Realtime Database y Cloud Storage, puede obtener el ID de usuario único del usuario que inició sesión de la variable auth y usarlo para controlar a qué datos puede acceder un usuario.