| // Copyright 2021 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| use super::*; |
| use crate::{cbor::value::Value, iana, util::expect_err, CborSerializable, Label}; |
| use alloc::{borrow::ToOwned, vec}; |
| |
| #[test] |
| fn test_header_encode() { |
| let tests = vec![ |
| ( |
| Header { |
| alg: Some(Algorithm::Assigned(iana::Algorithm::A128GCM)), |
| key_id: vec![1, 2, 3], |
| partial_iv: vec![1, 2, 3], |
| ..Default::default() |
| }, |
| concat!( |
| "a3", // 3-map |
| "01", "01", // 1 (alg) => A128GCM |
| "04", "43", "010203", // 4 (kid) => 3-bstr |
| "06", "43", "010203", // 6 (partial-iv) => 3-bstr |
| ), |
| ), |
| ( |
| Header { |
| alg: Some(Algorithm::PrivateUse(i64::MIN)), |
| ..Default::default() |
| }, |
| concat!( |
| "a1", // 1-map |
| "01", |
| "3b7fffffffffffffff", // 1 (alg) => -lots |
| ), |
| ), |
| ( |
| Header { |
| alg: Some(Algorithm::Assigned(iana::Algorithm::A128GCM)), |
| crit: vec![RegisteredLabel::Assigned(iana::HeaderParameter::Alg)], |
| content_type: Some(ContentType::Assigned(iana::CoapContentFormat::CoseEncrypt0)), |
| key_id: vec![1, 2, 3], |
| iv: vec![1, 2, 3], |
| rest: vec![ |
| (Label::Int(0x46), Value::from(0x47)), |
| (Label::Int(0x66), Value::from(0x67)), |
| ], |
| ..Default::default() |
| }, |
| concat!( |
| "a7", // 7-map |
| "01", "01", // 1 (alg) => A128GCM |
| "02", "81", "01", // 2 (crit) => 1-arr [x01] |
| "03", "10", // 3 (content-type) => 16 |
| "04", "43", "010203", // 4 (kid) => 3-bstr |
| "05", "43", "010203", // 5 (iv) => 3-bstr |
| "1846", "1847", // 46 => 47 (note canonical ordering) |
| "1866", "1867", // 66 => 67 |
| ), |
| ), |
| ( |
| Header { |
| alg: Some(Algorithm::Text("abc".to_owned())), |
| crit: vec![RegisteredLabel::Text("d".to_owned())], |
| content_type: Some(ContentType::Text("a/b".to_owned())), |
| key_id: vec![1, 2, 3], |
| iv: vec![1, 2, 3], |
| rest: vec![ |
| (Label::Int(0x46), Value::from(0x47)), |
| (Label::Text("a".to_owned()), Value::from(0x47)), |
| ], |
| counter_signatures: vec![CoseSignature { |
| signature: vec![1, 2, 3], |
| ..Default::default() |
| }], |
| ..Default::default() |
| }, |
| concat!( |
| "a8", // 8-map |
| "01", "63616263", // 1 (alg) => "abc" |
| "02", "81", "6164", // 2 (crit) => 1-arr ["d"] |
| "03", "63612f62", // 3 (content-type) => "a/b" |
| "04", "43", "010203", // 4 (kid) => 3-bstr |
| "05", "43", "010203", // 5 (iv) => 3-bstr |
| "07", "83", // 7 (sig) => [3-arr for COSE_Signature |
| "40", "a0", "43010203", // ] |
| "1846", "1847", // 46 => 47 (note canonical ordering) |
| "6161", "1847", // "a" => 47 |
| ), |
| ), |
| ( |
| Header { |
| alg: Some(Algorithm::Text("abc".to_owned())), |
| crit: vec![RegisteredLabel::Text("d".to_owned())], |
| content_type: Some(ContentType::Text("a/b".to_owned())), |
| key_id: vec![1, 2, 3], |
| iv: vec![1, 2, 3], |
| rest: vec![ |
| (Label::Int(0x46), Value::from(0x47)), |
| (Label::Text("a".to_owned()), Value::from(0x47)), |
| ], |
| counter_signatures: vec![ |
| CoseSignature { |
| signature: vec![1, 2, 3], |
| ..Default::default() |
| }, |
| CoseSignature { |
| signature: vec![3, 4, 5], |
| ..Default::default() |
| }, |
| ], |
| ..Default::default() |
| }, |
| concat!( |
| "a8", // 8-map |
| "01", "63616263", // 1 (alg) => "abc" |
| "02", "81", "6164", // 2 (crit) => 1-arr ["d"] |
| "03", "63612f62", // 3 (content-type) => "a/b" |
| "04", "43", "010203", // 4 (kid) => 3-bstr |
| "05", "43", "010203", // 5 (iv) => 3-bstr |
| "07", "82", // 7 (sig) => 2-array |
| "83", "40", "a0", "43010203", // [3-arr for COSE_Signature] |
| "83", "40", "a0", "43030405", // [3-arr for COSE_Signature] |
| "1846", "1847", // 46 => 47 (note canonical ordering) |
| "6161", "1847", // "a" => 47 |
| ), |
| ), |
| ( |
| HeaderBuilder::new() |
| .add_critical(iana::HeaderParameter::Alg) |
| .add_critical(iana::HeaderParameter::Alg) |
| .build(), |
| concat!( |
| "a1", // 1-map |
| "02", "820101", // crit => 2-arr [1, 1] |
| ), |
| ), |
| ]; |
| for (i, (header, header_data)) in tests.iter().enumerate() { |
| let got = header.clone().to_vec().unwrap(); |
| assert_eq!(*header_data, hex::encode(&got), "case {}", i); |
| |
| let mut got = Header::from_slice(&got).unwrap(); |
| for sig in &mut got.counter_signatures { |
| sig.protected.original_data = None; |
| } |
| assert_eq!(*header, got); |
| assert!(!got.is_empty()); |
| |
| // The same data also parses as a `ProtectedHeader` |
| let protected = ProtectedHeader { |
| original_data: None, |
| header: header.clone(), |
| }; |
| let protected_data = protected.clone().to_vec().unwrap(); |
| assert_eq!(*header_data, hex::encode(&protected_data), "case {}", i); |
| |
| let mut got = ProtectedHeader::from_slice(&protected_data).unwrap(); |
| for sig in &mut got.header.counter_signatures { |
| sig.protected.original_data = None; |
| } |
| assert!(!got.is_empty()); |
| assert_eq!(*header, got.header); |
| |
| // Also try parsing as a protected header inside a `bstr` |
| let prot_bstr_val = protected.cbor_bstr().unwrap(); |
| let mut got = ProtectedHeader::from_cbor_bstr(prot_bstr_val).unwrap(); |
| for sig in &mut got.header.counter_signatures { |
| sig.protected.original_data = None; |
| } |
| assert!(!got.is_empty()); |
| assert_eq!(*header, got.header); |
| assert_eq!( |
| *header_data, |
| hex::encode(&got.original_data.expect("missing original data")) |
| ); |
| } |
| } |
| |
| #[test] |
| fn test_header_decode_fail() { |
| let tests = vec![ |
| ( |
| concat!( |
| "a1", // 1-map |
| "01", "01", // 1 (alg) => 01 |
| "01", // extraneous data |
| ), |
| "extraneous data in CBOR input", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "01", "08", // 1 (alg) => invalid value |
| ), |
| "expected value in IANA or private use range", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "01", "4101", // 1 (alg) => bstr (invalid value type) |
| ), |
| "expected int/tstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "02", "4101", // 2 (crit) => bstr (invalid value type) |
| ), |
| "expected array", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "02", "81", "4101", // 2 (crit) => [bstr] (invalid value type) |
| ), |
| "expected int/tstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "02", "80", // 2 (crit) => [] |
| ), |
| "expected non-empty array", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "03", "81", "4101", // 3 (content-type) => [bstr] (invalid value type) |
| ), |
| "expected int/tstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "03", "19", "0606", // 3 (content-type) => invalid value 1542 |
| ), |
| "expected recognized IANA value", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "03", "64", "20612f62" // 3 (content-type) => invalid value " a/b" |
| ), |
| "expected no leading/trailing whitespace", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "03", "64", "612f6220" // 3 (content-type) => invalid value "a/b " |
| ), |
| "expected no leading/trailing whitespace", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "03", "62", "6162" // 3 (content-type) => invalid value "ab" |
| ), |
| "expected text of form type/subtype", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "03", "60", // 3 (content-type) => invalid value "" |
| ), |
| "expected non-empty tstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "04", "40", // 4 (key-id) => 0-bstr |
| ), |
| "expected non-empty bstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "04", "01", // 4 (key-id) => invalid value type |
| ), |
| "expected bstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "05", "40", // 5 (iv) => 0-bstr |
| ), |
| "expected non-empty bstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "05", "01", // 5 (iv) => invalid value type |
| ), |
| "expected bstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "06", "40", // 6 (partial-iv) => 0-bstr |
| ), |
| "expected non-empty bstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "06", "01", // 6 (partial-iv) => invalid value type |
| ), |
| "expected bstr", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "07", "01", // 7 (counter-sig) => invalid value type |
| ), |
| "expected array", |
| ), |
| ( |
| concat!( |
| "a1", // 1-map |
| "07", "80", // 7 (counter-sig) => 0-arr |
| ), |
| "expected non-empty sig array", |
| ), |
| ( |
| concat!( |
| "a2", // 1-map |
| "05", "4101", // 5 (iv) => 1-bstr |
| "06", "4101", // 6 (partial-iv) => 1-bstr |
| ), |
| "expected only one of IV and partial IV", |
| ), |
| ( |
| concat!( |
| "a2", // 2-map |
| "01", "63616263", // 1 (alg) => "abc" |
| "07", "82", // 7 (sig) => 2-array |
| "63616263", // tstr (invalid) |
| "83", "40", "a0", "43010203", // [3-arr for COSE_Signature] |
| ), |
| "array or bstr value", |
| ), |
| ]; |
| for (header_data, err_msg) in tests.iter() { |
| let data = hex::decode(header_data).unwrap(); |
| let result = Header::from_slice(&data); |
| expect_err(result, err_msg); |
| } |
| } |
| |
| #[test] |
| fn test_header_decode_dup_fail() { |
| let tests = [ |
| ( |
| concat!( |
| "a3", // 3-map |
| "01", "01", // 1 (alg) => A128GCM |
| "1866", "1867", // 66 => 67 |
| "1866", "1847", // 66 => 47 |
| ), |
| "duplicate map key", |
| ), |
| ( |
| concat!( |
| "a3", // 3-map |
| "01", "01", // 1 (alg) => A128GCM |
| "1866", "1867", // 66 => 67 |
| "01", "01", // 1 (alg) => A128GCM (duplicate label) |
| ), |
| "duplicate map key", |
| ), |
| ]; |
| for (header_data, err_msg) in tests.iter() { |
| let data = hex::decode(header_data).unwrap(); |
| let result = Header::from_slice(&data); |
| expect_err(result, err_msg); |
| } |
| } |
| |
| #[test] |
| fn test_header_encode_dup_fail() { |
| let tests = vec![ |
| Header { |
| alg: Some(Algorithm::Assigned(iana::Algorithm::A128GCM)), |
| crit: vec![RegisteredLabel::Assigned(iana::HeaderParameter::Alg)], |
| content_type: Some(ContentType::Assigned(iana::CoapContentFormat::CoseEncrypt0)), |
| key_id: vec![1, 2, 3], |
| iv: vec![1, 2, 3], |
| rest: vec![ |
| (Label::Int(0x46), Value::from(0x47)), |
| (Label::Int(0x46), Value::from(0x67)), |
| ], |
| ..Default::default() |
| }, |
| HeaderBuilder::new() |
| .text_value("doop".to_owned(), Value::from(1)) |
| .text_value("doop".to_owned(), Value::from(2)) |
| .build(), |
| ]; |
| for header in tests { |
| let result = header.clone().to_vec(); |
| expect_err(result, "duplicate map key"); |
| } |
| } |
| |
| #[test] |
| fn test_header_builder() { |
| let tests = vec![ |
| ( |
| HeaderBuilder::new().build(), |
| Header { |
| ..Default::default() |
| }, |
| ), |
| ( |
| HeaderBuilder::new() |
| .algorithm(iana::Algorithm::A128GCM) |
| .add_critical(iana::HeaderParameter::Alg) |
| .add_critical_label(RegisteredLabel::Text("abc".to_owned())) |
| .content_format(iana::CoapContentFormat::CoseEncrypt0) |
| .key_id(vec![1, 2, 3]) |
| .partial_iv(vec![4, 5, 6]) // removed by .iv() call |
| .iv(vec![1, 2, 3]) |
| .value(0x46, Value::from(0x47)) |
| .value(0x66, Value::from(0x67)) |
| .build(), |
| Header { |
| alg: Some(Algorithm::Assigned(iana::Algorithm::A128GCM)), |
| crit: vec![ |
| RegisteredLabel::Assigned(iana::HeaderParameter::Alg), |
| RegisteredLabel::Text("abc".to_owned()), |
| ], |
| content_type: Some(ContentType::Assigned(iana::CoapContentFormat::CoseEncrypt0)), |
| key_id: vec![1, 2, 3], |
| iv: vec![1, 2, 3], |
| rest: vec![ |
| (Label::Int(0x46), Value::from(0x47)), |
| (Label::Int(0x66), Value::from(0x67)), |
| ], |
| ..Default::default() |
| }, |
| ), |
| ( |
| HeaderBuilder::new() |
| .algorithm(iana::Algorithm::A128GCM) |
| .add_critical(iana::HeaderParameter::Alg) |
| .add_critical_label(RegisteredLabel::Text("abc".to_owned())) |
| .content_type("type/subtype".to_owned()) |
| .key_id(vec![1, 2, 3]) |
| .iv(vec![1, 2, 3]) // removed by .partial_iv() call |
| .partial_iv(vec![4, 5, 6]) |
| .build(), |
| Header { |
| alg: Some(Algorithm::Assigned(iana::Algorithm::A128GCM)), |
| crit: vec![ |
| RegisteredLabel::Assigned(iana::HeaderParameter::Alg), |
| RegisteredLabel::Text("abc".to_owned()), |
| ], |
| content_type: Some(ContentType::Text("type/subtype".to_owned())), |
| key_id: vec![1, 2, 3], |
| partial_iv: vec![4, 5, 6], |
| ..Default::default() |
| }, |
| ), |
| ]; |
| for (got, want) in tests { |
| assert_eq!(got, want); |
| } |
| } |
| |
| #[test] |
| #[should_panic] |
| fn test_header_builder_core_param_panic() { |
| // Attempting to set a core header parameter (in range [1,7]) via `.param()` panics. |
| let _hdr = HeaderBuilder::new().value(1, Value::Null).build(); |
| } |
