Authentifizieren Sie sich mit Apple

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Sie können Ihren Benutzern ermöglichen, sich bei Firebase mit ihrer Apple-ID zu authentifizieren, indem Sie das Firebase SDK verwenden, um den End-to-End-OAuth 2.0-Anmeldeablauf auszuführen.

Bevor Sie beginnen

Um Benutzer mit Apple anzumelden, konfigurieren Sie zunächst „Mit Apple anmelden“ auf der Entwickler-Website von Apple und aktivieren Sie dann Apple als Anmeldeanbieter für Ihr Firebase-Projekt.

Treten Sie dem Apple-Entwicklerprogramm bei

Mit Apple anmelden kann nur von Mitgliedern des Apple Developer Program konfiguriert werden.

Konfigurieren Sie die Anmeldung mit Apple

  1. Aktivieren Sie „Mit Apple anmelden“ für Ihre App auf der Seite „ Zertifikate, Kennungen und Profile “ der Entwickler-Website von Apple.
  2. Wenn Sie eine der Funktionen von Firebase Authentication verwenden, die E-Mails an Benutzer senden, einschließlich E-Mail-Link-Anmeldung, E-Mail-Adressüberprüfung, Widerruf von Kontoänderungen und andere, konfigurieren Sie den privaten Apple-E-Mail- Weiterleitungsdienst und registrieren noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (oder Ihre angepasste E-Mail-Vorlagendomäne), damit Apple von Firebase Authentication gesendete E-Mails an anonymisierte Apple-E-Mail-Adressen weiterleiten kann.

Aktivieren Sie Apple als Anmeldeanbieter

  1. Fügen Sie Ihrem Apple-Projekt Firebase hinzu . Achten Sie darauf, die Paket-ID Ihrer App zu registrieren, wenn Sie Ihre App in der Firebase-Konsole einrichten.
  2. Öffnen Sie in der Firebase-Konsole den Abschnitt Auth . Aktivieren Sie auf der Registerkarte Anmeldemethode den Apple -Anbieter. Wenn Sie in einer App nur „Mit Apple anmelden“ verwenden, können Sie die Felder „Service-ID“, „Apple-Team-ID“, „Privater Schlüssel“ und „Schlüssel-ID“ leer lassen.

Erfüllen Sie die Anforderungen von Apple an anonymisierte Daten

Mit Apple anmelden bietet Benutzern die Möglichkeit, ihre Daten, einschließlich ihrer E-Mail-Adresse, bei der Anmeldung zu anonymisieren. Benutzer, die diese Option wählen, haben E-Mail-Adressen mit der Domäne privaterelay.appleid.com . Wenn Sie „Mit Apple anmelden“ in Ihrer App verwenden, müssen Sie alle geltenden Entwicklerrichtlinien oder Bedingungen von Apple in Bezug auf diese anonymisierten Apple-IDs einhalten.

Dazu gehört auch das Einholen der erforderlichen Benutzereinwilligung, bevor Sie direkt identifizierende personenbezogene Daten mit einer anonymisierten Apple-ID verknüpfen. Bei Verwendung der Firebase-Authentifizierung kann dies die folgenden Aktionen umfassen:

  • Verknüpfen Sie eine E-Mail-Adresse mit einer anonymisierten Apple-ID oder umgekehrt.
  • Verknüpfen Sie eine Telefonnummer mit einer anonymisierten Apple-ID oder umgekehrt
  • Verknüpfen Sie einen nicht anonymen Social Credential (Facebook, Google usw.) mit einer anonymisierten Apple ID oder umgekehrt.

Die obige Liste ist nicht vollständig. Lesen Sie die Lizenzvereinbarung für das Apple-Entwicklerprogramm im Abschnitt „Mitgliedschaft“ Ihres Entwicklerkontos, um sicherzustellen, dass Ihre App die Anforderungen von Apple erfüllt.

Melden Sie sich bei Apple an und authentifizieren Sie sich bei Firebase

Um sich bei einem Apple-Konto zu authentifizieren, melden Sie den Benutzer zuerst mit dem AuthenticationServices -Framework von Apple bei seinem Apple-Konto an und verwenden Sie dann das ID-Token aus der Antwort von Apple, um ein Firebase AuthCredential Objekt zu erstellen:

  1. Generieren Sie für jede Anmeldeanforderung eine zufällige Zeichenfolge – eine „Nonce“ –, die Sie verwenden, um sicherzustellen, dass das ID-Token, das Sie erhalten, speziell als Antwort auf die Authentifizierungsanforderung Ihrer App gewährt wurde. Dieser Schritt ist wichtig, um Replay-Angriffe zu verhindern.

    Sie können eine kryptografisch sichere Nonce mit SecRandomCopyBytes(_:_:_) generieren, wie im folgenden Beispiel:

    Schnell

    // 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: [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
    }
    
        

    Ziel 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];
    }
        

    Sie senden den SHA256-Hash der Nonce mit Ihrer Anmeldeanforderung, die Apple unverändert in der Antwort weitergibt. Firebase validiert die Antwort, indem es die ursprüngliche Nonce hasht und mit dem von Apple übergebenen Wert vergleicht.

    Schnell

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

    Ziel 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;
    }
        
  2. Starten Sie den Anmeldeablauf von Apple, einschließlich des SHA256-Hashes der Nonce und der Delegate-Klasse, die Apples Antwort verarbeiten wird (siehe nächster Schritt):

    Schnell

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

    Ziel 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];
    }
    
  3. Behandeln Sie die Antwort von Apple in Ihrer Implementierung von ASAuthorizationControllerDelegate . Wenn die Anmeldung erfolgreich war, verwenden Sie das ID-Token aus der Antwort von Apple mit dem ungehashten Nonce, um sich bei Firebase zu authentifizieren:

    Schnell

    @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)")
      }
    
    }
    

    Ziel 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);
    }
    

Im Gegensatz zu anderen Anbietern, die von Firebase Auth unterstützt werden, stellt Apple keine Foto-URL bereit.

Wenn der Benutzer sich entscheidet, seine E-Mail-Adresse nicht mit der App zu teilen, stellt Apple eine eindeutige E-Mail-Adresse für diesen Benutzer (in der Form xyz@privaterelay.appleid.com ) bereit, die es mit Ihrer App teilt. Wenn Sie den privaten E-Mail-Weiterleitungsdienst konfiguriert haben, leitet Apple an die anonymisierte Adresse gesendete E-Mails an die echte E-Mail-Adresse des Benutzers weiter.

Apple teilt Benutzerinformationen wie den Anzeigenamen nur mit Apps, wenn sich ein Benutzer zum ersten Mal anmeldet. Normalerweise speichert Firebase den Anzeigenamen, wenn sich ein Benutzer zum ersten Mal bei Apple anmeldet, den Sie mit Auth.auth().currentUser.displayName . Wenn Sie jedoch zuvor Apple verwendet haben, um einen Benutzer bei der App anzumelden, ohne Firebase zu verwenden, stellt Apple Firebase nicht den Anzeigenamen des Benutzers bereit.

Erneute Authentifizierung und Kontoverknüpfung

Das gleiche Muster kann mit reauthenticateWithCredential() verwendet werden, mit dem Sie neue Anmeldeinformationen für vertrauliche Vorgänge abrufen können, die eine kürzlich erfolgte Anmeldung erfordern:

Schnell

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

Ziel 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.
  // ...
}];

Und Sie können linkWithCredential() verwenden, um verschiedene Identitätsanbieter mit bestehenden Konten zu verknüpfen.

Beachten Sie, dass Apple verlangt, dass Sie die ausdrückliche Zustimmung der Benutzer einholen, bevor Sie ihre Apple-Konten mit anderen Daten verknüpfen.

Mit der Anmeldung bei Apple können Sie keine Authentifizierungsdaten erneut verwenden, um eine Verknüpfung mit einem vorhandenen Konto herzustellen. Wenn Sie eine Anmeldung mit Apple-Anmeldeinformationen mit einem anderen Konto verknüpfen möchten, müssen Sie zuerst versuchen, die Konten mit der alten Anmeldung mit Apple-Anmeldeinformationen zu verknüpfen, und dann den zurückgegebenen Fehler untersuchen, um eine neue Anmeldeinformation zu finden. Die neuen Anmeldeinformationen befinden sich im userInfo -Wörterbuch des Fehlers und können über den Schlüssel FIRAuthErrorUserInfoUpdatedCredentialKey werden.

Um beispielsweise ein Facebook-Konto mit dem aktuellen Firebase-Konto zu verknüpfen, verwenden Sie das Zugriffstoken, das Sie erhalten haben, als Sie den Benutzer bei Facebook angemeldet haben:

Schnell

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

Ziel 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.
  // ...
}];

Nächste Schritte

Nachdem sich ein Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen verknüpft – d. h. dem Benutzernamen und Kennwort, der Telefonnummer oder den Authentifizierungsanbieterinformationen –, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Benutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Benutzer anmeldet.

  • In Ihren Apps können Sie die grundlegenden Profilinformationen des Benutzers aus dem FIRUser Objekt abrufen. Siehe Benutzer verwalten .

  • In Ihren Sicherheitsregeln für die Firebase-Echtzeitdatenbank und den Cloudspeicher können Sie die eindeutige Benutzer-ID des angemeldeten Benutzers aus der Variablen auth und damit steuern, auf welche Daten ein Benutzer zugreifen kann.

Sie können Benutzern erlauben, sich mit mehreren Authentifizierungsanbietern bei Ihrer App anzumelden, indem Sie die Anmeldeinformationen des Authentifizierungsanbieters mit einem vorhandenen Benutzerkonto verknüpfen.

Um einen Benutzer abzumelden, rufen signOut: .

Schnell

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

Ziel c

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

Möglicherweise möchten Sie auch Fehlerbehandlungscode für alle Authentifizierungsfehler hinzufügen. Siehe Behandlung von Fehlern .