Diese Seite wurde von der Cloud Translation API übersetzt.

Nutzer mit Credential Manager anmelden

Credential Manager ist eine Jetpack API, die mehrere Anmeldemethoden wie Nutzername und Passwort, Passkeys und Verbundanmeldelösungen (z. B. „Über Google anmelden“) in einer einzigen API unterstützt. So wird die Integration für Entwickler vereinfacht.

Außerdem wird die Anmeldeschnittstelle für Nutzer durch Credential Manager über alle Authentifizierungsmethoden hinweg vereinheitlicht. So wird es für Nutzer – unabhängig von der gewählten Methode – übersichtlicher und einfacher, sich anzumelden.

Auf dieser Seite wird das Konzept von Passkeys erläutert und beschrieben, wie Sie mit der Credential Manager API clientseitige Unterstützung für Authentifizierungslösungen wie Passkeys implementieren. Außerdem gibt es eine separate FAQ-Seite, auf der detailliertere, spezifische Fragen beantwortet werden.

Info zu Passkeys

Passkeys sind eine sichere und einfache Alternative zu Passwörtern. Mit Passkeys können sich Nutzer über einen biometrischen Sensor (z. B. Fingerabdruck oder Gesichtserkennung), eine PIN oder ein Muster in Apps und auf Websites anmelden. So wird eine nahtlose Anmeldung ermöglicht, bei der sich Nutzer keine Nutzernamen oder Passwörter merken müssen.

Passkeys basieren auf WebAuthn (Web Authentication), einem Standard, der gemeinsam von der FIDO Alliance und dem World Wide Web Consortium (W3C) entwickelt wurde. WebAuthn verwendet Public-Key-Kryptografie zur Authentifizierung des Nutzers. Die Website oder App, bei der sich der Nutzer anmeldet, kann den öffentlichen Schlüssel sehen und speichern, aber niemals den privaten Schlüssel. Der private Schlüssel wird geheim und sicher aufbewahrt. Da der Schlüssel eindeutig ist und mit der Website oder App verknüpft ist, sind Passkeys nicht anfällig für Phishing.

Mit dem Credential Manager können Nutzer Passkeys erstellen und im Google Passwortmanager speichern.

Nutzerauthentifizierung mit Passkeys

Voraussetzungen

Führen Sie die Schritte in diesem Abschnitt aus, um den Credential Manager zu verwenden.

Aktuelle Plattformversion verwenden

Der Anmeldedaten-Manager wird ab Android 4.4 (API-Level 19) unterstützt.

Abhängigkeiten zur App hinzufügen

Fügen Sie dem Build-Skript Ihres App-Moduls die folgenden Abhängigkeiten hinzu:

implementation(libs.androidx.credentials)

// optional - needed for credentials support from play services, for devices running
// Android 13 and below.
implementation(libs.androidx.credentials.play.services.auth)build.gradle.kts

Weitere Informationen zum Verkleinern, Verschleiern und Optimieren Ihrer App

Unterstützung für Digital Asset Links hinzufügen

Wenn Sie die Passkey-Unterstützung für Ihre Android-App aktivieren möchten, verknüpfen Sie Ihre App mit einer Website, die Ihnen gehört. So deklarieren Sie diese Verknüpfung:

Erstellen Sie eine Digital Asset Links-JSON-Datei. Wenn Sie beispielsweise deklarieren möchten, dass die Website https://signin.example.com und eine Android-App mit dem Paketnamen com.example Anmeldedaten gemeinsam nutzen können, erstellen Sie eine Datei mit dem Namen assetlinks.json mit folgendem Inhalt:

[
  {
    "relation" : [
      "delegate_permission/common.handle_all_urls",
      "delegate_permission/common.get_login_creds"
    ],
    "target" : {
      "namespace" : "android_app",
      "package_name" : "com.example.android",
      "sha256_cert_fingerprints" : [
        SHA_HEX_VALUE
      ]
    }
  }
]assetlinks.json

Das Feld relation ist ein Array mit einem oder mehreren Strings, die die deklarierte Beziehung beschreiben. Wenn Sie angeben möchten, dass Apps und Websites Anmeldedaten gemeinsam nutzen, geben Sie die Beziehungen als delegate_permission/handle_all_urls und delegate_permission/common.get_login_creds an.

Das Feld target ist ein Objekt, das das Asset angibt, für das die Deklaration gilt. Die folgenden Felder identifizieren eine Website:

namespace web

site

Die URL der Website im Format https://domain[:optional_port], z. B. https://www.example.com.

Der domain muss vollständig qualifiziert sein und optional_port muss weggelassen werden, wenn Port 443 für HTTPS verwendet wird.

Ein site-Ziel kann nur eine Stammdomain sein. Sie können eine App-Verknüpfung nicht auf ein bestimmtes Unterverzeichnis beschränken. Die URL darf keinen Pfad enthalten, z. B. einen abschließenden Schrägstrich.

Subdomains werden nicht als Übereinstimmung betrachtet. Wenn Sie also domain als www.example.com angeben, ist die Domain www.counter.example.com nicht mit Ihrer App verknüpft.

Die folgenden Felder identifizieren eine Android-App:

`namespace`	`android_app`
`package_name`	Der im Manifest der App deklarierte Paketname. Beispiel: `com.example.android`
`sha256_cert_fingerprints`	Die SHA256-Fingerabdrücke des Signaturzertifikats Ihrer App.

Hosten Sie die Digital Asset Links-JSON-Datei am folgenden Speicherort in der Anmeldedomain:
```
https://domain[:optional_port]/.well-known/assetlinks.json
```
Wenn Ihre Anmeldedomain beispielsweise signin.example.com ist, hosten Sie die JSON-Datei unter https://signin.example.com/.well-known/assetlinks.json.

Der MIME-Typ für die Digital Asset Links-Datei muss JSON sein. Prüfen Sie, ob der Server in der Antwort einen Content-Type: application/json-Header sendet.
Prüfen Sie, ob Ihr Host Google das Abrufen Ihrer Digital Asset Links-Datei erlaubt. Wenn Sie eine robots.txt-Datei haben, muss sie dem Googlebot-Agent den Abruf von /.well-known/assetlinks.json erlauben. Auf den meisten Websites kann jeder automatisierte Agent Dateien im Pfad /.well-known/ abrufen, damit andere Dienste auf die Metadaten in diesen Dateien zugreifen können:
```
User-agent: *
Allow: /.well-known/
```

Fügen Sie der Manifestdatei unter <application> die folgende Zeile hinzu:

<meta-data android:name="asset_statements" android:resource="@string/asset_statements" />

Wenn Sie die Anmeldung mit Passwort über Credential Manager verwenden, folgen Sie diesem Schritt, um die Verknüpfung digitaler Assets im Manifest zu konfigurieren. Dieser Schritt ist nicht erforderlich, wenn Sie nur Passkeys verwenden.

Deklarieren Sie die Verknüpfung in der Android-App. Fügen Sie ein Objekt hinzu, das die zu ladenden assetlinks.json-Dateien angibt. Alle Apostrophe und Anführungszeichen, die Sie im String verwenden, müssen maskiert werden. Beispiel:
```
<string name="asset_statements" translatable="false">
[{
  \"include\": \"https://signin.example.com/.well-known/assetlinks.json\"
}]
</string>
```
Hinweis :Der https://signin.example.com/.well-known/assetlinks.json-Link muss eine 200-HTTP-Antwort mit einem JSON-MIME-Content-Type-Header zurückgeben. Wenn Sie eine HTTP-Weiterleitung vom Typ 301 oder 302 oder einen Content-Type zurückgeben, der nicht JSON ist, schlägt die Bestätigung fehl. Das folgende Beispiel zeigt eine Anfrage und die zugehörigen Antwortheadern.
```
> GET /.well-known/assetlinks.json HTTP/1.1
> User-Agent: curl/7.35.0
> Host: signin.example.com

< HTTP/1.1 200 OK
< Content-Type: application/json
```

Credential Manager konfigurieren

Fügen Sie zum Konfigurieren und Initialisieren eines CredentialManager-Objekts eine Logik wie die folgende hinzu:

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
private val credentialManager = CredentialManager.create(context)PasskeyAndPasswordFunctions.kt

Felder für Anmeldedaten angeben

Unter Android 14 und höher kann das Attribut isCredential verwendet werden, um Anmeldedatenfelder wie Nutzername- oder Passwortfelder anzugeben. Dieses Attribut gibt an, dass diese Ansicht ein Anmeldedatenfeld ist, das mit dem Credential Manager und Anmeldedatenanbietern von Drittanbietern verwendet werden soll. Außerdem hilft es Autofill-Diensten, bessere Autofill-Vorschläge zu machen. Wenn die App die Credential Manager API verwendet, wird das Credential Manager-Bottom-Sheet mit den verfügbaren Anmeldedaten angezeigt. Das Autofill-Dialogfeld zum Ausfüllen von Nutzername oder Passwort muss nicht mehr angezeigt werden. Ebenso muss der Speicherdialog für die automatische Vervollständigung für Passwörter nicht angezeigt werden, da die App die Credential Manager API anfordert, um die Anmeldedaten zu speichern.

Wenn Sie das Attribut isCredential verwenden möchten, fügen Sie es den entsprechenden Ansichten hinzu:

<TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:isCredential="true" />xmlsnippets.xml

So rufen Sie alle Passkey- und Passwortoptionen ab, die mit dem Konto des Nutzers verknüpft sind:

Initialisieren Sie die Optionen für die Passwort- und Passkey-Authentifizierung:

// Retrieves the user's saved password for your app from their
// password provider.
val getPasswordOption = GetPasswordOption()

// Get passkey from the user's public key credential provider.
val getPublicKeyCredentialOption = GetPublicKeyCredentialOption(
  requestJson = requestJson
)PasskeyAndPasswordFunctions.kt

Verwenden Sie die im vorherigen Schritt abgerufenen Optionen, um die Anmeldeanfrage zu erstellen.

Hinweis:Apps sollten das Feld origin nicht festlegen. Ausnahmen gelten für Browser und ähnlich privilegierte Apps. Weitere Informationen
```
val credentialRequest = GetCredentialRequest(
  listOf(getPasswordOption, getPublicKeyCredentialOption),
)PasskeyAndPasswordFunctions.kt
      
```

Starten Sie den Anmeldevorgang:

coroutineScope {
  try {
    result = credentialManager.getCredential(
      // Use an activity-based context to avoid undefined system UI
      // launching behavior.
      context = activityContext,
      request = credentialRequest
    )
    handleSignIn(result)
  } catch (e: GetCredentialException) {
    // Handle failure
  }
}PasskeyAndPasswordFunctions.kt

fun handleSignIn(result: GetCredentialResponse) {
  // Handle the successfully returned credential.
  val credential = result.credential

  when (credential) {
    is PublicKeyCredential -> {
      val responseJson = credential.authenticationResponseJson
      // Share responseJson i.e. a GetCredentialResponse on your server to
      // validate and  authenticate
    }

    is PasswordCredential -> {
      val username = credential.id
      val password = credential.password
      // Use id and password to send to your server to validate
      // and authenticate
    }

    is CustomCredential -> {
      // If you are also using any external sign-in libraries, parse them
      // here with the utility functions provided.
      if (credential.type == ExampleCustomCredential.TYPE) {
        try {
          val ExampleCustomCredential =
            ExampleCustomCredential.createFrom(credential.data)
          // Extract the required credentials and complete the authentication as per
          // the federated sign in or any external sign in library flow
        } catch (e: ExampleCustomCredential.ExampleCustomCredentialParsingException) {
          // Unlikely to happen. If it does, you likely need to update the dependency
          // version of your external sign-in library.
          Log.e(TAG, "Failed to parse an ExampleCustomCredential", e)
        }
      } else {
        // Catch any unrecognized custom credential type here.
        Log.e(TAG, "Unexpected type of credential")
      }
    }
    else -> {
      // Catch any unrecognized credential type here.
      Log.e(TAG, "Unexpected type of credential")
    }
  }
}PasskeyAndPasswordFunctions.kt

Hinweis:Wenn der Aufruf des Credential Manager durch eine explizite Nutzeraktion ausgelöst wurde, setzen Sie preferImmediatelyAvailableCredentials auf false. Wenn der Anmeldedaten-Manager opportunistisch aufgerufen wurde, setzen Sie preferImmediatelyAvailableCredentials auf true.

Mit der Option preferImmediatelyAvailableCredentials wird festgelegt, ob Sie für die Erfüllung der Anfrage nur lokal verfügbare Anmeldedaten anstelle von Anmeldedaten von Sicherheitsschlüsseln oder hybriden Schlüsselabläufen verwenden möchten. Dieser Wert ist standardmäßig false.

Wenn Sie preferImmediatelyAvailableCredentials auf true festlegen und keine sofort verfügbaren Anmeldedaten vorhanden sind, wird in Credential Manager keine Benutzeroberfläche angezeigt und die Anfrage schlägt sofort fehl. Für GET-Anfragen wird NoCredentialException und für CREATE-Anfragen CreateCredentialNoCreateOptionException zurückgegeben. Dies wird empfohlen, wenn die Credential Manager API opportunistisch aufgerufen wird, z. B. beim ersten Öffnen der App.

Das folgende Beispiel zeigt, wie die JSON-Anfrage formatiert wird, wenn Sie einen Passkey erhalten:

{
  "challenge": "T1xCsnxM2DNL2KdK5CLa6fMhD7OBqho6syzInk_n-Uo",
  "allowCredentials": [],
  "timeout": 1800000,
  "userVerification": "required",
  "rpId": "https://passkeys-codelab.glitch.me/"
}

Das folgende Beispiel zeigt, wie eine JSON-Antwort aussehen könnte, nachdem Sie eine Anmeldedaten für öffentliche Schlüssel erhalten haben:

{
  "id": "KEDetxZcUfinhVi6Za5nZQ",
  "type": "public-key",
  "rawId": "KEDetxZcUfinhVi6Za5nZQ",
  "response": {
    "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uZ2V0IiwiY2hhbGxlbmdlIjoiVDF4Q3NueE0yRE5MMktkSzVDTGE2Zk1oRDdPQnFobzZzeXpJbmtfbi1VbyIsIm9yaWdpbiI6ImFuZHJvaWQ6YXBrLWtleS1oYXNoOk1MTHpEdll4UTRFS1R3QzZVNlpWVnJGUXRIOEdjVi0xZDQ0NEZLOUh2YUkiLCJhbmRyb2lkUGFja2FnZU5hbWUiOiJjb20uZ29vZ2xlLmNyZWRlbnRpYWxtYW5hZ2VyLnNhbXBsZSJ9",
    "authenticatorData": "j5r_fLFhV-qdmGEwiukwD5E_5ama9g0hzXgN8thcFGQdAAAAAA",
    "signature": "MEUCIQCO1Cm4SA2xiG5FdKDHCJorueiS04wCsqHhiRDbbgITYAIgMKMFirgC2SSFmxrh7z9PzUqr0bK1HZ6Zn8vZVhETnyQ",
    "userHandle": "2HzoHm_hY0CjuEESY9tY6-3SdjmNHOoNqaPDcZGzsr0"
  }
}

Ausnahmen behandeln, wenn keine Anmeldedaten verfügbar sind

In einigen Fällen hat der Nutzer möglicherweise keine Anmeldedaten verfügbar oder er erteilt keine Einwilligung zur Verwendung verfügbarer Anmeldedaten. Wenn getCredential() aufgerufen wird und keine Anmeldedaten gefunden werden, wird NoCredentialException zurückgegeben. In diesem Fall sollte Ihr Code die NoCredentialException-Instanzen verarbeiten.

coroutineScope {
  try {
    result = credentialManager.getCredential(
      context = activityContext,
      request = credentialRequest
    )
  } catch (e: GetCredentialException) {
    Log.e("CredentialManager", "No credential available", e)
  }
}PasskeyAndPasswordFunctions.kt

Unter Android 14 oder höher können Sie die Latenz beim Anzeigen der Kontoauswahl reduzieren, indem Sie die Methode prepareGetCredential() aufrufen, bevor Sie getCredential() aufrufen.

coroutineScope {
  val response = credentialManager.prepareGetCredential(
    GetCredentialRequest(
      listOf(
        getPublicKeyCredentialOption,
        getPasswordOption
      )
    )
  )
}PasskeyAndPasswordFunctions.kt

Die Methode prepareGetCredential() ruft keine UI-Elemente auf. Sie hilft Ihnen nur bei der Vorbereitung, damit Sie den verbleibenden Vorgang zum Abrufen von Anmeldedaten (der Benutzeroberflächen umfasst) später über die getCredential() API starten können.

Die im Cache gespeicherten Daten werden in einem PrepareGetCredentialResponse-Objekt zurückgegeben. Wenn Anmeldedaten vorhanden sind, werden die Ergebnisse im Cache gespeichert. Sie können dann später die verbleibende getCredential() API starten, um die Kontoauswahl mit den Daten aus dem Cache aufzurufen.

Registrierungsvorgänge

Sie können einen Nutzer für die Authentifizierung mit einem Passkey oder einem Passwort registrieren.

, um den Nutzer darüber zu informieren, dass er einen Passkey erstellen muss, um die Passkey-Authentifizierung zu unterstützen.

Passkey erstellen

Wenn Sie Nutzern die Möglichkeit geben möchten, einen Passkey zu registrieren und für die Reauthentifizierung zu verwenden, registrieren Sie Anmeldedaten für Nutzer mit einem CreatePublicKeyCredentialRequest-Objekt.

suspend fun createPasskey(requestJson: String, preferImmediatelyAvailableCredentials: Boolean) {
  val createPublicKeyCredentialRequest = CreatePublicKeyCredentialRequest(
    // Contains the request in JSON format. Uses the standard WebAuthn
    // web JSON spec.
    requestJson = requestJson,
    // Defines whether you prefer to use only immediately available
    // credentials, not hybrid credentials, to fulfill this request.
    // This value is false by default.
    preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
  )

  // Execute CreateCredentialRequest asynchronously to register credentials
  // for a user account. Handle success and failure cases with the result and
  // exceptions, respectively.
  coroutineScope {
    try {
      val result = credentialManager.createCredential(
        // Use an activity-based context to avoid undefined system
        // UI launching behavior
        context = activityContext,
        request = createPublicKeyCredentialRequest,
      )
      //  Handle passkey creation result
    } catch (e : CreateCredentialException){
      handleFailure(e)
    }
  }
}PasskeyAndPasswordFunctions.kt

fun handleFailure(e: CreateCredentialException) {
  when (e) {
    is CreatePublicKeyCredentialDomException -> {
      // Handle the passkey DOM errors thrown according to the
      // WebAuthn spec.
    }
    is CreateCredentialCancellationException -> {
      // The user intentionally canceled the operation and chose not
      // to register the credential.
    }
    is CreateCredentialInterruptedException -> {
      // Retry-able error. Consider retrying the call.
    }
    is CreateCredentialProviderConfigurationException -> {
      // Your app is missing the provider configuration dependency.
      // Most likely, you're missing the
      // "credentials-play-services-auth" module.
    }
    is CreateCredentialCustomException -> {
      // You have encountered an error from a 3rd-party SDK. If you
      // make the API call with a request object that's a subclass of
      // CreateCustomCredentialRequest using a 3rd-party SDK, then you
      // should check for any custom exception type constants within
      // that SDK to match with e.type. Otherwise, drop or log the
      // exception.
    }
    else -> Log.w(TAG, "Unexpected exception type ${e::class.java.name}")
  }
}PasskeyAndPasswordFunctions.kt

JSON-Anfrage formatieren

Nachdem Sie einen Passkey erstellt haben, müssen Sie ihn mit dem Konto eines Nutzers verknüpfen und den öffentlichen Schlüssel des Passkeys auf Ihrem Server speichern. Das folgende Codebeispiel zeigt, wie die JSON-Anfrage beim Erstellen eines Passkeys formatiert wird.

In diesem Blogbeitrag zur nahtlosen Authentifizierung in Ihren Apps wird beschrieben, wie Sie Ihre JSON-Anfrage formatieren, wenn Sie Passkeys erstellen und sich mit Passkeys authentifizieren. Außerdem wird erläutert, warum Passwörter keine effektive Authentifizierungslösung sind, wie Sie vorhandene biometrische Anmeldedaten nutzen, wie Sie Ihre App mit einer Website verknüpfen, die Ihnen gehört, wie Sie Passkeys erstellen und wie Sie sich mit Passkeys authentifizieren.

{
  "challenge": "abc123",
  "rp": {
    "name": "Credential Manager example",
    "id": "credential-manager-test.example.com"
  },
  "user": {
    "id": "def456",
    "name": "helloandroid@gmail.com",
    "displayName": "helloandroid@gmail.com"
  },
  "pubKeyCredParams": [
    {
      "type": "public-key",
      "alg": -7
    },
    {
      "type": "public-key",
      "alg": -257
    }
  ],
  "timeout": 1800000,
  "attestation": "none",
  "excludeCredentials": [
    {
      "id": "ghi789",
      "type": "public-key"
    },
    {
      "id": "jkl012",
      "type": "public-key"
    }
  ],
  "authenticatorSelection": {
    "authenticatorAttachment": "platform",
    "requireResidentKey": true,
    "residentKey": "required",
    "userVerification": "required"
  }
}

Werte für „authenticatorAttachment“ festlegen

Der Parameter authenticatorAttachment kann nur beim Erstellen von Anmeldedaten festgelegt werden. Sie können platform, cross-platform oder keinen Wert angeben. In den meisten Fällen wird kein Wert empfohlen.

platform: Wenn Sie das aktuelle Gerät des Nutzers registrieren oder einen Nutzer mit Passwort auffordern möchten, nach der Anmeldung auf Passkeys umzustellen, legen Sie authenticatorAttachment auf platform fest.
cross-platform: Dieser Wert wird häufig bei der Registrierung von Anmeldedaten für die Multi-Faktor-Authentifizierung verwendet und nicht im Kontext von Passkeys.
Kein Wert: Damit Nutzer Passkeys auf ihren bevorzugten Geräten erstellen können (z. B. in den Kontoeinstellungen), sollte der Parameter authenticatorAttachment nicht angegeben werden, wenn ein Nutzer einen Passkey hinzufügen möchte. In den meisten Fällen ist es am besten, den Parameter nicht anzugeben.

Das Erstellen doppelter Passkeys verhindern

Listen Sie Anmeldedaten-IDs im optionalen Array excludeCredentials auf, um zu verhindern, dass ein neuer Passkey erstellt wird, wenn bereits einer mit demselben Passkey-Anbieter vorhanden ist.

JSON-Antwort verarbeiten

Das folgende Code-Snippet zeigt ein Beispiel für eine JSON-Antwort zum Erstellen eines Anmeldedatenpaars mit öffentlichem Schlüssel. Weitere Informationen zum Umgang mit dem zurückgegebenen Anmeldedaten-Credential für den öffentlichen Schlüssel

{
  "id": "KEDetxZcUfinhVi6Za5nZQ",
  "type": "public-key",
  "rawId": "KEDetxZcUfinhVi6Za5nZQ",
  "response": {
    "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIiwiY2hhbGxlbmdlIjoibmhrUVhmRTU5SmI5N1Z5eU5Ka3ZEaVh1Y01Fdmx0ZHV2Y3JEbUdyT0RIWSIsIm9yaWdpbiI6ImFuZHJvaWQ6YXBrLWtleS1oYXNoOk1MTHpEdll4UTRFS1R3QzZVNlpWVnJGUXRIOEdjVi0xZDQ0NEZLOUh2YUkiLCJhbmRyb2lkUGFja2FnZU5hbWUiOiJjb20uZ29vZ2xlLmNyZWRlbnRpYWxtYW5hZ2VyLnNhbXBsZSJ9",
    "attestationObject": "o2NmbXRkbm9uZWdhdHRTdG10oGhhdXRoRGF0YViUj5r_fLFhV-qdmGEwiukwD5E_5ama9g0hzXgN8thcFGRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAEChA3rcWXFH4p4VYumWuZ2WlAQIDJiABIVgg4RqZaJyaC24Pf4tT-8ONIZ5_Elddf3dNotGOx81jj3siWCAWXS6Lz70hvC2g8hwoLllOwlsbYatNkO2uYFO-eJID6A"
  }
}

Ursprung anhand von Clientdaten-JSON überprüfen

Das origin steht für die Anwendung oder Website, von der eine Anfrage stammt, und wird von Passkeys verwendet, um vor Phishing-Angriffen zu schützen. Der Server Ihrer App muss den Ursprung der Clientdaten anhand einer Zulassungsliste genehmigter Apps und Websites prüfen. Wenn der Server eine Anfrage von einer App oder Website mit einem unbekannten Ursprung empfängt, sollte die Anfrage abgelehnt werden.

Im Webfall spiegelt origin den Ursprung derselben Website wider, auf der die Anmeldedaten angemeldet wurden. Bei der URL https://www.example.com:8443/store?category=shoes#athletic ist origin beispielsweise https://www.example.com:8443.

Bei Android-Apps wird der User-Agent automatisch auf origin gesetzt, also auf die Signatur der aufrufenden App. Diese Signatur sollte auf Ihrem Server abgeglichen werden, um den Aufrufer der Passkey API zu validieren. Der Android-origin ist ein URI, der aus dem SHA-256-Hash des APK-Signaturzertifikats abgeleitet wird, z. B.:

android:apk-key-hash:<sha256_hash-of-apk-signing-cert>

Die SHA-256-Hashes der Signaturzertifikate aus einem Keystore können Sie mit dem folgenden Terminalbefehl ermitteln:

keytool -list -keystore <path-to-apk-signing-keystore>

Die SHA-256-Hashes sind in einem durch Doppelpunkte getrennten hexadezimalen Format (91:F7:CB:F9:D6:81…) und die Android-origin-Werte sind base64url-codiert. Dieses Python-Beispiel zeigt, wie Sie das Hash-Format in ein kompatibles, durch Doppelpunkte getrenntes hexadezimales Format umwandeln:

import binascii
import base64
fingerprint = '91:F7:CB:F9:D6:81:53:1B:C7:A5:8F:B8:33:CC:A1:4D:AB:ED:E5:09:C5'
print("android:apk-key-hash:" + base64.urlsafe_b64encode(binascii.a2b_hex(fingerprint.replace(':', ''))).decode('utf8').replace('=', ''))

Ersetzen Sie den Wert von fingerprint durch Ihren eigenen Wert. Hier ein Beispiel für ein Ergebnis:

android:apk-key-hash:kffL-daBUxvHpY-4M8yhTavt5QnFEI2LsexohxrGPYU

Sie können diesen String dann als zulässigen Ursprung auf Ihrem Server abgleichen. Wenn Sie mehrere Signaturzertifikate haben, z. B. Zertifikate für Debugging und Release, oder mehrere Apps, wiederholen Sie den Vorgang und akzeptieren Sie alle diese Ursprünge als gültig auf dem Server.

Passwort eines Nutzers speichern

Wenn der Nutzer einen Nutzernamen und ein Passwort für einen Authentifizierungsablauf in Ihrer App angibt, können Sie Anmeldedaten registrieren, mit denen der Nutzer authentifiziert werden kann. Erstellen Sie dazu ein CreatePasswordRequest-Objekt:

suspend fun registerPassword(username: String, password: String) {
  // Initialize a CreatePasswordRequest object.
  val createPasswordRequest =
    CreatePasswordRequest(id = username, password = password)

  // Create credential and handle result.
  coroutineScope {
    try {
      val result =
        credentialManager.createCredential(
          // Use an activity based context to avoid undefined
          // system UI launching behavior.
          activityContext,
          createPasswordRequest
        )
      // Handle register password result
    } catch (e: CreateCredentialException) {
      handleFailure(e)
    }
  }
}PasskeyAndPasswordFunctions.kt

Wiederherstellung von Anmeldedaten unterstützen

Wenn ein Nutzer keinen Zugriff mehr auf ein Gerät hat, auf dem er seine Anmeldedaten gespeichert hat, muss er sie möglicherweise aus einer sicheren Onlinesicherung wiederherstellen. Weitere Informationen dazu, wie Sie diesen Prozess zum Wiederherstellen von Anmeldedaten unterstützen können, finden Sie in diesem Blogpost im Abschnitt „Zugriff wiederherstellen oder neue Geräte hinzufügen“: Sicherheit von Passkeys im Passwortmanager von Google.

Automatisch Passkeys für Nutzer erstellen

Wenn ein Nutzer keinen Passkey hat, können Sie beim nächsten Mal, wenn er sich mit einem in seinem Passwortmanager gespeicherten Passwort anmeldet, automatisch einen Passkey für ihn erstellen. Legen Sie dazu das Feld isConditionalCreateRequest fest, wenn Sie öffentliche Anmeldedaten anfordern:

CreatePublicKeyCredentialRequest(
    // other parameters
    isConditionalCreateRequest: Boolean = true
)

Wenn sich der Nutzer anmeldet, wird automatisch ein Passkey erstellt und im ausgewählten Passwortmanager des Nutzers gespeichert. Wenn der Google Passwortmanager verwendet wird, muss der Nutzer das im Passwortmanager gespeicherte Passwort bereits verwendet haben (entweder über Credential Manager oder Autofill). Der Nutzer erhält eine Benachrichtigung, wenn dieser Passkey erstellt wird, und kann ihn im Passwortmanager verwalten.

Für diese Funktion ist Version 1.6.0-alpha01 oder höher erforderlich.

Unterstützung für Passwortverwaltungstools mit Passkey-Endpunkten und bekannten URLs hinzugefügt

Für eine nahtlose Integration und zukünftige Kompatibilität mit Tools zur Passwort- und Anmeldedatenverwaltung empfehlen wir, Unterstützung für Passkey-Endpunkte mit bekannten URLs hinzuzufügen. Dies ist ein offenes Protokoll, mit dem beteiligte Parteien ihre Unterstützung für Passkeys offiziell bekanntgeben und direkte Links für die Registrierung und Verwaltung von Passkeys bereitstellen können.

Für eine vertrauende Partei unter https://example.com, die eine Website sowie Android- und iOS-Apps hat, wäre die bekannte URL https://example.com/.well-known/passkey-endpoints.

Wenn die URL abgefragt wird, sollte die Antwort das folgende Schema verwenden:

{
  "enroll": "https://example.com/account/manage/passkeys/create"
  "manage": "https://example.com/account/manage/passkeys"
}

Wenn dieser Link direkt in Ihrer App anstatt im Web geöffnet werden soll, verwenden Sie Android-App-Links.
Weitere Informationen finden Sie in der Erläuterung zur Well-Known-URL für Passkey-Endpunkte auf GitHub.

Nutzern helfen, ihre Passkeys zu verwalten, indem angezeigt wird, von welchem Anbieter sie erstellt wurden

Eine Herausforderung für Nutzer bei der Verwaltung mehrerer Passkeys, die mit einer bestimmten App verknüpft sind, besteht darin, den richtigen Passkey zum Bearbeiten oder Löschen zu finden. Um dieses Problem zu beheben, wird empfohlen, dass Apps und Websites zusätzliche Informationen wie den Anbieter, der die Anmeldedaten erstellt hat, das Erstellungsdatum und das Datum der letzten Verwendung in einer Passkey-Liste auf dem Einstellungsbildschirm Ihrer App angeben.Die Anbieterinformationen werden durch Untersuchen der AAGUID ermittelt, die mit dem entsprechenden Passkey verknüpft ist. Die AAGUID ist Teil der Authentifikatordaten eines Passkeys.

Wenn ein Nutzer beispielsweise einen Passkey auf einem Android-Gerät mit Google Passwortmanager erstellt, erhält der RP eine AAGUID, die in etwa so aussieht: „ea9b8d66-4d01-1d21-3ce4-b6b48cb575d4“. Die vertrauende Partei kann den Passkey in der Passkey-Liste mit einem Hinweis versehen, dass er mit dem Passwortmanager von Google erstellt wurde.

Um eine AAGUID einem Passkey-Anbieter zuzuordnen, können RPs ein von der Community erstelltes Repository von AAGUIDs verwenden. Suchen Sie in der Liste nach der AAGUID, um den Namen und das Symbol des Passkey-Anbieters zu finden.

Weitere Informationen zur AAGUID-Integration

Häufige Fehler beheben

Im Leitfaden zur Fehlerbehebung für Credential Manager finden Sie häufige Fehlercodes, Beschreibungen und Informationen zu den Ursachen.

Zusätzliche Ressourcen

Weitere Informationen zur Credential Manager API und zu Passkeys finden Sie in den folgenden Ressourcen: