feat: brought updates from tock-tbf into tbf-parser

Author: AliwiWalid

tbf-parser/src/parse.rs

@@ -143,6 +143,7 @@ pub fn parse_tbf_header(
                     types::TbfHeaderV2StoragePermissions<8>,
                 > = None;
                 let mut kernel_version: Option<types::TbfHeaderV2KernelVersion> = None;
+                let mut short_id: Option<types::TbfHeaderV2ShortId> = None;
 
                 // Iterate the remainder of the header looking for TLV entries.
                 while !remaining.is_empty() {
@@ -282,6 +283,22 @@ pub fn parse_tbf_header(
                             }
                         }
 
+                        types::TbfHeaderTypes::TbfHeaderShortId => {
+                            let entry_len = mem::size_of::<types::TbfHeaderV2ShortId>();
+                            if tlv_header.length as usize == entry_len {
+                                short_id = Some(
+                                    remaining
+                                        .get(0..entry_len)
+                                        .ok_or(types::TbfParseError::NotEnoughFlash)?
+                                        .try_into()?,
+                                );
+                            } else {
+                                return Err(types::TbfParseError::BadTlvEntry(
+                                    tlv_header.tipe as usize,
+                                ));
+                            }
+                        }
+
                         _ => {}
                     }
 
@@ -303,6 +320,7 @@ pub fn parse_tbf_header(
                     permissions: permissions_pointer,
                     storage_permissions: storage_permissions_pointer,
                     kernel_version,
+                    short_id,
                 };
 
                 Ok(types::TbfHeader::TbfHeaderV2(tbf_header))
@@ -332,4 +350,4 @@ pub fn parse_tbf_footer(
         }
         _ => Err(types::TbfParseError::BadTlvEntry(tlv_header.tipe as usize)),
     }
-}
+}

tbf-parser/src/types.rs

@@ -94,19 +94,21 @@ impl fmt::Debug for TbfParseError {
         match self {
             TbfParseError::NotEnoughFlash => write!(f, "Buffer too short to parse TBF header"),
             TbfParseError::UnsupportedVersion(version) => {
-                write!(f, "TBF version {version} unsupported")
+                write!(f, "TBF version {} unsupported", version)
             }
             TbfParseError::ChecksumMismatch(app, calc) => write!(
                 f,
-                "Checksum verification failed: app:{app:#x}, calc:{calc:#x}"
+                "Checksum verification failed: app:{:#x}, calc:{:#x}",
+                app, calc
             ),
-            TbfParseError::BadTlvEntry(tipe) => write!(f, "TLV entry type {tipe} is invalid"),
+            TbfParseError::BadTlvEntry(tipe) => write!(f, "TLV entry type {} is invalid", tipe),
             TbfParseError::BadProcessName => write!(f, "Process name not UTF-8"),
             TbfParseError::InternalError => write!(f, "Internal kernel error. This is a bug."),
             TbfParseError::TooManyEntries(tipe) => {
                 write!(
                     f,
-                    "There are too many variable entries of {tipe} for Tock to parse"
+                    "There are too many variable entries of {} for Tock to parse",
+                    tipe
                 )
             }
             TbfParseError::PackageNameTooLong => write!(f, "The package name is too long."),
@@ -137,6 +139,7 @@ pub enum TbfHeaderTypes {
     TbfHeaderStoragePermissions = 7,
     TbfHeaderKernelVersion = 8,
     TbfHeaderProgram = 9,
+    TbfHeaderShortId = 10,
     TbfFooterCredentials = 128,
 
     /// Some field in the header that we do not understand. Since the TLV format
@@ -254,6 +257,14 @@ pub struct TbfHeaderV2KernelVersion {
     minor: u16,
 }
 
+/// The v2 ShortId for apps.
+///
+/// Header to specify a fixed ShortID for an app.
+#[derive(Clone, Copy, Debug)]
+pub struct TbfHeaderV2ShortId {
+    short_id: Option<core::num::NonZeroU32>,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum TbfFooterV2CredentialsType {
     Reserved = 0,
@@ -262,6 +273,7 @@ pub enum TbfFooterV2CredentialsType {
     SHA256 = 3,
     SHA384 = 4,
     SHA512 = 5,
+    EcdsaNistP256 = 6,
 }
 
 /// Reference: https://github.com/tock/tock/blob/master/doc/reference/trd-appid.md#52-credentials-footer
@@ -274,6 +286,7 @@ pub enum TbfFooterV2Credentials {
     SHA256(TbfFooterV2SHA<32>),
     SHA384(TbfFooterV2SHA<48>),
     SHA512(TbfFooterV2SHA<64>),
+    EcdsaNistP256(TbfFooterV2Ecdsa<256>),
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -287,6 +300,14 @@ pub struct TbfFooterV2RSA<const L: usize> {
     signature: [u8; L],
 }
 
+#[derive(Clone, Copy, Debug)]
+pub struct TbfFooterV2Ecdsa<const L: usize> {
+    public_key_x: [u8; 32],
+    public_key_y: [u8; 32],
+    signature_r: [u8; 32],
+    signature_s: [u8; 32],
+}
+
 impl<const L: usize> TbfFooterV2SHA<L> {
     pub fn get_format(&self) -> Result<TbfFooterV2CredentialsType, TbfParseError> {
         match L {
@@ -320,7 +341,28 @@ impl<const L: usize> TbfFooterV2RSA<L> {
     }
 }
 
-// Conversion functions from slices to the various TBF fields.
+impl<const L: usize> TbfFooterV2Ecdsa<L>{
+    pub fn get_format(&self) -> Result<TbfFooterV2CredentialsType, TbfParseError> {
+        Ok(TbfFooterV2CredentialsType::EcdsaNistP256)
+    }
+
+    pub fn get_public_key_x(&self) -> &[u8; 32] {
+        &self.public_key_x
+    }
+
+    pub fn get_public_key_y(&self) -> &[u8; 32] {
+        &self.public_key_y
+    }
+
+    pub fn get_signature_r(&self) -> &[u8; 32] {
+        &self.signature_r
+    }
+
+    pub fn get_signature_s(&self) -> &[u8; 32] {
+        &self.signature_s
+    }
+}
+
 
 impl core::convert::TryFrom<&[u8]> for TbfHeaderV2Base {
     type Error = TbfParseError;
@@ -372,6 +414,7 @@ impl core::convert::TryFrom<u16> for TbfHeaderTypes {
             7 => Ok(TbfHeaderTypes::TbfHeaderStoragePermissions),
             8 => Ok(TbfHeaderTypes::TbfHeaderKernelVersion),
             9 => Ok(TbfHeaderTypes::TbfHeaderProgram),
+            10 => Ok(TbfHeaderTypes::TbfHeaderShortId),
             128 => Ok(TbfHeaderTypes::TbfFooterCredentials),
             _ => Ok(TbfHeaderTypes::Unknown),
         }
@@ -675,6 +718,20 @@ impl core::convert::TryFrom<&[u8]> for TbfHeaderV2KernelVersion {
     }
 }
 
+impl core::convert::TryFrom<&[u8]> for TbfHeaderV2ShortId {
+    type Error = TbfParseError;
+
+    fn try_from(b: &[u8]) -> Result<TbfHeaderV2ShortId, Self::Error> {
+        Ok(TbfHeaderV2ShortId {
+            short_id: core::num::NonZeroU32::new(u32::from_le_bytes(
+                b.get(0..4)
+                    .ok_or(TbfParseError::InternalError)?
+                    .try_into()?,
+            )),
+        })
+    }
+}
+
 impl core::convert::TryFrom<&[u8]> for TbfFooterV2Credentials {
     type Error = TbfParseError;
 
@@ -691,6 +748,7 @@ impl core::convert::TryFrom<&[u8]> for TbfFooterV2Credentials {
             3 => TbfFooterV2CredentialsType::SHA256,
             4 => TbfFooterV2CredentialsType::SHA384,
             5 => TbfFooterV2CredentialsType::SHA512,
+            6 => TbfFooterV2CredentialsType::EcdsaNistP256,
             _ => {
                 return Err(TbfParseError::InternalError);
             }
@@ -702,6 +760,7 @@ impl core::convert::TryFrom<&[u8]> for TbfFooterV2Credentials {
             TbfFooterV2CredentialsType::SHA256 => 32,
             TbfFooterV2CredentialsType::SHA384 => 48,
             TbfFooterV2CredentialsType::SHA512 => 64,
+            TbfFooterV2CredentialsType::EcdsaNistP256 => 64,
         };
 
         let data = b
@@ -747,6 +806,22 @@ impl core::convert::TryFrom<&[u8]> for TbfFooterV2Credentials {
                         .map_err(|_| TbfParseError::InternalError)?,
                 }))
             }
+            TbfFooterV2CredentialsType::EcdsaNistP256 => {
+                Ok(TbfFooterV2Credentials::EcdsaNistP256(TbfFooterV2Ecdsa {
+                    public_key_x: data[0..32]
+                        .try_into()
+                        .map_err(|_| TbfParseError::InternalError)?,
+                    public_key_y: data[32..64]
+                        .try_into()
+                        .map_err(|_| TbfParseError::InternalError)?,
+                    signature_r: data[64..96]
+                        .try_into()
+                        .map_err(|_| TbfParseError::InternalError)?,
+                    signature_s: data[96..128]
+                        .try_into()
+                        .map_err(|_| TbfParseError::InternalError)?,
+                }))
+            }
         }
     }
 }
@@ -760,6 +835,7 @@ impl TbfFooterV2Credentials {
             TbfFooterV2Credentials::SHA256(_) => "SHA256",
             TbfFooterV2Credentials::SHA384(_) => "SHA384",
             TbfFooterV2Credentials::SHA512(_) => "SHA512",
+            TbfFooterV2Credentials::EcdsaNistP256(_) => "EcdsaNistP256",
         }
     }
 }
@@ -794,6 +870,7 @@ pub struct TbfHeaderV2 {
     pub(crate) permissions: Option<TbfHeaderV2Permissions<8>>,
     pub(crate) storage_permissions: Option<TbfHeaderV2StoragePermissions<NUM_STORAGE_PERMISSIONS>>,
     pub(crate) kernel_version: Option<TbfHeaderV2KernelVersion>,
+    pub(crate) short_id: Option<TbfHeaderV2ShortId>,
 }
 
 /// Type that represents the fields of the Tock Binary Format header.
@@ -967,13 +1044,13 @@ impl TbfHeader {
     }
 
     /// Get the offset and size of a given flash region.
-    pub fn get_writeable_flash_region(&self, index: usize) -> (u32, u32) {
+    pub fn get_writeable_flash_region(&self, index: usize) -> (usize, usize) {
         match *self {
             TbfHeader::TbfHeaderV2(hd) => hd.writeable_regions.map_or((0, 0), |wrs| {
                 wrs.get(index).unwrap_or(&None).map_or((0, 0), |wr| {
                     (
-                        wr.writeable_flash_region_offset,
-                        wr.writeable_flash_region_size,
+                        wr.writeable_flash_region_offset as usize,
+                        wr.writeable_flash_region_size as usize,
                     )
                 })
             }),
@@ -1114,4 +1191,13 @@ impl TbfHeader {
             _ => 0,
         }
     }
-}
+
+    /// Return the fixed ShortId of the application if it was specified in the
+    /// TBF header.
+    pub fn get_fixed_short_id(&self) -> Option<core::num::NonZeroU32> {
+        match self {
+            TbfHeader::TbfHeaderV2(hd) => hd.short_id.and_then(|si| si.short_id),
+            _ => None,
+        }
+    }
+}

tbf-parser/tests/parse.rs

@@ -1,4 +1,4 @@
-use tbf_parser::parse::*;
+use tbf_parser::{parse::*};
 use tbf_parser::types::{TbfFooterV2Credentials, TbfFooterV2CredentialsType};
 
 #[test]