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 auprès de à l'aide de leurs adresses e-mail et mots de passe, et pour gérer de mots de passe.

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.
Activer la connexion par e-mail/mot de passe: <ph type="x-smartling-placeholder">
1. Dans la console Firebase, ouvrez la section Auth.
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 à la classe `firebase::auth::Auth`

La classe Auth est la passerelle de 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__)

Procurez-vous la classe firebase::auth::Auth pour votre firebase::App. Il existe un mappage de type "un à un" entre App et Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Créer un compte avec mot de passe

Pour créer un compte utilisateur avec un mot de passe, procédez comme suit dans le code de connexion de votre application:

Lorsqu'un nouvel utilisateur s'inscrit à l'aide du formulaire d'inscription de votre application, remplissez les étapes de validation du compte requises par votre application, telles que la vérification le mot de passe du nouveau compte a été correctement saisi et répond à votre complexité exigences.
Créez un compte en transmettant l'adresse e-mail et le mot de passe du nouvel utilisateur vers 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 des événements, vous pouvez enregistrer un rappel sur la Futur.

Se connecter à un compte 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 mot de passe pour 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());
  }
}

Ou, si votre programme est basé sur des événements, vous pouvez préférer enregistrer un rappel sur le Future.

Enregistrer un rappel sur un objet Future

Certains programmes comportent des fonctions Update appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler le 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 une fois l'objet Future terminé.

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 la page Règles relatives aux mots de passe de la page "Authentication Settings" (Paramètres d'authentification) de la console Firebase:

Paramètres d'authentification

Firebase Authentication règles relatives aux mots de passe sont compatibles avec les exigences suivantes:

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

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

Vous pouvez activer l'application des règles relatives aux mots de passe dans deux modes:

Exiger : les tentatives de connexion échouent tant que l'utilisateur n'indique pas un mot de passe conforme à vos règles.
Notifier: les utilisateurs sont autorisés à se connecter 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 au règlement côté client et inviter l'utilisateur à modifier son mot de passe 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 le mode d'application obligatoire, sauf si vous prévoyez de bloquer l'accès aux utilisateurs dont les mots de passe ne respectent pas votre règle. Utilisez plutôt le mode notification, qui permet aux utilisateurs de se connecter avec leur mot de passe actuel et de les informer 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 utilisent 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 doit l'être. (par exemple, lorsque vous vous connectez avec une adresse e-mail et un mot de passe), ou enregistrés lorsqu'elle ne doit pas être utilisée (par exemple, lors de la modification de l'adresse e-mail d'un utilisateur). Bien que cela puisse être utile pour suggérer des solutions spécifiques aux utilisateurs, cela peut également être utilisé de manière abusive par des acteurs malveillants 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 signalement des erreurs d'Firebase Authentication. Assurez-vous que votre application ne s'appuie 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 et mot de passe de l'utilisateur, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels l'utilisateur s'est connecté. Cette nouvelle est stocké dans votre projet Firebase et peut servir à identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la façon dont l'utilisateur se connecte.

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 votre Firebase Realtime Database et votre Cloud Storage Règles de sécurité, vous pouvez obtenez 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 appli à l'aide de plusieurs authentifications fournisseurs en associant leurs identifiants compte utilisateur existant.

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

auth->SignOut();