Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
//! 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()))
}