use base64::Engine;
use serde::Serialize;
use sha2::{Digest, Sha256};
use std::sync::Arc;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::protocol::jwt::{JwkPublicKey, JwtHandler};
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct Jwk {
#[serde(rename = "kty")]
pub kty: String,
#[serde(rename = "use")]
pub use_: &'static str,
#[serde(rename = "alg")]
pub alg: String,
#[serde(rename = "kid")]
pub kid: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub n: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub e: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub crv: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub x: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub y: Option<String>,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct JwkSet {
pub keys: Vec<Jwk>,
}
fn thumbprint(canonical_json: &str) -> String {
let digest = Sha256::digest(canonical_json.as_bytes());
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(digest)
}
pub fn build_jwk_set(jwt_algorithm: &str, private_key_pem: &str) -> GarrisonResult<JwkSet> {
if !matches!(jwt_algorithm, "RS256" | "ES256" | "EdDSA") {
return Err(GarrisonError::Config(format!(
"jwt-jwks-unsupported-alg::{jwt_algorithm}"
)));
}
let parts = JwtHandler::from_algorithm_parts(
jwt_algorithm,
"",
Some(private_key_pem),
Some(private_key_pem),
Some(private_key_pem),
)?
.export_public_jwk_parts()?
.ok_or_else(|| GarrisonError::Internal("jwt-jwks-symmetric::".to_string()))?;
let jwk = match parts {
JwkPublicKey::Rsa { n, e } => {
let kid = thumbprint(&format!(r#"{{"e":"{e}","kty":"RSA","n":"{n}"}}"#));
Jwk {
kty: "RSA".to_string(),
use_: "sig",
alg: jwt_algorithm.to_string(),
kid,
n: Some(n),
e: Some(e),
crv: None,
x: None,
y: None,
}
},
JwkPublicKey::Ec { crv, x, y } => {
let kid = thumbprint(&format!(
r#"{{"crv":"{crv}","kty":"EC","x":"{x}","y":"{y}"}}"#
));
Jwk {
kty: "EC".to_string(),
use_: "sig",
alg: jwt_algorithm.to_string(),
kid,
n: None,
e: None,
crv: Some(crv.to_string()),
x: Some(x),
y: Some(y),
}
},
JwkPublicKey::Okp { x } => {
let kid = thumbprint(&format!(r#"{{"crv":"Ed25519","kty":"OKP","x":"{x}"}}"#));
Jwk {
kty: "OKP".to_string(),
use_: "sig",
alg: jwt_algorithm.to_string(),
kid,
n: None,
e: None,
crv: Some("Ed25519".to_string()),
x: Some(x),
y: None,
}
},
};
Ok(JwkSet { keys: vec![jwk] })
}
pub const JWKS_STATE_KEY: &str = "oauth2:jwks:state";
pub struct JwksKeystore {
dao: Arc<dyn GarrisonDao>,
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
struct JwksStateDoc {
entries: Vec<crate::protocol::jwt::KeySnapshot>,
}
impl JwksKeystore {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
pub async fn rotate(
&self,
jwt_algorithm: &str,
private_key_pem: &str,
now_secs: i64,
retention_secs: u64,
) -> GarrisonResult<crate::protocol::jwt::KeyRotationOutcome> {
if !matches!(jwt_algorithm, "RS256" | "ES256" | "EdDSA") {
return Err(GarrisonError::Config(format!(
"jwt-jwks-unsupported-alg::{jwt_algorithm}"
)));
}
let expected = self.dao.get(JWKS_STATE_KEY).await?;
let mut doc: JwksStateDoc = match &expected {
Some(raw) => serde_json::from_str(raw)
.map_err(|e| GarrisonError::Internal(format!("jwks-state-corrupt::{e}")))?,
None => JwksStateDoc {
entries: Vec::new(),
},
};
let probe = crate::protocol::jwt::JwtHandler::from_algorithm_parts(
jwt_algorithm,
"",
Some(private_key_pem),
Some(private_key_pem),
Some(private_key_pem),
)?;
let new_kid = crate::protocol::jwt::kid_for(&probe)?;
if doc.entries.iter().any(|e| e.kid == new_kid) {
return Err(GarrisonError::InvalidParam(format!(
"jwt-kid-already-registered::{new_kid}"
)));
}
let retention = i64::try_from(retention_secs).unwrap_or(i64::MAX);
for entry in doc.entries.iter_mut() {
if entry.status == crate::protocol::jwt::KeyStatus::Passive
&& now_secs.saturating_sub(entry.status_since_secs) >= retention
{
entry.status = crate::protocol::jwt::KeyStatus::Disabled;
}
}
let passive_kid = doc
.entries
.iter()
.find(|e| e.status == crate::protocol::jwt::KeyStatus::Active)
.map(|e| e.kid.clone());
for entry in doc.entries.iter_mut() {
if entry.status == crate::protocol::jwt::KeyStatus::Active {
entry.status = crate::protocol::jwt::KeyStatus::Passive;
entry.status_since_secs = now_secs;
}
}
doc.entries.push(crate::protocol::jwt::KeySnapshot {
kid: new_kid.clone(),
status: crate::protocol::jwt::KeyStatus::Active,
algorithm: jwt_algorithm.to_string(),
private_pem: private_key_pem.to_string(),
status_since_secs: now_secs,
});
let next = serde_json::to_string(&doc)
.map_err(|e| GarrisonError::Internal(format!("jwks-state-serialize::{e}")))?;
let committed = self
.dao
.compare_and_swap(JWKS_STATE_KEY, expected.as_deref(), &next, 0)
.await?;
if !committed {
return Err(GarrisonError::OAuth2(
"oauth2-server-jwks-rotation-conflict::another-instance-rotated-reload-and-retry"
.to_string(),
));
}
Ok(crate::protocol::jwt::KeyRotationOutcome {
activated_kid: new_kid,
passive_kid,
})
}
pub async fn retire_expired(
&self,
now_secs: i64,
retention_secs: u64,
) -> GarrisonResult<Vec<String>> {
let expected = self.dao.get(JWKS_STATE_KEY).await?;
let Some(raw) = expected.clone() else {
return Ok(Vec::new());
};
let mut doc: JwksStateDoc = serde_json::from_str(&raw)
.map_err(|e| GarrisonError::Internal(format!("jwks-state-corrupt::{e}")))?;
let mut retired = Vec::new();
let retention = i64::try_from(retention_secs).unwrap_or(i64::MAX);
for entry in doc.entries.iter_mut() {
if entry.status == crate::protocol::jwt::KeyStatus::Passive
&& now_secs.saturating_sub(entry.status_since_secs) >= retention
{
entry.status = crate::protocol::jwt::KeyStatus::Disabled;
retired.push(entry.kid.clone());
}
}
if retired.is_empty() {
return Ok(retired);
}
let next = serde_json::to_string(&doc)
.map_err(|e| GarrisonError::Internal(format!("jwks-state-serialize::{e}")))?;
let committed = self
.dao
.compare_and_swap(JWKS_STATE_KEY, expected.as_deref(), &next, 0)
.await?;
if !committed {
return Err(GarrisonError::OAuth2(
"oauth2-server-jwks-retirement-conflict::another-instance-rotated-retirement-deferred-to-that-rotation".to_string(),
));
}
Ok(retired)
}
pub async fn load_keystore(&self) -> GarrisonResult<crate::protocol::jwt::JwkSet> {
match self.dao.get(JWKS_STATE_KEY).await? {
Some(raw) => {
let doc: JwksStateDoc = serde_json::from_str(&raw)
.map_err(|e| GarrisonError::Internal(format!("jwks-state-corrupt::{e}")))?;
crate::protocol::jwt::JwkSet::from_snapshots(doc.entries)
},
None => Ok(crate::protocol::jwt::JwkSet::new()),
}
}
pub async fn state_raw(&self) -> GarrisonResult<Option<String>> {
self.dao.get(JWKS_STATE_KEY).await
}
pub async fn jwks_document(
&self,
now_secs: i64,
retention_secs: u64,
) -> GarrisonResult<JwkSet> {
let keystore = self.load_keystore().await?;
let mut keystore = keystore;
keystore.retire_expired(now_secs, retention_secs);
let entries = keystore.jwks_entries();
let keys = entries
.iter()
.map(|entry| match &entry.parts {
JwkPublicKey::Rsa { n, e } => Jwk {
kty: "RSA".to_string(),
use_: "sig",
alg: entry.alg.clone(),
kid: entry.kid.clone(),
n: Some(n.clone()),
e: Some(e.clone()),
crv: None,
x: None,
y: None,
},
JwkPublicKey::Ec { crv, x, y } => Jwk {
kty: "EC".to_string(),
use_: "sig",
alg: entry.alg.clone(),
kid: entry.kid.clone(),
n: None,
e: None,
crv: Some(crv.to_string()),
x: Some(x.clone()),
y: Some(y.clone()),
},
JwkPublicKey::Okp { x } => Jwk {
kty: "OKP".to_string(),
use_: "sig",
alg: entry.alg.clone(),
kid: entry.kid.clone(),
n: None,
e: None,
crv: Some("Ed25519".to_string()),
x: Some(x.clone()),
y: None,
},
})
.collect();
let doc = JwkSet { keys };
Ok(doc)
}
pub async fn sign(&self, login_id: impl Into<String>, timeout: i64) -> GarrisonResult<String> {
self.load_keystore().await?.sign(login_id, timeout)
}
}
#[cfg(test)]
mod keystore_ledger_tests {
use super::*;
use crate::dao::{GarrisonDao, InMemoryDao};
use crate::protocol::jwt::{KeySnapshot, KeyStatus};
use std::sync::Arc;
const LEDGER_RSA_PEM_1: &str = "-----BEGIN PRIVATE KEY-----
MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCpfIC0d10OgO90
LkTO2R4C+FBeNQm4qt2lgnH1zDDUT+NRW3wcZEQPxHXHZlSoK7+TEdbsMUBEoQfE
6RCs37mBe0pusLR4gSuS6nrLH8weaAs5cy8jOQNCxOGeZS3TMh4jSSxKt78e2RUP
Cwwde0jgYw779wqOvDg4rocuXFP2rtQuFu8m3AY99DGvz4clCN2lOqFF64g3/D2S
lgVUWmyz/IHXvrI1EaHK6pj3lzOu4EZzJQfvBNS6zjmh61AIQe/EXUyRKPZJjEnV
ubtPTOji+L5ndlLULJqs6xBGhaHcAbiGMHH3c+OcXnZsMmZREY2zD0wiY+RhYcBi
CmK4V2KvAgMBAAECggEAP8RlokCUpPvS2/n6jn624XQuvLskzLOQ0BBLsyifqInk
I3yRrhb1Wp9Wlu7D5EANhJZ+MAB5xzh09VuhGAHWyEYsY4gdZodm7xBEof71K+2G
Z5eUQSLWvLzZjGBSBPeCylDiFryabk9Lsoy8Aq2bZj0u6pLwiHJ9jqnvl3xKZPGW
NWBBVy4MFkzuS2QCTnVLGx+V4Uuekm0oI0tB5qCKsGMpU+bnkKJfhaAy21YIAf/y
l33h51PNi/txgcptn1+fm9uu7w0YIWc7BMqoQhjL1nPaOB/+T0aEHZkkMKGxT1rC
bFrQEZA/ottapHkPSXqD7JezCDuLB8qnIEFGpnzjVQKBgQDeSlPeluvfxkHTEmZR
CUZ8El5UAG/4Z/mJWwOpXy0WbKaHksgW0t+lSGNwMuF75ToYCJ1GroDHpxVjxCcF
KCCbYVqFtj/sGynv/sd1zZ4R0fakl/ItrOxLcMHdtpn37IpdTUXlXiiQapfZRJDV
eG9DA9Wrge6QGpgeV5IDwPmv7QKBgQDDMDznNzZwv7Uv+Cdde8Ce5bAkFhkfvF7E
jdVn2g3ZgB9/8fnGHdA0cGH5tzrLOmU/9nZcTFQja/3skzJwQ5WTFICl4ka2LGBt
A/Dv1xDgA2p3asZvtzvfSuQB3d3N24LHc2WbABCQjBNQCuQXrLwWYK1Qvx8YyGcb
PShEjmqxiwKBgEG1vRcmi/FpXNn1LXO1BzX0BBhWzMKkkbpNwkZWETD4yz12YVmF
2oC0ZlirYcZLG6IxIbTcLstWE9ebC2HV29WysJyoJDs6SGpeaT3km15vL7a2B+wC
mxMt8NEGgnssXDZ6ejf0Xo9aQysBvsKryFAKGSaK0SeeBOurPUmIyQZ9AoGAWA8o
OuxG7GEhHk4nfF57jXR0niM2HIJAgw62K89NlkXecDu8AyyqJS5alW2b4dormcrY
pVVuVDjBa30RMWLcVWnXjH9khYXJzwULKzltDJOd8dhDRF13bor8CPeOvPP+sXsX
aPGDh6Mah28Sbrfod3QQXTCMmAK5ualCxIM4EXcCgYA8rN6qszVmCuxJNDaW4lWD
E74zsDrDRo+3K8CM/XqY7P2fPiYOChb7/mQ8TiPovXVtI76WwtbcZ1NH+07pDg07
ef2ciVLpNBQ3dV6q95yzIOfXwqJyePxotdB6KYLXgHKAt+HUKPrU/Sub9PE561O0
TVOiVROQ8xegHGbo4Bx/Mg==
-----END PRIVATE KEY-----
";
const LEDGER_RSA_PEM_2: &str = "-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC751S0Pf/oKnCq
AvE+iD2TB3fvkUXTiHfGgVHXfuFrVnam2DV9rPAWtzj78N/n4SzwIojGGzPFZtpd
Kw+VMWOEf0y5kTwOYEIAGJel6MPZBm8r2BqkgiDUw4usrI9BCRy9zRuDighMWoo0
r23RtOglWjwh6YbEXkg+dlaaFzuwZbtd7zOokVcd7MlXV51PRGT3HHbLekMJqKjM
+L+cN7NSoR6CsWHSqx8HlEJ8VQyNizsO1wKFo6gUSzGPeMH1uNMVxguI2OOzM8NS
8iEJmvMtVbcUxdYgIgFCol8ibBXYBsRQ02/arulEts3DoNJ/dOqt3uWaHv/+SVpc
CjdCgxdXAgMBAAECggEABSHWYG3pFXBDT4FxEWIrPF7R2cs/+v0ZOGTD1XzzrzjX
WMtC+sHEdPpgJhF4LB8sWQq4baDEkzmx8SWB8XM94pqPf+oFl+btJo+FZNSstLrG
Qo5Oe/vJ5cXJhNfZuc8D5/M4MymL/HnkmHfKKhYk2RBT4CE+uxJQKtSUnPTRfonc
v74IXU9mgrEWyhRnRLDCQTDS+MiFx+ca+Q2j3A3VXb6mLngi7+MlCTHesOrNi/h4
Krh6gXQDE3xw4oWlSy59zRXswrThFeNePbtN5suqHrGfhAJqvcVTuJRNPBL1OhYL
z9Fw+i5ypa0IFiiWmzIdTf6Z8fWAIRa16Gi7HofgYQKBgQDyasNqMmH2SJZ0X5Sk
RNsrHXlCVHdofP7B/w1mRXdXQN7bEdt+TkgHBOqO+005kHqcpjnm8GfKwaTVo9UK
cpYYDg11mBTULFn8BFKMH+MEzYTjKrHjA62DlM9PfdmKjPDXqJceWG1bp6Z2d+Rd
U0TfkTQLKmWihLYTUn2+c/gIWQKBgQDGbqAv9KU/7SKiUNVfSMMw/YYBm2jjEdQb
++IQuugzg0/cTwm+5sVbdzwqqt0jihO+2KWDbEHLqRndEeRjA5hvk+qp316MaeV8
x/dySeNG/lCnobiY+9ZjF14Zmaz1jGe+oAwmqGF4beoL5hkF77tFKUQtBRzkZgFC
A7yXzdQnLwKBgQCUu/Cd7b+xLiQxzpsSlrSqJXFKwyxoTZi5SlXcU+6++CxD2RcE
zd7ff6Kyi3l8QisYhdys1v+3pUwPUG/b8yYoKCcV6XOOIpArUjObiczuG3LXNlDi
alVBkEIKEbsxiPwUNXpSwgqG27wEn9bbc8WkLiDyYNbu+eIExO4ltl2OMQKBgHYk
KTVEGBruab9wFwmq/aOuXdmZGKKQ29NpbRf+3/7DgImveSLyrLAfVnAk2JKvQ8BN
poWPr8C8xkxLucmFu306+Oz4s4cwCVT4jYe7HBkJkyWq8IgM8ICAyiK9zy9G0AG7
smBVwep8rms1LNLO/5VW02NmduQ5IyiVpvROtLA7AoGBALycmaxr5wjzgTiw0oyh
/SSBunDWL23NnXrjjnLZ9BsmglkQUvhtkaA9AquuGJA4RiVxznoQQ6iXgZV80+Ui
j3MTO7dWRoAlfHi/NMU1BNA7zXLA2xPP/ekmHfb3PwCt5AhZTl43dEL+8V3xNlxp
HxmxsMlpmvvbydfhRl3OoqMR
-----END PRIVATE KEY-----
";
const LEDGER_RSA_PEM_3: &str = "-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDMQoXOvmvs4kpj
nYshns5CYyNziLt/xBQBZtlkzY3KUuHtJMz9zK0TTz0DbhCnDCWF8tpWqxHBTtON
pMnnC6bTN4Wg/PWDn67hub23b4xAKq5qH45RmWn4a0TGTUyQktebjlCiWBlMCo43
j7FLyvGrOx3SmyUUaI5vh02Pf5Swg2CCQ69ht3L58jM6lp+jILJ4gEjNC2hmaWgH
bbYhTX5qCaPgZTndfgPXX9wkDG8jhpgRpfwmSuJ4aRiRrjvgycWuPccryX7aXiBU
c5H8rdKVgnjPTzSL8h3P/2tpZkNj5OFBZKTgmdPuwF87Mjlbr7Oi2xpCIpNpnyF1
L8G/mIIRAgMBAAECggEAY2vnzIOEbceRtN4cuC8fr1GpElXWCfELWclRfI7O+tGP
9YlpnAmxnsn9ZTuAMIcphoL4QqI+4Kw5LeMtgV/7AikuyncGG9ywV1+819ocVqlP
vwkAEXjOi2PPFITQhThsaOODHRorqgcjRSkUf9NXAWUjdX0dtcrUtbWSi4vqeGWC
O0Ni/9iWJYFjAgHu+XJgYXZtn7sJGe30PuIFmiKHfHuuM9alo6SubQ3UU80B+hQm
N4VVuYN+dYmGsekp+Ofj65mq2+WAyvHE2V9OB92L+yVY0uKZ428eXdN9ydp8kVqh
yOW2yLTq6sBNBOi/F/DMim6QrIzn6zpp0hXyc97d1wKBgQD+2qQOQ+urTE1ymdXT
C/os5kMrjsYd/rfcMaBbl4XmDE/PjlJg1Z6yVBGMmvM/shjTslcV8kgKyKf+aHm1
b3ckgu9PLtoYGX0yjeHbYCidwkjJPz8sy5pIFHslY/bGhV5RqsSPJo1aX2En0c4R
3cJHGGGn2YguQuWSOU94VTKgowKBgQDNLaS9Q08j/tiozEY23oH9i5p5iSwxc3It
hS/UwLYNFad6byRiDgVlvx+sVHZfLBsmNMlHEY+oMGocctqGAC8+a0pvtaLnU12/
GI61axWfAlCJrYs3CBOKwOH3hBM04mqPUb2ySHdlzPawpIr55jMkohuXXyw/22je
pK7iIPHZuwKBgQC+/Gi/TAUbjQXpIQHNtAcaiMDDrq4nolB00jfjC81LVeSlnXl8
mfngmAHCxggOrs/OLbL3fmagtji2/eJfppW5penjBDBqqQda0Fr2xLwLZaKYNi6I
ylfnNnoGzkAMC7xgJUJCKNj7ZcjwR1lPqElEcDAW0n0sdfOGvi4g9nAHUwKBgGIB
E1dz9zFyYXr/V+qNjfnV3QuAgiN8yWUE4Tv2cP7/AOhyfiZ4HAvlpvNhxMjhAHbX
b+0KblwgBA9irQ6kt+xQw1VopU9perX0vPXbGJDDQkUBKCY5LVxxlX3tEF+KZuve
V4X5J07xAESP0/JaCsPMyvEa/L/jxcvTTdWlduBRAoGBAPx2MMqUGXa+UZ+a0cyF
tW0xGglEWCX+e2vSNf31v4FyoGxNi6h2ap2OWEddpGttS+UbOzO9BlzcCtYJvPwW
lRVGEQXEoVyslCUwTlV8LmtrJS6Xl9YwRHmmajJMH6GJTk/CToOLIvj2bOMxHW5A
dzWfBsm+KAfTJuqbV7VnJL3G
-----END PRIVATE KEY-----
";
fn ledger() -> (JwksKeystore, Arc<InMemoryDao>) {
let dao = Arc::new(InMemoryDao::new());
(JwksKeystore::new(dao.clone()), dao)
}
#[tokio::test]
async fn rotate_bootstraps_first_active_key() {
let (ledger, _dao) = ledger();
let outcome = ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.expect("引导轮换必须成功");
assert!(outcome.passive_kid.is_none());
let keystore = ledger.load_keystore().await.unwrap();
assert_eq!(keystore.active_kid(), Some(outcome.activated_kid.as_str()));
}
#[tokio::test]
async fn rotate_passivates_old_active_key() {
let (ledger, _dao) = ledger();
let first = ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
let second = ledger
.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000)
.await
.unwrap();
assert_eq!(
second.passive_kid.as_deref(),
Some(first.activated_kid.as_str())
);
let keystore = ledger.load_keystore().await.unwrap();
assert_eq!(
keystore.status_of(&first.activated_kid),
Some(KeyStatus::Passive)
);
assert_eq!(
keystore.status_of(&second.activated_kid),
Some(KeyStatus::Active)
);
}
#[tokio::test]
async fn rotate_rejects_duplicate_kid() {
let (ledger, _dao) = ledger();
ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
let err = ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 2_000, 10_000)
.await
.expect_err("同钥重复轮换必须显性拒绝");
assert!(
matches!(err, GarrisonError::InvalidParam(ref m) if m.contains("jwt-kid-already-registered")),
"错误必须显性指明 kid 重复,实际: {err}"
);
}
struct FrozenReadDao {
frozen_state: std::sync::Mutex<String>,
inner: Arc<InMemoryDao>,
}
impl FrozenReadDao {
fn new(frozen_state: String, inner: Arc<InMemoryDao>) -> Self {
Self {
frozen_state: std::sync::Mutex::new(frozen_state),
inner,
}
}
}
#[async_trait::async_trait]
impl GarrisonDao for FrozenReadDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
if key == JWKS_STATE_KEY {
return Ok(Some(self.frozen_state.lock().unwrap().clone()));
}
self.inner.get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
self.inner.delete(key).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
self.inner.set_if_absent(key, value, ttl_seconds).await
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
self.inner.rename(old_key, new_key).await
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
self.inner.get_and_delete(key).await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
self.inner.decr(key).await
}
}
#[tokio::test]
async fn concurrent_rotations_exactly_one_wins_and_loser_sees_consistent_state() {
let (bootstrap, dao) = ledger();
bootstrap
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
let state_v1 = dao.get(JWKS_STATE_KEY).await.unwrap().unwrap();
let frozen = Arc::new(FrozenReadDao::new(state_v1.clone(), dao.clone()));
let a = JwksKeystore::new(frozen.clone());
let b = JwksKeystore::new(frozen);
let (ra, rb) = tokio::join!(
a.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000),
b.rotate("RS256", LEDGER_RSA_PEM_3, 2_000, 10_000),
);
let wins = [&ra, &rb].iter().filter(|r| r.is_ok()).count();
assert_eq!(wins, 1, "同一基线上的两并发轮换必须恰有一方成功");
let err = ra
.as_ref()
.err()
.or_else(|| rb.as_ref().err())
.expect("恰有一方失败");
assert!(
err.to_string().contains(&crate::i18n::translate_detail(
"oauth2-server-jwks-rotation-conflict",
&[("arg0", "another-instance-rotated-reload-and-retry")],
)),
"失败方错误必须显性指明 CAS 冲突,实际: {err}"
);
let winner_kid = match (ra, rb) {
(Ok(o), _) => o.activated_kid,
(_, Ok(o)) => o.activated_kid,
_ => unreachable!(),
};
let keystore = bootstrap.load_keystore().await.unwrap();
assert_eq!(keystore.active_kid(), Some(winner_kid.as_str()));
assert!(
keystore.status_of(&winner_kid).is_some(),
"胜方 kid 必须在状态中"
);
assert_eq!(
keystore
.snapshots()
.iter()
.filter(|s| s.status == KeyStatus::Active)
.count(),
1,
"并发后库内恰有一把 Active"
);
}
#[tokio::test]
async fn retire_expired_disables_aged_passive_and_removes_from_jwks() {
let (ledger, _dao) = ledger();
let first = ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
ledger
.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000)
.await
.unwrap();
let retired = ledger.retire_expired(5_000, 10_000).await.unwrap();
assert!(retired.is_empty());
assert_eq!(
ledger
.jwks_document(5_000, 10_000)
.await
.unwrap()
.keys
.len(),
2
);
let retired = ledger.retire_expired(12_000, 10_000).await.unwrap();
assert_eq!(retired, vec![first.activated_kid.clone()]);
let doc = ledger.jwks_document(12_000, 10_000).await.unwrap();
assert_eq!(doc.keys.len(), 1);
assert_ne!(
doc.keys[0].kid, first.activated_kid,
"退役 kid 必须移出 JWKS"
);
}
#[tokio::test]
async fn token_of_retired_kid_rejected_after_retention() {
let (ledger, _dao) = ledger();
ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
let old_token = ledger.sign("user-8", 3_600).await.unwrap();
ledger
.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000)
.await
.unwrap();
ledger.retire_expired(12_000, 10_000).await.unwrap();
let keystore = ledger.load_keystore().await.unwrap();
let err = keystore
.verify(&old_token)
.expect_err("退役钥的 token 必须显性拒绝");
assert!(
matches!(err, GarrisonError::InvalidToken(ref m) if m.contains("jwt-kid-retired")),
"错误必须显性指明钥已退役,实际: {err}"
);
}
#[tokio::test]
async fn rotate_rejects_symmetric_algorithm() {
let (ledger, _dao) = ledger();
let err = ledger
.rotate("HS256", "some-secret-material", 1_000, 10_000)
.await
.expect_err("对称算法必须显性拒绝");
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("jwt-jwks-unsupported-alg::HS256")),
"错误必须显性指明算法不受支持,实际: {err}"
);
}
#[tokio::test]
async fn empty_state_operations_are_noop() {
let (ledger, _dao) = ledger();
let retired = ledger.retire_expired(1_000, 10_000).await.unwrap();
assert!(retired.is_empty());
let doc = ledger.jwks_document(1_000, 10_000).await.unwrap();
assert!(doc.keys.is_empty());
}
#[tokio::test]
async fn rotate_disables_passive_key_beyond_retention() {
let (ledger, _dao) = ledger();
let first = ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
ledger
.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000)
.await
.unwrap();
ledger
.rotate("RS256", LEDGER_RSA_PEM_3, 20_000, 10_000)
.await
.unwrap();
let keystore = ledger.load_keystore().await.unwrap();
assert_eq!(
keystore.status_of(&first.activated_kid),
Some(crate::protocol::jwt::KeyStatus::Disabled),
"超期 Passive 应在轮换同批提交中转 Disabled"
);
let doc = ledger.jwks_document(20_000, 10_000).await.unwrap();
assert!(
!doc.keys.iter().any(|k| k.kid == first.activated_kid),
"Disabled 钥不得出现在发布文档"
);
}
#[tokio::test]
async fn retire_expired_reports_cas_conflict() {
let inner = Arc::new(InMemoryDao::new());
let ledger = JwksKeystore::new(inner.clone());
ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
ledger
.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000)
.await
.unwrap();
let frozen = inner.get(JWKS_STATE_KEY).await.unwrap().unwrap();
let stale = JwksKeystore::new(Arc::new(FrozenReadDao::new(frozen, inner.clone())));
ledger
.rotate("RS256", LEDGER_RSA_PEM_3, 3_000, 10_000)
.await
.unwrap();
let err = stale
.retire_expired(30_000, 10_000)
.await
.expect_err("并发轮换后退役方 CAS 必须失败");
assert!(
err.to_string().contains(&crate::i18n::translate_detail(
"oauth2-server-jwks-retirement-conflict",
&[(
"arg0",
"another-instance-rotated-retirement-deferred-to-that-rotation"
)],
)),
"失败方错误必须显性指明 CAS 冲突,实际: {err}"
);
}
#[tokio::test]
async fn frozen_read_dao_delegates_non_state_keys() {
use crate::dao::GarrisonDao;
let dao = FrozenReadDao::new("frozen".to_string(), Arc::new(InMemoryDao::new()));
dao.set("k", "v1", 60).await.unwrap();
assert_eq!(dao.get("k").await.unwrap(), Some("v1".to_string()));
assert_eq!(
dao.get(JWKS_STATE_KEY).await.unwrap(),
Some("frozen".to_string()),
"状态键恒返回冻结快照"
);
dao.update("k", "v2").await.unwrap();
assert_eq!(dao.get("k").await.unwrap(), Some("v2".to_string()));
assert!(dao
.compare_and_swap("k", Some("v2"), "v3", 60)
.await
.unwrap());
assert!(!dao
.compare_and_swap("k", Some("v2"), "v4", 60)
.await
.unwrap());
assert!(dao.set_if_absent("fresh", "1", 60).await.unwrap());
assert!(!dao.set_if_absent("fresh", "2", 60).await.unwrap());
assert_eq!(dao.incr("counter", 60).await.unwrap(), 1);
assert_eq!(dao.decr("counter").await.unwrap(), 0);
assert_eq!(
dao.get_and_delete("k").await.unwrap(),
Some("v3".to_string())
);
assert!(
dao.get("k").await.unwrap().is_none(),
"get_and_delete 应删键"
);
dao.set("old", "v", 60).await.unwrap();
dao.rename("old", "new").await.unwrap();
assert_eq!(dao.get("new").await.unwrap(), Some("v".to_string()));
dao.expire("new", 30).await.unwrap();
dao.delete("new").await.unwrap();
assert!(dao.get("new").await.unwrap().is_none());
}
#[tokio::test]
async fn corrupted_snapshot_rejected_explicitly() {
let (ledger, _dao) = ledger();
ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
let raw = _dao.get(JWKS_STATE_KEY).await.unwrap().unwrap();
let mut doc: serde_json::Value = serde_json::from_str(&raw).unwrap();
doc["entries"][0]["kid"] = serde_json::Value::String("tampered".to_string());
_dao.set(JWKS_STATE_KEY, &doc.to_string(), 0).await.unwrap();
let err = ledger
.load_keystore()
.await
.expect_err("kid 篡改必须显性拒绝");
assert!(
matches!(err, GarrisonError::InvalidParam(ref m) if m.contains("jwt-snapshot-kid-mismatch")),
"错误必须显性指明快照损坏,实际: {err}"
);
}
#[tokio::test]
async fn sign_embeds_kid_and_passive_verification_continues() {
let (ledger, _dao) = ledger();
let first = ledger
.rotate("RS256", LEDGER_RSA_PEM_1, 1_000, 10_000)
.await
.unwrap();
let old_token = ledger.sign("user-9", 3_600).await.unwrap();
ledger
.rotate("RS256", LEDGER_RSA_PEM_2, 2_000, 10_000)
.await
.unwrap();
let new_token = ledger.sign("user-9", 3_600).await.unwrap();
let old_header = jsonwebtoken::decode_header(&old_token).unwrap();
let new_header = jsonwebtoken::decode_header(&new_token).unwrap();
assert_eq!(
old_header.kid.as_deref(),
Some(first.activated_kid.as_str())
);
assert_ne!(old_header.kid, new_header.kid, "轮换后签发必须切换到新 kid");
let keystore = ledger.load_keystore().await.unwrap();
assert!(keystore.verify(&old_token).is_ok());
assert!(keystore.verify(&new_token).is_ok());
}
#[test]
fn key_snapshot_serde_roundtrip() {
let snapshot = KeySnapshot {
kid: "k".to_string(),
status: KeyStatus::Passive,
algorithm: "RS256".to_string(),
private_pem: "pem".to_string(),
status_since_secs: 1,
};
let json = serde_json::to_string(&snapshot).unwrap();
assert!(json.contains("\"status\":\"passive\""));
}
}
#[cfg(test)]
mod tests {
use super::*;
const TEST_RSA_PEM: &str = "-----BEGIN PRIVATE KEY-----
MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDMQoXOvmvs4kpj
nYshns5CYyNziLt/xBQBZtlkzY3KUuHtJMz9zK0TTz0DbhCnDCWF8tpWqxHBTtON
pMnnC6bTN4Wg/PWDn67hub23b4xAKq5qH45RmWn4a0TGTUyQktebjlCiWBlMCo43
j7FLyvGrOx3SmyUUaI5vh02Pf5Swg2CCQ69ht3L58jM6lp+jILJ4gEjNC2hmaWgH
bbYhTX5qCaPgZTndfgPXX9wkDG8jhpgRpfwmSuJ4aRiRrjvgycWuPccryX7aXiBU
c5H8rdKVgnjPTzSL8h3P/2tpZkNj5OFBZKTgmdPuwF87Mjlbr7Oi2xpCIpNpnyF1
L8G/mIIRAgMBAAECggEAY2vnzIOEbceRtN4cuC8fr1GpElXWCfELWclRfI7O+tGP
9YlpnAmxnsn9ZTuAMIcphoL4QqI+4Kw5LeMtgV/7AikuyncGG9ywV1+819ocVqlP
vwkAEXjOi2PPFITQhThsaOODHRorqgcjRSkUf9NXAWUjdX0dtcrUtbWSi4vqeGWC
O0Ni/9iWJYFjAgHu+XJgYXZtn7sJGe30PuIFmiKHfHuuM9alo6SubQ3UU80B+hQm
N4VVuYN+dYmGsekp+Ofj65mq2+WAyvHE2V9OB92L+yVY0uKZ428eXdN9ydp8kVqh
yOW2yLTq6sBNBOi/F/DMim6QrIzn6zpp0hXyc97d1wKBgQD+2qQOQ+urTE1ymdXT
C/os5kMrjsYd/rfcMaBbl4XmDE/PjlJg1Z6yVBGMmvM/shjTslcV8kgKyKf+aHm1
b3ckgu9PLtoYGX0yjeHbYCidwkjJPz8sy5pIFHslY/bGhV5RqsSPJo1aX2En0c4R
3cJHGGGn2YguQuWSOU94VTKgowKBgQDNLaS9Q08j/tiozEY23oH9i5p5iSwxc3It
hS/UwLYNFad6byRiDgVlvx+sVHZfLBsmNMlHEY+oMGocctqGAC8+a0pvtaLnU12/
GI61axWfAlCJrYs3CBOKwOH3hBM04mqPUb2ySHdlzPawpIr55jMkohuXXyw/22je
pK7iIPHZuwKBgQC+/Gi/TAUbjQXpIQHNtAcaiMDDrq4nolB00jfjC81LVeSlnXl8
mfngmAHCxggOrs/OLbL3fmagtji2/eJfppW5penjBDBqqQda0Fr2xLwLZaKYNi6I
ylfnNnoGzkAMC7xgJUJCKNj7ZcjwR1lPqElEcDAW0n0sdfOGvi4g9nAHUwKBgGIB
E1dz9zFyYXr/V+qNjfnV3QuAgiN8yWUE4Tv2cP7/AOhyfiZ4HAvlpvNhxMjhAHbX
b+0KblwgBA9irQ6kt+xQw1VopU9perX0vPXbGJDDQkUBKCY5LVxxlX3tEF+KZuve
V4X5J07xAESP0/JaCsPMyvEa/L/jxcvTTdWlduBRAoGBAPx2MMqUGXa+UZ+a0cyF
tW0xGglEWCX+e2vSNf31v4FyoGxNi6h2ap2OWEddpGttS+UbOzO9BlzcCtYJvPwW
lRVGEQXEoVyslCUwTlV8LmtrJS6Xl9YwRHmmajJMH6GJTk/CToOLIvj2bOMxHW5A
dzWfBsm+KAfTJuqbV7VnJL3G
-----END PRIVATE KEY-----
";
#[test]
fn build_jwk_set_rsa_fields_and_deterministic_kid() {
let set1 = build_jwk_set("RS256", TEST_RSA_PEM).unwrap();
let set2 = build_jwk_set("RS256", TEST_RSA_PEM).unwrap();
assert_eq!(set1.keys.len(), 1);
let jwk = &set1.keys[0];
assert_eq!(jwk.kty, "RSA");
assert_eq!(jwk.use_, "sig");
assert_eq!(jwk.alg, "RS256");
assert!(jwk.n.is_some() && jwk.e.is_some());
assert!(jwk.crv.is_none() && jwk.x.is_none() && jwk.y.is_none());
assert_eq!(jwk.kid, set2.keys[0].kid, "同密钥多次导出 kid 必须一致");
assert!(!jwk.kid.is_empty());
let json = serde_json::to_string(jwk).unwrap();
assert!(!json.contains("private"), "JWK 不得含私钥字段");
assert!(json.contains("\"use\":\"sig\"") && json.contains("\"kid\":"));
}
const TEST_EC_PEM: &str = "-----BEGIN PRIVATE KEY-----
MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgHu89Emnr1D+OpkZF
T2f/jZRjQNl9Q6AyVEnsI2rH+tihRANCAARSS8Qlg3TwbmWk6ICPdeHxy/X0LARI
FTcfYH6rUSsxJH2JD7Adnx1iw7UhnOZXVf8YOnDrqaXJkQcXNWPSUBqA
-----END PRIVATE KEY-----
";
const TEST_ED_PEM: &str = "-----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIOChr1YQD9KWBWWGBLFFjHQiHx9+OznRi69Gh25Uhv8H
-----END PRIVATE KEY-----
";
#[tokio::test]
async fn jwks_document_emits_ec_and_okp_entries() {
let ledger = JwksKeystore::new(Arc::new(crate::dao::InMemoryDao::new()));
ledger
.rotate("ES256", TEST_EC_PEM, 1_000, 10_000)
.await
.expect("EC 轮换应成功");
ledger
.rotate("EdDSA", TEST_ED_PEM, 2_000, 10_000)
.await
.expect("Ed25519 轮换应成功");
let doc = ledger.jwks_document(2_000, 10_000).await.unwrap();
let ec = doc
.keys
.iter()
.find(|k| k.kty == "EC")
.expect("应含 EC 公钥");
assert_eq!(ec.alg, "ES256");
assert_eq!(ec.crv.as_deref(), Some("P-256"));
assert!(ec.x.is_some() && ec.y.is_some(), "EC 应含 x/y");
assert!(ec.n.is_none() && ec.e.is_none(), "EC 不得含 RSA 成分");
let okp = doc
.keys
.iter()
.find(|k| k.kty == "OKP")
.expect("应含 OKP 公钥");
assert_eq!(okp.alg, "EdDSA");
assert_eq!(okp.crv.as_deref(), Some("Ed25519"));
assert!(okp.x.is_some(), "OKP 应含 x");
assert!(okp.y.is_none() && okp.n.is_none() && okp.e.is_none());
}
#[test]
fn build_jwk_set_ec_produces_ec_key() {
let doc = build_jwk_set("ES256", TEST_EC_PEM).unwrap();
assert_eq!(doc.keys.len(), 1);
let k = &doc.keys[0];
assert_eq!(k.kty, "EC");
assert_eq!(k.alg, "ES256");
assert_eq!(k.crv.as_deref(), Some("P-256"));
assert!(k.x.is_some() && k.y.is_some(), "EC JWK 应含 x/y");
assert!(k.n.is_none() && k.e.is_none(), "EC JWK 不得含 RSA 成分");
assert!(!k.kid.is_empty(), "kid 应为 RFC 7638 thumbprint");
}
#[test]
fn build_jwk_set_ed_produces_okp_key() {
let doc = build_jwk_set("EdDSA", TEST_ED_PEM).unwrap();
assert_eq!(doc.keys.len(), 1);
let k = &doc.keys[0];
assert_eq!(k.kty, "OKP");
assert_eq!(k.alg, "EdDSA");
assert_eq!(k.crv.as_deref(), Some("Ed25519"));
assert!(k.x.is_some(), "OKP JWK 应含 x");
assert!(k.n.is_none() && k.e.is_none() && k.y.is_none());
}
#[test]
fn build_jwk_set_rsa_produces_rsa_key() {
let doc = build_jwk_set("RS256", TEST_RSA_PEM).unwrap();
assert_eq!(doc.keys.len(), 1);
let k = &doc.keys[0];
assert_eq!(k.kty, "RSA");
assert!(k.n.is_some() && k.e.is_some(), "RSA JWK 应含 n/e");
}
#[test]
fn build_jwk_set_rejects_symmetric_algorithm() {
let err = build_jwk_set("HS256", TEST_RSA_PEM).unwrap_err();
assert!(
matches!(err, GarrisonError::Config(ref m) if m.contains("jwt-jwks-unsupported-alg")),
"HS256 应报 jwt-jwks-unsupported-alg,实际: {err:?}"
);
}
#[test]
fn build_jwk_set_rejects_invalid_pem() {
assert!(build_jwk_set("RS256", "not-a-pem").is_err());
}
}