密钥管理系统：您需要了解的一切

不久前，在一次麻瓜工作中，我们遇到了一个关于为各种服务存储私钥的问题。在此过程中，我们发现了几种由于不同原因而不太合适的解决方案。我决定找个时间再回过头来解决这个问题。 服务要求 就我个人而言，我强调了这项服务正常运行的一些要求： 目前，该服务必须存储 256 位私钥（大多数区块链网络使用） 应该为 EVM 网络签署交易和消息（以后可以支持其他网络）。 一个用户可以拥有无限数量的密钥。 用户的私钥不得离开我们的服务。 每个钥匙可与无限数量的人共享。 我们共享的密钥必须是唯一的。 我们应该记录每一个键的活动。 如果使用 服务密钥被泄露，我们应该能够撤销它。 sk 在工作过程中，当我意识到应该如何解决这个任务时，我又强调了一个要求： 我们必须能够限制每个密钥的范围。但是，由于这项工作已经在进行中，我将其留到下一篇文章中。因此，我们将限制自己在这篇文章中对消息进行签名。 解决问题的选项 由于密钥将在文章中多次使用，因此为了避免混淆，我将私钥称为 ，将共享的密钥称为 。 pk sk 最初的选择是在 函数中加密密钥，但是由于在这个算法的过程中我们只有一个密钥，所以存在如何共享密钥来访问签名的问题。 pbkdf2 我找到了两种解决问题的方法： 我们有存储在数据库中的加密密钥的主密钥，并且已经共享了生成的密钥，从而可以获取原始密钥。我不会说我喜欢这个选项，因为如果您可以访问数据库，则 密钥很容易解密。 pk 我们为检查的每个密钥创建单独的 密钥实例。我也不怎么喜欢这个选项。 pk 因此，四处走走并思考如何使 sk 密钥变得方便时，我想到使用 Shamir Secrets Sharing (SSS) 时，您可以使 密钥独一无二，并且仅共享密钥的一部分。其余部分将安全地存储在后端，您可以将这些部分提供给您想要的任何人。 sk 它看起来像这样：我们用 SSS 生成的密钥加密 pk 密钥，将密钥的一部分存储在不同的存储中，并将密钥的一部分作为 提供给用户。大约 10-15 分钟后，我意识到了一件简单的事情： sk 使用 SSS 时，我们不需要用其他任何东西加密我们的 密钥，因为 SSS 可以处理一些问题，而且我认为这种解决方案非常适合存储 PK 密钥。它总是使用不同的存储选项（包括用户的存储选项）分解成几部分。如果需要撤销，我们会删除 密钥的索引信息并快速组装一个新的。 pk sk 在本文中，我不会详细讨论 SSS 的原则；我已经就这个主题写了一篇 ，本文中的许多原则将构成我们新服务的基础。 短文 建筑学 我们的服务原则如下： 用户选择生成密钥。 我们为服务创建一个合适的密钥。这将是我们的 密钥。它永远不会离开整个服务。 pk 使用 SSS，我们拆分密钥，因此需要拆分密钥的三个部分来恢复 密钥。每个拆分密钥由两部分组成：x：密钥的位置 y：此位置的值 pk 我们将第一部分放入 Vault（它可以是任何可通过 API 访问的存储敏感信息的服务）。 第二部分我们保存到数据库（我将使用 PostgreSQL）。 第三部分我们部分保存到数据库，另一部分我们提供给用户（ ）。为了使用 SK 找到我们需要的值，我们还将 保存到数据库中。据我所知，它还没有被破解。 sk keccak256(sk) 当用户需要签署某些内容时，我们会从应用程序的不同部分收集私钥并对其进行签署。 这种方法有一个缺点，如果 密钥管理员丢失了他生成的所有 密钥，我们就无法恢复原始密钥。您可以选择备份原始密钥，但那是另一回事了 =)。 sk sk 数据库 由于我的工作，我有这样的数据库结构： 存储有关用户（又名密钥管理员）的信息。 用户 存储有关密钥的基本信息，例如我们的共享的第二部分、在 Vault 中可以找到共享的第一部分的索引，以及其他信息，例如我们的私钥的地址。 keys 包含 Share 的一部分，还存储了此 Share 的哈希值。这样做是为了我们可以在数据库中找到它。 shares 与密钥相关的任何活动，例如密钥创建和所有签名，都在这里。 记录 实现 我使用 Rust 编程语言和 Actix-web 框架来提供这项服务。我在工作中一直使用它们，所以为什么不呢？ 正如我所说，由于以下原因，数据库将采用 Postgresql。 多项式 lazy_static! { static ref PRIME: BigUint = BigUint::from_str_radix( "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16 ) .expect("N parse error"); } #[derive(Clone, Debug)] pub struct Share { pub x: BigUint, pub y: BigUint, } #[derive(Clone, Debug, Serialize, Deserialize)] pub struct ShareStore { pub x: String, pub y: String, } impl From for ShareStore { fn from(share: Share) -> Self { ShareStore { x: hex::encode(share.x.to_bytes_be()), y: hex::encode(share.y.to_bytes_be()), } } } impl From for ShareStore { fn from(share: &Share) -> Self { ShareStore { x: hex::encode(share.x.to_bytes_be()), y: hex::encode(share.y.to_bytes_be()), } } } pub struct Polynomial { prime: BigUint, } impl Polynomial { pub(crate) fn new() -> Self { Polynomial { prime: PRIME.clone(), } } // Calculates the modular multiplicative inverse of `a` modulo `m` using Fermat's Little Theorem. fn mod_inverse(&self, a: &BigUint, m: &BigUint) -> BigUint { a.modpow(&(m - 2u32), m) } // Generates a random polynomial of a given degree with the secret as the constant term. fn random_polynomial(&self, degree: usize, secret: &BigUint) -> Vec { let mut coefficients = vec![secret.clone()]; for _ in 0..degree { let index = BigUint::from_bytes_be(generate_random().as_slice()); coefficients.push(index); } coefficients } // Evaluates a polynomial at a given point `x`, using Horner's method for efficient computation under a prime modulus. fn evaluate_polynomial(&self, coefficients: &[BigUint], x: &BigUint) -> BigUint { let mut result = BigUint::zero(); let mut power = BigUint::one(); for coeff in coefficients { result = (&result + (coeff * &power) % &self.prime) % &self.prime; power = (&power * x) % &self.prime; } result } // Generates `num_shares` shares from a secret, using a polynomial of degree `threshold - 1`. pub fn generate_shares( &self, secret: &BigUint, num_shares: usize, threshold: usize, ) -> Vec { let coefficients = self.random_polynomial(threshold - 1, secret); let mut shares = vec![]; for _x in 1..=num_shares { let x = BigUint::from_bytes_be(generate_random().as_slice()); let y = self.evaluate_polynomial(&coefficients, &x); shares.push(Share { x, y }); } shares } // Reconstructs the secret from a subset of shares using Lagrange interpolation in a finite field. pub fn reconstruct_secret(&self, shares: &Vec ) -> BigUint { let mut secret = BigUint::zero(); for share_i in shares { let mut numerator = BigUint::one(); let mut denominator = BigUint::one(); for share_j in shares { if share_i.x != share_j.x { numerator = (&numerator * &share_j.x) % &self.prime; let diff = if share_j.x > share_i.x { &share_j.x - &share_i.x } else { &self.prime - (&share_i.x - &share_j.x) }; denominator = (&denominator * &diff) % &self.prime; } } let lagrange = (&share_i.y * &numerator * self.mod_inverse(&denominator, &self.prime)) % &self.prime; secret = (&secret + &lagrange) % &self.prime; } secret } // Adds a new share to the existing set of shares using Lagrange interpolation in a finite field. pub fn add_share(&self, shares: &Vec ) -> Share { let new_index = BigUint::from_bytes_be(generate_random().as_slice()); let mut result = BigUint::zero(); for share_i in shares { let mut lambda = BigUint::one(); for share_j in shares { if share_i.x != share_j.x { let numerator = if new_index.clone() >= share_j.x { (new_index.clone() - &share_j.x) % &self.prime } else { (&self.prime - (&share_j.x - new_index.clone()) % &self.prime) % &self.prime }; let denominator = if share_i.x >= share_j.x { (&share_i.x - &share_j.x) % &self.prime } else { (&self.prime - (&share_j.x - &share_i.x) % &self.prime) % &self.prime }; lambda = (&lambda * &numerator * self.mod_inverse(&denominator, &self.prime)) % &self.prime; } } result = (&result + &share_i.y * &lambda) % &self.prime; } Share { x: new_index, y: result, } } } 我在这里要坦白一点：我不是数学家。虽然我试图找到尽可能多的相关信息，但事实上，这是我之前文章中改编的代码。 您可以在此处阅读有关此功能的更多信息 https://en.wikipedia.org/wiki/Lagrange_polynomial 这个结构（或类，以更方便的为准）执行我们今天描述的流程中最重要的部分 - 将 密钥分解成碎片并重新组装。 pk 创建用户 #[derive(Serialize, Deserialize)] pub struct CreateUserResponse { pub secret: String, } pub async fn users_create_handler(app_data: web::Data ) -> HttpResponse { let code = generate_code(); match create_user( CreateOrUpdateUser { secret: code.clone(), }, app_data.get_db_connection(), ) .await { Ok(_) => HttpResponse::Ok().json(CreateUserResponse { secret: code }), Err(e) => { return HttpResponse::InternalServerError().body(format!("Error creating user: {}", e)); } } } 在这里，一切都尽可能简单；我们创建一个拥有主密钥的用户来使用他的密钥。这样做是为了防止任何其他方使用我们的密钥做任何事情。理想情况下，此密钥不应以任何方式分发。 生成密钥 pub async fn keys_generate_handler(req: HttpRequest, app_data: web::Data ) -> HttpResponse { // Check if the request has a master key header let Some(Ok(master_key)) = req.headers().get(MASTER_KEY).map(|header| header.to_str()) else { return HttpResponse::Unauthorized().finish(); }; // Check if user with master key exist let user = match get_user_by_secret(&master_key, app_data.get_db_connection()).await { Ok(user) => user, Err(UserErrors::NotFound(_)) => { return HttpResponse::Unauthorized().finish(); } Err(e) => { return HttpResponse::InternalServerError().body(format!("Error getting user: {}", e)); } }; // generate random `pk` private key let private_key = generate_random(); let Ok(signer) = PrivateKeySigner::from_slice(private_key.as_slice()) else { return HttpResponse::InternalServerError().finish(); }; let secret = BigUint::from_bytes_be(private_key.as_slice()); let poly = Polynomial::new(); // divide `pk` key into 3 shares let shares = poly .generate_shares(&secret, 3, 3) .iter() .map(Into::into) .collect:: >(); // store first part at Vault let path = generate_code(); if let Err(err) = kv2::set( app_data.get_vault_client().as_ref(), "secret", &path, &shares[0], ) .await { return HttpResponse::InternalServerError().body(format!("Error setting secret: {}", err)); } // Store second part at database and path to first share let key = CreateOrUpdateKey { user_id: user.id, local_key: shares[1].y.clone(), local_index: shares[1].y.clone(), cloud_key: path, address: signer.address(), }; let key = match create_key(key, app_data.get_db_connection()).await { Ok(key) => key, Err(err) => { return HttpResponse::InternalServerError() .body(format!("Error creating key: {}", err)); } }; // Store third part at database as share let share = match create_share( CreateOrUpdateShare { secret: shares[2].y.clone(), key_id: key.id, user_index: shares[2].x.clone(), owner: SharesOwner::Admin, }, app_data.get_db_connection(), ) .await { Ok(share) => share, Err(err) => { return HttpResponse::InternalServerError() .body(format!("Error creating share: {}", err)); } }; let Ok(user_key) = hex::decode(&shares[2].y) else { return HttpResponse::InternalServerError().finish(); }; // Store log let _ = create_log( CreateLog { key_id: key.id, action: "generate_key".to_string(), data: serde_json::json!({ "user_id": user.id }), message: None, }, app_data.get_db_connection(), ) .await; // Return the key and share identifier HttpResponse::Ok().json(KeysGenerateResponse { key: STANDARD.encode(user_key), id: share.id, }) } 检查用户是否存在这样的用户，创建一个 密钥，将其分成几部分，并将它们保存在不同的地方。 pk 授予访问权限 pub async fn keys_grant_handler(req: HttpRequest, app_data: web::Data ) -> HttpResponse { // Check if the request has a master key header let Some(Ok(master_key)) = req.headers().get(MASTER_KEY).map(|header| header.to_str()) else { return HttpResponse::Unauthorized().finish(); }; // Check if a user with the master key exists let user = match get_user_by_secret(&master_key, app_data.get_db_connection()).await { Ok(user) => user, Err(UserErrors::NotFound(_)) => { return HttpResponse::Unauthorized().finish(); } Err(e) => { return HttpResponse::InternalServerError().body(format!("Error getting user: {}", e)); } }; // Check if the request has a secret key header let Some(Ok(secret_key)) = req.headers().get(SECRET_KEY).map(|header| header.to_str()) else { return HttpResponse::Unauthorized().finish(); }; let Ok(share) = STANDARD.decode(secret_key) else { return HttpResponse::Unauthorized().finish(); }; // Check if the share exists let share_value = hex::encode(share); let share = match get_share_by_secret(&share_value, app_data.get_db_connection()).await { Ok(share) => share, Err(ShareErrors::NotFound(_)) => return HttpResponse::NotFound().finish(), Err(_) => { return HttpResponse::Unauthorized().finish(); } }; if !matches!(share.status, SharesStatus::Granted) { return HttpResponse::Unauthorized().finish(); } // Get original key with necessary information let key = match get_key_by_id(&share.key_id, app_data.get_db_connection()).await { Ok(key) => key, Err(KeyErrors::NotFound(_)) => return HttpResponse::NotFound().finish(), Err(_) => { return HttpResponse::Unauthorized().finish(); } }; // Check if the key belongs to the user if key.user_id != user.id { return HttpResponse::Unauthorized().finish(); } // Get the first part of the key from Vault let Ok(cloud_secret) = kv2::read:: ( app_data.get_vault_client().as_ref(), "secret", &key.cloud_key, ) .await else { return HttpResponse::InternalServerError().finish(); }; // Combine the shares let shares = vec![ Share { x: BigUint::from_str_radix(&cloud_secret.x, 16).expect("Error parsing local index"), y: BigUint::from_str_radix(&cloud_secret.y, 16).expect("Error parsing local key"), }, Share { x: BigUint::from_str_radix(&key.local_index, 16).expect("Error parsing local index"), y: BigUint::from_str_radix(&key.local_key, 16).expect("Error parsing local key"), }, Share { x: BigUint::from_str_radix(&share.user_index, 16).expect("Error parsing user index"), y: BigUint::from_str_radix(&share_value, 16).expect("Error parsing user key"), }, ]; let sss = Polynomial::new(); // Create a new share let new_share = ShareStore::from(sss.add_share(&shares)); // Store new share into database let share = match create_share( CreateOrUpdateShare { secret: new_share.y.to_string(), key_id: key.id, user_index: new_share.x.to_string(), owner: SharesOwner::Guest, }, app_data.get_db_connection(), ) .await { Ok(share) => share, Err(err) => { return HttpResponse::InternalServerError() .body(format!("Error creating share: {}", err)); } }; let Ok(user_key) = hex::decode(&new_share.y).map(|k| STANDARD.encode(k)) else { return HttpResponse::InternalServerError().finish(); }; // Store log let _ = create_log( CreateLog { key_id: key.id, action: "grant".to_string(), data: serde_json::json!({ "user_id": user.id, "share_id": share.id, }), message: None, }, app_data.get_db_connection(), ) .await; // Return the key and share the identifier HttpResponse::Ok().json(KeysGenerateResponse { key: user_key, id: share.id, }) } 该函数的运行机制如下： 我们验证访问请求者是否拥有该共享的所有权利。 我们在这里需要密钥的原因很简单，没有它我们就无法恢复原始 密钥。创建一个额外的共享，并将其提供给用户。 pk 撤销访问权限 pub async fn keys_revoke_handler( req: HttpRequest, app_data: web::Data , body: web::Json , ) -> HttpResponse { let Some(Ok(master_key)) = req.headers().get(MASTER_KEY).map(|header| header.to_str()) else { return HttpResponse::Unauthorized().finish(); }; let user = match get_user_by_secret(&master_key, app_data.get_db_connection()).await { Ok(user) => user, Err(UserErrors::NotFound(_)) => { return HttpResponse::Unauthorized().finish(); } Err(e) => { return HttpResponse::InternalServerError().body(format!("Error getting user: {}", e)); } }; let share = match get_share_by_id(&body.id, app_data.get_db_connection()).await { Ok(share) => share, Err(ShareErrors::NotFound(_)) => return HttpResponse::NotFound().finish(), Err(_) => { return HttpResponse::Unauthorized().finish(); } }; let key = match get_key_by_id(&share.key_id, app_data.get_db_connection()).await { Ok(key) => key, Err(KeyErrors::NotFound(_)) => return HttpResponse::NotFound().finish(), Err(_) => { return HttpResponse::Unauthorized().finish(); } }; if key.user_id != user.id { return HttpResponse::Unauthorized().finish(); } if revoke_share_by_id(&share.id, app_data.get_db_connection()) .await .is_err() { return HttpResponse::InternalServerError().finish(); } let _ = create_log( CreateLog { key_id: key.id, action: "revoke".to_string(), data: serde_json::json!({ "user_id": user.id, "share_id": share.id, }), message: None, }, app_data.get_db_connection(), ) .await; HttpResponse::Ok().finish() } 在这里，我们只需要知道要撤销访问权限的共享的标识符。将来，如果我制作了一个 Web 界面，这将更容易使用。我们不需要我们的 密钥，因为我们不会在这里恢复私钥。 sk 签署讯息 #[derive(Deserialize, Serialize, Debug)] pub struct SignMessageRequest { pub message: String, } #[derive(Deserialize, Serialize, Debug)] pub struct SignMessageResponse { pub signature: String, } pub async fn sign_message_handler( app_data: web::Data , req: HttpRequest, body: web::Json , ) -> HttpResponse { // Get the `sk` key from the request headers let Some(Ok(secret_key)) = req.headers().get(SECRET_KEY).map(|header| header.to_str()) else { return HttpResponse::Unauthorized().finish(); }; // restore shares let (shares, key_id, share_id) = match restore_shares(secret_key, &app_data).await { Ok(shares) => shares, Err(e) => { return HttpResponse::BadRequest().json(json!({"error": e.to_string()})); } }; let sss = Polynomial::new(); // restore `pk` key let private_key = sss.reconstruct_secret(&shares); //sign message let Ok(signer) = PrivateKeySigner::from_slice(private_key.to_bytes_be().as_slice()) else { return HttpResponse::InternalServerError().finish(); }; let Ok(signature) = signer.sign_message(body.message.as_bytes()).await else { return HttpResponse::InternalServerError().finish(); }; // create log let _ = create_log( CreateLog { key_id, action: "sign_message".to_string(), data: json!({ "share_id": share_id, }), message: Some(body.message.clone()), }, app_data.get_db_connection(), ) .await; // return signature HttpResponse::Ok().json(SignMessageResponse { signature: hex::encode(signature.as_bytes()), }) } 收到消息，如果一切正常，则恢复私钥，并用它签署消息。 基本上，我们应用程序的主要方法已经描述完毕；出于同情，我决定不把整个代码放在这里。GitHub 上有这个，所有代码都可以 找到 =) 在那里 结论 虽然这仍然是应用程序的草案，但需要注意的是，这不仅仅是一个概念。这是一个可行的草案，显示出希望。存储库中还有集成测试，以了解其工作原理。在接下来的部分中，我计划添加交易签名，并使其使用范围受到限制。然后我可能会制作一个 Web 界面，让这个项目对普通人来说很友好。 这项开发具有相当大的使用潜力，我希望至少能透露其中的一部分；我为这些代码页和稀疏的评论道歉。我更喜欢编写代码，而不是解释我上面写的内容。我会努力变得更好，但现在这比我更强了。 此外，如果需要，欢迎对代码和 PR 进行评论 =) 祝大家一切顺利，并保管好你们的私钥。