Skip to content

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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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)
}