Source code
Revision control
Copy as Markdown
Other Tools
use crate::{
crypto::{PinUvAuthParam, PinUvAuthToken},
ctap2::server::UserVerificationRequirement,
errors::{AuthenticatorError, UnsupportedOption},
transport::errors::HIDError,
FidoDevice,
};
use serde::{
de::{Error as SerdeError, IgnoredAny, MapAccess, Visitor},
ser::{Error as SerError, SerializeMap},
Deserialize, Deserializer, Serialize, Serializer,
};
use serde_bytes::ByteBuf;
use serde_cbor::{from_slice, to_vec, Value};
use sha2::{Digest, Sha256};
use std::fmt;
use super::{Command, CommandError, CtapResponse, PinUvAuthCommand, RequestCtap2, StatusCode};
#[derive(Debug)]
pub(crate) struct LargeBlobs {
get: Option<u64>, // (0x01) Unsigned integer Optional The number of bytes requested to read. MUST NOT be present if set is present.
set: Option<ByteBuf>, // (0x02) Byte String Optional A fragment to write. MUST NOT be present if get is present.
offset: u64, // (0x03) Unsigned integer Required The byte offset at which to read/write.
length: Option<u64>, // (0x04) Unsigned integer Optional The total length of a write operation. Present if, and only if, set is present and offset is zero.
pin_uv_auth_param: Option<PinUvAuthParam>, // (0x05) authenticate(pinUvAuthToken, 32×0xff || h’0c00' || uint32LittleEndian(offset) || SHA-256(contents of set byte string, i.e. not including an outer CBOR tag with major type two))
}
impl PinUvAuthCommand for LargeBlobs {
fn set_pin_uv_auth_param(
&mut self,
pin_uv_auth_token: Option<PinUvAuthToken>,
) -> Result<(), AuthenticatorError> {
let mut param = None;
if let Some(token) = pin_uv_auth_token {
// pinUvAuthParam (0x05): the result of calling
// authenticate(pinUvAuthToken, 32×0xff || h’0c00' || uint32LittleEndian(offset) || SHA-256(contents of set byte string, i.e. not including an outer CBOR tag with major type two))
let mut data = vec![0xff; 32];
data.extend([0x0c, 0x00]);
data.extend((self.offset as u32).to_le_bytes());
if let Some(ref set) = self.set {
data.extend(Sha256::digest(set.as_slice()));
}
param = Some(token.derive(&data).map_err(CommandError::Crypto)?);
}
self.pin_uv_auth_param = param;
Ok(())
}
fn can_skip_user_verification(
&mut self,
_info: &crate::AuthenticatorInfo,
_uv: UserVerificationRequirement,
) -> bool {
// "discouraged" does not exist for LargeBlobs
false
}
fn set_uv_option(&mut self, _uv: Option<bool>) {
/* No-op */
}
fn get_pin_uv_auth_param(&self) -> Option<&PinUvAuthParam> {
self.pin_uv_auth_param.as_ref()
}
fn get_rp_id(&self) -> Option<&String> {
None
}
fn hmac_requested(&self) -> bool {
false
}
}
impl Serialize for LargeBlobs {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
if self.set.is_none() && self.get.is_none() {
return Err(SerError::custom("Either set or get has to be set"));
}
let mut map_len = 2; // get/set and offset
if self.length.is_some() {
map_len += 1;
}
if self.pin_uv_auth_param.is_some() {
map_len += 2;
}
let mut map = serializer.serialize_map(Some(map_len))?;
if let Some(ref get) = self.get {
map.serialize_entry(&0x01, get)?;
}
if let Some(ref set) = self.set {
map.serialize_entry(&0x02, set)?;
}
map.serialize_entry(&0x03, &self.offset)?;
if let Some(ref length) = self.length {
map.serialize_entry(&0x04, length)?;
}
if let Some(ref pin_uv_auth_param) = self.pin_uv_auth_param {
map.serialize_entry(&0x05, pin_uv_auth_param)?;
map.serialize_entry(&0x06, &pin_uv_auth_param.pin_protocol.id())?;
}
map.end()
}
}
impl RequestCtap2 for LargeBlobs {
type Output = LargeBlobSegment;
fn command(&self) -> Command {
Command::LargeBlobs
}
fn wire_format(&self) -> Result<Vec<u8>, HIDError> {
let output = to_vec(&self).map_err(CommandError::Serializing)?;
trace!("client subcommmand: {:04X?}", &output);
Ok(output)
}
fn handle_response_ctap2<Dev>(
&self,
_dev: &mut Dev,
input: &[u8],
) -> Result<Self::Output, HIDError>
where
Dev: FidoDevice,
{
if input.is_empty() {
return Err(CommandError::InputTooSmall.into());
}
let status: StatusCode = input[0].into();
if status.is_ok() {
if input.len() > 1 {
let payload = &input[1..];
Ok(payload.to_vec())
} else {
// Some subcommands return only an OK-status without any data
Ok(Vec::new())
}
} else {
let data: Option<Value> = if input.len() > 1 {
let payload = &input[1..];
Some(from_slice(payload).map_err(CommandError::Deserializing)?)
} else {
None
};
Err(CommandError::StatusCode(status, data).into())
}
}
fn send_to_virtual_device<Dev: crate::VirtualFidoDevice>(
&self,
_dev: &mut Dev,
) -> Result<Self::Output, HIDError> {
unimplemented!()
}
}
#[derive(Default, Debug, Clone, PartialEq, Eq)]
pub struct LargeBlobArrayElement {
/// AEAD_AES_256_GCM ciphertext, implicitly including the AEAD “authentication tag” at the end.
pub ciphertext: Vec<u8>,
/// AEAD_AES_256_GCM nonce. MUST be exactly 12 bytes long.
pub nonce: [u8; 12],
/// Contains the length, in bytes, of the uncompressed data.
pub orig_size: u64,
}
impl Serialize for LargeBlobArrayElement {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let map_len = 3; // The Array is the only one
let mut map = serializer.serialize_map(Some(map_len))?;
map.serialize_entry(&0x01, &self.ciphertext)?;
map.serialize_entry(&0x02, &self.nonce)?;
map.serialize_entry(&0x03, &self.orig_size)?;
map.end()
}
}
impl<'de> Deserialize<'de> for LargeBlobArrayElement {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct LargeBlobArrayElementVisitor;
impl<'de> Visitor<'de> for LargeBlobArrayElementVisitor {
type Value = LargeBlobArrayElement;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a map")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
let mut ciphertext = None; // Sub-level (0x01)
let mut nonce = None; // Sub-level (0x02)
let mut orig_size = None; // Sub-level (0x03)
// Parsing out the top-level "large-blob array"
while let Some(key) = map.next_key()? {
match key {
0x01 => {
if ciphertext.is_some() {
return Err(SerdeError::duplicate_field("ciphertext"));
}
ciphertext = Some(map.next_value()?);
}
0x02 => {
if nonce.is_some() {
return Err(SerdeError::duplicate_field("nonce"));
}
nonce = Some(map.next_value()?);
}
0x03 => {
if orig_size.is_some() {
return Err(SerdeError::duplicate_field("orig_size"));
}
orig_size = Some(map.next_value()?);
}
k => {
warn!("LargeBlobArray: unexpected key: {:?}", k);
let _ = map.next_value::<IgnoredAny>()?;
continue;
}
}
}
let ciphertext = ciphertext.ok_or_else(|| M::Error::missing_field("ciphertext"))?;
let nonce = nonce.ok_or_else(|| M::Error::missing_field("nonce"))?;
let orig_size = orig_size.ok_or_else(|| M::Error::missing_field("orig_size"))?;
Ok(LargeBlobArrayElement {
ciphertext,
nonce,
orig_size,
})
}
}
deserializer.deserialize_bytes(LargeBlobArrayElementVisitor)
}
}
#[derive(Default, Debug, PartialEq, Eq)]
pub struct LargeBlobsResponse {
pub(crate) large_blob_array: Vec<LargeBlobArrayElement>,
/// Truncated SHA-256 hash of the preceding bytes
pub(crate) hash: [u8; 16],
pub(crate) byte_len: u64,
}
impl<'de> Deserialize<'de> for LargeBlobsResponse {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct LargeBlobsResponseVisitor;
impl<'de> Visitor<'de> for LargeBlobsResponseVisitor {
type Value = LargeBlobsResponse;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a map")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
// this data is serialized as a CBOR-encoded array (called the large-blob array) of large-blob maps, concatenated with 16 following bytes. Those final 16 bytes are the truncated SHA-256 hash of the preceding bytes.
let mut response = None; // Top-level 0x01
// Parsing out the top-level "large-blob array"
while let Some(key) = map.next_key()? {
match key {
0x01 => {
if response.is_some() {
return Err(SerdeError::duplicate_field("response"));
}
let payload: ByteBuf = map.next_value()?;
// Note: the minimum length of a serialized large-blob array is 17 bytes. Omitting 16 bytes for the trailing SHA-256 hash, this leaves just one byte. This is the size of an empty CBOR array.
if payload.len() < 17 {
return Err(SerdeError::invalid_length(
payload.len(),
&">= 17 bytes",
));
}
// split off trailing hash-bytes
let (mut large_blob, mut hash_slice) =
payload.split_at(payload.len() - 16);
let expected_hash = Sha256::digest(large_blob);
// The initial serialized large-blob array is the value of the serialized large-blob array on a fresh authenticator, as well as immediately after a reset. It is the byte string h'8076be8b528d0075f7aae98d6fa57a6d3c', which is an empty CBOR array (80) followed by LEFT(SHA-256(h'80'), 16).
let default_large_blob = [0x80];
let default_hash = [
0x76, 0xbe, 0x8b, 0x52, 0x8d, 0x00, 0x75, 0xf7, 0xaa, 0xe9, 0x8d,
0x6f, 0xa5, 0x7a, 0x6d, 0x3c,
];
// Once complete, the platform MUST confirm that the embedded SHA-256 hash is correct, based on the definition above. If not, the configuration is corrupt and the platform MUST discard it and act as if the initial serialized large-blob array was received.
if &expected_hash[0..16] != hash_slice {
warn!("Large blob array hash doesn't match with the expected value! Assuming an empty array.");
large_blob = &default_large_blob;
hash_slice = &default_hash;
}
let byte_len = large_blob.len() as u64;
let large_blob_array: Vec<LargeBlobArrayElement> =
from_slice(large_blob).map_err(M::Error::custom)?;
let mut hash = [0u8; 16];
hash.copy_from_slice(hash_slice);
response = Some(LargeBlobsResponse {
large_blob_array,
hash,
byte_len,
});
}
k => {
warn!("LargeBlobsResponse: unexpected key: {:?}", k);
let _ = map.next_value::<IgnoredAny>()?;
continue;
}
}
}
let response =
response.ok_or_else(|| M::Error::missing_field("large_blob_bytes"))?;
Ok(response)
}
}
deserializer.deserialize_bytes(LargeBlobsResponseVisitor)
}
}
pub type LargeBlobSegment = Vec<u8>;
impl CtapResponse for LargeBlobSegment {}
pub fn read_large_blob_array<Dev>(
dev: &mut Dev,
keep_alive: &dyn Fn() -> bool,
) -> Result<LargeBlobsResponse, AuthenticatorError>
where
Dev: FidoDevice,
{
// Spec:
// A per-authenticator constant, maxFragmentLength, is here defined as the value of maxMsgSize (from the authenticatorGetInfo response) minus 64.
// If no maxMsgSize is given in the authenticatorGetInfo response) then it defaults to 1024, leaving maxFragmentLength to default to 960.
//
// In the highly unlikely case of a max_msg_size smaller than 65 (leaving zero-byte fragment-length), we error out, saying that largeBlobs is unsupported.
let max_msg_size = dev
.get_authenticator_info()
.and_then(|i| i.max_msg_size)
.unwrap_or(1024);
if max_msg_size <= 64 {
return Err(AuthenticatorError::UnsupportedOption(
UnsupportedOption::LargeBlobs,
));
}
let max_fragment_length = max_msg_size - 64;
let mut bytes = vec![];
let mut offset = 0;
loop {
let cmd = LargeBlobs {
get: Some(max_fragment_length as u64),
set: None,
offset,
length: None,
pin_uv_auth_param: None,
};
let mut segment = dev.send_cbor_cancellable(&cmd, keep_alive)?;
let segment_len = segment.len();
bytes.append(&mut segment);
// Spec:
// If the length of the response is equal to the value of get then more data may be
// available and the platform SHOULD repeatedly issue requests, each time updating offset
// to equal the amount of data received so far. It stops once a short (or empty)
// fragment is returned.
if segment_len < max_fragment_length {
// The last segment was smaller than the max-size
// so we have read all there is to read.
break;
} else {
// There is still more data. So set the offset and repeat
offset += segment_len as u64;
continue;
}
}
let response: LargeBlobsResponse = from_slice(&bytes).map_err(CommandError::Deserializing)?;
Ok(response)
}
pub fn write_large_blob_segment<Dev>(
dev: &mut Dev,
keep_alive: &dyn Fn() -> bool,
bytes: &[u8],
initial_offset: u64,
pin_uv_auth_token: Option<PinUvAuthToken>,
) -> Result<(), AuthenticatorError>
where
Dev: FidoDevice,
{
// Spec:
// A per-authenticator constant, maxFragmentLength, is here defined as the value of maxMsgSize (from the authenticatorGetInfo response) minus 64.
// If no maxMsgSize is given in the authenticatorGetInfo response) then it defaults to 1024, leaving maxFragmentLength to default to 960.
//
// In the highly unlikely case of a max_msg_size smaller than 65 (leaving zero-byte fragment-length), we error out, saying that largeBlobs is unsupported.
let max_msg_size = dev
.get_authenticator_info()
.and_then(|i| i.max_msg_size)
.unwrap_or(1024);
if max_msg_size <= 64 {
return Err(AuthenticatorError::UnsupportedOption(
UnsupportedOption::LargeBlobs,
));
}
let max_fragment_length = max_msg_size - 64;
let total_length = bytes.len();
let mut offset = initial_offset;
for chunk in bytes.chunks(max_fragment_length) {
let chunk_len = chunk.len();
let mut cmd = LargeBlobs {
get: None,
set: Some(ByteBuf::from(chunk)),
offset,
length: if offset == 0 {
Some(total_length as u64)
} else {
None
},
pin_uv_auth_param: None,
};
cmd.set_pin_uv_auth_param(pin_uv_auth_token.clone())?;
dev.send_cbor_cancellable(&cmd, keep_alive)?;
offset += chunk_len as u64;
}
Ok(())
}
pub fn add_large_blob<Dev>(
dev: &mut Dev,
keep_alive: &dyn Fn() -> bool,
blob: LargeBlobArrayElement,
pin_uv_auth_token: Option<PinUvAuthToken>,
) -> Result<(), AuthenticatorError>
where
Dev: FidoDevice,
{
let mut array = read_large_blob_array(dev, keep_alive)?;
// Adding it
array.large_blob_array.push(blob);
// Then rewriting the whole array
let mut bytes = to_vec(&array.large_blob_array).map_err(CommandError::Serializing)?;
let mut hasher = Sha256::new();
hasher.update(&bytes);
let hash = hasher.finalize();
bytes.extend_from_slice(&hash[..16]);
write_large_blob_segment(dev, keep_alive, &bytes, 0, pin_uv_auth_token)
}
#[cfg(test)]
pub mod tests {
use super::*;
use crate::consts::HIDCmd;
use crate::transport::device_selector::Device;
use crate::transport::hid::HIDDevice;
use crate::transport::platform::device::{IN_HID_RPT_SIZE, OUT_HID_RPT_SIZE};
use crate::transport::{FidoDevice, FidoProtocol};
use rand::{thread_rng, RngCore};
fn add_bytes_to_read(cid: &[u8], bytes: &[u8], device: &mut Device) {
let mut data = Vec::new();
let payload_len = (bytes.len() + 1) as u16;
// We skip the very first byte (HIDCmd::Cbor), as we will insert it below
data.extend(payload_len.to_be_bytes());
data.push(0x00); // status == success
data.extend(bytes);
let chunks = data.chunks(IN_HID_RPT_SIZE - 5);
for (id, chunk) in chunks.enumerate() {
let mut msg = cid.to_vec();
let state_or_seq = if id == 0 {
HIDCmd::Cbor.into()
} else {
(id - 1) as u8 // SEQ
};
msg.push(state_or_seq);
msg.extend(chunk);
device.add_read(&msg, 0);
}
}
fn add_bytes_to_write(cid: &[u8], bytes: &[u8], device: &mut Device) {
let mut data = Vec::new();
let payload_len = (bytes.len()) as u16;
// We skip the very first byte (HIDCmd::Cbor), as we will insert it below
data.extend(payload_len.to_be_bytes());
data.extend(bytes);
let chunks = data.chunks(OUT_HID_RPT_SIZE - 5);
for (id, chunk) in chunks.enumerate() {
let mut msg = cid.to_vec();
let state_or_seq = if id == 0 {
HIDCmd::Cbor.into()
} else {
(id - 1) as u8 // SEQ
};
msg.push(state_or_seq);
msg.extend(chunk);
device.add_write(&msg, 0);
}
}
#[test]
fn test_read_large_blob_array() {
let keep_alive = || true;
let mut device = Device::new("commands/large_blobs").unwrap();
assert_eq!(device.get_protocol(), FidoProtocol::CTAP2);
// 'initialize' the device
let mut cid = [0u8; 4];
thread_rng().fill_bytes(&mut cid);
device.set_cid(cid);
let cmd = [
0xa2, // map(2)
0x01, // unsigned(1) - get
0x19, 0x03, 0xc0, // unsigned(960)
0x03, // unsigned(3) - offset
0x00, // unsigned(0)
];
let mut msg = cid.to_vec();
msg.extend(vec![HIDCmd::Cbor.into(), 0x00, cmd.len() as u8 + 1]); // cmd + bcnt
msg.extend(vec![0x0C]); // LargeBlobs
msg.extend(cmd); // Actual command
device.add_write(&msg, 0);
add_bytes_to_read(&cid, &LARGE_BLOB_ARRAY, &mut device);
let array = read_large_blob_array(&mut device, &keep_alive)
.expect("Failed to read large blob array");
let expected = get_expected_large_blobs_response();
assert_eq!(expected, array);
}
#[test]
fn test_read_large_blob_array_with_wrong_hash() {
let keep_alive = || true;
let mut device = Device::new("commands/large_blobs").unwrap();
assert_eq!(device.get_protocol(), FidoProtocol::CTAP2);
// 'initialize' the device
let mut cid = [0u8; 4];
thread_rng().fill_bytes(&mut cid);
device.set_cid(cid);
let cmd = [
0xa2, // map(2)
0x01, // unsigned(1) - get
0x19, 0x03, 0xc0, // unsigned(960)
0x03, // unsigned(3) - offset
0x00, // unsigned(0)
];
let mut msg = cid.to_vec();
msg.extend(vec![HIDCmd::Cbor.into(), 0x00, cmd.len() as u8 + 1]); // cmd + bcnt
msg.extend(vec![0x0C]); // LargeBlobs
msg.extend(cmd); // Actual command
device.add_write(&msg, 0);
let mut payload = LARGE_BLOB_ARRAY;
payload[483] += 1; // Changing one byte in the hash
add_bytes_to_read(&cid, &payload, &mut device);
// Should succeed, but give us the default empty Large blob array, as defined by the spec
let array = read_large_blob_array(&mut device, &keep_alive)
.expect("Failed to read large blob array");
let expected = LargeBlobsResponse {
large_blob_array: vec![],
hash: [
0x76, 0xbe, 0x8b, 0x52, 0x8d, 0x00, 0x75, 0xf7, 0xaa, 0xe9, 0x8d, 0x6f, 0xa5, 0x7a,
0x6d, 0x3c,
],
byte_len: 1,
};
assert_eq!(expected, array);
}
#[test]
fn test_read_large_blob_array_multi_read() {
let keep_alive = || true;
let mut device = Device::new("commands/large_blobs").unwrap();
assert_eq!(device.get_protocol(), FidoProtocol::CTAP2);
device.set_authenticator_info(crate::AuthenticatorInfo {
max_msg_size: Some(164), // Note: This value minus 64 will be the fragment size
..Default::default()
});
// 'initialize' the device
let mut cid = [0u8; 4];
thread_rng().fill_bytes(&mut cid);
device.set_cid(cid);
for ii in 0..5 {
let mut cmd = vec![
0xa2, // map(2)
0x01, // unsigned(1) - get
0x18, 0x64, // unsigned(100)
0x03, // unsigned(3) - offset
];
cmd.extend(&to_vec(&serde_cbor::Value::Integer(ii * 100)).unwrap());
let mut msg = cid.to_vec();
msg.extend(vec![HIDCmd::Cbor.into(), 0x00, cmd.len() as u8 + 1]); // cmd + bcnt
msg.extend(vec![0x0C]); // LargeBlobs
msg.extend(cmd); // Actual command
device.add_write(&msg, 0);
}
for chunk in LARGE_BLOB_ARRAY.chunks(100) {
add_bytes_to_read(&cid, chunk, &mut device);
}
let array = read_large_blob_array(&mut device, &keep_alive)
.expect("Failed to read large blob array");
let expected = get_expected_large_blobs_response();
assert_eq!(expected, array);
}
#[test]
fn test_add_large_blob_element() {
let keep_alive = || true;
let mut device = Device::new("commands/large_blobs").unwrap();
assert_eq!(device.get_protocol(), FidoProtocol::CTAP2);
// First we read the whole existing array
let mut cid = [0u8; 4];
thread_rng().fill_bytes(&mut cid);
device.set_cid(cid);
let cmd = [
0xa2, // map(2)
0x01, // unsigned(1) - get
0x19, 0x03, 0xc0, // unsigned(960)
0x03, // unsigned(3) - offset
0x00, // unsigned(0)
];
let mut msg = cid.to_vec();
msg.extend(vec![HIDCmd::Cbor.into(), 0x00, cmd.len() as u8 + 1]); // cmd + bcnt
msg.extend(vec![0x0C]); // LargeBlobs
msg.extend(cmd); // Actual command
device.add_write(&msg, 0);
add_bytes_to_read(&cid, &LARGE_BLOB_ARRAY, &mut device);
// Now add write-command
let mut cmd = vec![
0x0C, // LargeBlobs
0xa3, // map(3)
0x02, // unsigned(1) - set
0x59, 0x02, 0x78, // unsigned(632) 479+153
];
cmd.extend(LARGE_BLOB_ARRAY_LONGER);
cmd.extend([
0x03, // unsigned(3) - offset
0x00, // unsigned(0)
0x04, // unsigned(4) - length
0x19, 0x02, 0x78, // unsigned(631)
]);
add_bytes_to_write(&cid, &cmd, &mut device);
// empty success-command
add_bytes_to_read(&cid, &[], &mut device);
let add_parsed = additional_blob_element();
add_large_blob(&mut device, &keep_alive, add_parsed, None)
.expect("Failed to write add large blob element");
}
#[test]
fn test_add_large_blob_element_multi_write() {
let keep_alive = || true;
let mut device = Device::new("commands/large_blobs").unwrap();
assert_eq!(device.get_protocol(), FidoProtocol::CTAP2);
device.set_authenticator_info(crate::AuthenticatorInfo {
max_msg_size: Some(164), // Note: This value minus 64 will be the fragment size
..Default::default()
});
// First we read the whole existing array
let mut cid = [0u8; 4];
thread_rng().fill_bytes(&mut cid);
device.set_cid(cid);
for ii in 0..5 {
let mut cmd = vec![
0xa2, // map(2)
0x01, // unsigned(1) - get
0x18, 0x64, // unsigned(100)
0x03, // unsigned(3) - offset
];
cmd.extend(&to_vec(&serde_cbor::Value::Integer(ii * 100)).unwrap());
let mut msg = cid.to_vec();
msg.extend(vec![HIDCmd::Cbor.into(), 0x00, cmd.len() as u8 + 1]); // cmd + bcnt
msg.extend(vec![0x0C]); // LargeBlobs
msg.extend(cmd); // Actual command
device.add_write(&msg, 0);
}
for chunk in LARGE_BLOB_ARRAY.chunks(100) {
add_bytes_to_read(&cid, chunk, &mut device);
}
// Now add write-command
for (ii, chunk) in LARGE_BLOB_ARRAY_LONGER.chunks(100).enumerate() {
let mut cmd = vec![
0x0C, // LargeBlobs
];
if ii == 0 {
cmd.push(0xa3); // map(3) // with 'length'
} else {
cmd.push(0xa2); // map(2) // without 'length'
}
cmd.push(0x02); // unsigned(1) - set
if ii == 6 {
cmd.extend([0x58, 0x20]); // unsigned(32) Remaining bytes
} else {
cmd.extend([0x58, 0x64]); // unsigned(100) Remaining bytes
}
cmd.extend(chunk);
cmd.push(0x03); // unsigned(3) - offset
cmd.extend(&to_vec(&serde_cbor::Value::Integer((ii * 100) as i128)).unwrap());
if ii == 0 {
cmd.extend([
0x04, // unsigned(4) - length
0x19, 0x02, 0x78, // unsigned(631)
]);
}
add_bytes_to_write(&cid, &cmd, &mut device);
// empty success-command
add_bytes_to_read(&cid, &[], &mut device);
}
let add_parsed = additional_blob_element();
add_large_blob(&mut device, &keep_alive, add_parsed, None)
.expect("Failed to write add large blob element");
}
fn additional_blob_element() -> LargeBlobArrayElement {
LargeBlobArrayElement {
ciphertext: vec![
116, 199, 82, 206, 68, 131, 237, 242, 213, 144, 244, 185, 155, 148, 217, 62, 245,
5, 128, 162, 176, 99, 5, 160, 186, 68, 88, 140, 38, 255, 168, 254, 88, 161, 188,
30, 113, 221, 67, 21, 88, 43, 211, 17, 190, 252, 14, 186, 225, 200, 135, 186, 168,
255, 232, 51, 151, 183, 194, 134, 160, 250, 191, 141,
],
nonce: [117, 86, 137, 126, 205, 2, 34, 50, 18, 20, 165, 104],
orig_size: 34,
}
}
fn get_expected_large_blobs_response() -> LargeBlobsResponse {
LargeBlobsResponse {
large_blob_array: vec![
LargeBlobArrayElement {
ciphertext: vec![
116, 199, 82, 206, 68, 131, 237, 242, 213, 144, 244, 185, 155, 148, 217,
62, 245, 5, 128, 162, 176, 99, 5, 160, 186, 68, 88, 140, 38, 255, 168, 254,
88, 161, 188, 30, 113, 221, 67, 21, 88, 43, 211, 17, 190, 252, 14, 186,
225, 200, 135, 186, 168, 255, 232, 51, 151, 183, 194, 134, 160, 250, 191,
141,
],
nonce: [117, 86, 137, 126, 205, 2, 34, 50, 18, 20, 165, 104],
orig_size: 34,
},
LargeBlobArrayElement {
ciphertext: vec![
71, 124, 111, 114, 77, 240, 163, 5, 124, 7, 191, 2, 177, 167, 200, 95, 248,
163, 235, 77, 195, 106, 253, 23, 183, 119, 55, 17, 50, 238, 217, 248, 56,
135, 48, 49, 101, 132, 66, 78, 58, 23, 101, 77, 52, 213, 89, 73, 34, 61,
237, 8, 219, 1, 208, 245, 129, 101, 234, 114, 170, 54, 7, 147, 59, 226, 32,
],
nonce: [99, 132, 251, 236, 134, 156, 86, 195, 121, 49, 205, 162],
orig_size: 36,
},
LargeBlobArrayElement {
ciphertext: vec![
212, 135, 116, 12, 170, 245, 186, 103, 147, 112, 196, 29, 43, 120, 236,
175, 205, 84, 184, 231, 118, 152, 76, 60, 216, 128, 204, 166, 96, 8, 67, 3,
163, 242, 243, 124, 156, 65, 138, 98, 66, 46, 201, 40, 219, 236, 53, 43,
107, 14, 135, 23, 99, 150, 240, 14, 234, 153, 115, 94, 180, 117, 162, 213,
],
nonce: [231, 165, 15, 21, 64, 8, 234, 133, 6, 223, 226, 134],
orig_size: 34,
},
],
hash: [
0x15, 0xee, 0x84, 0xa0, 0xce, 0x5d, 0xa7, 0xd6, 0x6d, 0x3e, 0xb6, 0xf2, 0xc1, 0x40,
0x28, 0x65,
],
byte_len: 463,
}
}
#[rustfmt::skip]
pub const LARGE_BLOB_ARRAY: [u8; 484] = [
0xa1, // map(1)
0x01, // unsigned(1)
0x59, 0x01, 0xdf, // bytes(479)
0x83, // array(3)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x40, // array(64)
0x18, 0x74, 0x18, 0xc7, 0x18, 0x52, 0x18, 0xce, 0x18, 0x44, 0x18, 0x83, 0x18, 0xed, 0x18, 0xf2, 0x18, 0xd5, 0x18, 0x90, 0x18, 0xf4, 0x18, 0xb9, 0x18, 0x9b, 0x18, 0x94, 0x18, 0xd9, 0x18, 0x3e, 0x18, 0xf5, 0x05, 0x18, 0x80, 0x18, 0xa2, 0x18, 0xb0, 0x18, 0x63, 0x05, 0x18, 0xa0, 0x18, 0xba, 0x18, 0x44, 0x18, 0x58, 0x18, 0x8c, 0x18, 0x26, 0x18, 0xff, 0x18, 0xa8, 0x18, 0xfe, 0x18, 0x58, 0x18, 0xa1, 0x18, 0xbc, 0x18, 0x1e, 0x18, 0x71, 0x18, 0xdd, 0x18, 0x43, 0x15, 0x18, 0x58, 0x18, 0x2b, 0x18, 0xd3, 0x11, 0x18, 0xbe, 0x18, 0xfc, 0x0e, 0x18, 0xba, 0x18, 0xe1, 0x18, 0xc8, 0x18, 0x87, 0x18, 0xba, 0x18, 0xa8, 0x18, 0xff, 0x18, 0xe8, 0x18, 0x33, 0x18, 0x97, 0x18, 0xb7, 0x18, 0xc2, 0x18, 0x86, 0x18, 0xa0, 0x18, 0xfa, 0x18, 0xbf, 0x18, 0x8d,
0x02, // unsigned(2) - nonce
0x8c, // array(12)
0x18, 0x75, 0x18, 0x56, 0x18, 0x89, 0x18, 0x7e, 0x18, 0xcd, 0x02, 0x18, 0x22, 0x18, 0x32, 0x12, 0x14, 0x18, 0xa5, 0x18, 0x68,
0x03, // unsigned(3) - origSize
0x18, 0x22, // unsigned(34)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x43, // array(67)
0x18, 0x47, 0x18, 0x7c, 0x18, 0x6f, 0x18, 0x72, 0x18, 0x4d, 0x18, 0xf0, 0x18, 0xa3, 0x05, 0x18, 0x7c, 0x07, 0x18, 0xbf, 0x02, 0x18, 0xb1, 0x18, 0xa7, 0x18, 0xc8, 0x18, 0x5f, 0x18, 0xf8, 0x18, 0xa3, 0x18, 0xeb, 0x18, 0x4d, 0x18, 0xc3, 0x18, 0x6a, 0x18, 0xfd, 0x17, 0x18, 0xb7, 0x18, 0x77, 0x18, 0x37, 0x11, 0x18, 0x32, 0x18, 0xee, 0x18, 0xd9, 0x18, 0xf8, 0x18, 0x38, 0x18, 0x87, 0x18, 0x30, 0x18, 0x31, 0x18, 0x65, 0x18, 0x84, 0x18, 0x42, 0x18, 0x4e, 0x18, 0x3a, 0x17, 0x18, 0x65, 0x18, 0x4d, 0x18, 0x34, 0x18, 0xd5, 0x18, 0x59, 0x18, 0x49, 0x18, 0x22, 0x18, 0x3d, 0x18, 0xed, 0x08, 0x18, 0xdb, 0x01, 0x18, 0xd0, 0x18, 0xf5, 0x18, 0x81, 0x18, 0x65, 0x18, 0xea, 0x18, 0x72, 0x18, 0xaa, 0x18, 0x36, 0x07, 0x18, 0x93, 0x18, 0x3b, 0x18, 0xe2, 0x18, 0x20,
0x02, // unsigned(2)
0x8c, // array(12) - nonce
0x18, 0x63, 0x18, 0x84, 0x18, 0xfb, 0x18, 0xec, 0x18, 0x86, 0x18, 0x9c, 0x18, 0x56, 0x18, 0xc3, 0x18, 0x79, 0x18, 0x31, 0x18, 0xcd, 0x18, 0xa2,
0x03, // unsigned(3) - origSize
0x18, 0x24, // unsigned(36)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x40, // array(64)
0x18, 0xd4, 0x18, 0x87, 0x18, 0x74, 0x0c, 0x18, 0xaa, 0x18, 0xf5, 0x18, 0xba, 0x18, 0x67, 0x18, 0x93, 0x18, 0x70, 0x18, 0xc4, 0x18, 0x1d, 0x18, 0x2b, 0x18, 0x78, 0x18, 0xec, 0x18, 0xaf, 0x18, 0xcd, 0x18, 0x54, 0x18, 0xb8, 0x18, 0xe7, 0x18, 0x76, 0x18, 0x98, 0x18, 0x4c, 0x18, 0x3c, 0x18, 0xd8, 0x18, 0x80, 0x18, 0xcc, 0x18, 0xa6, 0x18, 0x60, 0x08, 0x18, 0x43, 0x03, 0x18, 0xa3, 0x18, 0xf2, 0x18, 0xf3, 0x18, 0x7c, 0x18, 0x9c, 0x18, 0x41, 0x18, 0x8a, 0x18, 0x62, 0x18, 0x42, 0x18, 0x2e, 0x18, 0xc9, 0x18, 0x28, 0x18, 0xdb, 0x18, 0xec, 0x18, 0x35, 0x18, 0x2b, 0x18, 0x6b, 0x0e, 0x18, 0x87, 0x17, 0x18, 0x63, 0x18, 0x96, 0x18, 0xf0, 0x0e, 0x18, 0xea, 0x18, 0x99, 0x18, 0x73, 0x18, 0x5e, 0x18, 0xb4, 0x18, 0x75, 0x18, 0xa2, 0x18, 0xd5,
0x02, // unsigned(2) - nonce
0x8c, // array(12)
0x18, 0xe7, 0x18, 0xa5, 0x0f, 0x15, 0x18, 0x40, 0x08, 0x18, 0xea, 0x18, 0x85, 0x06, 0x18, 0xdf, 0x18, 0xe2, 0x18, 0x86,
0x03, // unsigned(3) - origSize
0x18, 0x22, // unsigned(34)
0x15, 0xee, 0x84, 0xa0, 0xce, 0x5d, 0xa7, 0xd6, 0x6d, 0x3e, 0xb6, 0xf2, 0xc1, 0x40, 0x28, 0x65 // trailing hash-bytes
];
#[rustfmt::skip]
pub const LARGE_BLOB_ARRAY_LONGER: [u8; 632] = [
// Skipping initial map(1) -> unsigned(1) -> bytes(632), as we have to change that with
// fragmented writes
0x84, // array(4)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x40, // array(64)
0x18, 0x74, 0x18, 0xc7, 0x18, 0x52, 0x18, 0xce, 0x18, 0x44, 0x18, 0x83, 0x18, 0xed, 0x18, 0xf2, 0x18, 0xd5, 0x18, 0x90, 0x18, 0xf4, 0x18, 0xb9, 0x18, 0x9b, 0x18, 0x94, 0x18, 0xd9, 0x18, 0x3e, 0x18, 0xf5, 0x05, 0x18, 0x80, 0x18, 0xa2, 0x18, 0xb0, 0x18, 0x63, 0x05, 0x18, 0xa0, 0x18, 0xba, 0x18, 0x44, 0x18, 0x58, 0x18, 0x8c, 0x18, 0x26, 0x18, 0xff, 0x18, 0xa8, 0x18, 0xfe, 0x18, 0x58, 0x18, 0xa1, 0x18, 0xbc, 0x18, 0x1e, 0x18, 0x71, 0x18, 0xdd, 0x18, 0x43, 0x15, 0x18, 0x58, 0x18, 0x2b, 0x18, 0xd3, 0x11, 0x18, 0xbe, 0x18, 0xfc, 0x0e, 0x18, 0xba, 0x18, 0xe1, 0x18, 0xc8, 0x18, 0x87, 0x18, 0xba, 0x18, 0xa8, 0x18, 0xff, 0x18, 0xe8, 0x18, 0x33, 0x18, 0x97, 0x18, 0xb7, 0x18, 0xc2, 0x18, 0x86, 0x18, 0xa0, 0x18, 0xfa, 0x18, 0xbf, 0x18, 0x8d,
0x02, // unsigned(2) - nonce
0x8c, // array(12)
0x18, 0x75, 0x18, 0x56, 0x18, 0x89, 0x18, 0x7e, 0x18, 0xcd, 0x02, 0x18, 0x22, 0x18, 0x32, 0x12, 0x14, 0x18, 0xa5, 0x18, 0x68,
0x03, // unsigned(3) - origSize
0x18, 0x22, // unsigned(34)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x43, // array(67)
0x18, 0x47, 0x18, 0x7c, 0x18, 0x6f, 0x18, 0x72, 0x18, 0x4d, 0x18, 0xf0, 0x18, 0xa3, 0x05, 0x18, 0x7c, 0x07, 0x18, 0xbf, 0x02, 0x18, 0xb1, 0x18, 0xa7, 0x18, 0xc8, 0x18, 0x5f, 0x18, 0xf8, 0x18, 0xa3, 0x18, 0xeb, 0x18, 0x4d, 0x18, 0xc3, 0x18, 0x6a, 0x18, 0xfd, 0x17, 0x18, 0xb7, 0x18, 0x77, 0x18, 0x37, 0x11, 0x18, 0x32, 0x18, 0xee, 0x18, 0xd9, 0x18, 0xf8, 0x18, 0x38, 0x18, 0x87, 0x18, 0x30, 0x18, 0x31, 0x18, 0x65, 0x18, 0x84, 0x18, 0x42, 0x18, 0x4e, 0x18, 0x3a, 0x17, 0x18, 0x65, 0x18, 0x4d, 0x18, 0x34, 0x18, 0xd5, 0x18, 0x59, 0x18, 0x49, 0x18, 0x22, 0x18, 0x3d, 0x18, 0xed, 0x08, 0x18, 0xdb, 0x01, 0x18, 0xd0, 0x18, 0xf5, 0x18, 0x81, 0x18, 0x65, 0x18, 0xea, 0x18, 0x72, 0x18, 0xaa, 0x18, 0x36, 0x07, 0x18, 0x93, 0x18, 0x3b, 0x18, 0xe2, 0x18, 0x20,
0x02, // unsigned(2)
0x8c, // array(12) - nonce
0x18, 0x63, 0x18, 0x84, 0x18, 0xfb, 0x18, 0xec, 0x18, 0x86, 0x18, 0x9c, 0x18, 0x56, 0x18, 0xc3, 0x18, 0x79, 0x18, 0x31, 0x18, 0xcd, 0x18, 0xa2,
0x03, // unsigned(3) - origSize
0x18, 0x24, // unsigned(36)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x40, // array(64)
0x18, 0xd4, 0x18, 0x87, 0x18, 0x74, 0x0c, 0x18, 0xaa, 0x18, 0xf5, 0x18, 0xba, 0x18, 0x67, 0x18, 0x93, 0x18, 0x70, 0x18, 0xc4, 0x18, 0x1d, 0x18, 0x2b, 0x18, 0x78, 0x18, 0xec, 0x18, 0xaf, 0x18, 0xcd, 0x18, 0x54, 0x18, 0xb8, 0x18, 0xe7, 0x18, 0x76, 0x18, 0x98, 0x18, 0x4c, 0x18, 0x3c, 0x18, 0xd8, 0x18, 0x80, 0x18, 0xcc, 0x18, 0xa6, 0x18, 0x60, 0x08, 0x18, 0x43, 0x03, 0x18, 0xa3, 0x18, 0xf2, 0x18, 0xf3, 0x18, 0x7c, 0x18, 0x9c, 0x18, 0x41, 0x18, 0x8a, 0x18, 0x62, 0x18, 0x42, 0x18, 0x2e, 0x18, 0xc9, 0x18, 0x28, 0x18, 0xdb, 0x18, 0xec, 0x18, 0x35, 0x18, 0x2b, 0x18, 0x6b, 0x0e, 0x18, 0x87, 0x17, 0x18, 0x63, 0x18, 0x96, 0x18, 0xf0, 0x0e, 0x18, 0xea, 0x18, 0x99, 0x18, 0x73, 0x18, 0x5e, 0x18, 0xb4, 0x18, 0x75, 0x18, 0xa2, 0x18, 0xd5,
0x02, // unsigned(2) - nonce
0x8c, // array(12)
0x18, 0xe7, 0x18, 0xa5, 0x0f, 0x15, 0x18, 0x40, 0x08, 0x18, 0xea, 0x18, 0x85, 0x06, 0x18, 0xdf, 0x18, 0xe2, 0x18, 0x86,
0x03, // unsigned(3) - origSize
0x18, 0x22, // unsigned(34)
0xa3, // map(3)
0x01, // unsigned(1) - ciphertext
0x98, 0x40, // array(64)
0x18, 0x74, 0x18, 0xc7, 0x18, 0x52, 0x18, 0xce, 0x18, 0x44, 0x18, 0x83, 0x18, 0xed, 0x18, 0xf2, 0x18, 0xd5, 0x18, 0x90, 0x18, 0xf4, 0x18, 0xb9, 0x18, 0x9b, 0x18, 0x94, 0x18, 0xd9, 0x18, 0x3e, 0x18, 0xf5, 0x05, 0x18, 0x80, 0x18, 0xa2, 0x18, 0xb0, 0x18, 0x63, 0x05, 0x18, 0xa0, 0x18, 0xba, 0x18, 0x44, 0x18, 0x58, 0x18, 0x8c, 0x18, 0x26, 0x18, 0xff, 0x18, 0xa8, 0x18, 0xfe, 0x18, 0x58, 0x18, 0xa1, 0x18, 0xbc, 0x18, 0x1e, 0x18, 0x71, 0x18, 0xdd, 0x18, 0x43, 0x15, 0x18, 0x58, 0x18, 0x2b, 0x18, 0xd3, 0x11, 0x18, 0xbe, 0x18, 0xfc, 0x0e, 0x18, 0xba, 0x18, 0xe1, 0x18, 0xc8, 0x18, 0x87, 0x18, 0xba, 0x18, 0xa8, 0x18, 0xff, 0x18, 0xe8, 0x18, 0x33, 0x18, 0x97, 0x18, 0xb7, 0x18, 0xc2, 0x18, 0x86, 0x18, 0xa0, 0x18, 0xfa, 0x18, 0xbf, 0x18, 0x8d,
0x02, // unsigned(2) - nonce
0x8c, // array(12)
0x18, 0x75, 0x18, 0x56, 0x18, 0x89, 0x18, 0x7e, 0x18, 0xcd, 0x02, 0x18, 0x22, 0x18, 0x32, 0x12, 0x14, 0x18, 0xa5, 0x18, 0x68,
0x03, // unsigned(3) - origSize
0x18, 0x22, // unsigned(34)
0xb9, 0xd5, 0x4e, 0x96, 0xcf, 0x6e, 0xd8, 0xf6, 0xb4, 0x4c, 0x2e, 0xdc, 0xec, 0x76, 0x67, 0x0, // trailing hash-bytes
];
}