Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Move Jwk logic to jwk.rs (#2468)
Leendert de Borst56c36b0afdd6
diff --git a/core/rust/src/crypto/jwk.rs b/core/rust/src/crypto/jwk.rsnew file mode 100644index 000000000..928044e58--- /dev/null+++ b/core/rust/src/crypto/jwk.rs@@ -0,0 +1,144 @@+//! RSA keys as JWK JSON (RFC 7517/7518), shared by the RSA-OAEP keys and the RS256 passkey keys.++use rsa::traits::{PrivateKeyParts, PublicKeyParts};+use rsa::{BigUint, RsaPrivateKey, RsaPublicKey};+use serde::{Deserialize, Serialize};+use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};++use crate::common::encoding::{base64url_decode, base64url_encode};+use crate::common::error::{VaultError, VaultResult};++/// The WebCrypto members `key_ops`, `ext` and `alg` written in front of the key; the passkey JWKs carry none.+#[derive(Clone, Copy)]+pub(crate) struct JwkUsage {+ pub key_op: &'static str,+ pub alg: &'static str,+}++/// An RSA JWK. Field order is the serialized order and part of the stored format.+#[derive(Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]+struct RsaJwk {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ key_ops: Option<Vec<String>>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ ext: Option<bool>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ alg: Option<String>,+ kty: String,+ n: String,+ e: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ d: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ p: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ q: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ dp: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ dq: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ qi: Option<String>,+}++impl RsaJwk {+ fn new(usage: Option<JwkUsage>, n: &BigUint, e: &BigUint) -> Self {+ RsaJwk {+ key_ops: usage.map(|u| vec![u.key_op.to_string()]),+ ext: usage.map(|_| true),+ alg: usage.map(|u| u.alg.to_string()),+ kty: "RSA".to_string(),+ n: encode_field(n),+ e: encode_field(e),+ d: None,+ p: None,+ q: None,+ dp: None,+ dq: None,+ qi: None,+ }+ }+}++/// The RSA public key of a JWK (public or private).+pub(crate) fn rsa_public_from_jwk(jwk: &str) -> VaultResult<RsaPublicKey> {+ let parsed = parse(jwk)?;+ RsaPublicKey::new(decode_field(&parsed.n)?, decode_field(&parsed.e)?).map_err(|e| VaultError::General(format!("Invalid RSA public key: {}", e)))+}++/// The RSA private key of a private JWK; the CRT members are recomputed, not read.+pub(crate) fn rsa_private_from_jwk(jwk: &str) -> VaultResult<RsaPrivateKey> {+ let parsed = parse(jwk)?;+ let d = parsed.d.as_deref().ok_or_else(|| VaultError::General("JWK is not a private key".to_string()))?;+ let p = parsed.p.as_deref().ok_or_else(|| VaultError::General("JWK private key is missing p".to_string()))?;+ let q = parsed.q.as_deref().ok_or_else(|| VaultError::General("JWK private key is missing q".to_string()))?;+ RsaPrivateKey::from_components(decode_field(&parsed.n)?, decode_field(&parsed.e)?, decode_field(d)?, vec![decode_field(p)?, decode_field(q)?])+ .map_err(|e| VaultError::General(format!("Invalid RSA private key: {}", e)))+}++/// A public JWK for `public`.+pub(crate) fn rsa_public_to_jwk(public: &RsaPublicKey, usage: Option<JwkUsage>) -> VaultResult<String> {+ serde_json::to_string(&RsaJwk::new(usage, public.n(), public.e())).map_err(VaultError::from)+}++/// A private JWK (with CRT members) for a two-prime `private` key.+pub(crate) fn rsa_private_to_jwk(private: &RsaPrivateKey, usage: Option<JwkUsage>) -> VaultResult<String> {+ let primes = private.primes();+ if primes.len() != 2 {+ return Err(VaultError::General("Only two-prime RSA keys can be exported as JWK".to_string()));+ }+ let qinv = private.qinv().ok_or_else(|| VaultError::General("RSA key is missing its CRT coefficient".to_string()))?;+ let qinv = qinv.to_biguint().ok_or_else(|| VaultError::General("RSA CRT coefficient is negative".to_string()))?;+ let mut jwk = RsaJwk::new(usage, private.n(), private.e());+ jwk.d = Some(encode_field(private.d()));+ jwk.p = Some(encode_field(&primes[0]));+ jwk.q = Some(encode_field(&primes[1]));+ jwk.dp = private.dp().map(encode_field);+ jwk.dq = private.dq().map(encode_field);+ jwk.qi = Some(encode_field(&qinv));+ serde_json::to_string(&jwk).map_err(VaultError::from)+}++fn parse(jwk: &str) -> VaultResult<RsaJwk> {+ let parsed: RsaJwk = serde_json::from_str(jwk).map_err(|e| VaultError::General(format!("Invalid RSA JWK: {}", e)))?;+ if parsed.kty != "RSA" {+ return Err(VaultError::General(format!("Unsupported JWK key type \"{}\"", parsed.kty)));+ }+ Ok(parsed)+}++/// A JWK integer member: unpadded base64url of the big-endian bytes.+fn decode_field(value: &str) -> VaultResult<BigUint> {+ let bytes = Zeroizing::new(base64url_decode(value).map_err(|_| VaultError::General("Invalid base64url in JWK".to_string()))?);+ Ok(BigUint::from_bytes_be(&bytes))+}++/// Encode a JWK integer member as unpadded base64url of its big-endian bytes.+fn encode_field(value: &BigUint) -> String {+ base64url_encode(&Zeroizing::new(value.to_bytes_be()))+}++#[cfg(test)]+mod tests {+ use super::*;++ /// The member order of both JWK shapes is part of the stored format.+ #[test]+ fn member_order_is_stable_with_and_without_usage() {+ let key = RsaPrivateKey::new(&mut rand_core06::OsRng, 1024).unwrap();+ let usage = JwkUsage { key_op: "decrypt", alg: "RSA-OAEP-256" };+ // Member names in written order; no JWK value contains ',' or ':'.+ let keys_of = |json: &str| -> Vec<String> { json.trim_matches(['{', '}']).split(',').filter_map(|part| part.split(':').next().filter(|s| s.starts_with('"'))).map(|s| s.trim_matches('"').to_string()).collect() };+ let with = rsa_private_to_jwk(&key, Some(usage)).unwrap();+ assert_eq!(keys_of(&with), ["key_ops", "ext", "alg", "kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"]);+ assert!(with.starts_with("{\"key_ops\":[\"decrypt\"],\"ext\":true,\"alg\":\"RSA-OAEP-256\",\"kty\":\"RSA\","));+ let without = rsa_private_to_jwk(&key, None).unwrap();+ assert_eq!(keys_of(&without), ["kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"]);+ let public = rsa_public_to_jwk(&key.to_public_key(), None).unwrap();+ assert_eq!(keys_of(&public), ["kty", "n", "e"]);++ assert_eq!(rsa_private_from_jwk(&with).unwrap(), key);+ assert_eq!(rsa_private_from_jwk(&without).unwrap(), key);+ assert_eq!(rsa_public_from_jwk(&public).unwrap(), key.to_public_key());+ }+}diff --git a/core/rust/src/crypto/mod.rs b/core/rust/src/crypto/mod.rsindex 434730cd2..dd716e9b2 100644--- a/core/rust/src/crypto/mod.rs+++ b/core/rust/src/crypto/mod.rs@@ -1,8 +1,22 @@-//! Cryptographic modules used by the clients.+//! Cryptographic modules used by the clients. Every AAD string and RSA-OAEP label lives in [`aad`].+//!+//! - [`aad`]: the associated-data and OAEP-label registry that binds each ciphertext to its slot.+//! - [`aes_gcm`]: AES-256-GCM (`aes-gcm`), random 96-bit nonce, `IV | ciphertext | tag`; every vault payload and key wrap.+//! - [`argon2`]: Argon2id (`argon2`) with a parameter floor; turns the master password into the unlock key.+//! - `jwk`: RSA keys to and from JWK JSON (`rsa`), for the OAEP keys and the RS256 passkey keys.+//! - [`key_chain`]: HKDF-SHA256 (`hkdf`) KEK and SRP input from the unlock key; KEK > Account Key > VEK, private keys.+//! - [`pin`]: PIN unlock: Argon2id + AES-256-GCM wrap of the key the host stores, with the failed-attempt policy.+//! - [`rsa_oaep`]: RSA-2048 OAEP-SHA256 (`rsa`, blinded decryption); grants and delivery keys.+//! - [`signing`]: Ed25519 (`ed25519-dalek`) account signatures over grants, public keys and invitation names.+//! - [`srp`]: SRP-6a client (`srp`, SHA-256, 2048-bit group); login without sending the password.+//! - [`tokens`]: the algorithm, key-type and KDF tokens stored or sent on the wire.+//!+//! Randomness comes from `getrandom` via `common::rng`; `rsa` and `p256` use `rand_core` `OsRng`.pub mod aad;pub mod aes_gcm;pub mod argon2;+pub(crate) mod jwk;pub mod key_chain;pub mod pin;pub mod rsa_oaep;@@ -11,23 +25,14 @@ pub mod srp;pub mod tokens;pub use aes_gcm::{- generate_key_base64, symmetric_decrypt, symmetric_decrypt_bytes, symmetric_decrypt_bytes_with_aad, symmetric_decrypt_with_aad, symmetric_encrypt, symmetric_encrypt_bytes, symmetric_encrypt_bytes_with_aad,+ generate_key_base64, symmetric_decrypt, symmetric_decrypt_bytes, symmetric_decrypt_bytes_with_aad, symmetric_decrypt_with_aad, symmetric_encrypt, symmetric_encrypt_bytes,symmetric_encrypt_raw_with_aad, symmetric_encrypt_with_aad,};-pub use pin::{pin_decrypt, pin_encrypt, pin_generate_salt, pin_is_locked, pin_register_failure, PinFailure, PIN_MAX_ATTEMPTS};pub use key_chain::{- create_account_key_hierarchy, create_account_key_hierarchy_with_key_pair, derive_kek, derive_kek_base64, derive_srp_password_hash, open_account_key_chain, open_account_private_key, open_account_signing_private_key, reencrypt_account_key, unwrap_account_key, unwrap_key, wrap_account_key, wrap_key, AccountKeyBlobs,- AccountKeyHierarchy, KeyChainError, OpenedKeyChain, ReencryptedAccountKey, SrpInputError, ENCRYPTION_TYPE_ARGON2ID, ENCRYPTION_TYPE_ARGON2ID_HKDF,+ create_account_key_hierarchy, create_account_key_hierarchy_with_key_pair, derive_srp_password_hash, open_account_key_chain, open_account_private_key, open_account_signing_private_key,+ reencrypt_account_key, unwrap_account_key, unwrap_key, wrap_key, AccountKeyBlobs, AccountKeyHierarchy, KeyChainError, SrpInputError,};-pub use rsa_oaep::{- decrypt_with_private_key, decrypt_with_private_key_and_label, encrypt_with_public_key, encrypt_with_public_key_and_label, generate_rsa_key_pair, validate_rsa_key_pair, RsaKeyPair,-};--pub use signing::{generate_signing_key_pair, SigningKeyPair};+pub use pin::{pin_decrypt, pin_encrypt, pin_generate_salt, pin_is_locked, pin_register_failure, PinFailure};+pub use rsa_oaep::{decrypt_with_private_key, decrypt_with_private_key_and_label, encrypt_with_public_key, encrypt_with_public_key_and_label, generate_rsa_key_pair, RsaKeyPair};+pub use signing::generate_signing_key_pair;-pub use self::argon2::{argon2_derive_key, argon2_derive_key_bytes_from_settings, argon2_derive_key_from_settings, Argon2Error, Argon2Params};-pub use self::srp::{- srp_derive_private_key, srp_derive_session, srp_derive_session_server, srp_derive_verifier,- srp_generate_ephemeral, srp_generate_ephemeral_server, srp_generate_salt, srp_verify_session,- SrpEphemeral, SrpError, SrpSession,-};diff --git a/core/rust/src/crypto/rsa_oaep.rs b/core/rust/src/crypto/rsa_oaep.rsindex 86a082f1f..d1595aa18 100644--- a/core/rust/src/crypto/rsa_oaep.rs+++ b/core/rust/src/crypto/rsa_oaep.rs@@ -1,13 +1,13 @@//! RSA-OAEP (SHA-256) with keys carried as JWK JSON strings compatible with the WebCrypto API.-use rsa::traits::{PrivateKeyParts, PublicKeyParts};-use rsa::{BigUint, Oaep, RsaPrivateKey, RsaPublicKey};+use rsa::{Oaep, RsaPrivateKey};use serde::{Deserialize, Serialize};use sha2::Sha256;use std::fmt;-use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};+use zeroize::{Zeroize, ZeroizeOnDrop};-use crate::common::encoding::{base64_decode, base64_encode, base64url_decode, base64url_encode};+use super::jwk::{rsa_private_from_jwk, rsa_private_to_jwk, rsa_public_from_jwk, rsa_public_to_jwk, JwkUsage};+use crate::common::encoding::{base64_decode, base64_encode};use crate::common::error::{VaultError, VaultResult};const MODULUS_BITS: usize = 2048;@@ -26,42 +26,20 @@ impl fmt::Debug for RsaKeyPair {}}-/// The JWK fields WebCrypto emits for an RSA-OAEP-256 key.-#[derive(Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]-struct RsaJwk {- #[serde(default)]- key_ops: Vec<String>,- #[serde(default)]- ext: bool,- #[serde(default)]- alg: String,- kty: String,- n: String,- e: String,- #[serde(skip_serializing_if = "Option::is_none")]- d: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- p: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- q: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- dp: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- dq: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- qi: Option<String>,-}+/// WebCrypto's JWK members for the public and private halves of an RSA-OAEP-256 key.+const OAEP_PUBLIC: JwkUsage = JwkUsage { key_op: "encrypt", alg: "RSA-OAEP-256" };+const OAEP_PRIVATE: JwkUsage = JwkUsage { key_op: "decrypt", alg: "RSA-OAEP-256" };/// Generate a 2048-bit RSA key pair for RSA-OAEP-256 grants.pub fn generate_rsa_key_pair() -> VaultResult<RsaKeyPair> {let private = RsaPrivateKey::new(&mut rand_core06::OsRng, MODULUS_BITS).map_err(|e| VaultError::General(format!("RSA key generation failed: {}", e)))?;let public = private.to_public_key();- Ok(RsaKeyPair { public_key: public_to_jwk(&public)?, private_key: private_to_jwk(&private)? })+ Ok(RsaKeyPair { public_key: rsa_public_to_jwk(&public, Some(OAEP_PUBLIC))?, private_key: rsa_private_to_jwk(&private, Some(OAEP_PRIVATE))? })}/// Check that a key pair generated elsewhere (WebCrypto) is a valid private key whose public half matches.pub fn validate_rsa_key_pair(key_pair: &RsaKeyPair) -> VaultResult<()> {- if private_from_jwk(&key_pair.private_key)?.to_public_key() != public_from_jwk(&key_pair.public_key)? {+ if rsa_private_from_jwk(&key_pair.private_key)?.to_public_key() != rsa_public_from_jwk(&key_pair.public_key)? {return Err(VaultError::General("RSA public key does not belong to the private key".to_string()));}Ok(())@@ -88,13 +66,13 @@ pub fn decrypt_with_private_key_and_label(base64_ciphertext: &str, private_key_j}fn encrypt(plaintext: &[u8], public_key_jwk: &str, padding: Oaep) -> VaultResult<String> {- let public = public_from_jwk(public_key_jwk)?;+ let public = rsa_public_from_jwk(public_key_jwk)?;let ciphertext = public.encrypt(&mut rand_core06::OsRng, padding, plaintext).map_err(|e| VaultError::General(format!("RSA-OAEP encryption failed: {}", e)))?;Ok(base64_encode(&ciphertext))}fn decrypt(base64_ciphertext: &str, private_key_jwk: &str, padding: Oaep) -> VaultResult<Vec<u8>> {- let private = private_from_jwk(private_key_jwk)?;+ let private = rsa_private_from_jwk(private_key_jwk)?;let ciphertext = base64_decode(base64_ciphertext)?;// Blinded: plain `decrypt` runs the exponentiation on the ciphertext as given, which leaks timing an// attacker who can submit chosen ciphertexts turns into key recovery (RUSTSEC-2023-0071, Marvin attack).@@ -108,78 +86,6 @@ fn label_text(label: &[u8]) -> VaultResult<String> {String::from_utf8(label.to_vec()).map_err(|_| VaultError::General("RSA-OAEP label must be UTF-8".to_string()))}-fn public_from_jwk(jwk: &str) -> VaultResult<RsaPublicKey> {- let parsed = parse_jwk(jwk)?;- RsaPublicKey::new(field(&parsed.n)?, field(&parsed.e)?).map_err(|e| VaultError::General(format!("Invalid RSA public key: {}", e)))-}--pub(crate) fn private_from_jwk(jwk: &str) -> VaultResult<RsaPrivateKey> {- let parsed = parse_jwk(jwk)?;- let d = parsed.d.as_deref().ok_or_else(|| VaultError::General("JWK is not a private key".to_string()))?;- let p = parsed.p.as_deref().ok_or_else(|| VaultError::General("JWK private key is missing p".to_string()))?;- let q = parsed.q.as_deref().ok_or_else(|| VaultError::General("JWK private key is missing q".to_string()))?;- RsaPrivateKey::from_components(field(&parsed.n)?, field(&parsed.e)?, field(d)?, vec![field(p)?, field(q)?])- .map_err(|e| VaultError::General(format!("Invalid RSA private key: {}", e)))-}--fn parse_jwk(jwk: &str) -> VaultResult<RsaJwk> {- let parsed: RsaJwk = serde_json::from_str(jwk).map_err(|e| VaultError::General(format!("Invalid RSA JWK: {}", e)))?;- if parsed.kty != "RSA" {- return Err(VaultError::General(format!("Unsupported JWK key type \"{}\"", parsed.kty)));- }- Ok(parsed)-}--fn field(value: &str) -> VaultResult<BigUint> {- let bytes = Zeroizing::new(base64url_decode(value).map_err(|_| VaultError::General("Invalid base64url in JWK".to_string()))?);- Ok(BigUint::from_bytes_be(&bytes))-}--fn encode(value: &BigUint) -> String {- base64url_encode(&Zeroizing::new(value.to_bytes_be()))-}--fn public_to_jwk(public: &RsaPublicKey) -> VaultResult<String> {- let jwk = RsaJwk {- key_ops: vec!["encrypt".to_string()],- ext: true,- alg: "RSA-OAEP-256".to_string(),- kty: "RSA".to_string(),- n: encode(public.n()),- e: encode(public.e()),- d: None,- p: None,- q: None,- dp: None,- dq: None,- qi: None,- };- serde_json::to_string(&jwk).map_err(VaultError::from)-}--fn private_to_jwk(private: &RsaPrivateKey) -> VaultResult<String> {- let primes = private.primes();- if primes.len() != 2 {- return Err(VaultError::General("Only two-prime RSA keys can be exported as JWK".to_string()));- }- let qinv = private.qinv().ok_or_else(|| VaultError::General("RSA key is missing its CRT coefficient".to_string()))?;- let jwk = RsaJwk {- key_ops: vec!["decrypt".to_string()],- ext: true,- alg: "RSA-OAEP-256".to_string(),- kty: "RSA".to_string(),- n: encode(private.n()),- e: encode(private.e()),- d: Some(encode(private.d())),- p: Some(encode(&primes[0])),- q: Some(encode(&primes[1])),- dp: private.dp().map(encode),- dq: private.dq().map(encode),- qi: Some(encode(&qinv.to_biguint().ok_or_else(|| VaultError::General("RSA CRT coefficient is negative".to_string()))?)),- };- serde_json::to_string(&jwk).map_err(VaultError::from)-}-#[cfg(test)]mod tests {use super::*;diff --git a/core/rust/src/passkey/keys.rs b/core/rust/src/passkey/keys.rsindex c96f708ec..97b10bfcc 100644--- a/core/rust/src/passkey/keys.rs+++ b/core/rust/src/passkey/keys.rs@@ -3,8 +3,8 @@use p256::ecdsa::signature::Signer;use p256::ecdsa::{Signature, SigningKey};use p256::pkcs8::EncodePublicKey;-use rsa::traits::{PrivateKeyParts, PublicKeyParts};-use rsa::{BigUint, Pkcs1v15Sign, RsaPrivateKey};+use rsa::traits::PublicKeyParts;+use rsa::{Pkcs1v15Sign, RsaPrivateKey};use serde::{Deserialize, Serialize};use sha2::{Digest, Sha256};use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};@@ -13,7 +13,7 @@ use super::cbor;use super::{ALG_ES256, ALG_RS256};use crate::common::encoding::{base64url_decode, base64url_encode};use crate::common::error::{VaultError, VaultResult};-use crate::crypto::rsa_oaep::private_from_jwk;+use crate::crypto::jwk::{rsa_private_from_jwk, rsa_private_to_jwk, rsa_public_to_jwk};const RSA_MODULUS_BITS: usize = 2048;@@ -26,7 +26,7 @@ pub(super) struct GeneratedKey {pub cose_public_key: Vec<u8>,}-/// The JWK of a passkey key, EC or RSA. Unknown members (WebCrypto's `alg`, `ext`, `key_ops`) are ignored on read.+/// The JWK of an EC passkey key, also read for the `kty` of an RSA one. Unknown members are ignored on read.#[derive(Default, Clone, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]struct PasskeyJwk {#[serde(default)]@@ -38,21 +38,7 @@ struct PasskeyJwk {#[serde(skip_serializing_if = "Option::is_none")]y: Option<String>,#[serde(skip_serializing_if = "Option::is_none")]- n: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- e: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]d: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- p: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- q: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- dp: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- dq: Option<String>,- #[serde(skip_serializing_if = "Option::is_none")]- qi: Option<String>,}/// Generate a key pair for a COSE algorithm the authenticator supports.@@ -69,7 +55,7 @@ pub(super) fn sign(private_key_jwk: &str, data: &[u8]) -> VaultResult<Vec<u8>> {let jwk: PasskeyJwk = serde_json::from_str(private_key_jwk).map_err(|e| VaultError::General(format!("Invalid passkey JWK: {e}")))?;match jwk.kty.as_str() {"RSA" => {- let key = private_from_jwk(private_key_jwk)?;+ let key = rsa_private_from_jwk(private_key_jwk)?;let digest = Sha256::digest(data);key.sign(Pkcs1v15Sign::new::<Sha256>(), &digest).map_err(|e| VaultError::General(format!("RS256 signing failed: {e}")))}@@ -106,26 +92,12 @@ fn generate_es256() -> VaultResult<GeneratedKey> {fn generate_rs256() -> VaultResult<GeneratedKey> {let key = RsaPrivateKey::new(&mut rand_core06::OsRng, RSA_MODULUS_BITS).map_err(|e| VaultError::General(format!("RSA key generation failed: {e}")))?;- let primes = key.primes();- let qinv = key.qinv().and_then(|qinv| qinv.to_biguint()).ok_or_else(|| VaultError::General("RSA key has no CRT coefficient".to_string()))?;let (n, e) = (key.n().to_bytes_be(), key.e().to_bytes_be());- let mut public = PasskeyJwk::default();- public.kty = "RSA".into();- public.n = Some(base64url_encode(&n));- public.e = Some(base64url_encode(&e));- let mut private = public.clone();- private.d = Some(encode(key.d()));- private.p = Some(encode(&primes[0]));- private.q = Some(encode(&primes[1]));- private.dp = key.dp().map(encode);- private.dq = key.dq().map(encode);- private.qi = Some(encode(&qinv));-// COSE_Key RSA (RFC 8230): {1: 3 (kty RSA), 3: -257 (alg RS256), -1: n, -2: e}let cose_public_key = cbor::map(&[(cbor::int(1), cbor::int(3)), (cbor::int(3), cbor::int(ALG_RS256)), (cbor::int(-1), cbor::bytes(&n)), (cbor::int(-2), cbor::bytes(&e))]);let public_key_spki = key.to_public_key().to_public_key_der().map_err(|e| VaultError::General(format!("RSA SPKI encoding failed: {e}")))?.into_vec();- Ok(GeneratedKey { public_key_jwk: to_json(&public)?, public_key_spki, private_key_jwk: to_json(&private)?, cose_public_key })+ Ok(GeneratedKey { public_key_jwk: rsa_public_to_jwk(&key.to_public_key(), None)?, public_key_spki, private_key_jwk: rsa_private_to_jwk(&key, None)?, cose_public_key })}/// The P-256 signing key of a private scalar, left-padded to 32 bytes: some stored JWKs dropped leading zero bytes.@@ -138,10 +110,6 @@ fn signing_key_from_scalar(d: &[u8]) -> VaultResult<SigningKey> {SigningKey::from_bytes(padded.as_slice().into()).map_err(|_| VaultError::General("Invalid P-256 private key".to_string()))}-fn encode(value: &BigUint) -> String {- base64url_encode(&Zeroizing::new(value.to_bytes_be()))-}-fn to_json(jwk: &PasskeyJwk) -> VaultResult<String> {serde_json::to_string(jwk).map_err(VaultError::from)}