Możesz umożliwić użytkownikom uwierzytelnianie w Firebase za pomocą ich identyfikatorów Apple ID, korzystając z pakietu SDK Firebase do przeprowadzenia pełnego procesu logowania OAuth 2.0.
Zanim zaczniesz
Aby logować użytkowników przy użyciu urządzenia Apple, najpierw skonfiguruj funkcję Zaloguj się przez Apple w witrynie dla deweloperów Apple, a potem włącz Apple jako dostawcę logowania w swoim projekcie Firebase.
Dołącz do programu dla deweloperów Apple
Funkcja Zaloguj się przez Apple może skonfigurować tylko członkowie programu dla deweloperów Apple.
Skonfiguruj logowanie się przez Apple
- Włącz w swojej aplikacji funkcję Zaloguj się przez Apple na stronie Certyfikaty, identyfikatory i profile w witrynie dla deweloperów Apple.
- Powiąż witrynę z aplikacją w sposób opisany w pierwszej sekcji artykułu Konfigurowanie logowania się przez Apple w przeglądarce. Gdy pojawi się prośba, zarejestruj ten URL jako zwrotny adres URL:
https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler
Identyfikator projektu Firebase znajdziesz na stronie ustawień konsoli Firebase. Gdy skończysz, zanotuj nowy identyfikator usługi, który będzie Ci potrzebny w następnej sekcji. - Utwórz klucz prywatny logowania się przez Apple. W następnej sekcji będą Ci potrzebne nowy klucz prywatny i identyfikator klucza.
- Jeśli używasz dowolnej funkcji uwierzytelniania Firebase, która wysyła e-maile do użytkowników, w tym logowania za pomocą linku przez e-maila, weryfikacji adresu e-mail, unieważnienia zmiany konta itp., skonfiguruj usługę prywatnego przekaźnika poczty e-mail firmy Apple
i zarejestruj się
noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com
(lub własną domenę szablonu e-maila), aby firma Apple mogła przekazywać e-maile wysyłane przez usługę Uwierzytelnianie Firebase na zanonimizowane adresy e-mail Apple.
Włącz Apple jako dostawcę logowania
- Dodaj Firebase do projektu Apple. Pamiętaj, by zarejestrować identyfikator pakietu aplikacji podczas konfigurowania aplikacji w konsoli Firebase.
- W konsoli Firebase otwórz sekcję Uwierzytelnianie. Na karcie Metoda logowania włącz dostawcę Apple. Podaj identyfikator usługi utworzony w poprzedniej sekcji. Poza tym w sekcji Konfiguracja przepływu kodu OAuth podaj identyfikator zespołu Apple oraz klucz prywatny i identyfikator klucza utworzone w poprzedniej sekcji.
Zgodność z wymaganiami firmy Apple dotyczącymi zanonimizowanych danych
Zaloguj się przez Apple umożliwia anonimizację danych, w tym adresu e-mail, podczas logowania. Użytkownicy, którzy wybiorą tę opcję, mają adresy e-mail w domenie privaterelay.appleid.com
. Gdy w swojej aplikacji korzystasz z funkcji Zaloguj się przez Apple, musisz przestrzegać wszystkich obowiązujących zasad dla deweloperów i warunków firmy Apple dotyczących tych zanonimizowanych identyfikatorów Apple.
Obejmuje to uzyskanie wymaganej zgody użytkownika przed powiązaniem danych osobowych umożliwiających bezpośrednią identyfikację z anonimowym identyfikatorem Apple ID. Gdy używasz uwierzytelniania Firebase, może to wiązać się z tymi działaniami:
- Połącz adres e-mail z anonimowym identyfikatorem Apple ID lub odwrotnie.
- Łączenie numeru telefonu z anonimowym identyfikatorem Apple ID i odwrotnie
- Połącz nieanonimowe dane społecznościowe (Facebook, Google itp.) z anonimowym identyfikatorem Apple lub odwrotnie.
Powyższa lista nie jest wyczerpująca. Zapoznaj się z umową licencyjną programu Apple dla deweloperów w sekcji Subskrypcja na koncie dewelopera, aby upewnić się, że Twoja aplikacja spełnia wymagania Apple.
Zaloguj się przez Apple i uwierzytelnij się w Firebase
Aby uwierzytelnić się na koncie Apple, najpierw zaloguj użytkownika na to konto za pomocą platformy AuthenticationServices
Apple, a potem użyj tokena identyfikatora z odpowiedzi Apple do utworzenia obiektu Firebase AuthCredential
:
Dla każdego żądania logowania wygeneruj losowy ciąg znaków (jednorazowy), którego będziesz używać do sprawdzania, czy otrzymany token tożsamości został przyznany w odpowiedzi na żądanie uwierzytelnienia aplikacji. Ten krok jest ważny, aby zapobiec atakom typu replay.
Możesz wygenerować kryptograficznie zabezpieczoną liczbę jednorazową za pomocą
SecRandomCopyBytes(_:_:_)
, jak w tym przykładzie:Swift
private func randomNonceString(length: Int = 32) -> String { precondition(length > 0) var randomBytes = [UInt8](repeating: 0, count: length) let errorCode = SecRandomCopyBytes(kSecRandomDefault, randomBytes.count, &randomBytes) if errorCode != errSecSuccess { fatalError( "Unable to generate nonce. SecRandomCopyBytes failed with OSStatus \(errorCode)" ) } let charset: [Character] = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._") let nonce = randomBytes.map { byte in // Pick a random character from the set, wrapping around if needed. charset[Int(byte) % charset.count] } return String(nonce) }
Objective-C
// Adapted from https://auth0.com/docs/api-auth/tutorials/nonce#generate-a-cryptographically-random-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--; } } } return [result copy]; }
W żądaniu logowania wysyłasz identyfikator SHA256 identyfikatora jednorazowego, który Apple przekaże w odpowiedzi bez zmian. Firebase weryfikuje odpowiedź, szyfrując pierwotną liczbę jednorazową i porównując ją z wartością przekazaną przez Apple.
Swift
@available(iOS 13, *) private func sha256(_ input: String) -> String { let inputData = Data(input.utf8) let hashedData = SHA256.hash(data: inputData) let hashString = hashedData.compactMap { String(format: "%02x", $0) }.joined() return hashString }
Objective-C
- (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; }
Uruchom proces logowania Apple, m.in. w żądaniu identyfikatora SHA256 wartości jednorazowej oraz klasy delegowanej, która będzie obsługiwać odpowiedź Apple (patrz następny krok):
Swift
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() }
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]; }
Przetwarzaj odpowiedź Apple w implementacji
ASAuthorizationControllerDelegate
. Jeśli logowanie się udało, użyj tokena identyfikatora z odpowiedzi Apple z niezaszyfrowaną liczbą jednorazową, aby uwierzytelnić się w Firebase:Swift
@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, including the user's full name. let credential = OAuthProvider.appleCredential(withIDToken: idTokenString, rawNonce: nonce, fullName: appleIDCredential.fullName) // 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, including the user's full name. FIROAuthCredential *credential = [FIROAuthProvider appleCredentialWithIDToken:IDToken rawNonce:self.appleRawNonce fullName:appleIDCredential.fullName]; // 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); }
W przeciwieństwie do innych dostawców obsługiwanych przez Uwierzytelnianie Firebase Apple nie udostępnia adresu URL zdjęcia.
Oprócz tego, gdy użytkownik zdecyduje się nie udostępniać swojego adresu e-mail aplikacji, Apple udostępnia mu unikalny adres e-mail (w formie formularza xyz@privaterelay.appleid.com
), który udostępnia aplikacji. Jeśli masz skonfigurowaną prywatną usługę przekaźnika, Apple przekazuje e-maile wysyłane na anonimowy adres na rzeczywisty adres użytkownika.
Ponowne uwierzytelnianie i łączenie kont
Tego samego wzorca można używać z zasadą reauthenticateWithCredential()
, za pomocą której możesz pobrać nowe dane logowania w przypadku poufnych operacji, które wymagają niedawnego zalogowania:
Swift
// 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.
// ...
}];
Za pomocą linkWithCredential()
możesz też łączyć różnych dostawców tożsamości z istniejącymi kontami.
Pamiętaj, że firma Apple wymaga uzyskania wyraźnej zgody użytkowników przed połączeniem ich kont Apple z innymi danymi.
Funkcja Zaloguj się przez Apple nie pozwala na ponowne użycie danych uwierzytelniających uwierzytelniania do połączenia z istniejącym kontem. Jeśli chcesz połączyć dane logowania Zaloguj się przez Apple z innym kontem, musisz najpierw spróbować połączyć konta za pomocą starych danych logowania Zaloguj się przez Apple, a następnie sprawdzić zwrócony błąd, aby znaleźć nowe dane logowania.
Nowe dane logowania będą znajdować się w słowniku userInfo
błędu i będą dostępne za pomocą klucza AuthErrorUserInfoUpdatedCredentialKey
.
Aby np. połączyć konto na Facebooku z bieżącym kontem Firebase, użyj tokena dostępu uzyskanego po zalogowaniu użytkownika na Facebooku:
Swift
// 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.
// ...
}];
Unieważnienie tokena
Firma Apple wymaga, aby aplikacje, które umożliwiają tworzenie kont, muszą umożliwiać użytkownikom zainicjowanie usunięcia konta z poziomu aplikacji, zgodnie z opisem w wytycznych dotyczących zamieszczania opinii w sklepie z aplikacjami.
Aby spełnić to wymaganie, wykonaj następujące czynności:
Upewnij się, że wypełniono sekcje Identyfikator usług i Konfiguracja przepływu kodu OAuth w konfiguracji dostawcy funkcji Zaloguj się przez Apple, jak opisano w sekcji Konfigurowanie logowania przez Apple.
Firebase nie przechowuje tokenów użytkowników tworzonych za pomocą funkcji Zaloguj się przez Apple, więc przed unieważnieniem tokena i usunięciem konta musisz poprosić użytkownika o ponowne zalogowanie się.
Swift
private func deleteCurrentUser() { do { let nonce = try CryptoUtils.randomNonceString() currentNonce = nonce let appleIDProvider = ASAuthorizationAppleIDProvider() let request = appleIDProvider.createRequest() request.requestedScopes = [.fullName, .email] request.nonce = CryptoUtils.sha256(nonce) let authorizationController = ASAuthorizationController(authorizationRequests: [request]) authorizationController.delegate = self authorizationController.presentationContextProvider = self authorizationController.performRequests() } catch { // In the unlikely case that nonce generation fails, show error view. displayError(error) } }
Uzyskaj kod autoryzacji ze źródła
ASAuthorizationAppleIDCredential
i użyj go do wywołania metodyAuth.auth().revokeToken(withAuthorizationCode:)
w celu unieważnienia tokenów użytkownika.Swift
func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) { guard let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential else { print("Unable to retrieve AppleIDCredential") return } guard let _ = currentNonce else { fatalError("Invalid state: A login callback was received, but no login request was sent.") } guard let appleAuthCode = appleIDCredential.authorizationCode else { print("Unable to fetch authorization code") return } guard let authCodeString = String(data: appleAuthCode, encoding: .utf8) else { print("Unable to serialize auth code string from data: \(appleAuthCode.debugDescription)") return } Task { do { try await Auth.auth().revokeToken(withAuthorizationCode: authCodeString) try await user?.delete() self.updateUI() } catch { self.displayError(error) } } }
Na koniec usuń konto użytkownika (i wszystkie powiązane z nim dane).
Dalsze kroki
Gdy użytkownik loguje się po raz pierwszy, tworzone jest nowe konto użytkownika, które jest łączone z danymi logowania (nazwa użytkownika i hasło, numer telefonu lub informacje o dostawcy uwierzytelniania). Nowe konto jest przechowywane w ramach Twojego projektu Firebase i może być używane do identyfikowania użytkowników we wszystkich aplikacjach w Twoim projekcie niezależnie od tego, jak się on loguje.
-
W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu
User
. Zobacz Zarządzanie użytkownikami. W regułach zabezpieczeń Bazy danych czasu rzeczywistego Firebase i Cloud Storage możesz pobrać ze zmiennej
auth
unikalny identyfikator użytkownika zalogowanego użytkownika i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.
Możesz zezwolić użytkownikom na logowanie się w aplikacji przy użyciu różnych dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.
Aby wylogować użytkownika, wywołaj
signOut:
.
Swift
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; }
Możesz też dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Patrz sekcja Obsługa błędów.