Diese Seite wurde von der Cloud Translation API übersetzt.

Mit Apple und C++ authentifizieren

Sie können Ihren Nutzern die Authentifizierung mit Firebase über ihre Apple-ID ermöglichen, indem Sie das Firebase SDK verwenden, um den End-to-End-OAuth 2.0-Anmeldevorgang durchzuführen.

Hinweis

Wenn Sie Nutzer mit Apple anmelden möchten, müssen Sie zuerst „Mit Apple anmelden“ auf der Entwicklerwebsite von Apple konfigurieren und dann Apple als Anmeldeanbieter für Ihr Firebase-Projekt aktivieren.

Am Apple-Programm für Entwickler teilnehmen

„Über Apple anmelden“ kann nur von Mitgliedern des Apple-Programms für Entwickler konfiguriert werden.

„Mit Apple anmelden“ muss in Ihrem Firebase-Projekt aktiviert und richtig konfiguriert sein. Die Konfiguration variiert je nach Android- und Apple-Plattform. Folgen Sie dem Abschnitt „Mit Apple anmelden konfigurieren“ der Anleitungen für Apple-Plattformen und/oder Android, bevor Sie fortfahren.

Öffnen Sie in der Firebase-Konsole den Bereich Auth (Authentifizierung). Aktivieren Sie auf dem Tab Anmeldemethode den Anbieter Apple.
Konfigurieren Sie die Anmeldeeinstellungen für Apple:
1. Wenn Sie Ihre App nur auf Apple-Plattformen bereitstellen, können Sie die Felder „Dienst-ID“, „Apple-Team-ID“, „privater Schlüssel“ und „Schlüssel-ID“ leer lassen.
2. Support für Android-Geräte:
  1. Fügen Sie Ihrem Android-Projekt Firebase hinzu. Registrieren Sie die SHA-1-Signatur Ihrer App, wenn Sie Ihre App in der Firebase-Konsole einrichten.
  2. Öffnen Sie in der Firebase Console den Bereich Auth. Aktivieren Sie auf dem Tab Anmeldemethode den Anbieter Apple. Geben Sie die Dienst-ID an, die Sie im vorherigen Abschnitt erstellt haben. Geben Sie außerdem im Konfigurationsbereich für den OAuth-Codefluss Ihre Apple-Team-ID sowie den privaten Schlüssel und die Schlüssel-ID an, die Sie im vorherigen Abschnitt erstellt haben.

Anforderungen von Apple für anonymisierte Daten einhalten

Mit „Mit Apple anmelden“ haben Nutzer die Möglichkeit, ihre Daten, einschließlich ihrer E-Mail-Adresse, bei der Anmeldung zu anonymisieren. Nutzer, die diese Option auswählen, haben E-Mail-Adressen mit der Domain privaterelay.appleid.com. Wenn Sie „Mit Apple anmelden“ in Ihrer App verwenden, müssen Sie alle anwendbaren Entwicklerrichtlinien oder ‑bedingungen von Apple bezüglich dieser anonymisierten Apple-IDs einhalten.

Außerdem müssen Sie die erforderliche Einwilligung des Nutzers einholen, bevor Sie direkt identifizierbare personenbezogene Daten mit einer anonymisierten Apple-ID verknüpfen. Wenn Sie die Firebase-Authentifizierung verwenden, kann dies die folgenden Aktionen umfassen:

Eine E‑Mail-Adresse mit einer anonymisierten Apple‑ID verknüpfen und umgekehrt
Telefonnummer mit einer anonymisierten Apple‑ID verknüpfen und umgekehrt
Nicht-anonyme Anmeldedaten für soziale Medien (Facebook, Google usw.) mit einer anonymisierten Apple-ID verknüpfen und umgekehrt

Die obige Liste ist nicht vollständig. In der Lizenzvereinbarung des Apple-Entwicklerprogramms im Mitgliedschaftsbereich Ihres Entwicklerkontos finden Sie Informationen dazu, ob Ihre App die Anforderungen von Apple erfüllt.

Auf die Klasse `firebase::auth::Auth` zugreifen

Die Auth-Klasse ist das Gateway für alle API-Aufrufe.

Fügen Sie die Headerdateien für die Authentifizierung und die App hinzu:
```
#include "firebase/app.h"
#include "firebase/auth.h"
```

Erstellen Sie im Initialisierungscode eine firebase::App-Klasse.

#if defined(__ANDROID__)
  firebase::App* app =
      firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
#else
  firebase::App* app = firebase::App::Create(firebase::AppOptions());
#endif  // defined(__ANDROID__)

Rufen Sie die firebase::auth::Auth-Klasse für Ihre firebase::App ab. Es gibt eine 1:1-Zuordnung zwischen App und Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Anmeldevorgang mit dem Firebase SDK abwickeln

Der Anmeldevorgang über Apple variiert je nach Apple- und Android-Plattform.

Auf Apple-Plattformen

Authentifizieren Sie Ihre Nutzer mit Firebase über das Apple Sign In Objective-C SDK, das von Ihrem C++-Code aufgerufen wird.

Generieren Sie für jede Anmeldeanfrage einen zufälligen String – "Nonce", mit dem Sie prüfen, ob das ID-Token, das Sie erhalten, speziell als Antwort auf die Authentifizierungsanfrage der Anwendung gewährt wurde. Dieser Schritt ist wichtig, um Wiederholungsversuche zu verhindern.

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

Sie senden den SHA256-Hash der Nonce mit Ihrer Anmeldeanfrage, die Apple in der Antwort unverändert übergibt. Firebase validiert die Antwort, indem die ursprüngliche Nonce gehasht und mit dem von Apple übergebenen Wert verglichen wird.

Starten Sie den Anmeldevorgang von Apple und fügen Sie in Ihre Anfrage den SHA256-Hash des Nonce und die Delegate-Klasse ein, die die Antwort von Apple verarbeitet (siehe nächster Schritt):

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

Verarbeiten 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 nicht gehashten Nonce zur Authentifizierung bei Firebase:

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

Verwenden Sie den resultierenden Tokenstring und die ursprüngliche Nonce, um ein Firebase-Anmeldedatenobjekt zu erstellen und sich in Firebase anzumelden.

firebase::auth::OAuthProvider::GetCredential(
        /*provider_id=*/"apple.com", token, nonce,
        /*access_token=*/nullptr);

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

Dasselbe Muster kann mit Reauthenticate verwendet werden, um neue Anmeldedaten für vertrauliche Vorgänge abzurufen, für die eine aktuelle Anmeldung erforderlich ist.
```
firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);
```

Dasselbe Muster kann verwendet werden, um ein Konto mit Apple-Anmeldung zu verknüpfen. Es kann jedoch ein Fehler auftreten, wenn ein vorhandenes Firebase-Konto bereits mit dem Apple-Konto verknüpft ist, das Sie verknüpfen möchten. In diesem Fall gibt der Future den Status kAuthErrorCredentialAlreadyInUse zurück und AuthResult kann ein gültiges credential enthalten. Mit diesen Anmeldedaten kann sich das mit Apple verknüpfte Konto über SignInAndRetrieveDataWithCredential anmelden, ohne dass ein weiteres Apple-Anmeldetoken und ein weiterer Nonce generiert werden müssen.

firebase::Future<firebase::auth::AuthResult> link_result =
    auth->current_user().LinkWithCredential(credential);

// To keep example simple, wait on the current thread until call completes.
while (link_result.status() == firebase::kFutureStatusPending) {
  Wait(100);
}

// Determine the result of the link attempt
if (link_result.error() == firebase::auth::kAuthErrorNone) {
  // user linked correctly.
} else if (link_result.error() ==
               firebase::auth::kAuthErrorCredentialAlreadyInUse &&
           link_result.result()
               ->additional_user_info.updated_credential.is_valid()) {
  // Sign In with the new credential
  firebase::Future<firebase::auth::AuthResult> result =
      auth->SignInAndRetrieveDataWithCredential(
          link_result.result()->additional_user_info.updated_credential);
} else {
  // Another link error occurred.
}

Auf Android-Geräten

Authentifizieren Sie Ihre Nutzer auf Android mit Firebase, indem Sie die webbasierte generische OAuth-Anmeldung in Ihre App einbinden und das Firebase SDK verwenden, um den End-to-End-Anmeldevorgang durchzuführen.

So handhaben Sie den Anmeldevorgang mit dem Firebase SDK:

Erstellen Sie eine Instanz von FederatedOAuthProviderData, die mit der für Apple geeigneten Anbieter-ID konfiguriert ist.
```
firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
```
Optional:Geben Sie zusätzliche OAuth 2.0-Bereiche an, die über die Standardbereiche hinausgehen und die Sie vom Authentifizierungsanbieter anfordern möchten.
```
provider_data.scopes.push_back("email");
provider_data.scopes.push_back("name");
```
Optional:Wenn Sie den Anmeldebildschirm von Apple in einer anderen Sprache als Englisch anzeigen möchten, legen Sie den Parameter locale fest. Eine Liste der unterstützten Sprachen finden Sie in der Dokumentation zu „Mit Apple anmelden“.
```
// Localize to French.
provider_data.custom_parameters["language"] = "fr";
```
```

Nachdem Sie die Daten Ihres Anbieters konfiguriert haben, können Sie damit einen FederatedOAuthProvider erstellen.

// Construct a FederatedOAuthProvider for use in Auth methods.
firebase::auth::FederatedOAuthProvider provider(provider_data);

Authentifizieren Sie sich mit Firebase über das Auth-Anbieterobjekt. Im Gegensatz zu anderen FirebaseAuth-Vorgängen wird dadurch die Steuerung Ihrer Benutzeroberfläche übernommen, indem eine Webansicht eingeblendet wird, in der der Nutzer seine Anmeldedaten eingeben kann.

Rufen Sie signInWithProvider auf, um den Anmeldevorgang zu starten:
```
firebase::Future<firebase::auth::AuthResult> result =
  auth->SignInWithProvider(provider_data);
```
Ihre Anwendung kann dann warten oder einen Callback für die Future registrieren.
Dasselbe Muster kann mit ReauthenticateWithProvider verwendet werden, um neue Anmeldedaten für vertrauliche Vorgänge abzurufen, für die eine aktuelle Anmeldung erforderlich ist.
```
firebase::Future<firebase::auth::AuthResult> result =
  user.ReauthenticateWithProvider(provider_data);
```
Ihre Anwendung kann dann warten oder einen Callback für die Future registrieren.
Mit LinkWithCredential() können Sie verschiedene Identitätsanbieter mit bestehenden Konten verknüpfen.

Hinweis: Apple setzt voraus, dass Sie die ausdrückliche Einwilligung der Nutzer einholen, bevor Sie ihre Apple-Konten mit anderen Daten verknüpfen.

Wenn Sie beispielsweise ein Facebook-Konto mit dem aktuellen Firebase-Konto verknüpfen möchten, verwenden Sie das Zugriffstoken, das Sie beim Anmelden des Nutzers bei Facebook erhalten haben:
```
// Initialize a Facebook credential with a Facebook access token.
AuthCredential credential =
    firebase::auth::FacebookAuthProvider.getCredential(token);

// Assuming the current user is an Apple user linking a Facebook provider.
firebase::Future<firebase::auth::AuthResult> result =
    auth.current_user().LinkWithCredential(credential);
```

Anders als andere von Firebase Auth unterstützte Anbieter stellt Apple keine Foto-URL bereit.

Wenn der Nutzer seine E‑Mail-Adresse nicht mit der App teilen möchte, stellt Apple eine eindeutige E‑Mail-Adresse für diesen Nutzer bereit (im Format xyz@privaterelay.appleid.com), die an Ihre App weitergegeben wird. Wenn Sie den privaten E‑Mail-Relay-Dienst konfiguriert haben, leitet Apple alle an die anonymisierte Adresse gesendeten E‑Mails an die reale E‑Mail-Adresse des Nutzers weiter.

Apple gibt Nutzerinformationen wie den Anzeigenamen nur dann an Apps weiter, wenn sich ein Nutzer zum ersten Mal anmeldet. Normalerweise speichert Firebase den Anzeigenamen, wenn sich ein Nutzer zum ersten Mal mit Apple anmeldet. Sie können ihn mit current_user().display_name() abrufen. Wenn Sie Apple jedoch zuvor verwendet haben, um einen Nutzer ohne Firebase in der App anzumelden, stellt Apple Firebase den Anzeigenamen des Nutzers nicht zur Verfügung.

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, mit denen sich der Nutzer angemeldet hat, also mit dem Nutzernamen und dem Passwort, der Telefonnummer oder den Informationen des Authentifizierungsanbieters. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Nutzer anmeldet.

In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers aus dem firebase::auth::User-Objekt abrufen. Weitere Informationen finden Sie unter Nutzer verwalten.

In Ihren Firebase Realtime Database- und Cloud Storage-Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der auth-Variablen abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

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

Hinweis

Am Apple-Programm für Entwickler teilnehmen

Über Apple anmelden konfigurieren

Apple als Anmeldeanbieter aktivieren