Update to heapless 0.9

Author: sosthene-nitrokey

Cargo.toml

@@ -8,8 +8,8 @@ homepage = "https://trussed.dev"
 license = "Apache-2.0 OR MIT"
 
 [workspace.dependencies]
-heapless = "0.7"
-heapless-bytes = "0.3"
+heapless = "0.9"
+heapless-bytes = { version = "0.5", features = ["heapless-0.9"]}
 littlefs2-core = { version = "0.1", features = ["serde"] }
 postcard = "0.7.0"
 rand_core = "0.6"
@@ -35,7 +35,7 @@ bitflags = { version = "2.1" }
 # const-oid = "0.4.5"
 cfg-if = "1.0"
 embedded-hal = { version = "0.2.3", features = ["unproven"] }
-flexiber = { version = "0.1.0", features = ["derive", "heapless"] }
+flexiber = { version = "0.2.0", features = ["derive", "heapless"] }
 generic-array = "0.14.4"
 heapless = { workspace = true, features = ["serde"] }
 hex-literal = "0.4.1"
@@ -51,20 +51,20 @@ aes = { version = "0.8", default-features = false }
 cbc = "0.1.2"
 blake2 = { version = "0.10", default-features = false, optional = true }
 chacha20 = { version = "0.9", default-features = false }
-chacha20poly1305 = { version = "0.10", default-features = false, features = ["heapless", "reduced-round"] }
+chacha20poly1305 = { version = "0.10", default-features = false, features = ["reduced-round"] }
 des = { version = "0.8", optional = true }
 hmac = "0.12"
 sha-1 = { version = "0.10", default-features = false, optional = true }
 sha2 = { version = "0.10", default-features = false }
 
 # ours
-cosey = "0.3"
+cosey = "0.4"
 delog = "0.1.0"
-cbor-smol = { version = "0.5", features = ["heapless-bytes-v0-3"] }
+cbor-smol = { version = "0.5", features = ["heapless-bytes-v0-5"] }
 heapless-bytes.workspace = true
 interchange = "0.3.0"
-littlefs2 = "0.5.0"
-littlefs2-core = { workspace = true, features = ["heapless-bytes03"] }
+littlefs2 = "0.7.0"
+littlefs2-core = { workspace = true, features = ["heapless-bytes05"] }
 p256-cortex-m4 = { version = "0.1.0-alpha.6", features = ["prehash", "sec1-signatures"] }
 salty = { version = "0.3.0", features = ["cose"] }
 p384 = { version = "0.13.0", optional = true, default-features = false, features = ["sha384", "ecdh", "ecdsa"] }
@@ -91,6 +91,7 @@ virt = ["std"]
 
 log-all = []
 log-none = []
+log-trace = []
 log-info = []
 log-debug = []
 log-warn = []

core/src/client.rs

@@ -87,7 +87,7 @@ pub trait CertificateClient: PollClient {
         location: Location,
         der: &[u8],
     ) -> ClientResult<'_, reply::WriteCertificate, Self> {
-        let der = Message::from_slice(der).map_err(|_| ClientError::DataTooLarge)?;
+        let der = Message::try_from(der).map_err(|_| ClientError::DataTooLarge)?;
         self.request(request::WriteCertificate { location, der })
     }
 }
@@ -134,11 +134,11 @@ pub trait CryptoClient: PollClient {
         nonce: &[u8],
         tag: &[u8],
     ) -> ClientResult<'c, reply::Decrypt, Self> {
-        let message = Message::from_slice(message).map_err(|_| ClientError::DataTooLarge)?;
+        let message = Message::try_from(message).map_err(|_| ClientError::DataTooLarge)?;
         let associated_data =
-            Message::from_slice(associated_data).map_err(|_| ClientError::DataTooLarge)?;
-        let nonce = ShortData::from_slice(nonce).map_err(|_| ClientError::DataTooLarge)?;
-        let tag = ShortData::from_slice(tag).map_err(|_| ClientError::DataTooLarge)?;
+            Message::try_from(associated_data).map_err(|_| ClientError::DataTooLarge)?;
+        let nonce = ShortData::try_from(nonce).map_err(|_| ClientError::DataTooLarge)?;
+        let tag = ShortData::try_from(tag).map_err(|_| ClientError::DataTooLarge)?;
         self.request(request::Decrypt {
             mechanism,
             key,
@@ -196,7 +196,7 @@ pub trait CryptoClient: PollClient {
         attributes: StorageAttributes,
     ) -> ClientResult<'c, reply::DeserializeKey, Self> {
         let serialized_key =
-            SerializedKey::from_slice(serialized_key).map_err(|_| ClientError::DataTooLarge)?;
+            SerializedKey::try_from(serialized_key).map_err(|_| ClientError::DataTooLarge)?;
         self.request(request::DeserializeKey {
             mechanism,
             serialized_key,
@@ -213,9 +213,9 @@ pub trait CryptoClient: PollClient {
         associated_data: &[u8],
         nonce: Option<ShortData>,
     ) -> ClientResult<'c, reply::Encrypt, Self> {
-        let message = Message::from_slice(message).map_err(|_| ClientError::DataTooLarge)?;
+        let message = Message::try_from(message).map_err(|_| ClientError::DataTooLarge)?;
         let associated_data =
-            ShortData::from_slice(associated_data).map_err(|_| ClientError::DataTooLarge)?;
+            ShortData::try_from(associated_data).map_err(|_| ClientError::DataTooLarge)?;
         self.request(request::Encrypt {
             mechanism,
             key,
@@ -290,7 +290,7 @@ pub trait CryptoClient: PollClient {
         self.request(request::Sign {
             key,
             mechanism,
-            message: Bytes::from_slice(data).map_err(|_| ClientError::DataTooLarge)?,
+            message: Bytes::try_from(data).map_err(|_| ClientError::DataTooLarge)?,
             format,
         })
     }
@@ -306,8 +306,8 @@ pub trait CryptoClient: PollClient {
         self.request(request::Verify {
             mechanism,
             key,
-            message: Message::from_slice(message).expect("all good"),
-            signature: Signature::from_slice(signature).expect("all good"),
+            message: Message::try_from(message).expect("all good"),
+            signature: Signature::try_from(signature).expect("all good"),
             format,
         })
     }
@@ -321,7 +321,7 @@ pub trait CryptoClient: PollClient {
     ) -> ClientResult<'_, reply::UnsafeInjectKey, Self> {
         self.request(request::UnsafeInjectKey {
             mechanism,
-            raw_key: SerializedKey::from_slice(raw_key).unwrap(),
+            raw_key: SerializedKey::try_from(raw_key).unwrap(),
             attributes: StorageAttributes::new().set_persistence(persistence),
             format,
         })
@@ -333,7 +333,7 @@ pub trait CryptoClient: PollClient {
         location: Location,
     ) -> ClientResult<'_, reply::UnsafeInjectSharedKey, Self> {
         self.request(request::UnsafeInjectSharedKey {
-            raw_key: ShortData::from_slice(raw_key).unwrap(),
+            raw_key: ShortData::try_from(raw_key).unwrap(),
             location,
         })
     }
@@ -348,8 +348,8 @@ pub trait CryptoClient: PollClient {
         attributes: StorageAttributes,
     ) -> ClientResult<'c, reply::UnwrapKey, Self> {
         let associated_data =
-            Message::from_slice(associated_data).map_err(|_| ClientError::DataTooLarge)?;
-        let nonce = ShortData::from_slice(nonce).map_err(|_| ClientError::DataTooLarge)?;
+            Message::try_from(associated_data).map_err(|_| ClientError::DataTooLarge)?;
+        let nonce = ShortData::try_from(nonce).map_err(|_| ClientError::DataTooLarge)?;
         self.request(request::UnwrapKey {
             mechanism,
             wrapping_key,
@@ -369,7 +369,7 @@ pub trait CryptoClient: PollClient {
         nonce: Option<ShortData>,
     ) -> ClientResult<'_, reply::WrapKey, Self> {
         let associated_data =
-            Bytes::from_slice(associated_data).map_err(|_| ClientError::DataTooLarge)?;
+            Bytes::try_from(associated_data).map_err(|_| ClientError::DataTooLarge)?;
         self.request(request::WrapKey {
             mechanism,
             wrapping_key,

core/src/client/mechanisms.rs

@@ -28,7 +28,7 @@ pub trait Aes256Cbc: CryptoClient {
             wrapping_key,
             key,
             &[],
-            iv.and_then(|iv| ShortData::from_slice(iv).ok()),
+            iv.and_then(|iv| ShortData::try_from(iv).ok()),
         )
     }
 }
@@ -64,7 +64,7 @@ pub trait Chacha8Poly1305: CryptoClient {
             key,
             message,
             associated_data,
-            nonce.and_then(|nonce| ShortData::from_slice(nonce).ok()),
+            nonce.and_then(|nonce| ShortData::try_from(nonce).ok()),
         )
     }
 
@@ -88,7 +88,7 @@ pub trait Chacha8Poly1305: CryptoClient {
         self.unwrap_key(
             Mechanism::Chacha8Poly1305,
             wrapping_key,
-            Message::from_slice(wrapped_key).map_err(|_| ClientError::DataTooLarge)?,
+            Message::try_from(wrapped_key).map_err(|_| ClientError::DataTooLarge)?,
             associated_data,
             &[],
             StorageAttributes::new().set_persistence(location),
@@ -107,7 +107,7 @@ pub trait Chacha8Poly1305: CryptoClient {
             wrapping_key,
             key,
             associated_data,
-            nonce.and_then(|nonce| ShortData::from_slice(nonce).ok()),
+            nonce.and_then(|nonce| ShortData::try_from(nonce).ok()),
         )
     }
 }
@@ -122,7 +122,7 @@ pub trait HmacBlake2s: CryptoClient {
         self.derive_key(
             Mechanism::HmacBlake2s,
             base_key,
-            Some(MediumData::from_slice(message).map_err(|_| ClientError::DataTooLarge)?),
+            Some(MediumData::try_from(message).map_err(|_| ClientError::DataTooLarge)?),
             StorageAttributes::new().set_persistence(persistence),
         )
     }
@@ -151,7 +151,7 @@ pub trait HmacSha1: CryptoClient {
         self.derive_key(
             Mechanism::HmacSha1,
             base_key,
-            Some(MediumData::from_slice(message).map_err(|_| ClientError::DataTooLarge)?),
+            Some(MediumData::try_from(message).map_err(|_| ClientError::DataTooLarge)?),
             StorageAttributes::new().set_persistence(persistence),
         )
     }
@@ -180,7 +180,7 @@ pub trait HmacSha256: CryptoClient {
         self.derive_key(
             Mechanism::HmacSha256,
             base_key,
-            Some(MediumData::from_slice(message).map_err(|_| ClientError::DataTooLarge)?),
+            Some(MediumData::try_from(message).map_err(|_| ClientError::DataTooLarge)?),
             StorageAttributes::new().set_persistence(persistence),
         )
     }
@@ -209,7 +209,7 @@ pub trait HmacSha512: CryptoClient {
         self.derive_key(
             Mechanism::HmacSha512,
             base_key,
-            Some(MediumData::from_slice(message).map_err(|_| ClientError::DataTooLarge)?),
+            Some(MediumData::try_from(message).map_err(|_| ClientError::DataTooLarge)?),
             StorageAttributes::new().set_persistence(persistence),
         )
     }
@@ -568,7 +568,7 @@ pub trait Sha256: CryptoClient {
     fn hash_sha256<'c>(&'c mut self, message: &[u8]) -> ClientResult<'c, reply::Hash, Self> {
         self.hash(
             Mechanism::Sha256,
-            Message::from_slice(message).map_err(|_| ClientError::DataTooLarge)?,
+            Message::try_from(message).map_err(|_| ClientError::DataTooLarge)?,
         )
     }
 }

core/src/serde_extensions.rs

@@ -20,6 +20,16 @@ use crate::{
     types::Bytes,
 };
 
+pub(crate) fn postcard_serialize_bytes<T: serde::Serialize, const N: usize>(
+    object: &T,
+) -> postcard::Result<Bytes<N>> {
+    let mut vec = Bytes::new();
+    vec.resize_to_capacity();
+    let serialized = postcard::to_slice(object, &mut vec)?.len();
+    vec.resize(serialized, 0).unwrap();
+    Ok(vec)
+}
+
 /// A Trussed API extension.
 pub trait Extension {
     /// The requests supported by this extension.
@@ -37,8 +47,7 @@ pub trait Extension {
         id: u8,
         request: &Self::Request,
     ) -> Result<request::SerdeExtension, ClientError> {
-        postcard::to_vec(request)
-            .map(Bytes::from)
+        postcard_serialize_bytes(request)
             .map(|request| request::SerdeExtension { id, request })
             .map_err(|_| ClientError::SerializationFailed)
     }
@@ -60,8 +69,7 @@ pub trait Extension {
     /// crate releases.
     #[inline(never)]
     fn serialize_reply(reply: &Self::Reply) -> Result<reply::SerdeExtension, Error> {
-        postcard::to_vec(reply)
-            .map(Bytes::from)
+        postcard_serialize_bytes(reply)
             .map(|reply| reply::SerdeExtension { reply })
             .map_err(|_| Error::ReplySerializationFailure)
     }

src/lib.rs

@@ -66,8 +66,11 @@ pub(crate) use postcard::from_bytes as postcard_deserialize;
 pub(crate) fn postcard_serialize_bytes<T: serde::Serialize, const N: usize>(
     object: &T,
 ) -> postcard::Result<Bytes<N>> {
-    let vec = postcard::to_vec(object)?;
-    Ok(Bytes::from(vec))
+    let mut vec = Bytes::new();
+    vec.resize_to_capacity();
+    let serialized = postcard::to_slice(object, &mut vec)?.len();
+    vec.resize(serialized, 0).unwrap();
+    Ok(vec)
 }
 
 #[cfg(test)]

src/mechanisms/aes256cbc.rs

@@ -57,7 +57,7 @@ impl Encrypt for super::Aes256Cbc {
             .encrypt_padded_mut::<ZeroPadding>(&mut buffer, l)
             .unwrap();
 
-        let ciphertext = Message::from_slice(ciphertext).unwrap();
+        let ciphertext = Message::try_from(ciphertext).unwrap();
         Ok(reply::Encrypt {
             ciphertext,
             nonce: ShortData::new(),
@@ -78,7 +78,7 @@ impl WrapKey for super::Aes256Cbc {
 
         // let message: Message = serialized_key.material.try_to_byte_buf().map_err(|_| Error::InternalError)?;
 
-        let message = Message::from_slice(
+        let message = Message::try_from(
             keystore
                 .load_key(key::Secrecy::Secret, None, &request.key)?
                 .material
@@ -152,7 +152,7 @@ impl Decrypt for super::Aes256Cbc {
             .decrypt_padded_mut::<ZeroPadding>(&mut buffer)
             .unwrap();
         // hprintln!("decrypted: {:?}", &plaintext).ok();
-        let plaintext = Message::from_slice(plaintext).unwrap();
+        let plaintext = Message::try_from(plaintext).unwrap();
 
         Ok(reply::Decrypt {
             plaintext: Some(plaintext),

src/mechanisms/chacha8poly1305.rs

@@ -155,8 +155,8 @@ impl Encrypt for super::Chacha8Poly1305 {
             .try_into()
             .unwrap();
 
-        let nonce = ShortData::from_slice(&nonce).unwrap();
-        let tag = ShortData::from_slice(&tag).unwrap();
+        let nonce = ShortData::try_from(&nonce).unwrap();
+        let tag = ShortData::try_from(&tag).unwrap();
 
         // let ciphertext = Message::from_slice(&ciphertext).unwrap();
         Ok(reply::Encrypt {
@@ -179,7 +179,7 @@ impl WrapKey for super::Chacha8Poly1305 {
         // TODO: need to check both secret and private keys
         let serialized_key = keystore.load_key(key::Secrecy::Secret, None, &request.key)?;
 
-        let message = Message::from_slice(&serialized_key.serialize()).unwrap();
+        let message = Message::try_from(&*serialized_key.serialize()).unwrap();
 
         let encryption_request = request::Encrypt {
             mechanism: Mechanism::Chacha8Poly1305,

src/mechanisms/ed255.rs

@@ -140,7 +140,7 @@ impl SerializeKey for super::Ed255 {
                 let cose_pk = cosey::Ed25519PublicKey {
                     // x: Bytes::from_slice(public_key.x_coordinate()).unwrap(),
                     // x: Bytes::from_slice(&buf).unwrap(),
-                    x: Bytes::from_slice(public_key.as_bytes()).unwrap(),
+                    x: Bytes::try_from(public_key.as_bytes()).unwrap(),
                 };
                 crate::cbor_serialize_bytes(&cose_pk).map_err(|_| Error::CborError)?
             }
@@ -196,7 +196,7 @@ impl Sign for super::Ed255 {
         let keypair = load_keypair(keystore, &key_id)?;
 
         let native_signature = keypair.sign(&request.message);
-        let our_signature = Signature::from_slice(&native_signature.to_bytes()).unwrap();
+        let our_signature = Signature::try_from(&native_signature.to_bytes()).unwrap();
 
         // hprintln!("Ed255 signature:").ok();
         // hprintln!("msg: {:?}", &request.message).ok();

src/mechanisms/hmacsha1.rs

@@ -60,7 +60,7 @@ impl Sign for super::HmacSha1 {
 
         mac.update(&request.message);
         let result = mac.finalize();
-        let signature = Signature::from_slice(&result.into_bytes()).unwrap();
+        let signature = Signature::try_from(&*result.into_bytes()).unwrap();
 
         Ok(reply::Sign { signature })
     }

src/mechanisms/hmacsha256.rs

@@ -65,7 +65,7 @@ impl Sign for super::HmacSha256 {
 
         mac.update(&request.message);
         let result = mac.finalize();
-        let signature = Signature::from_slice(&result.into_bytes()).unwrap();
+        let signature = Signature::try_from(&*result.into_bytes()).unwrap();
 
         Ok(reply::Sign { signature })
     }