OER: decode error when unused preamble bits are not zero

src/error/decode.rs

@@ -695,6 +695,8 @@ pub enum OerDecodeErrorKind {
         /// The amount of invalid bits.
         msg: alloc::string::String,
     },
+    #[snafu(display("Invalid preamble: {msg}"))]
+    InvalidPreamble { msg: alloc::string::String },
 }
 
 impl OerDecodeErrorKind {
@@ -719,6 +721,10 @@ impl OerDecodeErrorKind {
     pub fn invalid_bit_string(msg: alloc::string::String) -> DecodeError {
         CodecDecodeError::Oer(Self::InvalidOerBitString { msg }).into()
     }
+    #[must_use]
+    pub fn invalid_preamble(msg: alloc::string::String) -> DecodeError {
+        CodecDecodeError::Oer(Self::InvalidPreamble { msg }).into()
+    }
 }
 
 #[derive(Snafu, Debug)]

src/oer.rs

@@ -120,4 +120,28 @@ mod tests {
         decode_error!(coer, Test, &[0b1000_0001, 0x01]);
         decode_ok!(oer, Test, &[0b1000_0001, 0x01], Test::A);
     }
+    #[test]
+    fn test_seq_preamble_unused_bits() {
+        use crate as rasn;
+        #[derive(AsnType, Decode, Encode, Clone, Debug, PartialEq, Eq)]
+        #[rasn(automatic_tags)]
+        pub struct SequenceOptionals {
+            pub it: Integer,
+            pub is: Option<OctetString>,
+            pub late: Option<Integer>,
+        }
+        let data = [0x10, 0x01, 0x2A];
+        decode_error!(coer, SequenceOptionals, &data);
+        let data = [0x0, 0x01, 0x2A];
+        round_trip!(
+            oer,
+            SequenceOptionals,
+            SequenceOptionals {
+                it: 42.into(),
+                is: None,
+                late: None
+            },
+            &data
+        );
+    }
 }

src/oer/de.rs

@@ -92,11 +92,17 @@ impl<'input> Decoder<'input> {
         self.input = input;
         Ok(byte.as_bytes()[0])
     }
-    fn drop_bits(&mut self, num: usize) -> Result<(), DecodeError> {
-        let (input, _) = nom::bytes::streaming::take(num)(self.input)
+    fn drop_preamble_bits(&mut self, num: usize) -> Result<(), DecodeError> {
+        let (input, bits) = nom::bytes::streaming::take(num)(self.input)
             .map_err(|e| DecodeError::map_nom_err(e, self.codec()))?;
-        self.input = input;
-        Ok(())
+        if bits.not_any() {
+            self.input = input;
+            Ok(())
+        } else {
+            Err(OerDecodeErrorKind::invalid_preamble(
+                "Preamble unused bits should be all zero.".to_string(),
+            ))
+        }
     }
     fn parse_tag(&mut self) -> Result<Tag, DecodeError> {
         // Seems like tag number
@@ -466,7 +472,7 @@ impl<'input> Decoder<'input> {
         } else {
             bitmap.len()
         };
-        self.drop_bits((8 - preamble_length % 8) % 8)?;
+        self.drop_preamble_bits((8 - preamble_length % 8) % 8)?;
 
         debug_assert_eq!(self.input.len() % 8, 0);
         Ok((bitmap, extensible_present))