use rusty_esp_core::capability::Manifest;
use rusty_esp_core::error::Result;
use crate::signer::{DeviceSigner, verify_prehash};
pub const MANIFEST_DOMAIN: &[u8] = b"janus-manifest-v1\n";
pub const MAKER_DOMAIN: &[u8] = b"janus-maker-v1\n";
fn prehash(domain: &[u8], bytes: &[u8]) -> [u8; 32] {
use sha2::Digest;
let mut h = sha2::Sha256::new();
h.update(domain);
h.update(bytes);
h.finalize().into()
}
#[must_use]
pub fn sign_manifest_bytes(manifest_bytes: &[u8], signer: &impl DeviceSigner) -> [u8; 64] {
signer.sign_prehash(&prehash(MANIFEST_DOMAIN, manifest_bytes))
}
pub fn sign_manifest(
manifest: &Manifest<'_>,
signer: &impl DeviceSigner,
out: &mut [u8],
) -> Result<(usize, [u8; 64])> {
let n = manifest.encode(out)?;
Ok((n, sign_manifest_bytes(&out[..n], signer)))
}
pub fn sign_manifest_cached(
manifest: &Manifest<'_>,
key: &crate::DeviceKey,
kv: &mut impl rusty_esp_core::hal::Kv,
name: &str,
out: &mut [u8],
) -> Result<(usize, [u8; 64])> {
let n = manifest.encode(out)?;
Ok((
n,
key.sign_prehash_cached(kv, name, &prehash(MANIFEST_DOMAIN, &out[..n])),
))
}
pub fn verify_manifest(
manifest_bytes: &[u8],
signature: &[u8; 64],
device_pubkey: &[u8],
) -> Result<()> {
verify_prehash(
device_pubkey,
&prehash(MANIFEST_DOMAIN, manifest_bytes),
signature,
)
}
#[must_use]
pub fn maker_prehash(model: &str, firmware: &str) -> [u8; 32] {
use sha2::Digest;
let mut h = sha2::Sha256::new();
h.update(MAKER_DOMAIN);
h.update((model.len() as u16).to_be_bytes());
h.update(model.as_bytes());
h.update((firmware.len() as u16).to_be_bytes());
h.update(firmware.as_bytes());
h.finalize().into()
}
pub fn verify_maker(
model: &str,
firmware: &str,
signature: &[u8; 64],
maker_pubkey: &[u8],
) -> Result<()> {
verify_prehash(maker_pubkey, &maker_prehash(model, firmware), signature)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::key::DeviceKey;
use rusty_esp_core::capability::{Capability, Chip, Declared};
use rusty_esp_core::error::Error;
#[test]
fn manifest_signature_round_trip_and_tamper() {
let k = DeviceKey::from_seed_for_tests("m", "cam-1");
let declared = [
Declared::available(Capability::ImageJpeg, "rusty_esp_image"),
Declared::preview(Capability::MidDevice, "rusty_esp_mid"),
];
let m = Manifest {
model: "acme/doorbell-2",
firmware: "1.4.0",
chip: Chip::Esp32S3,
declared: &declared,
};
let mut buf = [0u8; 512];
let (n, sig) = sign_manifest(&m, &k, &mut buf).unwrap();
verify_manifest(&buf[..n], &sig, k.did().pubkey()).unwrap();
buf[n - 2] ^= 1;
assert_eq!(
verify_manifest(&buf[..n], &sig, k.did().pubkey()),
Err(Error::Crypto)
);
}
#[test]
fn maker_attestation() {
let maker = DeviceKey::from_seed_for_tests("maker", "factory");
let sig = maker.sign_prehash(&maker_prehash("acme/doorbell-2", "1.4.0"));
verify_maker("acme/doorbell-2", "1.4.0", &sig, maker.did().pubkey()).unwrap();
assert_eq!(
verify_maker("acme/doorbell-2", "1.4.1", &sig, maker.did().pubkey()),
Err(Error::Crypto)
);
}
}