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

Authentifizieren mit Apple und C++

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

Die Apple-Anmeldung muss in Ihrem Firebase-Projekt aktiviert und richtig konfiguriert sein. Die Konfiguration variiert je nach Android- und Apple-Plattform. Bitte folgen Sie dem „Configure Einloggen mit Apple“ Abschnitt der Apple - Plattformen und / oder Android Führer , bevor Sie fortfahren.

Apple als Anmeldeanbieter aktivieren

  1. In der Firebase Konsole , öffnen Sie den Abschnitt Auth. Auf dem Anmelden Methode Registerkarte, aktivieren Sie den Apple - Provider.
  2. Konfigurieren Sie die Einstellungen des Apple-Anmeldeanbieters:
    1. Wenn Sie Ihre App nur auf Apple-Plattformen bereitstellen, können Sie die Felder Service-ID, Apple-Team-ID, privater Schlüssel und Schlüssel-ID leer lassen.
    2. Für Unterstützung auf Android-Geräten:
      1. In Firebase zu dem Android - Projekt . Achten Sie darauf, die SHA-1-Signatur Ihrer App zu registrieren, wenn Sie Ihre App in der Firebase-Konsole einrichten.
      2. In der Firebase Konsole , öffnen Sie den Abschnitt Auth. Auf dem Anmelden Methode Registerkarte, aktivieren Sie den Apple - Provider. Geben Sie die Service-ID an, die Sie im vorherigen Abschnitt erstellt haben. Geben Sie außerdem im Abschnitt zur Konfiguration des OAuth-Codeflusses Ihre Apple-Team-ID sowie den privaten Schlüssel und die Schlüssel-ID an, die Sie im vorherigen Abschnitt erstellt haben.

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.

Besuchen Sie das firebase::auth::Auth Klasse

Die Auth - Klasse ist das Gateway für alle API - Aufrufe.
  1. Fügen Sie die Auth und App - Header - Dateien:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. In Ihrem Initialisierungscode, erstellen Sie 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__)
    
  3. Erwerben Sie die firebase::auth::Auth - Klasse für Ihre firebase::App . Es gibt eine Eins-zu-Eins - Abbildung zwischen App und Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Verwalten Sie den Anmeldevorgang mit dem Firebase SDK

Der Prozess zur Anmeldung bei Apple variiert je nach Apple- und Android-Plattform.

Auf Apple-Plattformen

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

  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.

      - (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 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.

  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):

      - (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;
      }
    
  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 der nicht gehashten Nonce, um sich bei Firebase zu authentifizieren:

      - (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);
          }
        }
    
  4. Verwenden Sie den resultierenden Token-String und die ursprüngliche Nonce, um Firebase-Anmeldeinformationen zu erstellen und sich bei Firebase anzumelden.

    firebase::auth::OAuthProvider::GetCredential(
            /*provider_id=*/"apple.com", token, nonce,
            /*access_token=*/nullptr);
    
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  5. Das gleiche Muster kann mit verwendet wird Reauthenticate , die verwendet werden können , frische Anmeldeinformationen für sensible Vorgänge abzurufen , die letzte Anmeldung erforderlich.

    firebase::Future<firebase::auth::SignInResult> result =
        user->Reauthenticate(credential);
    
  6. Das gleiche Muster kann verwendet werden, um ein Konto mit der Apple-Anmeldung zu verknüpfen. Es kann jedoch zu einem Fehler kommen, wenn ein vorhandenes Firebase-Konto bereits mit dem Apple-Konto verknüpft wurde, mit dem Sie eine Verknüpfung herstellen möchten. Wenn das die Zukunft auftritt , wird einen Status zurückgeben kAuthErrorCredentialAlreadyInUse und das Userinfo - Objekt des SignInResult ein gültiges enthalten updated_credential . Dieser Berechtigungsnachweis kann verwendet werden , in dem Apple-Linked - Konto anmelden über SignInWithCredential ohne die Notwendigkeit , eine anderen Apple - Einloggen Token und nonce zu erzeugen.

    Beachten Sie, dass Sie verwenden müssen LinkAndRetrieveDataWithCredential für diesen Vorgang die Berechtigung enthalten als updated_credential Mitglied der ist SignInResult.UserInfo Objekt.

    firebase::Future<firebase::auth::SignInResult> link_result =
        auth->current_user()->LinkAndRetrieveDataWithCredential(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()->info.updated_credential.is_valid()) {
      // Sign In with the new credential
      firebase::Future<firebase::auth::User*> result = auth->SignInWithCredential(
          link_result.result()->info.updated_credential);
    } else {
      // Another link error occurred.
    }
    

Auf Android

Auf Android authentifizieren Sie Ihre Benutzer mit Firebase, indem Sie webbasiertes generisches OAuth-Login in Ihre App integrieren, indem Sie das Firebase SDK verwenden, um den End-to-End-Anmeldevorgang durchzuführen.

Gehen Sie wie folgt vor, um den Anmeldevorgang mit dem Firebase SDK durchzuführen:

  1. Konstruieren Sie eine Instanz eines FederatedOAuthProviderData mit dem Provider - ID entsprechenden für Apple konfiguriert.

    firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
    
  2. Optional: Geben Sie zusätzliche OAuth 2.0 Bereiche jenseits der Standard , dass Sie auf Anfrage vom Authentifizierungs - Provider wollen.

    provider_data.scopes.push_back("email");
    provider_data.scopes.push_back("name");
    
  3. Optional: Wenn Sie Apples Anmeldebildschirm in einer anderen Sprache als Englisch angezeigt werden sollen, setzen Sie die locale - Parameter. Siehe die Anmeldung mit Apple - docs für die unterstützten Sprachen.

    // Localize to French.
    provider_data.custom_parameters["language"] = "fr";
    ```
    
  4. Nachdem Ihre Anbieterdaten konfiguriert wurden, verwenden Sie sie, um einen FederatedOAuthProvider zu erstellen.

    // Construct a FederatedOAuthProvider for use in Auth methods.
    firebase::auth::FederatedOAuthProvider provider(provider_data);
    
  5. Authentifizieren Sie sich bei Firebase mithilfe des Auth-Provider-Objekts. Beachten Sie, dass dies im Gegensatz zu anderen FirebaseAuth-Vorgängen die Kontrolle über Ihre Benutzeroberfläche übernimmt, indem eine Webansicht geöffnet wird, in der der Benutzer seine Anmeldeinformationen eingeben kann.

    Um das Vorzeichen in Fluss zu starten, rufen signInWithProvider :

    firebase::Future<firebase::auth::SignInResult> result =
      auth->SignInWithProvider(provider_data);
    

    Ihre Anwendung kann dann warten oder einen Rückruf über die Zukunft registrieren .

  6. Das gleiche Muster kann mit verwendet wird ReauthenticateWithProvider die verwendet werden können frische Anmeldeinformationen für sensible Vorgänge abzurufen , die letzte Anmeldung erforderlich.

    firebase::Future<firebase::auth::SignInResult> result =
      user->ReauthenticateWithProvider(provider_data);
    

    Ihre Anwendung kann dann warten oder einen Rückruf über die Zukunft registrieren .

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

    Um beispielsweise ein Facebook-Konto mit dem aktuellen Firebase-Konto zu verknüpfen, verwenden Sie das Zugriffstoken, das Sie von der Anmeldung des Benutzers 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::SignInResult> result =
        auth.getCurrentUser().linkWithCredential(credential);
    

Mit Apple Notes anmelden

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 Firebase speichert der Anzeigename das erste Mal ein Benutzer mit Apple, die Sie mit bekommen getCurrentUser().getDisplayName() . 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.

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 Apps können Sie die grundlegenden Profilinformationen des Benutzers vom firebase::auth::user-Objekt abrufen. Siehe Benutzer verwalten .

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