Diese Seite wurde von der Cloud Translation API übersetzt.

Anmeldung über ein verknüpftes Konto für Android

Die Anmeldung über ein verknüpftes Konto aktiviert die Funktion Über Google anmelden über One Tap für Nutzer deren Google-Konto bereits mit Ihrem Dienst verknüpft ist. Dadurch wird die da die Nutzer sich mit einem Klick anmelden können, Nutzername und Passwort. Außerdem verringert sich so die Wahrscheinlichkeit, doppelte Konten in Ihrem Dienst.

Die Anmeldung über ein verknüpftes Konto ist als Teil des Anmeldevorgangs über One Tap verfügbar für Android Das bedeutet, dass Sie keine separate Bibliothek importieren müssen, wenn Ihre App ist die One Tap-Funktion bereits aktiviert.

In diesem Dokument erfahren Sie, wie Sie Ihre Android-App so anpassen, dass sie Anmeldung in einem verknüpften Konto.

Funktionsweise

Sie können festlegen, dass verknüpfte Konten während der Anmeldung über One Tap angezeigt werden.
Wenn der Nutzer bei Google angemeldet ist und sein Google-Konto verknüpft mit Konto bei Ihrem Dienst verwenden, wird ein ID-Token für das verknüpfte Konto.
Dem Nutzer wird eine Aufforderung zur Anmeldung über One Tap mit der Option angezeigt, sich in Ihrem mit ihrem verknüpften Konto.
Wenn der Nutzer mit dem verknüpften Konto fortfahren möchte, wird das ID-Token des Nutzers an Ihre App zurückgegeben. Sie gleichen sie mit dem Token ab, das an Ihre um den angemeldeten Nutzer zu identifizieren.

Einrichtung

Entwicklungsumgebung einrichten

Holen Sie sich die neuesten Google Play-Dienste auf Ihrem Entwicklungshost:

Öffnen Sie das Android SDK Manager

Suchen Sie unter SDK-Tools nach Google Play-Dienste.
Wenn der Status dieser Pakete nicht „Installiert“ lautet, wählen Sie beide aus und klicken Sie auf Pakete installieren

Eigene App konfigurieren

Fügen Sie in die Datei build.gradle auf Projektebene das Maven-Repository von Google ein. in den Abschnitten buildscript und allprojects.
```
buildscript {
    repositories {
        google()
    }
}

allprojects {
    repositories {
        google()
    }
}
```
Abhängigkeiten für „Mit Google verknüpfen“ hinzufügen API zu Ihrem Modul Gradle-Datei auf App-Ebene, in der Regel app/build.gradle:
```
dependencies {
  implementation 'com.google.android.gms:play-services-auth:21.2.0'
}
```

Ändern Sie Ihre Android-App so, dass sie die Anmeldung über ein verknüpftes Konto unterstützt

Am Ende des Anmeldevorgangs für ein verknüpftes Konto wird ein ID-Token an Ihr Die Integrität des ID-Tokens muss überprüft werden, bevor der Nutzer angemeldet wird.

Im folgenden Codebeispiel werden die Schritte zum Abrufen beschrieben. Das ID-Token verifizieren und anschließend den Nutzer anmelden.

Erstellen Sie eine Aktivität, um das Ergebnis des Anmelde-Intents zu erhalten

Kotlin

  private val activityResultLauncher = registerForActivityResult(
    ActivityResultContracts.StartIntentSenderForResult()) { result ->
    if (result.resultCode == RESULT_OK) {
      try {
        val signInCredentials = Identity.signInClient(this)
                                .signInCredentialFromIntent(result.data)
        // Review the Verify the integrity of the ID token section for
        // details on how to verify the ID token
        verifyIdToken(signInCredential.googleIdToken)
      } catch (e: ApiException) {
        Log.e(TAG, "Sign-in failed with error code:", e)
      }
    } else {
      Log.e(TAG, "Sign-in failed")
    }
  }

Java

  private final ActivityResultLauncher<IntentSenderResult>
    activityResultLauncher = registerForActivityResult(
    new ActivityResultContracts.StartIntentSenderForResult(),
    result -> {
    If (result.getResultCode() == RESULT_OK) {
        try {
          SignInCredential signInCredential = Identity.getSignInClient(this)
                         .getSignInCredentialFromIntent(result.getData());
          verifyIdToken(signInCredential.getGoogleIdToken());
        } catch (e: ApiException ) {
          Log.e(TAG, "Sign-in failed with error:", e)
        }
    } else {
        Log.e(TAG, "Sign-in failed")
    }
});

Anmeldeanfrage erstellen

Kotlin

private val tokenRequestOptions =
GoogleIdTokenRequestOptions.Builder()
  .supported(true)
  // Your server's client ID, not your Android client ID.
  .serverClientId(getString("your-server-client-id")
  .filterByAuthorizedAccounts(true)
  .associateLinkedAccounts("service-id-of-and-defined-by-developer",
                           scopes)
  .build()

Java

 private final GoogleIdTokenRequestOptions tokenRequestOptions =
     GoogleIdTokenRequestOptions.Builder()
  .setSupported(true)
  .setServerClientId("your-service-client-id")
  .setFilterByAuthorizedAccounts(true)
  .associateLinkedAccounts("service-id-of-and-defined-by-developer",
                            scopes)
  .build()

Intent „Sign-in Pending“ (Anmeldung ausstehend) starten

Kotlin

 Identity.signInClient(this)
    .beginSignIn(
  BeginSignInRequest.Builder()
    .googleIdTokenRequestOptions(tokenRequestOptions)
  .build())
    .addOnSuccessListener{result ->
      activityResultLauncher.launch(result.pendingIntent.intentSender)
  }
  .addOnFailureListener {e ->
    Log.e(TAG, "Sign-in failed because:", e)
  }

Java

 Identity.getSignInClient(this)
  .beginSignIn(
    BeginSignInRequest.Builder()
      .setGoogleIdTokenRequestOptions(tokenRequestOptions)
      .build())
  .addOnSuccessListener(result -> {
    activityResultLauncher.launch(
        result.getPendingIntent().getIntentSender());
})
.addOnFailureListener(e -> {
  Log.e(TAG, "Sign-in failed because:", e);
});

Integrität des ID-Tokens prüfen

Prüfen Sie, ob die folgenden Kriterien erfüllt sind:

Das ID-Token ist ordnungsgemäß von Google signiert. Verwenden Sie die öffentlichen Schlüssel von Google (verfügbar im Format JWK oder PEM), um die Signatur des Tokens zu prüfen. Diese Schlüssel werden regelmäßig rotiert. Prüfen Sie den Cache-Control-Header in der Antwort, um festzustellen, wann Sie sie noch einmal abrufen sollten.
Der Wert von aud im ID-Token entspricht einer der Client-IDs der Anwendung. Diese Prüfung ist erforderlich, um zu verhindern, dass ID-Tokens, die an eine schädliche Anwendung gesendet wurden, für den Zugriff auf Daten desselben Nutzers auf dem Back-End-Server der Anwendung verwendet werden.
Der Wert von iss im ID-Token ist accounts.google.com oder https://accounts.google.com.
Die Ablaufzeit (exp) des ID-Tokens ist noch nicht verstrichen.
Wenn Sie überprüfen müssen, ob das ID-Token ein Google Workspace- oder Cloud-Organisationskonto darstellt, können Sie die hd-Anforderung prüfen, die die gehostete Domain des Nutzers angibt. Dies muss verwendet werden, wenn der Zugriff auf eine Ressource auf Mitglieder bestimmter Domains beschränkt werden soll. Falls dieser Anspruch fehlt, bedeutet das, dass das Konto nicht zu einer von Google gehosteten Domain gehört.

Anstatt eigenen Code zu schreiben, um diese Überprüfungsschritte auszuführen, empfehlen wir dringend, eine Google API-Clientbibliothek für Ihre Plattform oder eine allgemeine JWT-Bibliothek zu verwenden. Zur Entwicklung und Fehlerbehebung können Sie unseren Validierungsendpunkt tokeninfo aufrufen.

Google API-Clientbibliothek verwenden

Mit der Google API-Java-Clientbibliothek wird empfohlen, um Google-ID-Tokens in einer Produktionsumgebung zu validieren.

Java

  import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken;
  import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken.Payload;
  import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier;

  ...

  GoogleIdTokenVerifier verifier = new GoogleIdTokenVerifier.Builder(transport, jsonFactory)
      // Specify the CLIENT_ID of the app that accesses the backend:
      .setAudience(Collections.singletonList(CLIENT_ID))
      // Or, if multiple clients access the backend:
      //.setAudience(Arrays.asList(CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3))
      .build();

  // (Receive idTokenString by HTTPS POST)

  GoogleIdToken idToken = verifier.verify(idTokenString);
  if (idToken != null) {
    Payload payload = idToken.getPayload();

    // Print user identifier
    String userId = payload.getSubject();
    System.out.println("User ID: " + userId);

    // Get profile information from payload
    String email = payload.getEmail();
    boolean emailVerified = Boolean.valueOf(payload.getEmailVerified());
    String name = (String) payload.get("name");
    String pictureUrl = (String) payload.get("picture");
    String locale = (String) payload.get("locale");
    String familyName = (String) payload.get("family_name");
    String givenName = (String) payload.get("given_name");

    // Use or store profile information
    // ...

  } else {
    System.out.println("Invalid ID token.");
  }

Die Methode GoogleIdTokenVerifier.verify() prüft die JWT-Signatur, die aud-Anspruch, iss-Anspruch und exp-Anspruch.

Wenn Sie prüfen müssen, ob das ID-Token für Google Workspace oder Cloud steht Organisationskonto haben, können Sie die hd-Beanspruchung bestätigen, indem Sie den Domainnamen überprüfen Payload.getHostedDomain() zurückgegeben.

Tokeninfo-Endpunkt aufrufen

Eine einfache Möglichkeit zur Validierung einer ID-Token-Signatur für das Debugging ist die Verwendung des Endpunkts tokeninfo. Das Aufrufen dieses Endpunkts erfordert eine zusätzliche Netzwerkanfrage, die den Großteil der Validierung für Sie übernimmt, während Sie die ordnungsgemäße Validierung und die Extraktion der Nutzlast in Ihrem eigenen Code testen. Sie ist nicht für die Verwendung in Produktionscode geeignet, da Anfragen gedrosselt oder auf andere Weise zeitweilig auftretenden Fehlern ausgesetzt werden können.

Wenn Sie ein ID-Token mit dem Endpunkt tokeninfo validieren möchten, senden Sie eine HTTPS-POST- oder -GET-Anfrage an den Endpunkt und übergeben Sie Ihr ID-Token im Parameter id_token. Um beispielsweise das Token "XYZ123" zu validieren, führen Sie die folgende GET-Anfrage aus:

https://oauth2.googleapis.com/tokeninfo?id_token=XYZ123

Wenn das Token ordnungsgemäß signiert ist und die Anforderungen iss und exp die erwarteten Werte haben, erhalten Sie eine HTTP 200-Antwort, in der der Text die ID-Token-Anforderungen im JSON-Format enthält. Sie sehen hier ein Beispiel:

{
 // These six fields are included in all Google ID Tokens.
 "iss": "https://accounts.google.com",
 "sub": "110169484474386276334",
 "azp": "1008719970978-hb24n2dstb40o45d4feuo2ukqmcc6381.apps.googleusercontent.com",
 "aud": "1008719970978-hb24n2dstb40o45d4feuo2ukqmcc6381.apps.googleusercontent.com",
 "iat": "1433978353",
 "exp": "1433981953",

 // These seven fields are only included when the user has granted the "profile" and
 // "email" OAuth scopes to the application.
 "email": "testuser@gmail.com",
 "email_verified": "true",
 "name" : "Test User",
 "picture": "https://lh4.googleusercontent.com/-kYgzyAWpZzJ/ABCDEFGHI/AAAJKLMNOP/tIXL9Ir44LE/s99-c/photo.jpg",
 "given_name": "Test",
 "family_name": "User",
 "locale": "en"
}

Warnung:Auch bei Erhalt dieser Anforderungen müssen Sie prüfen, ob die aud-Anforderung eine der Client-IDs Ihrer Anwendung enthält. Ist dies der Fall, ist das Token gültig und für Ihren Client bestimmt. Sie können die eindeutige Google-ID des Nutzers sicher aus der sub-Anforderung abrufen und verwenden.

Wenn du überprüfen musst, ob das ID-Token ein Google Workspace-Konto darstellt, kannst du die hd-Anforderung prüfen, die die gehostete Domain des Nutzers angibt. Dies muss verwendet werden, wenn der Zugriff auf eine Ressource auf Mitglieder bestimmter Domains beschränkt werden soll. Falls dieser Anspruch fehlt, bedeutet das, dass das Konto nicht zu einer von Google Workspace gehosteten Domain gehört.