אימות עם Firebase באמצעות חשבונות מבוססי-סיסמה עם C++

ניתן להשתמש ב-Firebase Authentication כדי לאפשר למשתמשים לבצע אימות באמצעות Firebase באמצעות כתובות האימייל והסיסמאות שלהם, וכדי לנהל את החשבונות של האפליקציה שמבוססים על סיסמאות.

לפני שמתחילים

  1. מוסיפים את Firebase לפרויקט C++.
  2. אם עדיין לא קישרתם את האפליקציה לפרויקט Firebase, צריך לעשות זאת ממסוף Firebase.
  3. מפעילים את הכניסה באמצעות כתובת אימייל/סיסמה:
    1. במסוף Firebase, פותחים את הקטע Auth.
    2. בכרטיסייה Sign in method, מפעילים את אמצעי הכניסה Email/password ולוחצים על Save.

גישה לכיתה firebase::auth::Auth

הכיתה Auth היא השער לכל הקריאות ל-API.
  1. מוסיפים את קובצי הכותרות של Auth ו-App: 
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. בקוד ההפעלה, יוצרים את הכיתה 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. עליך להשיג את הכיתה firebase::auth::Auth ל-firebase::App. יש מיפוי אחד-לאחד בין App לבין Auth. 
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

יצירת חשבון שמבוסס על סיסמה

כדי ליצור חשבון משתמש חדש עם סיסמה, מבצעים את השלבים הבאים בקוד הכניסה של האפליקציה:

  1. כשמשתמש חדש נרשם באמצעות טופס ההרשמה של האפליקציה, צריך להשלים את השלבים החדשים לאימות החשבון שנדרשים לאפליקציה, למשל כדי לוודא שהסיסמה של החשבון החדש הוקלדה בצורה נכונה ועומדת בדרישות המורכבות שלך.
  2. כדי ליצור חשבון חדש, מעבירים את כתובת האימייל והסיסמה של המשתמש החדש אל Auth::CreateUserWithEmailAndPassword: 
    firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
  3. אם לתוכנית יש לולאת עדכון שפועלת באופן קבוע (למשל 30 או 60 פעמים בשנייה), אפשר לבדוק את התוצאות פעם אחת בכל עדכון באמצעות 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());
  }
}
     לחלופין, אם התוכנית מבוססת על אירועים, ייתכן שתעדיפו לרשום התקשרות חזרה בעתיד.

כניסה של משתמש באמצעות כתובת אימייל וסיסמה

השלבים לכניסה של משתמש באמצעות סיסמה דומים לשלבים ליצירת חשבון חדש. בפונקציית הכניסה של האפליקציה, מבצעים את הפעולות הבאות:

  1. כשמשתמש נכנס לאפליקציה, מעבירים את כתובת האימייל והסיסמה שלו אל firebase::auth::Auth::SignInWithEmailAndPassword: 
    firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
  2. אם בתוכנית יש לולאת עדכון שרצה באופן קבוע (למשל ב-30 או 60 פעמים בשנייה), תוכלו לבדוק את התוצאות פעם אחת בכל עדכון באמצעות Auth::SignInWithEmailAndPasswordLastResult: 
    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());
  }
}
     לחלופין, אם התוכנית שלכם מבוססת על אירועים, תוכלו לרשום קריאה חוזרת (callback) ב-Future.

רישום של שיחה חוזרת ב-Future‏

בחלק מהתוכניות יש פונקציות Update שנקראות 30 או 60 פעמים בשנייה. לדוגמה, יש הרבה משחקים שמבוססים על המודל הזה. התוכניות האלה יכולות להפעיל את הפונקציות LastResult כדי לבצע סקרים של קריאות אסינכרוניות. עם זאת, אם התוכנית שלכם מבוססת על אירועים, יכול להיות שתעדיפו לרשום פונקציות קריאה חוזרת (callback). מתבצעת קריאה לפונקציית קריאה חוזרת (callback) לאחר השלמת העתיד. 
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);
}
 אם רוצים, אפשר להשתמש גם בפונקציית למדה כפונקציית ה-callback. 
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);
}

מומלץ: הגדרת מדיניות סיסמאות

כדי לשפר את אבטחת החשבון, אפשר לאכוף דרישות לגבי מורכבות הסיסמאות.

כדי להגדיר מדיניות סיסמאות לפרויקט, פותחים את הכרטיסייה Password policy בדף Authentication Settings במסוף Firebase:

הגדרות אימות

כללי המדיניות של Firebase Authentication בנושא סיסמאות תומכים בדרישות הבאות לסיסמאות:

  • חובה להשתמש באותיות קטנות בלבד

  • צריך להזין תו גדול

  • יש להזין תו מספר

  • חובה להזין תו שאינו אלפאנומרי

    התווים הבאים עומדים בדרישות לגבי תווים שאינם אלפאנומריים: ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~

  • אורך הסיסמה המינימלי (נע בין 6 ל-30 תווים, ברירת המחדל היא 6)

  • האורך המקסימלי של הסיסמה (אורך מקסימלי של 4,096 תווים)

אפשר להפעיל את האכיפה של מדיניות הסיסמאות בשני מצבים:

  • דרישה: ניסיונות הרשמה ייכשלו עד שהמשתמש יתעדכן לסיסמה שתואמת למדיניות שלכם.

  • התרעה: המשתמשים יכולים להירשם עם סיסמה שלא עומדת בדרישות. כשמשתמשים במצב הזה, צריך לבדוק אם הסיסמה של המשתמש עומדת בדרישות המדיניות בצד הלקוח, ולבקש מהמשתמש לעדכן את הסיסמה אם היא לא עומדת בדרישות.

משתמשים חדשים תמיד נדרשים לבחור סיסמה שתואמת למדיניות שלכם.

אם יש לכם משתמשים פעילים, מומלץ לא להפעיל את השדרוג המאולץ בזמן הכניסה, אלא אם אתם מתכוונים לחסום את הגישה של משתמשים שהסיסמאות שלהם לא עומדות בדרישות המדיניות. במקום זאת, כדאי להשתמש במצב הודעה, שמאפשר למשתמשים להיכנס לחשבון עם הסיסמאות הנוכחיות שלהם, וליידע אותם לגבי הדרישות שאין להם סיסמה.

מומלץ: הפעלת הגנה על ספירת כתובות אימייל

שיטות מסוימות של Firebase Authentication שמקבלות כתובות אימייל כפרמטרים גורמות להצגת שגיאות ספציפיות אם כתובת האימייל לא רשומה כשצריך לרשום אותה (לדוגמה, כשיוצרים חשבון באמצעות כתובת אימייל וסיסמה), או אם היא רשומה כשאסור להשתמש בה (לדוגמה, כשמשנים את כתובת האימייל של משתמש). היכולת הזו יכולה לעזור להציע למשתמשים תכשירים ספציפיים, אבל גורמים זדוניים עלולים לנצל אותה לרעה כדי לגלות את כתובות האימייל שנרשמו על ידי המשתמשים.

כדי לצמצם את הסיכון הזה, מומלץ להפעיל הגנה על ספירת כתובות אימייל בפרויקט באמצעות הכלי gcloud של Google Cloud. שימו לב שהפעלת התכונה הזו משנה את אופן הדיווח על שגיאות של Firebase Authentication: צריך לוודא שהאפליקציה לא מסתמכת על השגיאות הספציפיות יותר.

השלבים הבאים

אחרי שמשתמש נכנס לחשבון בפעם הראשונה, נוצר חשבון משתמש חדש שמקושר לפרטי הכניסה – כלומר שם המשתמש והסיסמה, מספר הטלפון או פרטי ספק האימות – שבאמצעותם המשתמש נכנס לחשבון. החשבון החדש הזה מאוחסן כחלק מפרויקט Firebase, וניתן להשתמש בו כדי לזהות משתמש בכל האפליקציות בפרויקט, ללא קשר לאופן שבו המשתמש נכנס לחשבון.

  • באפליקציות, אפשר לקבל את פרטי הפרופיל הבסיסיים של המשתמש מהאובייקט 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();
}

  • בכללי האבטחה של Firebase Realtime Database ו-Cloud Storage, אפשר לקבל את מזהה המשתמש הייחודי של המשתמש שנכנס לחשבון מהמשתנה auth, ולהשתמש בו כדי לקבוע לאילו נתונים למשתמש תהיה גישה.

כדי לאפשר למשתמשים להיכנס לאפליקציה באמצעות כמה ספקי אימות, אפשר לקשר את פרטי הכניסה של ספק האימות לחשבון משתמש קיים.

כדי להוציא משתמש מהחשבון, קוראים לפונקציה SignOut():

auth->SignOut();