const PEM_HEADER: &str = "-----BEGIN LICENSE FILE-----";
const PEM_FOOTER: &str = "-----END LICENSE FILE-----";
#[derive(Debug, Clone, serde::Deserialize)]
pub struct LicenseFileResource {
pub id: uuid::Uuid,
#[serde(rename = "type")]
pub resource_type: String,
pub attributes: LicenseFile,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct LicenseFile {
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>,
}
#[derive(Debug, serde::Deserialize)]
struct CertPayload {
enc: String,
sig: String,
alg: String,
}
#[derive(Debug, serde::Deserialize)]
struct DataPayload {
data: crate::models::license::LicenseResource,
meta: LicenseFileClaims,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct LicenseFileClaims {
pub iat: i64,
#[serde(default)]
pub exp: Option<i64>,
pub jti: String,
pub kid: String,
}
#[derive(Debug, Clone)]
pub struct VerifiedLicenseFile {
pub license: crate::models::license::LicenseResource,
pub claims: LicenseFileClaims,
}
pub(crate) const CLOCK_SKEW_TOLERANCE_SECS: i64 = 60;
pub fn verify_license_file(
pem: &str,
ed25519_pubkey: &[u8; 32],
license_key: Option<&str>,
) -> Result<crate::models::license::LicenseResource, crate::error::CheckoutError> {
verify_license_file_with_claims(pem, ed25519_pubkey, license_key).map(|v| v.license)
}
pub fn verify_license_file_with_claims(
pem: &str,
ed25519_pubkey: &[u8; 32],
license_key: Option<&str>,
) -> Result<VerifiedLicenseFile, crate::error::CheckoutError> {
verify_license_file_at(pem, ed25519_pubkey, license_key, unix_now())
}
pub(crate) fn unix_now() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or(0)
}
pub fn verify_license_file_at(
pem: &str,
ed25519_pubkey: &[u8; 32],
license_key: Option<&str>,
now_unix: i64,
) -> Result<VerifiedLicenseFile, crate::error::CheckoutError> {
let cert = parse_envelope(pem)?;
let encoding = validate_alg(&cert.alg)?;
verify_signature(ed25519_pubkey, &cert)?;
let plaintext = decode_plaintext(&cert, encoding, license_key)?;
finish(&plaintext, now_unix)
}
pub fn verify_license_file_with_key_set(
pem: &str,
keys: &crate::checkout::key_set::SigningKeySet,
license_key: Option<&str>,
) -> Result<VerifiedLicenseFile, crate::error::CheckoutError> {
verify_license_file_with_key_set_at(pem, keys, license_key, unix_now())
}
pub fn verify_license_file_with_key_set_at(
pem: &str,
keys: &crate::checkout::key_set::SigningKeySet,
license_key: Option<&str>,
now_unix: i64,
) -> Result<VerifiedLicenseFile, crate::error::CheckoutError> {
let cert = parse_envelope(pem)?;
let encoding = validate_alg(&cert.alg)?;
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)?;
finish(&plaintext, now_unix)
}
None => Err(keys.label_failure(decode_plaintext(&cert, encoding, license_key))),
}
}
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)?;
Ok(serde_json::from_slice(&cert_json)?)
}
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 verify_signature(
ed25519_pubkey: &[u8; 32],
cert: &CertPayload,
) -> Result<(), crate::error::CheckoutError> {
let sig_bytes = decode_signature(cert)?;
crate::crypto::ed25519::verify(ed25519_pubkey, cert.enc.as_bytes(), &sig_bytes)?;
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EncEncoding {
Plain,
Aes256Gcm,
}
fn validate_alg(alg: &str) -> Result<EncEncoding, crate::error::CheckoutError> {
match alg {
"base64+ed25519+v2" => Ok(EncEncoding::Plain),
"aes-256-gcm+ed25519+v2" => Ok(EncEncoding::Aes256Gcm),
other => Err(crate::error::CheckoutError::UnsupportedAlgorithm(
other.to_string(),
)),
}
}
fn decode_plaintext(
cert: &CertPayload,
encoding: EncEncoding,
license_key: Option<&str>,
) -> Result<Vec<u8>, crate::error::CheckoutError> {
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
let enc_bytes = B64
.decode(&cert.enc)
.map_err(|_| crate::error::CheckoutError::InvalidBase64)?;
match encoding {
EncEncoding::Plain => Ok(enc_bytes),
EncEncoding::Aes256Gcm => {
let key_str = license_key.ok_or(crate::error::CheckoutError::LicenseKeyMissing)?;
let key = crate::crypto::hkdf::derive_license_file_key(key_str);
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");
Ok(crate::crypto::aes_gcm::decrypt(
&key,
&nonce,
ciphertext_and_tag,
)?)
}
}
}
pub(crate) fn probe_kid(plaintext: &[u8]) -> Result<String, crate::error::CheckoutError> {
#[derive(serde::Deserialize)]
struct KidProbe {
meta: KidProbeMeta,
}
#[derive(serde::Deserialize)]
struct KidProbeMeta {
kid: String,
}
let probe: KidProbe = serde_json::from_slice(plaintext)?;
Ok(probe.meta.kid)
}
fn finish(
plaintext: &[u8],
now_unix: i64,
) -> Result<VerifiedLicenseFile, crate::error::CheckoutError> {
let payload: DataPayload = serde_json::from_slice(plaintext)?;
if let Some(exp) = payload.meta.exp {
if now_unix.saturating_sub(CLOCK_SKEW_TOLERANCE_SECS) > exp {
return Err(crate::error::CheckoutError::Expired { exp });
}
}
Ok(VerifiedLicenseFile {
license: payload.data,
claims: payload.meta,
})
}
#[cfg(test)]
mod tests {
use super::*;
use ed25519_dalek::{Signer, SigningKey};
use rand::rngs::OsRng;
use rand::RngCore;
const B64_TEST: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
fn gen_keypair() -> ([u8; 32], SigningKey) {
let mut secret = [0u8; 32];
OsRng.fill_bytes(&mut secret);
let signing_key = SigningKey::from_bytes(&secret);
(signing_key.verifying_key().to_bytes(), signing_key)
}
fn build_pem(
payload_json: &str,
signing_key: &SigningKey,
encryption_key: Option<&[u8; 32]>,
) -> String {
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
let (enc, alg) = match encryption_key {
None => (B64.encode(payload_json.as_bytes()), "base64+ed25519+v2"),
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; 12];
AeadOsRng.fill_bytes(&mut nonce_bytes);
let nonce = Nonce::from(nonce_bytes);
let ciphertext_and_tag = cipher.encrypt(&nonce, payload_json.as_bytes()).unwrap();
let mut out = nonce_bytes.to_vec();
out.extend_from_slice(&ciphertext_and_tag);
(B64.encode(&out), "aes-256-gcm+ed25519+v2")
}
};
let sig = B64.encode(signing_key.sign(enc.as_bytes()).to_bytes());
let cert = serde_json::json!({ "enc": enc, "sig": sig, "alg": alg });
let cert_json = serde_json::to_string(&cert).unwrap();
let pem_body = B64.encode(cert_json.as_bytes());
format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}")
}
fn payload_json_with_kid(kid: &str) -> String {
let mut v: serde_json::Value =
serde_json::from_str(&representative_payload_json()).unwrap();
v["meta"]["kid"] = serde_json::json!(kid);
v.to_string()
}
fn pubkey_b64(pubkey: &[u8; 32]) -> String {
use base64::Engine as _;
base64::engine::general_purpose::STANDARD.encode(pubkey)
}
fn repack_alg(pem: &str, alg: &str) -> String {
use base64::Engine as _;
let body: String = pem.lines().filter(|l| !l.starts_with("-----")).collect();
let cert_json = B64_TEST.decode(body.trim()).unwrap();
let mut cert: serde_json::Value = serde_json::from_slice(&cert_json).unwrap();
cert["alg"] = serde_json::json!(alg);
let repacked = B64_TEST.encode(serde_json::to_string(&cert).unwrap().as_bytes());
format!("{PEM_HEADER}\n{repacked}\n{PEM_FOOTER}")
}
fn representative_payload_json() -> String {
serde_json::json!({
"data": {
"type": "licenses",
"id": "01926b3e-0000-7000-8000-000000000000",
"attributes": {
"name": "Acme Corp", "key": "lic-abc123", "status": "ACTIVE",
"expiry": null, "suspended": false, "protected": false,
"scheme": null, "encrypted": false, "strict": false, "floating": false,
"max_machines": null, "max_users": null,
"last_validated_at": null, "last_check_in_at": null, "last_check_out_at": null,
"machines_count": 0, "metadata": {},
"created": "2026-01-01T00:00:00Z", "updated": "2026-01-01T00:00:00Z",
}
},
"meta": { "iat": 1_767_225_600, "jti": "test-jti", "kid": "test-kid" }
})
.to_string()
}
fn payload_json_expiring_at(exp: i64) -> String {
let mut v: serde_json::Value =
serde_json::from_str(&representative_payload_json()).unwrap();
v["meta"]["exp"] = serde_json::json!(exp);
v.to_string()
}
#[test]
fn an_expired_file_is_refused_even_though_its_signature_is_valid() {
let (pubkey, signing_key) = gen_keypair();
let exp = 1_767_225_600;
let pem = build_pem(&payload_json_expiring_at(exp), &signing_key, None);
let err = verify_license_file_at(&pem, &pubkey, None, exp + 3600).unwrap_err();
assert!(matches!(err, crate::error::CheckoutError::Expired { .. }));
}
#[test]
fn a_file_within_its_ttl_verifies() {
let (pubkey, signing_key) = gen_keypair();
let exp = 1_767_225_600;
let pem = build_pem(&payload_json_expiring_at(exp), &signing_key, None);
let verified = verify_license_file_at(&pem, &pubkey, None, exp - 3600).unwrap();
assert_eq!(verified.claims.exp, Some(exp));
}
#[test]
fn a_file_without_an_exp_claim_never_expires() {
let (pubkey, signing_key) = gen_keypair();
let pem = build_pem(&representative_payload_json(), &signing_key, None);
let verified = verify_license_file_at(&pem, &pubkey, None, i64::MAX / 2).unwrap();
assert!(verified.claims.exp.is_none());
}
#[test]
fn clock_skew_tolerance_is_seconds_not_hours() {
let (pubkey, signing_key) = gen_keypair();
let exp = 1_767_225_600;
let pem = build_pem(&payload_json_expiring_at(exp), &signing_key, None);
assert!(verify_license_file_at(&pem, &pubkey, None, exp + 30).is_ok());
assert!(verify_license_file_at(&pem, &pubkey, None, exp + 600).is_err());
}
#[test]
fn a_v1_file_is_refused_outright() {
use base64::Engine as _;
let (pubkey, signing_key) = gen_keypair();
let pem = build_pem(&representative_payload_json(), &signing_key, None);
let body: String = pem.lines().filter(|l| !l.starts_with("-----")).collect();
let cert_json = B64_TEST.decode(body.trim()).unwrap();
let mut cert: serde_json::Value = serde_json::from_slice(&cert_json).unwrap();
cert["alg"] = serde_json::json!("base64+ed25519");
let repacked = B64_TEST.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let v1_pem = format!("{PEM_HEADER}\n{repacked}\n{PEM_FOOTER}");
let err = verify_license_file(&v1_pem, &pubkey, None).unwrap_err();
assert!(matches!(
err,
crate::error::CheckoutError::UnsupportedAlgorithm(ref a) if a == "base64+ed25519"
));
}
#[test]
fn a_v1_alg_is_refused_before_the_signature_is_even_checked() {
let (_pubkey, signing_key) = gen_keypair();
let (wrong_pubkey, _) = gen_keypair();
let pem = build_pem(&representative_payload_json(), &signing_key, None);
let v1_pem = repack_alg(&pem, "base64+ed25519");
assert!(matches!(
verify_license_file(&v1_pem, &wrong_pubkey, None).unwrap_err(),
crate::error::CheckoutError::UnsupportedAlgorithm(ref a) if a == "base64+ed25519"
));
}
#[test]
fn the_claims_carry_a_replay_id_and_a_key_id() {
let (pubkey, signing_key) = gen_keypair();
let pem = build_pem(&representative_payload_json(), &signing_key, None);
let verified = verify_license_file_with_claims(&pem, &pubkey, None).unwrap();
assert!(!verified.claims.jti.is_empty());
assert!(!verified.claims.kid.is_empty());
}
#[test]
fn verifies_a_known_good_plain_fixture() {
let (pubkey, signing_key) = gen_keypair();
let pem = build_pem(&representative_payload_json(), &signing_key, None);
let license = verify_license_file(&pem, &pubkey, None).unwrap();
assert_eq!(license.attributes.key, Some("lic-abc123".to_string()));
}
#[test]
fn verifies_a_known_good_encrypted_fixture() {
let (pubkey, signing_key) = gen_keypair();
let license_key = "lic-abc123";
let enc_key = crate::crypto::hkdf::derive_license_file_key(license_key);
let pem = build_pem(&representative_payload_json(), &signing_key, Some(&enc_key));
let license = verify_license_file(&pem, &pubkey, Some(license_key)).unwrap();
assert_eq!(license.attributes.key, Some("lic-abc123".to_string()));
}
#[test]
fn rejects_tampered_signature() {
let (pubkey, signing_key) = gen_keypair();
let mut pem = build_pem(&representative_payload_json(), &signing_key, None);
let mid = pem.len() / 2;
let corrupted_char = if pem.as_bytes()[mid] == b'A' {
'B'
} else {
'A'
};
pem.replace_range(mid..mid + 1, &corrupted_char.to_string());
assert!(verify_license_file(&pem, &pubkey, None).is_err());
}
#[test]
fn rejects_tampered_ciphertext_aead_tag_mismatch() {
let (pubkey, signing_key) = gen_keypair();
let license_key = "lic-abc123";
let enc_key = crate::crypto::hkdf::derive_license_file_key(license_key);
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
let mut enc_bytes = {
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(*enc_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, representative_payload_json().as_bytes())
.unwrap();
let mut out = nonce_bytes.to_vec();
out.extend_from_slice(&ciphertext_and_tag);
out
};
let last = enc_bytes.len() - 1;
enc_bytes[last] ^= 0xff;
let enc = B64.encode(&enc_bytes);
let sig = B64.encode(signing_key.sign(enc.as_bytes()).to_bytes());
let cert = serde_json::json!({ "enc": enc, "sig": sig, "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!(verify_license_file(&pem, &pubkey, Some(license_key)).is_err());
}
#[test]
fn a_file_signed_before_a_rotation_still_verifies_against_the_retired_key() {
let (old_pubkey, old_signing) = gen_keypair();
let (new_pubkey, _new_signing) = gen_keypair();
let old_b64 = pubkey_b64(&old_pubkey);
let kid = crate::crypto::ed25519::key_id(&old_b64);
let pem = build_pem(&payload_json_with_kid(&kid), &old_signing, None);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([
pubkey_b64(&new_pubkey),
old_b64,
])
.unwrap();
let verified = verify_license_file_with_key_set(&pem, &keys, None).unwrap();
assert_eq!(verified.claims.kid, kid);
assert_eq!(
verified.license.attributes.key,
Some("lic-abc123".to_string())
);
assert!(verify_license_file(&pem, &new_pubkey, None).is_err());
}
#[test]
fn an_unknown_kid_is_reported_distinctly_from_a_bad_signature() {
let (_pubkey, signing) = gen_keypair();
let (other_pubkey, _) = gen_keypair();
let other_b64 = pubkey_b64(&other_pubkey);
let pem = build_pem(&payload_json_with_kid("00ff00ff00ff00ff"), &signing, None);
let stale =
crate::checkout::key_set::SigningKeySet::from_public_keys([&other_b64]).unwrap();
let err = verify_license_file_with_key_set(&pem, &stale, None).unwrap_err();
assert!(
matches!(
err,
crate::error::CheckoutError::UnknownSigningKey { ref kid }
if kid == "00ff00ff00ff00ff"
),
"expected UnknownSigningKey, got {err:?}"
);
let wrong_key_under_the_claimed_kid = build_pem(
&payload_json_with_kid(&crate::crypto::ed25519::key_id(&other_b64)),
&signing,
None,
);
let err = verify_license_file_with_key_set(&wrong_key_under_the_claimed_kid, &stale, None)
.unwrap_err();
assert!(matches!(
err,
crate::error::CheckoutError::Crypto(crate::error::CryptoError::VerificationFailed)
));
}
#[test]
fn an_empty_key_set_reports_the_kid_rather_than_a_forgery() {
let (_pubkey, signing) = gen_keypair();
let pem = build_pem(&payload_json_with_kid("abcdef0123456789"), &signing, None);
let empty = crate::checkout::key_set::SigningKeySet::default();
let err = verify_license_file_with_key_set(&pem, &empty, None).unwrap_err();
assert!(matches!(
err,
crate::error::CheckoutError::UnknownSigningKey { ref kid } if kid == "abcdef0123456789"
));
}
#[test]
fn the_key_set_path_verifies_before_it_decrypts() {
let (pubkey, signing) = gen_keypair();
let (other_pubkey, _) = gen_keypair();
let b64 = pubkey_b64(&pubkey);
let kid = crate::crypto::ed25519::key_id(&b64);
let enc_key = crate::crypto::hkdf::derive_license_file_key("lic-abc123");
let pem = build_pem(&payload_json_with_kid(&kid), &signing, Some(&enc_key));
let stale =
crate::checkout::key_set::SigningKeySet::from_public_keys([pubkey_b64(&other_pubkey)])
.unwrap();
assert!(
matches!(
verify_license_file_with_key_set(&pem, &stale, Some("wrong-key")).unwrap_err(),
crate::error::CheckoutError::Crypto(crate::error::CryptoError::VerificationFailed)
),
"an unreadable kid leaves the signature failure standing"
);
let held = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
assert!(
matches!(
verify_license_file_with_key_set(&pem, &held, Some("wrong-key")).unwrap_err(),
crate::error::CheckoutError::Crypto(crate::error::CryptoError::DecryptionFailed)
),
"after a verified signature, a decryption failure is a wrong-key report"
);
assert!(verify_license_file_with_key_set(&pem, &held, Some("lic-abc123")).is_ok());
}
#[test]
fn a_held_key_verifies_a_file_whatever_kid_it_names() {
let (pubkey_a, signing_a) = gen_keypair();
let (pubkey_b, _) = gen_keypair();
let a_b64 = pubkey_b64(&pubkey_a);
let b_b64 = pubkey_b64(&pubkey_b);
let pem = build_pem(
&payload_json_with_kid(&crate::crypto::ed25519::key_id(&b_b64)),
&signing_a,
None,
);
let keys =
crate::checkout::key_set::SigningKeySet::from_public_keys([&a_b64, &b_b64]).unwrap();
assert!(verify_license_file_with_key_set(&pem, &keys, None).is_ok());
}
#[test]
fn a_stale_set_with_an_encrypted_file_still_names_the_kid_given_the_licence_key() {
let (_pubkey, signing) = gen_keypair();
let (other_pubkey, _) = gen_keypair();
let enc_key = crate::crypto::hkdf::derive_license_file_key("lic-abc123");
let pem = build_pem(
&payload_json_with_kid("abcdef0123456789"),
&signing,
Some(&enc_key),
);
let stale =
crate::checkout::key_set::SigningKeySet::from_public_keys([pubkey_b64(&other_pubkey)])
.unwrap();
assert!(matches!(
verify_license_file_with_key_set(&pem, &stale, Some("lic-abc123")).unwrap_err(),
crate::error::CheckoutError::UnknownSigningKey { ref kid } if kid == "abcdef0123456789"
));
assert!(matches!(
verify_license_file_with_key_set(&pem, &stale, None).unwrap_err(),
crate::error::CheckoutError::LicenseKeyMissing
));
}
#[test]
fn the_key_set_path_opens_an_encrypted_file_and_still_enforces_exp() {
let (pubkey, signing) = gen_keypair();
let b64 = pubkey_b64(&pubkey);
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 enc_key = crate::crypto::hkdf::derive_license_file_key(license_key);
let exp = 1_767_225_600;
let mut payload: serde_json::Value =
serde_json::from_str(&payload_json_with_kid(&kid)).unwrap();
payload["meta"]["exp"] = serde_json::json!(exp);
let pem = build_pem(&payload.to_string(), &signing, Some(&enc_key));
let verified =
verify_license_file_with_key_set_at(&pem, &keys, Some(license_key), exp - 3600)
.unwrap();
assert_eq!(verified.claims.exp, Some(exp));
let err = verify_license_file_with_key_set_at(&pem, &keys, Some(license_key), exp + 3600)
.unwrap_err();
assert!(matches!(err, crate::error::CheckoutError::Expired { .. }));
assert!(matches!(
verify_license_file_with_key_set(&pem, &keys, None).unwrap_err(),
crate::error::CheckoutError::LicenseKeyMissing
));
}
#[test]
fn the_key_set_path_refuses_a_v1_file_too() {
use base64::Engine as _;
let (pubkey, signing) = gen_keypair();
let b64 = pubkey_b64(&pubkey);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
let pem = build_pem(
&payload_json_with_kid(&crate::crypto::ed25519::key_id(&b64)),
&signing,
None,
);
let body: String = pem.lines().filter(|l| !l.starts_with("-----")).collect();
let cert_json = B64_TEST.decode(body.trim()).unwrap();
let mut cert: serde_json::Value = serde_json::from_slice(&cert_json).unwrap();
cert["alg"] = serde_json::json!("base64+ed25519");
let repacked = B64_TEST.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let v1_pem = format!("{PEM_HEADER}\n{repacked}\n{PEM_FOOTER}");
assert!(matches!(
verify_license_file_with_key_set(&v1_pem, &keys, None).unwrap_err(),
crate::error::CheckoutError::UnsupportedAlgorithm(ref a) if a == "base64+ed25519"
));
}
#[test]
fn a_payload_without_a_kid_claim_is_a_parse_failure_not_an_unknown_key() {
use base64::Engine as _;
let (pubkey, signing) = gen_keypair();
let b64 = pubkey_b64(&pubkey);
let keys = crate::checkout::key_set::SigningKeySet::from_public_keys([&b64]).unwrap();
let mut payload: serde_json::Value =
serde_json::from_str(&representative_payload_json()).unwrap();
payload["meta"].as_object_mut().unwrap().remove("kid");
let enc = B64_TEST.encode(payload.to_string().as_bytes());
let sig = B64_TEST.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_TEST.encode(serde_json::to_string(&cert).unwrap().as_bytes());
let pem = format!("{PEM_HEADER}\n{pem_body}\n{PEM_FOOTER}");
assert!(matches!(
verify_license_file_with_key_set(&pem, &keys, None).unwrap_err(),
crate::error::CheckoutError::InvalidJson(_)
));
}
#[test]
fn decoded_bytes_signature_verification_fails_proving_the_string_bytes_gotcha() {
let (pubkey, signing_key) = gen_keypair();
let payload = representative_payload_json();
use base64::Engine as _;
const B64: base64::engine::GeneralPurpose = base64::engine::general_purpose::STANDARD;
let enc = B64.encode(payload.as_bytes());
let decoded_enc_bytes = B64.decode(&enc).unwrap();
let wrong_sig = signing_key.sign(&decoded_enc_bytes);
let verify_result =
crate::crypto::ed25519::verify(&pubkey, enc.as_bytes(), &wrong_sig.to_bytes());
assert!(
verify_result.is_err(),
"a signature over decoded bytes must not verify against the base64 string bytes"
);
}
}