use kms_client::InMemoryDeviceSigner;
use crate::test_fixtures::{
make_signing_key, mint_jwt, sign_chain_entry, sign_genesis, DeviceKey, IdentityFixture,
};
use crate::{Authenticator, RpError, VerifyError, VerifyParams};
use mid_issuer::{
build_mid_jwt, AttestedBy, ClaimRequest, ClaimValue, EmbeddedGenesisRoster,
EmbeddedRosterChainEntry, IdentitySnapshot, MidIssuerError, MidJwtPayload, RpRequest,
VerificationMethod,
};
use std::collections::BTreeMap;
const RP: &str = "https://acme.com";
const EPOCH: u64 = 1_759_190_400;
const IAT: u64 = EPOCH + 60;
const NOW: u64 = IAT + 10;
const ROOT_KID: &str = "device-0";
struct Person {
identity: IdentityFixture,
alienware: DeviceKey,
macbook: DeviceKey,
}
impl Person {
fn new() -> Self {
Self {
identity: IdentityFixture::new("vault-derived-root", ROOT_KID),
alienware: DeviceKey::new("m5-alienware", "device-alienware"),
macbook: DeviceKey::new("m5-macbook", "device-macbook"),
}
}
fn did(&self) -> String {
self.identity.did()
}
fn root_vm(&self) -> VerificationMethod {
self.identity.vm_for(&self.identity.genesis)
}
fn canonical_genesis(&self) -> EmbeddedGenesisRoster {
let mut genesis = EmbeddedGenesisRoster {
version: 1,
did: self.did(),
verification_methods: vec![self.root_vm()],
signed_at: EPOCH,
self_signed_by_genesis_key: String::new(),
};
genesis.self_signed_by_genesis_key =
sign_genesis(&genesis, &self.identity.genesis.signing_key);
genesis
}
fn link(
&self,
version: u64,
new_vms: Vec<VerificationMethod>,
signer_kid: &str,
signer: &DeviceKey,
) -> EmbeddedRosterChainEntry {
let mut entry = EmbeddedRosterChainEntry {
version,
did: self.did(),
verification_methods: new_vms,
signed_at: EPOCH + 100 * version,
signed_by_signer_in_prior_roster: String::new(),
signer_kid: signer_kid.to_string(),
};
entry.signed_by_signer_in_prior_roster = sign_chain_entry(&entry, &signer.signing_key);
entry
}
fn v2_root_adds_both(&self) -> EmbeddedRosterChainEntry {
self.link(
2,
vec![
self.root_vm(),
self.identity.vm_for(&self.alienware),
self.identity.vm_for(&self.macbook),
],
ROOT_KID,
&self.identity.genesis,
)
}
fn v3_alienware_revokes_macbook(&self) -> EmbeddedRosterChainEntry {
self.link(
3,
vec![self.root_vm(), self.identity.vm_for(&self.alienware)],
"device-alienware",
&self.alienware,
)
}
fn v4_alienware_retires_root(&self) -> EmbeddedRosterChainEntry {
self.link(
4,
vec![self.identity.vm_for(&self.alienware)],
"device-alienware",
&self.alienware,
)
}
fn snapshot(&self, chain: Vec<EmbeddedRosterChainEntry>, device: &DeviceKey) -> IdentitySnapshot {
let mut approved = BTreeMap::new();
approved.insert(
"did".into(),
ClaimValue {
value: serde_json::Value::String(self.did()),
attested_by: AttestedBy::SelfAttested,
verified_at_signup: None,
computed_at: None,
formula_version: None,
},
);
IdentitySnapshot {
did: self.did(),
genesis_roster: self.canonical_genesis(),
roster_chain: chain,
current_verification_method: self.identity.embedded_vm_for(device),
approved_claims: approved,
}
}
fn signer_for(&self, device: &DeviceKey, seed: &str) -> InMemoryDeviceSigner {
InMemoryDeviceSigner::new(device.device_id.clone(), make_signing_key(seed))
}
fn mint_attempt(
&self,
chain: Vec<EmbeddedRosterChainEntry>,
device: &DeviceKey,
seed: &str,
) -> Result<String, MidIssuerError> {
let snapshot = self.snapshot(chain, device);
let signer = self.signer_for(device, seed);
let req = RpRequest {
rp_origin: RP.into(),
nonce: "n".into(),
claims: ClaimRequest { required: vec!["did".into()], optional: vec![], custom: BTreeMap::new() },
};
build_mid_jwt(&req, &snapshot, &signer, IAT)
}
fn forge_jwt(
&self,
chain: Vec<EmbeddedRosterChainEntry>,
device: &DeviceKey,
seed: &str,
nonce: &str,
) -> String {
let snapshot = self.snapshot(chain, device);
let signer = self.signer_for(device, seed);
let payload = MidJwtPayload {
iss: snapshot.did.clone(),
sub: snapshot.did.clone(),
aud: RP.into(),
iat: IAT,
exp: IAT + 300,
nonce: nonce.into(),
claims: snapshot.approved_claims.clone(),
embedded_genesis_roster: snapshot.genesis_roster.clone(),
embedded_roster_chain: snapshot.roster_chain.clone(),
embedded_verification_method: snapshot.current_verification_method.clone(),
};
let payload_json = serde_json::to_vec(&payload).unwrap();
mid_issuer::jws::build_jws_compact(&payload_json, &signer).expect("raw JWS")
}
fn sign_in(
&self,
auth: &Authenticator,
chain: Vec<EmbeddedRosterChainEntry>,
device: &DeviceKey,
seed: &str,
) -> Result<crate::RpSession, RpError> {
let snapshot = self.snapshot(chain, device);
let signer = self.signer_for(device, seed);
let nonce = auth.issue_nonce(NOW).unwrap();
let jwt = mint_jwt(&snapshot, &signer, RP, &nonce, IAT);
auth.authenticate(&jwt, &VerifyParams::new(RP, &nonce, NOW))
}
}
#[test]
fn two_devices_authenticate_at_one_relying_party_on_one_anchor() {
let p = Person::new();
let auth = Authenticator::in_memory();
let chain = vec![p.v2_root_adds_both()];
let a = p
.sign_in(&auth, chain.clone(), &p.alienware, "m5-alienware")
.expect("the Alienware signs in under device-alienware");
let b = p
.sign_in(&auth, chain.clone(), &p.macbook, "m5-macbook")
.expect("the MacBook signs in under device-macbook, on the anchor the Alienware set");
assert_eq!(a.did, p.did());
assert_eq!(b.did, p.did());
assert_eq!(a.current_version, 2);
assert_eq!(b.current_version, 2);
let r = p
.sign_in(&auth, chain, &p.identity.genesis, "vault-derived-root")
.expect("the root signs as device-0 until retired");
assert_eq!(r.current_version, 2);
}
#[test]
fn a_device_behind_the_roster_head_reads_as_a_rollback() {
let p = Person::new();
let auth = Authenticator::in_memory();
p.sign_in(&auth, vec![p.v2_root_adds_both()], &p.alienware, "m5-alienware")
.expect("v2 seen");
let err = p
.sign_in(&auth, vec![], &p.identity.genesis, "vault-derived-root")
.unwrap_err();
assert!(
matches!(err, RpError::Rollback { presented: 1, last_seen: 2, .. }),
"got {err:?}"
);
}
#[test]
fn a_revoked_device_is_refused_and_its_old_head_is_a_rollback() {
let p = Person::new();
let auth = Authenticator::in_memory();
let v2 = p.v2_root_adds_both();
let v3 = p.v3_alienware_revokes_macbook();
p.sign_in(&auth, vec![v2.clone()], &p.macbook, "m5-macbook")
.expect("the MacBook was rostered at v2");
let a = p
.sign_in(&auth, vec![v2.clone(), v3.clone()], &p.alienware, "m5-alienware")
.expect("a device-signed removal verifies");
assert_eq!(a.current_version, 3);
let err = p
.mint_attempt(vec![v2.clone(), v3.clone()], &p.macbook, "m5-macbook")
.unwrap_err();
assert!(matches!(err, MidIssuerError::SignerNotInHeadRoster(_)), "got {err:?}");
let nonce = auth.issue_nonce(NOW).unwrap();
let jwt = p.forge_jwt(vec![v2.clone(), v3.clone()], &p.macbook, "m5-macbook", &nonce);
let err = auth
.authenticate(&jwt, &VerifyParams::new(RP, &nonce, NOW))
.unwrap_err();
assert!(
matches!(err, RpError::Verify(VerifyError::CurrentVmNotInHeadRoster { .. })),
"got {err:?}"
);
let err = p
.sign_in(&auth, vec![v2.clone()], &p.macbook, "m5-macbook")
.unwrap_err();
assert!(
matches!(err, RpError::Rollback { presented: 2, last_seen: 3, .. }),
"got {err:?}"
);
let forged = p.link(
4,
vec![p.root_vm(), p.identity.vm_for(&p.alienware), p.identity.vm_for(&p.macbook)],
"device-macbook",
&p.macbook,
);
let err = p
.sign_in(&auth, vec![v2, v3, forged], &p.macbook, "m5-macbook")
.unwrap_err();
assert!(
matches!(err, RpError::Verify(VerifyError::ChainSignerNotInPriorRoster { .. })),
"got {err:?}"
);
}
#[test]
fn after_root_retirement_the_vault_alone_cannot_sign() {
let p = Person::new();
let auth = Authenticator::in_memory();
let v2 = p.v2_root_adds_both();
let v3 = p.v3_alienware_revokes_macbook();
let v4 = p.v4_alienware_retires_root();
let chain = vec![v2, v3, v4];
let a = p
.sign_in(&auth, chain.clone(), &p.alienware, "m5-alienware")
.expect("the rostered device signs in after retirement");
assert_eq!(a.current_version, 4);
let err = p
.mint_attempt(chain.clone(), &p.identity.genesis, "vault-derived-root")
.unwrap_err();
assert!(matches!(err, MidIssuerError::SignerNotInHeadRoster(_)), "got {err:?}");
let nonce = auth.issue_nonce(NOW).unwrap();
let jwt = p.forge_jwt(chain.clone(), &p.identity.genesis, "vault-derived-root", &nonce);
let err = auth
.authenticate(&jwt, &VerifyParams::new(RP, &nonce, NOW))
.unwrap_err();
assert!(
matches!(err, RpError::Verify(VerifyError::CurrentVmNotInHeadRoster { .. })),
"a vault without a rostered device key cannot sign in: got {err:?}"
);
let err = p
.sign_in(&auth, chain[..2].to_vec(), &p.identity.genesis, "vault-derived-root")
.unwrap_err();
assert!(
matches!(err, RpError::Rollback { presented: 3, last_seen: 4, .. }),
"got {err:?}"
);
let mut readd = chain.clone();
readd.push(p.link(
5,
vec![p.identity.vm_for(&p.alienware), p.root_vm()],
ROOT_KID,
&p.identity.genesis,
));
let err = p
.sign_in(&auth, readd, &p.identity.genesis, "vault-derived-root")
.unwrap_err();
assert!(
matches!(err, RpError::Verify(VerifyError::ChainSignerNotInPriorRoster { .. })),
"got {err:?}"
);
let mut readmit = chain;
readmit.push(p.link(
5,
vec![p.identity.vm_for(&p.alienware), p.identity.vm_for(&p.macbook)],
"device-alienware",
&p.alienware,
));
let b = p
.sign_in(&auth, readmit, &p.macbook, "m5-macbook")
.expect("re-admitted by a rostered device key, no root needed");
assert_eq!(b.current_version, 5);
}
#[test]
fn a_legacy_anchor_is_a_different_identity_to_the_relying_party() {
let p = Person::new();
let auth = Authenticator::in_memory();
p.sign_in(&auth, vec![], &p.identity.genesis, "vault-derived-root")
.expect("canonical genesis anchored");
let mut stale = p.snapshot(vec![], &p.identity.genesis);
stale.genesis_roster.signed_at = EPOCH - 12_345; stale.genesis_roster.self_signed_by_genesis_key =
sign_genesis(&stale.genesis_roster, &p.identity.genesis.signing_key);
let signer = p.signer_for(&p.identity.genesis, "vault-derived-root");
let nonce = auth.issue_nonce(NOW).unwrap();
let jwt = mint_jwt(&stale, &signer, RP, &nonce, IAT);
let err = auth
.authenticate(&jwt, &VerifyParams::new(RP, &nonce, NOW))
.unwrap_err();
assert!(matches!(err, RpError::GenesisMismatch { .. }), "got {err:?}");
}