Web 加密第 2 级

W3C 第一份公开工作草案 2025年4月22日

本文档的更多详细信息

本版本：: https://www.w3.org/TR/2025/WD-webcrypto-2-20250422/
最新发布版本：: https://www.w3.org/TR/webcrypto-2/
最新编辑草案：: https://w3c.github.io/webcrypto/
历史：: https://www.w3.org/standards/history/webcrypto-2/; 提交历史
编辑：: Daniel Huigens （Proton AG）
前任编辑：: Mark Watson - 直到 2016年11月1日; Ryan Sleevi - 直到 2016年1月21日
反馈：: GitHub w3c/webcrypto （拉取请求，新议题，未解决议题）

摘要

本规范描述了一种 JavaScript API，用于在 Web 应用中执行基本的加密操作，例如散列、签名生成与验证，以及加密与解密。此外，它还描述了一种 API，用于让应用生成和/或管理执行这些操作所必需的密钥材料。此 API 的用途包括用户或服务认证、文档或代码签名，以及通信的机密性和完整性。

本文档状态

本节描述的是本文档在其发布时的状态。当前 W3C 出版物列表以及本技术报告的最新修订版可在 W3C 标准和草案索引中找到，网址为 https://www.w3.org/TR/。

本文档由 Web 应用安全工作组作为第一份公开工作草案发布，使用的是推荐标准轨道。

作为第一份公开工作草案发布并不表示得到 W3C 及其成员的认可。

这是一份草案文档，随时可能被其他文档更新、替换或废弃。除作为进行中的工作外，不宜以其他方式引用本文档。

本文档由一个根据 W3C 专利政策运作的工作组制作。 W3C 维护着一个与该工作组交付物有关的任何专利披露的公开列表；该页面还包括披露专利的说明。实际知晓某项专利，并且该个人认为该专利包含必要权利要求的个人，必须按照 W3C 专利政策第 6 节披露相关信息。

本文档受 2023年11月3日 W3C 流程文档管辖。

本节是非规范性的。

Web Cryptography API 定义了一个低级接口，用于与由用户代理管理或暴露的加密密钥材料进行交互。该 API 本身不关心密钥存储的底层实现，但提供了一组通用接口，使富 Web 应用能够执行签名生成与验证、散列与验证、加密与解密等操作，而无需访问原始密钥材料。

加密转换通过 SubtleCrypto 接口暴露，该接口定义了一组方法，用于执行常见的加密操作。除了签名生成与验证、散列与验证，以及加密与解密等操作外，该 API 还提供了用于密钥生成、密钥派生以及密钥导入和导出的接口。

本节是非规范性的。

Web 应用可能希望用基于证明用户拥有某些秘密密钥材料访问权的认证方法，扩展或替换现有的基于用户名/密码的认证方案。与其使用传输层认证，例如 TLS 客户端证书，Web 应用可能更倾向于在应用自身内部进行认证所提供的更丰富的用户体验。

使用 Web Cryptography API，应用可以定位合适的客户端密钥，这些密钥可能此前已通过用户代理生成，或由 Web 应用通过带外方式预先配置。然后它可以执行加密操作，例如先解密一个认证质询，再对认证响应进行签名。

通过基于底层传输的属性派生一个密钥，将认证绑定到客户端正在其上进行认证的 TLS 会话，可以进一步增强这种交换。

如果用户还没有与其账户关联的密钥，Web 应用可以指示用户代理生成一个新密钥，或者重新使用用户选择的现有密钥。

Web 应用可能希望限制包含敏感或个人信息的文档的查看者，即使这些文档已经通过安全方式接收，例如通过 TLS。

使用 Web Cryptography API，应用可以通过使用秘密密钥加密文档，然后用与授权查看者关联的公钥包装该密钥来实现这一点。当用户代理导航到这样的 Web 应用时，该应用会发送文档的加密形式。随后用户代理被指示使用用户的私钥解包加密密钥，并从那里解密并显示文档。

Web 应用可能希望允许用户在上传之前，保护存储于远程服务提供者处的数据和文档的机密性。

使用 Web Cryptography API，应用可以让用户选择一个私有或秘密密钥，可选地从所选密钥派生一个加密密钥，加密文档，然后使用现有 API 将加密数据上传到服务提供者。

此用例类似于受保护的文档交换用例，只是文档的查看者仅限于用户本人。

Web 应用可能希望接受文档上的电子签名，以替代需要物理签名。

使用 Web Cryptography API，应用可以指示用户选择一个密钥，该密钥可能已通过带外方式预先配置，或专门为该 Web 应用生成。使用此密钥，应用可以对某些数据执行签名操作，以证明用户接受该文档。

Web 应用可能希望在本地缓存数据，同时确保这些数据不能在离线攻击中被修改。

使用 Web Cryptography API，应用可以使用包含在应用中的公钥来验证数据缓存的内容。此前，当数据被添加到缓存时，它会由服务器用相应的私钥进行签名。通过在从缓存恢复数据时验证签名，客户端可确保缓存的数据未被篡改。

Web 应用可能希望使用诸如 off-the-record (OTR) messaging 之类的方案来采用消息层安全性，即使这些消息已经通过安全方式接收，例如通过 TLS。

Web Cryptography API 允许执行密钥协商，从而支持 OTR 以及类似的消息签名方案。双方可以协商共享的加密密钥和消息认证码（MAC）密钥，以允许对消息进行加密和解密，并防止篡改。

Web 应用可能希望与 IETF JavaScript Object Signing and Encryption (JOSE) Working Group 定义的结构和消息格式进行交互。

使用 Web Cryptography API，应用可以读取并导入以 JSON 密钥格式（JWK）编码的密钥，验证使用数字签名或 MAC（JWS）进行了完整性保护的消息，或者解密已加密的消息（JWE）。

除标记为非规范性的章节外，本规范中的所有编写指南、图表、示例和注释均为非规范性的。本规范中的其他所有内容均为规范性的。

本文档中的关键词 MUST、REQUIRED 和 SHALL 应按照 BCP 14 [RFC2119] [RFC8174] 中所述进行解释，但仅当它们以全大写形式出现时才如此，如此处所示。

本规范定义了以下一致性类别：

一致的用户代理: 如果用户代理满足本规范中适用于实现的所有一致的用户代理 MUST 级、 REQUIRED 级和 SHALL 级标准，则该用户代理被认为是一致的用户代理。本规范使用“conforming user agent”和“user agent”这两个术语来指代此产品类别。

以算法或具体步骤表述的一致性要求可以以任何方式实现，只要最终结果等效即可。（特别是，本规范中定义的算法旨在易于遵循，而不是旨在高性能。）

使用 ECMAScript 来实现本规范中定义的 API 的用户代理 MUST 以与 Web IDL 规范中定义的 ECMAScript 绑定一致的方式实现它们 [WebIDL]，因为本规范使用该规范及其术语。

除非另有说明，字符串比较均以区分大小写的方式进行。本规范中以等宽字体书写的字符串字面量，例如 “this”，不包括外围引号。

强烈不鼓励对本规范进行厂商特定的专有扩展。作者不得使用此类扩展，因为这样做会降低互操作性并分裂用户群，使只有特定用户代理的用户才能访问相关内容。

如果需要厂商特定扩展，则成员应以厂商特定字符串作为前缀，以防止与本规范未来版本发生冲突。扩展的定义必须保证扩展的使用既不与规范中定义的功能相矛盾，也不会导致其不一致。

当需要对本规范进行厂商中立的扩展时，可以相应地更新本规范，或者编写一个覆盖本规范中要求的扩展规范。当某个将本规范应用于其活动的人决定承认此类扩展规范的要求时，它就成为本规范一致性要求目的下的适用规范。由 W3C Web Cryptography Working Group 定义的适用规范列在下表中。

规范

参考

注

建议读者查阅本规范的勘误，以获取对上表的更新。

本节是非规范性的。

本规范试图聚焦于各种平台特定或标准化加密 API 之间的通用功能和特性，并避免仅特定于一两个实现的特性和功能。因此，该 API 允许以一种避免开发者需要关心底层密钥存储实现的抽象层级进行密钥生成、管理和交换。该 API 专门围绕 CryptoKey 对象，作为底层原始加密密钥材料的抽象。其背后的意图是允许一个足够通用的 API，使一致的用户代理能够暴露由用户代理直接存储和管理的密钥，这些密钥可能使用某些操作系统提供的每用户密钥存储等隔离存储 API 进行存储或管理，或者存储在安全元件等密钥存储设备中，同时允许富 Web 应用操纵这些密钥，并且不要求 Web 应用了解底层密钥存储的性质。

由于底层加密实现会因一致的用户代理而异，并且可能受制于本地策略，包括但不限于政府或行业监管、安全最佳实践、知识产权问题，以及受限的运行环境等考虑，本规范不规定 MUST 实现的一组强制算法。相反，它定义了一组通用绑定，这些绑定可以以与算法无关的方式使用；一个通用框架，用于发现用户代理或密钥句柄是否支持底层算法；以及一组关于各个算法在被实现时的行为的一致性要求。

此 API 虽然允许应用生成、检索和操纵密钥材料，但并不专门处理在特定类型的密钥存储中（例如安全元件或智能卡）配置密钥的问题。这是因为此类配置操作通常负担着厂商特定细节，使得定义一个与厂商无关的接口成为一个不适宜且无界的任务。此外，此 API 不处理或解决加密模块的发现问题，因为这些概念依赖于底层用户代理，并且不是可在常见操作系统、加密库和实现之间移植的概念。

本节是非规范性的。

本规范假定但不要求，一致的用户代理不会并且将不会在用户代理自身内部直接实现加密操作。从历史上看，许多用户代理已将加密操作（例如 TLS 中使用的那些操作）委托给作为底层操作系统一部分提供的现有 API，或委托给独立于用户代理进行管理的第三方模块。

CryptoKey 对象表示 JavaScript 执行环境与这些底层库之间的桥梁，这是通过使用名为 [[handle]] 的内部槽来实现的。该句柄表示一种实现特定的不透明类型，它可能无法在 JavaScript 类型中表示，也绝不会暴露给脚本作者。通过这种方式， CryptoKey 对象相对于 JavaScript 执行环境，在概念上等同于 [[handle]] 相对于底层加密实现。

这些 API 传统上围绕加密提供者的概念构建，加密提供者是一组算法的特定实现的抽象。操作系统或库可能带有默认提供者，并且通常允许用户添加额外的提供者、重新配置已启用算法的集合，或者以其他方式自定义加密服务的提供方式。

虽然假定大多数用户代理将与完全以软件实现的加密提供者交互，但本规范并不要求如此。因此，某些实现的能力可能受限于底层硬件的能力，并且根据用户如何配置底层加密库，这对用户代理而言可能完全是不透明的。

本规范并未为 CryptoKey 对象显式提供任何新的存储机制。相反，通过为序列化和反序列化步骤定义 CryptoKey 对象，任何支持存储可序列化对象的现有或未来 Web 存储机制，都可用于存储 CryptoKey 对象。

在实践中，预计大多数作者会使用 Indexed Database API [INDEXEDDB]，它允许对键/值对进行关联式存储，其中键是对应用有意义的某个字符串标识符，值是一个 CryptoKey 对象。这允许存储和检索密钥材料，而不会将该密钥材料暴露给应用或 JavaScript 环境。此外，这允许作者拥有充分的灵活性，将任何额外元数据与 CryptoKey 本身一起存储。

本节是非规范性的。

由于没有提供显式的存储机制，本规范假定 CryptoKey 对象限定于当前执行环境以及该环境可用的任何存储机制（例如 Indexed Database API）。应用作者依赖这一点来保障其应用的安全性；拥有同一 CryptoKey 对象的两个源，对底层密钥具有完全访问权，因此，来自这些应用的消息无法区分，发送给这些应用的消息也可以被完全恢复。实现者应确保不会在两个源之间共享 CryptoKey 对象，除非作者已明确选择共享（例如通过使用 postMessage）

本规范中规定的一些算法会执行计算密集型工作，例如生成非常大的素数，或通过对特定操作进行重复迭代。因此，恶意应用可能会试图滥用此 API，并试图使实现执行大量工作，从而拒绝其他正在执行的应用访问或服务。实现应采取措施来缓解这些风险，例如限制实现并发执行的操作数量、对已知可能会破坏执行环境的操作要求用户同意，或者为诸如密钥大小或迭代次数等属性定义设备特定的限制。

本规范包含了多种加密操作的描述，其中一些在使用不当时具有已知弱点。应用开发者必须谨慎，并查阅适当且最新的加密文献，以理解并缓解此类问题。一般而言，强烈不鼓励应用开发者发明新的加密协议；与所有应用一样，本规范的用户最好使用现有协议，而本规范提供了实现这些协议所需的构建块。

为了使用本规范中定义的 API 提供任何有意义的加密保证，作者必须熟悉 Web 应用面临的现有威胁，以及所采用的底层安全模型。从概念上讲，脚本注入等问题等同于其他操作环境中的远程代码执行，允许注入恶意脚本可能导致密钥或数据被外泄。脚本注入可能来自其他应用，对此可通过审慎使用内容安全策略来缓解；也可能来自恶意网络中间人，对此可通过使用传输层安全性来缓解。

本规范没有定义任何用于存储加密密钥的具体机制。默认情况下，除非作者采取具体措施来持久化密钥，例如通过使用 Indexed Database API，否则使用此 API 创建的密钥仅在当前页面的生命周期内有效（例如直到发生导航事件）。希望在不同页面或多个浏览会话之间使用同一密钥的作者，必须采用现有的 Web 存储技术。作者应了解这些技术的安全性假设，例如同源安全模型；也就是说，共享相同方案、主机和端口的任何应用都可以访问同一存储分区，即使路径等其他信息可能不同。作者可以通过跨源共享（例如 postMessage）显式选择放宽这种安全性。

作者应注意，本规范没有对实现如何存储底层加密密钥材料提出规范性要求。唯一的要求是密钥材料不得暴露给脚本，除非通过使用 exportKey 和 wrapKey 操作。特别是，它并不保证底层加密密钥材料不会被持久化到磁盘上（可能未加密），也不保证拥有与用户代理相同权限运行的用户或其他应用无法访问这些材料。任何有权访问设备存储的应用或用户都可能恢复密钥材料，即使脚本可能被禁止访问。

本规范没有对实现如何在所有对密钥材料的引用消失后处理这些材料提出规范性要求。也就是说，一致的用户代理不要求对密钥材料进行清零，并且即使对 CryptoKey 的所有引用都已消失，它仍可能在设备存储或设备内存中可访问。

应用可以通过使用结构化克隆算法以及 postMessage 等 API，跨安全边界（例如源）共享 CryptoKey 对象。虽然对底层加密密钥材料的访问可能会基于 extractable 属性受到限制，但一旦密钥与目标源共享，源源就无法之后限制或撤销对该密钥的访问。因此，作者必须小心确保其信任目标源会采取与源源相同的缓解恶意脚本的措施。此外，如果源源发生脚本注入，攻击者可能会将密钥发布到攻击者控制的源。每当用户代理访问攻击者的源时，用户代理可能会被指示使用该密钥执行加密操作，例如解密现有消息或创建新的欺诈性消息。

作者应注意，用户可以随时选择清除与某个源关联的存储，从而可能销毁密钥。旨在提供长期存储（例如服务器端存储）的应用，应考虑使用密钥托管等技术，以防止此类数据变得不可访问。作者不应假定密钥会无限期可用。

使用本规范中定义的 API 的应用的用户应注意，无论采用何种加密技术，这些应用都将完全访问所有交换的消息。也就是说，对于加密消息，使用这些 API 的应用也将完全访问解密后的消息。

本节是非规范性的。

指纹识别: 通过暴露反映底层平台能力的额外 API，本规范可能允许恶意应用确定或区分不同的用户代理或设备。
超级 Cookie: 本规范没有提供任何手段，使恶意应用能够创建比现有 Web 存储技术寿命更长的标识符。但是，在引入此 API 的未来修订版或额外加密能力时，必须谨慎，例如由硬件支持的能力（例如：智能卡或可信平台模块）。考虑到此类存储的设计目标是防止任意两个用户拥有相同的底层密钥数据，此类 API 可能真正存在被用作违背用户意愿的永久标识符的风险。
将 randomUUID 用作用户 ID: randomUUID 可用于生成用户 ID，但不会直接赋予任何生成全局标识符的能力。

本规范依赖底层规范。

DOM: 一致的用户代理 MUST 至少支持本规范所依赖的 DOM 中定义的功能子集；特别是，它 MUST 支持 Promise 和 DOMException。 [DOM]
HTML: 一致的用户代理 MUST 至少支持本规范所依赖的 HTML 中定义的功能子集；特别是，它 MUST 支持 ArrayBufferView typedef 和可序列化对象。 [HTML]
Web IDL: 一致的用户代理 MUST 是本规范中 IDL 片段的一致实现，如 Web IDL 规范中所述。[WebIDL]

术语 ArrayBuffer、 ArrayBufferView 和可序列化对象由 HTML 规范定义 [HTML]。

术语 DOMString 和 BufferSource 定义于 [WEBIDL]。

术语字节序列定义于 [Infra]。

字节序列的位长度是其长度乘以 8。

包含位序列的字节序列 b 是通过如下方式获得的字节序列：首先向 b 追加零个或多个值为零的位，使所得位序列的长度最小且为 8 的整数倍，然后将该字符串中每个连续的 8 位序列视为一个字节。

当本规范要求将非负整数 i 转换为长度为 n 的字节序列，其中 n * 8 大于 i 以 2 为底的对数时，用户代理必须先计算 i 的二进制表示，最高有效位在前，在其前面添加足够的零位，以形成长度为 n * 8 的位序列，然后返回通过将该位序列中每个连续的 8 位序列视为一个字节而形成的字节序列。

以区分大小写的方式比较两个字符串，意味着逐个码点精确比较它们。

以ASCII 不区分大小写的方式比较两个字符串，意味着逐个码点精确比较它们，但范围 U+0041 .. U+005A 中的码点（即 LATIN CAPITAL LETTER A 到 LATIN CAPITAL LETTER Z）和范围 U+0061 .. U+007A 中的相应码点（即 LATIN SMALL LETTER A 到 LATIN SMALL LETTER Z）也被视为匹配。

当本规范要求终止算法时，用户代理必须在完成其当前所在步骤后终止该算法。这里所指的算法是规范定义的一组处理步骤，而不是可能正处于处理过程中的底层加密算法。

当本规范要求解析 ASN.1 结构时，用户代理必须执行以下步骤：

令 data 为要解析的字节序列。
令 structure 为要解析的 ASN.1 结构。
令 exactData 为一个可选布尔值。如果未提供，则将其初始化为 true。
根据 [X690] 的区分编码规则解析 data，使用 structure 作为要解码的 ASN.1 结构。
如果指定了 exactData，且在解析阶段没有消耗 data 的所有字节，则抛出一个 DataError。
返回解析后的 ASN.1 结构。

当本规范要求解析 subjectPublicKeyInfo时，用户代理必须解析 ASN.1 结构，其中 data 设置为要解析的字节序列，structure 为 [RFC5280] 中规定的 subjectPublicKeyInfo 的 ASN.1 结构，并且 exactData 设置为 true。

当本规范要求解析 PrivateKeyInfo时，用户代理必须解析 ASN.1 结构，其中 data 设置为要解析的字节序列， structure 为 [RFC5208] 中规定的 PrivateKeyInfo 的 ASN.1 结构，并且 exactData 设置为 true。

当本规范要求解析 JWK时，用户代理必须运行以下步骤：

令 data 为要解析的字节序列。
令 json 为按照 UTF-8 解释 data 所得到的 Unicode 字符串。
将 json 转换为 UTF-16。
令 result 为在新全局对象上下文中执行 JSON.parse 内部函数所得的对象字面量，其中 text 参数设置为包含 json 的 JavaScript String。
令 key 为将 result 转换为 JsonWebKey 的 IDL 字典类型所得的结果。
如果 key 的 kty 字段未定义，则抛出一个 DataError。
返回 key。

当本规范要求计算两个序列 a 和 b 的用途交集时，结果应为一个序列，其中包含同时出现在 a 和 b 中的每个已识别密钥用途值，其顺序按照已识别密钥用途值列表中的顺序；如果序列中存在某个元素与该值进行区分大小写字符串匹配，则称该值出现在该序列中。

当本规范要求计算 usages 的用途列表的规范化值时，结果应为 usages 与包含所有已识别密钥用途值的序列的用途交集。

当本规范提及与 object 的内部槽 [[slot]] 关联的缓存的 ECMAScript 对象时，用户代理必须运行以下步骤：

如果 object 的 [[slot_cached]] 内部槽未定义：

将 object 的 [[slot_cached]] 内部槽设置为对 object 的 [[slot]] 内部槽的内容执行 [WebIDL] 中定义的到 ECMAScript 对象的类型转换所得的结果。
返回 object 的 [[slot_cached]] 内部槽的内容。

Crypto 接口表示一个面向通用加密功能的接口，包括一个以真正随机值为种子的、加密强度高的伪随机数生成器。

WebIDLpartial interface mixin WindowOrWorkerGlobalScope {
  [SameObject] readonly attribute Crypto crypto;
};

[Exposed=(Window,Worker)]
interface Crypto {
  [SecureContext] readonly attribute SubtleCrypto subtle;
  ArrayBufferView getRandomValues(ArrayBufferView array);
  [SecureContext] DOMString randomUUID();
};

注

实现应使用成熟的加密伪随机数生成器来生成加密强度高的随机值，这些生成器应以高质量熵作为种子，例如来自操作系统熵源（如 “/dev/urandom”）的熵。本规范没有规定加密强度高的随机值中所含信息论熵的下限，但实现应尽最大努力提供尽可能多的熵。

注

此接口定义了一个同步方法，用于获取加密强度高的随机值。虽然某些设备和实现可能支持真正随机的加密数字生成器，或提供在熵不足时会阻塞的接口，但在实现 getRandomValues 时，不鼓励实现使用这些来源，这既是出于性能考虑，也是为了避免耗尽系统熵。相反，这些来源应用作加密伪随机数生成器的种子，而该生成器随后可以高效地返回合适的值。

getRandomValues 方法会生成加密强度高的随机值。它必须按如下方式行事：

如果 array 不是 Int8Array、Uint8Array、Uint8ClampedArray、 Int16Array、Uint16Array、Int32Array、Uint32Array、 BigInt64Array 或 BigUint64Array，则抛出一个 TypeMismatchError 并终止算法。
令 byteLength 为 array 的字节长度。
如果 byteLength 大于 65536，则抛出一个 QuotaExceededError 并终止算法。
令 bytes 为一个长度为 byteLength 的字节序列。
用加密安全的随机字节填充 bytes。
将 bytes 写入 array。
返回 array。

注

不要使用 getRandomValues 方法生成密钥。请改用 generateKey 方法。

randomUUID 方法会生成一个新的第 4 版 UUID，并返回其命名空间特定字符串表示，如 [RFC4122] 的第 3 节所述。要生成随机 UUID：

令 bytes 为长度为 16 的字节序列。
用加密安全的随机字节填充 bytes。
将表示 UUID 版本的 bytes[6] 的最高 4 位设置为 0100。
将表示 UUID 变体的 bytes[8] 的最高 2 位设置为 10。
返回以下内容的字符串拼接 «
1. bytes[0] 的十六进制表示、bytes[1] 的十六进制表示、 bytes[2] 的十六进制表示、 bytes[3] 的十六进制表示，
2. "-"，
3. bytes[4] 的十六进制表示、bytes[5] 的十六进制表示，
4. "-"，
5. bytes[6] 的十六进制表示、bytes[7] 的十六进制表示，
6. "-"，
7. bytes[8] 的十六进制表示、bytes[9] 的十六进制表示，
8. "-"，
9. bytes[10] 的十六进制表示、bytes[11] 的十六进制表示、 bytes[12] 的十六进制表示、 bytes[13] 的十六进制表示、 bytes[14] 的十六进制表示、bytes[15] 的十六进制表示
»。

对于生成随机 UUID算法中描述的步骤，字节 value 的十六进制表示是通过使用 ASCII 小写十六进制数字以十六进制表示 value 所创建的两字符字符串，并在左侧填充 "0"，以达到两个 ASCII 小写十六进制数字。

subtle 属性提供 SubtleCrypto 接口的一个实例，该接口提供低级加密原语和算法。

Algorithm 对象是一个字典对象 [WEBIDL]，用于指定某个算法以及完全指定所需操作所需的任何额外参数。

WebIDLtypedef (object or DOMString) AlgorithmIdentifier;

typedef AlgorithmIdentifier HashAlgorithmIdentifier;

dictionary Algorithm {
  required DOMString name;
};

name: 要使用的已注册算法的名称。

KeyAlgorithm 字典表示有关给定 CryptoKey 对象内容的信息。

WebIDLdictionary KeyAlgorithm {
  required DOMString name;
};

本节是非规范性的。

提供 KeyAlgorithm 字典，是为了帮助记录 CryptoKey 的固定公共属性如何反映回应用。实际的字典类型从不会暴露给应用。

name: 用于生成 CryptoKey 的算法名称

CryptoKey 对象表示对由用户代理管理的密钥材料的一个不透明引用。

WebIDLenum KeyType { "public", "private", "secret" };

enum KeyUsage { "encrypt", "decrypt", "sign", "verify", "deriveKey", "deriveBits", "wrapKey", "unwrapKey" };

[SecureContext,Exposed=(Window,Worker),Serializable]
interface CryptoKey {
  readonly attribute KeyType type;
  readonly attribute boolean extractable;
  readonly attribute object algorithm;
  readonly attribute object usages;
};

本节是非规范性的。

本规范为用户代理管理的许多不同种类的密钥材料提供统一接口。这可以包括由用户代理生成的密钥、由用户代理从其他密钥派生的密钥、通过用户操作或使用此 API 导入到用户代理的密钥、预先配置在用户代理可访问的软件或硬件中的密钥，或以其他方式提供给用户代理的密钥。术语“密钥”广义地指任何密钥材料，包括用于加密操作的实际密钥，以及在密钥派生或交换操作中获得的秘密值。

CryptoKey 对象不需要直接与底层密钥存储机制交互，而可以只是用户代理用来理解在需要时（例如执行加密操作时）如何获取密钥材料的一个引用。

KeyType: 密钥的类型。已识别的密钥类型值为 "public"、"private" 和 "secret"。不透明密钥材料，包括用于对称算法的密钥材料，由 secret 表示，而作为由公钥/私钥密钥对组成的非对称算法一部分使用的密钥，将是 public 或 private。
KeyUsage: 可以使用密钥执行的一种操作类型。已识别的密钥用途值为 encrypt、 decrypt、 sign、 verify、 deriveKey、 deriveBits、 wrapKey 和 unwrapKey。

每个 CryptoKey 对象都有一组内部槽，用于存储有关密钥的信息。这些槽不会作为本规范的一部分暴露；它们表示实现用于实现本规范的内部状态。这里复用了 [ECMA-262] 中使用的记号约定；内部槽以包含在双重方括号 [[ ]] 中的名称标识。

所有 CryptoKey 对象都具有名为 [[type]]、 [[extractable]]、 [[algorithm]]、 [[algorithm_cached]]、 [[usages]]、 [[usages_cached]] 以及 [[handle]] 的内部槽。

[[algorithm]] 内部槽的内容应为 KeyAlgorithm，或从其派生。 [[usages]] 内部槽的内容应为 Sequence<KeyUsage> 类型。

注

[[handle]] 槽是一种不透明类型，包含底层加密实现用来表示逻辑密钥的任何数据。不同的加密实现可能使用不同类型，从表示为整数的不透明标识符，到指针类型，或提供标识信息的结构。这些句柄绝不会暴露给应用。

type: 反映 [[type]] 内部槽，该槽包含底层密钥的类型。
extractable: 反映 [[extractable]] 内部槽，该槽指示原始密钥材料是否可以由应用导出。
algorithm: 返回与 [[algorithm]] 内部槽关联的缓存的 ECMAScript 对象。
usages: 返回与 [[usages]] 内部槽关联的缓存的 ECMAScript 对象，该内部槽指示哪些加密操作允许与此密钥一起使用。

CryptoKey 对象是可序列化对象。给定 value 和 serialized，其序列化步骤为：

将 serialized.[[Type]] 设置为 value 的 [[type]] 内部槽。
将 serialized.[[Extractable]] 设置为 value 的 [[extractable]] 内部槽。
将 serialized.[[Algorithm]] 设置为 value 的 [[algorithm]] 内部槽的子序列化。
将 serialized.[[Usages]] 设置为 value 的 [[usages]] 内部槽的子序列化。
将 serialized.[[Handle]] 设置为 value 的 [[handle]] 内部槽。

给定 serialized 和 value，其反序列化步骤为：

将 value 的 [[type]] 内部槽初始化为 serialized.[[Type]]。
将 value 的 [[extractable]] 内部槽初始化为 serialized.[[Extractable]]。
将 value 的 [[algorithm]] 内部槽初始化为 serialized.[[Algorithm]] 的子反序列化。
将 value 的 [[usages]] 内部槽初始化为 serialized.[[Usages]] 的子反序列化。
将 value 的 [[handle]] 内部槽初始化为 serialized.[[Handle]]。

注

在反序列化已序列化的 CryptoKey 对象时，重要的是该对象不得被反序列化为不同类型。这由反序列化步骤的定义以规范方式要求，但它值得特别注意，因为此类反序列化可能会暴露密钥材料的内容，而在某些情况下（例如 [[extractable]] 内部槽为 false 时）不应向应用暴露这些内容。

SubtleCrypto 接口提供了一组用于处理低级加密原语和算法的方法。

WebIDLenum KeyFormat { "raw", "spki", "pkcs8", "jwk" };

[SecureContext,Exposed=(Window,Worker)]
interface SubtleCrypto {
  Promise<ArrayBuffer> encrypt(
    AlgorithmIdentifier algorithm,
    CryptoKey key,
    BufferSource data
  );
  Promise<ArrayBuffer> decrypt(
    AlgorithmIdentifier algorithm,
    CryptoKey key,
    BufferSource data
  );
  Promise<ArrayBuffer> sign(
    AlgorithmIdentifier algorithm,
    CryptoKey key,
    BufferSource data
  );
  Promise<boolean> verify(
    AlgorithmIdentifier algorithm,
    CryptoKey key,
    BufferSource signature,
    BufferSource data
  );
  Promise<ArrayBuffer> digest(
    AlgorithmIdentifier algorithm,
    BufferSource data
  );

  Promise<(CryptoKey or CryptoKeyPair)> generateKey(
    AlgorithmIdentifier algorithm,
    boolean extractable,
    sequence<KeyUsage> keyUsages
  );
  Promise<CryptoKey> deriveKey(
    AlgorithmIdentifier algorithm,
    CryptoKey baseKey,
    AlgorithmIdentifier derivedKeyType,
    boolean extractable,
    sequence<KeyUsage> keyUsages
  );
  Promise<ArrayBuffer> deriveBits(
    AlgorithmIdentifier algorithm,
    CryptoKey baseKey,
    optional unsigned long? length = null
  );

  Promise<CryptoKey> importKey(
    KeyFormat format,
    (BufferSource or JsonWebKey) keyData,
    AlgorithmIdentifier algorithm,
    boolean extractable,
    sequence<KeyUsage> keyUsages
  );
  Promise<(ArrayBuffer or JsonWebKey)> exportKey(
    KeyFormat format,
    CryptoKey key
  );

  Promise<ArrayBuffer> wrapKey(
    KeyFormat format,
    CryptoKey key,
    CryptoKey wrappingKey,
    AlgorithmIdentifier wrapAlgorithm
  );
  Promise<CryptoKey> unwrapKey(
    KeyFormat format,
    BufferSource wrappedKey,
    CryptoKey unwrappingKey,
    AlgorithmIdentifier unwrapAlgorithm,
    AlgorithmIdentifier unwrappedKeyAlgorithm,
    boolean extractable,
    sequence<KeyUsage> keyUsages
  );
};

注

SubtleCrypto 接口被命名为 “SubtleCrypto”，是为了反映这样一个事实：为了提供所需的算法安全保证，许多这类算法都有微妙的使用要求。

例如，直接使用未经认证的加密方案，例如计数器模式下的 AES，会使潜在攻击者能够通过操纵输入中的位来操纵输出中的位，从而破坏消息的完整性。然而，AES-CTR 可以与其他加密原语（例如消息认证码）组合安全地使用，以确保受保护消息的完整性，但前提是消息认证码是在加密消息和 IV 之上构造的。

使用 SubtleCrypto 接口的开发者应了解与所提供各种算法的设计和实现相关的安全性问题。提供原始算法，是为了让开发者在实现各种协议和应用时获得最大的灵活性，其中每一种协议和应用都可能以独特方式表示组合和安全参数，因而需要使用原始算法。

KeyFormat

指定密钥的序列化格式。已识别的密钥格式值为：

raw: 未格式化的字节序列。用于秘密密钥。
pkcs8: 来自 [RFC5208] 的 PrivateKeyInfo 结构的 DER 编码。
spki: 来自 [RFC5280] 的 SubjectPublicKeyInfo 结构的 DER 编码。
jwk: 该密钥是一个编码为 JavaScript 对象的 JsonWebKey 字典

crypto 任务源: 此任务源用于对任务进行排队，以解决或拒绝响应 SubtleCrypto 方法调用而创建的 promise。

注

本规范没有对 SubtleCrypto 方法调用响应的顺序提出具体要求，无论是在多次调用之间，还是在这些调用与来自其他任务源的任务之间。此任务源仅用于排队任务，以便在加密操作完成时解决或拒绝相关 promise，从而防止竞态条件。

注

所有错误都会通过拒绝返回的 Promise 来异步报告。这包括 Web IDL 类型映射错误。

encrypt 方法返回一个新的 Promise 对象，该对象将使用指定的 AlgorithmIdentifier 和所提供的 CryptoKey 来加密数据。它必须按如下方式行事：

令 algorithm 和 key 分别为传递给 encrypt() 方法的 algorithm 和 key 参数。
令 data 为获取传递给 encrypt() 方法的 data 参数所持有字节的副本所得的结果。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "encrypt"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 key 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 key 的 [[usages]] 内部槽不包含值为 "encrypt" 的条目，则抛出一个 InvalidAccessError。
令 ciphertext 为使用 algorithm 和 key，并以 data 作为 plaintext，执行由 normalizedAlgorithm 指定的 encrypt 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中创建一个包含 ciphertext 的 ArrayBuffer 所得的结果。
用 result 解决 promise。

decrypt 方法返回一个新的 Promise 对象，该对象将使用指定的 AlgorithmIdentifier 和所提供的 CryptoKey 来解密数据。它必须按如下方式行事：

令 algorithm 和 key 分别为传递给 decrypt() 方法的 algorithm 和 key 参数。
令 data 为获取传递给 decrypt() 方法的 data 参数所持有字节的副本所得的结果。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "decrypt"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 key 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 key 的 [[usages]] 内部槽不包含值为 "decrypt" 的条目，则抛出一个 InvalidAccessError。
令 plaintext 为使用 key 和 algorithm，并以 data 作为 ciphertext，执行由 normalizedAlgorithm 指定的 decrypt 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中创建一个包含 plaintext 的 ArrayBuffer 所得的结果。
用 result 解决 promise。

sign 方法返回一个新的 Promise 对象，该对象将使用指定的 AlgorithmIdentifier 和所提供的 CryptoKey 来签名数据。它必须按如下方式行事：

令 algorithm 和 key 分别为传递给 sign() 方法的 algorithm 和 key 参数。
令 data 为获取传递给 sign() 方法的 data 参数所持有字节的副本所得的结果。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "sign"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 key 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 key 的 [[usages]] 内部槽不包含值为 "sign" 的条目，则抛出一个 InvalidAccessError。
令 signature 为使用 key 和 algorithm，并以 data 作为 message，执行由 normalizedAlgorithm 指定的 sign 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中创建一个包含 signature 的 ArrayBuffer 所得的结果。
用 result 解决 promise。

verify 方法返回一个新的 Promise 对象，该对象将使用指定的 AlgorithmIdentifier 和所提供的 CryptoKey 来验证数据。它必须按如下方式行事：

令 algorithm 和 key 分别为传递给 verify() 方法的 algorithm 和 key 参数。
令 signature 为获取传递给 verify() 方法的 signature 参数所持有字节的副本所得的结果。
令 data 为获取传递给 verify() 方法的 data 参数所持有字节的副本所得的结果。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "verify"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 key 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 key 的 [[usages]] 内部槽不包含值为 "verify" 的条目，则抛出一个 InvalidAccessError。
令 result 为使用 key、 algorithm 和 signature，并以 data 作为 message，执行由 normalizedAlgorithm 指定的 verify 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
用 result 解决 promise。

digest 方法返回一个新的 Promise 对象，该对象将使用指定的 AlgorithmIdentifier 对数据进行摘要计算。它必须按如下方式行事：

令 algorithm 为传递给 digest() 方法的 algorithm 参数。
令 data 为获取传递给 digest() 方法的 data 参数所持有字节的副本所得的结果。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "digest"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
令 digest 为使用 algorithm，并以 data 作为 message，执行由 normalizedAlgorithm 指定的 digest 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中创建一个包含 digest 的 ArrayBuffer 所得的结果。
用 result 解决 promise。

调用时，generateKey MUST 执行以下步骤：

令 algorithm、extractable 和 usages 分别为传递给 generateKey() 方法的 algorithm、extractable 和 keyUsages 参数。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "generateKey"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
令 result 为使用 algorithm、extractable 和 usages，执行由 normalizedAlgorithm 指定的 generate key 操作所得的结果。
如果 result 是一个 CryptoKey 对象：

如果 result 的 [[type]] 内部槽为 "secret" 或 "private"，并且 usages 为空，则抛出一个 SyntaxError。

如果 result 是一个 CryptoKeyPair 对象：

如果 result 的 privateKey 属性的 [[usages]] 内部槽为空序列，则抛出一个 SyntaxError。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中将 result 转换为 ECMAScript Object 所得的结果，如 [WebIDL] 中所定义。
用 result 解决 promise。

调用时，deriveKey MUST 执行以下步骤：

令 algorithm、baseKey、derivedKeyType、 extractable 和 usages 分别为传递给 deriveKey() 方法的 algorithm、 baseKey、derivedKeyType、extractable 和 keyUsages 参数。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "deriveBits"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 normalizedDerivedKeyAlgorithmImport 为规范化算法所得的结果，其中 alg 设置为 derivedKeyType，op 设置为 "importKey"。
如果发生错误，则返回一个以 normalizedDerivedKeyAlgorithmImport 拒绝的 Promise。
令 normalizedDerivedKeyAlgorithmLength 为规范化算法所得的结果，其中 alg 设置为 derivedKeyType，op 设置为 "get key length"。
如果发生错误，则返回一个以 normalizedDerivedKeyAlgorithmLength 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 baseKey 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 baseKey 的 [[usages]] 内部槽不包含值为 "deriveKey" 的条目，则抛出一个 InvalidAccessError。
令 length 为使用 derivedKeyType，执行由 normalizedDerivedKeyAlgorithmLength 指定的 get key length 算法所得的结果。
令 secret 为使用 key、algorithm 和 length，执行由 normalizedAlgorithm 指定的 derive bits 操作所得的结果。
令 result 为使用 "raw" 作为 format、secret 作为 keyData、 derivedKeyType 作为 algorithm，并使用 extractable 和 usages，执行由 normalizedDerivedKeyAlgorithmImport 指定的 import key 操作所得的结果。
如果 result 的 [[type]] 内部槽为 "secret" 或 "private"，并且 usages 为空，则抛出一个 SyntaxError。
将 result 的 [[extractable]] 内部槽设置为 extractable。
将 result 的 [[usages]] 内部槽设置为 usages 的规范化值。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中将 result 转换为 ECMAScript Object 所得的结果，如 [WebIDL] 中所定义。
用 result 解决 promise。

调用时，deriveBits MUST 执行以下步骤：

令 algorithm、baseKey 和 length 分别为传递给 deriveBits() 方法的 algorithm、 baseKey 和 length 参数。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "deriveBits"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 baseKey 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 baseKey 的 [[usages]] 内部槽不包含值为 "deriveBits" 的条目，则抛出一个 InvalidAccessError。
令 bits 为使用 baseKey、 algorithm 和 length，执行由 normalizedAlgorithm 指定的 derive bits 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中创建一个包含 bits 的 ArrayBuffer 所得的结果。
用 result 解决 promise。

调用时，importKey 方法 MUST 执行以下步骤：

令 format、algorithm、extractable 和 usages 分别为传递给 importKey() 方法的 format、algorithm、 extractable 和 keyUsages 参数。
如果 format 等于字符串 "raw"、 "pkcs8" 或 "spki"：
1. 如果传递给 importKey() 方法的 keyData 参数是 JsonWebKey 字典，则抛出一个 TypeError。
2. 令 keyData 为获取传递给 importKey() 方法的 keyData 参数所持有字节的副本所得的结果。
如果 format 等于字符串 "jwk"：
1. 如果传递给 importKey() 方法的 keyData 参数不是 JsonWebKey 字典，则抛出一个 TypeError。
2. 令 keyData 为传递给 importKey() 方法的 keyData 参数。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "importKey"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
令 result 为使用 keyData、 algorithm、 format、extractable 和 usages，执行由 normalizedAlgorithm 指定的 import key 操作所得的 CryptoKey 对象。
如果 result 的 [[type]] 内部槽为 "secret" 或 "private"，并且 usages 为空，则抛出一个 SyntaxError。
将 result 的 [[extractable]] 内部槽设置为 extractable。
将 result 的 [[usages]] 内部槽设置为 usages 的规范化值。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中将 result 转换为 ECMAScript Object 所得的结果，如 [WebIDL] 中所定义。
用 result 解决 promise。

注

为了互操作性，鼓励支持 "raw" 密钥格式。 Web 开发者应查阅测试套件，以获取关于实现对其他密钥格式支持情况的详细信息。

注

对于结构化密钥格式 "spki"、"pkcs8" 和 "jwk"，在某个算法的密钥导入过程中未被显式引用的字段会被忽略。

调用时，exportKey 方法 MUST 执行以下步骤：

令 format 和 key 分别为传递给 exportKey() 方法的 format 和 key 参数。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 key 的 [[algorithm]] 内部槽的 name 成员未标识一个支持 export key 操作的已注册算法，则抛出一个 NotSupportedError。
如果 key 的 [[extractable]] 内部槽为 false，则抛出一个 InvalidAccessError。
令 result 为使用 key 和 format，执行由 key 的 [[algorithm]] 内部槽指定的 export key 操作所得的结果。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
如果 format 等于字符串 "raw"、 "pkcs8" 或 "spki"：

令 result 为在 realm 中创建一个包含 result 的 ArrayBuffer 所得的结果。

如果 format 等于字符串 "jwk"：

令 result 为在 realm 中将 result 转换为 ECMAScript Object 所得的结果，如 [WebIDL] 中所定义。
用 result 解决 promise。

注

为了互操作性，鼓励支持 "raw" 密钥格式。 Web 开发者应查阅测试套件，以获取关于实现对其他密钥格式支持情况的详细信息。

调用时，wrapKey 方法 MUST 执行以下步骤：

令 format、key、wrappingKey 和 algorithm 分别为传递给 wrapKey() 方法的 format、key、 wrappingKey 和 wrapAlgorithm 参数。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "wrapKey"。
如果发生错误，则令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "encrypt"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 wrappingKey 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 wrappingKey 的 [[usages]] 内部槽不包含值为 "wrapKey" 的条目，则抛出一个 InvalidAccessError。
如果由 key 的 [[algorithm]] 内部槽标识的算法不支持 export key 操作，则抛出一个 NotSupportedError。
如果 key 的 [[extractable]] 内部槽为 false，则抛出一个 InvalidAccessError。

注

因为 wrapKey 方法实际上会导出密钥，所以只有标记为 extractable 的密钥才可以被包装。特别是，这意味着此 API 无法使用 ext JWK 成员创建一个标记为不可提取的已包装 JWK 密钥。

但是，unwrapKey 方法确实支持 ext JWK 成员，因此，在其他地方（例如由服务器）创建的已包装不可提取密钥可以使用此 API 解包。
令 exportedKey 为使用 key 和 format，执行由 key 的 [[algorithm]] 内部槽指定的 export key 操作所得的结果。
如果 format 等于字符串 "raw"、 "pkcs8" 或 "spki"：

令 bytes 为 exportedKey。

如果 format 等于字符串 "jwk"：
1. 令 json 为将 exportedKey 表示为符合 JSON 语法的 UTF-16 字符串所得的结果；例如，通过在新全局对象上下文中执行 [ECMA-262] 中指定的 JSON.stringify 算法。
2. 令 bytes 为对 json 进行UTF-8 编码所得的结果。
注

某些算法的密钥包装操作会对载荷大小施加限制。例如，AES-KW 要求载荷长度为 8 字节的倍数，而 RSA-OAEP 会对长度施加限制。对于在给定密钥的序列化方面提供灵活性的密钥格式（例如 JWK），实现可以选择使序列化适配包装算法的约束。这就是为什么没有规范性要求 JSON.stringify，否则它将禁止实现引入额外的填充。
如果 normalizedAlgorithm 支持 wrap key 操作：

令 result 为使用 algorithm， wrappingKey 作为 key，并以 bytes 作为 plaintext，执行由 normalizedAlgorithm 指定的 wrap key 操作所得的结果。

否则，如果 normalizedAlgorithm 支持 encrypt 操作：

令 result 为使用 algorithm， wrappingKey 作为 key，并以 bytes 作为 plaintext，执行由 normalizedAlgorithm 指定的 encrypt 操作所得的结果。

否则：

抛出一个 NotSupportedError。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中创建一个包含 result 的 ArrayBuffer 所得的结果。
用 result 解决 promise。

注

为了互操作性，鼓励支持 "raw" 密钥格式。 Web 开发者应查阅测试套件，以获取关于实现对其他密钥格式支持情况的详细信息。

调用时，unwrapKey 方法 MUST 执行以下步骤：

令 format、unwrappingKey、 algorithm、unwrappedKeyAlgorithm、 extractable 和 usages 分别为传递给 unwrapKey() 方法的 format、unwrappingKey、 unwrapAlgorithm、unwrappedKeyAlgorithm、 extractable 和 keyUsages 参数。
令 wrappedKey 为获取传递给 unwrapKey() 方法的 wrappedKey 参数所持有字节的副本所得的结果。
令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "unwrapKey"。
如果发生错误，则令 normalizedAlgorithm 为规范化算法所得的结果，其中 alg 设置为 algorithm，op 设置为 "decrypt"。
如果发生错误，则返回一个以 normalizedAlgorithm 拒绝的 Promise。
令 normalizedKeyAlgorithm 为规范化算法所得的结果，其中 alg 设置为 unwrappedKeyAlgorithm，op 设置为 "importKey"。
如果发生错误，则返回一个以 normalizedKeyAlgorithm 拒绝的 Promise。
令 realm 为相关 realm，其属于 this。
令 promise 为一个新的 Promise。
返回 promise，并并行执行剩余步骤。
如果以下步骤或引用的过程要求抛出错误，则在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以返回的错误拒绝 promise；然后终止算法。
如果 normalizedAlgorithm 的 name 成员不等于 unwrappingKey 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 unwrappingKey 的 [[usages]] 内部槽不包含值为 "unwrapKey" 的条目，则抛出一个 InvalidAccessError。
如果 normalizedAlgorithm 支持 unwrap key 操作：

令 bytes 为使用 algorithm， unwrappingKey 作为 key，并以 wrappedKey 作为 ciphertext，执行由 normalizedAlgorithm 指定的 unwrap key 操作所得的结果。

否则，如果 normalizedAlgorithm 支持 decrypt 操作：

令 bytes 为使用 algorithm， unwrappingKey 作为 key，并以 wrappedKey 作为 ciphertext，执行由 normalizedAlgorithm 指定的 decrypt 操作所得的结果。

否则：

抛出一个 NotSupportedError。
如果 format 等于字符串 "raw"、 "pkcs8" 或 "spki"：

令 key 为 bytes。

如果 format 等于字符串 "jwk"：

令 key 为以 bytes 作为要解析的 data，执行解析 JWK算法所得的结果。
令 result 为使用 unwrappedKeyAlgorithm 作为 algorithm、format、 usages 和 extractable，并以 key 作为 keyData，执行由 normalizedKeyAlgorithm 指定的 import key 操作所得的结果。
如果 result 的 [[type]] 内部槽为 "secret" 或 "private"，并且 usages 为空，则抛出一个 SyntaxError。
将 result 的 [[extractable]] 内部槽设置为 extractable。
将 result 的 [[usages]] 内部槽设置为 usages 的规范化值。
在crypto 任务源上排队一个全局任务，给定 realm 的全局对象，以执行剩余步骤。
令 result 为在 realm 中将 result 转换为 ECMAScript Object 所得的结果，如 [WebIDL] 中所定义。
用 result 解决 promise。

注

为了互操作性，鼓励支持 "raw" 密钥格式。 Web 开发者应查阅测试套件，以获取关于实现对其他密钥格式支持情况的详细信息。

SubtleCrypto 接口的方法通过使用 ECMAScript [ECMA-262] 或 DOMException 中定义的预定义异常拒绝返回的 promise 来返回错误。使用以下预定义异常：TypeError。使用 [DOM] 中的以下 DOMException 类型：

名称	描述
`NotSupportedError`	不支持该算法
`SyntaxError`	缺少必需参数或参数超出范围
`InvalidAccessError`	所请求的操作对所提供的密钥无效
`DataError`	提供给操作的数据不满足要求
`OperationError`	操作因操作特定的原因而失败

当本规范要求抛出错误时，用户代理必须按照 [WebIDL] 中所述抛出错误。当这发生在子算法中时，这会导致该子算法以及所有祖先算法的执行终止，直到到达某个显式描述了捕获异常过程的算法为止。被抛出的错误对象应与相关 realm，其属于 this。

WebIDLdictionary RsaOtherPrimesInfo {
  // The following fields are defined in Section 6.3.2.7 of JSON Web Algorithms
  DOMString r;
  DOMString d;
  DOMString t;
};

dictionary JsonWebKey {
  // The following fields are defined in Section 3.1 of JSON Web Key
  DOMString kty;
  DOMString use;
  sequence<DOMString> key_ops;
  DOMString alg;

  // The following fields are defined in JSON Web Key Parameters Registration
  boolean ext;

  // The following fields are defined in Section 6 of JSON Web Algorithms
  DOMString crv;
  DOMString x;
  DOMString y;
  DOMString d;
  DOMString n;
  DOMString e;
  DOMString p;
  DOMString q;
  DOMString dp;
  DOMString dq;
  DOMString qi;
  sequence<RsaOtherPrimesInfo> oth;
  DOMString k;
};

JsonWebKey 字典提供了一种表示和交换由 JSON Web Key [JWK] 结构表示的加密密钥的方法，同时允许在 Web Cryptography API 应用中进行原生且高效的使用。

RsaOtherPrimesInfo 的成员定义于 JSON Web Algorithms 第 6.3.2.7 节。

WebIDLtypedef Uint8Array BigInteger;

BigInteger typedef 是一个 Uint8Array，其以大端序保存任意大小的无符号整数。从 API 读取的值SHALL具有最小类型化数组长度（即至多 7 个前导零位，但值 0 应具有 8 位长度）。API SHALL 接受具有任意数量前导零位的值，包括表示零的空数组。

注

由于整数是无符号的，最高有效位不是符号位。实现者在映射到期望有符号整数的大整数实现时应谨慎。

WebIDLdictionary CryptoKeyPair {
  CryptoKey publicKey;
  CryptoKey privateKey;
};

CryptoKeyPair 字典表示一个非对称密钥对，由公钥（publicKey）和私钥（privateKey）组成。

本节是非规范性的。

除了通过 SubtleCrypto 接口提供执行加密操作的通用接口之外，本规范还提供了作者可能希望使用、且用户代理可以选择实现的各种算法的描述。这包括一组常用部署的对称和非对称算法、密钥派生机制，以及用于包装和解包密钥的方法。此外，本规范定义了一个过程，允许其他规范引入额外的加密算法。

为与 Web Cryptography API 一起使用而定义的每个加密算法 MUST 具有一个唯一名称，称为其已识别算法名称，使得没有其他规范为 Web Cryptography API 的使用定义相同的不区分大小写字符串。

为与 Web Cryptography API 一起使用而定义的每个加密算法都有一个支持的操作列表，它们是一组由 SubtleCrypto 接口调用以执行所需加密操作的子算法。本规范使用以下操作：

encrypt
decrypt
sign
verify
digest
deriveBits
wrapKey
unwrapKey
generateKey
importKey
exportKey
get key length

如果给定的算法规范没有列出某个特定操作为受支持，或显式列出某个操作为不受支持，则用户代理 MUST 表现得好像调用该子算法抛出了 NotSupportedError。

为与 Web Cryptography API 一起使用而定义的每个加密算法 MUST 针对每个支持的操作，定义用于算法规范化的 IDL 类型，以及子算法返回值的 IDL 类型或类型集合。

本规范中的每个加密算法定义都采用以下规范约定。标题为 "Registration" 的小节将包括已识别算法名称。此外，它包括一个表，该表将把每个支持的操作列为行，并由 Operation 列标识。给定行中 Parameters 列的内容将包含用于该操作算法规范化的 IDL 类型，而该行中 Result 列的内容指示执行该支持的操作后所得的 IDL 类型。

如果一致的用户代理实现某个算法，则它 MUST 实现所有支持的操作，并且 MUST 返回指定的 IDL 类型。

此外，在初始化时，一致的用户代理必须对每个支持的操作执行定义算法步骤，按指示注册其 IDL 参数类型。

除非另有说明，由本规范中定义的操作创建的对象应与相关 realm 关联，其属于 this。

本节是非规范性的。

AlgorithmIdentifier typedef 允许算法被指定为 DOMString 或一个对象。使用 DOMString 是为了允许作者用简写来表示没有参数的算法（例如 SHA-1）。使用对象是为了允许指定 Algorithm（或适当的子类），其包含对象的所有关联参数。

因此，有必要定义将 AlgorithmIdentifier 转换为可与此 API 一起使用的适当字典的算法。该算法必须是可扩展的，以允许添加新的加密算法，并且必须是一致的，以便 Web IDL 类型映射可以在任何控制返回给调用脚本之前发生，否则可能允许参数或脚本环境发生变异。

本规范使用一个内部对象 supportedAlgorithms。该内部对象不暴露给应用。

由于该值不暴露给应用，因此未指定其确切类型。仅要求它表现为键/值对的关联容器，其中键的比较以区分大小写的方式执行。

此内部对象的初始内容如下：

对于支持的操作列表中的每个值 v，将内部对象 supportedAlgorithms 的 v 键设置为新的关联容器。

定义算法算法由规范作者使用，用于指示用户代理应如何为特定算法规范化参数。其输入为算法名称 alg（表示为 DOMString）、操作名称 op（表示为 DOMString），以及所需的 IDL 字典类型 type。该算法行为如下：

令 registeredAlgorithms 为存储在 supportedAlgorithms 的 op 键处的关联容器。
将 registeredAlgorithms 的 alg 键设置为 IDL 字典类型 type。

规范化算法算法定义了在 Web IDL 转换发生之后，将输入强制转换为目标 IDL 字典类型的过程。它被设计为可扩展，以允许未来规范定义额外算法，同时也安全适用于 Promise。其输入为操作名称 op 和一个 AlgorithmIdentifier alg。其输出为 IDL 字典类型或错误。其行为如下：

如果 alg 是 DOMString 的实例：

返回运行规范化算法算法所得的结果，其中 alg 设置为一个新的 Algorithm 字典，其 name 属性为 alg，并且 op 设置为 op。

如果 alg 是对象：

令 registeredAlgorithms 为存储在 supportedAlgorithms 的 op 键处的关联容器。
令 initialAlg 为将 alg 表示的 ECMAScript 对象转换为 IDL 字典类型 Algorithm 所得的结果，如 [WebIDL] 中所定义。
如果发生错误，则返回该错误并终止此算法。
令 algName 为 initialAlg 的 name 属性的值。
如果 registeredAlgorithms 包含一个键，该键与 algName 为不区分大小写字符串匹配：
1. 将 algName 设置为匹配键的值。
2. 令 desiredType 为存储在 registeredAlgorithms 中 algName 处的 IDL 字典类型。
否则：

返回一个新的 NotSupportedError 并终止此算法。
令 normalizedAlgorithm 为将 alg 表示的 ECMAScript 对象转换为 IDL 字典类型 desiredType 所得的结果，如 [WebIDL] 中所定义。
将 normalizedAlgorithm 的 name 属性设置为 algName。
如果发生错误，则返回该错误并终止此算法。
令 dictionaries 为一个列表，由 IDL 字典类型 desiredType 及 desiredType 的所有继承字典组成，按从最不派生到最派生的顺序排列。
对 dictionaries 中的每个字典 dictionary：
1. 对 dictionary 上声明的每个字典成员 member，按顺序：
  1. 令 key 为 member 的标识符。
  2. 令 idlValue 为 normalizedAlgorithm 上键名为 key 的字典成员的值。
  3. 如果 member 的类型为 BufferSource 且存在：
    
    将 normalizedAlgorithm 上键名为 key 的字典成员设置为获取其持有字节副本 idlValue 所得的结果，以替换当前值。
    
    如果 member 的类型为 HashAlgorithmIdentifier：
    
    将 normalizedAlgorithm 上键名为 key 的字典成员设置为规范化算法所得的结果，其中 alg 设置为 idlValue，并且 op 设置为 "digest"。
    
    如果 member 的类型为 AlgorithmIdentifier：
    
    将 normalizedAlgorithm 上键名为 key 的字典成员设置为规范化算法所得的结果，其中 alg 设置为 idlValue，并且 op 设置为由标识 algName 的算法所属规范定义的操作。
  4. 如果发生错误，则返回该错误并终止此算法。
返回 normalizedAlgorithm。

本节是非规范性的。

由于此 API 旨在可扩展，以跟上密码学领域的未来发展，因此没有要求一致的用户代理必须实现的算法。因此，作者应检查当前哪些算法被推荐并由实现支持。

如安全性考虑中所强调的，即使某些加密算法在某一目的下可能被认为很强，用于另一目的时也可能不足。因此，作者在发明新的加密协议之前应极其谨慎。

此外，本规范包括若干算法，其默认用法可能导致加密漏洞。虽然这些问题可以被缓解，例如通过与本规范提供的额外算法组合和合成，作者在使用给定算法之前仍应谨慎行事并查阅相关密码学文献。本规范中包含算法并不表示它们适合任何或所有目的，而仅仅是提供一个规范，说明一致的用户代理如果选择实现该算法时，必须如何实现给定算法。

为了促进开发者的互操作性，本规范包括一个建议算法列表。这些算法被认为是在撰写本文时实践中使用最广泛的算法，因此为本规范的初始实现提供了良好的起点。建议的算法为：

使用 SHA-1 的 HMAC
使用 SHA-256 的 HMAC
使用 SHA-1 的 RSASSA-PKCS1-v1_5
使用 SHA-256 以及基于 SHA-256 的 MGF1 的 RSA-PSS。
使用 SHA-256 以及基于 SHA-256 的 MGF1 的 RSA-OAEP。
使用 P-256 曲线和 SHA-256 的 ECDSA
AES-CBC

本节是非规范性的。

下表包含本规范中描述的算法概述，以及该算法可与之一起使用的 SubtleCrypto 方法集合。为了使某个算法可与某个方法一起使用，必须在算法规范中定义该方法的过程中所定义的相应操作或操作集合。请注意，方法到底层操作的这种映射不是一对一的：

encrypt 方法需要 encrypt 操作。
decrypt 方法需要 decrypt 操作。
sign 方法需要 sign 操作。
verify 方法需要 verify 操作。
generateKey 方法需要 generateKey 操作。
importKey 方法需要 importKey 操作。
exportKey 方法需要 exportKey 操作。
deriveKey 方法需要用于密钥派生算法的 deriveBits 操作，以及用于派生密钥算法的 get key length 和 importKey 操作。
deriveBits 方法需要用于密钥派生算法的 deriveBits 操作。
digest 方法需要 digest 操作。
wrapKey 方法需要用于包装算法的 encrypt 或 wrapKey 操作，以及用于被包装密钥算法的 exportKey 操作。
unwrapKey 方法需要用于解包算法的 decrypt 或 unwrapKey 操作，以及用于被解包密钥算法的 importKey 操作。

注

应用开发者和脚本作者不应将此表解释为推荐使用特定算法。相反，它只是记录了支持哪些方法。作者应参考本文档的面向作者的安全考虑一节，以更好地理解使用某些算法时可能产生的风险和顾虑。

算法名称	encrypt	decrypt	sign	verify	digest	generateKey	deriveKey	deriveBits	importKey	exportKey	wrapKey	unwrapKey
RSASSA-PKCS1-v1_5			✔	✔		✔			✔	✔
RSA-PSS			✔	✔		✔			✔	✔
RSA-OAEP	✔	✔				✔			✔	✔	✔	✔
ECDSA			✔	✔		✔			✔	✔
ECDH						✔	✔	✔	✔	✔
Ed25519			✔	✔		✔			✔	✔
X25519						✔	✔	✔	✔	✔
AES-CTR	✔	✔				✔			✔	✔	✔	✔
AES-CBC	✔	✔				✔			✔	✔	✔	✔
AES-GCM	✔	✔				✔			✔	✔	✔	✔
AES-KW						✔			✔	✔	✔	✔
HMAC			✔	✔		✔			✔	✔
SHA-1					✔
SHA-256					✔
SHA-384					✔
SHA-512					✔
HKDF							✔	✔	✔
PBKDF2							✔	✔	✔

本节是非规范性的。

"RSASSA-PKCS1-v1_5" 算法标识符用于执行 [RFC3447] 中指定的 RSASSA-PKCS1-v1_5 算法的签名和验证，并使用本规范中定义的 SHA 哈希函数。

其他规范可以指定将其他哈希算法与 RSASSA-PKCS1-v1_5 一起使用。此类规范必须定义其他哈希算法的摘要操作，以及 RSASSA-PKCS1-v1_5 的密钥导入步骤和密钥导出步骤。

此算法的已识别算法名称为 "RSASSA-PKCS1-v1_5"。

操作	参数	结果
sign	无	字节序列
verify	无	boolean
generateKey	`RsaHashedKeyGenParams`	`CryptoKeyPair`
importKey	`RsaHashedImportParams`	`CryptoKey`
exportKey	无	object

WebIDLdictionary RsaKeyGenParams : Algorithm {
  required [EnforceRange] unsigned long modulusLength;
  required BigInteger publicExponent;
};

modulusLength 成员包含 RSA 模数的长度，以位为单位。

publicExponent 成员包含 RSA 公共指数。

WebIDLdictionary RsaHashedKeyGenParams : RsaKeyGenParams {
  required HashAlgorithmIdentifier hash;
};

hash 成员表示要使用的哈希算法。

WebIDLdictionary RsaKeyAlgorithm : KeyAlgorithm {
  required unsigned long modulusLength;
  required BigInteger publicExponent;
};

modulusLength 成员包含 RSA 模数的长度，以位为单位。

publicExponent 成员包含 RSA 公共指数。

WebIDLdictionary RsaHashedKeyAlgorithm : RsaKeyAlgorithm {
  required KeyAlgorithm hash;
};

hash 成员描述与此密钥一起使用的哈希算法。

WebIDLdictionary RsaHashedImportParams : Algorithm {
  required HashAlgorithmIdentifier hash;
};

hash 成员描述要使用的哈希算法。

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
执行 [RFC3447] 第 8.2 节中定义的签名生成操作，其中使用 key 的 [[handle]] 内部槽表示的密钥作为签名者的私钥，以 message 作为 M，并使用 key 的 [[algorithm]] 内部槽的 hash 属性中指定的哈希函数，作为 EMSA-PKCS1-v1_5 编码方法的 Hash 选项。
如果执行该操作导致错误，则抛出一个 OperationError。
令 signature 为执行该操作所得的值 S。
返回 signature。

如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
执行 [RFC3447] 第 8.2 节中定义的签名验证操作，其中使用 key 的 [[handle]] 内部槽表示的密钥作为签名者的 RSA 公钥，以 message 作为 M，并以 signature 作为 S，并使用 key 的 [[algorithm]] 内部槽的 hash 属性中指定的哈希函数作为 EMSA-PKCS1-v1_5 编码方法的 Hash 选项。
令 result 为一个 boolean；如果该操作的结果为 "valid signature"，则其值为 true，否则其值为 false。
返回 result。

如果 usages 包含不是 "sign" 或 "verify" 的条目，则抛出一个 SyntaxError。
按 [RFC3447] 中的定义生成一个 RSA 密钥对，其 RSA 模数长度等于 normalizedAlgorithm 的 modulusLength 属性，RSA 公共指数等于 normalizedAlgorithm 的 publicExponent 属性。
如果密钥对生成失败，则抛出一个 OperationError。
令 algorithm 为一个新的 RsaHashedKeyAlgorithm 字典。
将 algorithm 的 name 属性设置为 "RSASSA-PKCS1-v1_5"。
将 algorithm 的 modulusLength 属性设置为等于 normalizedAlgorithm 的 modulusLength 属性。
将 algorithm 的 publicExponent 属性设置为等于 normalizedAlgorithm 的 publicExponent 属性。
将 algorithm 的 hash 属性设置为等于 normalizedAlgorithm 的 hash 成员。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为 usages 与 [ "verify" ] 的用法交集。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "sign" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 包含不是 "verify" 的条目，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC3447] 中定义的 rsaEncryption 对象标识符，则抛出一个 DataError。
5. 令 publicKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 spki 的 subjectPublicKeyInfo 字段， structure 为 [RFC3447] 第 A.1.1 节中指定的 RSAPublicKey 结构，并将 exactData 设置为 true。
6. 如果解析过程中发生错误，或者可以确定 publicKey 不是符合 [RFC3447] 的有效公钥，则抛出一个 DataError。
7. 令 key 为一个新的 CryptoKey，它表示由 publicKey 标识的 RSA 公钥。
8. 将 key 的 [[type]] 内部槽设置为 "public"
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "sign" 的条目，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC3447] 中定义的 rsaEncryption 对象标识符，则抛出一个 DataError。
5. 令 rsaPrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段， structure 为 [RFC3447] 第 A.1.2 节中指定的 RSAPrivateKey 结构，并将 exactData 设置为 true。
6. 如果解析过程中发生错误，或者 rsaPrivateKey 不是符合 [RFC3447] 的有效 RSA 私钥，则抛出一个 DataError。
7. 令 key 为一个新的 CryptoKey，它表示由 rsaPrivateKey 标识的 RSA 私钥。
8. 将 key 的 [[type]] 内部槽设置为 "private"
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 d 字段存在，且 usages 包含不是 "sign" 的条目；或者，如果 jwk 的 d 字段不存在，且 usages 包含不是 "verify" 的条目，则抛出一个 SyntaxError。
3. 如果 jwk 的 kty 字段与 "RSA" 不是区分大小写的字符串匹配，则抛出一个 DataError。
4. 如果 usages 非空，且 jwk 的 use 字段存在，并且与 "sig" 不是区分大小写的字符串匹配，则抛出一个 DataError。
5. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或不包含所有指定的 usages 值，则抛出一个 DataError。
6. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
7. 令 hash 为一个初始值为 undefined 的字符串。
8. 如果 jwk 的 alg 字段不存在：
  
  令 hash 为 undefined。
  
  如果 alg 字段等于字符串 "RS1"：
  
  令 hash 为字符串 "SHA-1"。
  
  如果 alg 字段等于字符串 "RS256"：
  
  令 hash 为字符串 "SHA-256"。
  
  如果 alg 字段等于字符串 "RS384"：
  
  令 hash 为字符串 "SHA-384"。
  
  如果 alg 字段等于字符串 "RS512"：
  
  令 hash 为字符串 "SHA-512"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 jwk 并获得 hash。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
9. 如果 hash 不是 undefined：
  
  令 normalizedHash 为规范化算法所得的结果，其中 alg 设置为 hash，并将 op 设置为 digest。
  
  如果 normalizedHash 不等于 normalizedAlgorithm 的 hash 成员，则抛出一个 DataError。
10. 如果 jwk 的 d 字段存在：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.3.2 节的要求，则抛出一个 DataError。
  
  令 privateKey 表示按照 JSON Web Algorithms [JWA] 第 6.3.2 节解释 jwk 所标识的 RSA 私钥。
  
  如果 privateKey 不是符合 [RFC3447] 的有效 RSA 私钥，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示 privateKey。
  
  将 key 的 [[type]] 内部槽设置为 "private"
  
  否则：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.3.1 节的要求，则抛出一个 DataError。
  
  令 publicKey 表示按照 JSON Web Algorithms [JWA] 第 6.3.1 节解释 jwk 所标识的 RSA 公钥。
  
  如果可以确定 publicKey 不是符合 [RFC3447] 的有效 RSA 公钥，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，表示 publicKey。
  
  将 key 的 [[type]] 内部槽设置为 "public"
否则：

抛出一个 NotSupportedError。
令 algorithm 为一个新的 RsaHashedKeyAlgorithm 字典。
将 algorithm 的 name 属性设置为 "RSASSA-PKCS1-v1_5"
将 algorithm 的 modulusLength 属性设置为 RSA 公共模数的长度，以位为单位。
将 algorithm 的 publicExponent 属性设置为 RSA 公共指数的 BigInteger 表示。
将 algorithm 的 hash 属性设置为 normalizedAlgorithm 的 hash 成员。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

令 key 为要导出的密钥。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC3447] 中定义的 OID rsaEncryption。
    
    将 params 字段设置为 ASN.1 类型 NULL。
  - 将 subjectPublicKey 字段设置为对 [RFC3447] 附录 A.1.1 中定义的 RSAPublicKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 RSA 公钥
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC3447] 中定义的 OID rsaEncryption。
    
    将 params 字段设置为 ASN.1 类型 NULL。
  - 将 privateKey 字段设置为对 [RFC3447] 附录 A.1.2 中定义的 RSAPrivateKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 RSA 私钥
    
    注
    
    [RFC5208] 在第 5 节中规定，此字段的编码应进行 BER 编码（作为 “例如”）。然而，为了避免要求 WebCrypto 实现支持 BER 编码和 BER 解码，只会生成或接受 DER 编码。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "RSA"。
3. 令 hash 为 key 的 [[algorithm]] 内部槽的 hash 属性的 name 属性。
4. 如果 hash 为 "SHA-1"：
  
  将 jwk 的 alg 属性设置为字符串 "RS1"。
  
  如果 hash 为 "SHA-256"：
  
  将 jwk 的 alg 属性设置为字符串 "RS256"。
  
  如果 hash 为 "SHA-384"：
  
  将 jwk 的 alg 属性设置为字符串 "RS384"。
  
  如果 hash 为 "SHA-512"：
  
  将 jwk 的 alg 属性设置为字符串 "RS512"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format、 key 并获得 alg。
  
  如果发生错误或不存在适用规范，则抛出一个 NotSupportedError。
  
  将 jwk 的 alg 属性设置为 alg。
5. 按照 JSON Web Algorithms [JWA] 第 6.3.1 节中的相应定义，设置 jwk 的属性 n 和 e。
6. 如果 key 的 [[type]] 内部槽为 "private"：
  
  按照 JSON Web Algorithms [JWA] 第 6.3.2 节中的相应定义，设置 jwk 的名为 d、p、 q、dp、dq 和 qi 的属性。
  
  如果由 key 的 [[handle]] 内部槽表示的底层 RSA 私钥由多于两个素数表示，则按照 JSON Web Algorithms [JWA] 第 6.3.2.7 节中的相应定义，设置 jwk 的名为 oth 的属性
7. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
8. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
9. 令 result 为 jwk。
否则

抛出一个 NotSupportedError。
返回 result。

本节是非规范性的。

"RSA-PSS" 算法标识符用于执行使用 [RFC3447] 中指定的 RSASSA-PSS 算法的签名和验证，并使用本规范中定义的 SHA 哈希函数和掩码生成公式 MGF1。

其他规范可以指定将其他哈希算法与 RSASSA-PSS 一起使用。此类规范必须定义其他哈希算法的摘要操作，以及 RSASSA-PSS 的密钥导入步骤和密钥导出步骤。

此算法的已识别算法名称为 "RSA-PSS"。

操作	参数	结果
sign	`RsaPssParams`	字节序列
verify	`RsaPssParams`	boolean
generateKey	`RsaHashedKeyGenParams`	`CryptoKeyPair`
importKey	`RsaHashedImportParams`	`CryptoKey`
exportKey	无	object

WebIDLdictionary RsaPssParams : Algorithm {
  required [EnforceRange] unsigned long saltLength;
};

saltLength 成员表示所需的随机盐长度，以字节为单位。

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
执行 [RFC3447] 第 8.1 节中定义的签名生成操作，其中使用 key 的 [[handle]] 内部槽表示的密钥作为签名者的私钥 K，以 message 作为要签名的消息 M，并使用 key 的 [[algorithm]] 内部槽的 hash 属性指定的哈希函数作为 Hash 选项，MGF1（定义于 [RFC3447] 第 B.2.1 节）作为 MGF 选项，并使用 normalizedAlgorithm 的 saltLength 成员作为 EMSA-PSS-ENCODE 操作的盐长度选项。
如果执行该操作导致错误，则抛出一个 OperationError。
令 signature 为执行该操作所得的签名 S。
返回 signature。

如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
执行 [RFC3447] 第 8.1 节中定义的签名验证操作，其中使用 key 的 [[handle]] 内部槽表示的密钥作为签名者的 RSA 公钥，以 message 作为 M，并以 signature 作为 S，并使用 key 的 [[algorithm]] 内部槽的 hash 属性指定的哈希函数作为 Hash 选项，MGF1（定义于 [RFC3447] 第 B.2.1 节）作为 MGF 选项，并使用 normalizedAlgorithm 的 saltLength 成员作为 EMSA-PSS-VERIFY 操作的盐长度选项。
令 result 为一个 boolean；如果该操作的结果为 "valid signature"，则其值为 true，否则其值为 false。

如果 usages 包含不是 "sign" 或 "verify" 的条目，则抛出一个 SyntaxError。
按 [RFC3447] 中的定义生成一个 RSA 密钥对，其 RSA 模数长度等于 normalizedAlgorithm 的 modulusLength 成员， RSA 公共指数等于 normalizedAlgorithm 的 publicExponent 成员。
如果执行该操作导致错误，则抛出一个 OperationError。
令 algorithm 为一个新的 RsaHashedKeyAlgorithm 字典。
将 algorithm 的 name 属性设置为 "RSA-PSS"。
将 algorithm 的 modulusLength 属性设置为等于 normalizedAlgorithm 的 modulusLength 成员。
将 algorithm 的 publicExponent 属性设置为等于 normalizedAlgorithm 的 publicExponent 成员。
将 algorithm 的 hash 属性设置为等于 normalizedAlgorithm 的 hash 成员。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为 usages 与 [ "verify" ] 的用法交集。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "sign" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 包含不是 "verify" 的条目，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC3447] 中定义的 rsaEncryption 对象标识符，则抛出一个 DataError。
5. 令 publicKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 spki 的 subjectPublicKeyInfo 字段， structure 为 [RFC3447] 第 A.1.1 节中指定的 RSAPublicKey 结构，并将 exactData 设置为 true。
6. 如果解析过程中发生错误，或者可以确定 publicKey 不是符合 [RFC3447] 的有效公钥，则抛出一个 DataError。
7. 令 key 为一个新的 CryptoKey，它表示由 publicKey 标识的 RSA 公钥。
8. 将 key 的 [[type]] 内部槽设置为 "public"
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "sign" 的条目，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC3447] 中定义的 rsaEncryption 对象标识符，则抛出一个 DataError。
5. 令 rsaPrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段， structure 为 [RFC3447] 第 A.1.2 节中指定的 RSAPrivateKey 结构，并将 exactData 设置为 true。
6. 如果解析过程中发生错误，或者 rsaPrivateKey 不是符合 [RFC3447] 的有效 RSA 私钥，则抛出一个 DataError。
7. 令 key 为一个新的 CryptoKey，它表示由 rsaPrivateKey 标识的 RSA 私钥。
8. 将 key 的 [[type]] 内部槽设置为 "private"
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 d 字段存在，且 usages 包含不是 "sign" 的条目；或者，如果 jwk 的 d 字段不存在，且 usages 包含不是 "verify" 的条目，则抛出一个 SyntaxError。
3. 如果 jwk 的 kty 字段与 "RSA" 不是区分大小写的字符串匹配，则抛出一个 DataError。
4. 如果 usages 非空，且 jwk 的 use 字段存在，并且与 "sig" 不是区分大小写的字符串匹配，则抛出一个 DataError。
5. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或不包含所有指定的 usages 值，则抛出一个 DataError。
6. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
7. 如果 jwk 的 alg 字段不存在：
  
  令 hash 为 undefined。
  
  如果 alg 字段等于字符串 "PS1"：
  
  令 hash 为字符串 "SHA-1"。
  
  如果 alg 字段等于字符串 "PS256"：
  
  令 hash 为字符串 "SHA-256"。
  
  如果 alg 字段等于字符串 "PS384"：
  
  令 hash 为字符串 "SHA-384"。
  
  如果 alg 字段等于字符串 "PS512"：
  
  令 hash 为字符串 "SHA-512"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 jwk 并获得 hash。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
8. 如果 hash 不是 undefined：
  
  令 normalizedHash 为规范化算法所得的结果，其中 alg 设置为 hash，并将 op 设置为 digest。
  
  如果 normalizedHash 不等于 normalizedAlgorithm 的 hash 成员，则抛出一个 DataError。
9. 如果 jwk 的 d 字段存在：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.3.2 节的要求，则抛出一个 DataError。
  
  令 privateKey 表示按照 JSON Web Algorithms [JWA] 第 6.3.2 节解释 jwk 所标识的 RSA 私钥。
  
  如果可以确定 privateKey 不是符合 [RFC3447] 的有效 RSA 私钥，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，表示 privateKey。
  
  将 key 的 [[type]] 内部槽设置为 "private"
  
  否则：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.3.1 节的要求，则抛出一个 DataError。
  
  令 publicKey 表示按照 JSON Web Algorithms [JWA] 第 6.3.1 节解释 jwk 所标识的 RSA 公钥。
  
  如果可以确定 publicKey 不是符合 [RFC3447] 的有效 RSA 公钥，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，表示 publicKey。
  
  将 key 的 [[type]] 内部槽设置为 "public"
否则：

抛出一个 NotSupportedError。
令 algorithm 为一个新的 RsaHashedKeyAlgorithm 字典。
将 algorithm 的 name 属性设置为 "RSA-PSS"
将 algorithm 的 modulusLength 属性设置为 RSA 公共模数的长度，以位为单位。
将 algorithm 的 publicExponent 属性设置为 RSA 公共指数的 BigInteger 表示。
将 algorithm 的 hash 属性设置为 normalizedAlgorithm 的 hash 成员。
将 key 的 [[algorithm]] 内部槽设置为 algorithm
返回 key。

令 key 为要导出的密钥。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC3447] 中定义的 OID rsaEncryption。
    
    将 params 字段设置为 ASN.1 类型 NULL。
  - 将 subjectPublicKey 字段设置为对 [RFC3447] 附录 A.1.1 中定义的 RSAPublicKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 RSA 公钥
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC3447] 中定义的 OID rsaEncryption。
    
    将 params 字段设置为 ASN.1 类型 NULL。
  - 将 privateKey 字段设置为对 [RFC3447] 附录 A.1.2 中定义的 RSAPrivateKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 RSA 私钥
    
    注
    
    [RFC5208] 在第 5 节中规定，此字段的编码应进行 BER 编码（作为 “例如”）。然而，为了避免要求 WebCrypto 实现支持 BER 编码和 BER 解码，只会生成或接受 DER 编码。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "RSA"。
3. 令 hash 为 key 的 [[algorithm]] 内部槽的 hash 属性的 name 属性。
4. 如果 hash 为 "SHA-1"：
  
  将 jwk 的 alg 属性设置为字符串 "PS1"。
  
  如果 hash 为 "SHA-256"：
  
  将 jwk 的 alg 属性设置为字符串 "PS256"。
  
  如果 hash 为 "SHA-384"：
  
  将 jwk 的 alg 属性设置为字符串 "PS384"。
  
  如果 hash 为 "SHA-512"：
  
  将 jwk 的 alg 属性设置为字符串 "PS512"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 hash 属性，并获得 alg。
  
  将 jwk 的 alg 属性设置为 alg。
5. 按照 JSON Web Algorithms [JWA] 第 6.3.1 节中的相应定义，设置 jwk 的属性 n 和 e。
6. 如果 key 的 [[type]] 内部槽为 "private"：
  
  按照 JSON Web Algorithms [JWA] 第 6.3.2 节中的相应定义，设置 jwk 的名为 d、p、 q、dp、dq 和 qi 的属性。
  
  如果由 key 的 [[handle]] 内部槽表示的底层 RSA 私钥由多于两个素数表示，则按照 JSON Web Algorithms [JWA] 第 6.3.2.7 节中的相应定义，设置 jwk 的名为 oth 的属性
7. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
8. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
9. 令 result 为 jwk。
否则

抛出一个 NotSupportedError。
返回 result。

本节是非规范性的。

"RSA-OAEP" 算法标识符用于根据 [RFC3447] 中指定的 RSAES-OAEP 算法执行加密和解密，并使用本规范中定义的 SHA 哈希函数以及掩码生成函数 MGF1。

其他规范可以指定将其他哈希算法与 RSAES-OAEP 一起使用。此类规范必须定义其他哈希算法的摘要操作，以及 RSAES-OAEP 的密钥导入步骤和密钥导出步骤。

此算法的已识别算法名称为 "RSA-OAEP"。

操作	参数	结果
encrypt	`RsaOaepParams`	字节序列
decrypt	`RsaOaepParams`	字节序列
generateKey	`RsaHashedKeyGenParams`	`CryptoKeyPair`
importKey	`RsaHashedImportParams`	`CryptoKey`
exportKey	无	object

WebIDLdictionary RsaOaepParams : Algorithm {
  BufferSource label;
};

label 成员表示要与消息关联的可选标签/应用数据。

如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
令 label 为 normalizedAlgorithm 的 label 成员；如果 normalizedAlgorithm 的 label 成员不存在，则为空字节序列。
执行 [RFC3447] 第 7.1 节中定义的加密操作，其中使用由 key 表示的密钥作为接收者的 RSA 公钥，以 plaintext 作为要加密的消息 M，以 label 作为标签 L，并使用 key 的 [[algorithm]] 内部槽的 hash 属性指定的哈希函数作为 Hash 选项，并以 MGF1（定义于 [RFC3447] 第 B.2.1 节）作为 MGF 选项。
如果执行该操作导致错误，则抛出一个 OperationError。
令 ciphertext 为执行该操作所得的值 C。
返回 ciphertext。

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
令 label 为 normalizedAlgorithm 的 label 成员；如果 normalizedAlgorithm 的 label 成员不存在，则为空字节序列。
执行 [RFC3447] 第 7.1 节中定义的解密操作，其中使用由 key 表示的密钥作为接收者的 RSA 私钥，以 ciphertext 作为要解密的密文 C，以 label 作为标签 L，并使用 key 的 [[algorithm]] 内部槽的 hash 属性指定的哈希函数作为 Hash 选项，并以 MGF1（定义于 [RFC3447] 第 B.2.1 节）作为 MGF 选项。
如果执行该操作导致错误，则抛出一个 OperationError。
令 plaintext 为执行该操作所得的值 M。
返回 plaintext。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 的条目，则抛出一个 SyntaxError。
按 [RFC3447] 中的定义生成一个 RSA 密钥对，其 RSA 模数长度等于 normalizedAlgorithm 的 modulusLength 成员， RSA 公共指数等于 normalizedAlgorithm 的 publicExponent 成员。
如果执行该操作导致错误，则抛出一个 OperationError。
令 algorithm 为一个新的 RsaHashedKeyAlgorithm 对象。
将 algorithm 的 name 属性设置为 "RSA-OAEP"。
将 algorithm 的 modulusLength 属性设置为等于 normalizedAlgorithm 的 modulusLength 成员。
将 algorithm 的 publicExponent 属性设置为等于 normalizedAlgorithm 的 publicExponent 成员。
将 algorithm 的 hash 属性设置为等于 normalizedAlgorithm 的 hash 成员。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为 usages 与 [ "encrypt", "wrapKey" ] 的用法交集。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "decrypt", "unwrapKey" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 包含不是 "encrypt" 或 "wrapKey" 的条目，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC3447] 中定义的 rsaEncryption 对象标识符，则抛出一个 DataError。
5. 令 publicKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 spki 的 subjectPublicKeyInfo 字段， structure 为 [RFC3447] 第 A.1.1 节中指定的 RSAPublicKey 结构，并将 exactData 设置为 true。
6. 如果解析过程中发生错误，或者可以确定 publicKey 不是符合 [RFC3447] 的有效公钥，则抛出一个 DataError。
7. 令 key 为一个新的 CryptoKey，它表示由 publicKey 标识的 RSA 公钥。
8. 将 key 的 [[type]] 内部槽设置为 "public"
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "decrypt" 或 "unwrapKey" 的条目，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC3447] 中定义的 rsaEncryption 对象标识符，则抛出一个 DataError。
5. 令 rsaPrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段， structure 为 [RFC3447] 第 A.1.2 节中指定的 RSAPrivateKey 结构，并将 exactData 设置为 true。
6. 如果解析过程中发生错误，或者 rsaPrivateKey 不是符合 [RFC3447] 的有效 RSA 私钥，则抛出一个 DataError。
7. 令 key 为一个新的 CryptoKey，它表示由 rsaPrivateKey 标识的 RSA 私钥。
8. 将 key 的 [[type]] 内部槽设置为 "private"
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 d 字段存在，且 usages 包含不是 "decrypt" 或 "unwrapKey" 的条目，则抛出一个 SyntaxError。
3. 如果 jwk 的 d 字段不存在，且 usages 包含不是 "encrypt" 或 "wrapKey" 的条目，则抛出一个 SyntaxError。
4. 如果 jwk 的 kty 字段与 "RSA" 不是区分大小写的字符串匹配，则抛出一个 DataError。
5. 如果 usages 非空，且 jwk 的 use 字段存在，并且与 "enc" 不是区分大小写的字符串匹配，则抛出一个 DataError。
6. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或不包含所有指定的 usages 值，则抛出一个 DataError。
7. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
8. 如果 jwk 的 alg 字段不存在：
  
  令 hash 为 undefined。
  
  如果 jwk 的 alg 字段等于 "RSA-OAEP"：
  
  令 hash 为字符串 "SHA-1"。
  
  如果 jwk 的 alg 字段等于 "RSA-OAEP-256"：
  
  令 hash 为字符串 "SHA-256"。
  
  如果 jwk 的 alg 字段等于 "RSA-OAEP-384"：
  
  令 hash 为字符串 "SHA-384"。
  
  如果 jwk 的 alg 字段等于 "RSA-OAEP-512"：
  
  令 hash 为字符串 "SHA-512"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 jwk 并获得 hash。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
9. 如果 hash 不是 undefined：
  
  令 normalizedHash 为规范化算法所得的结果，其中 alg 设置为 hash，并将 op 设置为 digest。
  
  如果 normalizedHash 不等于 normalizedAlgorithm 的 hash 成员，则抛出一个 DataError。
10. 如果 jwk 的 d 字段存在：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.3.2 节的要求，则抛出一个 DataError。
  
  令 privateKey 表示按照 JSON Web Algorithms [JWA] 第 6.3.2 节解释 jwk 所标识的 RSA 私钥。
  
  如果可以确定 privateKey 不是符合 [RFC3447] 的有效 RSA 私钥，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，表示 privateKey。
  
  将 key 的 [[type]] 内部槽设置为 "private"
  
  否则：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.3.1 节的要求，则抛出一个 DataError。
  
  令 publicKey 表示按照 JSON Web Algorithms [JWA] 第 6.3.1 节解释 jwk 所标识的 RSA 公钥。
  
  如果可以确定 publicKey 不是符合 [RFC3447] 的有效 RSA 公钥，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，表示 publicKey。
  
  将 key 的 [[type]] 内部槽设置为 "public"
否则：

抛出一个 NotSupportedError。
令 algorithm 为一个新的 RsaHashedKeyAlgorithm。
将 algorithm 的 name 属性设置为 "RSA-OAEP"
将 algorithm 的 modulusLength 属性设置为 RSA 公共模数的长度，以位为单位。
将 algorithm 的 publicExponent 属性设置为 RSA 公共指数的 BigInteger 表示。
将 algorithm 的 hash 属性设置为 normalizedAlgorithm 的 hash 成员。
将 key 的 [[algorithm]] 内部槽设置为 algorithm
返回 key。

令 key 为要导出的密钥。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC3447] 中定义的 OID rsaEncryption。
    
    将 params 字段设置为 ASN.1 类型 NULL。
  - 将 subjectPublicKey 字段设置为对 [RFC3447] 附录 A.1.1 中定义的 RSAPublicKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 RSA 公钥
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC3447] 中定义的 OID rsaEncryption。
    
    将 params 字段设置为 ASN.1 类型 NULL。
  - 将 privateKey 字段设置为对 [RFC3447] 附录 A.1.2 中定义的 RSAPrivateKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 RSA 私钥
    
    注
    
    [RFC5208] 在第 5 节中规定，此字段的编码应进行 BER 编码（作为 “例如”）。然而，为了避免要求 WebCrypto 实现支持 BER 编码和 BER 解码，只会生成或接受 DER 编码。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "RSA"。
3. 令 hash 为 key 的 [[algorithm]] 内部槽的 hash 属性的 name 属性。
4. 如果 hash 为 "SHA-1"：
  
  将 jwk 的 alg 属性设置为字符串 "RSA-OAEP"。
  
  如果 hash 为 "SHA-256"：
  
  将 jwk 的 alg 属性设置为字符串 "RSA-OAEP-256"。
  
  如果 hash 为 "SHA-384"：
  
  将 jwk 的 alg 属性设置为字符串 "RSA-OAEP-384"。
  
  如果 hash 为 "SHA-512"：
  
  将 jwk 的 alg 属性设置为字符串 "RSA-OAEP-512"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 hash 属性，并获得 alg。
  
  将 jwk 的 alg 属性设置为 alg。
5. 按照 JSON Web Algorithms [JWA] 第 6.3.1 节中的相应定义，设置 jwk 的属性 n 和 e。
6. 如果 key 的 [[type]] 内部槽为 "private"：
  
  按照 JSON Web Algorithms [JWA] 第 6.3.2 节中的相应定义，设置 jwk 的名为 d、p、 q、dp、dq 和 qi 的属性。
  
  如果由 key 的 [[handle]] 内部槽表示的底层 RSA 私钥由多于两个素数表示，则按照 JSON Web Algorithms [JWA] 第 6.3.2.7 节中的相应定义，设置 jwk 的名为 oth 的属性
7. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
8. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
9. 令 result 为 jwk。
否则

抛出一个 NotSupportedError。
返回 result。

本节是非规范性的。

"ECDSA" 算法标识符用于使用 [RFC6090] 中指定的 ECDSA 算法执行签名和验证，并使用本规范中定义的 SHA 哈希函数和椭圆曲线。

其他规范可以指定将其他椭圆曲线和哈希算法与 ECDSA 一起使用。要指定与 ECDSA 一起使用的其他哈希算法，规范必须定义一个支持摘要操作的注册算法。要指定额外的椭圆曲线，规范必须定义曲线名称、 ECDSA 签名步骤、 ECDSA 验证步骤、 ECDSA 生成步骤、 ECDSA 密钥导入步骤和 ECDSA 密钥导出步骤。

此算法的已识别算法名称为 "ECDSA"。

操作	参数	结果
sign	`EcdsaParams`	字节序列
verify	`EcdsaParams`	boolean
generateKey	`EcKeyGenParams`	`CryptoKeyPair`
importKey	`EcKeyImportParams`	`CryptoKey`
exportKey	无	object

WebIDLdictionary EcdsaParams : Algorithm {
  required HashAlgorithmIdentifier hash;
};

hash 成员表示要使用的哈希算法。

WebIDLtypedef DOMString NamedCurve;

dictionary EcKeyGenParams : Algorithm {
  required NamedCurve namedCurve;
};

NamedCurve 类型表示命名椭圆曲线，它们是指定知名椭圆曲线的域参数的一种便捷方式。本规范定义了以下值：

"P-256": NIST 推荐曲线 P-256，也称为 secp256r1。
"P-384": NIST 推荐曲线 P-384，也称为 secp384r1。
"P-521": NIST 推荐曲线 P-521，也称为 secp521r1。

其他规范可以定义额外值。

EcKeyGenParams 字典的 namedCurve 成员表示命名曲线。

WebIDLdictionary EcKeyAlgorithm : KeyAlgorithm {
  required NamedCurve namedCurve;
};

namedCurve 成员表示该密钥使用的命名曲线。

WebIDLdictionary EcKeyImportParams : Algorithm {
  required NamedCurve namedCurve;
};

namedCurve 成员表示命名曲线。

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
令 hashAlgorithm 为 normalizedAlgorithm 的 hash 成员。
令 M 为使用 message 执行由 hashAlgorithm 指定的摘要操作所得的结果。
令 d 为与 key 关联的 ECDSA 私钥。
令 params 为与 key 关联的 EC 域参数。
如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：
1. 执行 [RFC6090] 第 5.4 节中指定的 ECDSA 签名过程，其中 M 作为消息，使用 params 作为 EC 域参数，并以 d 作为私钥。
2. 令 r 和 s 为执行 ECDSA 签名过程所得的整数对。
3. 令 result 为空字节序列。
4. 令 n 为满足 n * 8 大于由 params 标识的椭圆曲线基点阶数以 2 为底的对数的最小整数。
5. 将 r 转换为长度为 n 的字节序列并追加到 result。
6. 将 s 转换为长度为 n 的字节序列并追加到 result。
否则，如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性是适用规范中指定的值：

执行该规范中指定的 ECDSA 签名步骤，传入 M、params 和 d，并得到 result。
返回 result。

如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
令 hashAlgorithm 为 normalizedAlgorithm 的 hash 成员。
令 M 为使用 message 执行由 hashAlgorithm 指定的摘要操作所得的结果。
令 Q 为与 key 关联的 ECDSA 公钥。
令 params 为与 key 关联的 EC 域参数。
如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：

执行 [RFC6090] 第 5.3 节中指定的 ECDSA 验证过程，其中 M 作为接收到的消息，signature 作为接收到的签名，并使用 params 作为 EC 域参数，且以 Q 作为公钥。

否则，如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性是适用规范中指定的值：

执行该规范中指定的 ECDSA 验证步骤，传入 M、signature、 params 和 Q，并得到所谓签名是否有效的指示。
令 result 为 boolean；如果签名有效，则其值为 true，否则其值为 false。
返回 result。

如果 usages 包含不是 "sign" 或 "verify" 之一的值，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 namedCurve 成员为 "P-256"、"P-384" 或 "P-521"：

按 [RFC6090] 中的定义生成一个椭圆曲线密钥对，其域参数用于 normalizedAlgorithm 的 namedCurve 成员所标识的曲线。

如果 normalizedAlgorithm 的 namedCurve 成员是适用规范中指定的值：

执行该规范中指定的 ECDSA 生成步骤，传入 normalizedAlgorithm，并得到椭圆曲线密钥对。

否则：

抛出一个 NotSupportedError
如果执行密钥生成操作导致错误，则抛出一个 OperationError。
令 algorithm 为一个新的 EcKeyAlgorithm 对象。
将 algorithm 的 name 属性设置为 "ECDSA"。
将 algorithm 的 namedCurve 属性设置为等于 normalizedAlgorithm 的 namedCurve 成员。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为 usages 与 [ "verify" ] 的用法交集。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "sign" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 包含不是 "verify" 的值，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC5480] 中定义的 id-ecPublicKey 对象标识符，则抛出一个 DataError。
5. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 parameters 字段缺失，则抛出一个 DataError。
6. 令 params 为 spki 的 algorithm AlgorithmIdentifier 字段的 parameters 字段。
7. 如果 params 不是 [RFC5480] 中定义的、指定了 namedCurve 的 ECParameters ASN.1 类型实例，则抛出一个 DataError。
8. 令 namedCurve 为一个初始值为 undefined 的字符串。
9. 如果 params 等价于 [RFC5480] 中定义的 secp256r1 对象标识符：
  
  将 namedCurve 设置为 "P-256"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp384r1 对象标识符：
  
  将 namedCurve 设置为 "P-384"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp521r1 对象标识符：
  
  将 namedCurve 设置为 "P-521"。
10. 如果 namedCurve 不是 undefined：
  
  令 publicKey 为通过使用 spki 的 subjectPublicKey 字段执行 [SEC1] 第 2.3.4 节中定义的转换步骤所标识的椭圆曲线公钥。
  
  未压缩点格式 MUST 被支持。
  
  如果实现不支持压缩点格式，并且提供了压缩点，则抛出一个 DataError。
  
  如果发生解码错误或发现单位点，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，它表示 publicKey。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 spki 并获得 namedCurve 和 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
11. 如果 namedCurve 已定义，且不等于 normalizedAlgorithm 的 namedCurve 成员，则抛出一个 DataError。
12. 如果公钥值不是 normalizedAlgorithm 的 namedCurve 成员所标识的椭圆曲线上的有效点，则抛出一个 DataError。
13. 将 key 的 [[type]] 内部槽设置为 "public"
14. 令 algorithm 为一个新的 EcKeyAlgorithm。
15. 将 algorithm 的 name 属性设置为 "ECDSA"。
16. 将 algorithm 的 namedCurve 属性设置为 namedCurve。
17. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "sign" 的值，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC5480] 中定义的 id-ecPublicKey 对象标识符，则抛出一个 DataError。
5. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段不存在，则抛出一个 DataError。
6. 令 params 为 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段。
7. 如果 params 不是 [RFC5480] 中定义的、指定了 namedCurve 的 ECParameters ASN.1 类型实例，则抛出一个 DataError。
8. 令 namedCurve 为一个初始值为 undefined 的字符串。
9. 如果 params 等价于 [RFC5480] 中定义的 secp256r1 对象标识符：
  
  将 namedCurve 设置为 "P-256"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp384r1 对象标识符：
  
  将 namedCurve 设置为 "P-384"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp521r1 对象标识符：
  
  将 namedCurve 设置为 "P-521"。
10. 如果 namedCurve 不是 undefined：
  
  令 ecPrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段，structure 为 [RFC5915] 第 3 节中指定的 ASN.1 ECPrivateKey 结构，并将 exactData 设置为 true。
  
  如果解析过程中发生错误，则抛出一个 DataError。
  
  如果 ecPrivateKey 的 parameters 字段存在，并且不是 [RFC5480] 中定义的 namedCurve ASN.1 类型实例，或者不包含与 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段相同的对象标识符，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，它表示通过使用 ecPrivateKey 执行 [RFC5915] 第 3 节中定义的转换步骤所标识的椭圆曲线私钥。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 privateKeyInfo 并获得 namedCurve 和 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
11. 如果 namedCurve 已定义，且不等于 normalizedAlgorithm 的 namedCurve 成员，则抛出一个 DataError。
12. 如果私钥值不是 normalizedAlgorithm 的 namedCurve 成员所标识的椭圆曲线上的有效点，则抛出一个 DataError。
13. 将 key 的 [[type]] 内部槽设置为 "private"
14. 令 algorithm 为一个新的 EcKeyAlgorithm。
15. 将 algorithm 的 name 属性设置为 "ECDSA"。
16. 将 algorithm 的 namedCurve 属性设置为 namedCurve。
17. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 d 字段存在且 usages 包含不是 "sign" 的值，或者，如果 d 字段不存在且 usages 包含不是 "verify" 的值，则抛出一个 SyntaxError。
3. 如果 jwk 的 kty 字段不是 "EC"，则抛出一个 DataError。
4. 如果 usages 非空，且 jwk 的 use 字段存在，并且不是 "sig"，则抛出一个 DataError。
5. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
6. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
7. 令 namedCurve 为一个字符串，其值等于 jwk 的 crv 字段。
8. 如果 namedCurve 不等于 normalizedAlgorithm 的 namedCurve 成员，则抛出一个 DataError。
9. 如果 namedCurve 等于 "P-256"、 "P-384" 或 "P-521"：
  
  令 algNamedCurve 为一个初始值为 undefined 的字符串。
  
  如果 alg 字段不存在：
  
  令 algNamedCurve 为 undefined。
  
  如果 alg 字段等于字符串 "ES256"：
  
  令 algNamedCurve 为字符串 "P-256"。
  
  如果 alg 字段等于字符串 "ES384"：
  
  令 algNamedCurve 为字符串 "P-384"。
  
  如果 alg 字段等于字符串 "ES512"：
  
  令 algNamedCurve 为字符串 "P-521"。
  
  否则：
  
  抛出一个 DataError。
  
  如果 algNamedCurve 已定义，且不等于 namedCurve，则抛出一个 DataError。
  
  如果 d 字段存在：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.2.2 节的要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 JSON Web Algorithms [JWA] 第 6.2.2 节解释 jwk 所标识的椭圆曲线私钥。
  
  将 Key 的 [[type]] 内部槽设置为 "private"。
  
  否则：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.2.1 节的要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 JSON Web Algorithms [JWA] 第 6.2.1 节解释 jwk 所标识的椭圆曲线公钥。
  
  将 Key 的 [[type]] 内部槽设置为 "public"。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 jwk 并获得 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
10. 如果密钥值不是 normalizedAlgorithm 的 namedCurve 成员所标识的椭圆曲线上的有效点，则抛出一个 DataError。
11. 令 algorithm 为一个新的 EcKeyAlgorithm 对象实例。
12. 将 algorithm 的 name 属性设置为 "ECDSA"。
13. 将 algorithm 的 namedCurve 属性设置为 namedCurve。
14. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "raw"：
1. 如果 normalizedAlgorithm 的 namedCurve 成员不是命名曲线，则抛出一个 DataError。
2. 如果 usages 包含不是 "verify" 的值，则抛出一个 SyntaxError。
3. 如果 namedCurve 为 "P-256"、 "P-384" 或 "P-521"：
  
  令 Q 为通过对 keyData 执行 [SEC1] 第 2.3.4 节中定义的转换步骤所标识的、位于 normalizedAlgorithm 的 namedCurve 成员所标识曲线上的椭圆曲线点。
  
  未压缩点格式 MUST 被支持。
  
  如果实现不支持压缩点格式，并且提供了压缩点，则抛出一个 DataError。
  
  如果发生解码错误或发现单位点，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，它表示 Q。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 keyData 并获得 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
4. 令 algorithm 为一个新的 EcKeyAlgorithm 对象。
5. 将 algorithm 的 name 属性设置为 "ECDSA"。
6. 将 algorithm 的 namedCurve 属性设置为等于 normalizedAlgorithm 的 namedCurve 成员。
7. 将 key 的 [[type]] 内部槽设置为 "public"
8. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
否则：

抛出一个 NotSupportedError。
返回 key

令 key 为要导出的 CryptoKey。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC5480] 中定义的 OID id-ecPublicKey。
    
    将 parameters 字段设置为 [RFC5480] 中定义的 ECParameters ASN.1 类型实例，如下所示：
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、 "P-384" 或 "P-521"：
    
    令 keyData 为一个字节序列，其按照 [RFC5480] 第 2.2 节中指定的编码规则，并使用未压缩形式，表示由 key 的 [[handle]] 内部槽表示的椭圆曲线公钥。以及 keyData。
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"：
    
    将 parameters 设置为 namedCurve 选项，其值等于 [RFC5480] 中定义的对象标识符 secp256r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-384"：
    
    将 parameters 设置为 namedCurve 选项，其值等于 [RFC5480] 中定义的对象标识符 secp384r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-521"：
    
    将 parameters 设置为 namedCurve 选项，其值等于 [RFC5480] 中定义的对象标识符 secp521r1
    
    否则：
    
    执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurveOid 和 keyData。
    
    将 parameters 设置为 namedCurve 选项，其值等于对象标识符 namedCurveOid。
  - 将 subjectPublicKey 字段设置为 keyData。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC5480] 中定义的 OID id-ecPublicKey。
    
    将 parameters 字段设置为 [RFC5480] 中定义的 ECParameters ASN.1 类型实例，如下所示：
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、 "P-384" 或 "P-521"：
    
    令 keyData 为对 [RFC5915] 第 3 节中定义的 ECPrivateKey 结构的一个实例进行 DER 编码所得的结果，该实例用于由 key 的 [[handle]] 内部槽表示的椭圆曲线私钥，并符合以下要求：
    
    parameters 字段存在，并且等价于此 PrivateKeyInfo ASN.1 结构的 privateKeyAlgorithm 字段的 parameters 字段。
    
    publicKey 字段存在，并表示与由 key 的 [[handle]] 内部槽表示的椭圆曲线私钥相关联的椭圆曲线公钥。
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"：
    
    将 parameters 设置为 namedCurve 选项，其值等于 [RFC5480] 中定义的对象标识符 secp256r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-384"：
    
    将 parameters 设置为 namedCurve 选项，其值等于 [RFC5480] 中定义的对象标识符 secp384r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-521"：
    
    将 parameters 设置为 namedCurve 选项，其值等于 [RFC5480] 中定义的对象标识符 secp521r1
    
    否则：
    
    执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurveOid 和 keyData。
    
    将 parameters 设置为 namedCurve 选项，其值等于对象标识符 namedCurveOid。
  - 将 privateKey 字段设置为 keyData。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为 "EC"。
3. 如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：
  
  如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"：
  
  将 jwk 的 crv 属性设置为 "P-256"
  
  如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-384"：
  
  将 jwk 的 crv 属性设置为 "P-384"
  
  如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-521"：
  
  将 jwk 的 crv 属性设置为 "P-521"
  
  按照 JSON Web Algorithms [JWA] 第 6.2.1.2 节中的定义，设置 jwk 的 x 属性。
  
  按照 JSON Web Algorithms [JWA] 第 6.2.1.3 节中的定义，设置 jwk 的 y 属性。
  
  如果 key 的 [[type]] 内部槽为 "private"
  
  按照 JSON Web Algorithms [JWA] 第 6.2.2.1 节中的定义，设置 jwk 的 d 属性。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurve 和 jwk 的新值。
  
  将 jwk 的 crv 属性设置为 namedCurve。
4. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
5. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
6. 令 result 为 jwk。
如果 format 为 "raw"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：
  
  令 data 为一个字节序列，其按照 [SEC1] 第 2.3.3 节使用未压缩格式，表示由 key 的 [[handle]] 内部槽表示的椭圆曲线点 Q。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurve 和 data。
3. 令 result 为 data。
否则：

抛出一个 NotSupportedError。
返回 result。

本节是非规范性的。

本节描述了使用 Elliptic Curve Diffie-Hellman (ECDH) 进行密钥生成和密钥协商，如 [RFC6090] 所指定。

其他规范可以指定将其他椭圆曲线与 ECDH 一起使用。要指定额外的椭圆曲线，规范必须定义曲线名称、 ECDH 生成步骤、 ECDH 派生步骤、 ECDH 密钥导入步骤和 ECDH 密钥导出步骤。

此算法的已识别算法名称为 "ECDH"。

操作	参数	结果
generateKey	`EcKeyGenParams`	`CryptoKeyPair`
deriveBits	`EcdhKeyDeriveParams`	字节序列
importKey	`EcKeyImportParams`	`CryptoKey`
exportKey	无	object

WebIDLdictionary EcdhKeyDeriveParams : Algorithm {
  required CryptoKey public;
};

public 成员表示对等方的 EC 公钥。

如果 usages 包含不是 "deriveKey" 或 "deriveBits" 的条目，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 namedCurve 成员为 "P-256"、"P-384" 或 "P-521"：

按 [RFC6090] 中的定义生成一个椭圆曲线密钥对，其域参数用于 normalizedAlgorithm 的 namedCurve 成员所标识的曲线。

如果 normalizedAlgorithm 的 namedCurve 成员是适用规范中指定的值，且该规范指定了将此值与 ECDH 一起使用：

执行该规范中指定的 ECDH 生成步骤，传入 normalizedAlgorithm，并得到一个椭圆曲线密钥对。

否则：

抛出一个 NotSupportedError
如果执行该操作导致错误，则抛出一个 OperationError。
令 algorithm 为一个新的 EcKeyAlgorithm 对象。
将 algorithm 的 name 成员设置为 "ECDH"。
将 algorithm 的 namedCurve 属性设置为等于 normalizedAlgorithm 的 namedCurve 成员。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为空列表。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "deriveKey", "deriveBits" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
令 publicKey 为 normalizedAlgorithm 的 public 成员。
如果 publicKey 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
如果 publicKey 的 [[algorithm]] 内部槽的 name 属性不等于 key 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
如果 publicKey 的 [[algorithm]] 内部槽的 namedCurve 属性不等于 key 的 [[algorithm]] 内部槽的 namedCurve 属性，则抛出一个 InvalidAccessError。
如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：
1. 执行 [RFC6090] 第 4 节中指定的 ECDH 原语，其中 key 作为 EC 私钥 d，并以由 publicKey 的 [[handle]] 内部槽表示的 EC 公钥作为 EC 公钥。
2. 令 secret 为一个字节序列，其中包含将 [RFC6090] 第 6.2 节中定义的从域元素到八位字节字符串的转换应用于 ECDH 原语输出所得的结果。
如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性是适用规范中指定的值，且该规范指定了将此值与 ECDH 一起使用：

执行该规范中指定的 ECDH 派生步骤，传入 key 和 publicKey，并得到 secret。

否则：

抛出一个 NotSupportedError
如果执行该操作导致错误，则抛出一个 OperationError。
如果 length 为 null：

返回 secret

否则：

如果 secret 的位长度小于 length：

抛出一个 OperationError。

否则：

返回一个包含 secret 的前 length 位的字节序列。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 不是空的，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC5480] 中定义的 id-ecPublicKey 对象标识符，则抛出一个 DataError。
5. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 parameters 字段缺失，则抛出一个 DataError。
6. 令 params 为 spki 的 algorithm AlgorithmIdentifier 字段的 parameters 字段。
7. 如果 params 不是 [RFC5480] 中定义的、指定了 namedCurve 的 ECParameters ASN.1 类型实例，则抛出一个 DataError。
8. 令 namedCurve 为一个初始值为 undefined 的字符串。
9. 如果 params 等价于 [RFC5480] 中定义的 secp256r1 对象标识符：
  
  将 namedCurve 设置为 "P-256"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp384r1 对象标识符：
  
  将 namedCurve 设置为 "P-384"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp521r1 对象标识符：
  
  将 namedCurve 设置为 "P-521"。
10. 如果 namedCurve 不是 undefined：
  
  令 publicKey 为通过对 spki 的 subjectPublicKey 字段执行 [SEC1] 第 2.3.4 节中定义的转换步骤所标识的椭圆曲线公钥。
  
  未压缩点格式 MUST 被支持。
  
  如果实现不支持压缩点格式，并且提供了压缩点，则抛出一个 DataError。
  
  如果发生解码错误或发现单位点，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，它表示 publicKey。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 spki 并获得 namedCurve 和 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
11. 如果 namedCurve 已定义，且不等于 normalizedAlgorithm 的 namedCurve 成员，则抛出一个 DataError。
12. 如果密钥值不是 normalizedAlgorithm 的 namedCurve 成员所标识的椭圆曲线上的有效点，则抛出一个 DataError。
13. 将 key 的 [[type]] 内部槽设置为 "public"
14. 令 algorithm 为一个新的 EcKeyAlgorithm。
15. 将 algorithm 的 name 属性设置为 "ECDH"。
16. 将 algorithm 的 namedCurve 属性设置为 namedCurve。
17. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "deriveKey" 或 "deriveBits" 的条目，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC5480] 中定义的 id-ecPublicKey 对象标识符，则抛出一个 DataError。
5. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段不存在，则抛出一个 DataError。
6. 令 params 为 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段。
7. 如果 params 不是 [RFC5480] 中定义的、指定了 namedCurve 的 ECParameters ASN.1 类型实例，则抛出一个 DataError。
8. 令 namedCurve 为一个初始值为 undefined 的字符串。
9. 如果 params 等价于 [RFC5480] 中定义的 secp256r1 对象标识符：
  
  将 namedCurve 设置为 "P-256"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp384r1 对象标识符：
  
  将 namedCurve 设置为 "P-384"。
  
  如果 params 等价于 [RFC5480] 中定义的 secp521r1 对象标识符：
  
  将 namedCurve 设置为 "P-521"。
10. 如果 namedCurve 不是 undefined：
  
  令 ecPrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段，structure 为 [RFC5915] 第 3 节中指定的 ASN.1 ECPrivateKey 结构，并将 exactData 设置为 true。
  
  如果解析过程中发生错误，则抛出一个 DataError。
  
  如果 ecPrivateKey 的 parameters 字段存在，并且不是 [RFC5480] 中定义的 namedCurve ASN.1 类型实例，或者不包含与 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段相同的对象标识符，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，它表示通过使用 ecPrivateKey 执行 [RFC5915] 第 3 节中定义的转换步骤所标识的椭圆曲线私钥。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 privateKeyInfo 并获得 namedCurve 和 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
11. 如果 namedCurve 已定义，且不等于 normalizedAlgorithm 的 namedCurve 成员，则抛出一个 DataError。
12. 如果密钥值不是 normalizedAlgorithm 的 namedCurve 成员所标识的椭圆曲线上的有效点，则抛出一个 DataError。
13. 将 key 的 [[type]] 内部槽设置为 "private"。
14. 令 algorithm 为一个新的 EcKeyAlgorithm。
15. 将 algorithm 的 name 属性设置为 "ECDH"。
16. 将 algorithm 的 namedCurve 属性设置为 namedCurve。
17. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 d 字段存在，且 usages 包含不是 "deriveKey" 或 "deriveBits" 的条目，则抛出一个 SyntaxError。
3. 如果 d 字段不存在，且 usages 不是空的，则抛出一个 SyntaxError。
4. 如果 jwk 的 kty 字段不是 "EC"，则抛出一个 DataError。
5. 如果 usages 非空，且 jwk 的 use 字段存在，并且不等于 "enc"，则抛出一个 DataError。
6. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
7. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
8. 令 namedCurve 为一个字符串，其值等于 jwk 的 crv 字段。
9. 如果 namedCurve 不等于 normalizedAlgorithm 的 namedCurve 成员，则抛出一个 DataError。
10. 如果 namedCurve 为 "P-256"、 "P-384" 或 "P-521"：
  
  如果 d 字段存在：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.2.2 节的要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 JSON Web Algorithms [JWA] 第 6.2.2 节解释 jwk 所标识的椭圆曲线私钥。
  
  将 Key 的 [[type]] 内部槽设置为 "private"。
  
  否则：
  
  如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.2.1 节的要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 JSON Web Algorithms [JWA] 第 6.2.1 节解释 jwk 所标识的椭圆曲线公钥。
  
  将 Key 的 [[type]] 内部槽设置为 "public"。
  
  否则
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 jwk 并获得 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
11. 如果密钥值不是 normalizedAlgorithm 的 namedCurve 成员所标识的椭圆曲线上的有效点，则抛出一个 DataError。
12. 令 algorithm 为一个新的 EcKeyAlgorithm 对象实例。
13. 将 algorithm 的 name 属性设置为 "ECDH"。
14. 将 algorithm 的 namedCurve 属性设置为 namedCurve。
15. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "raw"：
1. 如果 normalizedAlgorithm 的 namedCurve 成员不是命名曲线，则抛出一个 DataError。
2. 如果 usages 不是空列表，则抛出一个 SyntaxError。
3. 如果 namedCurve 为 "P-256"、 "P-384" 或 "P-521"：
  
  令 Q 为位于 normalizedAlgorithm 的 namedCurve 成员所标识曲线上的椭圆曲线公钥，该公钥通过对 keyData 执行 [SEC1] 第 2.3.4 节中定义的转换步骤来标识。
  
  未压缩点格式 MUST 被支持。
  
  如果实现不支持压缩点格式，并且提供了压缩点，则抛出一个 DataError。
  
  如果发生解码错误或发现单位点，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey，它表示 Q。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、 keyData 并获得 key。
  
  如果发生错误或不存在适用规范，则抛出一个 DataError。
4. 令 algorithm 为一个新的 EcKeyAlgorithm 对象。
5. 将 algorithm 的 name 属性设置为 "ECDH"。
6. 将 algorithm 的 namedCurve 属性设置为等于 normalizedAlgorithm 的 namedCurve 成员。
7. 将 key 的 [[type]] 内部槽设置为 "public"
8. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key

令 key 为要导出的 CryptoKey。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC5480] 中定义的 OID id-ecPublicKey。
    
    将 parameters 字段设置为 [RFC5480] 中定义的 ECParameters ASN.1 类型实例，如下所示：
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、 "P-384" 或 "P-521"：
    
    令 keyData 为一个字节序列，其按照 [SEC1] 第 2.3.3 节中指定的编码规则并使用未压缩形式，表示由 key 的 [[handle]] 内部槽表示的椭圆曲线公钥。
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"：
    
    将 parameters 设置为 namedCurve 选择，其值等于 [RFC5480] 中定义的对象标识符 secp256r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-384"：
    
    将 parameters 设置为 namedCurve 选择，其值等于 [RFC5480] 中定义的对象标识符 secp384r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-521"：
    
    将 parameters 设置为 namedCurve 选择，其值等于 [RFC5480] 中定义的对象标识符 secp521r1
    
    否则：
    
    执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurveOid 和 keyData。
    
    将 parameters 设置为 namedCurve 选择，其值等于对象标识符 namedCurveOid。
  - 将 subjectPublicKey 字段设置为 keyData
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 字段设置为 [RFC5480] 中定义的 OID id-ecPublicKey。
    
    将 parameters 字段设置为 [RFC5480] 中定义的 ECParameters ASN.1 类型实例，如下所示：
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、 "P-384" 或 "P-521"：
    
    令 keyData 为对 [RFC5915] 第 3 节中定义的 ECPrivateKey 结构的一个实例进行 DER 编码所得的结果，该实例用于由 key 的 [[handle]] 内部槽表示的椭圆曲线私钥，并符合以下要求：
    
    parameters 字段存在，并且等价于此 PrivateKeyInfo ASN.1 结构的 privateKeyAlgorithm 字段的 parameters 字段。
    
    publicKey 字段存在，并表示与由 key 的 [[handle]] 内部槽表示的椭圆曲线私钥相关联的椭圆曲线公钥。
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"：
    
    将 parameters 设置为 namedCurve 选择，其值等于 [RFC5480] 中定义的对象标识符 secp256r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-384"：
    
    将 parameters 设置为 namedCurve 选择，其值等于 [RFC5480] 中定义的对象标识符 secp384r1
    
    如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-521"：
    
    将 parameters 设置为 namedCurve 选择，其值等于 [RFC5480] 中定义的对象标识符 secp521r1
    
    否则：
    
    执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurveOid 和 keyData。
    
    将 parameters 设置为 namedCurve 选择，其值等于对象标识符 namedCurveOid。
  - 将 privateKey 字段设置为 keyData。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为 "EC"。
3. 如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：
  
  如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"：
  
  将 jwk 的 crv 属性设置为 "P-256"
  
  如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-384"：
  
  将 jwk 的 crv 属性设置为 "P-384"
  
  如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-521"：
  
  将 jwk 的 crv 属性设置为 "P-521"
  
  按照 JSON Web Algorithms [JWA] 第 6.2.1.2 节中的定义，设置 jwk 的 x 属性。
  
  按照 JSON Web Algorithms [JWA] 第 6.2.1.3 节中的定义，设置 jwk 的 y 属性。
  
  如果 key 的 [[type]] 内部槽为 "private"
  
  按照 JSON Web Algorithms [JWA] 第 6.2.2.1 节中的定义，设置 jwk 的 d 属性。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurve 和 jwk 的新值。
  
  将 jwk 的 crv 属性设置为 namedCurve。
4. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
5. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
6. 令 result 为 jwk。
如果 format 为 "raw"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 如果 key 的 [[algorithm]] 内部槽的 namedCurve 属性为 "P-256"、"P-384" 或 "P-521"：
  
  令 data 为一个字节序列，其按照 [SEC1] 第 2.3.3 节中指定的编码规则并使用未压缩形式，表示由 key 的 [[handle]] 内部槽表示的椭圆曲线公钥。
  
  否则：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 的 [[algorithm]] 内部槽的 namedCurve 属性，并获得 namedCurve 和 data。
3. 令 result 为 data。
返回 result。

本节是非规范性的。

"Ed25519" 算法标识符用于使用 [RFC8032] 中指定的 Ed25519 算法执行签名和验证。

此算法的已识别算法名称为 "Ed25519"。

操作	参数	结果
sign	无	字节序列
verify	无	boolean
generateKey	无	`CryptoKeyPair`
importKey	无	`CryptoKey`
exportKey	无	object

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
令 result 为执行 [RFC8032] 第 5.1.6 节中指定的 Ed25519 签名过程所得的结果，其中 message 作为 M，并使用与 key 关联的 Ed25519 私钥。

问题 1

某些实现可能（希望）按照 draft-irtf-cfrg-det-sigs-with-noise 生成随机化签名，而不是按照 [RFC8032] 生成确定性签名。

参见 WICG/webcrypto-secure-curves 议题 28。
返回 result。

如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
如果 key 的密钥数据表示 Ed25519 椭圆曲线上的无效点或小阶元素，则返回 false。

问题 2

并非所有实现都会执行此检查。

参见 WICG/webcrypto-secure-curves 议题 27。
如果编码在 signature 前半部分中的点 R 表示 Ed25519 椭圆曲线上的无效点或小阶元素，则返回 false。

问题 3

并非所有实现都会执行此检查。

参见 WICG/webcrypto-secure-curves 议题 27。
执行 [RFC8032] 第 5.1.7 节中指定的 Ed25519 验证步骤，使用无余因子（非批处理）方程 [S]B = R + [k]A'，对 signature 进行验证，其中 message 作为 M，并使用与 key 关联的 Ed25519 公钥。
令 result 为一个 boolean；如果签名有效，则其值为 true，否则其值为 false。
返回 result。

如果 usages 包含不是 "sign" 或 "verify" 之一的值，则抛出一个 SyntaxError。
按 [RFC8032] 第 5.1.5 节中的定义生成一个 Ed25519 密钥对。
令 algorithm 为一个新的 KeyAlgorithm 对象。
将 algorithm 的 name 属性设置为 "Ed25519"。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为 usages 与 [ "verify" ] 的用法交集。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "sign" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 包含不是 "verify" 的值，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC8410] 中定义的 id-Ed25519 对象标识符，则抛出一个 DataError。
5. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 parameters 字段存在，则抛出一个 DataError。
6. 令 publicKey 为由 spki 的 subjectPublicKey 字段标识的 Ed25519 公钥。
7. 令 key 为一个新的 CryptoKey，它表示 publicKey。
8. 将 key 的 [[type]] 内部槽设置为 "public"
9. 令 algorithm 为一个新的 KeyAlgorithm。
10. 将 algorithm 的 name 属性设置为 "Ed25519"。
11. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "sign" 的值，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC8410] 中定义的 id-Ed25519 对象标识符，则抛出一个 DataError。
5. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段存在，则抛出一个 DataError。
6. 令 curvePrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段， structure 为 [RFC8410] 第 7 节中指定的 ASN.1 CurvePrivateKey 结构，并将 exactData 设置为 true。
7. 如果解析过程中发生错误，则抛出一个 DataError。
8. 令 key 为一个新的 CryptoKey，它表示由 curvePrivateKey 标识的 Ed25519 私钥。
9. 将 key 的 [[type]] 内部槽设置为 "private"
10. 令 algorithm 为一个新的 KeyAlgorithm。
11. 将 algorithm 的 name 属性设置为 "Ed25519"。
12. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 d 字段存在且 usages 包含不是 "sign" 的值，或者，如果 d 字段不存在且 usages 包含不是 "verify" 的值，则抛出一个 SyntaxError。
3. 如果 jwk 的 kty 字段不是 "OKP"，则抛出一个 DataError。
4. 如果 jwk 的 crv 字段不是 "Ed25519"，则抛出一个 DataError。
5. 如果 jwk 的 alg 字段存在，且不是 "Ed25519" 或 "EdDSA"，则抛出一个 DataError。
6. 如果 usages 非空，且 jwk 的 use 字段存在，且不是 "sig"，则抛出一个 DataError。
7. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
8. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
9. 如果 d 字段存在：
  
  如果 jwk 不满足 [RFC8037] 第 2 节中描述的 JWK 私钥格式要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 [RFC8037] 第 2 节解释 jwk 所标识的 Ed25519 私钥。
  
  将 Key 的 [[type]] 内部槽设置为 "private"。
  
  否则：
  
  如果 jwk 不满足 [RFC8037] 第 2 节中描述的 JWK 公钥格式要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 [RFC8037] 第 2 节解释 jwk 所标识的 Ed25519 公钥。
  
  将 Key 的 [[type]] 内部槽设置为 "public"。
10. 令 algorithm 为一个新的 KeyAlgorithm 对象实例。
11. 将 algorithm 的 name 属性设置为 "Ed25519"。
12. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "raw"：
1. 如果 usages 包含不是 "verify" 的值，则抛出一个 SyntaxError。
2. 令 algorithm 为一个新的 KeyAlgorithm 对象。
3. 将 algorithm 的 name 属性设置为 "Ed25519"。
4. 令 key 为一个新的 CryptoKey，表示 keyData 中提供的密钥数据。
5. 将 key 的 [[type]] 内部槽设置为 "public"
6. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
否则：

抛出一个 NotSupportedError。
返回 key

令 key 为要导出的 CryptoKey。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 对象标识符设置为 [RFC8410] 中定义的 id-Ed25519 OID。
  - 将 subjectPublicKey 字段设置为 keyData。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 对象标识符设置为 [RFC8410] 中定义的 id-Ed25519 OID。
  - 将 privateKey 字段设置为对 [RFC8410] 第 7 节中定义的 CurvePrivateKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 Ed25519 私钥
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为 "OKP"。
3. 将 jwk 的 alg 属性设置为 "Ed25519"。
4. 将 jwk 的 crv 属性设置为 "Ed25519"。
5. 按照 [RFC8037] 第 2 节中的定义，设置 jwk 的 x 属性。
6. 如果 key 的 [[type]] 内部槽为 "private"
  
  按照 [RFC8037] 第 2 节中的定义，设置 jwk 的 d 属性。
7. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
8. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
9. 令 result 为 jwk。
如果 format 为 "raw"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为表示 Ed25519 公钥的字节序列，该公钥由 key 的 [[handle]] 内部槽表示。
3. 令 result 为 data。
否则：

抛出一个 NotSupportedError。
返回 result。

本节是非规范性的。

"X25519" 算法标识符用于使用 [RFC7748] 中指定的 X25519 算法执行密钥协商。

此算法的已识别算法名称为 "X25519"。

操作	参数	结果
deriveBits	`EcdhKeyDeriveParams`	字节序列
generateKey	无	`CryptoKeyPair`
importKey	无	`CryptoKey`
exportKey	无	object

如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
令 publicKey 为 normalizedAlgorithm 的 public 成员。
如果 publicKey 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
如果 publicKey 的 [[algorithm]] 内部槽的 name 属性不等于 key 的 [[algorithm]] 内部槽的 name 属性，则抛出一个 InvalidAccessError。
令 secret 为执行 [RFC7748] 第 5 节中指定的 X25519 函数所得的结果，其中 key 作为 X25519 私钥 k，且由 publicKey 的 [[handle]] 内部槽表示的 X25519 公钥作为 X25519 公钥 u。
如果 secret 为全零值，则抛出一个 OperationError。按 [RFC7748] 第 6.1 节，此检查必须以常数时间执行。
如果 length 为 null：

返回 secret

否则：

如果 secret 的位长度小于 length：

抛出一个 OperationError。

否则：

返回一个包含 secret 的前 length 位的字节序列。

如果 usages 包含不是 "deriveKey" 或 "deriveBits" 的条目，则抛出一个 SyntaxError。
按 [RFC7748] 第 6.1 节中的定义生成一个 X25519 密钥对，其中私钥为 32 个随机字节，公钥为 X25519(a, 9)。
令 algorithm 为一个新的 KeyAlgorithm 对象。
将 algorithm 的 name 属性设置为 "X25519"。
令 publicKey 为一个新的 CryptoKey，表示所生成密钥对的公钥。
将 publicKey 的 [[type]] 内部槽设置为 "public"
将 publicKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 publicKey 的 [[extractable]] 内部槽设置为 true。
将 publicKey 的 [[usages]] 内部槽设置为空列表。
令 privateKey 为一个新的 CryptoKey，表示所生成密钥对的私钥。
将 privateKey 的 [[type]] 内部槽设置为 "private"
将 privateKey 的 [[algorithm]] 内部槽设置为 algorithm。
将 privateKey 的 [[extractable]] 内部槽设置为 extractable。
将 privateKey 的 [[usages]] 内部槽设置为 usages 与 [ "deriveKey", "deriveBits" ] 的用法交集。
令 result 为一个新的 CryptoKeyPair 字典。
将 result 的 publicKey 属性设置为 publicKey。
将 result 的 privateKey 属性设置为 privateKey。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "spki"：
1. 如果 usages 不是空的，则抛出一个 SyntaxError。
2. 令 spki 为对 keyData 运行解析 subjectPublicKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 algorithm 对象标识符字段不等于 [RFC8410] 中定义的 id-X25519 对象标识符，则抛出一个 DataError。
5. 如果 spki 的 algorithm AlgorithmIdentifier 字段的 parameters 字段存在，则抛出一个 DataError。
6. 令 publicKey 为由 spki 的 subjectPublicKey 字段标识的 X25519 公钥。
7. 令 key 为一个新的 CryptoKey，它表示 publicKey。
8. 将 key 的 [[type]] 内部槽设置为 "public"
9. 令 algorithm 为一个新的 KeyAlgorithm。
10. 将 algorithm 的 name 属性设置为 "X25519"。
11. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "pkcs8"：
1. 如果 usages 包含不是 "deriveKey" 或 "deriveBits" 的条目，则抛出一个 SyntaxError。
2. 令 privateKeyInfo 为对 keyData 运行解析 privateKeyInfo 算法所得的结果。
3. 如果解析过程中发生错误，则抛出一个 DataError。
4. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithm 字段的 algorithm 对象标识符字段不等于 [RFC8410] 中定义的 id-X25519 对象标识符，则抛出一个 DataError。
5. 如果 privateKeyInfo 的 privateKeyAlgorithm PrivateKeyAlgorithmIdentifier 字段的 parameters 字段存在，则抛出一个 DataError。
6. 令 curvePrivateKey 为执行解析 ASN.1 结构算法所得的结果，其中 data 为 privateKeyInfo 的 privateKey 字段， structure 为 [RFC8410] 第 7 节中指定的 ASN.1 CurvePrivateKey 结构，并将 exactData 设置为 true。
7. 如果解析过程中发生错误，则抛出一个 DataError。
8. 令 key 为一个新的 CryptoKey，它表示由 curvePrivateKey 标识的 X25519 私钥。
9. 将 key 的 [[type]] 内部槽设置为 "private"
10. 令 algorithm 为一个新的 KeyAlgorithm。
11. 将 algorithm 的 name 属性设置为 "X25519"。
12. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 d 字段存在，且 usages 包含不是 "deriveKey" 或 "deriveBits" 的条目，则抛出一个 SyntaxError。
3. 如果 d 字段不存在，且 usages 不是空的，则抛出一个 SyntaxError。
4. 如果 jwk 的 kty 字段不是 "OKP"，则抛出一个 DataError。
5. 如果 jwk 的 crv 字段不是 "X25519"，则抛出一个 DataError。
6. 如果 usages 非空，且 jwk 的 use 字段存在且不等于 "enc"，则抛出一个 DataError。
7. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
8. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
9. 如果 d 字段存在：
  
  如果 jwk 不满足 [RFC8037] 第 2 节中描述的 JWK 私钥格式要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 [RFC8037] 第 2 节解释 jwk 所标识的 X25519 私钥。
  
  将 Key 的 [[type]] 内部槽设置为 "private"。
  
  否则：
  
  如果 jwk 不满足 [RFC8037] 第 2 节中描述的 JWK 公钥格式要求，则抛出一个 DataError。
  
  令 key 为一个新的 CryptoKey 对象，它表示按照 [RFC8037] 第 2 节解释 jwk 所标识的 X25519 公钥。
  
  将 Key 的 [[type]] 内部槽设置为 "public"。
10. 令 algorithm 为一个新的 KeyAlgorithm 对象实例。
11. 将 algorithm 的 name 属性设置为 "X25519"。
12. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
如果 format 为 "raw"：
1. 如果 usages 不是空的，则抛出一个 SyntaxError。
2. 令 algorithm 为一个新的 KeyAlgorithm 对象。
3. 将 algorithm 的 name 属性设置为 "X25519"。
4. 令 key 为一个新的 CryptoKey，表示 keyData 中提供的密钥数据。
5. 将 key 的 [[type]] 内部槽设置为 "public"
6. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
否则：

抛出一个 NotSupportedError。
返回 key

令 key 为要导出的 CryptoKey。
如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "spki"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5280] 中定义的 SubjectPublicKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 algorithm 字段设置为具有以下属性的 AlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 对象标识符设置为 [RFC8410] 中定义的 id-X25519 OID。
  - 将 subjectPublicKey 字段设置为 keyData。
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "pkcs8"：
1. 如果 key 的 [[type]] 内部槽不是 "private"，则抛出一个 InvalidAccessError。
2. 令 data 为 [RFC5208] 中定义的 PrivateKeyInfo ASN.1 结构的一个实例，并具有以下属性：
  - 将 version 字段设置为 0。
  - 将 privateKeyAlgorithm 字段设置为具有以下属性的 PrivateKeyAlgorithmIdentifier ASN.1 类型：
    
    将 algorithm 对象标识符设置为 [RFC8410] 中定义的 id-X25519 OID。
  - 将 privateKey 字段设置为对 [RFC8410] 第 7 节中定义的 CurvePrivateKey ASN.1 类型进行 DER 编码所得的结果，该类型表示由 key 的 [[handle]] 内部槽表示的 X25519 私钥
3. 令 result 为对 data 进行 DER 编码所得的结果。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为 "OKP"。
3. 将 jwk 的 crv 属性设置为 "X25519"。
4. 按照 [RFC8037] 第 2 节中的定义，设置 jwk 的 x 属性。
5. 如果 key 的 [[type]] 内部槽为 "private"
  
  按照 [RFC8037] 第 2 节中的定义，设置 jwk 的 d 属性。
6. 将 jwk 的 key_ops 属性设置为 key 的 usages 属性。
7. 将 jwk 的 ext 属性设置为 key 的 [[extractable]] 内部槽。
8. 令 result 为 jwk。
如果 format 为 "raw"：
1. 如果 key 的 [[type]] 内部槽不是 "public"，则抛出一个 InvalidAccessError。
2. 令 data 为表示 X25519 公钥的字节序列，该公钥由 key 的 [[handle]] 内部槽表示。
3. 令 result 为 data。
否则：

抛出一个 NotSupportedError。
返回 result。

本节是非规范性的。

"AES-CTR" 算法标识符用于使用计数器模式下的 AES 执行加密和解密，如 [NIST-SP800-38A] 中所述。

此算法的已识别算法名称为 "AES-CTR"。

操作	参数	结果
encrypt	`AesCtrParams`	字节序列
decrypt	`AesCtrParams`	字节序列
generateKey	`AesKeyGenParams`	`CryptoKey`
importKey	无	`CryptoKey`
exportKey	无	object
get key length	`AesDerivedKeyParams`	Integer

WebIDLdictionary AesCtrParams : Algorithm {
  required BufferSource counter;
  required [EnforceRange] octet length;
};

counter 成员包含计数器块的初始值。 counter MUST 为 16 字节（AES 块大小）。计数器位是计数器块最右侧的 length 位。计数器块的其余部分用于 nonce。计数器位使用 NIST SP 800-38A 附录 B.1 中指定的标准递增函数来递增：计数器位被解释为一个大端整数，并加一。

length 成员包含计数器块中被递增的最右侧部分的长度（以位为单位）。

WebIDLdictionary AesKeyAlgorithm : KeyAlgorithm {
  required unsigned short length;
};

length 成员表示密钥的长度（以位为单位）。

WebIDLdictionary AesKeyGenParams : Algorithm {
  required [EnforceRange] unsigned short length;
};

length 成员表示密钥的长度（以位为单位）。

WebIDLdictionary AesDerivedKeyParams : Algorithm {
  required [EnforceRange] unsigned short length;
};

length 成员表示密钥的长度（以位为单位）。

如果 normalizedAlgorithm 的 counter 成员的长度不是 16 字节，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 length 成员为零或大于 128，则抛出一个 OperationError。
令 ciphertext 为执行 [NIST-SP800-38A] 第 6.5 节中描述的 CTR Encryption 操作所得的结果，其中使用 AES 作为分组密码，使用 normalizedAlgorithm 的 counter 成员作为计数器块的初始值，使用 normalizedAlgorithm 的 length 成员作为 [NIST-SP800-38A] 附录 B.1 中定义的标准计数器块递增函数的输入参数 m，并使用 plaintext 作为输入明文。
返回 ciphertext。

如果 normalizedAlgorithm 的 counter 成员的长度不是 16 字节，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 length 成员为零或大于 128，则抛出一个 OperationError。
令 plaintext 为执行 [NIST-SP800-38A] 第 6.5 节中描述的 CTR Decryption 操作所得的结果，其中使用 AES 作为分组密码，使用 normalizedAlgorithm 的 counter 成员作为计数器块的初始值，使用 normalizedAlgorithm 的 length 成员作为 [NIST-SP800-38A] 附录 B.1 中定义的标准计数器块递增函数的输入参数 m，并使用 ciphertext 作为输入密文。
返回 plaintext。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 之一的任何条目，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 length 成员不等于 128、192 或 256 之一，则抛出一个 OperationError。
生成一个长度等于 normalizedAlgorithm 的 length 成员的 AES 密钥。
如果密钥生成步骤失败，则抛出一个 OperationError。
令 key 为一个新的 CryptoKey 对象，表示所生成的 AES 密钥。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-CTR"。
将 algorithm 的 length 属性设置为等于 normalizedAlgorithm 的 length 成员。
将 key 的 [[type]] 内部槽设置为 "secret"。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
将 key 的 [[extractable]] 内部槽设置为 extractable。
将 key 的 [[usages]] 内部槽设置为 usages。
返回 key。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 之一的条目，则抛出一个 SyntaxError。
如果 format 为 "raw"：
1. 令 data 为 keyData。
2. 如果 data 的位长度不是 128、192 或 256，则抛出一个 DataError。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 kty 字段不是 "oct"，则抛出一个 DataError。
3. 如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.4 节的要求，则抛出一个 DataError。
4. 令 data 为通过解码 jwk 的 k 字段获得的字节序列。
5. 如果 data 的位长度为 128：
  
  如果 jwk 的 alg 字段存在，且不是 "A128CTR"，则抛出一个 DataError。
  
  如果 data 的位长度为 192：
  
  如果 jwk 的 alg 字段存在，且不是 "A192CTR"，则抛出一个 DataError。
  
  如果 data 的位长度为 256：
  
  如果 jwk 的 alg 字段存在，且不是 "A256CTR"，则抛出一个 DataError。
  
  否则：
  
  抛出一个 DataError。
6. 如果 usages 非空，且 jwk 的 use 字段存在，并且不是 "enc"，则抛出一个 DataError。
7. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
8. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
否则：

抛出一个 NotSupportedError。
令 key 为一个新的 CryptoKey 对象，表示值为 data 的 AES 密钥。
将 key 的 [[type]] 内部槽设置为 "secret"。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-CTR"。
将 algorithm 的 length 属性设置为 data 的长度（以位为单位）。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "raw"：
1. 令 data 为一个字节序列，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节。
2. 令 result 为 data。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "oct"。
3. 将 jwk 的 k 属性设置为一个字符串，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节，并按照 JSON Web Algorithms [JWA] 第 6.4 节进行编码。
4. 如果 key 的 length 属性为 128：
  
  将 jwk 的 alg 属性设置为字符串 "A128CTR"。
  
  如果 key 的 length 属性为 192：
  
  将 jwk 的 alg 属性设置为字符串 "A192CTR"。
  
  如果 key 的 length 属性为 256：
  
  将 jwk 的 alg 属性设置为字符串 "A256CTR"。
5. 将 jwk 的 key_ops 属性设置为等于 key 的 [[usages]] 内部槽。
6. 将 jwk 的 ext 属性设置为等于 key 的 [[extractable]] 内部槽。
7. 令 result 为 jwk。
否则：

抛出一个 NotSupportedError。
返回 result。

如果 normalizedDerivedKeyAlgorithm 的 length 成员不是 128、192 或 256，则抛出一个 OperationError。
返回 normalizedDerivedKeyAlgorithm 的 length 成员。

本节是非规范性的。

"AES-CBC" 算法标识符用于使用 Cipher Block Chaining 模式下的 AES 执行加密和解密，如 [NIST-SP800-38A] 中所述。

当以 CBC 模式运行时，不是 AES 块大小（16 字节）精确倍数的消息，可以在多种填充方案下进行填充。在 Web Crypto API 中，唯一受支持的填充模式是 PKCS#7，如 [RFC2315] 第 10.3 节第 2 步所述。

此算法的已识别算法名称为 "AES-CBC"。

操作	参数	结果
encrypt	`AesCbcParams`	字节序列
decrypt	`AesCbcParams`	字节序列
generateKey	`AesKeyGenParams`	`CryptoKey`
importKey	无	`CryptoKey`
exportKey	无	object
get key length	`AesDerivedKeyParams`	Integer

WebIDLdictionary AesCbcParams : Algorithm {
  required BufferSource iv;
};

iv 成员表示初始化向量。它MUST为 16 字节。

如果 normalizedAlgorithm 的 iv 成员的长度不是 16 字节，则抛出一个 OperationError。
令 paddedPlaintext 为按照 [RFC2315] 第 10.3 节第 2 步中定义的过程，使用 k 的值为 16，向 plaintext 添加填充八位字节所得的结果。
令 ciphertext 为执行 [NIST-SP800-38A] 第 6.2 节中描述的 CBC Encryption 操作所得的结果，其中使用 AES 作为分组密码，使用 normalizedAlgorithm 的 iv 成员作为 IV 输入参数，并使用 paddedPlaintext 作为输入明文。
返回 ciphertext。

如果 normalizedAlgorithm 的 iv 成员的长度不是 16 字节，则抛出一个 OperationError。
如果 ciphertext 的长度为零，或不是 16 字节的倍数，则抛出一个 OperationError。
令 paddedPlaintext 为执行 [NIST-SP800-38A] 第 6.2 节中描述的 CBC Decryption 操作所得的结果，其中使用 AES 作为分组密码，使用 normalizedAlgorithm 的 iv 成员作为 IV 输入参数，并使用 ciphertext 作为输入密文。
令 p 为 paddedPlaintext 最后一个八位字节的值。
如果 p 为零或大于 16，或者 paddedPlaintext 的最后 p 个八位字节中的任何一个的值不是 p，则抛出一个 OperationError。
令 plaintext 为从 paddedPlaintext 末尾移除 p 个八位字节所得的结果。
返回 plaintext。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 之一的任何条目，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 length 成员不等于 128、192 或 256 之一，则抛出一个 OperationError。
生成一个长度等于 normalizedAlgorithm 的 length 成员的 AES 密钥。
如果密钥生成步骤失败，则抛出一个 OperationError。
令 key 为一个新的 CryptoKey 对象，表示所生成的 AES 密钥。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-CBC"。
将 algorithm 的 length 属性设置为等于 normalizedAlgorithm 的 length 成员。
将 key 的 [[type]] 内部槽设置为 "secret"。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
将 key 的 [[extractable]] 内部槽设置为 extractable。
将 key 的 [[usages]] 内部槽设置为 usages。
返回 key。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 之一的条目，则抛出一个 SyntaxError。
如果 format 为 "raw"：
1. 令 data 为 keyData。
2. 如果 data 的位长度不是 128、192 或 256，则抛出一个 DataError。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 kty 字段不是 "oct"，则抛出一个 DataError。
3. 如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.4 节的要求，则抛出一个 DataError。
4. 令 data 为通过解码 jwk 的 k 字段获得的字节序列。
5. 如果 data 的位长度为 128：
  
  如果 jwk 的 alg 字段存在，且不是 "A128CBC"，则抛出一个 DataError。
  
  如果 data 的位长度为 192：
  
  如果 jwk 的 alg 字段存在，且不是 "A192CBC"，则抛出一个 DataError。
  
  如果 data 的位长度为 256：
  
  如果 jwk 的 alg 字段存在，且不是 "A256CBC"，则抛出一个 DataError。
  
  否则：
  
  抛出一个 DataError。
6. 如果 usages 非空，且 jwk 的 use 字段存在，并且不是 "enc"，则抛出一个 DataError。
7. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
8. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
否则：

抛出一个 NotSupportedError
令 key 为一个新的 CryptoKey 对象，表示值为 data 的 AES 密钥。
将 key 的 [[type]] 内部槽设置为 "secret"。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-CBC"。
将 algorithm 的 length 属性设置为 data 的长度（以位为单位）。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "raw"：
1. 令 data 为一个字节序列，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节。
2. 令 result 为 data。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "oct"。
3. 将 jwk 的 k 属性设置为一个字符串，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节，并按照 JSON Web Algorithms [JWA] 第 6.4 节进行编码。
4. 如果 key 的 length 属性为 128：
  
  将 jwk 的 alg 属性设置为字符串 "A128CBC"。
  
  如果 key 的 length 属性为 192：
  
  将 jwk 的 alg 属性设置为字符串 "A192CBC"。
  
  如果 key 的 length 属性为 256：
  
  将 jwk 的 alg 属性设置为字符串 "A256CBC"。
5. 将 jwk 的 key_ops 属性设置为等于 key 的 usages 属性。
6. 将 jwk 的 ext 属性设置为等于 key 的 [[extractable]] 内部槽。
7. 令 result 为 jwk。
否则：

抛出一个 NotSupportedError。
返回 result。

如果 normalizedDerivedKeyAlgorithm 的 length 成员不是 128、192 或 256，则抛出一个 OperationError。
返回 normalizedDerivedKeyAlgorithm 的 length 成员。

本节是非规范性的。

"AES-GCM" 算法标识符用于使用 Galois/Counter Mode 模式下的 AES 执行认证加密和解密，如 [NIST-SP800-38D] 中所述。

此算法的已识别算法名称为 "AES-GCM"。

操作	参数	结果
encrypt	`AesGcmParams`	字节序列
decrypt	`AesGcmParams`	字节序列
generateKey	`AesKeyGenParams`	`CryptoKey`
importKey	无	`CryptoKey`
exportKey	无	object
get key length	`AesDerivedKeyParams`	Integer

WebIDLdictionary AesGcmParams : Algorithm {
  required BufferSource iv;
  BufferSource additionalData;
  [EnforceRange] octet tagLength;
};

iv 成员表示要使用的初始化向量。最长可以为 2^64-1 字节。

additionalData 成员表示要包含的额外认证数据。

tagLength 成员表示所需的认证标签长度。可以为 0 - 128。

如果 plaintext 的长度大于 2^39 - 256 字节，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 iv 成员的长度大于 2^64 - 1 字节，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 additionalData 成员存在且其长度大于 2^64 - 1 字节，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 tagLength 成员不存在：

令 tagLength 为 128。

如果 normalizedAlgorithm 的 tagLength 成员是 32、64、96、104、112、120 或 128 之一：

令 tagLength 等于 normalizedAlgorithm 的 tagLength 成员

否则：

抛出一个 OperationError。
令 additionalData 为 normalizedAlgorithm 的 additionalData 成员（如果存在），否则为空字节序列。
令 C 和 T 为执行 [NIST-SP800-38D] 第 7.1 节中描述的 Authenticated Encryption Function 所得到的输出，其中使用 AES 作为分组密码，使用 normalizedAlgorithm 的 iv 成员作为 IV 输入参数， additionalData 作为 A 输入参数， tagLength 作为 t 前提条件，并使用 plaintext 作为输入明文。
令 ciphertext 等于 C | T，其中 “|” 表示连接。
返回 ciphertext。

如果 normalizedAlgorithm 的 tagLength 成员不存在：

令 tagLength 为 128。

如果 normalizedAlgorithm 的 tagLength 成员是 32、64、96、104、112、120 或 128 之一：

令 tagLength 等于 normalizedAlgorithm 的 tagLength 成员

否则：

抛出一个 OperationError。
如果 ciphertext 的位长度小于 tagLength，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 iv 成员的长度大于 2^64 - 1 字节，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 additionalData 成员存在且其长度大于 2^64 - 1 字节，则抛出一个 OperationError。
令 tag 为 ciphertext 的最后 tagLength 位。
令 actualCiphertext 为从 ciphertext 中移除最后 tagLength 位所得的结果。
令 additionalData 为 normalizedAlgorithm 的 additionalData 成员（如果存在），否则为空字节序列。
执行 [NIST-SP800-38D] 第 7.2 节中描述的 Authenticated Decryption Function，其中使用 AES 作为分组密码，使用 normalizedAlgorithm 的 iv 成员作为 IV 输入参数， additionalData 作为 A 输入参数， tagLength 作为 t 前提条件， actualCiphertext 作为输入密文，C，并以 tag 作为认证标签 T。

如果算法的结果是不真实性指示 "FAIL"：

抛出一个 OperationError

否则：

令 plaintext 为 Authenticated Decryption Function 的输出 P。
返回 plaintext。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 之一的任何条目，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 length 成员不等于 128、192 或 256 之一，则抛出一个 OperationError。
生成一个长度等于 normalizedAlgorithm 的 length 成员的 AES 密钥。
如果密钥生成步骤失败，则抛出一个 OperationError。
令 key 为一个新的 CryptoKey 对象，表示所生成的 AES 密钥。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-GCM"。
将 algorithm 的 length 属性设置为等于 normalizedAlgorithm 的 length 成员。
将 key 的 [[type]] 内部槽设置为 "secret"。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
将 key 的 [[extractable]] 内部槽设置为 extractable。
将 key 的 [[usages]] 内部槽设置为 usages。
返回 key。

如果 usages 包含不是 "encrypt"、"decrypt"、 "wrapKey" 或 "unwrapKey" 之一的条目，则抛出一个 SyntaxError。
如果 format 为 "raw"：
1. 令 data 为 keyData。
2. 如果 data 的位长度不是 128、192 或 256，则抛出一个 DataError。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 kty 字段不是 "oct"，则抛出一个 DataError。
3. 如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.4 节的要求，则抛出一个 DataError。
4. 令 data 为通过解码 jwk 的 k 字段获得的字节序列。
5. 如果 data 的位长度为 128：
  
  如果 jwk 的 alg 字段存在，且不是 "A128GCM"，则抛出一个 DataError。
  
  如果 data 的位长度为 192：
  
  如果 jwk 的 alg 字段存在，且不是 "A192GCM"，则抛出一个 DataError。
  
  如果 data 的位长度为 256：
  
  如果 jwk 的 alg 字段存在，且不是 "A256GCM"，则抛出一个 DataError。
  
  否则：
  
  抛出一个 DataError。
6. 如果 usages 非空，且 jwk 的 use 字段存在，并且不是 "enc"，则抛出一个 DataError。
7. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
8. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
否则：

抛出一个 NotSupportedError。
令 key 为一个新的 CryptoKey 对象，表示值为 data 的 AES 密钥。
将 key 的 [[type]] 内部槽设置为 "secret"。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-GCM"。
将 algorithm 的 length 属性设置为 data 的长度（以位为单位）。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "raw"：
1. 令 data 为一个字节序列，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节。
2. 令 result 为 data。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "oct"。
3. 将 jwk 的 k 属性设置为一个字符串，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节，并按照 JSON Web Algorithms [JWA] 第 6.4 节进行编码。
4. 如果 key 的 length 属性为 128：
  
  将 jwk 的 alg 属性设置为字符串 "A128GCM"。
  
  如果 key 的 length 属性为 192：
  
  将 jwk 的 alg 属性设置为字符串 "A192GCM"。
  
  如果 key 的 length 属性为 256：
  
  将 jwk 的 alg 属性设置为字符串 "A256GCM"。
5. 将 jwk 的 key_ops 属性设置为等于 key 的 usages 属性。
6. 将 jwk 的 ext 属性设置为等于 key 的 [[extractable]] 内部槽。
7. 令 result 为 jwk。
否则：

抛出一个 NotSupportedError。
返回 result。

如果 normalizedDerivedKeyAlgorithm 的 length 成员不是 128、192 或 256，则抛出一个 OperationError。
返回 normalizedDerivedKeyAlgorithm 的 length 成员。

本节是非规范性的。

"AES-KW" 算法标识符用于使用 AES 执行密钥包装，如 [RFC3394] 中所述。

此算法的已识别算法名称为 "AES-KW"。

操作	参数	结果
wrapKey	无	字节序列
unwrapKey	无	字节序列
generateKey	`AesKeyGenParams`	`CryptoKey`
importKey	无	`CryptoKey`
exportKey	无	object
get key length	`AesDerivedKeyParams`	Integer

如果 plaintext 的长度不是 64 位的倍数，则抛出一个 OperationError。
令 ciphertext 为执行 [RFC3394] 第 2.2.1 节中描述的密钥包装操作所得的结果，其中 plaintext 作为要被包装的明文，并使用同一文档第 2.2.3.1 节中定义的默认初始值。
返回 ciphertext。

令 plaintext 为执行 [RFC3394] 第 2.2.2 节中描述的密钥解包操作所得的结果，其中 ciphertext 作为输入密文，并使用同一文档第 2.2.3.1 节中定义的默认初始值。
如果密钥解包操作返回错误，则抛出一个 OperationError。
返回 plaintext。

如果 usages 包含不是 "wrapKey" 或 "unwrapKey" 之一的任何条目，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 length 属性不等于 128、192 或 256 之一，则抛出一个 OperationError。
生成一个长度等于 normalizedAlgorithm 的 length 成员的 AES 密钥。
如果密钥生成步骤失败，则抛出一个 OperationError。
令 key 为一个新的 CryptoKey 对象，表示所生成的 AES 密钥。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-KW"。
将 algorithm 的 length 属性设置为等于 normalizedAlgorithm 的 length 属性。
将 key 的 [[type]] 内部槽设置为 "secret"。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
将 key 的 [[extractable]] 内部槽设置为 extractable。
将 key 的 [[usages]] 内部槽设置为 usages。
返回 key。

如果 usages 包含不是 "wrapKey" 或 "unwrapKey" 之一的条目，则抛出一个 SyntaxError。
如果 format 为 "raw"：
1. 令 data 为 keyData。
2. 如果 data 的位长度不是 128、192 或 256，则抛出一个 DataError。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 kty 字段不是 "oct"，则抛出一个 DataError。
3. 如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.4 节的要求，则抛出一个 DataError。
4. 令 data 为通过解码 jwk 的 k 字段获得的字节序列。
5. 如果 data 的位长度为 128：
  
  如果 jwk 的 alg 字段存在，且不是 "A128KW"，则抛出一个 DataError。
  
  如果 data 的位长度为 192：
  
  如果 jwk 的 alg 字段存在，且不是 "A192KW"，则抛出一个 DataError。
  
  如果 data 的位长度为 256：
  
  如果 jwk 的 alg 字段存在，且不是 "A256KW"，则抛出一个 DataError。
  
  否则：
  
  抛出一个 DataError。
6. 如果 usages 非空，且 jwk 的 use 字段存在，并且不是 "enc"，则抛出一个 DataError。
7. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
8. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
否则：

抛出一个 NotSupportedError。
令 key 为一个新的 CryptoKey，它表示值为 data 的 AES 密钥。
将 key 的 [[type]] 内部槽设置为 "secret"。
令 algorithm 为一个新的 AesKeyAlgorithm。
将 algorithm 的 name 属性设置为 "AES-KW"。
将 algorithm 的 length 属性设置为 data 的长度（以位为单位）。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
如果 format 为 "raw"：
1. 令 data 为一个字节序列，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节。
2. 令 result 为 data。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "oct"。
3. 将 jwk 的 k 属性设置为一个字符串，其中包含由 key 的 [[handle]] 内部槽表示的密钥的原始八位字节，并按照 JSON Web Algorithms [JWA] 第 6.4 节进行编码。
4. 如果 key 的 length 属性为 128：
  
  将 jwk 的 alg 属性设置为字符串 "A128KW"。
  
  如果 key 的 length 属性为 192：
  
  将 jwk 的 alg 属性设置为字符串 "A192KW"。
  
  如果 key 的 length 属性为 256：
  
  将 jwk 的 alg 属性设置为字符串 "A256KW"。
5. 将 jwk 的 key_ops 属性设置为等于 key 的 usages 属性。
6. 将 jwk 的 ext 属性设置为等于 key 的 [[extractable]] 内部槽。
7. 令 result 为 jwk。
否则：

抛出一个 NotSupportedError。
返回 result。

如果 normalizedDerivedKeyAlgorithm 的 length 成员不是 128、192 或 256，则抛出一个 OperationError。
返回 normalizedDerivedKeyAlgorithm 的 length 成员。

本节是非规范性的。

HMAC 算法根据 [FIPS-198-1] 使用本规范中定义的 SHA 哈希函数，计算和验证基于哈希的消息认证码。

其他规范可以指定 HMAC 对其他哈希算法的使用。此类规范必须为额外的哈希算法定义摘要操作，并为 HMAC 定义密钥导入步骤和密钥导出步骤。

此算法的已识别算法名称为 "HMAC"。

操作	参数	结果
sign	无	字节序列
verify	无	boolean
generateKey	`HmacKeyGenParams`	`CryptoKey`
importKey	`HmacImportParams`	`CryptoKey`
exportKey	无	object
get key length	`HmacImportParams`	Integer

WebIDLdictionary HmacImportParams : Algorithm {
  required HashAlgorithmIdentifier hash;
  [EnforceRange] unsigned long length;
};

hash 成员表示要使用的内部哈希函数。

length 成员表示密钥的长度（以位为单位）。

WebIDLdictionary HmacKeyAlgorithm : KeyAlgorithm {
  required KeyAlgorithm hash;
  required unsigned long length;
};

hash 成员表示要使用的内部哈希函数。

length 成员表示密钥的长度（以位为单位）。

WebIDLdictionary HmacKeyGenParams : Algorithm {
  required HashAlgorithmIdentifier hash;
  [EnforceRange] unsigned long length;
};

hash 成员表示要使用的内部哈希函数。

length 成员表示要生成的密钥的长度（以位为单位）。如果未指定，则将使用推荐长度，即相关哈希函数的块大小。

令 mac 为执行 [FIPS-198-1] 第 4 节中描述的 MAC Generation 操作所得的结果，其中使用由 key 的 [[handle]] 内部槽表示的密钥、由 key 的 [[algorithm]] 内部槽的 hash 属性所标识的哈希函数，并以 message 作为输入数据 text。
返回 mac。

令 mac 为执行 [FIPS-198-1] 第 4 节中描述的 MAC Generation 操作所得的结果，其中使用由 key 的 [[handle]] 内部槽表示的密钥、由 key 的 [[algorithm]] 内部槽的 hash 属性所标识的哈希函数，并以 message 作为输入数据 text。
如果 mac 等于 signature，则返回 true；否则返回 false。

如果 usages 包含不是 "sign" 或 "verify" 的任何条目，则抛出一个 SyntaxError。
如果 normalizedAlgorithm 的 length 成员不存在：

令 length 为 normalizedAlgorithm 的 hash 成员所标识的哈希函数的块大小（以位为单位）。

否则，如果 normalizedAlgorithm 的 length 成员非零：

令 length 等于 normalizedAlgorithm 的 length 成员。

否则：

抛出一个 OperationError。
生成一个长度为 length 位的密钥。
如果密钥生成步骤失败，则抛出一个 OperationError。
令 key 为一个新的 CryptoKey 对象，表示生成的密钥。
令 algorithm 为一个新的 HmacKeyAlgorithm。
将 algorithm 的 name 属性设置为 "HMAC"。
将 algorithm 的 length 属性设置为 length。
令 hash 为一个新的 KeyAlgorithm。
将 hash 的 name 属性设置为等于 normalizedAlgorithm 的 hash 成员的 name 成员。
将 algorithm 的 hash 属性设置为 hash。
将 key 的 [[type]] 内部槽设置为 "secret"。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
将 key 的 [[extractable]] 内部槽设置为 extractable。
将 key 的 [[usages]] 内部槽设置为 usages。
返回 key。

令 keyData 为要导入的密钥数据。
如果 usages 包含不是 "sign" 或 "verify" 的条目，则抛出一个 SyntaxError。
令 hash 为一个新的 KeyAlgorithm。
如果 format 为 "raw"：
1. 令 data 为 keyData。
2. 将 hash 设置为等于 normalizedAlgorithm 的 hash 成员。
如果 format 为 "jwk"：
1. 如果 keyData 是一个 JsonWebKey 字典：
  
  令 jwk 等于 keyData。
  
  否则：
  
  抛出一个 DataError。
2. 如果 jwk 的 kty 字段不是 "oct"，则抛出一个 DataError。
3. 如果 jwk 不满足 JSON Web Algorithms [JWA] 第 6.4 节的要求，则抛出一个 DataError。
4. 令 data 为通过解码 jwk 的 k 字段获得的字节序列。
5. 将 hash 设置为等于 normalizedAlgorithm 的 hash 成员。
6. 如果 hash 的 name 属性为 "SHA-1"：
  
  如果 jwk 的 alg 字段存在，且不是 "HS1"，则抛出一个 DataError。
  
  如果 hash 的 name 属性为 "SHA-256"：
  
  如果 jwk 的 alg 字段存在，且不是 "HS256"，则抛出一个 DataError。
  
  如果 hash 的 name 属性为 "SHA-384"：
  
  如果 jwk 的 alg 字段存在，且不是 "HS384"，则抛出一个 DataError。
  
  如果 hash 的 name 属性为 "SHA-512"：
  
  如果 jwk 的 alg 字段存在，且不是 "HS512"，则抛出一个 DataError。
  
  否则，如果 hash 的 name 属性在另一个适用规范中定义：
  
  执行由其他适用规范定义的任何密钥导入步骤，传入 format、jwk 和 hash 并获得 hash。
7. 如果 usages 非空，且 jwk 的 use 字段存在，并且不是 "sign"，则抛出一个 DataError。
8. 如果 jwk 的 key_ops 字段存在，且根据 JSON Web Key [JWK] 的要求无效，或者不包含所有指定的 usages 值，则抛出一个 DataError。
9. 如果 jwk 的 ext 字段存在且值为 false，并且 extractable 为 true，则抛出一个 DataError。
否则：

抛出一个 NotSupportedError。
令 length 为 data 的位长度。
如果 length 为零，则抛出一个 DataError。
如果 normalizedAlgorithm 的 length 成员存在：

如果 normalizedAlgorithm 的 length 成员大于 length：

抛出一个 DataError。

如果 normalizedAlgorithm 的 length 成员小于或等于 length 减八：

抛出一个 DataError。

否则：

将 length 设置为等于 normalizedAlgorithm 的 length 成员。
令 key 为一个新的 CryptoKey 对象，它表示使用 data 的前 length 位的 HMAC 密钥。
将 key 的 [[type]] 内部槽设置为 "secret"。
令 algorithm 为一个新的 HmacKeyAlgorithm。
将 algorithm 的 name 属性设置为 "HMAC"。
将 algorithm 的 length 属性设置为 length。
将 algorithm 的 hash 属性设置为 hash。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

如果无法访问由 key 的 [[handle]] 内部槽表示的底层加密密钥材料，则抛出一个 OperationError。
令 bits 为由 key 的 [[handle]] 内部槽表示的密钥的原始位。
令 data 为一个包含 bits 的字节序列。
如果 format 为 "raw"：
1. 令 result 为 data。
如果 format 为 "jwk"：
1. 令 jwk 为一个新的 JsonWebKey 字典。
2. 将 jwk 的 kty 属性设置为字符串 "oct"。
3. 将 jwk 的 k 属性设置为一个字符串，其中包含 data，并按照 JSON Web Algorithms [JWA] 第 6.4 节进行编码。
4. 令 algorithm 为 key 的 [[algorithm]] 内部槽。
5. 令 hash 为 algorithm 的 hash 属性。
6. 如果 hash 的 name 属性为 "SHA-1"：
  
  将 jwk 的 alg 属性设置为字符串 "HS1"。
  
  如果 hash 的 name 属性为 "SHA-256"：
  
  将 jwk 的 alg 属性设置为字符串 "HS256"。
  
  如果 hash 的 name 属性为 "SHA-384"：
  
  将 jwk 的 alg 属性设置为字符串 "HS384"。
  
  如果 hash 的 name 属性为 "SHA-512"：
  
  将 jwk 的 alg 属性设置为字符串 "HS512"。
  
  否则，hash 的 name 属性在另一个适用规范中定义：
  
  执行由其他适用规范定义的任何密钥导出步骤，传入 format 和 key 并获得 alg。
  
  将 jwk 的 alg 属性设置为 alg。
7. 将 jwk 的 key_ops 属性设置为等于 key 的 usages 属性。
8. 将 jwk 的 ext 属性设置为等于 key 的 [[extractable]] 内部槽。
9. 令 result 为 jwk。
否则：

抛出一个 NotSupportedError。
返回 result。

如果 normalizedDerivedKeyAlgorithm 的 length 成员不存在：

令 length 为 normalizedDerivedKeyAlgorithm 的 hash 成员所标识的哈希函数的块大小（以位为单位）。

否则，如果 normalizedDerivedKeyAlgorithm 的 length 成员非零：

令 length 等于 normalizedDerivedKeyAlgorithm 的 length 成员。

否则：

抛出一个 TypeError。
返回 length。

本节是非规范性的。

这里描述 SHA-1 和 SHA-2 族，如 [FIPS-180-4] 所指定。

相应 SHA 算法的已识别算法名称是 "SHA-1"、 "SHA-256"、 "SHA-384" 和 "SHA-512"。

操作	参数	结果
digest	无	字节序列

如果 normalizedAlgorithm 的 name 成员区分大小写地字符串匹配 "SHA-1"：

令 result 为执行 [FIPS-180-4] 第 6.1 节中定义的 SHA-1 哈希函数所得的结果，其中 message 作为输入消息 M。

如果 normalizedAlgorithm 的 name 成员区分大小写地字符串匹配 "SHA-256"：

令 result 为执行 [FIPS-180-4] 第 6.2 节中定义的 SHA-256 哈希函数所得的结果，其中 message 作为输入消息 M。

如果 normalizedAlgorithm 的 name 成员区分大小写地字符串匹配 "SHA-384"：

令 result 为执行 [FIPS-180-4] 第 6.5 节中定义的 SHA-384 哈希函数所得的结果，其中 message 作为输入消息 M。

如果 normalizedAlgorithm 的 name 成员区分大小写地字符串匹配 "SHA-512"：

令 result 为执行 [FIPS-180-4] 第 6.4 节中定义的 SHA-512 哈希函数所得的结果，其中 message 作为输入消息 M。
如果执行操作导致错误，则抛出一个 OperationError。
返回 result。

本节是非规范性的。

"HKDF" 算法标识符用于使用 [RFC5869] 中描述的先提取后扩展方法执行密钥派生，并使用本规范中定义的 SHA 哈希函数。

其他规范可以指定 HKDF 对其他哈希算法的使用。此类规范必须为额外的哈希算法定义摘要操作。

此算法的已识别算法名称为 "HKDF"。

操作	参数	结果
deriveBits	`HkdfParams`	字节序列
importKey	无	`CryptoKey`
Get key length	无	null

WebIDLdictionary HkdfParams : Algorithm {
  required HashAlgorithmIdentifier hash;
  required BufferSource salt;
  required BufferSource info;
};

hash 成员表示要与 HMAC 一起使用的算法（例如：SHA-256）。

salt 成员表示提取步骤中使用的盐。

info 成员表示派生密钥材料的应用特定上下文。

如果 length 为 null 或不是 8 的倍数，则抛出一个 OperationError。
令 keyDerivationKey 为由 key 的 [[handle]] 内部槽表示的秘密值。
令 result 为执行 [RFC5869] 第 2 节中描述的 HKDF 提取步骤然后执行 HKDF 扩展步骤所得的结果，使用：
- normalizedAlgorithm 的 hash 成员作为 Hash，
- keyDerivationKey 作为输入密钥材料， IKM，
- normalizedAlgorithm 的 salt 成员作为 salt，
- normalizedAlgorithm 的 info 成员作为 info，
- length 除以 8 作为 L 的值，
如果密钥派生操作失败，则抛出一个 OperationError。
返回 result。

令 keyData 为要导入的密钥数据。
如果 format 为 "raw"：
1. 如果 usages 包含不是 "deriveKey" 或 "deriveBits" 的值，则抛出一个 SyntaxError。
2. 如果 extractable 不是 false，则抛出一个 SyntaxError。
3. 令 key 为一个新的 CryptoKey，表示 keyData 中提供的密钥数据。
4. 将 key 的 [[type]] 内部槽设置为 "secret"。
5. 令 algorithm 为一个新的 KeyAlgorithm 对象。
6. 将 algorithm 的 name 属性设置为 "HKDF"。
7. 将 key 的 [[algorithm]] 内部槽设置为 algorithm。
8. 返回 key。
否则：

抛出一个 NotSupportedError。

返回 null。

本节是非规范性的。

"PBKDF2" 算法标识符用于使用 [RFC8018] 中定义的 PKCS#5 基于口令的密钥派生函数版本 2 执行密钥派生，其中使用 HMAC 作为伪随机函数，并使用本规范中定义的 SHA 哈希函数。

其他规范可以指定 PBKDF2 对其他哈希算法的使用。此类规范必须为额外的哈希算法定义摘要操作。

此算法的已识别算法名称为 "PBKDF2"。

操作	参数	结果
deriveBits	`Pbkdf2Params`	字节序列
importKey	无	`CryptoKey`
Get key length	无	null

WebIDLdictionary Pbkdf2Params : Algorithm {
  required BufferSource salt;
  required [EnforceRange] unsigned long iterations;
  required HashAlgorithmIdentifier hash;
};

Pbkdf2Params 字典具有一个 salt 成员、一个 iterations 成员，以及一个 hash 成员。

如果 length 为 null 或不是 8 的倍数，则抛出一个 OperationError。
如果 normalizedAlgorithm 的 iterations 成员为零，则抛出一个 OperationError。
如果 length 为零，则返回一个空字节序列。
令 prf 为 [FIPS-198-1] 第 4 节中描述的 MAC Generation 函数，它使用由 normalizedAlgorithm 的 hash 成员描述的哈希函数。
令 result 为执行 [RFC8018] 第 5.2 节中定义的 PBKDF2 操作所得的结果，其中使用 prf 作为伪随机函数 PRF，由 key 的 [[handle]] 内部槽表示的口令作为口令 P， normalizedAlgorithm 的 salt 属性作为盐 S， normalizedAlgorithm 的 iterations 属性的值作为迭代次数 c，并将 length 除以 8 作为预期密钥长度 dkLen。
如果密钥派生操作失败，则抛出一个 OperationError。
返回 result。

如果 format 不是 "raw"，则抛出一个 NotSupportedError
如果 usages 包含不是 "deriveKey" 或 "deriveBits" 的值，则抛出一个 SyntaxError。
如果 extractable 不是 false，则抛出一个 SyntaxError。
令 key 为一个新的 CryptoKey，表示 keyData。
将 key 的 [[type]] 内部槽设置为 "secret"。
令 algorithm 为一个新的 KeyAlgorithm 对象。
将 algorithm 的 name 属性设置为 "PBKDF2"。
将 key 的 [[algorithm]] 内部槽设置为 algorithm。
返回 key。

返回 null。

此示例生成两个 X25519 密钥对，一个用于 Alice，一个用于 Bob，在二者之间执行密钥协商，使用带 SHA-256 的 HKDF 从结果中派生一个 256 位 AES-GCM 密钥，并用它加密和解密一些数据。

示例 1：X25519 密钥协商

// 为 Alice 生成密钥对。
const alice_x25519_key = await crypto.subtle.generateKey('X25519', false /* extractable */, ['deriveKey']);
const alice_private_key = alice_x25519_key.privateKey;

// 通常，公钥会由 Bob 提前通过某个已认证通道发送给 Alice。
// 在此示例中，我们将生成另一个密钥对，并改用其公钥。
const bob_x25519_key = await crypto.subtle.generateKey('X25519', false /* extractable */, ['deriveKey']);
const bob_public_key = bob_x25519_key.publicKey;

// 执行密钥协商。
const alice_x25519_params = { name: 'X25519', public: bob_public_key };
const alice_shared_key = await crypto.subtle.deriveKey(alice_x25519_params, alice_private_key, 'HKDF', false /* extractable */, ['deriveKey']);

// 从结果派生一个对称密钥。
const salt = crypto.getRandomValues(new Uint8Array(32));
const info = new TextEncoder().encode('X25519 key agreement for an AES-GCM-256 key');
const hkdf_params = { name: 'HKDF', hash: 'SHA-256', salt, info };
const gcm_params = { name: 'AES-GCM', length: 256 };
const alice_symmetric_key = await crypto.subtle.deriveKey(hkdf_params, alice_shared_key, gcm_params, false /* extractable */, ['encrypt', 'decrypt']);

// 用对称密钥加密一些数据，并发送给 Bob。IV 也必须一并传递。
const iv = crypto.getRandomValues(new Uint8Array(12));
const message = new TextEncoder().encode('Hi Bob!');
const encrypted = await crypto.subtle.encrypt({ ...gcm_params, iv }, alice_symmetric_key, message);

// 在 Bob 一侧，改用 Alice 的公钥和 Bob 的私钥。
// 为获得相同结果，Alice 和 Bob 必须约定使用相同的 salt 和 info。
const alice_public_key = alice_x25519_key.publicKey;
const bob_private_key = bob_x25519_key.privateKey;
const bob_x25519_params = { name: 'X25519', public: alice_public_key };
const bob_shared_key = await crypto.subtle.deriveKey(bob_x25519_params, bob_private_key, 'HKDF', false /* extractable */, ['deriveKey']);
const bob_symmetric_key = await crypto.subtle.deriveKey(hkdf_params, bob_shared_key, gcm_params, false /* extractable */, ['encrypt', 'decrypt']);

// 在 Bob 一侧，可以解密数据。
const decrypted = await crypto.subtle.decrypt({ ...gcm_params, iv }, bob_symmetric_key, encrypted);
const decrypted_message = new TextDecoder().decode(decrypted);

示例 2：Ed25519 签名

const data = new TextEncoder().encode('Hello, world!');
const key = await crypto.subtle.generateKey('Ed25519', false, ['sign']);
const signature = await crypto.subtle.sign('Ed25519', key.privateKey, data);

示例 3：AES-GCM 加密

const data = new TextEncoder().encode('Hello, world!');
const aesAlgorithmKeyGen = {
  name: 'AES-GCM',
  // AesKeyGenParams
  length: 256
};
const aesAlgorithmEncrypt = {
  name: 'AES-GCM',
  // AesGcmParams
  iv: crypto.getRandomValues(new Uint8Array(16))
};
const key = await crypto.subtle.generateKey(aesAlgorithmKeyGen, false, ['encrypt']);
const encrypted = await crypto.subtle.encrypt(aesAlgorithmEncrypt, key, data);

示例 4：随机 UUID 生成

const filename = `${crypto.randomUUID()}.txt`;

本节在 IANA JSON Web Signature and Encryption Algorithms Registry 中注册以下算法标识符，以便与 JSON Web Key 一起使用。注意，模板中的 'Implementation Requirements' 字段专指与 JSON Web Signature 和 JSON Web Encryption 一起使用，在这种情况下，禁止使用未经认证的加密。

算法名称："RS1"
算法描述：RSASSA-PKCS1-v1_5 with SHA-1
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："RSA-OAEP-384"
算法描述：RSA-OAEP using SHA-384 and MGF1 with SHA-384
算法使用位置："alg"
JOSE 实现要求：可选
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："RSA-OAEP-512"
算法描述：RSA-OAEP using SHA-512 and MGF1 with SHA-512
算法使用位置："alg"
JOSE 实现要求：可选
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："A128CBC"
算法描述：AES CBC using 128 bit key
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："A192CBC"
算法描述：AES CBC using 192 bit key
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："A256CBC"
算法描述：AES CBC using 256 bit key
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："A128CTR"
算法描述：AES CTR using 128 bit key
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："A192CTR"
算法描述：AES CTR using 192 bit key
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："A256CTR"
算法描述：AES CTR using 256 bit key
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

算法名称："HS1"
算法描述：HMAC using SHA-1
算法使用位置："JWK"
JOSE 实现要求：禁止
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

参数名称："ext"
参数描述：Extractable
与 "kty" 值一起使用：*
参数信息类别：公开
变更控制方：W3C Web Cryptography Working Group
规范文档：[[ This Document ]]

特别感谢 Ryan Sleevi，本文件的原作者和编辑，以及本文件的前编辑 Mark Watson。

感谢 Adam Barth、Alex Russell、Ali Asad、Arun Ranganathan、 Brian Smith、Brian Warner、Channy Yun、Charles Engelke、Eric Roman、Glenn Adams、Jim Schaad、Kai Engert、 Michael Hutchinson、Michael B. Jones、Nick Van den Bleeken、Richard Barnes、Ryan Hurst、 Tim Taubert、Vijay Bharadwaj、Virginie Galindo 和 Wan-Teh Chang 提供技术反馈和协助。

感谢 W3C Web Cryptography WG，以及 public-webcrypto@w3.org 邮件列表的参与者。

W3C 感谢 Northrop Grumman Cybersecurity Research Consortium 对 W3C/MIT 的支持。

getRandomValues 方法最初由 Adam Barth 向 Crypto 接口中的 WHATWG 提议。

本节是非规范性的。

有关导入和导出 JWK 的规范性要求，请参见特定于算法的小节。

JSON Web Key	AlgorithmIdentifier
`{ kty: "RSA", alg: "RS1" }`	`{ name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-1" } }`
`{ kty: "RSA", alg: "RS256" }`	`{ name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-256" } }`
`{ kty: "RSA", alg: "RS384" }`	`{ name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-384" } }`
`{ kty: "RSA", alg: "RS512" }`	`{ name: "RSASSA-PKCS1-v1_5", hash: { name: "SHA-512" } }`
`{ kty: "RSA", alg: "PS256" }`	`{ name: "RSA-PSS", hash: { name: "SHA-256" } }`
`{ kty: "RSA", alg: "PS384" }`	`{ name: "RSA-PSS", hash: { name: "SHA-384" } }`
`{ kty: "RSA", alg: "PS512" }`	`{ name: "RSA-PSS", hash: { name: "SHA-512" } }`
`{ kty: "RSA", alg: "RSA-OAEP" }`	`{ name: "RSA-OAEP", hash: { name: "SHA-1" } }`
`{ kty: "RSA", alg: "RSA-OAEP-256" }`	`{ name: "RSA-OAEP", hash: { name: "SHA-256" } }`
`{ kty: "RSA", alg: "RSA-OAEP-384" }`	`{ name: "RSA-OAEP", hash: { name: "SHA-384" } }`
`{ kty: "RSA", alg: "RSA-OAEP-512" }`	`{ name: "RSA-OAEP", hash: { name: "SHA-512" } }`
`{ kty: "EC", alg: "ES256" }`	`{ name: "ECDSA", namedCurve: "P-256", hash: { name: "SHA-256" } }`
`{ kty: "EC", alg: "ES384" }`	`{ name: "ECDSA", namedCurve: "P-384", hash: { name: "SHA-384" } }`
`{ kty: "EC", alg: "ES512" }`	`{ name: "ECDSA", namedCurve: "P-521", hash: { name: "SHA-512" } }`
`{ kty: "OKP", crv: "Ed25519", alg: "Ed25519" }`	`{ name: "Ed25519" }`
`{ kty: "OKP", crv: "X25519" }`	`{ name: "X25519" }`
`{ kty: "oct", alg: "A128CTR" }`	`{ name: "AES-CTR", length: 128 }`
`{ kty: "oct", alg: "A192CTR" }`	`{ name: "AES-CTR", length: 192 }`
`{ kty: "oct", alg: "A256CTR" }`	`{ name: "AES-CTR", length: 256 }`
`{ kty: "oct", alg: "A128CBC" }`	`{ name: "AES-CBC", length: 128 }`
`{ kty: "oct", alg: "A192CBC" }`	`{ name: "AES-CBC", length: 192 }`
`{ kty: "oct", alg: "A256CBC" }`	`{ name: "AES-CBC", length: 256 }`
`{ kty: "oct", alg: "A128KW" }`	`{ name: "AES-KW", length: 128 }`
`{ kty: "oct", alg: "A192KW" }`	`{ name: "AES-KW", length: 192 }`
`{ kty: "oct", alg: "A256KW" }`	`{ name: "AES-KW", length: 256 }`
`{ kty: "oct", alg: "A128GCM" }`	`{ name: "AES-GCM", length: 128 }`
`{ kty: "oct", alg: "A192GCM" }`	`{ name: "AES-GCM", length: 192 }`
`{ kty: "oct", alg: "A256GCM" }`	`{ name: "AES-GCM", length: 256 }`
`{ kty: "oct", alg: "A128GCMKW" }`	`{ name: "AES-GCM", length: 128 }`
`{ kty: "oct", alg: "A192GCMKW" }`	`{ name: "AES-GCM", length: 192 }`
`{ kty: "oct", alg: "A256GCMKW" }`	`{ name: "AES-GCM", length: 256 }`
`{ kty: "oct", alg: "HS1" }`	`{ name: "HMAC", hash: { name: "SHA-1" } }`
`{ kty: "oct", alg: "HS256" }`	`{ name: "HMAC", hash: { name: "SHA-256" } }`
`{ kty: "oct", alg: "HS384" }`	`{ name: "HMAC", hash: { name: "SHA-384" } }`
`{ kty: "oct", alg: "HS512" }`	`{ name: "HMAC", hash: "SHA-512" }`

本节是非规范性的。

有关导入和导出 SPKI 的规范性要求，请参见特定于算法的小节。

Algorithm OID	subjectPublicKey ASN.1 结构	AlgorithmIdentifier	参考
rsaEncryption (1.2.840.113549.1.1.1)	RSAPublicKey	"`RSASSA-PKCS1-v1_5`"、 "`RSA-PSS`" 或 "`RSA-OAEP`"	[RFC3447]
id-ecPublicKey (1.2.840.10045.2.1)	ECPoint	"`ECDH`" 或 "`ECDSA`"	[RFC5480]
id-Ed25519 (1.3.101.112)	BIT STRING	"`Ed25519`"	[RFC8410]
id-X25519 (1.3.101.110)	BIT STRING	"`X25519`"	[RFC8410]

注

本规范使用的对象标识符不包含该密钥意图与之一起使用的特定算法和哈希的信息。如果需要这些信息，建议改用 "jwk" 密钥格式。

本节是非规范性的。

有关导入和导出 PKCS#8 PrivateKeyInfo 的规范性要求，请参见特定于算法的小节。

privateKeyAlgorithm	privateKey 格式	AlgorithmIdentifier	参考
rsaEncryption (1.2.840.113549.1.1.1)	RSAPrivateKey	"`RSASSA-PKCS1-v1_5`"、 "`RSA-PSS`" 或 "`RSA-OAEP`"	[RFC3447]
id-ecPublicKey (1.2.840.10045.2.1)	ECPrivateKey	"`ECDH`" 或 "`ECDSA`"	[RFC5480]
id-Ed25519 (1.3.101.112)	CurvePrivateKey	"`Ed25519`"	[RFC8410]
id-X25519 (1.3.101.110)	CurvePrivateKey	"`X25519`"	[RFC8410]

[DOM]: DOM Standard. Anne van Kesteren. WHATWG. Living Standard. URL: https://dom.spec.whatwg.org/
[ECMA-262]: ECMAScript Language Specification. Ecma International. URL: https://tc39.es/ecma262/multipage/
[encoding]: Encoding Standard. Anne van Kesteren. WHATWG. Living Standard. URL: https://encoding.spec.whatwg.org/
[FIPS-180-4]: FIPS PUB 180-4: Secure Hash Standard (SHS). U.S. Department of Commerce/National Institute of Standards and Technology. August 2015. National Standard. URL: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
[FIPS-198-1]: The Keyed-Hash Message Authentication Code (HMAC). NIST. July 2008. URL: http://csrc.nist.gov/publications/fips/fips198-1/FIPS-198-1_final.pdf
[HTML]: HTML Standard. Anne van Kesteren; Domenic Denicola; Dominic Farolino; Ian Hickson; Philip Jägenstedt; Simon Pieters. WHATWG. Living Standard. URL: https://html.spec.whatwg.org/multipage/
[Infra]: Infra Standard. Anne van Kesteren; Domenic Denicola. WHATWG. Living Standard. URL: https://infra.spec.whatwg.org/
[JWA]: JSON Web Algorithms (JWA). M. Jones. IETF. May 2015. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc7518
[JWK]: JSON Web Key (JWK). M. Jones. IETF. May 2015. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc7517
[NIST-SP800-38A]: NIST Special Publication 800-38A: Recommendation for Block Cipher Modes of Operation, Methods and Techniques. NIST. December 2001. URL: http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
[NIST-SP800-38D]: NIST Special Publication 800-38D: Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC. NIST. November 2007. URL: http://csrc.nist.gov/publications/nistpubs/800-38D/SP-800-38D.pdf
[RFC2119]: Key words for use in RFCs to Indicate Requirement Levels. S. Bradner. IETF. March 1997. Best Current Practice. URL: https://www.rfc-editor.org/rfc/rfc2119
[RFC2141]: URN Syntax. R. Moats. IETF. May 1997. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc2141
[RFC2315]: PKCS #7: Cryptographic Message Syntax Version 1.5. B. Kaliski. IETF. March 1998. Informational. URL: https://www.rfc-editor.org/rfc/rfc2315
[RFC3394]: Advanced Encryption Standard (AES) Key Wrap Algorithm. J. Schaad; R. Housley. IETF. September 2002. Informational. URL: https://www.rfc-editor.org/rfc/rfc3394
[RFC3447]: Public-Key Cryptography Standards (PKCS) #1: RSA Cryptography Specifications Version 2.1. J. Jonsson; B. Kaliski. IETF. February 2003. Informational. URL: https://www.rfc-editor.org/rfc/rfc3447
[RFC4122]: A Universally Unique IDentifier (UUID) URN Namespace. P. Leach; M. Mealling; R. Salz. IETF. July 2005. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc4122
[RFC5208]: Public-Key Cryptography Standards (PKCS) #8: Private-Key Information Syntax Specification Version 1.2. B. Kaliski. IETF. May 2008. Informational. URL: https://www.rfc-editor.org/rfc/rfc5208
[RFC5280]: Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile. D. Cooper; S. Santesson; S. Farrell; S. Boeyen; R. Housley; W. Polk. IETF. May 2008. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc5280
[RFC5480]: Elliptic Curve Cryptography Subject Public Key Information. S. Turner; D. Brown; K. Yiu; R. Housley; T. Polk. IETF. March 2009. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc5480
[RFC5869]: HMAC-based Extract-and-Expand Key Derivation Function (HKDF). H. Krawczyk; P. Eronen. IETF. May 2010. Informational. URL: https://www.rfc-editor.org/rfc/rfc5869
[RFC5915]: Elliptic Curve Private Key Structure. S. Turner; D. Brown. IETF. June 2010. Informational. URL: https://www.rfc-editor.org/rfc/rfc5915
[RFC6090]: Fundamental Elliptic Curve Cryptography Algorithms. D. McGrew; K. Igoe; M. Salter. IETF. February 2011. Informational. URL: https://www.rfc-editor.org/rfc/rfc6090
[RFC7748]: Elliptic Curves for Security. A. Langley; M. Hamburg; S. Turner. IETF. January 2016. Informational. URL: https://www.rfc-editor.org/rfc/rfc7748
[RFC8018]: PKCS #5: Password-Based Cryptography Specification Version 2.1. K. Moriarty, Ed.; B. Kaliski; A. Rusch. IETF. January 2017. Informational. URL: https://www.rfc-editor.org/rfc/rfc8018
[RFC8032]: Edwards-Curve Digital Signature Algorithm (EdDSA). S. Josefsson; I. Liusvaara. IETF. January 2017. Informational. URL: https://www.rfc-editor.org/rfc/rfc8032
[RFC8037]: CFRG Elliptic Curve Diffie-Hellman (ECDH) and Signatures in JSON Object Signing and Encryption (JOSE). I. Liusvaara. IETF. January 2017. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc8037
[RFC8174]: Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words. B. Leiba. IETF. May 2017. Best Current Practice. URL: https://www.rfc-editor.org/rfc/rfc8174
[RFC8410]: Algorithm Identifiers for Ed25519, Ed448, X25519, and X448 for Use in the Internet X.509 Public Key Infrastructure. S. Josefsson; J. Schaad. IETF. August 2018. Proposed Standard. URL: https://www.rfc-editor.org/rfc/rfc8410
[SEC1]: SEC 1: Elliptic Curve Cryptography. Certicom Research. URL: http://www.secg.org/sec1-v2.pdf
[WebIDL]: Web IDL Standard. Edgar Chen; Timothy Gu. WHATWG. Living Standard. URL: https://webidl.spec.whatwg.org/
[X690]: Information technology - ASN.1 encoding rules: Specification of Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules (DER). Justin Uberti; Cullen Jennings; Eric Rescorla. ITU-T. November 2008. ITU-T Recommendation. URL: https://tools.ietf.org/html/draft-ietf-rtcweb-jsep/

[INDEXEDDB]: Indexed Database API. Nikunj Mehta; Jonas Sicking; Eliot Graff; Andrei Popescu; Jeremy Orlow; Joshua Bell. W3C. 8 January 2015. W3C Recommendation. URL: https://www.w3.org/TR/IndexedDB/

Web 加密 第 2 级

摘要

本文档状态

1. 简介

2. 用例

2.1 多因素认证

2.2 受保护的文档交换

2.3 云存储

2.4 文档签名

2.5 数据完整性保护

2.6 安全消息传递

2.7 JavaScript Object Signing and Encryption (JOSE)

3. 一致性

3.1 可扩展性

4. 范围

4.1 抽象层级

4.2 加密算法

4.3 范围之外

5. 概念

5.1 底层 加密实现

5.2 密钥存储

6. 安全性考虑

6.1 面向实现者的安全性 考虑

6.2 面向作者的安全性考虑

6.3 面向 用户的安全性考虑

7. 隐私性考虑

8. 依赖项

9. 术语

10. Crypto 接口

10.1 方法和参数

10.1.1 getRandomValues 方法

10.1.2 randomUUID 方法

10.2 属性

10.2.1 subtle 属性

11. Algorithm 字典

11.1 Algorithm 字典成员

12. KeyAlgorithm 字典

12.1 描述

12.2 KeyAlgorithm 字典 成员

13. CryptoKey 接口

13.1 描述

13.2 Key 接口数据类型

13.3 CryptoKey 内部槽

13.4 CryptoKey 接口成员

13.5 序列化和 反序列化步骤

14. SubtleCrypto 接口

14.1 数据类型

14.2 任务源

14.3 方法和参数

14.3.1 encrypt 方法

14.3.2 decrypt 方法

14.3.3 sign 方法

14.3.4 verify 方法

14.3.5 digest 方法

14.3.6 generateKey 方法

14.3.7 deriveKey 方法

14.3.8 deriveBits 方法

14.3.9 importKey 方法

14.3.10 exportKey 方法

14.3.11 wrapKey 方法

14.3.12 unwrapKey 方法

14.4 异常

15. JsonWebKey 字典

16. BigInteger

17. CryptoKeyPair 字典

18. 算法

18.1 概述

18.2 概念

18.2.1 命名

18.2.2 支持的操作

18.2.3 规范化

18.3 规范约定

18.4 算法规范化

18.4.1 描述

18.4.2 内部状态对象

18.4.3 定义算法

18.4.4 规范化算法

18.5 建议

18.5.1 面向作者

18.5.2 面向实现者

Web 加密第 2 级

5.1 底层加密实现

6.1 面向实现者的安全性考虑

6.3 面向用户的安全性考虑

11.1 `Algorithm` 字典成员

12.2 KeyAlgorithm 字典成员

13.5 序列化和反序列化步骤

20.3 `RsaKeyGenParams` 字典

20.4 `RsaHashedKeyGenParams` 字典

20.5 `RsaKeyAlgorithm` 字典

20.6 `RsaHashedKeyAlgorithm` 字典

20.7 `RsaHashedImportParams` 字典

21.3 `RsaPssParams` 字典

22.3 `RsaOaepParams` 字典

23.3 `EcdsaParams` 字典

23.4 `EcKeyGenParams` 字典

23.5 `EcKeyAlgorithm` 字典

23.6 `EcKeyImportParams` 字典

24.3 `EcdhKeyDeriveParams` 字典