#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct OfflineProofVerified;
const PROOF_PREFIX: &str = "v1x0.";
fn build_payload_json(
account_id: uuid::Uuid,
machine_id: uuid::Uuid,
fingerprint: &str,
dataset: &serde_json::Value,
) -> String {
let payload = serde_json::json!({
"account": { "id": account_id },
"machine": { "id": machine_id, "fingerprint": fingerprint },
"dataset": dataset,
});
serde_json::to_string(&payload).expect("serde_json::Value serialization is infallible")
}
pub fn verify_offline_proof(
proof: &str,
account_id: uuid::Uuid,
machine_id: uuid::Uuid,
fingerprint: &str,
dataset: &serde_json::Value,
rsa_pubkey: &[u8],
) -> Result<OfflineProofVerified, crate::error::ProofError> {
let sig_b64 = proof
.strip_prefix(PROOF_PREFIX)
.ok_or(crate::error::ProofError::MalformedProof)?;
use base64::Engine as _;
let sig_bytes = base64::engine::general_purpose::STANDARD
.decode(sig_b64)
.map_err(|_| crate::error::ProofError::InvalidBase64)?;
let payload_json = build_payload_json(account_id, machine_id, fingerprint, dataset);
crate::crypto::rsa::verify_pkcs1(rsa_pubkey, payload_json.as_bytes(), &sig_bytes)?;
Ok(OfflineProofVerified)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn payload_json_field_order_is_alphabetical_not_source_order() {
let account_id = uuid::Uuid::nil();
let machine_id = uuid::Uuid::nil();
let json = build_payload_json(
account_id,
machine_id,
"fp-abc",
&serde_json::json!({ "b": 1, "a": 2 }),
);
let account_pos = json.find("\"account\"").unwrap();
let dataset_pos = json.find("\"dataset\"").unwrap();
let machine_pos = json.find("\"machine\"").unwrap();
assert!(account_pos < dataset_pos, "{json}");
assert!(dataset_pos < machine_pos, "{json}");
let fingerprint_pos = json.find("\"fingerprint\"").unwrap();
let id_pos_in_machine = json[machine_pos..].find("\"id\"").unwrap() + machine_pos;
assert!(fingerprint_pos < id_pos_in_machine, "{json}");
let a_pos = json.find("\"a\":2").unwrap();
let b_pos = json.find("\"b\":1").unwrap();
assert!(a_pos < b_pos, "{json}");
}
#[test]
fn payload_json_matches_a_known_good_server_produced_fixture() {
let account_id: uuid::Uuid = "01926b3e-0000-7000-8000-000000000000".parse().unwrap();
let machine_id: uuid::Uuid = "01926b3e-1111-7000-8000-000000000000".parse().unwrap();
let json = build_payload_json(
account_id,
machine_id,
"fp-abc",
&serde_json::json!({ "cores": 4 }),
);
let expected = format!(
"{{\"account\":{{\"id\":\"{account_id}\"}},\"dataset\":{{\"cores\":4}},\"machine\":{{\"fingerprint\":\"fp-abc\",\"id\":\"{machine_id}\"}}}}"
);
assert_eq!(json, expected);
}
fn gen_rsa_keypair() -> (Vec<u8>, aws_lc_rs::rsa::KeyPair) {
use aws_lc_rs::rsa::{KeyPair as RsaKeyPair, KeySize};
use aws_lc_rs::signature::KeyPair as _;
let kp = RsaKeyPair::generate(KeySize::Rsa2048).unwrap();
let pubkey = kp.public_key().as_ref().to_vec();
(pubkey, kp)
}
fn sign_payload(kp: &aws_lc_rs::rsa::KeyPair, payload_json: &str) -> String {
use aws_lc_rs::rand::SystemRandom;
use aws_lc_rs::signature::RSA_PKCS1_SHA256;
use base64::Engine as _;
let rng = SystemRandom::new();
let mut sig = vec![0u8; kp.public_modulus_len()];
kp.sign(&RSA_PKCS1_SHA256, &rng, payload_json.as_bytes(), &mut sig)
.unwrap();
base64::engine::general_purpose::STANDARD.encode(&sig)
}
#[test]
fn verify_offline_proof_accepts_a_known_good_fixture() {
let (pubkey, kp) = gen_rsa_keypair();
let account_id = uuid::Uuid::nil();
let machine_id = uuid::Uuid::nil();
let dataset = serde_json::json!({ "cores": 4 });
let payload_json = build_payload_json(account_id, machine_id, "fp-abc", &dataset);
let proof = format!("v1x0.{}", sign_payload(&kp, &payload_json));
let result =
verify_offline_proof(&proof, account_id, machine_id, "fp-abc", &dataset, &pubkey);
assert!(result.is_ok(), "{result:?}");
}
#[test]
fn verify_offline_proof_rejects_tampered_dataset() {
let (pubkey, kp) = gen_rsa_keypair();
let account_id = uuid::Uuid::nil();
let machine_id = uuid::Uuid::nil();
let signed_dataset = serde_json::json!({ "cores": 4 });
let payload_json = build_payload_json(account_id, machine_id, "fp-abc", &signed_dataset);
let proof = format!("v1x0.{}", sign_payload(&kp, &payload_json));
let tampered_dataset = serde_json::json!({ "cores": 999 });
let result = verify_offline_proof(
&proof,
account_id,
machine_id,
"fp-abc",
&tampered_dataset,
&pubkey,
);
assert!(result.is_err());
}
#[test]
fn verify_offline_proof_rejects_a_signature_computed_over_reordered_json() {
let (pubkey, kp) = gen_rsa_keypair();
let account_id = uuid::Uuid::nil();
let machine_id = uuid::Uuid::nil();
let dataset = serde_json::json!({ "cores": 4 });
let canonical_json = build_payload_json(account_id, machine_id, "fp-abc", &dataset);
let reordered_json = format!(
"{{\"account\":{{\"id\":\"{account_id}\"}},\"machine\":{{\"id\":\"{machine_id}\",\"fingerprint\":\"fp-abc\"}},\"dataset\":{{\"cores\":4}}}}"
);
assert_ne!(canonical_json, reordered_json);
let proof = format!("v1x0.{}", sign_payload(&kp, &reordered_json));
let result =
verify_offline_proof(&proof, account_id, machine_id, "fp-abc", &dataset, &pubkey);
assert!(
result.is_err(),
"a signature over reordered JSON must not verify against the canonical payload"
);
}
#[test]
fn malformed_prefix_is_rejected_before_any_crypto() {
let (pubkey, _) = gen_rsa_keypair();
let result = verify_offline_proof(
"not-v1x0-prefixed",
uuid::Uuid::nil(),
uuid::Uuid::nil(),
"fp",
&serde_json::json!({}),
&pubkey,
);
assert!(matches!(
result,
Err(crate::error::ProofError::MalformedProof)
));
}
}