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

S'authentifier avec Apple et 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 effectuer le flux de connexion OAuth 2.0 de bout en bout.

Avant de commencer

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

Rejoindre l'Apple Developer Program

Seuls les membres du programme Apple Developer peuvent configurer "Se connecter avec Apple".

La connexion avec 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 Se connecter avec Apple" des guides Plates-formes Apple et/ou Android avant de continuer.

Dans la console Firebase, ouvrez la section Authentification. Dans l'onglet Méthode de connexion, activez le fournisseur Apple.
Configurez les paramètres du fournisseur de connexion Apple :
1. Si vous ne déployez votre application que sur les plates-formes Apple, vous pouvez laisser vides les champs "ID de service", "ID d'équipe Apple", "Clé privée" et "ID de clé".
2. Pour obtenir de l'aide sur les appareils Android :
  1. Ajoutez Firebase à votre projet Android. Veillez à enregistrer la signature SHA-1 de votre application lorsque vous la configurez dans la console Firebase.
  2. Dans la console Firebase, ouvrez la section Authentification. 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. Dans la section de configuration du flux de code OAuth, spécifiez également votre ID d'équipe Apple, ainsi que la clé privée et l'ID de clé que vous avez créés dans la section précédente.

Respecter les exigences d'Apple concernant les données anonymisées

La fonctionnalité Se connecter avec Apple permet aux utilisateurs d'anonymiser leurs données, y compris leur adresse e-mail, lorsqu'ils se connectent. Les utilisateurs qui choisissent cette option disposent d'adresses e-mail avec le domaine privaterelay.appleid.com. Lorsque vous utilisez S'identifier avec Apple dans votre application, vous devez respecter le règlement pour les développeurs ou les conditions d'utilisation d'Apple concernant ces identifiants Apple anonymes.

Cela inclut l'obtention de l'autorisation de l'utilisateur avant d'associer des informations personnelles permettant d'identifier directement l'utilisateur à un identifiant Apple anonyme. Lorsque vous utilisez Firebase Authentication, cela peut inclure les actions suivantes :

Associer une adresse e-mail à un identifiant Apple anonyme, ou inversement
Associer un numéro de téléphone à un identifiant Apple anonyme, ou inversement
Associez un identifiant de réseau social non anonyme (Facebook, Google, etc.) à un identifiant Apple anonyme, ou inversement.

La liste ci-dessus n'est pas exhaustive. Consultez le Contrat de licence du programme Apple Developer dans la section "Abonnement" de votre compte de développeur pour vous assurer que votre application répond aux exigences d'Apple.

Accéder au cours `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__)

Acquérez la classe firebase::auth::Auth pour votre firebase::App. Il existe une correspondance 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

La procédure de connexion avec Apple varie selon les plates-formes Apple et Android.

Sur les plates-formes Apple

Authentifiez vos utilisateurs avec Firebase via le SDK Apple Sign In Objective-C appelé à 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'ID obtenu a été accordé spécifiquement en réponse à la requête d'authentification de votre application. Cette étape est importante pour éviter les attaques par relecture.

  - (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 envoyez le hachage SHA256 du nonce avec votre requête de connexion, qu'Apple transmet dans la réponse sans la modifier. 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 requête le hachage SHA256 de la chaîne 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'ID 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 et le nonce d'origine 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::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

Le même schéma peut être utilisé avec Reauthenticate, qui peut servir à récupérer des identifiants récents pour les opérations sensibles nécessitant une connexion récente.
```
firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);
```

Le même schéma peut être utilisé pour associer un compte à Se connecter avec Apple. Toutefois, vous pouvez rencontrer une erreur lorsqu'un compte Firebase existant a déjà été associé au compte Apple que vous essayez d'associer. Dans ce cas, l'avenir renverra un état kAuthErrorCredentialAlreadyInUse et le AuthResult peut contenir un credential valide. Ces identifiants peuvent être utilisés pour se connecter au compte associé à Apple via SignInAndRetrieveDataWithCredential sans avoir à générer un autre jeton et nonce de connexion avec Apple.

firebase::Future<firebase::auth::AuthResult> link_result =
    auth->current_user().LinkWithCredential(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()
               ->additional_user_info.updated_credential.is_valid()) {
  // Sign In with the new credential
  firebase::Future<firebase::auth::AuthResult> result =
      auth->SignInAndRetrieveDataWithCredential(
          link_result.result()->additional_user_info.updated_credential);
} else {
  // Another link error occurred.
}

Sur Android

Sur Android, authentifiez vos utilisateurs avec Firebase en intégrant une connexion OAuth générique basée sur le Web à 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 niveaux d'accès OAuth 2.0 supplémentaires en plus de ceux 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 autre langue que l'anglais, définissez le paramètre locale. Consultez la documentation sur S'identifier avec Apple pour connaître les langues disponibles.
```
// 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 avec Firebase à l'aide de l'objet du fournisseur d'authentification. Notez que, contrairement à d'autres opérations FirebaseAuth, celle-ci prendra le contrôle de votre UI en affichant une vue Web dans laquelle l'utilisateur pourra saisir ses identifiants.

Pour démarrer le flux de connexion, appelez signInWithProvider :
```
firebase::Future<firebase::auth::AuthResult> result =
  auth->SignInWithProvider(provider_data);
```
Votre application peut ensuite attendre ou enregistrer un rappel sur l'avenir.
Le même schéma peut être utilisé avec ReauthenticateWithProvider, qui peut servir à récupérer des identifiants récents pour les opérations sensibles nécessitant une connexion récente.
```
firebase::Future<firebase::auth::AuthResult> result =
  user.ReauthenticateWithProvider(provider_data);
```
Votre application peut ensuite attendre ou enregistrer un rappel sur l'avenir.
Vous pouvez également utiliser LinkWithCredential() pour associer différents fournisseurs d'identité à des comptes existants.

Notez qu'Apple vous demande d'obtenir le consentement explicite des utilisateurs avant d'associer leurs comptes Apple à d'autres données.

Par exemple, pour associer 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::AuthResult> result =
    auth.current_user().LinkWithCredential(credential);
```

Contrairement aux autres fournisseurs acceptés par Firebase Auth, Apple ne fournit pas d'URL de photo.

De plus, lorsque l'utilisateur choisit de ne pas partager son adresse e-mail avec l'application, Apple provisionne une adresse e-mail unique pour cet utilisateur (au format xyz@privaterelay.appleid.com) et la 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 anonyme à l'adresse e-mail réelle de l'utilisateur.

Apple ne partage des informations utilisateur, telles que le nom à afficher, qu'avec les applications la première fois qu'un utilisateur se connecte. En règle générale, Firebase stocke le nom à afficher la première fois qu'un utilisateur se connecte avec Apple. Vous pouvez l'obtenir avec current_user().display_name(). Toutefois, si vous avez déjà utilisé Apple pour connecter un utilisateur à l'application sans utiliser Firebase, Apple ne fournira pas le nom à afficher de l'utilisateur à Firebase.

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associé aux identifiants avec lesquels il s'est connecté (nom d'utilisateur et mot de passe, numéro de téléphone ou informations du fournisseur d'authentification). Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la méthode de connexion de l'utilisateur.

Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet firebase::auth::User. Consultez 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 d'authentification et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

S'authentifier avec Apple et C++ Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Rejoindre l'Apple Developer Program

Configurer "Se connecter avec Apple"

Activer Apple en tant que fournisseur d'identité