Ta strona została przetłumaczona przez Cloud Translation API.

Uwierzytelnij przez Apple

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.

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 metody Auth.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.

Uwierzytelnij przez Apple

Zanim zaczniesz

Dołącz do programu dla deweloperów Apple

Skonfiguruj logowanie się przez Apple

Włącz Apple jako dostawcę logowania

Zgodność z wymaganiami firmy Apple dotyczącymi zanonimizowanych danych

Zaloguj się przez Apple i uwierzytelnij się w Firebase

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Ponowne uwierzytelnianie i łączenie kont

Swift

Objective-C

Swift

Objective-C

Unieważnienie tokena

Swift

Swift

Dalsze kroki

Swift

Objective-C