דף זה תורגם על ידי Cloud Translation API.

אימות באמצעות Apple ו-C++

אתה יכול לאפשר למשתמשים שלך לבצע אימות עם Firebase באמצעות Apple ID שלהם באמצעות Firebase SDK כדי לבצע את זרימת הכניסה מקצה לקצה OAuth 2.0.

לפני שאתה מתחיל

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

הצטרף לתוכנית המפתחים של אפל

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

Apple Sign In חייב להיות זמין ומוגדר כהלכה בפרויקט Firebase שלך. התצורה משתנה בין פלטפורמות אנדרואיד ואפל. אנא עקוב אחר הסעיף "הגדר כניסה עם אפל" של פלטפורמות אפל ו/או מדריכי אנדרואיד לפני שתמשיך.

במסוף Firebase , פתח את הקטע Auth . בכרטיסייה שיטת כניסה , הפעל את ספק Apple .
הגדר את הגדרות ספק הכניסה של Apple:
1. אם אתה פורס את האפליקציה שלך רק בפלטפורמות של Apple, תוכל להשאיר את השדות מזהה שירות, מזהה צוות Apple, מפתח פרטי ומזהה מפתח ריקים.
2. לתמיכה במכשירי אנדרואיד:
  1. הוסף את Firebase לפרויקט Android שלך . הקפד לרשום את חתימת ה-SHA-1 של האפליקציה שלך כאשר אתה מגדיר את האפליקציה שלך במסוף Firebase.
  2. במסוף Firebase , פתח את הקטע Auth . בכרטיסייה שיטת כניסה , הפעל את ספק Apple . ציין את מזהה השירות שיצרת בסעיף הקודם. כמו כן, בסעיף תצורת זרימת קוד OAuth, ציין את מזהה צוות Apple שלך ואת המפתח הפרטי ומזהה המפתח שיצרת בסעיף הקודם.

עמוד בדרישות הנתונים האנונימיים של Apple

כניסה עם אפל נותנת למשתמשים אפשרות להפוך את הנתונים שלהם לאנונימיים, כולל כתובת הדוא"ל שלהם, בעת הכניסה. למשתמשים שבוחרים באפשרות זו יש כתובות דוא"ל עם הדומיין privaterelay.appleid.com . כאשר אתה משתמש בכניסה עם Apple באפליקציה שלך, עליך לציית לכל מדיניות מפתחים או תנאים רלוונטיים של Apple לגבי מזהי Apple אנונימיים אלה.

זה כולל קבלת כל הסכמת משתמש נדרשת לפני שאתה משייך מידע אישי מזהה ישיר עם מזהה Apple אנונימי. בעת שימוש באימות Firebase, זה עשוי לכלול את הפעולות הבאות:

קשר כתובת אימייל למזהה Apple אנונימי או להיפך.
קשר מספר טלפון למזהה Apple אנונימי או להיפך
קשר אישור חברתי לא אנונימי (פייסבוק, גוגל וכו') למזהה Apple אנונימי או להיפך.

הרשימה לעיל אינה ממצה. עיין בהסכם הרישיון של Apple Developer Program בסעיף החברות בחשבון המפתח שלך כדי לוודא שהאפליקציה שלך עומדת בדרישות של Apple.

גש למחלקת `firebase::auth::Auth`

מחלקת Auth היא השער לכל קריאות ה-API.

הוסף את קובצי ה-Auth ו-App header:

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

בקוד האתחול שלך, צור מחלקה 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__)

רכוש את מחלקת firebase::auth::Auth עבור firebase::App שלך. יש מיפוי אחד לאחד בין App ו- Auth .
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

טפל בזרימת הכניסה עם Firebase SDK

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

בפלטפורמות של אפל

אמת את המשתמשים שלך עם Firebase באמצעות Apple Sign In Objective-C SDK שהופעל מקוד C++ שלך.

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

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

אתה תשלח את ה-hash SHA256 של nonce עם בקשת הכניסה שלך, שאפל תעביר ללא שינוי בתגובה. Firebase מאמת את התגובה על ידי hashing של ה-nonce המקורי והשוואתה לערך שהעביר אפל.

התחל את זרימת הכניסה של אפל, כולל בבקשתך את ה-hash SHA256 של ה-nonce ומחלקת הנציג שתטפל בתגובה של אפל (ראה את השלב הבא):

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

טפל בתגובה של אפל ביישום שלך ASAuthorizationControllerDelegate`. אם הכניסה הצליחה, השתמש באסימון המזהה מהתגובה של אפל עם ה-nonce unhashed כדי לאמת עם 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);
      }
    }

השתמש במחרוזת האסימון שהתקבלה וב-nonce המקורי כדי לבנות אישור Firebase ולהיכנס ל-Firebase.

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

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

ניתן להשתמש באותה דפוס עם Reauthenticate אשר ניתן להשתמש בו כדי לאחזר אישורים טריים עבור פעולות רגישות הדורשות כניסה אחרונה.
```
firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);
```

ניתן להשתמש באותה דפוס כדי לקשר חשבון עם Apple Sign In. עם זאת, אתה עלול להיתקל בשגיאה כאשר חשבון Firebase קיים כבר קושר לחשבון Apple שאליו אתה מנסה לקשר. כאשר זה קורה, העתיד יחזיר סטטוס של kAuthErrorCredentialAlreadyInUse וה- AuthResult עשוי להכיל credential חוקי. ניתן להשתמש באישור זה כדי להיכנס לחשבון המקושר ל-Apple באמצעות SignInAndRetrieveDataWithCredential ללא צורך ליצור אסימון Apple Sign In נוסף וללא צורך.

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.
}

באנדרואיד

ב-Android, אמת את המשתמשים שלך עם Firebase על ידי שילוב OAuth Login גנרי מבוסס-אינטרנט באפליקציה שלך באמצעות Firebase SDK כדי לבצע את זרימת הכניסה מקצה לקצה.

כדי לטפל בזרימת הכניסה עם Firebase SDK, בצע את השלבים הבאים:

בנה מופע של FederatedOAuthProviderData המוגדר עם מזהה הספק המתאים לאפל.
```
firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
```
אופציונלי: ציין היקפי OAuth 2.0 נוספים מעבר לברירת המחדל שברצונך לבקש מספק האימות.
```
provider_data.scopes.push_back("email");
provider_data.scopes.push_back("name");
```
אופציונלי: אם ברצונך להציג את מסך הכניסה של אפל בשפה שאינה אנגלית, הגדר את פרמטר locale . עיין במסמכי הכניסה עם Apple למקומות הנתמכים.
```
// Localize to French.
provider_data.custom_parameters["language"] = "fr";
```
```

לאחר שנתוני הספק שלך הוגדרו, השתמש בהם כדי ליצור FederatedOAuthProvider.

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

בצע אימות באמצעות Firebase באמצעות אובייקט ספק האימות. שים לב שבניגוד לפעולות אחרות של FirebaseAuth, זה ישתלט על ממשק המשתמש שלך על ידי הצגת תצוגת אינטרנט שבה המשתמש יכול להזין את האישורים שלו.
כדי להתחיל את זרימת הכניסה, התקשר ל- signInWithProvider :
```
firebase::Future<firebase::auth::AuthResult> result =
  auth->SignInWithProvider(provider_data);
```
לאחר מכן, היישום שלך עשוי להמתין או לרשום התקשרות חוזרת על העתיד .
ניתן להשתמש באותה דפוס עם ReauthenticateWithProvider אשר ניתן להשתמש בו כדי לאחזר אישורים טריים עבור פעולות רגישות הדורשות כניסה אחרונה.
```
firebase::Future<firebase::auth::AuthResult> result =
  user.ReauthenticateWithProvider(provider_data);
```
לאחר מכן, היישום שלך עשוי להמתין או לרשום התקשרות חוזרת על העתיד .
בנוסף, אתה יכול להשתמש LinkWithCredential() כדי לקשר ספקי זהות שונים לחשבונות קיימים.
שים לב שאפל דורשת ממך לקבל הסכמה מפורשת ממשתמשים לפני שתקשר את חשבונות Apple שלהם לנתונים אחרים.
לדוגמה, כדי לקשר חשבון פייסבוק לחשבון Firebase הנוכחי, השתמש באסימון הגישה שקיבלת מהכניסה של המשתמש לפייסבוק:
```
// 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);
```

בניגוד לספקים אחרים הנתמכים על ידי Firebase Auth, אפל לא מספקת כתובת URL של תמונה.

כמו כן, כאשר המשתמש בוחר שלא לשתף את הדוא"ל שלו עם האפליקציה, אפל מספקת כתובת דוא"ל ייחודית עבור אותו משתמש (בצורה xyz@privaterelay.appleid.com ), אותה היא חולקת עם האפליקציה שלך. אם הגדרת את שירות ממסר הדוא"ל הפרטי, אפל מעבירה מיילים שנשלחו לכתובת האנונימית לכתובת הדוא"ל האמיתית של המשתמש.

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

הצעדים הבאים

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

באפליקציות שלך, אתה יכול לקבל את פרטי הפרופיל הבסיסיים של המשתמש מאובייקט firebase::auth::User . ראה ניהול משתמשים .

בכללי האבטחה שלך במסד הנתונים בזמן אמת של Firebase וב-Cloud Storage, תוכל לקבל את מזהה המשתמש הייחודי של המשתמש המחובר ממשתנה האימות, ולהשתמש בו כדי לשלוט לאילו נתונים המשתמש יכול לגשת.