use ring::{hkdf, hmac};
use std::collections::{HashMap, VecDeque};
use std::sync::Mutex;
pub const VERSION_BYTE: u8 = 0x01;
pub const V1_VERSION_BYTE: u8 = 0x00;
const DOMAIN_TAG: &[u8] = b"zakuro-wire-v2";
const HKDF_SALT: &[u8] = b"zakuro-wire-v1";
pub const DEFAULT_MAX_SKEW_S: u64 = 300;
pub const REPLAY_CAP: usize = 100_000;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Reject;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WireMode {
V1,
V2,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WireConfig {
pub mode: WireMode,
pub accept_v1: bool,
pub max_skew_s: u64,
}
impl WireConfig {
pub fn from_env_fn(get: &dyn Fn(&str) -> Option<String>) -> Self {
let val = |k: &str| get(k).map(|v| v.trim().to_lowercase()).unwrap_or_default();
let mode = if val("ZAKURO_WIRE") == "v2" {
WireMode::V2
} else {
WireMode::V1
};
let max_skew_s = val("ZAKURO_WIRE_MAX_SKEW_S")
.parse::<u64>()
.ok()
.filter(|s| *s > 0)
.unwrap_or(DEFAULT_MAX_SKEW_S);
Self {
mode,
accept_v1: val("ZAKURO_WIRE_ACCEPT_V1") != "0",
max_skew_s,
}
}
pub fn from_env() -> Self {
Self::from_env_fn(&|k| std::env::var(k).ok())
}
}
#[derive(Clone, PartialEq)]
pub struct EnvelopeV2 {
pub job_id: String,
pub tenant_id: String,
pub issued_at_ms: u64,
pub callable: Vec<u8>,
pub args: Vec<u8>,
pub mac: [u8; 32],
pub cpus: f32,
pub memory_mb: u32,
pub gpus: u32,
pub timeout_seconds: u32,
}
impl std::fmt::Debug for EnvelopeV2 {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("EnvelopeV2")
.field("job_id", &self.job_id)
.field("tenant_id", &self.tenant_id)
.finish_non_exhaustive()
}
}
struct Len32;
impl hkdf::KeyType for Len32 {
fn len(&self) -> usize {
32
}
}
pub fn tenant_key(master: &[u8], tenant_id: &str) -> [u8; 32] {
let info = format!("payload-v2:{tenant_id}");
let prk = hkdf::Salt::new(hkdf::HKDF_SHA256, HKDF_SALT).extract(master);
let info_parts = [info.as_bytes()];
let okm = prk
.expand(&info_parts, Len32)
.expect("32 bytes is a valid HKDF-SHA256 output length");
let mut out = [0u8; 32];
okm.fill(&mut out)
.expect("output buffer matches the requested length");
out
}
fn mac_input(e: &EnvelopeV2) -> Vec<u8> {
let mut m = Vec::with_capacity(DOMAIN_TAG.len() + e.callable.len() + e.args.len() + 64);
m.extend_from_slice(DOMAIN_TAG);
let mut field = |b: &[u8]| {
m.extend_from_slice(&(b.len() as u32).to_be_bytes());
m.extend_from_slice(b);
};
field(&[VERSION_BYTE]);
field(e.tenant_id.as_bytes());
field(e.job_id.as_bytes());
field(&e.issued_at_ms.to_be_bytes());
field(&e.callable);
field(&e.args);
m
}
pub fn compute_mac(master: &[u8], e: &EnvelopeV2) -> [u8; 32] {
let key = hmac::Key::new(hmac::HMAC_SHA256, &tenant_key(master, &e.tenant_id));
let tag = hmac::sign(&key, &mac_input(e));
let mut out = [0u8; 32];
out.copy_from_slice(tag.as_ref());
out
}
pub fn sign(master: &[u8], e: &mut EnvelopeV2) {
e.mac = compute_mac(master, e);
}
fn put_varint(out: &mut Vec<u8>, mut v: u64) {
while v >= 0x80 {
out.push((v as u8 & 0x7f) | 0x80);
v >>= 7;
}
out.push(v as u8);
}
fn put_bytes(out: &mut Vec<u8>, b: &[u8]) {
put_varint(out, b.len() as u64);
out.extend_from_slice(b);
}
pub fn encode(e: &EnvelopeV2) -> Vec<u8> {
let mut o = Vec::with_capacity(e.callable.len() + e.args.len() + 96);
o.push(VERSION_BYTE);
put_bytes(&mut o, e.job_id.as_bytes());
put_bytes(&mut o, e.tenant_id.as_bytes());
put_varint(&mut o, e.issued_at_ms);
put_bytes(&mut o, &e.callable);
put_bytes(&mut o, &e.args);
o.extend_from_slice(&e.mac);
o.extend_from_slice(&e.cpus.to_le_bytes());
put_varint(&mut o, u64::from(e.memory_mb));
put_varint(&mut o, u64::from(e.gpus));
put_varint(&mut o, u64::from(e.timeout_seconds));
o
}
struct Rd<'a>(&'a [u8]);
impl<'a> Rd<'a> {
fn take(&mut self, n: usize) -> Result<&'a [u8], Reject> {
if self.0.len() < n {
return Err(Reject);
}
let (a, b) = self.0.split_at(n);
self.0 = b;
Ok(a)
}
fn varint(&mut self) -> Result<u64, Reject> {
let mut v: u64 = 0;
for i in 0..10 {
let b = self.take(1)?[0];
let low = u64::from(b & 0x7f);
if i == 9 && low > 1 {
return Err(Reject);
}
v |= low << (7 * i);
if b & 0x80 == 0 {
if i > 0 && low == 0 {
return Err(Reject);
}
return Ok(v);
}
}
Err(Reject)
}
fn u32(&mut self) -> Result<u32, Reject> {
u32::try_from(self.varint()?).map_err(|_| Reject)
}
fn bytes(&mut self) -> Result<Vec<u8>, Reject> {
let n = usize::try_from(self.varint()?).map_err(|_| Reject)?;
Ok(self.take(n)?.to_vec())
}
fn string(&mut self) -> Result<String, Reject> {
String::from_utf8(self.bytes()?).map_err(|_| Reject)
}
}
pub fn decode(raw: &[u8]) -> Result<EnvelopeV2, Reject> {
let mut r = Rd(raw);
if r.take(1)?[0] != VERSION_BYTE {
return Err(Reject);
}
let job_id = r.string()?;
let tenant_id = r.string()?;
let issued_at_ms = r.varint()?;
let callable = r.bytes()?;
let args = r.bytes()?;
let mut mac = [0u8; 32];
mac.copy_from_slice(r.take(32)?);
let cpus = f32::from_le_bytes(r.take(4)?.try_into().map_err(|_| Reject)?);
let memory_mb = r.u32()?;
let gpus = r.u32()?;
let timeout_seconds = r.u32()?;
if !r.0.is_empty() {
return Err(Reject);
}
Ok(EnvelopeV2 {
job_id,
tenant_id,
issued_at_ms,
callable,
args,
mac,
cpus,
memory_mb,
gpus,
timeout_seconds,
})
}
pub fn peek_version(raw: &[u8]) -> Option<u8> {
raw.first()
.copied()
.filter(|b| *b == V1_VERSION_BYTE || *b == VERSION_BYTE)
}
pub struct ReplayCache {
cap: usize,
inner: Mutex<Inner>,
}
#[derive(Default)]
struct Inner {
seen: HashMap<(String, String), u64>,
order: VecDeque<((String, String), u64)>,
}
impl ReplayCache {
pub fn new() -> Self {
Self::with_cap(REPLAY_CAP)
}
pub fn with_cap(cap: usize) -> Self {
Self {
cap: cap.max(1),
inner: Mutex::new(Inner::default()),
}
}
fn check_and_insert(&self, tenant: &str, job: &str, now_ms: u64, ttl_ms: u64) -> bool {
let mut g = self.inner.lock().unwrap_or_else(|p| p.into_inner());
while let Some((k, at)) = g.order.front().cloned() {
if now_ms.saturating_sub(at) < ttl_ms && g.seen.len() < self.cap {
break;
}
g.order.pop_front();
if g.seen.get(&k) == Some(&at) {
g.seen.remove(&k);
}
}
let key = (tenant.to_string(), job.to_string());
if g.seen.contains_key(&key) {
return false;
}
g.seen.insert(key.clone(), now_ms);
g.order.push_back((key, now_ms));
true
}
}
impl Default for ReplayCache {
fn default() -> Self {
Self::new()
}
}
pub fn verify(
master: &[u8],
e: &EnvelopeV2,
now_ms: u64,
max_skew_s: u64,
cache: &ReplayCache,
) -> Result<(), Reject> {
let key = hmac::Key::new(hmac::HMAC_SHA256, &tenant_key(master, &e.tenant_id));
hmac::verify(&key, &mac_input(e), &e.mac).map_err(|_| Reject)?;
let skew_ms = max_skew_s.saturating_mul(1000);
if now_ms.abs_diff(e.issued_at_ms) > skew_ms {
return Err(Reject);
}
if !cache.check_and_insert(&e.tenant_id, &e.job_id, now_ms, skew_ms.saturating_mul(2)) {
return Err(Reject);
}
Ok(())
}
pub fn now_ms() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
#[cfg(test)]
mod tests {
use super::*;
const MASTER: [u8; 32] = [0x11; 32];
const T0: u64 = 1_760_000_000_000;
fn sample() -> EnvelopeV2 {
EnvelopeV2 {
job_id: "job-1".into(),
tenant_id: "acme".into(),
issued_at_ms: T0,
callable: b"callable-bytes".to_vec(),
args: b"args-bytes".to_vec(),
mac: [0; 32],
cpus: 1.0,
memory_mb: 1024,
gpus: 0,
timeout_seconds: 60,
}
}
#[test]
fn wire_v2_fixed_vectors() {
assert_eq!(
hex::encode(tenant_key(&MASTER, "acme")),
"b38c960e38b07c76a04fcfad14e1d433c43127dea5dc847eb109be0440e59e32"
);
let mut e = sample();
sign(&MASTER, &mut e);
assert_eq!(
hex::encode(e.mac),
"415981780bfa27bbdb5b06422fb7534290d98b31594d6ac07def49cb827349f2"
);
let wire = encode(&e);
assert_eq!(
hex::encode(&wire),
"01056a6f622d310461636d658080b3c19c330e63616c6c61626c652d62797465730a617267732d6279746573415981780bfa27bbdb5b06422fb7534290d98b31594d6ac07def49cb827349f20000803f8008003c"
);
assert_eq!(decode(&wire).unwrap(), e);
assert_eq!(peek_version(&wire), Some(VERSION_BYTE));
}
fn signed() -> EnvelopeV2 {
let mut e = sample();
sign(&MASTER, &mut e);
e
}
#[test]
fn wire_v2_accepts_fresh_and_rejects_replay() {
let c = ReplayCache::new();
let e = signed();
assert!(verify(&MASTER, &e, T0 + 1000, 300, &c).is_ok());
assert_eq!(verify(&MASTER, &e, T0 + 2000, 300, &c), Err(Reject));
let mut e2 = sample();
e2.job_id = "job-2".into();
sign(&MASTER, &mut e2);
assert!(verify(&MASTER, &e2, T0, 300, &c).is_ok());
}
#[test]
fn wire_v2_rejects_stale_and_future_but_does_not_cache_them() {
let c = ReplayCache::new();
let e = signed();
assert_eq!(verify(&MASTER, &e, T0 + 301_000, 300, &c), Err(Reject));
assert_eq!(verify(&MASTER, &e, T0 - 301_000, 300, &c), Err(Reject));
assert!(verify(&MASTER, &e, T0 + 300_000, 300, &c).is_ok());
}
#[test]
fn wire_v2_rejects_tamper_and_field_shifting() {
let c = ReplayCache::new();
let mut shifted = signed();
shifted.callable.push(shifted.args.remove(0));
assert_eq!(verify(&MASTER, &shifted, T0, 300, &c), Err(Reject));
let mut t = signed();
t.tenant_id = "other".into();
assert_eq!(verify(&MASTER, &t, T0, 300, &c), Err(Reject));
let mut ts = signed();
ts.issued_at_ms += 1;
assert_eq!(verify(&MASTER, &ts, T0, 300, &c), Err(Reject));
assert_eq!(verify(&[0x22; 32], &signed(), T0, 300, &c), Err(Reject));
assert!(verify(&MASTER, &signed(), T0, 300, &c).is_ok());
}
#[test]
fn wire_v2_replay_cache_evicts_oldest_at_cap_and_expires() {
let c = ReplayCache::with_cap(2);
assert!(c.check_and_insert("t", "a", 0, 1000));
assert!(c.check_and_insert("t", "b", 1, 1000));
assert!(c.check_and_insert("t", "c", 2, 1000)); assert!(!c.check_and_insert("t", "c", 3, 1000));
assert!(c.check_and_insert("t", "a", 4, 1000));
assert!(c.check_and_insert("t", "c", 5000, 1000)); }
#[test]
fn wire_v2_decode_rejects_malformed() {
let wire = encode(&signed());
assert!(decode(&wire[..wire.len() - 1]).is_err());
let mut extra = wire.clone();
extra.push(0);
assert!(decode(&extra).is_err());
let mut v1 = wire.clone();
v1[0] = V1_VERSION_BYTE;
assert!(decode(&v1).is_err());
assert!(decode(&[]).is_err());
assert_eq!(peek_version(&v1), Some(V1_VERSION_BYTE));
assert_eq!(peek_version(&[7]), None);
}
#[test]
fn wire_v2_config_switch() {
let none = |_: &str| None;
let c = WireConfig::from_env_fn(&none);
assert_eq!(
c,
WireConfig {
mode: WireMode::V1,
accept_v1: true,
max_skew_s: 300
}
);
let env = |k: &str| match k {
"ZAKURO_WIRE" => Some(" V2 ".to_string()),
"ZAKURO_WIRE_ACCEPT_V1" => Some("0".to_string()),
"ZAKURO_WIRE_MAX_SKEW_S" => Some("60".to_string()),
_ => None,
};
let c = WireConfig::from_env_fn(&env);
assert_eq!(c.mode, WireMode::V2);
assert!(!c.accept_v1);
assert_eq!(c.max_skew_s, 60);
}
}