const PEM_HEADER: &str = "-----BEGIN MACHINE FILE-----";
const PEM_FOOTER: &str = "-----END MACHINE FILE-----";
#[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(())
}
#[derive(Debug, serde::Deserialize)]
struct CertPayload {
enc: String,
sig: String,
alg: String,
}
#[derive(Debug, serde::Deserialize)]
struct DataPayload {
data: crate::models::machine::MachineResource,
}
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",
}
}
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> {
use crate::models::policy::LicenseScheme;
if scheme == LicenseScheme::Rsa2048JwtRs256 {
return Err(crate::error::CheckoutError::SchemeNotSupported);
}
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)?;
let (enc_prefix, alg_suffix) = cert
.alg
.split_once('+')
.ok_or_else(|| crate::error::CheckoutError::UnsupportedAlgorithm(cert.alg.clone()))?;
let expected_suffix = scheme_alg_suffix(scheme);
if alg_suffix != expected_suffix {
return Err(crate::error::CheckoutError::UnsupportedAlgorithm(format!(
"file declares alg suffix {alg_suffix:?}, expected {expected_suffix:?} for the supplied scheme"
)));
}
let sig_bytes = B64
.decode(&cert.sig)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?;
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 enc_bytes = B64
.decode(&cert.enc)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?;
let plaintext = match enc_prefix {
"base64" => enc_bytes,
"aes-256-gcm" => {
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);
if enc_bytes.len() < 12 + 16 {
return Err(crate::error::CryptoError::DecryptionFailed.into());
}
let (nonce_bytes, ciphertext_and_tag) = enc_bytes.split_at(12);
let nonce: [u8; 12] = nonce_bytes
.try_into()
.expect("split_at(12) guarantees a 12-byte slice");
crate::crypto::aes_gcm::decrypt(&key, &nonce, ciphertext_and_tag)?
}
other => {
return Err(crate::error::CheckoutError::UnsupportedAlgorithm(
other.to_string(),
));
}
};
let payload: DataPayload = serde_json::from_slice(&plaintext)?;
Ok(payload.data)
}
#[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;
fn representative_payload_json() -> String {
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()
}
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(scheme: LicenseScheme, encrypt_key: Option<[u8; 32]>) -> (Vec<u8>, String) {
let payload = representative_payload_json();
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::{rand_core::RngCore as _, Aead, OsRng as AeadOsRng};
use aes_gcm::{Aes256Gcm, Key, KeyInit, Nonce};
let cipher = Aes256Gcm::new(&Key::<Aes256Gcm>::from(key));
let mut nonce_bytes = [0u8; 12];
AeadOsRng.fill_bytes(&mut nonce_bytes);
let nonce = Nonce::from(nonce_bytes);
let ciphertext_and_tag = cipher.encrypt(&nonce, payload.as_bytes()).unwrap();
let mut out = nonce_bytes.to_vec();
out.extend_from_slice(&ciphertext_and_tag);
("aes-256-gcm", B64.encode(&out))
}
};
let (pubkey, sig_bytes) = sign_for_scheme(scheme, &enc);
let sig = B64.encode(&sig_bytes);
let alg = format!("{enc_prefix}+{suffix}");
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}"))
}
#[test]
fn ed25519_machine_file_round_trip() {
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 rsa_pkcs1_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::Rsa2048Pkcs1Sign, None);
let machine =
verify_machine_file(&pem, LicenseScheme::Rsa2048Pkcs1Sign, &pubkey, None, None)
.unwrap();
assert_eq!(machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn rsa_pss_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::Rsa2048Pkcs1PssSign, None);
let machine = verify_machine_file(
&pem,
LicenseScheme::Rsa2048Pkcs1PssSign,
&pubkey,
None,
None,
)
.unwrap();
assert_eq!(machine.attributes.fingerprint, "fp-abc123");
}
#[test]
fn ecdsa_p256_machine_file_round_trip() {
let (pubkey, pem) = build_pem(LicenseScheme::EcdsaP256Sign, None);
let machine =
verify_machine_file(&pem, LicenseScheme::EcdsaP256Sign, &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_machine_file(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
Some(license_key),
Some(fingerprint),
)
.unwrap();
assert_eq!(machine.attributes.fingerprint, "fp-abc123");
let result = verify_machine_file(
&pem,
LicenseScheme::Ed25519Sign,
&pubkey,
Some(license_key),
Some("wrong-fingerprint"),
);
assert!(result.is_err());
}
#[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 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_machine_file(&pem, LicenseScheme::Rsa2048Pkcs1Sign, &pubkey, None, None);
assert!(matches!(
result,
Err(crate::error::CheckoutError::UnsupportedAlgorithm(_))
));
}
}