# vetKeys（可验证的加密阈值密钥） > **注：** vetKeys 是 IC 的一项较新功能。 `ic-vetkeys` Rust crate 和 `@dfinity/vetkeys` npm 包已发布，但 API 可能仍会随着时间的推移而改变。固定您的依赖项版本并检查 [DFINITY 论坛]() 以获取升级后的任何迁移指南。 ## 这是什么 vetKeys（可验证的加密阈值密钥）通过 **vetKD** 协议为 IC 带来链上隐私：安全、按需密钥派生，以便公共区块链可以保存和处理秘密数据。密钥是**可验证的**（用户可以检查正确性和是否被篡改）、**加密**（派生密钥在用户提供的传输密钥下加密 - 没有节点或容器看到原始密钥）和**阈值**（子网节点的法定数量合作派生密钥；没有任何一方拥有主密钥）。容器从子网的阈值基础设施请求派生密钥，接收在客户端传输公钥下加密的密钥，并且只有客户端在本地对其进行解密。这解锁了去中心化密钥管理 (DKMS)、加密链上存储、私人消息传递、基于身份的加密 (IBE)、时间锁加密、阈值 BLS 和可验证随机性用例。 ## 先决条件 * `icp-cli` >= 0.1.0 (`brew install dfinity/tap/icp-cli`) * Rust: `ic-vetkeys = "0.6"` ([crates.io]()) * Motoko：使用如下所示的原始管理罐方法 * 前端：`@dfinity/vetkeys` v0.4.0 (`npm install @dfinity/vetkeys`) * 对于本地测试：`icp network start`自动创建本地测试密钥 ## 容器 ID 罐|身份证 |目的 ---|---|--- 管理罐| `aaaaa-aa` |公开 `vetkd_public_key` 和 `vetkd_derive_key` 系统 API 链钥匙测试罐| `vrqyr-saaaa-aaaan-qzn4q-cai` | **仅测试：** 假 vetKD 实现用于测试密钥派生，无需支付生产 API 费用。不安全，请勿在生产中使用。管理容器不是真正的容器，它是系统级 API 端点。对“aaaaa-aa”的调用由系统路由到启用 vetKD 的子网，该子网保存“key_id”中指定的主密钥；该子网的节点运行阈值密钥派生。您的容器可以从任何子网进行调用。 **测试容器：** [链密钥测试容器]() 部署在主网上，并提供假 vetKD 实现（硬编码密钥，无阈值），因此您可以在没有生产周期成本的情况下进行密钥派生。使用密钥名称“insecure_test_key_1”。 **不安全，仅用于测试：**切勿在生产中或敏感数据中使用它。您还可以从存储库部署您自己的实例。 ### 主密钥名称和 API 费用 IC 上的任何容器都可以使用任何可用的主密钥，无论容器或密钥位于哪个子网；管理容器将呼叫路由到保存主密钥的子网。按键名称 |环境 |目的|周期（大约）|注释 ---|---|---|---|--- `dfx_test_key` |本地|仅限开发| — |使用“icp network start”自动创建 `test_key_1` |主网 |测试| 10_000_000_000 | 10_000_000_000子网 fuqsr（在 2fq7c 上备份） `key_1` |主网 |生产| 26_153_846_153 |子网 pzp6e（在 uzr34 上备份）费用取决于主密钥所在的子网（及其大小），而不是调用容器的子网。如果容器可能被黑洞或被其他容器使用，请发送比当前成本更多的周期，以便未来子网大小的增加不会导致调用失败；未使用的周期将被退款。请参阅 [vetKD API — API 费用]() 了解当前的美元估算。 ## 关键概念 * **vetKey** ：从“(canister_id, context, input)”确定性导出的密钥材料。相同的输入总是产生相同的密钥。容器和任何子网节点都看不到原始密钥，因为它是在客户端的传输密钥下加密的，直到在本地解密。 * **传输密钥** ：客户端生成的临时密钥对。公钥被发送到容器，以便 IC 可以加密派生密钥以进行交付。只有持有相应私钥的客户端才能解密结果。 * **上下文**：域分隔符 blob。隔离每个用例（例如每个功能或密钥用途）的派生子密钥，并防止同一容器内的密钥冲突。将其视为名称空间。 * **输入** ：应用程序定义的数据，用于标识派生哪个密钥（例如用户主体、文件 ID、聊天室 ID）。它以明文形式发送到管理容器。仅将其用作标识符，切勿用于秘密数据。 * **IBE（基于身份的加密）**：使用派生公钥加密身份（例如主体）的方案。 vetKeys 在 IC 上启用 IBE：任何人都可以使用容器的派生公钥加密主体；只有该主体才能获取匹配的 vetKey 并解密。 ## 破坏你的构建的错误 1. **不固定依赖版本。** `ic-vetkeys` crate 和 `@dfinity/vetkeys` npm 包已发布，但 API 在新版本中可能仍会发生变化。固定您的版本并在升级后重新测试。如果升级后某些功能停止工作，请查阅相关变更说明以了解发生了什么情况。 2. **跨会话重用传输密钥。** 每个会话必须生成新的传输密钥对。 Rust 和 TypeScript 库支持安全生成密钥；如果可能的话使用它们。 3. **使用原始`vetkd_derive_key`输出作为加密密钥。**输出是加密的blob。您必须使用传输密钥对其进行解密才能获取 vetKey（原始密钥材料）。接下来您要做什么取决于您的用例：例如，您可以通过“toDerivedKeyMaterial()”或等效方法派生对称密钥（例如 AES）。不要直接使用解密的字节作为 AES 密钥。其他用途（IBE 解密、签名等）以自己的方式消耗 vetKey；这些库为每个库记录了正确的模式。 4. **将 vetKD 与传统公钥加密相混淆。** 每个用户没有静态密钥对。密钥是根据子网的阈值主密钥（通过 vetKD 协议）按需派生的。相同的（容器、上下文、输入）始终会产生相同的派生密钥。 5. **将秘密数据放入“输入”字段中。** 输入以明文形式发送到管理容器。它是一个密钥标识符，而不是加密的有效负载。将其用于 ID（主体、文档 ID），切勿用于实际的秘密数据。 6. **忘记`vetkd_derive_key`是一个异步容器间调用。**它会消耗周期并且需要`await`。在等待之前捕获“调用者”作为防御练习。 7. **使用`context`不一致。**如果后端使用`b"my_app_v1"`作为上下文，但前端验证使用`b"my_app"`，则派生密钥将不匹配，解密将默默失败。 8. **没有为`vetkd_derive_key`附加足够的周期。** `vetkd_derive_key`消耗周期； `vetkd_public_key` 没有。对于derive_key，“key_1”花费约26B个周期，“test_key_1”花费约10B个周期。 ## 系统API（坦白） vetKD API 允许容器请求由阈值协议派生的 vetKey。派生是**确定性的**：相同的输入总是产生相同的密钥，因此可以可靠地检索密钥。不同的输入产生不同的密钥——容器可以派生无限数量的唯一密钥。总结如下；完整规范：[vetKD API]() 和 [IC 接口规范]()。 ### vetkd_public_key 返回用于**验证**使用“vetkd_derive_key”派生的密钥的公钥。在空上下文中，您可以获得容器级主公钥；对于非空上下文，您可以获得该上下文的派生子项。在 IBE 中，该公钥允许任何人加密身份（例如委托人）；只有该身份的持有者稍后才能获取匹配的 vetKey 并解密——无需事先进行密钥交换或接收者在场。 vetkd_public_key : (记录 { canister_id : 选择 canister_id; 上下文：斑点； key_id : 记录 { 曲线 : vetkd_curve;名称：文字}； }) -> (记录 { public_key : blob }) * `canister_id`：可选。如果省略 (`null`)，则返回 **调用容器** 的公钥；如果提供，则返回该罐的密钥。 * `context`：域分隔符，其含义与`vetkd_derive_key`中的含义相同。确保密钥是在特定上下文中派生的，并避免应用程序或用例之间发生冲突。 * `key_id.curve`: `bls12_381_g2`（仅支持曲线）。 * `key_id.name`：主密钥名称：`dfx_test_key`（本地）、`test_key_1`或`key_1`。您还可以从已知的主网主公钥**离线**导出此公钥；请参阅下面的“离线公钥派生”。 ### vetkd_derive_key 派生给定（上下文、输入）的密钥材料，并根据接收者的传输公钥将其**加密**返回。只有传输秘密的持有者才能解密。然后根据您的用例使用解密的材料（例如，通过“toDerivedKeyMaterial()”用于对称密钥，或用于 IBE 解密）。 vetkd_derive_key : (记录 { 输入：斑点；上下文：斑点； Transport_public_key : blob; key_id : 记录 { 曲线 : vetkd_curve;名称：文字}； }) -> (记录 { 加密密钥 : blob }) * `input`：用作密钥标识符的任意数据 - 不同的输入产生不同的派生密钥。不需要是随机的；以明文形式发送到管理容器。 * `context`: 域分隔符；必须与获取公钥时使用的上下文相匹配（例如用于验证或 IBE）。 * `transport_public_key`: 接收者的公钥；派生密钥在此下进行加密以确保安全传送。 * 返回：`加密密钥`。使用传输密钥解密以获取原始 vetKey，然后根据需要使用它（例如派生对称密钥；不要直接使用原始字节作为 AES 密钥）。主密钥名称和周期成本位于容器 ID 下的**主密钥名称和 API 费用**中。 ## 实施 ### 铁锈 **货物.toml：** [依赖项] 坦率=“0.10” ic-cdk =“0.19” serde = {版本=“1”，功能=[“派生”]} serde_bytes =“0.11” # 高级库（推荐）——来源：https://github.com/dfinity/vetkeys ic-vetkeys =“0.6” ic-稳定结构=“0.7” **使用 ic-vetkeys 库（推荐）：** 使用坦诚::校长；使用 ic_cdk::update; 使用 ic_stable_structs::memory_manager::{MemoryId、MemoryManager、VirtualMemory}；使用 ic_stable_structs::DefaultMemoryImpl；使用 ic_vetkeys::key_manager::KeyManager; 使用 ic_vetkeys::types::{AccessRights, VetKDCurve, VetKDKeyId}; // KeyManager 是 AccessControl 类型的通用型 — AccessRights 是默认值。 // 它使用稳定的内存来持久存储访问控制状态。线程本地！ { 静态 MEMORY_MANAGER：std::cell::RefCell> = std::cell::RefCell::new(MemoryManager::init(DefaultMemoryImpl::default())); 静态 KEY_MANAGER：std::cell::RefCell>> = std::cell::RefCell::new(无); } #[ic_cdk::init] fn 初始化() { 让 key_id = VetKDKeyId { 曲线：VetKDCurve::Bls12381G2， name: "key_1".to_string(), // "dfx_test_key" 用于本地， "test_key_1" 用于测试 }; MEMORY_MANAGER.with(|mm| { 让 mm = mm.borrow(); KEY_MANAGER.with(|公里| { *km.borrow_mut() = Some(KeyManager::init( "my_app_v1", // 域分隔符密钥 ID， mm.get(MemoryId::new(0)), // 配置内存 mm.get(MemoryId::new(1)), // 访问控制内存 mm.get(MemoryId::new(2)), // 共享密钥内存））； }); }); } #[更新] async fn get_encrypted_vetkey(subkey_id: Vec, Transport_public_key: Vec) -> Vec { 让来电者= ic_cdk::来电者(); // 在等待之前捕获让 future = KEY_MANAGER.with(|km| { 让 km = km.borrow(); let km = km.as_ref().expect("未初始化"); km.get_encrypted_vetkey（调用者，subkey_id，transport_public_key） .expect("访问被拒绝") }); 未来.等待 } #[更新] 异步 fn get_vetkey_verification_key() -> Vec { 让 future = KEY_MANAGER.with(|km| { 让 km = km.borrow(); let km = km.as_ref().expect("未初始化"); km.get_vetkey_verification_key() }); 未来.等待 } **直接调用管理容器（下层）：** 使用 candid::{CandidType, 反序列化, 主体}; 使用 ic_cdk::update; #[derive(CandidType, 反序列化)] 结构 VetKdKeyId { 曲线：VetKdCurve，名称：字符串， } #[derive(CandidType, 反序列化)] 枚举 VetKdCurve { #[serde(重命名=“bls12_381_g2”)] Bls12381G2， } #[导出（CandidType）] 结构 VetKdPublicKeyRequest { canister_id：选项<主体>，上下文：Vec， key_id: VetKdKeyId, } #[derive(CandidType, 反序列化)] 结构 VetKdPublicKeyResponse { 公钥：Vec， } #[导出（CandidType）] 结构 VetKdDeriveKeyRequest { 输入：Vec，上下文：Vec， Transport_public_key: Vec, key_id: VetKdKeyId, } #[derive(CandidType, 反序列化)] 结构 VetKdDeriveKeyResponse { 加密密钥：Vec， } const 上下文：&[u8] = b"my_app_v1"; fn key_id() -> VetKdKeyId { VetKdKeyId { 曲线：VetKdCurve::Bls12381G2， // 密钥名称：“dfx_test_key”用于本地，“test_key_1”用于主网测试，“key_1”用于生产名称：“key_1”.to_string(), } } #[更新] 异步 fn vetkd_public_key() -> Vec { 让请求= VetKdPublicKeyRequest { canister_id: None, // 默认为此容器上下文：CONTEXT.to_vec(), key_id: key_id(), }; // vetkd_public_key 不需要循环（与 vetkd_derive_key 不同）。让（响应，）：（VetKdPublicKeyResponse，）= ic_cdk :: api :: call :: call（校长::management_canister(), // aaaaa-aa “vetkd_public_key”，（请求，），） .await .expect("vetkd_public_key 调用失败"); 响应.public_key } #[更新] 异步 fn vetkd_derive_key(transport_public_key: Vec) -> Vec { 让来电者= ic_cdk::来电者(); // 必须在等待之前捕获让请求= VetKdDeriveKeyRequest { input: caller.as_slice().to_vec(), // 派生特定于该调用者的密钥上下文：CONTEXT.to_vec(), 运输公共密钥， key_id: key_id(), }; // key_1 花费约 26B 个周期，test_key_1 花费约 10B 个周期。让（响应，）：（VetKdDeriveKeyResponse，）= ic_cdk :: api :: call :: call_with_ payment128（校长::management_canister(), “vetkd_derive_key”，（请求，）， 26_000_000_000, // key_1 的周期（对 test_key_1 使用 10_000_000_000）） .await .expect("vetkd_derive_key 调用失败"); 响应.加密密钥 } ### 元子 **拖把.toml：** [包装] 名称 =“my-vetkd-app” 版本=“0.1.0” [依赖项] 核心=“2.0.0” **直接使用管理罐：** 导入 Blob“mo:core/Blob”；导入主体“mo：核心/主体”；导入文本“mo：核心/文本”；持久演员{ 类型 VetKdCurve = { #bls12_381_g2 }; 输入 VetKdKeyId = { 曲线：VetKdCurve；名称：文本； }; 类型 VetKdPublicKeyRequest = { canister_id : ?校长；上下文：斑点； key_id : VetKdKeyId; }; 类型 VetKdPublicKeyResponse = { 公钥：Blob； }; 类型 VetKdDeriveKeyRequest = { 输入：斑点；上下文：斑点； Transport_public_key : Blob; key_id : VetKdKeyId; }; 类型 VetKdDeriveKeyResponse = { 加密密钥：Blob； }; 让管理罐：演员{ vetkd_public_key ：VetKdPublicKeyRequest -> 异步 VetKdPublicKeyResponse； vetkd_derive_key ：VetKdDeriveKeyRequest -> 异步 VetKdDeriveKeyResponse； } = 演员“aaaaa-aa”；让上下文：Blob = Text.encodeUtf8（“my_app_v1”）; // 密钥名称：“dfx_test_key”用于本地，“test_key_1”用于主网测试，“key_1”用于生产 func keyId() : VetKdKeyId { { 曲线 = #bls12_381_g2;名称=“key_1”} }; 公共共享 func getPublicKey() : 异步 Blob { // vetkd_public_key 不需要循环（与 vetkd_derive_key 不同）。让响应 = 等待 managementCanister.vetkd_public_key({ canister_id = null; 背景； key_id = keyId(); }); 响应.public_key }; 公共共享（{调用者}）funcderiveKey（transportPublicKey：Blob）：异步Blob{ // 调用者在等待之前被捕获。 vetkd_derive_key 需要循环。让响应=等待（周期= 26_000_000_000）managementCanister.vetkd_derive_key（{ 输入=Principal.toBlob（调用者）；背景； Transport_public_key = TransportPublicKey; key_id = keyId(); }); 响应.加密密钥 }; }; ### 前端（TypeScript）前端生成传输密钥对，将公共部分发送到容器，接收加密的派生密钥，使用传输密钥对其进行解密以获得 vetKey（原始密钥材料），然后从该材料派生对称密钥（例如通过“toDerivedKeyMaterial()”）用于 AES 或其他用途。从“@dfinity/vetkeys”导入{ TransportSecretKey、DerivedPublicKey、EncryptedVetKey }； // 1. 生成传输密钥 (BLS12-381) const seeds = crypto.getRandomValues(new Uint8Array(32)); const TransportSecretKey = TransportSecretKey.fromSeed(seed); const TransportPublicKey = TransportSecretKey.publicKey(); // 2. 从您的容器请求加密的 vetkey 和验证密钥 const [加密密钥字节，验证密钥字节] = 等待 Promise.all([ backendActor.get_encrypted_vetkey（subkeyId，transportPublicKey）， backendActor.get_vetkey_verification_key(), ]); // 3. 反序列化和解密 const verifyKey = DerivedPublicKey.deserialize(new Uint8Array(verificationKeyBytes)); const cryptoVetKey = EncryptedVetKey.deserialize(new Uint8Array(encryptedKeyBytes)); const vetKey = cryptoVetKey.decryptAndVerify( 传输密钥，验证密钥，新的 Uint8Array(subkeyId), ）； // 4. 导出 AES-GCM 的对称密钥 const aesKeyMaterial = vetKey.toDerivedKeyMaterial(); const aesKey = 等待 crypto.subtle.importKey( “生的”， aesKeyMaterial.data.slice(0, 32), // 256 位 AES 密钥 {名称：“AES-GCM”}，假的， [“加密”，“解密”]，）； // 5. 加密 const iv = crypto.getRandomValues(new Uint8Array(12)); const ciphertext = 等待 crypto.subtle.encrypt( { 名称：“AES-GCM”，iv }，密钥， new TextEncoder().encode("秘密消息"), ）； // 6. 解密 const plaintext = 等待 crypto.subtle.decrypt( { 名称：“AES-GCM”，iv }，密钥，密文，）； `@dfinity/vetkeys` 包还通过子路径提供更高级别的抽象： * **`@dfinity/vetkeys/key_manager`** \-- `KeyManager` 和 `DefaultKeyManagerClient` 用于管理访问控制密钥 * **`@dfinity/vetkeys/encrypted_maps`** \-- 用于加密键值存储的 `EncryptedMaps` 和 `DefaultEncryptedMapsClient` 它们镜像 Rust `KeyManager` 和 `EncryptedMaps` 类型并自动处理传输密钥流。 ### 离线公钥推导您可以从给定密钥名称（例如“key_1”）的已知主网主公钥离线导出公钥（无需任何容器调用）。这对于 IBE 很有用：您可以为您的上下文派生容器的公钥，然后在接收者或容器不在线的情况下加密为身份（例如主体）。 **生锈：** 使用 ic_vetkeys::{MasterPublicKey, DerivedPublicKey}; // 从key_1的已知主网主公钥开始让 master_key = MasterPublicKey::for_mainnet_key("key_1") .expect("未知的键名"); // 导出容器级密钥让 canister_key = master_key.derive_canister_key(canister_id.as_slice()); // 派生特定上下文/身份的子密钥让衍生密钥： DerivedPublicKey = canister_key.derive_sub_key(b“my_app_v1”); // 使用衍生密钥进行 IBE 加密 — 无需调用容器 **打字稿：** 从“@dfinity/vetkeys”导入{MasterPublicKey，DerivedPublicKey}； // 从已知的主网主公钥开始 const masterKey = MasterPublicKey.生产密钥(); // 导出容器级密钥 const canisterKey = masterKey.deriveCanisterKey(canisterId); // 派生特定上下文/身份的子密钥常量衍生密钥： DerivedPublicKey = canisterKey.deriveSubKey( 新的 TextEncoder().encode("my_app_v1"), ）； // 使用衍生密钥进行 IBE 加密 — 无需容器调用 ### 基于身份的加密 (IBE) IBE 允许您仅使用容器的派生公钥加密身份（例如主体）——接收者不需要在线或事先注册密钥。接收者稍后向容器进行身份验证，通过“vetkd_derive_key”获取其 vetKey（针对该身份派生），并在本地解密。 **打字稿：** 导入{ TransportSecretKey、DerivedPublicKey、EncryptedVetKey、 IbeCiphertext、IbeIdentity、IbeSeed、来自“@dfinity/vetkeys”； // --- 加密（发送方，无需调用容器）--- // 离线派生接收者的公钥（参见上面的“离线公钥派生”） constrecipientIdentity = IbeIdentity.fromBytes(recipientPrincipalBytes); const 种子 = IbeSeed.random(); const plaintext = new TextEncoder().encode("秘密消息"); const ciphertext = IbeCiphertext.encrypt(drivenPublicKey,recipientIdentity,明文,种子); const 序列化 = ciphertext.serialize(); // 存储或传输这个 // --- 解密（接收方，需要调用容器才能获取 vetKey）--- // 1. 获取 vetKey（与上面前端部分相同的流程） const TransportSecretKey = TransportSecretKey.fromSeed(crypto.getRandomValues(new Uint8Array(32))); const [加密密钥字节，验证密钥字节] = 等待 Promise.all([ backendActor.get_encrypted_vetkey（subkeyId，transportSecretKey.publicKey（））， backendActor.get_vetkey_verification_key(), ]); const verifyKey = DerivedPublicKey.deserialize(new Uint8Array(verificationKeyBytes)); const cryptoVetKey = EncryptedVetKey.deserialize(new Uint8Array(encryptedKeyBytes)); const vetKey = cryptoVetKey.decryptAndVerify( TransportSecretKey、verificationKey、new Uint8Array(subkeyId)、）； // 2. 解密IBE密文 const 反序列化 = IbeCiphertext.deserialize(serialized); const 解密 = deserialized.decrypt(vetKey); // 解密后是包含“秘密消息”的Uint8Array **Rust（链下客户端或测试）：** 使用 ic_vetkeys::{ DerivedPublicKey、IbeCiphertext、IbeIdentity、IbeSeed、VetKey、 }; // --- 加密 --- 让身份 = IbeIdentity::from_bytes(recipient_principal.as_slice()); 让种子 = IbeSeed::new(&mut rand::rng()); let plaintext = b"秘密消息"; 让密文= IbeCiphertext::加密（ &衍生_公钥， &身份，明文，种子，）；让序列化 = ciphertext.serialize(); // --- 解密（获得VetKey后）--- 让反序列化 = IbeCiphertext::deserialize(&serialized) .expect("无效密文"); 让解密 = deserialized.decrypt(&vet_key) .expect("解密失败"); // 解密 == b"秘密消息" ### 更高级别的抽象：KeyManager 和 EncryptedMaps Rust crate 和 TypeScript 包都提供了两个更高级别的模块，可以为您处理传输密钥流、访问控制和加密存储： * **`KeyManager`** (Rust) / **`KeyManager`** (TS) — 管理具有稳定存储的访问控制 vetKey。容器强制规定谁可以请求哪些密钥；该库处理派生请求、用户权限（“Read”、“ReadWrite”、“ReadWriteManage”）以及主体之间的密钥共享。 * **`EncryptedMaps`** (Rust) / **`EncryptedMaps`** (TS) — 基于 KeyManager 构建，提供加密的键值存储。每个地图都受到访问控制并在派生的 vetKey 下进行加密。值的加密和解密是在客户端（前端）使用 vetKeys 处理的；该容器仅存储密文。在 Rust 中，它们位于“ic_vetkeys::key_manager”和“ic_vetkeys::encrypted_maps”中。在 TypeScript 中，从“@dfinity/vetkeys/key_manager”和“@dfinity/vetkeys/encrypted_maps”导入。有关完整示例，请参阅 [vetkeys 存储库]()。 ## 部署和测试 ### 本地发展 # 启动本地副本（自动创建 dfx_test_key） icp网络启动-d # 部署你的容器 icp部署后端 # 测试公钥检索 icp 容器调用后端 getPublicKey '()' # 返回: (blob "...") -- vetKD 公钥 # 对于derive_key，您需要一个传输公钥（由前端生成） # 使用虚拟 48 字节 blob 进行测试： icp 容器调用后端deriveKey '(blob “\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14\15\16\17\ 18\19\1a\1b\1c\1d\1e\1f\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f")' ### 主网 # 部署到主网 icp部署后端-e ic # 使用 test_key_1 进行初始测试，使用 key_1 进行生产 # 确保您的容器代码引用正确的密钥名称 ## 验证它是否有效 # 1. 验证公钥是否返回（非空 blob） icp 容器调用后端 getPublicKey '()' # 预期：(blob "\ab\cd\ef...") -- 48+ 字节的 BLS 公钥数据 # 2.验证derive_key返回加密密钥（非空blob） icp 容器调用后端deriveKey '(blob "\00\01...")' # Expected: (blob "\12\34\56...") -- 加密的密钥材料 # 3. 验证确定性：相同的（调用者、上下文、输入）和相同的传输密钥产生相同的 crypto_key # 使用相同的身份和传输密钥调用deriveKey两次 # 预期：两次都是相同的 crypto_key blob # 4.验证隔离：不同的调用者获得不同的密钥 icp 身份新 test-user-1 --storage-mode=plaintext icp 身份新 test-user-2 --storage-mode=plaintext icp 身份默认 test-user-1 icp 容器调用后端deriveKey '(blob "\00\01...")' # 注意输出 icp 身份默认 test-user-2 icp 容器调用后端deriveKey '(blob "\00\01...")' # 预期：不同的加密密钥（不同的调用者 = 不同的派生密钥） # 5.前端集成测试 # 打开前端，触发加解密 # 验证：加密数据可以被同一用户解密 # 验证：加密数据不能被其他用户解密

维特克德

包含技能