use core::fmt;
use p256::ecdsa::signature::hazmat::PrehashSigner;
use p256::ecdsa::{Signature, SigningKey, VerifyingKey};
use rusty_esp_core::error::{Error, Result};
use rusty_esp_core::hal::{Kv, Rng};
use crate::did::Did;
use crate::signer::DeviceSigner;
pub const MAX_DEVICE_ID_LEN: usize = 32;
pub const DEFAULT_DEVICE_ID: &str = "janus";
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct DeviceId {
bytes: [u8; MAX_DEVICE_ID_LEN],
len: u8,
}
impl DeviceId {
pub fn new(id: &str) -> Result<Self> {
let ok = !id.is_empty()
&& id.len() <= MAX_DEVICE_ID_LEN
&& id
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'.' || b == b'-');
if !ok {
return Err(Error::InvalidFormat);
}
let mut bytes = [0u8; MAX_DEVICE_ID_LEN];
bytes[..id.len()].copy_from_slice(id.as_bytes());
Ok(DeviceId {
bytes,
len: id.len() as u8,
})
}
#[must_use]
pub fn as_str(&self) -> &str {
core::str::from_utf8(&self.bytes[..self.len as usize]).unwrap_or(DEFAULT_DEVICE_ID)
}
}
impl fmt::Debug for DeviceId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
pub struct DeviceKey {
key: SigningKey,
device_id: DeviceId,
}
impl fmt::Debug for DeviceKey {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "DeviceKey({}, {})", self.device_id.as_str(), self.did())
}
}
impl DeviceKey {
pub const KV_KEY: &'static str = "mid.devkey";
const GENERATE_ATTEMPTS: usize = 8;
pub fn generate(rng: &mut impl Rng, device_id: &str) -> Result<Self> {
let device_id = DeviceId::new(device_id)?;
let mut secret = [0u8; 32];
for _ in 0..Self::GENERATE_ATTEMPTS {
rng.fill(&mut secret)?;
if let Ok(key) = SigningKey::from_bytes(&secret.into()) {
return Ok(DeviceKey { key, device_id });
}
}
Err(Error::Crypto)
}
pub fn from_secret(secret: &[u8; 32], device_id: &str) -> Result<Self> {
let device_id = DeviceId::new(device_id)?;
let key = SigningKey::from_bytes(&(*secret).into()).map_err(|_| Error::Crypto)?;
Ok(DeviceKey { key, device_id })
}
#[must_use]
pub fn secret_bytes(&self) -> [u8; 32] {
self.key.to_bytes().into()
}
#[must_use]
pub fn device_id(&self) -> &DeviceId {
&self.device_id
}
#[must_use]
pub fn did(&self) -> Did {
Did::from_verifying_key(self.key.verifying_key())
}
#[must_use]
pub fn verifying_key(&self) -> &VerifyingKey {
self.key.verifying_key()
}
#[must_use]
pub fn pubkey_sec1_uncompressed(&self) -> [u8; 65] {
let point = self.key.verifying_key().to_encoded_point(false);
let mut out = [0u8; 65];
out.copy_from_slice(point.as_bytes());
out
}
pub fn load(kv: &impl Kv, device_id: &str) -> Result<Option<Self>> {
let mut secret = [0u8; 32];
match kv.get(Self::KV_KEY, &mut secret)? {
None => Ok(None),
Some(32) => Self::from_secret(&secret, device_id).map(Some),
Some(_) => Err(Error::Corrupt),
}
}
pub fn store(&self, kv: &mut impl Kv) -> Result<()> {
kv.put(Self::KV_KEY, &self.secret_bytes())
}
pub fn load_or_generate(kv: &mut impl Kv, rng: &mut impl Rng, device_id: &str) -> Result<Self> {
if let Some(key) = Self::load(kv, device_id)? {
return Ok(key);
}
let key = Self::generate(rng, device_id)?;
key.store(kv)?;
Ok(key)
}
pub fn shared_secret(&self, their: &Did) -> Result<[u8; 32]> {
let their_pk =
p256::PublicKey::from_sec1_bytes(their.pubkey()).map_err(|_| Error::Crypto)?;
let shared = p256::ecdh::diffie_hellman(self.key.as_nonzero_scalar(), their_pk.as_affine());
let mut out = [0u8; 32];
out.copy_from_slice(shared.raw_secret_bytes());
Ok(out)
}
#[doc(hidden)]
#[must_use]
pub fn from_seed_for_tests(seed: &str, device_id: &str) -> Self {
use sha2::Digest;
let mut h = sha2::Sha256::new();
h.update(seed.as_bytes());
h.update(b"-rusty-esp-mid-test-seed");
let secret: [u8; 32] = h.finalize().into();
Self::from_secret(&secret, device_id)
.expect("hash output is a valid scalar with overwhelming odds")
}
}
impl DeviceSigner for DeviceKey {
fn device_id(&self) -> &str {
self.device_id.as_str()
}
fn sign_prehash(&self, prehash: &[u8; 32]) -> [u8; 64] {
let raw: Signature = self
.key
.sign_prehash(prehash)
.expect("sign_prehash over 32 bytes cannot fail for a valid key");
let sig = raw.normalize_s().unwrap_or(raw);
let mut out = [0u8; 64];
out.copy_from_slice(&sig.to_bytes());
out
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::signer::verify_prehash;
use rusty_esp_core::hal::host::{InsecureTestRng, MemoryKv};
#[test]
fn generate_store_load_is_stable() {
let mut rng = InsecureTestRng::seeded(42);
let mut kv = MemoryKv::new();
let a = DeviceKey::load_or_generate(&mut kv, &mut rng, "cam-1").unwrap();
let b = DeviceKey::load_or_generate(&mut kv, &mut rng, "cam-1").unwrap();
assert_eq!(a.did(), b.did());
assert_eq!(a.secret_bytes(), b.secret_bytes());
assert_eq!(kv.len(), 1);
}
#[test]
fn signatures_are_low_s_and_verify() {
let k = DeviceKey::from_seed_for_tests("k", "dev");
let prehash = crate::sha256(b"hello");
let sig = k.sign_prehash(&prehash);
verify_prehash(k.did().pubkey(), &prehash, &sig).unwrap();
let mut other = prehash;
other[0] ^= 1;
assert_eq!(
verify_prehash(k.did().pubkey(), &other, &sig),
Err(Error::Crypto)
);
}
#[test]
fn device_id_rules() {
assert!(DeviceId::new("cam-1.a_b").is_ok());
assert_eq!(DeviceId::new(""), Err(Error::InvalidFormat));
assert_eq!(DeviceId::new("has space"), Err(Error::InvalidFormat));
assert_eq!(
DeviceId::new("012345678901234567890123456789012"),
Err(Error::InvalidFormat)
);
}
#[test]
fn corrupt_store_is_reported() {
let mut kv = MemoryKv::new();
kv.put(DeviceKey::KV_KEY, &[1, 2, 3]).unwrap();
assert_eq!(DeviceKey::load(&kv, "dev").err(), Some(Error::Corrupt));
}
#[test]
fn ecdh_agrees_both_ways() {
let a = DeviceKey::from_seed_for_tests("a", "a");
let b = DeviceKey::from_seed_for_tests("b", "b");
assert_eq!(
a.shared_secret(&b.did()).unwrap(),
b.shared_secret(&a.did()).unwrap()
);
}
}