const PEM_HEADER: &str = "-----BEGIN MACHINE FILE-----";
const PEM_FOOTER: &str = "-----END MACHINE FILE-----";
const ALG_VERSION_MARKER: &str = "v2";
const NONCE_LEN: usize = 12;
const GCM_TAG_LEN: usize = 16;
#[derive(Debug, Clone, serde::Deserialize)]
pub struct MachineFileResource {
pub id: uuid::Uuid,
#[serde(rename = "type")]
pub resource_type: String,
pub attributes: MachineFile,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct MachineFile {
pub certificate: String,
pub algorithm: String,
pub includes: Vec<String>,
pub ttl: Option<i64>,
pub expiry: Option<chrono::DateTime<chrono::Utc>>,
pub issued: chrono::DateTime<chrono::Utc>,
}
pub const MAX_TTL_SECS: u64 = 365 * 24 * 3600;
pub fn check_ttl(ttl: u64) -> Result<(), crate::error::CheckoutError> {
if ttl == 0 || ttl > MAX_TTL_SECS {
return Err(crate::error::CheckoutError::TtlOutOfRange(format!(
"must be > 0 and <= {MAX_TTL_SECS}, got {ttl}"
)));
}
Ok(())
}
pub type MachineFileClaims = crate::checkout::license_file::LicenseFileClaims;
#[derive(Debug, Clone)]
pub struct VerifiedMachineFile {
pub machine: crate::models::machine::MachineResource,
pub claims: MachineFileClaims,
}
#[derive(Debug, serde::Deserialize)]
struct CertPayload {
enc: String,
sig: String,
alg: String,
}
#[derive(Debug, serde::Deserialize)]
struct DataPayload {
data: crate::models::machine::MachineResource,
meta: MachineFileClaims,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EncEncoding {
Plain,
Aes256Gcm,
}
fn scheme_alg_suffix(scheme: crate::models::policy::LicenseScheme) -> &'static str {
use crate::models::policy::LicenseScheme;
match scheme {
LicenseScheme::Ed25519Sign => "ed25519",
LicenseScheme::Rsa2048Pkcs1Sign | LicenseScheme::Rsa2048JwtRs256 => "rsa-sha256",
LicenseScheme::Rsa2048Pkcs1PssSign => "rsa-pss-sha256",
LicenseScheme::EcdsaP256Sign => "ecdsa-p256",
}
}
fn parse_alg(alg: &str) -> Result<(EncEncoding, &str), crate::error::CheckoutError> {
let unsupported = || crate::error::CheckoutError::UnsupportedAlgorithm(alg.to_string());
let (encoding, rest) = alg.split_once('+').ok_or_else(unsupported)?;
let (signing_suffix, version) = rest.rsplit_once('+').ok_or_else(unsupported)?;
if version != ALG_VERSION_MARKER {
return Err(unsupported());
}
if signing_suffix.is_empty() || signing_suffix.contains('+') {
return Err(unsupported());
}
let encoding = match encoding {
"base64" => EncEncoding::Plain,
"aes-256-gcm" => EncEncoding::Aes256Gcm,
_ => return Err(unsupported()),
};
Ok((encoding, signing_suffix))
}
pub fn verify_machine_file(
pem: &str,
scheme: crate::models::policy::LicenseScheme,
pubkey: &[u8],
license_key: Option<&str>,
fingerprint: Option<&str>,
) -> Result<crate::models::machine::MachineResource, crate::error::CheckoutError> {
verify_machine_file_with_claims(pem, scheme, pubkey, license_key, fingerprint)
.map(|v| v.machine)
}
pub fn verify_machine_file_with_claims(
pem: &str,
scheme: crate::models::policy::LicenseScheme,
pubkey: &[u8],
license_key: Option<&str>,
fingerprint: Option<&str>,
) -> Result<VerifiedMachineFile, crate::error::CheckoutError> {
verify_machine_file_at(
pem,
scheme,
pubkey,
license_key,
fingerprint,
crate::checkout::license_file::unix_now(),
)
}
pub fn verify_machine_file_at(
pem: &str,
scheme: crate::models::policy::LicenseScheme,
pubkey: &[u8],
license_key: Option<&str>,
fingerprint: Option<&str>,
now_unix: i64,
) -> Result<VerifiedMachineFile, crate::error::CheckoutError> {
use crate::models::policy::LicenseScheme;
if scheme == LicenseScheme::Rsa2048JwtRs256 {
return Err(crate::error::CheckoutError::SchemeNotSupported);
}
let cert = parse_envelope(pem)?;
let (encoding, signing_suffix) = parse_alg(&cert.alg)?;
let expected_suffix = scheme_alg_suffix(scheme);
if signing_suffix != expected_suffix {
return Err(crate::error::CheckoutError::UnsupportedAlgorithm(format!(
"file declares alg suffix {signing_suffix:?}, expected {expected_suffix:?} for the supplied scheme"
)));
}
let sig_bytes = decode_signature(&cert)?;
match scheme {
LicenseScheme::Ed25519Sign => {
let pubkey32: [u8; 32] = pubkey
.try_into()
.map_err(|_| crate::error::CryptoError::InvalidKey)?;
crate::crypto::ed25519::verify(&pubkey32, cert.enc.as_bytes(), &sig_bytes)?;
}
LicenseScheme::Rsa2048Pkcs1Sign => {
crate::crypto::rsa::verify_pkcs1(pubkey, cert.enc.as_bytes(), &sig_bytes)?;
}
LicenseScheme::Rsa2048Pkcs1PssSign => {
crate::crypto::rsa::verify_pss(pubkey, cert.enc.as_bytes(), &sig_bytes)?;
}
LicenseScheme::EcdsaP256Sign => {
crate::crypto::ecdsa::verify(pubkey, cert.enc.as_bytes(), &sig_bytes)?;
}
LicenseScheme::Rsa2048JwtRs256 => {
return Err(crate::error::CheckoutError::SchemeNotSupported);
}
}
let plaintext = decode_plaintext(&cert, encoding, license_key, fingerprint)?;
finish(&plaintext, now_unix)
}
pub fn verify_machine_file_with_key_set(
pem: &str,
keys: &crate::checkout::key_set::SigningKeySet,
license_key: Option<&str>,
fingerprint: Option<&str>,
) -> Result<VerifiedMachineFile, crate::error::CheckoutError> {
verify_machine_file_with_key_set_at(
pem,
keys,
license_key,
fingerprint,
crate::checkout::license_file::unix_now(),
)
}
pub fn verify_machine_file_with_key_set_at(
pem: &str,
keys: &crate::checkout::key_set::SigningKeySet,
license_key: Option<&str>,
fingerprint: Option<&str>,
now_unix: i64,
) -> Result<VerifiedMachineFile, crate::error::CheckoutError> {
use crate::models::policy::LicenseScheme;
let cert = parse_envelope(pem)?;
let (encoding, signing_suffix) = parse_alg(&cert.alg)?;
let expected_suffix = scheme_alg_suffix(LicenseScheme::Ed25519Sign);
if signing_suffix != expected_suffix {
return Err(crate::error::CheckoutError::UnsupportedAlgorithm(format!(
"file declares alg suffix {signing_suffix:?}; a signing key set can only verify {expected_suffix:?} machine files"
)));
}
let sig_bytes = decode_signature(&cert)?;
match keys.find_verifying_key(cert.enc.as_bytes(), &sig_bytes)? {
Some(_verified_key) => {
let plaintext = decode_plaintext(&cert, encoding, license_key, fingerprint)?;
finish(&plaintext, now_unix)
}
None => {
Err(keys.label_failure(decode_plaintext(&cert, encoding, license_key, fingerprint)))
}
}
}
fn decode_signature(cert: &CertPayload) -> Result<Vec<u8>, crate::error::CheckoutError> {
use base64::Engine as _;
base64::engine::general_purpose::STANDARD
.decode(&cert.sig)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)
}
fn parse_envelope(pem: &str) -> Result<CertPayload, crate::error::CheckoutError> {
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
let body = pem
.trim()
.strip_prefix(PEM_HEADER)
.and_then(|rest| rest.strip_suffix(PEM_FOOTER))
.ok_or(crate::error::CheckoutError::MalformedPem)?
.trim();
let cert_json = B64
.decode(body)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?;
let cert: CertPayload = serde_json::from_slice(&cert_json)?;
Ok(cert)
}
fn decode_plaintext(
cert: &CertPayload,
encoding: EncEncoding,
license_key: Option<&str>,
fingerprint: Option<&str>,
) -> Result<Vec<u8>, crate::error::CheckoutError> {
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
let plaintext = match encoding {
EncEncoding::Plain => B64
.decode(&cert.enc)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?,
EncEncoding::Aes256Gcm => {
let key_str = license_key.ok_or(crate::error::CheckoutError::LicenseKeyMissing)?;
let fp = fingerprint.ok_or(crate::error::CheckoutError::FingerprintMissing)?;
let key = crate::crypto::hkdf::derive_machine_file_key(key_str, fp);
let (nonce_b64, cipher_b64) = cert
.enc
.split_once('.')
.ok_or(crate::error::CryptoError::DecryptionFailed)?;
let nonce: [u8; NONCE_LEN] = B64
.decode(nonce_b64)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?
.as_slice()
.try_into()
.map_err(|_| crate::error::CryptoError::DecryptionFailed)?;
let ciphertext_and_tag = B64
.decode(cipher_b64)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?;
if ciphertext_and_tag.len() < GCM_TAG_LEN {
return Err(crate::error::CryptoError::DecryptionFailed.into());
}
crate::crypto::aes_gcm::decrypt(&key, &nonce, &ciphertext_and_tag)?
}
};
Ok(plaintext)
}
fn finish(
plaintext: &[u8],
now_unix: i64,
) -> Result<VerifiedMachineFile, crate::error::CheckoutError> {
let payload: DataPayload = serde_json::from_slice(plaintext)?;
if let Some(exp) = payload.meta.exp {
if now_unix.saturating_sub(crate::checkout::license_file::CLOCK_SKEW_TOLERANCE_SECS) > exp {
return Err(crate::error::CheckoutError::Expired { exp });
}
}
Ok(VerifiedMachineFile {
machine: payload.data,
claims: payload.meta,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::policy::LicenseScheme;
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
const ISSUED_AT: i64 = 1_767_225_600;
fn representative_payload_json(exp: Option<i64>) -> String {
let mut meta = serde_json::json!({
"iat": ISSUED_AT, "jti": "test-jti", "kid": "test-kid"
});
if let Some(exp) = exp {
meta["exp"] = serde_json::json!(exp);
}
serde_json::json!({
"data": {
"type": "machines",
"id": "01926b3e-2222-7000-8000-000000000000",
"attributes": {
"fingerprint": "fp-abc123", "cores": 4, "memory": null, "disk": null,
"ip": null, "hostname": "host1", "platform": "linux", "name": null,
"heartbeat_status": "NOT_STARTED", "last_heartbeat_at": null,
"next_heartbeat_at": null, "last_check_out_at": null, "metadata": {},
"created": "2026-01-01T00:00:00Z", "updated": "2026-01-01T00:00:00Z",
}
},
"meta": meta
})
.to_string()
}
fn sign_for_scheme(
scheme: LicenseScheme,
enc: &str,
) -> (Vec<u8> /* pubkey */, Vec<u8> /* sig */) {
use aws_lc_rs::rand::SystemRandom;
match scheme {
LicenseScheme::Ed25519Sign => {
use ed25519_dalek::{Signer, SigningKey};
use rand::rngs::OsRng;
use rand::RngCore;
let mut secret = [0u8; 32];
OsRng.fill_bytes(&mut secret);
let signing_key = SigningKey::from_bytes(&secret);
let pubkey = signing_key.verifying_key().to_bytes().to_vec();
let sig = signing_key.sign(enc.as_bytes()).to_bytes().to_vec();
(pubkey, sig)
}
LicenseScheme::Rsa2048Pkcs1Sign | LicenseScheme::Rsa2048JwtRs256 => {
use aws_lc_rs::rsa::{KeyPair as RsaKeyPair, KeySize};
use aws_lc_rs::signature::{KeyPair as _, RSA_PKCS1_SHA256};
let kp = RsaKeyPair::generate(KeySize::Rsa2048).unwrap();
let pubkey = kp.public_key().as_ref().to_vec();
let rng = SystemRandom::new();
let mut sig = vec![0u8; kp.public_modulus_len()];
kp.sign(&RSA_PKCS1_SHA256, &rng, enc.as_bytes(), &mut sig)
.unwrap();
(pubkey, sig)
}
LicenseScheme::Rsa2048Pkcs1PssSign => {
use aws_lc_rs::rsa::{KeyPair as RsaKeyPair, KeySize};
use aws_lc_rs::signature::{KeyPair as _, RSA_PSS_SHA256};
let kp = RsaKeyPair::generate(KeySize::Rsa2048).unwrap();
let pubkey = kp.public_key().as_ref().to_vec();
let rng = SystemRandom::new();
let mut sig = vec![0u8; kp.public_modulus_len()];
kp.sign(&RSA_PSS_SHA256, &rng, enc.as_bytes(), &mut sig)
.unwrap();
(pubkey, sig)
}
LicenseScheme::EcdsaP256Sign => {
use aws_lc_rs::signature::{EcdsaKeyPair, KeyPair, ECDSA_P256_SHA256_ASN1_SIGNING};
let rng = SystemRandom::new();
let pkcs8 =
EcdsaKeyPair::generate_pkcs8(&ECDSA_P256_SHA256_ASN1_SIGNING, &rng).unwrap();
let kp = EcdsaKeyPair::from_pkcs8(&ECDSA_P256_SHA256_ASN1_SIGNING, pkcs8.as_ref())
.unwrap();
let pubkey = kp.public_key().as_ref().to_vec();
let sig = kp.sign(&rng, enc.as_bytes()).unwrap().as_ref().to_vec();
(pubkey, sig)
}
}
}
fn build_pem_with(
scheme: LicenseScheme,
encrypt_key: Option<[u8; 32]>,
exp: Option<i64>,
) -> (Vec<u8>, String) {
let payload = representative_payload_json(exp);
let suffix = scheme_alg_suffix(scheme);
let (enc_prefix, enc) = match encrypt_key {
None => ("base64", B64.encode(payload.as_bytes())),
Some(key) => {
use aes_gcm::aead::Aead;
use aes_gcm::{Aes256Gcm, Key, KeyInit, Nonce};
use rand::{rngs::OsRng as AeadOsRng, RngCore as _};
let cipher = Aes256Gcm::new(&Key::<Aes256Gcm>::from(key));
let mut nonce_bytes = [0u8; NONCE_LEN];
AeadOsRng.fill_bytes(&mut nonce_bytes);
let nonce = Nonce::from(nonce_bytes);
let ciphertext_and_tag = cipher.encrypt(&nonce, payload.as_bytes()).unwrap();
(
"aes-256-gcm",
format!(
"{}.{}",
B64.encode(nonce_bytes),
B64.encode(&ciphertext_and_tag)
),
)
}
};
let (pubkey, sig_bytes) = sign_for_scheme(scheme, &enc);
let sig = B64.encode(&sig_bytes);
let alg = format!("{enc_prefix}+{suffix}+{ALG_VERSION_MARKER}");
let cert = serde_json::json!({ "enc": enc, "sig": sig, "alg": alg });
let pem_body = B64.encode(serde_json::to_string(&cert).unwrap().as_bytes());
(pubkey, format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}"))
}
fn build_pem(scheme: LicenseScheme, encrypt_key: Option<[u8; 32]>) -> (Vec<u8>, String) {
build_pem_with(scheme, encrypt_key, None)
}
fn verify_at_issue_time(
pem: &str,
scheme: LicenseScheme,
pubkey: &[u8],
license_key: Option<&str>,
fingerprint: Option<&str>,
) -> Result<VerifiedMachineFile, crate::error::CheckoutError> {
verify_machine_file_at(pem, scheme, pubkey, license_key, fingerprint, ISSUED_AT)
}
fn build_ed25519_pem_with_kid(
signing_key: &ed25519_dalek::SigningKey,
kid: &str,
encrypt_key: Option<[u8; 32]>,
) -> String {
use ed25519_dalek::Signer as _;
let mut payload: serde_json::Value =
serde_json::from_str(&representative_payload_json(None)).unwrap();
payload["meta"]["kid"] = serde_json::json!(kid);
let payload = payload.to_string();
let (enc_prefix, enc) = match encrypt_key {
None => ("base64", B64.encode(payload.as_bytes())),
Some(key) => {
use aes_gcm::aead::Aead;
use aes_gcm::{Aes256Gcm, Key, KeyInit, Nonce};
use rand::{rngs::OsRng as AeadOsRng, RngCore as _};
let cipher = Aes256Gcm::new(&Key::<Aes256Gcm>::from(key));
let mut nonce_bytes = [0u8; NONCE_LEN];
AeadOsRng.fill_bytes(&mut nonce_bytes);
let nonce = Nonce::from(nonce_bytes);
let ciphertext_and_tag = cipher.encrypt(&nonce, payload.as_bytes()).unwrap();
(
"aes-256-gcm",
format!(
"{}.{}",
B64.encode(nonce_bytes),
B64.encode(&ciphertext_and_tag)
),
)
}
};
let sig = B64.encode(signing_key.sign(enc.as_bytes()).to_bytes());
let alg = format!("{enc_prefix}+ed25519+{ALG_VERSION_MARKER}");
let cert = serde_json::json!({ "enc": enc, "sig": sig, "alg": alg });
let pem_body = B64.encode(serde_json::to_string(&cert).unwrap().as_bytes());
format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}")
}
fn gen_ed25519() -> (ed25519_dalek::SigningKey, String) {
use rand::rngs::OsRng;
use rand::RngCore;
let mut secret = [0u8; 32];
OsRng.fill_bytes(&mut secret);
let signing_key = ed25519_dalek::SigningKey::from_bytes(&secret);
let b64 = B64.encode(signing_key.verifying_key().to_bytes());
(signing_key, b64)
}
#[test]
fn a_machine_file_signed_before_a_rotation_verifies_against_the_retired_key() {
let (old_signing, old_b64) = gen_ed25519();
let (_new_signing, new_b64) = gen_ed25519();
let kid = crate::crypto::ed25519::key_id(&old_b64);
let pem = build_ed25519_pem_with_kid(&old_signing, &kid, None);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&new_b64, &old_b64])
.unwrap();
let verified =
verify_machine_file_with_key_set_at(&pem, &keys, None, None, ISSUED_AT).unwrap();
assert_eq!(verified.claims.kid, kid);
assert_eq!(verified.machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn an_unknown_kid_on_a_machine_file_is_distinct_from_a_bad_signature() {
let (signing, _b64) = gen_ed25519();
let (_other_signing, other_b64) = gen_ed25519();
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&other_b64]).unwrap();
let unknown = build_ed25519_pem_with_kid(&signing, "0f0f0f0f0f0f0f0f", None);
assert!(matches!(
verify_machine_file_with_key_set_at(&unknown, &keys, None, None, ISSUED_AT).unwrap_err(),
crate::error::CheckoutError::UnknownSigningKey { ref kid } if kid == "0f0f0f0f0f0f0f0f"
));
let forged =
build_ed25519_pem_with_kid(&signing, &crate::crypto::ed25519::key_id(&other_b64), None);
assert!(matches!(
verify_machine_file_with_key_set_at(&forged, &keys, None, None, ISSUED_AT).unwrap_err(),
crate::error::CheckoutError::Crypto(crate::error::CryptoError::VerificationFailed)
));
}
#[test]
fn the_key_set_path_handles_the_dot_separated_encrypted_enc() {
let (signing, b64) = gen_ed25519();
let kid = crate::crypto::ed25519::key_id(&b64);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
let license_key = "lic-abc123";
let fingerprint = "fp-abc123";
let enc_key = crate::crypto::hkdf::derive_machine_file_key(license_key, fingerprint);
let pem = build_ed25519_pem_with_kid(&signing, &kid, Some(*enc_key));
let verified = verify_machine_file_with_key_set_at(
&pem,
&keys,
Some(license_key),
Some(fingerprint),
ISSUED_AT,
)
.unwrap();
assert_eq!(verified.claims.kid, kid);
assert!(matches!(
verify_machine_file_with_key_set_at(&pem, &keys, None, Some(fingerprint), ISSUED_AT)
.unwrap_err(),
crate::error::CheckoutError::LicenseKeyMissing
));
assert!(matches!(
verify_machine_file_with_key_set_at(&pem, &keys, Some(license_key), None, ISSUED_AT)
.unwrap_err(),
crate::error::CheckoutError::FingerprintMissing
));
}
#[test]
fn the_machine_key_set_path_verifies_before_it_decrypts() {
let (signing, b64) = gen_ed25519();
let (_other_signing, other_b64) = gen_ed25519();
let kid = crate::crypto::ed25519::key_id(&b64);
let license_key = "lic-abc123";
let fingerprint = "fp-abc123";
let enc_key = crate::crypto::hkdf::derive_machine_file_key(license_key, fingerprint);
let pem = build_ed25519_pem_with_kid(&signing, &kid, Some(*enc_key));
let stale =
crate::checkout::key_set::SigningKeySet::from_public_keys([&other_b64]).unwrap();
assert!(matches!(
verify_machine_file_with_key_set_at(
&pem,
&stale,
Some("wrong-key"),
Some(fingerprint),
ISSUED_AT
)
.unwrap_err(),
crate::error::CheckoutError::Crypto(crate::error::CryptoError::VerificationFailed)
));
let held = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
assert!(matches!(
verify_machine_file_with_key_set_at(
&pem,
&held,
Some("wrong-key"),
Some(fingerprint),
ISSUED_AT
)
.unwrap_err(),
crate::error::CheckoutError::Crypto(crate::error::CryptoError::DecryptionFailed)
));
assert!(matches!(
verify_machine_file_with_key_set_at(
&pem,
&held,
Some(license_key),
Some("fp-other"),
ISSUED_AT
)
.unwrap_err(),
crate::error::CheckoutError::Crypto(crate::error::CryptoError::DecryptionFailed)
));
assert!(verify_machine_file_with_key_set_at(
&pem,
&held,
Some(license_key),
Some(fingerprint),
ISSUED_AT
)
.is_ok());
}
#[test]
fn a_non_ed25519_machine_file_is_refused_by_the_key_set_path() {
for scheme in [
LicenseScheme::EcdsaP256Sign,
LicenseScheme::Rsa2048Pkcs1Sign,
LicenseScheme::Rsa2048Pkcs1PssSign,
] {
let (_pubkey, pem) = build_pem(scheme, None);
let keys = crate::checkout::key_set::SigningKeySet::default();
let err = verify_machine_file_with_key_set_at(&pem, &keys, None, None, ISSUED_AT)
.unwrap_err();
assert!(
matches!(err, crate::error::CheckoutError::UnsupportedAlgorithm(ref a) if a.contains("key set")),
"{scheme:?} produced {err:?}"
);
}
}
#[test]
fn the_wall_clock_key_set_entry_point_verifies_a_file_that_never_expires() {
let (signing, b64) = gen_ed25519();
let kid = crate::crypto::ed25519::key_id(&b64);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
let pem = build_ed25519_pem_with_kid(&signing, &kid, None);
let verified = verify_machine_file_with_key_set(&pem, &keys, None, None).unwrap();
assert_eq!(verified.claims.kid, kid);
assert!(verified.claims.exp.is_none());
}
#[test]
fn the_key_set_path_still_enforces_the_signed_exp_claim() {
use ed25519_dalek::Signer as _;
let (signing, b64) = gen_ed25519();
let kid = crate::crypto::ed25519::key_id(&b64);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
let exp = ISSUED_AT + 3600;
let mut payload: serde_json::Value =
serde_json::from_str(&representative_payload_json(Some(exp))).unwrap();
payload["meta"]["kid"] = serde_json::json!(kid);
let enc = B64.encode(payload.to_string().as_bytes());
let sig = B64.encode(signing.sign(enc.as_bytes()).to_bytes());
let cert = serde_json::json!({ "enc": enc, "sig": sig, "alg": "base64+ed25519+v2" });
let pem_body = B64.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let pem = format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}");
assert!(verify_machine_file_with_key_set_at(&pem, &keys, None, None, exp - 1).is_ok());
assert!(matches!(
verify_machine_file_with_key_set_at(&pem, &keys, None, None, exp + 3600).unwrap_err(),
crate::error::CheckoutError::Expired { exp: e } if e == exp
));
}
#[test]
fn parse_alg_cuts_at_the_first_and_last_plus() {
assert_eq!(
parse_alg("base64+ed25519+v2").unwrap(),
(EncEncoding::Plain, "ed25519")
);
assert_eq!(
parse_alg("aes-256-gcm+rsa-pss-sha256+v2").unwrap(),
(EncEncoding::Aes256Gcm, "rsa-pss-sha256")
);
assert_eq!(
parse_alg("aes-256-gcm+ecdsa-p256+v2").unwrap(),
(EncEncoding::Aes256Gcm, "ecdsa-p256")
);
}
#[test]
fn parse_alg_refuses_anything_that_is_not_exactly_v2() {
for bad in [
"base64+ed25519", "base64+ed25519+v1", "base64+ed25519+v3", "base64+ed25519+v2junk", "xbase64+ed25519+v2", "base64+ed25519+extra+v2", "base64++v2", "base64", "", "aes-256-cbc+ed25519+v2", ] {
assert!(parse_alg(bad).is_err(), "alg {bad:?} must not be accepted");
}
}
#[test]
fn ed25519_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, None);
let machine =
verify_at_issue_time(&pem, LicenseScheme::Ed25519Sign, &pubkey, None, None).unwrap();
assert_eq!(machine.machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn rsa_pkcs1_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::Rsa2048Pkcs1Sign, None);
let machine =
verify_at_issue_time(&pem, LicenseScheme::Rsa2048Pkcs1Sign, &pubkey, None, None)
.unwrap();
assert_eq!(machine.machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn rsa_pss_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::Rsa2048Pkcs1PssSign, None);
let machine = verify_at_issue_time(
&pem,
LicenseScheme::Rsa2048Pkcs1PssSign,
&pubkey,
None,
None,
)
.unwrap();
assert_eq!(machine.machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn ecdsa_p256_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::EcdsaP256Sign, None);
let machine =
verify_at_issue_time(&pem, LicenseScheme::EcdsaP256Sign, &pubkey, None, None).unwrap();
assert_eq!(machine.machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn the_plain_entry_point_returns_just_the_machine_resource() {
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, None);
let machine =
verify_machine_file(&pem, LicenseScheme::Ed25519Sign, &pubkey, None, None).unwrap();
assert_eq!(machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn encrypted_machine_file_requires_correct_fingerprint() {
let license_key = "lic-abc123";
let fingerprint = "fp-abc123";
let key = crate::crypto::hkdf::derive_machine_file_key(license_key, fingerprint);
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, Some(*key));
let machine = verify_at_issue_time(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
Some(license_key),
Some(fingerprint),
)
.unwrap();
assert_eq!(machine.machine.attributes.fingerprint, "fp-abc123");
let result = verify_at_issue_time(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
Some(license_key),
Some("wrong-fingerprint"),
);
assert!(matches!(
result,
Err(crate::error::CheckoutError::Crypto(
crate::error::CryptoError::DecryptionFailed
))
));
}
#[test]
fn an_encrypted_file_needs_both_the_licence_key_and_the_fingerprint() {
let key = crate::crypto::hkdf::derive_machine_file_key("lic-abc123", "fp-abc123");
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, Some(*key));
assert!(matches!(
verify_at_issue_time(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
None,
Some("fp-abc123")
),
Err(crate::error::CheckoutError::LicenseKeyMissing)
));
assert!(matches!(
verify_at_issue_time(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
Some("lic-abc123"),
None
),
Err(crate::error::CheckoutError::FingerprintMissing)
));
}
#[test]
fn an_encrypted_enc_without_a_dot_separator_is_refused() {
let license_key = "lic-abc123";
let fingerprint = "fp-abc123";
let key = crate::crypto::hkdf::derive_machine_file_key(license_key, fingerprint);
let payload = representative_payload_json(None);
let enc = {
use aes_gcm::aead::Aead;
use aes_gcm::{Aes256Gcm, Key, KeyInit, Nonce};
use rand::{rngs::OsRng as AeadOsRng, RngCore as _};
let cipher = Aes256Gcm::new(&Key::<Aes256Gcm>::from(*key));
let mut nonce_bytes = [0u8; NONCE_LEN];
AeadOsRng.fill_bytes(&mut nonce_bytes);
let ciphertext_and_tag = cipher
.encrypt(&Nonce::from(nonce_bytes), payload.as_bytes())
.unwrap();
let mut out = nonce_bytes.to_vec();
out.extend_from_slice(&ciphertext_and_tag);
B64.encode(&out)
};
let (pubkey, sig_bytes) = sign_for_scheme(LicenseScheme::Ed25519Sign, &enc);
let cert = serde_json::json!({
"enc": enc,
"sig": B64.encode(&sig_bytes),
"alg": "aes-256-gcm+ed25519+v2",
});
let pem_body = B64.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let pem = format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}");
assert!(matches!(
verify_at_issue_time(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
Some(license_key),
Some(fingerprint)
),
Err(crate::error::CheckoutError::Crypto(
crate::error::CryptoError::DecryptionFailed
))
));
}
#[test]
fn an_expired_machine_file_is_refused_even_though_its_signature_is_valid() {
let exp = ISSUED_AT + 3600;
let (pubkey, pem) = build_pem_with(LicenseScheme::Ed25519Sign, None, Some(exp));
let err = verify_machine_file_at(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
None,
None,
exp + 3600,
)
.unwrap_err();
assert!(matches!(
err,
crate::error::CheckoutError::Expired { exp: e } if e == exp
));
}
#[test]
fn a_machine_file_within_its_ttl_verifies() {
let exp = ISSUED_AT + 3600;
let (pubkey, pem) = build_pem_with(LicenseScheme::Ed25519Sign, None, Some(exp));
let verified = verify_machine_file_at(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
None,
None,
exp - 60,
)
.unwrap();
assert_eq!(verified.claims.exp, Some(exp));
}
#[test]
fn a_machine_file_without_an_exp_claim_never_expires() {
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, None);
let verified = verify_machine_file_at(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
None,
None,
i64::MAX / 2,
)
.unwrap();
assert!(verified.claims.exp.is_none());
}
#[test]
fn machine_file_expiry_uses_the_same_skew_tolerance_as_the_licence_file() {
let exp = ISSUED_AT + 3600;
let (pubkey, pem) = build_pem_with(LicenseScheme::Ed25519Sign, None, Some(exp));
let at = |now| {
verify_machine_file_at(&pem, LicenseScheme::Ed25519Sign, &pubkey, None, None, now)
};
let tolerance = crate::checkout::license_file::CLOCK_SKEW_TOLERANCE_SECS;
assert_eq!(tolerance, 60, "the tolerance is seconds, not hours");
assert!(at(exp + tolerance).is_ok());
assert!(at(exp + tolerance + 1).is_err());
}
#[test]
fn a_payload_without_a_meta_block_is_refused() {
let payload = serde_json::json!({
"data": {
"type": "machines",
"id": "01926b3e-2222-7000-8000-000000000000",
"attributes": {
"fingerprint": "fp-abc123", "cores": 4, "memory": null, "disk": null,
"ip": null, "hostname": "host1", "platform": "linux", "name": null,
"heartbeat_status": "NOT_STARTED", "last_heartbeat_at": null,
"next_heartbeat_at": null, "last_check_out_at": null, "metadata": {},
"created": "2026-01-01T00:00:00Z", "updated": "2026-01-01T00:00:00Z",
}
}
})
.to_string();
let enc = B64.encode(payload.as_bytes());
let (pubkey, sig_bytes) = sign_for_scheme(LicenseScheme::Ed25519Sign, &enc);
let cert = serde_json::json!({
"enc": enc,
"sig": B64.encode(&sig_bytes),
"alg": "base64+ed25519+v2",
});
let pem_body = B64.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let pem = format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}");
assert!(matches!(
verify_at_issue_time(&pem, LicenseScheme::Ed25519Sign, &pubkey, None, None),
Err(crate::error::CheckoutError::InvalidJson(_))
));
}
#[test]
fn rsa_jwt_rs256_scheme_rejected_before_any_signature_attempt() {
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, None);
let result = verify_machine_file(&pem, LicenseScheme::Rsa2048JwtRs256, &pubkey, None, None);
assert!(matches!(
result,
Err(crate::error::CheckoutError::SchemeNotSupported)
));
}
#[test]
fn a_malformed_pem_envelope_is_refused() {
assert!(matches!(
verify_at_issue_time(
"not a pem",
LicenseScheme::Ed25519Sign,
&[0u8; 32],
None,
None
),
Err(crate::error::CheckoutError::MalformedPem)
));
}
#[test]
fn check_ttl_accepts_valid_range() {
assert!(check_ttl(1).is_ok());
assert!(check_ttl(MAX_TTL_SECS).is_ok());
}
#[test]
fn check_ttl_rejects_zero_and_over_max() {
assert!(check_ttl(0).is_err());
assert!(check_ttl(MAX_TTL_SECS + 1).is_err());
}
#[test]
fn alg_suffix_mismatch_is_rejected() {
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, None);
let result =
verify_at_issue_time(&pem, LicenseScheme::Rsa2048Pkcs1Sign, &pubkey, None, None);
assert!(matches!(
result,
Err(crate::error::CheckoutError::UnsupportedAlgorithm(_))
));
}
#[test]
fn a_v1_alg_is_refused_outright() {
let (pubkey, pem) = build_pem(LicenseScheme::Ed25519Sign, None);
let body: String = pem.lines().filter(|l| !l.starts_with("-----")).collect();
let mut cert: serde_json::Value =
serde_json::from_slice(&B64.decode(body.trim()).unwrap()).unwrap();
cert["alg"] = serde_json::json!("base64+ed25519");
let repacked = B64.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let v1_pem = format!("{PEM_HEADER}\n{repacked}\n{PEM_FOOTER}");
assert!(matches!(
verify_at_issue_time(&v1_pem, LicenseScheme::Ed25519Sign, &pubkey, None, None),
Err(crate::error::CheckoutError::UnsupportedAlgorithm(ref a)) if a == "base64+ed25519"
));
}
}