Catch up on everything we announced at this year's Firebase Summit. Learn more

Authentifizieren mit Apple

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

Bevor Sie beginnen

Um Benutzer mit Apple anzumelden, konfigurieren Sie zuerst "Mit Apple anmelden" auf der Entwickler-Site von Apple und aktivieren Sie dann Apple als Anmeldeanbieter für Ihr Firebase-Projekt.

Treten Sie dem Apple-Entwicklerprogramm bei

Einloggen mit Apple kann nur von Mitgliedern des so konfiguriert werden , von Apple Developer Program .

Anmeldung mit Apple konfigurieren

  1. Aktivieren Sie Anmeldung mit Apple für Ihre Anwendung auf die Zertifikate, Identifiers & Profile Seite von Apples Entwickler - Website.
  2. Wenn Sie eine beliebige Funktionen von Firebase - Authentifizierung ist , dass E - Mails an die Benutzer senden, einschließlich E - Mail - Link-Anmeldung, E - Mail - Adresse Überprüfung, Kontoänderung Widerruf und andere, configure das Apple private E - noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com Mail - Relay - Dienst und registrieren noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com (oder Ihre benutzerdefinierte E-Mail-Vorlagendomäne), damit Apple von Firebase Authentication gesendete E-Mails an anonymisierte Apple-E-Mail-Adressen weiterleiten kann.

Apple als Anmeldeanbieter aktivieren

  1. In Firebase zu Ihrem Apple - Projekt . Achten Sie darauf, die Bundle-ID Ihrer App zu registrieren, wenn Sie Ihre App in der Firebase Console einrichten.
  2. In der Firebase Konsole , öffnen Sie den Abschnitt Auth. Auf dem Anmelden Methode Registerkarte, aktivieren Sie den Apple - Provider. Wenn Sie Anmelden mit Apple nur in einer App verwenden, können Sie die Felder Service-ID, Apple-Team-ID, privater Schlüssel und Schlüssel-ID leer lassen.

Erfülle die Anforderungen für anonymisierte Daten von Apple

Einloggen mit Apple gibt den Benutzern die Möglichkeit , ihre Daten zu anonymisieren, einschließlich ihrer E - Mail - Adresse, bei der Anmeldung. Benutzer , die diese Option wählen , haben E - Mail - Adressen mit der Domain 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, die erforderliche Zustimmung des Benutzers einzuholen, bevor Sie direkt identifizierende personenbezogene Daten mit einer anonymisierten Apple-ID verknüpfen. Bei der Verwendung von Firebase Authentication 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 sozialen Zugang (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

Für die Authentifizierung mit einem Konto von Apple, den Benutzer zuerst anmelden , um ihre Apple - Konto mit Apple AuthenticationServices Rahmen und dann die ID verwenden , um von Apples Antwort Token auf ein Firebase erstellen AuthCredential Objekt:

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

    Sie können eine kryptografisch sicheren nonce mit generieren SecRandomCopyBytes(_:_:_) , 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 mit Ihrer Anmeldeanfrage den SHA256-Hash der Nonce, den Apple unverändert in der Antwort übergibt. Firebase validiert die Antwort durch Hashing der ursprünglichen Nonce und vergleicht sie mit dem von Apple übergebenen Wert.

    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 Anmeldevorgang von Apple, einschließlich des SHA256-Hashs der Nonce und der Delegate-Klasse, die die Antwort von Apple verarbeitet (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. Griff Apples Antwort in Ihrer Implementierung von ASAuthorizationControllerDelegate . Wenn die Anmeldung erfolgreich war, verwenden Sie das ID-Token aus der Antwort von Apple mit der nicht gehashten 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 von Firebase Auth unterstützten Anbietern stellt Apple keine Foto-URL bereit.

Auch wenn der Benutzer wählt nicht ihre E - Mail mit der App von Apple Bestimmungen einer eindeutige E - Mail - Adresse für den Benutzer (der Form zu teilen xyz@privaterelay.appleid.com ), die es Aktien mit Ihrer App. Wenn Sie den privaten E-Mail-Relay-Dienst konfiguriert haben, leitet Apple an die anonymisierte Adresse gesendete E-Mails an die echte E-Mail-Adresse des Benutzers weiter.

Apple - Aktien nur Benutzerinformationen wie dem Anzeigenamen mit Apps zum ersten Mal ein Benutzer in. In der Regel speichert Firebase der Anzeigename das erste Mal ein Benutzer mit Apple, die Sie mit bekommen 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 den Anzeigenamen des Benutzers nicht zur Verfügung.

Erneute Authentifizierung und Kontoverknüpfung

Das gleiche Muster kann mit verwendet werden reauthenticateWithCredential() , mit dem Sie einen neuen Berechtigungsnachweis abzurufen für sensible Vorgänge verwenden können , die kürzlich eine Anmeldung erforderlich:

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, können Sie linkWithCredential() verschiedene Identity - Provider zu bestehenden Konten zu verknüpfen.

Beachten Sie, dass Sie bei Apple die ausdrückliche Zustimmung der Benutzer einholen müssen, bevor Sie deren Apple-Konten mit anderen Daten verknüpfen.

Wenn Sie sich bei Apple anmelden, können Sie keine Authentifizierungsdaten wiederverwenden, um sie mit einem bestehenden Konto zu verknüpfen. Wenn Sie eine Anmeldung mit Apple-Anmeldeinformationen mit einem anderen Konto verknüpfen möchten, müssen Sie zuerst versuchen, die Konten mit den alten Anmeldeinformationen von Apple zu verknüpfen und dann den zurückgegebenen Fehler untersuchen, um eine neue Anmeldeinformation zu finden. Der neue Berechtigungsnachweis wird in der der Fehler lokalisiert werden userInfo Wörterbuch und kann über die zugegriffen werden FIRAuthErrorUserInfoUpdatedCredentialKey Schlüssel.

Um beispielsweise ein Facebook-Konto mit dem aktuellen Firebase-Konto zu verknüpfen, verwenden Sie das Zugriffstoken, das Sie durch die Anmeldung des Benutzers bei Facebook erhalten 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 anmeldet, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen – d. h. Benutzername und Kennwort, Telefonnummer oder Authentifizierungsanbieterinformationen – verknüpft, 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 Anwendungen können Sie die Benutzerprofilgrundinformationen aus dem bekommen FIRUser Objekt. Siehe Benutzer verwalten .

  • In Ihrer Datenbank und Firebase Realtime Cloud Storage Sicherheitsregeln , können Sie die angemeldeten Nutzer die eindeutige Benutzer - ID aus der bekommen auth Variable, und es verwenden , um steuern kann ein Benutzer Zugriff , welche Daten.

Sie können Benutzer erlauben , durch mehrere Authentifizierungsanbieter anmelden, um Ihre App Verknüpfung Auth - Provider - Anmeldeinformationen zu einem vorhandenen Benutzerkonto.

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 einen Fehlerbehandlungscode für alle Authentifizierungsfehler hinzufügen. Siehe Handle Fehler .