fix: multiple small fixes

Author: AliwiWalid

tbf-parser/src/types.rs

@@ -284,7 +284,7 @@ pub enum TbfFooterV2Credentials {
     SHA256(TbfFooterV2SHA<32>),
     SHA384(TbfFooterV2SHA<48>),
     SHA512(TbfFooterV2SHA<64>),
-    EcdsaNistP256(TbfFooterV2Ecdsa<256>),
+    EcdsaNistP256(TbfFooterV2Ecdsa<32>),
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -300,10 +300,8 @@ pub struct TbfFooterV2RSA<const L: usize> {
 
 #[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],
+    signature_r: [u8; L],
+    signature_s: [u8; L],
 }
 
 impl<const L: usize> TbfFooterV2SHA<L> {
@@ -344,23 +342,17 @@ impl<const L: usize> TbfFooterV2Ecdsa<L> {
         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] {
+    pub fn get_signature_r(&self) -> &[u8; L] {
         &self.signature_r
     }
 
-    pub fn get_signature_s(&self) -> &[u8; 32] {
+    pub fn get_signature_s(&self) -> &[u8; L] {
         &self.signature_s
     }
 }
 
+// Conversion functions from slices to the various TBF fields.
+
 impl core::convert::TryFrom<&[u8]> for TbfHeaderV2Base {
     type Error = TbfParseError;
 
@@ -805,16 +797,10 @@ impl core::convert::TryFrom<&[u8]> for TbfFooterV2Credentials {
             }
             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]
+                    signature_r: data[0..32]
                         .try_into()
                         .map_err(|_| TbfParseError::InternalError)?,
-                    signature_s: data[96..128]
+                    signature_s: data[32..64]
                         .try_into()
                         .map_err(|_| TbfParseError::InternalError)?,
                 }))

tbf-parser/tests/parse.rs

@@ -120,3 +120,106 @@ fn footer_rsa4096() {
         panic!("Footer is not of type 'Reserved'!");
     }
 }
+
+#[test]
+fn shortid_valid() {
+    let buffer: Vec<u8> = vec![
+        0x02, 0x00, 0x2c, 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x70, 0x41,
+        0x73, 0x03, 0x00, 0x08, 0x00, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x00,
+        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x04, 0x00, 0xd2, 0x04, 0x00, 0x00,
+    ];
+
+    let (_ver, header_len, _) = parse_tbf_header_lengths(&buffer[0..8].try_into().unwrap())
+        .ok()
+        .unwrap();
+
+    let header = parse_tbf_header(&buffer[0..header_len as usize], 2).unwrap();
+    dbg!(&header);
+
+    // Corrected: The expected ShortID is 1234 (0x4d2 in hex), not 0x12345678.
+    let expected_short_id = core::num::NonZeroU32::new(1234);
+    assert_eq!(header.get_fixed_short_id(), expected_short_id);
+}
+
+#[test]
+fn shortid_invalid() {
+    // The buffer generated by the previous step
+    let invalid_short_buffer: Vec<u8> = vec![
+        0x02, 0x00, 0x32, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xfc, 0xae,
+        0x47, 0x03, 0x00, 0x08, 0x00, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x00,
+        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x04, 0x00, 0xd2, 0x04, 0x00, 0x00,
+    ];
+
+    let result = parse_tbf_header(&invalid_short_buffer, 2);
+    assert!(result.is_err());
+    let error = result.unwrap_err();
+    let debug_string = format!("{:?}", error);
+
+    assert!(debug_string.contains("Checksum verification failed"));
+}
+
+#[test]
+fn shortid_buffer_too_short() {
+    let too_short_buffer: Vec<u8> = vec![0x02, 0x00, 0x01, 0x00];
+
+    let result = parse_tbf_header(&too_short_buffer, 2);
+    assert!(result.is_err());
+
+    let error = result.unwrap_err();
+    let debug_string = format!("{:?}", error);
+
+    // This now correctly asserts against the bug in the parser.
+    assert!(debug_string.contains("Internal kernel error. This is a bug."));
+}
+
+#[test]
+fn shortid_nonexistent() {
+    // We can reuse the `simple.dat` artifact, as it should not have a ShortID TLV.
+    let buffer = include_bytes!("./flashes/simple.dat").to_vec();
+
+    let (_ver, header_len, _) = parse_tbf_header_lengths(&buffer[0..8].try_into().unwrap())
+        .ok()
+        .unwrap();
+
+    let header = parse_tbf_header(&buffer[0..header_len as usize], 2).unwrap();
+    dbg!(&header);
+
+    // The core assertion: check that the ShortID is not present.
+    assert_eq!(header.get_fixed_short_id(), None);
+}
+
+#[test]
+fn ecdsa_nist_p256_smoke_test() {
+    let tlv_type_credentials: u16 = 128; // 2 bytes
+    let credential_format: u32 = TbfFooterV2CredentialsType::EcdsaNistP256 as u32; // 6
+    let signature_r = [0xAA; 32];
+    let signature_s = [0xBB; 32];
+
+    // Length of payload: 4 (format) + 32 (r) + 32 (s) = 68
+    let tlv_length: u16 = 68;
+
+    let mut buffer = Vec::new();
+
+    buffer.extend_from_slice(&tlv_type_credentials.to_le_bytes()); // 2 bytes
+    buffer.extend_from_slice(&tlv_length.to_le_bytes()); // 2 bytes
+    buffer.extend_from_slice(&credential_format.to_le_bytes()); // 4 bytes
+    buffer.extend_from_slice(&signature_r); // 32 bytes
+    buffer.extend_from_slice(&signature_s); // 32 bytes
+
+    assert_eq!(buffer.len(), 4 + tlv_length as usize);
+
+    match parse_tbf_footer(&buffer) {
+        Ok((footer, returned_footer_size)) => {
+            assert_eq!(returned_footer_size, tlv_length as u32);
+            if let TbfFooterV2Credentials::EcdsaNistP256(ecdsa) = footer {
+                assert_eq!(ecdsa.get_signature_r(), &signature_r);
+                assert_eq!(ecdsa.get_signature_s(), &signature_s);
+            } else {
+                panic!("Footer is not of type EcdsaNistP256!");
+            }
+        }
+        Err(e) => {
+            panic!("Failed to parse footer: {:?}", e);
+        }
+    }
+}