使用凭据管理器登录用户

凭据管理器 是一个 Jetpack API，它支持多种登录方法，例如用户名和密码、密钥通行证和联合登录解决方案（例如 Google 登录）在一个 API 中，从而简化了开发人员的集成。

此外，对于用户而言，凭据管理器统一了跨身份验证方法的登录界面，使用户能够更清晰、更轻松地登录应用，无论他们选择哪种方法。

此页面解释了密钥通行证的概念以及使用凭据管理器 API 实现客户端身份验证解决方案（包括密钥通行证）支持的步骤。还有一个单独的 常见问题解答页面 提供了更详细、更具体的答案。

您的反馈对于改进凭据管理器 API 至关重要。使用以下链接分享您发现的任何问题或改进 API 的想法

提供反馈

关于密钥通行证

密钥通行证 是密码更安全、更简单的替代方案。使用密钥通行证，用户可以使用生物识别传感器（例如指纹或面部识别）、PIN 或图案登录应用和网站。这提供了一种无缝的登录体验，使用户无需记住用户名或密码。

密码密钥依赖于 WebAuthn（网络身份验证），这是 FIDO 联盟和万维网联盟 (W3C) 共同制定的标准。WebAuthn 使用公钥加密技术来验证用户身份。用户登录的网站或应用可以查看和存储公钥，但永远无法访问私钥。私钥保持秘密和安全。并且由于密钥是唯一的，并且与网站或应用绑定，因此密码密钥无法被网络钓鱼窃取，从而增强了安全性。

凭据管理器允许用户创建密码密钥并将其存储在Google 密码管理器中。

阅读使用密码密钥进行用户身份验证，了解如何使用凭据管理器实现无缝密码密钥身份验证流程。

先决条件

要使用凭据管理器，请完成本节中的步骤。

使用较新的平台版本

凭据管理器支持 Android 4.4（API 级别 19）及更高版本。

向您的应用添加依赖项

将以下依赖项添加到您的应用模块的构建脚本中

Kotlin

dependencies {
    implementation("androidx.credentials:credentials:1.5.0-beta01")

    // optional - needed for credentials support from play services, for devices running
    // Android 13 and below.
    implementation("androidx.credentials:credentials-play-services-auth:1.5.0-beta01")
}

Groovy

dependencies {
    implementation "androidx.credentials:credentials:1.5.0-beta01"

    // optional - needed for credentials support from play services, for devices running
    // Android 13 and below.
    implementation "androidx.credentials:credentials-play-services-auth:1.5.0-beta01"
}

在 ProGuard 文件中保留类

在您的模块的proguard-rules.pro文件中，添加以下指令

-if class androidx.credentials.CredentialManager
-keep class androidx.credentials.playservices.** {
  *;
}

了解有关如何缩减、混淆和优化您的应用的更多信息。

添加对数字资产链接的支持

要为您的 Android 应用启用密码密钥支持，请将您的应用与您的应用拥有的网站关联起来。您可以通过完成以下步骤来声明此关联

  1. 创建一个数字资产链接 JSON 文件。例如，要声明网站https://signin.example.com和包名为com.example的 Android 应用可以共享登录凭据，请创建一个名为assetlinks.json的文件，内容如下：

    [
  {
    "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
      ]
    }
  }
]

    relation字段是一个或多个字符串数组，用于描述所声明的关系。要声明应用和站点共享登录凭据，请将关系指定为delegate_permission/handle_all_urls和delegate_permission/common.get_login_creds。

    target字段是一个对象，用于指定声明适用的资产。以下字段标识网站

    namespace web
    site

    网站的 URL，格式为https://domain[:optional_port]；例如，https://www.example.com。

    domain必须是完全限定的，并且在使用 HTTPS 的 443 端口时必须省略optional_port。

    一个site目标只能是根域：您不能将应用关联限制到特定的子目录。不要在 URL 中包含路径，例如尾部斜杠。

    子域不被视为匹配：也就是说，如果您将domain指定为www.example.com，则域www.counter.example.com不会与您的应用关联。

    以下字段标识 Android 应用

    namespace android_app
    package_name 在应用清单中声明的包名。例如，com.example.android
    sha256_cert_fingerprints 您应用的签名证书的 SHA256 指纹。

  2. 将数字资产链接 JSON 文件托管在登录域上的以下位置

    https://domain[:optional_port]/.well-known/assetlinks.json

    例如，如果您的登录域是signin.example.com，则将 JSON 文件托管在https://signin.example.com/.well-known/assetlinks.json。

    数字资产链接文件的 MIME 类型必须为 JSON。确保服务器在响应中发送Content-Type: application/json标头。

  3. 确保您的主机允许 Google 检索您的数字资产链接文件。如果您有robots.txt文件，它必须允许 Googlebot 代理检索/.well-known/assetlinks.json。大多数站点都可以允许任何自动化代理检索/.well-known/路径中的文件，以便其他服务可以访问这些文件中的元数据

    User-agent: *
Allow: /.well-known/

  4. 在<application>下的清单文件中添加以下行

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

  5. 如果您正在通过凭据管理器使用密码登录，请按照此步骤在清单中配置数字资产链接。如果您仅使用密码密钥，则不需要此步骤。

    在 Android 应用中声明关联。添加一个对象，指定要加载的assetlinks.json文件。您必须转义在字符串中使用的任何撇号和引号。例如

    <string name="asset_statements" translatable="false">
[{
  \"include\": \"https://signin.example.com/.well-known/assetlinks.json\"
}]
</string>

    > 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

配置凭据管理器

要配置和初始化CredentialManager对象，请添加类似于以下内容的逻辑

Kotlin

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

Java

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

指示凭据字段

在 Android 14 及更高版本上，可以使用isCredential属性来指示凭据字段，例如用户名或密码字段。此属性指示此视图是一个旨在与凭据管理器和第三方凭据提供程序一起使用的凭据字段，同时帮助自动填充服务提供更好的自动填充建议。当应用使用凭据管理器 API 时，将显示带有可用凭据的凭据管理器底部工作表，并且无需再为用户名或密码显示自动填充的填充对话框。类似地，无需为密码显示自动填充的保存对话框，因为应用将请求凭据管理器 API 保存凭据。

要使用isCredential属性，请将其添加到相关的视图中

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

登录您的用户

要检索与用户帐户关联的所有密码密钥和密码选项，请完成以下步骤

  1. 初始化密码和密码密钥身份验证选项

    Kotlin

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

    Java

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

// Get passkey from the user's public key credential provider.
GetPublicKeyCredentialOption getPublicKeyCredentialOption =
        new GetPublicKeyCredentialOption(requestJson);

  2. 使用从上一步检索到的选项来构建登录请求。

    Kotlin

    val getCredRequest = GetCredentialRequest(
    listOf(getPasswordOption, getPublicKeyCredentialOption)
)

    Java

    GetCredentialRequest getCredRequest = new GetCredentialRequest.Builder()
    .addCredentialOption(getPasswordOption)
    .addCredentialOption(getPublicKeyCredentialOption)
    .build();

  3. 启动登录流程

    Kotlin

    coroutineScope.launch {
    try {
        val result = credentialManager.getCredential(
            // Use an activity-based context to avoid undefined system UI
            // launching behavior.
            context = activityContext,
            request = getCredRequest
        )
        handleSignIn(result)
    } catch (e : GetCredentialException) {
        handleFailure(e)
    }
}

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")
        }
    }
}

    Java

    credentialManager.getCredentialAsync(
    // Use activity based context to avoid undefined
    // system UI launching behavior
    activity,
    getCredRequest,
    cancellationSignal,
    <executor>,
    new CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() {
        @Override
        public void onResult(GetCredentialResponse result) {
            handleSignIn(result);
        }

        @Override
        public void onError(GetCredentialException e) {
            handleFailure(e);
        }
    }
);

public void handleSignIn(GetCredentialResponse result) {
    // Handle the successfully returned credential.
    Credential credential = result.getCredential();
    if (credential instanceof PublicKeyCredential) {
        String responseJson = ((PublicKeyCredential) credential).getAuthenticationResponseJson();
        // Share responseJson i.e. a GetCredentialResponse on your server to validate and authenticate
    } else if (credential instanceof PasswordCredential) {
        String username = ((PasswordCredential) credential).getId();
        String password = ((PasswordCredential) credential).getPassword();
        // Use id and password to send to your server to validate and authenticate
    } else if (credential instanceof CustomCredential) {
        if (ExampleCustomCredential.TYPE.equals(credential.getType())) {
            try {
                ExampleCustomCredential customCred = ExampleCustomCredential.createFrom(customCredential.getData());
                // Extract the required credentials and complete the
                // authentication as per the federated sign in or any external
                // sign in library flow
            } catch (ExampleCustomCredential.ExampleCustomCredentialParsingException e) {
                // 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");
    }
}

以下示例显示了获取密码密钥时如何格式化 JSON 请求

{
  "challenge": "T1xCsnxM2DNL2KdK5CLa6fMhD7OBqho6syzInk_n-Uo",
  "allowCredentials": [],
  "timeout": 1800000,
  "userVerification": "required",
  "rpId": "credential-manager-app-test.glitch.me"
}

以下示例显示了获取公钥凭据后 JSON 响应可能是什么样子

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

处理没有可用凭据时的异常

在某些情况下，用户可能没有任何可用的凭据，或者用户可能不同意使用可用的凭据。如果调用getCredential()并且找不到任何凭据，则会返回NoCredentialException。如果发生这种情况，您的代码应处理NoCredentialException实例。

Kotlin

try {
  val credential = credentialManager.getCredential(credentialRequest)
} catch (e: NoCredentialException) {
  Log.e("CredentialManager", "No credential available", e)
}

Java

try {
  Credential credential = credentialManager.getCredential(credentialRequest);
} catch (NoCredentialException e) {
  Log.e("CredentialManager", "No credential available", e);
}

在 Android 14 或更高版本上，您可以通过在调用getCredential()之前使用prepareGetCredential()方法来减少显示帐户选择器时的延迟。

Kotlin

val response = credentialManager.prepareGetCredential(
  GetCredentialRequest(
    listOf(
      <getPublicKeyCredentialOption>,
      <getPasswordOption>
    )
  )
}

Java

GetCredentialResponse response = credentialManager.prepareGetCredential(
  new GetCredentialRequest(
    Arrays.asList(
      new PublicKeyCredentialOption(),
      new PasswordOption()
    )
  )
);

prepareGetCredential()方法不会调用 UI 元素。它只帮助您执行准备工作，以便您可以稍后通过getCredential()API 启动剩余的获取凭据操作（涉及 UI）。

缓存的数据将返回到PrepareGetCredentialResponse对象中。如果存在现有凭据，则结果将被缓存，然后您可以稍后启动剩余的getCredential()API 来使用缓存的数据调出帐户选择器。

注册流程

您可以使用密码密钥或密码注册用户进行身份验证。

创建密码密钥

要让用户可以选择注册密码密钥并将其用于重新身份验证，请使用CreatePublicKeyCredentialRequest对象注册用户凭据。

Kotlin

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.launch {
        try {
            val result = credentialManager.createCredential(
                // Use an activity-based context to avoid undefined system
                // UI launching behavior
                context = activityContext,
                request = createPublicKeyCredentialRequest,
            )
            handlePasskeyRegistrationResult(result)
        } catch (e : CreateCredentialException){
            handleFailure(e)
        }
    }
}

fun handleFailure(e: CreateCredentialException) {
    when (e) {
        is CreatePublicKeyCredentialDomException -> {
            // Handle the passkey DOM errors thrown according to the
            // WebAuthn spec.
            handlePasskeyError(e.domError)
        }
        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 CreateCredentialUnknownException -> ...
        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}")
    }
}

Java

public void createPasskey(String requestJson, boolean preferImmediatelyAvailableCredentials) {
    CreatePublicKeyCredentialRequest createPublicKeyCredentialRequest =
            // `requestJson` contains the request in JSON format. Uses the standard
            // WebAuthn web JSON spec.
            // `preferImmediatelyAvailableCredentials` defines whether you prefer
            // to only use immediately available credentials, not  hybrid credentials,
            // to fulfill this request. This value is false by default.
            new CreatePublicKeyCredentialRequest(
                requestJson, preferImmediatelyAvailableCredentials);

    // Execute CreateCredentialRequest asynchronously to register credentials
    // for a user account. Handle success and failure cases with the result and
    // exceptions, respectively.
    credentialManager.createCredentialAsync(
        // Use an activity-based context to avoid undefined system
        // UI launching behavior
        requireActivity(),
        createPublicKeyCredentialRequest,
        cancellationSignal,
        executor,
        new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() {
            @Override
            public void onResult(CreateCredentialResponse result) {
                handleSuccessfulCreatePasskeyResult(result);
            }

            @Override
            public void onError(CreateCredentialException e) {
                if (e instanceof CreatePublicKeyCredentialDomException) {
                    // Handle the passkey DOM errors thrown according to the
                    // WebAuthn spec.
                    handlePasskeyError(((CreatePublicKeyCredentialDomException)e).getDomError());
                } else if (e instanceof CreateCredentialCancellationException) {
                    // The user intentionally canceled the operation and chose not
                    // to register the credential.
                } else if (e instanceof CreateCredentialInterruptedException) {
                    // Retry-able error. Consider retrying the call.
                } else if (e instanceof CreateCredentialProviderConfigurationException) {
                    // Your app is missing the provider configuration dependency.
                    // Most likely, you're missing the
                    // "credentials-play-services-auth" module.
                } else if (e instanceof CreateCredentialUnknownException) {
                } else if (e instanceof 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.getClass().getName());
                }
            }
        }
    );
}

格式化 JSON 请求

创建密码密钥后，必须将其与用户的帐户关联，并将密码密钥的公钥存储在您的服务器上。以下代码示例显示了创建密码密钥时如何格式化 JSON 请求。

这篇关于为您的应用带来无缝身份验证的博文向您展示了创建密码密钥时以及使用密码密钥进行身份验证时如何格式化 JSON 请求。它还解释了为什么密码不是有效的身份验证解决方案，如何利用现有的生物识别凭据，如何将您的应用与您拥有的网站关联，如何创建密码密钥以及如何使用密码密钥进行身份验证。

{
  "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"
  }
}

设置 authenticatorAttachment 的值

authenticatorAttachment参数只能在凭据创建时设置。您可以指定platform、cross-platform或无值。在大多数情况下，建议不使用任何值。

  • platform：要注册用户的当前设备或提示密码用户在登录后升级到密钥，请将authenticatorAttachment 设置为 platform。
  • cross-platform：此值通常用于注册多因素凭据，不用于密钥上下文。
  • 无值：为了让用户能够在其首选设备上创建密钥（例如在帐户设置中），当用户选择添加密钥时，不应指定authenticatorAttachment参数。在大多数情况下，最好不指定此参数。

防止创建重复密钥

在可选的excludeCredentials数组中列出凭据 ID，以防止如果已存在具有相同密钥提供程序的密钥，则创建新的密钥。

处理 JSON 响应

以下代码片段显示了创建公钥凭据的 JSON 响应示例。了解更多关于如何处理返回的公钥凭据。

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

验证来自客户端数据 JSON 的来源

origin表示请求来自的应用程序或网站，密钥使用它来防止网络钓鱼攻击。您的应用服务器需要针对批准的应用和网站的白名单检查客户端数据来源。如果服务器收到来自未知来源的应用或网站的请求，则应拒绝该请求。

在 Web 情况下，origin 反映了签署凭据的同站点来源。例如，给定 URL https://www.example.com:8443/store?category=shoes#athletic，origin 是 https://www.example.com:8443。

对于 Android 应用，用户代理会自动将origin 设置为调用应用的签名。此签名应在您的服务器上验证为匹配项，以验证密钥 API 的调用方。Android origin 是从 APK 签名证书的 SHA-256 哈希派生的 URI，例如：

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

可以通过运行以下终端命令找到密钥库中签名证书的 SHA-256 哈希值：

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

SHA-256 哈希值采用冒号分隔的十六进制格式（91:F7:CB:F9:D6:81…），而 Android origin 值是 base64url 编码的。此 Python 示例演示了如何将哈希格式转换为兼容的冒号分隔的十六进制格式：

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('=', ''))

将fingerprint的值替换为您自己的值。这是一个示例结果：

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

然后，您可以将该字符串作为允许的来源与您的服务器匹配。如果您有多个签名证书（例如调试和发布证书）或多个应用，则重复此过程并在服务器上接受所有这些来源为有效来源。

保存用户的密码

如果用户为应用中的身份验证流程提供了用户名和密码，您可以注册可用于验证用户的用户凭据。为此，请创建一个CreatePasswordRequest对象。

Kotlin

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

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

Java

void registerPassword(String username, String password) {
    // Initialize a CreatePasswordRequest object.
    CreatePasswordRequest createPasswordRequest =
        new CreatePasswordRequest(username, password);

    // Register the username and password.
    credentialManager.createCredentialAsync(
        // Use an activity-based context to avoid undefined
        // system UI launching behavior
        requireActivity(),
        createPasswordRequest,
        cancellationSignal,
        executor,
        new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() {
            @Override
            public void onResult(CreateCredentialResponse result) {
                handleResult(result);
            }

            @Override
            public void onError(CreateCredentialException e) {
                handleFailure(e);
            }
        }
    );
}

支持凭据恢复

如果用户不再能够访问存储其凭据的设备，他们可能需要从安全的在线备份中恢复。要了解如何支持此凭据恢复过程，请阅读此博文中标题为“恢复访问权限或添加新设备”的部分：Google 密码管理器中的密钥安全性。

通过密钥端点 well-known URL 添加对密码管理工具的支持

为了与密码和凭据管理工具实现无缝集成和未来的兼容性，我们建议添加对密钥端点 well-known URL 的支持。这是一个开放协议，允许对齐的各方正式宣传其对密钥的支持，并提供密钥注册和管理的直接链接。

  1. 对于位于https://example.com的依赖方，它拥有网站以及 Android 和 iOS 应用，well-known URL 将为https://example.com/.well-known/passkey-endpoints。

  2. 查询 URL 时，响应应使用以下模式：

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

  3. 要使此链接直接在您的应用中打开，而不是在 Web 上打开，请使用Android 应用链接。

  4. 更多详细信息可以在 GitHub 上的密钥端点 well-known URL说明中找到。

通过显示创建密钥的提供商来帮助用户管理其密钥

用户在管理与给定应用关联的多个密钥时面临的一个挑战是识别用于编辑或删除的正确密钥。为了解决这个问题，建议应用和网站在应用的设置屏幕上的密钥列表中包含其他信息，例如创建凭据的提供商、创建日期和上次使用日期。提供商信息是通过检查与相应密钥关联的AAGUID来获得的。AAGUID 可作为密钥的验证器数据的一部分找到。

例如，如果用户使用 Google 密码管理器在 Android 设备上创建密钥，则 RP 将收到类似这样的 AAGUID：“ea9b8d66-4d01-1d21-3ce4-b6b48cb575d4”。依赖方可以在密钥列表中对密钥进行注释，以指示它是使用 Google 密码管理器创建的。

为了将 AAGUID 映射到密钥提供商，RP 可以使用社区提供的 AAGUID 存储库。在列表中查找 AAGUID 以查找密钥提供商名称和图标。

阅读有关AAGUID 集成的更多信息。

排查常见错误

有关常见错误代码、说明及其原因的信息，请参阅凭据管理器故障排除指南。

其他资源

要了解有关凭据管理器 API 和密钥的更多信息，请查看以下资源：