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

S'authentifier avec Firebase à l'aide de comptes basés sur un mot de passe avec C++

Vous pouvez utiliser Firebase Authentication pour permettre à vos utilisateurs de s'authentifier avec Firebase à l'aide de leur adresse e-mail et de leur mot de passe, et pour gérer les comptes basés sur un mot de passe de votre application.

Avant de commencer

Ajoutez Firebase à votre projet C++.
Si vous n'avez pas encore associé votre application à votre projet Firebase, faites-le depuis la console Firebase.
Activez la connexion par adresse e-mail/mot de passe :
1. Dans la console Firebase, ouvrez la section Authentification.
2. Dans l'onglet Méthode de connexion, activez la méthode de connexion Adresse e-mail/Mot de passe, puis cliquez sur Enregistrer.

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);
```

Créer un compte basé sur un mot de passe

Pour créer un compte utilisateur avec un mot de passe, suivez les étapes ci-dessous dans le code de connexion de votre application :

Lorsqu'un nouvel utilisateur s'inscrit à l'aide du formulaire d'inscription de votre application, effectuez toutes les étapes de validation de compte requises par votre application, par exemple en vérifiant que le mot de passe du nouveau compte a été saisi correctement et qu'il répond à vos exigences de complexité.
Créez un compte en transmettant l'adresse e-mail et le mot de passe du nouvel utilisateur à Auth::CreateUserWithEmailAndPassword :
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
```

Si votre programme comporte une boucle de mise à jour qui s'exécute régulièrement (par exemple, 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par mise à jour avec Auth::CreateUserWithEmailAndPasswordLastResult :

firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Create user succeeded for email %s\n",
           auth_result.user.email().c_str());
  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

Si votre programme est axé sur les événements, vous pouvez également enregistrer un rappel sur l'objet Future.

Connecter un utilisateur avec une adresse e-mail et un mot de passe

La procédure de connexion d'un utilisateur avec un mot de passe est semblable à celle de création d'un compte. Dans la fonction de connexion de votre application, procédez comme suit :

Lorsqu'un utilisateur se connecte à votre application, transmettez son adresse e-mail et son mot de passe à firebase::auth::Auth::SignInWithEmailAndPassword :
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
```

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for email %s\n",
           auth_result.user.email().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}

Si votre programme est axé sur les événements, vous pouvez également enregistrer un rappel sur l'objet Future.

Enregistrer un rappel sur un Future

Certains programmes comportent des fonctions Update qui sont appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler les fonctions LastResult pour interroger les appels asynchrones. Toutefois, si votre programme est basé sur des événements, vous préférerez peut-être enregistrer des fonctions de rappel. Une fonction de rappel est appelée à la fin de l'objet Future.

void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}

Si vous préférez, la fonction de rappel peut également être un lambda.

void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // The lambda has the same signature as the callback function.
  result.OnCompletion(
      [](const firebase::Future<firebase::auth::User*>& result,
         void* user_data) {
        // `user_data` is the same as &my_program_context, below.
        // Note that we can't capture this value in the [] because std::function
        // is not supported by our minimum compiler spec (which is pre C++11).
        MyProgramContext* program_context =
            static_cast<MyProgramContext*>(user_data);

        // Process create user result...
        (void)program_context;
      },
      &my_program_context);
}

Recommandation : Définir une règle de mot de passe

Vous pouvez renforcer la sécurité des comptes en appliquant des exigences de complexité des mots de passe.

Pour configurer une règle relative aux mots de passe pour votre projet, ouvrez l'onglet Règle relative aux mots de passe sur la page "Paramètres d'authentification" de la console Firebase :

Paramètres d'authentification

Les règles relatives aux mots de passe Firebase Authentication acceptent les exigences suivantes :

Minuscule requise
Majuscule requise
Caractère numérique requis
Caractère non alphanumérique requis

Les caractères suivants répondent à l'exigence de caractère non alphanumérique : ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~
Longueur minimale du mot de passe (entre 6 et 30 caractères, 6 par défaut)
Longueur maximale du mot de passe (4 096 caractères maximum)

Vous pouvez activer l'application forcée des règles relatives aux mots de passe de deux manières :

Obliger : les tentatives d'inscription échouent tant que l'utilisateur n'indique pas un mot de passe conforme à vos règles.
Notifier : les utilisateurs peuvent s'inscrire avec un mot de passe non conforme. Lorsque vous utilisez ce mode, vous devez vérifier si le mot de passe de l'utilisateur est conforme aux règles côté client et inviter l'utilisateur à le modifier s'il ne l'est pas.

Les nouveaux utilisateurs doivent toujours choisir un mot de passe conforme à vos règles.

Si vous avez des utilisateurs actifs, nous vous recommandons de ne pas activer la mise à niveau forcée à la connexion, sauf si vous avez l'intention de bloquer l'accès aux utilisateurs dont les mots de passe ne respectent pas votre règlement. Utilisez plutôt le mode notification, qui permet aux utilisateurs de se connecter avec leur mot de passe actuel et les informe des exigences auxquelles leur mot de passe ne répond pas.

Recommandation : activer la protection contre l'énumération d'adresses e-mail

Certaines méthodes Firebase Authentication qui prennent des adresses e-mail comme paramètres génèrent des erreurs spécifiques si l'adresse e-mail n'est pas enregistrée alors qu'elle devrait l'être (par exemple, lors de la connexion avec une adresse e-mail et un mot de passe) ou si elle est enregistrée alors qu'elle devrait être inutilisée (par exemple, lors du changement d'adresse e-mail d'un utilisateur). Bien que cela puisse être utile pour suggérer des solutions spécifiques aux utilisateurs, les acteurs malveillants peuvent également en abuser pour découvrir les adresses e-mail enregistrées par vos utilisateurs.

Pour limiter ce risque, nous vous recommandons d'activer la protection contre l'énumération d'adresses e-mail pour votre projet à l'aide de l'outil gcloud de Google Cloud. Notez que l'activation de cette fonctionnalité modifie le comportement de Firebase Authentication en matière de signalement des erreurs. Assurez-vous que votre application ne repose pas sur les erreurs plus spécifiques.

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associé aux identifiants (nom d'utilisateur et mot de passe, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels il s'est connecté. 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 :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string name = user.display_name();
  std::string email = user.email();
  std::string photo_url = user.photo_url();
  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

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.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez SignOut() :

auth->SignOut();