zcopy: invalid data tests and fixes

Author: alambert-lanl

tests/input/arrays.x

@@ -61,3 +61,11 @@ struct LimitedOpaqueArrays {
 struct UnlimitedOpaqueArray {
 	opaque data<>;
 };
+
+struct LimitedOpaqueArray {
+    string data<4>;
+};
+
+struct UnlimitedArrayOfLimited {
+    LimitedOpaqueArray a<>;
+};

tests/input/optional.x

@@ -42,3 +42,17 @@ struct exportnode {
    groups   ex_groups;
    exportnode *ex_next;
 };
+
+enum MyEnum {
+    ZERO = 0,
+    ONE = 1
+};
+
+struct EnumNode {
+    MyEnum a;
+    EnumNode *next;
+};
+
+struct EnumChainStart {
+    EnumNode* first;
+};

tests/input/unions.x

@@ -87,3 +87,24 @@ struct HasUnion {
     NumLeaves c;
     Plant nocache;
 };
+
+union Bar switch (Cases blah) {
+case one:
+        int a;
+case two:
+        void;
+};
+
+union AnOption switch (bool yes) {
+case TRUE:
+    int a;
+case FALSE:
+    void;
+};
+
+union Foo switch(Cases blah) {
+case one:
+        int *a;
+case two:
+        void;
+};

tests/zcopy/tests/arrays.rs

@@ -1,9 +1,11 @@
+use std::{ffi::OsString, str::FromStr};
+
 use rand::distr::{Alphanumeric, SampleString};
 
 include!(concat!(env!("OUT_DIR"), "/arrays.rs"));
 
 use crate::arrays::*;
-use xdr_lib::Reader;
+use xdr_lib::{DeserializeError, Reader};
 
 #[test]
 fn test_opaque_arrays_minsize() {
@@ -36,6 +38,92 @@ fn test_opaque_arrays() {
     assert_eq!(reader.get_bytes_3(), bytes3.as_slice());
 }
 
+#[test]
+fn test_opaque_arrays_size_check() {
+    let data: Vec<u8> = vec![0x0, 0x0];
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}
+
+#[test]
+fn test_opaque_arrays_missing_bytes_2_count() {
+    let data: Vec<u8> = vec![0xF, 0xF, 0xF];
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+
+    let data: Vec<u8> = vec![0xF, 0xF, 0xF, 0x1, 0x1, 0x1];
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}
+
+#[test]
+fn test_opaque_arrays_missing_bytes_2() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xF, 0xF, 0xF, 0x0, // bytes
+        0x0, 0x0, 0x0, 0x1, // bytes_2_count
+        0x1                 // bytes_2
+    ];
+
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}
+
+#[test]
+fn test_opaque_arrays_bytes_2_too_long() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xF, 0xF, 0xF, 0x0, // bytes
+        0x0, 0x0, 0x0, 0x4, // bytes_2_count
+        0x1, 0xF, 0xF, 0xF, // bytes_2
+        0x0, 0x0, 0x0, 0x4, // bytes_3_count
+        0x1, 0x1, 0x0, 0x0  // bytes_3
+    ];
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}
+
+#[test]
+fn test_opaque_arrays_missing_bytes_3_count() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xF, 0xF, 0xF, 0x0, // bytes
+        0x0, 0x0, 0x0, 0x1, // bytes_2_count
+        0x1, 0xF, 0xF, 0xF, // bytes_2
+        0x0, 0x0,
+    ];
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}
+
+#[test]
+fn test_opaque_rrays_missing_bytes_3() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xF, 0xF, 0xF, 0x0, // bytes
+        0x0, 0x0, 0x0, 0x1, // bytes_2_count
+        0x1, 0xF, 0xF, 0xF, // bytes_2
+        0x0, 0x0, 0x0, 0x5, // bytes_3_count
+        0x1, 0x1, 0x0, 0x0  // bytes_3
+    ];
+    assert_eq!(
+        OpaqueArraysReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}
+
 #[test]
 fn test_opaque_arrays_reader() {
     let mut data = Vec::new();
@@ -81,11 +169,12 @@ fn test_int_arrays_reader() {
     let reader = IntArraysReader::new(&data).unwrap();
 
     let mut fixed_iter = reader.get_fixed();
+    assert_eq!(reader.get_fixed().get_count(), 4);
     assert_eq!(fixed_iter.next().unwrap().unwrap().get_a(), 1);
     assert_eq!(fixed_iter.next().unwrap().unwrap().get_a(), 2);
     assert_eq!(fixed_iter.next().unwrap().unwrap().get_a(), 3);
     assert_eq!(fixed_iter.next().unwrap().unwrap().get_a(), 4);
-    assert!(fixed_iter.next().is_none());
+    assert_eq!(fixed_iter.next(), None);
 
     let mut limited_iter = reader.get_limited();
     assert_eq!(limited_iter.next().unwrap().unwrap().get_a(), 10);
@@ -101,6 +190,59 @@ fn test_int_arrays_reader() {
     assert_eq!(reader.get_width(), Ok(12 + 8 + 16));
 }
 
+#[test]
+fn test_int_arrays_empty() {
+    let data: Vec<u8> = Vec::new();
+    assert_eq!(IntArraysReader::new(data.as_slice()), Err(DeserializeError));
+}
+
+#[test]
+fn test_int_arrays_fixed_array_missing_element() {
+    let data: Vec<u8> = vec![0xF, 0xE, 0xE];
+    assert_eq!(IntArraysReader::new(data.as_slice()), Err(DeserializeError));
+}
+
+#[test]
+fn test_int_arrays_fixed_array_limited_missing_count() {
+    let data: Vec<u8> = vec![0xF, 0xE, 0xE, 0x0];
+    assert_eq!(IntArraysReader::new(data.as_slice()), Err(DeserializeError));
+}
+
+#[test]
+fn test_int_arrays_fixed_array_limited_under_count() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xF, 0xE, 0xE, 0x0, // fixed
+        0x0, 0x0, 0x0, 0x2, // limited_count
+        0x0, 0x0, 0x0, 0x1, // limited
+    ];
+    assert_eq!(IntArraysReader::new(data.as_slice()), Err(DeserializeError));
+}
+
+#[test]
+fn test_int_arrays_fixed_array_missing_unlimited_count() {
+    let data: Vec<u8> = vec![
+        0xF, 0xE, 0xE, 0x2, // fixed
+        0x0, 0x0, 0x0, 0x2, // limited_count
+        0x0, 0x0, 0x0, 0x1, // limited
+        0x0, 0x0, 0x0, 0x1,
+    ];
+    assert_eq!(IntArraysReader::new(data.as_slice()), Err(DeserializeError));
+}
+
+#[test]
+fn test_int_arrays_fixed_array_under_unlimited_count() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xF, 0xE, 0xE, 0x2, // fixed
+        0x0, 0x0, 0x0, 0x2, // limited_count
+        0x0, 0x0, 0x0, 0x1, // limited
+        0x0, 0x0, 0x0, 0x1,
+        0x0, 0x0, 0x0, 0x2, // unlimited_count
+    ];
+    assert_eq!(IntArraysReader::new(data.as_slice()), Err(DeserializeError));
+}
+
 #[test]
 fn test_strings_reader() {
     let mut data = Vec::new();
@@ -180,3 +322,62 @@ fn test_many_ints_reader() {
     assert_eq!(reader.get_third_width(), Ok(12));
     assert_eq!(reader.get_width(), Ok(12 + 12 + 16));
 }
+
+#[test]
+fn test_unlimited_array_of_unlimited() {
+    let mut data: Vec<u8> = vec![];
+    let mut strings: Vec<xdr_lib::Result<OsString>> = vec![];
+    data.extend(100_u32.to_be_bytes());
+    for _ in 0..100 {
+        let my_string = Alphanumeric.sample_string(&mut rand::rng(), 2);
+
+        strings.push(Ok(OsString::from_str(&my_string).unwrap()));
+
+        // if false && i == 49 {
+        //     data.extend(5_u32.to_be_bytes());
+        // } else {
+        data.extend(2_u32.to_be_bytes());
+        // }
+        data.extend(my_string.as_bytes());
+        data.extend(&[0x0, 0x0]);
+    }
+
+    assert_eq!(data.len() % 4, 0);
+
+    let reader = UnlimitedArrayOfLimitedReader::new(data.as_slice()).unwrap();
+    assert_eq!(
+        reader
+            .get_a()
+            .map(|v| v.map(|res| res.get_data().to_os_string()))
+            .collect::<Vec<xdr_lib::Result<OsString>>>(),
+        strings
+    );
+}
+
+#[test]
+fn test_unlimited_array_of_unlimited_error_in_middle() {
+    let mut data: Vec<u8> = vec![];
+    let mut strings: Vec<xdr_lib::Result<OsString>> = vec![];
+    data.extend(100_u32.to_be_bytes());
+    for i in 0..100 {
+        let my_string = Alphanumeric.sample_string(&mut rand::rng(), 2);
+
+        strings.push(Ok(OsString::from_str(&my_string).unwrap()));
+
+        if i == 49 {
+            data.extend(5_u32.to_be_bytes());
+            strings.push(Err(DeserializeError));
+        } else {
+            data.extend(2_u32.to_be_bytes());
+        }
+        data.extend(my_string.as_bytes());
+        data.extend(&[0x0, 0x0]);
+    }
+
+    assert_eq!(data.len() % 4, 0);
+
+    assert_eq!(
+        UnlimitedArrayOfLimitedReader::new(data.as_slice()),
+        Err(DeserializeError)
+    );
+}

tests/zcopy/tests/basic_xdr_types.rs

@@ -57,3 +57,18 @@ fn test_hello_invalid_enum() {
         Err(xdr_lib::DeserializeError)
     );
 }
+
+#[test]
+fn test_hello_one_byte_short() {
+    #[rustfmt::skip]
+    let data: Vec<u8> = vec![
+        0xC0, 0xFF, 0xEE, 0x11, // unsigned int abc
+        0x00, 0xBA, 0xB1, 0x0C, // int def
+        0x80, 0x00, 0x00, // favorite_fruit = invalid
+    ];
+
+    assert_eq!(
+        HelloReader::new(data.as_slice()),
+        Err(xdr_lib::DeserializeError)
+    );
+}