Cette page a été traduite par l'API Cloud Translation.

Authentification à l'aide d'Apple et de C++

Vous pouvez permettre à vos utilisateurs de s'authentifier auprès de Firebase à l'aide de leur identifiant Apple en utilisant le SDK Firebase pour exécuter le flux de connexion OAuth 2.0 de bout en bout.

Avant que tu commences

Pour connecter des utilisateurs à l'aide d'Apple, configurez d'abord Se connecter avec Apple sur le site des développeurs d'Apple, puis activez Apple en tant que fournisseur de connexion pour votre projet Firebase.

Rejoignez le programme pour développeurs Apple

La connexion avec Apple ne peut être configurée que par les membres du programme pour développeurs Apple .

La connexion Apple doit être activée et correctement configurée dans votre projet Firebase. La configuration varie selon les plates-formes Android et Apple. Veuillez suivre la section "Configurer la connexion avec Apple" des guides des plates-formes Apple et/ou Android avant de continuer.

Dans la console Firebase , ouvrez la section Auth . Dans l'onglet Méthode de connexion, activez le fournisseur Apple .
Configurez les paramètres du fournisseur de connexion Apple :
1. Si vous déployez votre application uniquement sur les plates-formes Apple, vous pouvez laisser les champs ID de service, ID d'équipe Apple, clé privée et ID de clé vides.
2. Pour l'assistance sur les appareils Android :
  1. Ajoutez Firebase à votre projet Android . Assurez-vous d'enregistrer la signature SHA-1 de votre application lorsque vous configurez votre application dans la console Firebase.
  2. Dans la console Firebase , ouvrez la section Auth . Dans l'onglet Méthode de connexion, activez le fournisseur Apple . Spécifiez l'ID de service que vous avez créé dans la section précédente. De plus, dans la section de configuration du flux de code OAuth, spécifiez votre identifiant d'équipe Apple ainsi que la clé privée et l'identifiant de clé que vous avez créés dans la section précédente.

Conformez-vous aux exigences de données anonymisées d'Apple

Se connecter avec Apple donne aux utilisateurs la possibilité d'anonymiser leurs données, y compris leur adresse e-mail, lors de la connexion. Les utilisateurs qui choisissent cette option ont des adresses e-mail avec le domaine privaterelay.appleid.com . Lorsque vous utilisez Se connecter avec Apple dans votre application, vous devez vous conformer à toutes les politiques ou conditions applicables aux développeurs d'Apple concernant ces identifiants Apple anonymisés.

Cela inclut l'obtention de tout consentement requis de l'utilisateur avant d'associer des informations personnelles d'identification directe à un identifiant Apple anonymisé. Lorsque vous utilisez Firebase Authentication, cela peut inclure les actions suivantes :

Associez une adresse e-mail à un identifiant Apple anonymisé ou vice versa.
Lier un numéro de téléphone à un identifiant Apple anonymisé ou vice versa
Liez un identifiant social non anonyme (Facebook, Google, etc.) à un identifiant Apple anonymisé ou vice versa.

La liste ci-dessus n'est pas exhaustive. Reportez-vous au contrat de licence du programme pour développeurs Apple dans la section Adhésion de votre compte de développeur pour vous assurer que votre application répond aux exigences d'Apple.

Accéder à la `firebase::auth::Auth`

La classe Auth est la passerelle pour tous les appels d'API.

Ajoutez les fichiers d'en-tête Auth et App :

#include "firebase/app.h"
#include "firebase/auth.h"

Dans votre code d'initialisation, créez une classe 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__)

Obtenez la firebase::auth::Auth pour votre firebase::App . Il existe un mappage un à un entre App et Auth .
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Gérer le flux de connexion avec le SDK Firebase

Le processus de connexion avec Apple varie selon les plates-formes Apple et Android.

Sur les plateformes Apple

Authentifiez vos utilisateurs auprès de Firebase via le SDK Apple Sign In Objective-C invoqué à partir de votre code C++.

Pour chaque demande de connexion, générez une chaîne aléatoire - un "nonce" - que vous utiliserez pour vous assurer que le jeton d'identification que vous obtenez a été accordé spécifiquement en réponse à la demande d'authentification de votre application. Cette étape est importante pour empêcher les attaques par rejeu.

  - (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--;
        }
      }
    }
  }

Vous enverrez le hachage SHA256 du nonce avec votre demande de connexion, qu'Apple transmettra tel quel dans la réponse. Firebase valide la réponse en hachant le nonce d'origine et en le comparant à la valeur transmise par Apple.

Démarrez le flux de connexion d'Apple, en incluant dans votre demande le hachage SHA256 du nonce et la classe déléguée qui gérera la réponse d'Apple (voir l'étape suivante) :

  - (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;
  }

Gérez la réponse d'Apple dans votre implémentation de ASAuthorizationControllerDelegate`. Si la connexion a réussi, utilisez le jeton d'identification de la réponse d'Apple avec le nonce non haché pour vous authentifier auprès de 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);
      }
    }

Utilisez la chaîne de jeton résultante et le nonce original pour créer un identifiant Firebase et vous connecter à Firebase.

firebase::auth::OAuthProvider::GetCredential(
        /*provider_id=*/"apple.com", token, nonce,
        /*access_token=*/nullptr);

firebase::Future<firebase::auth::User*> result =
    auth->SignInWithCredential(credential);

Le même modèle peut être utilisé avec Reauthenticate qui peut être utilisé pour récupérer de nouvelles informations d'identification pour les opérations sensibles qui nécessitent une connexion récente.
```
firebase::Future<firebase::auth::SignInResult> result =
    user->Reauthenticate(credential);
```

Le même schéma peut être utilisé pour lier un compte à Apple Sign In. Cependant, vous pouvez rencontrer une erreur lorsqu'un compte Firebase existant a déjà été lié au compte Apple avec lequel vous essayez de vous connecter. Lorsque cela se produit, le futur renverra un statut de kAuthErrorCredentialAlreadyInUse et l'objet UserInfo de SignInResult peut contenir un updated_credential valide. Ces informations d'identification peuvent être utilisées pour se connecter au compte lié à Apple via SignInWithCredential sans qu'il soit nécessaire de générer un autre jeton de connexion Apple et nonce.

Notez que vous devez utiliser LinkAndRetrieveDataWithCredential pour que cette opération contienne les informations d'identification car updated_credential est membre de l'objet 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.
}

Sur Androïd

Sur Android, authentifiez vos utilisateurs avec Firebase en intégrant la connexion OAuth générique basée sur le Web dans votre application à l'aide du SDK Firebase pour effectuer le flux de connexion de bout en bout.

Pour gérer le flux de connexion avec le SDK Firebase, procédez comme suit :

Créez une instance de FederatedOAuthProviderData configurée avec l'ID de fournisseur approprié pour Apple.
```
firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
```
Facultatif : spécifiez des étendues OAuth 2.0 supplémentaires au-delà de la valeur par défaut que vous souhaitez demander au fournisseur d'authentification.
```
provider_data.scopes.push_back("email");
provider_data.scopes.push_back("name");
```
Facultatif : si vous souhaitez afficher l'écran de connexion d'Apple dans une langue autre que l'anglais, définissez le locale de paramètres régionaux. Consultez la documentation Se connecter avec Apple pour connaître les paramètres régionaux pris en charge.
```
// Localize to French.
provider_data.custom_parameters["language"] = "fr";
```
```

Une fois les données de votre fournisseur configurées, utilisez-les pour créer un FederatedOAuthProvider.

// Construct a FederatedOAuthProvider for use in Auth methods.
firebase::auth::FederatedOAuthProvider provider(provider_data);

Authentifiez-vous auprès de Firebase à l'aide de l'objet fournisseur d'authentification. Notez que contrairement aux autres opérations FirebaseAuth, cela prendra le contrôle de votre interface utilisateur en faisant apparaître une vue Web dans laquelle l'utilisateur peut saisir ses informations d'identification.
Pour démarrer le flux de connexion, appelez signInWithProvider :
```
firebase::Future<firebase::auth::SignInResult> result =
  auth->SignInWithProvider(provider_data);
```
Votre application peut alors attendre ou enregistrer un rappel sur le Future .
Le même modèle peut être utilisé avec ReauthenticateWithProvider qui peut être utilisé pour récupérer de nouvelles informations d'identification pour les opérations sensibles qui nécessitent une connexion récente.
```
firebase::Future<firebase::auth::SignInResult> result =
  user->ReauthenticateWithProvider(provider_data);
```
Votre application peut alors attendre ou enregistrer un rappel sur le Future .
Et, vous pouvez utiliser linkWithCredential() pour lier différents fournisseurs d'identité à des comptes existants.
Notez qu'Apple exige que vous obteniez le consentement explicite des utilisateurs avant de lier leurs comptes Apple à d'autres données.
Par exemple, pour lier un compte Facebook au compte Firebase actuel, utilisez le jeton d'accès que vous avez obtenu en connectant l'utilisateur à 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);
```

Contrairement aux autres fournisseurs pris en charge par Firebase Auth, Apple ne fournit pas d'URL de photo.

De plus, lorsque l'utilisateur choisit de ne pas partager son e-mail avec l'application, Apple fournit une adresse e-mail unique pour cet utilisateur (de la forme xyz@privaterelay.appleid.com ), qu'il partage avec votre application. Si vous avez configuré le service de relais de messagerie privé, Apple transfère les e-mails envoyés à l'adresse anonymisée vers la véritable adresse e-mail de l'utilisateur.

Apple partage uniquement les informations utilisateur telles que le nom d'affichage avec les applications la première fois qu'un utilisateur se connecte. Habituellement, Firebase stocke le nom d'affichage la première fois qu'un utilisateur se connecte à Apple, que vous pouvez obtenir avec getCurrentUser().getDisplayName() . Cependant, si vous avez déjà utilisé Apple pour connecter un utilisateur à l'application sans utiliser Firebase, Apple ne fournira pas à Firebase le nom d'affichage de l'utilisateur.

Prochaines étapes

Lorsqu'un utilisateur se connecte pour la première fois, un nouveau compte d'utilisateur est créé et lié aux informations d'identification (c'est-à-dire le nom d'utilisateur et le mot de passe, le numéro de téléphone ou les informations du fournisseur d'authentification) avec lesquelles l'utilisateur s'est connecté. Ce nouveau compte est stocké dans le cadre de votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet, quelle que soit la manière dont l'utilisateur se connecte.

Dans vos applications, vous pouvez obtenir les informations de base du profil de l'utilisateur à partir de l'objet firebase::auth::user. Voir Gérer les utilisateurs .

Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, vous pouvez obtenir l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.