Diese Seite wurde von der Cloud Translation API übersetzt.

Mit Apple und C++ authentifizieren

Sie können Ihre Nutzer mit ihrer Apple-ID bei Firebase authentifizieren, indem Sie den OAuth 2.0-Anmeldevorgang mit dem Firebase SDK abwickeln.

Hinweis

Damit du Nutzer über Apple anmelden kannst, musst du zuerst „Über Apple anmelden“ konfigurieren auf der Entwicklerwebsite von Apple ein und aktivieren Sie dann Apple als Anmeldeanbieter für Ihr Firebase-Projekt

Am Apple Developer Program teilnehmen

„Über Apple anmelden“ kann nur von Mitgliedern des Apple-Entwicklerprogramms konfiguriert werden.

Apple Log-in muss in Ihrem Firebase-Projekt aktiviert und ordnungsgemäß konfiguriert sein. Die Konfiguration unterscheidet sich je nach Android- und Apple-Plattform. Bitte folgen Sie der „Über Apple anmelden“ konfigurieren des Abschnitts Apple-Plattformen und/oder Android-Anleitungen fortfahren.

Öffnen Sie in der Firebase-Konsole den Abschnitt Auth. Aktivieren Sie auf dem Tab Anmeldemethode den Anbieter Apple.
Konfigurieren Sie die Einstellungen für den Apple-Anmeldeanbieter:
1. Wenn Sie Ihre App nur auf Apple-Plattformen bereitstellen, können Sie das Feld Die Felder „Dienst-ID“, „Apple-Team-ID“, „Privater Schlüssel“ und „Schlüssel-ID“ sind leer.
2. Support auf Android-Geräten:
  1. Fügen Sie Ihrem Android-Projekt Firebase hinzu. Seien die SHA-1-Signatur Ihrer App registrieren, wenn Sie sie im Firebase-Konsole.
  2. Klicken Sie in der Firebase-App Console den Abschnitt Auth auf. Aktivieren Sie auf dem Tab Anmeldemethode den Anbieter Apple. Geben Sie die Dienst-ID an, die Sie im vorherigen Abschnitt erstellt haben. Im Abschnitt zur Konfiguration des OAuth-Codeflusses geben Sie Ihre Apple Team-ID sowie den von Ihnen erstellten privaten Schlüssel und die Schlüssel-ID an. im vorherigen Abschnitt.

Anforderungen von Apple für anonymisierte Daten einhalten

Mit „Über 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 „Über Apple anmelden“ in Ihrer App verwenden, müssen Sie alle geltenden Entwicklerrichtlinien oder -bedingungen von Apple bezüglich dieser anonymisierten Apple-IDs einhalten.

Außerdem muss die Einwilligung des Nutzers eingeholt werden, bevor personenbezogene Daten mit einer anonymisierten Apple-ID verknüpft werden. Bei Verwendung von Firebase Authentication kann dies Folgendes umfassen: Aktionen:

E-Mail-Adressen mit einer anonymisierten Apple-ID verknüpfen oder umgekehrt
Telefonnummer mit einer anonymisierten Apple-ID verknüpfen oder umgekehrt
Nicht-anonyme Anmeldedaten für soziale Medien (z. B. Facebook oder Google) mit einer anonymisierten Apple-ID verknüpfen und umgekehrt

Die obige Liste ist nicht vollständig. Mit dem Apple Developer Program Lizenzvereinbarung im Bereich „Mitgliedschaft“ deines Entwicklerkontos, 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 Auth- und App-Headerdateien hinzu:

#include "firebase/app.h"
#include "firebase/auth.h"

Erstellen Sie in Ihrem 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__)

Erwerben Sie die Klasse „firebase::auth::Auth“ für Ihr Gerät „firebase::App“. Es gibt eine Eins-zu-Eins-Zuordnung zwischen App und Auth.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Anmeldevorgang mit dem Firebase SDK durchführen

Der Vorgang zum Anmelden über Apple variiert je nach Apple- und Android-Plattform.

Auf Apple-Plattformen

Authentifizieren Sie Ihre Nutzer mit Firebase über das Objective-C SDK für die Apple-Anmeldung, das über Ihren C++-Code aufgerufen wird.

Generieren Sie für jede Anmeldeanfrage einen zufälligen String – ein „Nonce“. So können 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 Ihrer Anfrage den SHA256-Hash der Nonce und die Delegate-Klasse hinzu, 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;
  }

die Antwort von Apple bei der Implementierung ASAuthorizationControllerDelegate`. Wenn die Anmeldung erfolgreich war, verwenden Sie die ID. Token aus der Antwort von Apple mit der nicht gehashten Nonce für die Authentifizierung 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);
      }
    }

Verwende den resultierenden Token-String und das ursprüngliche Nonce, um ein Firebase-Anmeldedatenobjekt zu erstellen und dich 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, wobei werden zum Abrufen neuer Anmeldedaten für vertrauliche Vorgänge verwendet, die Letzte Anmeldung
```
firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);
```

Mit demselben Muster können Sie ein Konto mit Apple Sign In verknüpfen. Es kann jedoch ein Fehler auftreten, wenn ein bestehendes Firebase-Konto bereits mit dem Apple-Konto verknüpft ist, das Sie verknüpfen möchten. In diesem Fall wird für die Zukunft der Status kAuthErrorCredentialAlreadyInUse und AuthResult können einen gültigen credential Diese Anmeldedaten können zur Anmeldung in der von Apple SignInAndRetrieveDataWithCredential-Konto zu erstellen, ohne Generieren Sie ein weiteres Apple-Anmeldetoken und eine Nonce.

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 Nutzer unter Android mit Firebase, indem Sie die webbasierte generische OAuth-Anmeldung mithilfe des Firebase SDK in Ihre App einbinden, um den End-to-End-Anmeldevorgang durchzuführen.

So verwalten 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 über den Standardumfang hinaus zusätzliche OAuth 2.0-Bereiche an. Authentifizierungsanbieter beantragen 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 lassen möchten, legen Sie den Parameter locale fest. Weitere Informationen finden Sie in der Über Apple anmelden für die unterstützten Sprachen.
```
// Localize to French.
provider_data.custom_parameters["language"] = "fr";
```
```

Nachdem Sie die Anbieterdaten konfiguriert haben, erstellen Sie einen FederatedOAuthProvider.

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

Authentifizieren Sie sich bei Firebase mithilfe des Auth-Anbieterobjekts. Im Gegensatz zu anderen FirebaseAuth-Vorgängen wird hier die Kontrolle über die 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 Rückruf für die Future-Funktion registrieren.
Dasselbe Muster kann mit ReauthenticateWithProvider verwendet werden, um aktuelle 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 Rückruf für den Future registrieren.
Außerdem können Sie LinkWithCredential() verwenden, um verschiedene Identitätsanbieter zu verknüpfen in bestehenden Konten.

Apple verlangt, 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 bei der Anmeldung 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 an Apps weiter, wenn sich ein Nutzer das erste Mal anmeldet. Normalerweise speichert Firebase den Anzeigenamen wenn sich ein Nutzer bei der ersten Anmeldung über Apple anmeldet. Dies können Sie current_user().display_name() Wenn Sie Nutzer jedoch zuvor über Apple in der App angemeldet haben, ohne Firebase zu verwenden, 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, d. h. mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen des Authentifizierungsanbieters, mit denen sich der Nutzer angemeldet hat. Dieses neue Konto ist gespeichert unter Ihres Firebase-Projekts an und kann verwendet werden, um einen Nutzer auf allen in Ihrem Projekt verwenden, unabhängig davon, wie sich der Nutzer anmeldet.

Die grundlegenden Profilinformationen der Nutzer finden Sie in Ihren Apps über die firebase::auth::User-Objekt. 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-Variable abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.