אמת באמצעות אפל ב- iOS

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

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

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

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

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

הגדר כניסה עם Apple

  1. אפשר כניסה עם אפל עבור האפליקציה שלך על התעודות, מזהה לפרופילי דף באתר המפתחים של אפל.
  2. אם אתה משתמש בכל התכונות של אימות Firebase ששולחים מיילים למשתמשים, כולל קישור בדוא"ל הכניסה, אימות כתובת הדוא"ל, חשבון שינוי הביטול, ואחרים, להגדיר את שירות ממסר הדוא"ל הפרטית אפל ולרשום noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (או דומיין תבנית הדוא"ל המותאמת אישית שלך) כך שאפל תוכל להעביר הודעות דוא"ל שנשלחו על ידי אימות Firebase לכתובות דוא"ל אנונימיות של אפל.

הפעל את Apple כספק כניסה

  1. להוסיף Firebase לפרויקט iOS שלך . הקפד לרשום את מזהה החבילה של האפליקציה שלך בעת הגדרת האפליקציה במסוף Firebase.
  2. בשנות ה קונסולת Firebase , פתח את הקטע המחבר. 'הכניסה דרך כרטיסיית שיטה, לאפשר הספק האפל. אם אתה משתמש רק בכניסה עם Apple באפליקציית iOS, תוכל להשאיר את שדות השירות, מזהה צוות Apple, מפתח פרטי ומזהה מפתח ריקים.

ציית לדרישות הנתונים האנונימיות של אפל

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

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

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

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

היכנס באמצעות Apple והפעל באמצעות Firebase

כדי לאמת עם חשבון אפל, לחתום תחילה על המשתמש לאפל שלהם חשבון באמצעות של אפל AuthenticationServices המסגרת , ולאחר מכן להשתמש מזהה אסימון מן התגובה של אפל ליצור Firebase AuthCredential אובייקט:

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

    אתה יכול ליצור הוה מאובטח באופן מוצפן על iOS עם SecRandomCopyBytes(_:_:_) , כמו בדוגמה הבאה:

    מָהִיר

    // Adapted from https://auth0.com/docs/api-auth/tutorials/nonce#generate-a-cryptographically-random-nonce
    private func randomNonceString(length: Int = 32) -> String {
      precondition(length > 0)
      let charset: Array<Character> =
          Array("0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._")
      var result = ""
      var remainingLength = length
    
      while remainingLength > 0 {
        let randoms: [UInt8] = (0 ..< 16).map { _ in
          var random: UInt8 = 0
          let errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random)
          if errorCode != errSecSuccess {
            fatalError("Unable to generate nonce. SecRandomCopyBytes failed with OSStatus \(errorCode)")
          }
          return random
        }
    
        randoms.forEach { random in
          if remainingLength == 0 {
            return
          }
    
          if random < charset.count {
            result.append(charset[Int(random)])
            remainingLength -= 1
          }
        }
      }
    
      return result
    }
    

    Objective-C

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

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

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

    מָהִיר

    import CryptoKit
    
    // Unhashed nonce.
    fileprivate var currentNonce: String?
    
    @available(iOS 13, *)
    func startSignInWithAppleFlow() {
      let nonce = randomNonceString()
      currentNonce = nonce
      let appleIDProvider = ASAuthorizationAppleIDProvider()
      let request = appleIDProvider.createRequest()
      request.requestedScopes = [.fullName, .email]
      request.nonce = sha256(nonce)
    
      let authorizationController = ASAuthorizationController(authorizationRequests: [request])
      authorizationController.delegate = self
      authorizationController.presentationContextProvider = self
      authorizationController.performRequests()
    }
    
    @available(iOS 13, *)
    private func sha256(_ input: String) -> String {
      let inputData = Data(input.utf8)
      let hashedData = SHA256.hash(data: inputData)
      let hashString = hashedData.compactMap {
        return String(format: "%02x", $0)
      }.joined()
    
      return hashString
    }
    

    Objective-C

    @import CommonCrypto;
    
    - (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;
    }
    
  3. טפל התגובה של אפל ביישום שלך ASAuthorizationControllerDelegate . אם הכניסה הייתה מוצלחת, השתמש באסימון הזיהוי מהתגובה של אפל עם ה- nonce שלא נמחץ לאימות באמצעות Firebase:

    מָהִיר

    @available(iOS 13.0, *)
    extension MainViewController: ASAuthorizationControllerDelegate {
    
      func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
        if let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
          guard let nonce = currentNonce else {
            fatalError("Invalid state: A login callback was received, but no login request was sent.")
          }
          guard let appleIDToken = appleIDCredential.identityToken else {
            print("Unable to fetch identity token")
            return
          }
          guard let idTokenString = String(data: appleIDToken, encoding: .utf8) else {
            print("Unable to serialize token string from data: \(appleIDToken.debugDescription)")
            return
          }
          // Initialize a Firebase credential.
          let credential = OAuthProvider.credential(withProviderID: "apple.com",
                                                    IDToken: idTokenString,
                                                    rawNonce: nonce)
          // Sign in with Firebase.
          Auth.auth().signIn(with: credential) { (authResult, error) in
            if error {
              // Error. If error.code == .MissingOrInvalidNonce, make sure
              // you're sending the SHA256-hashed nonce as a hex string with
              // your request to Apple.
              print(error.localizedDescription)
              return
            }
            // User is signed in to Firebase with Apple.
            // ...
          }
        }
      }
    
      func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
        // Handle error.
        print("Sign in with Apple errored: \(error)")
      }
    
    }
    

    Objective-C

    - (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);
        }
    
        // Initialize a Firebase credential.
        FIROAuthCredential *credential = [FIROAuthProvider credentialWithProviderID:@"apple.com"
                                                                            IDToken:idToken
                                                                           rawNonce:rawNonce];
    
        // Sign in with Firebase.
        [[FIRAuth auth] signInWithCredential:credential
                                  completion:^(FIRAuthDataResult * _Nullable authResult,
                                               NSError * _Nullable error) {
          if (error != nil) {
            // Error. If error.code == FIRAuthErrorCodeMissingOrInvalidNonce,
            // make sure you're sending the SHA256-hashed nonce as a hex string
            // with your request to Apple.
            return;
          }
          // Sign-in succeeded!
        }];
      }
    }
    
    - (void)authorizationController:(ASAuthorizationController *)controller
               didCompleteWithError:(NSError *)error API_AVAILABLE(ios(13.0)) {
      NSLog(@"Sign in with Apple errored: %@", error);
    }
    

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

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

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

אימות מחדש וקישור חשבון

אותו הדפוס יכול לשמש עם reauthenticateWithCredential() , שבו ניתן להשתמש כדי לשלוף תעודה טריה עבור פעולות רגישות הדורשות כניסה אחרונה:

מָהִיר

// Initialize a fresh Apple credential with Firebase.
let credential = OAuthProvider.credential(
  withProviderID: "apple.com",
  IDToken: appleIdToken,
  rawNonce: rawNonce
)
// Reauthenticate current Apple user with fresh Apple credential.
Auth.auth().currentUser.reauthenticate(with: credential) { (authResult, error) in
  guard error != nil else { return }
  // Apple user successfully re-authenticated.
  // ...
}

Objective-C

FIRAuthCredential *credential = [FIROAuthProvider credentialWithProviderID:@"apple.com",
                                                                   IDToken:appleIdToken,
                                                                  rawNonce:rawNonce];
[[FIRAuth auth].currentUser
    reauthenticateWithCredential:credential
                      completion:^(FIRAuthDataResult * _Nullable authResult,
                                   NSError * _Nullable error) {
  if (error) {
    // Handle error.
  }
  // Apple user successfully re-authenticated.
  // ...
}];

וגם, אתה יכול להשתמש linkWithCredential() לקשר ספקי זהות שונים לחשבונות קיימים.

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

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

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

מָהִיר

// Initialize a Facebook credential with Firebase.
let credential = FacebookAuthProvider.credential(
  withAccessToken: AccessToken.current!.tokenString
)
// Assuming the current user is an Apple user linking a Facebook provider.
Auth.auth().currentUser.link(with: credential) { (authResult, error) in
  // Facebook credential is linked to the current Apple user.
  // The user can now sign in with Facebook or Apple to the same Firebase
  // account.
  // ...
}

Objective-C

// Initialize a Facebook credential with Firebase.
FacebookAuthCredential *credential = [FIRFacebookAuthProvider credentialWithAccessToken:accessToken];
// Assuming the current user is an Apple user linking a Facebook provider.
[FIRAuth.auth linkWithCredential:credential completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
  // Facebook credential is linked to the current Apple user.
  // The user can now sign in with Facebook or Apple to the same Firebase
  // account.
  // ...
}];

הצעדים הבאים

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

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

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

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

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

מָהִיר

    let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}
  

Objective-C

    NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

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