use rusty_esp_core::error::{Error, Result};
use sha2::Digest;
use crate::signer::DeviceSigner;
pub const NONCE_DOMAIN: &[u8] = b"kms-nonce-v1\n";
pub const ENVELOPE_VERSION: u8 = 1;
pub const NONCE_TYPE: &str = "nonce";
pub const ASSERTION_TYPE: &str = "signed_assertion";
pub const MAX_TTL_SECS: u64 = 300;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NonceEnvelopeRef<'a> {
pub envelope_version: u8,
pub nonce: &'a [u8],
pub did: &'a str,
pub audience: &'a str,
pub purpose: &'a str,
pub issued_at: u64,
pub expires_at: u64,
pub issuer: &'a str,
}
impl NonceEnvelopeRef<'_> {
pub fn validate(&self) -> Result<()> {
if self.envelope_version != ENVELOPE_VERSION {
return Err(Error::Unsupported);
}
if self.nonce.len() != 32 {
return Err(Error::InvalidFormat);
}
crate::did::Did::parse(self.did)?;
if self.expires_at <= self.issued_at || self.expires_at - self.issued_at > MAX_TTL_SECS {
return Err(Error::InvalidFormat);
}
for field in [self.did, self.audience, self.purpose, self.issuer] {
if field.len() > u16::MAX as usize {
return Err(Error::InvalidFormat);
}
}
Ok(())
}
#[must_use]
pub fn canonical_bytes(&self) -> [u8; 32] {
let mut h = sha2::Sha256::new();
h.update(NONCE_DOMAIN);
h.update([self.envelope_version]);
lp(&mut h, self.nonce);
lp(&mut h, self.did.as_bytes());
lp(&mut h, self.audience.as_bytes());
lp(&mut h, self.purpose.as_bytes());
h.update(self.issued_at.to_be_bytes());
h.update(self.expires_at.to_be_bytes());
lp(&mut h, self.issuer.as_bytes());
h.finalize().into()
}
pub fn sign(&self, signer: &impl DeviceSigner) -> Result<[u8; 64]> {
self.validate()?;
Ok(signer.sign_prehash(&self.canonical_bytes()))
}
}
fn lp(h: &mut sha2::Sha256, bytes: &[u8]) {
let len = u16::try_from(bytes.len()).unwrap_or(u16::MAX);
h.update(len.to_be_bytes());
h.update(bytes);
}
#[cfg(feature = "alloc")]
pub mod json {
use alloc::string::String;
use alloc::vec::Vec;
use rusty_esp_core::error::{Error, Result};
use serde::{Deserialize, Serialize};
use super::{ASSERTION_TYPE, ENVELOPE_VERSION, NONCE_TYPE, NonceEnvelopeRef};
use crate::signer::DeviceSigner;
pub mod b64 {
use alloc::string::String;
use alloc::vec::Vec;
use base64::Engine;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use serde::{Deserialize, Deserializer, Serializer};
pub fn serialize<S: Serializer>(
bytes: &Vec<u8>,
ser: S,
) -> core::result::Result<S::Ok, S::Error> {
ser.serialize_str(&URL_SAFE_NO_PAD.encode(bytes))
}
pub fn deserialize<'de, D: Deserializer<'de>>(
de: D,
) -> core::result::Result<Vec<u8>, D::Error> {
let s = String::deserialize(de)?;
URL_SAFE_NO_PAD
.decode(s.as_bytes())
.map_err(serde::de::Error::custom)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NonceEnvelope {
pub envelope_version: u8,
pub envelope_type: String,
#[serde(with = "b64")]
pub nonce: Vec<u8>,
pub did: String,
pub audience: String,
pub purpose: String,
pub issued_at: u64,
pub expires_at: u64,
pub issuer: String,
}
impl NonceEnvelope {
pub fn from_json(json: &str) -> Result<Self> {
let env: NonceEnvelope =
serde_json::from_str(json).map_err(|_| Error::InvalidFormat)?;
env.validate()?;
Ok(env)
}
#[must_use]
pub fn to_json(&self) -> String {
serde_json::to_string(self).expect("serializing plain fields cannot fail")
}
#[must_use]
pub fn as_ref(&self) -> NonceEnvelopeRef<'_> {
NonceEnvelopeRef {
envelope_version: self.envelope_version,
nonce: &self.nonce,
did: &self.did,
audience: &self.audience,
purpose: &self.purpose,
issued_at: self.issued_at,
expires_at: self.expires_at,
issuer: &self.issuer,
}
}
pub fn validate(&self) -> Result<()> {
if self.envelope_type != NONCE_TYPE {
return Err(Error::InvalidFormat);
}
self.as_ref().validate()
}
pub fn sign(&self, signer: &impl DeviceSigner) -> Result<SignedAssertion> {
let signature = self.as_ref().sign(signer)?;
Ok(SignedAssertion {
envelope_version: ENVELOPE_VERSION,
envelope_type: String::from(ASSERTION_TYPE),
nonce_envelope: self.clone(),
device_id: String::from(signer.device_id()),
signature: signature.to_vec(),
})
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SignedAssertion {
pub envelope_version: u8,
pub envelope_type: String,
pub nonce_envelope: NonceEnvelope,
pub device_id: String,
#[serde(with = "b64")]
pub signature: Vec<u8>,
}
impl SignedAssertion {
#[must_use]
pub fn to_json(&self) -> String {
serde_json::to_string(self).expect("serializing plain fields cannot fail")
}
pub fn from_json(json: &str) -> Result<Self> {
serde_json::from_str(json).map_err(|_| Error::InvalidFormat)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::key::DeviceKey;
fn env<'a>(did: &'a str, nonce: &'a [u8; 32]) -> NonceEnvelopeRef<'a> {
NonceEnvelopeRef {
envelope_version: 1,
nonce,
did,
audience: "home-computer",
purpose: "janus.telemetry",
issued_at: 1_716_583_200,
expires_at: 1_716_583_230,
issuer: "home-computer-gateway",
}
}
#[test]
fn canonical_is_deterministic_and_field_sensitive() {
let k = DeviceKey::from_seed_for_tests("kms", "dev");
let did = k.did().to_did_string();
let nonce = [0xAB; 32];
let a = env(&did, &nonce);
let base = a.canonical_bytes();
assert_eq!(base, a.canonical_bytes());
let mut b = a;
b.purpose = "janus.control";
assert_ne!(base, b.canonical_bytes());
let mut c = a;
c.expires_at += 1;
assert_ne!(base, c.canonical_bytes());
}
#[test]
fn validate_rules() {
let k = DeviceKey::from_seed_for_tests("kms", "dev");
let did = k.did().to_did_string();
let nonce = [1u8; 32];
assert!(env(&did, &nonce).validate().is_ok());
let mut bad = env(&did, &nonce);
bad.expires_at = bad.issued_at + 301;
assert_eq!(bad.validate(), Err(Error::InvalidFormat));
let short = [1u8; 31];
let mut bad = env(&did, &nonce);
bad.nonce = &short;
assert_eq!(bad.validate(), Err(Error::InvalidFormat));
let mut bad = env(&did, &nonce);
bad.envelope_version = 2;
assert_eq!(bad.validate(), Err(Error::Unsupported));
}
}