2708629986

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/google/OpenSK/commit/<a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/f1f2f4ee045ee84f3712a178050b310b34954f4d">f1f2f4ee0">&lt;a href=&quot;https://github.com/google/OpenSK/commit/</a><a class="double-link" href="https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/OpenSK/commit/f1f2f4ee045ee84f3712a178050b310b34954f4d">f1f2f4ee0</a><a href="https://github.com/google/OpenSK/commit/f1f2f4ee045ee84f3712a178050b310b34954f4d">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/google/OpenSK/commit/f1f2f4ee045ee84f3712a178050b310b34954f4d&quot;&gt;f1f2f4ee0&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/f1f2f4ee045ee84f3712a178050b310b34954f4d&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;htt... (continued)

Pull Request Pull Request #515: Interleave sending and receiving of packets to reduce rx latency

Run Details

5 of 5 new or added lines in 2 files covered. (100.0%)

13556 of 15124 relevant lines covered (89.63%)

527895.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.53

/src/ctap/hid/send.rs

// Copyright 2019-2022 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::{CtapHid, HidPacket, Message};

/// Iterator for HID packets.
///
/// The `new` constructor splits the CTAP `Message` into `HidPacket`s for sending over USB.
pub struct HidPacketIterator(Option<MessageSplitter>);

impl HidPacketIterator {
    pub fn new(message: Message) -> Option<HidPacketIterator> {
        let splitter = MessageSplitter::new(message);
        if splitter.is_some() {
            Some(HidPacketIterator(splitter))
        } else {
            None
        }
    }

    pub fn none() -> HidPacketIterator {
        HidPacketIterator(None)
    }

    pub fn has_data(&self) -> bool {
        self.0.is_some()
    }
}

impl Iterator for HidPacketIterator {
    type Item = HidPacket;

    fn next(&mut self) -> Option<HidPacket> {
        match &mut self.0 {
            Some(splitter) => splitter.next(),
            None => None,
        }
    }
}

struct MessageSplitter {
    message: Message,
    packet: HidPacket,
    seq: Option<u8>,
    i: usize,
}

impl MessageSplitter {
    /// Try to split this message into an iterator of HID packets.
    ///
    /// This fails if the message is too long to fit into a sequence of HID packets.
    pub fn new(message: Message) -> Option<MessageSplitter> {
        if message.payload.len() > 7609 {
            None
        } else {
            // Cache the CID, as it is constant for all packets in this message.
            let mut packet = [0; 64];
            packet[..4].copy_from_slice(&message.cid);

            Some(MessageSplitter {
                message,
                packet,
                seq: None,
                i: 0,
            })
        }
    }

    /// Copy as many bytes as possible from data to dst, and return how many bytes are copied.
    ///
    /// Contrary to copy_from_slice, this doesn't require slices of the same length.
    /// All unused bytes in dst are set to zero, as if the data was padded with zeros to match.
    fn consume_data(dst: &mut [u8], data: &[u8]) -> usize {
        let dst_len = dst.len();
        let data_len = data.len();

        if data_len <= dst_len {
            // data fits in dst, copy all the bytes.
            dst[..data_len].copy_from_slice(data);
            for byte in dst[data_len..].iter_mut() {
                *byte = 0;
            }
            data_len
        } else {
            // Fill all of dst.
            dst.copy_from_slice(&data[..dst_len]);
            dst_len
        }
    }
}

impl Iterator for MessageSplitter {
    type Item = HidPacket;

    fn next(&mut self) -> Option<HidPacket> {
        let payload_len = self.message.payload.len();
        match self.seq {
            None => {
                // First, send an initialization packet.
                self.packet[4] = self.message.cmd as u8 | CtapHid::TYPE_INIT_BIT;
                self.packet[5] = (payload_len >> 8) as u8;
                self.packet[6] = payload_len as u8;

                self.seq = Some(0);
                self.i =
                    MessageSplitter::consume_data(&mut self.packet[7..], &self.message.payload);
                Some(self.packet)
            }
            Some(seq) => {
                // Send the next continuation packet, if any.
                if self.i < payload_len {
                    self.packet[4] = seq;
                    self.seq = Some(seq + 1);
                    self.i += MessageSplitter::consume_data(
                        &mut self.packet[5..],
                        &self.message.payload[self.i..],
                    );
                    Some(self.packet)
                } else {
                    None
                }
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::super::CtapHidCommand;
    use super::*;

    fn assert_packet_output_equality(message: Message, expected_packets: Vec<HidPacket>) {
        let packets: Vec<HidPacket> = HidPacketIterator::new(message).unwrap().collect();
        assert_eq!(packets.len(), expected_packets.len());
        for (packet, expected_packet) in packets.iter().zip(expected_packets.iter()) {
            assert_eq!(packet as &[u8], expected_packet as &[u8]);
        }
    }

    #[test]
    fn test_hid_packet_iterator_single_packet() {
        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Cbor,
            payload: vec![0xAA, 0xBB],
        };
        let expected_packets: Vec<HidPacket> = vec![[
            0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x02, 0xAA, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ]];
        assert_packet_output_equality(message, expected_packets);
    }

    #[test]
    fn test_hid_packet_iterator_big_single_packet() {
        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Cbor,
            payload: vec![0xAA; 64 - 7],
        };
        let expected_packets: Vec<HidPacket> = vec![[
            0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x39, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
        ]];
        assert_packet_output_equality(message, expected_packets);
    }

    #[test]
    fn test_hid_packet_iterator_two_packets() {
        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Cbor,
            payload: vec![0xAA; 64 - 7 + 1],
        };
        let expected_packets: Vec<HidPacket> = vec![
            [
                0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x3A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
            ],
            [
                0x12, 0x34, 0x56, 0x78, 0x00, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            ],
        ];
        assert_packet_output_equality(message, expected_packets);
    }

    #[test]
    fn test_hid_packet_iterator_two_full_packets() {
        let mut payload = vec![0xAA; 64 - 7];
        payload.extend(vec![0xBB; 64 - 5]);
        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Cbor,
            payload,
        };
        let expected_packets: Vec<HidPacket> = vec![
            [
                0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x74, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
                0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
            ],
            [
                0x12, 0x34, 0x56, 0x78, 0x00, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
                0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
                0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
                0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
                0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
            ],
        ];
        assert_packet_output_equality(message, expected_packets);
    }

    #[test]
    fn test_hid_packet_iterator_max_packets() {
        let mut payload = vec![0xFF; 64 - 7];
        for i in 0..128 {
            payload.extend(vec![i + 1; 64 - 5]);
        }

        // Sanity check for the length of the payload.
        assert_eq!(payload.len(), 0x1db9);

        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Msg,
            payload,
        };

        let mut expected_packets: Vec<HidPacket> = vec![[
            0x12, 0x34, 0x56, 0x78, 0x83, 0x1D, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
        ]];
        for i in 0..128 {
            let mut packet: HidPacket = [0; 64];
            packet[0] = 0x12;
            packet[1] = 0x34;
            packet[2] = 0x56;
            packet[3] = 0x78;
            packet[4] = i;
            for byte in packet.iter_mut().skip(5) {
                *byte = i + 1;
            }
            expected_packets.push(packet);
        }

        assert_packet_output_equality(message, expected_packets);
    }

    #[test]
    fn test_hid_packet_iterator_payload_one_too_large() {
        let payload = vec![0xFF; (64 - 7) + 128 * (64 - 5) + 1];
        assert_eq!(payload.len(), 0x1dba);
        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Msg,
            payload,
        };
        assert!(HidPacketIterator::new(message).is_none());
    }

    #[test]
    fn test_hid_packet_iterator_payload_way_too_large() {
        // Check that overflow of u16 doesn't bypass the size limit.
        let payload = vec![0xFF; 0x10000];
        let message = Message {
            cid: [0x12, 0x34, 0x56, 0x78],
            cmd: CtapHidCommand::Msg,
            payload,
        };
        assert!(HidPacketIterator::new(message).is_none());
    }
}

1	// Copyright 2019-2022 Google LLC
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	use super::{CtapHid, HidPacket, Message};
16
17	/// Iterator for HID packets.
18	///
19	/// The `new` constructor splits the CTAP `Message` into `HidPacket`s for sending over USB.
20	pub struct HidPacketIterator(Option<MessageSplitter>);
21
22	impl HidPacketIterator {
23	pub fn new(message: Message) -> Option<HidPacketIterator> {	7,626✔
24	let splitter = MessageSplitter::new(message);	7,626✔
25	if splitter.is_some() {	7,626✔
26	Some(HidPacketIterator(splitter))	7,623✔
27	} else {
28	None	3✔
29	}
30	}	7,626✔
31
32	pub fn none() -> HidPacketIterator {	2✔
33	HidPacketIterator(None)	2✔
34	}	2✔
35
36	pub fn has_data(&self) -> bool {	×
37	self.0.is_some()	×
38	}	×
39	}
40
41	impl Iterator for HidPacketIterator {
42	type Item = HidPacket;
43
44	fn next(&mut self) -> Option<HidPacket> {	502,353✔
45	match &mut self.0 {	502,353✔
46	Some(splitter) => splitter.next(),	502,351✔
47	None => None,	2✔
48	}
49	}	502,353✔
50	}
51
52	struct MessageSplitter {
53	message: Message,
54	packet: HidPacket,
55	seq: Option<u8>,
56	i: usize,
57	}
58
59	impl MessageSplitter {
60	/// Try to split this message into an iterator of HID packets.
61	///
62	/// This fails if the message is too long to fit into a sequence of HID packets.
63	pub fn new(message: Message) -> Option<MessageSplitter> {	7,626✔
64	if message.payload.len() > 7609 {	7,626✔
65	None	3✔
66	} else {
67	// Cache the CID, as it is constant for all packets in this message.
68	let mut packet = [0; 64];	7,623✔
69	packet[..4].copy_from_slice(&message.cid);	7,623✔
70		7,623✔
71	Some(MessageSplitter {	7,623✔
72	message,	7,623✔
73	packet,	7,623✔
74	seq: None,	7,623✔
75	i: 0,	7,623✔
76	})	7,623✔
77	}
78	}	7,626✔
79
80	/// Copy as many bytes as possible from data to dst, and return how many bytes are copied.
81	///
82	/// Contrary to copy_from_slice, this doesn't require slices of the same length.
83	/// All unused bytes in dst are set to zero, as if the data was padded with zeros to match.
84	fn consume_data(dst: &mut [u8], data: &[u8]) -> usize {	494,728✔
85	let dst_len = dst.len();	494,728✔
86	let data_len = data.len();	494,728✔
87		494,728✔
88	if data_len <= dst_len {	494,728✔
89	// data fits in dst, copy all the bytes.
90	dst[..data_len].copy_from_slice(data);	7,623✔
91	for byte in dst[data_len..].iter_mut() {	221,276✔
92	*byte = 0;	221,276✔
93	}	221,276✔
94	data_len	7,623✔
95	} else {
96	// Fill all of dst.
97	dst.copy_from_slice(&data[..dst_len]);	487,105✔
98	dst_len	487,105✔
99	}
100	}	494,728✔
101	}
102
103	impl Iterator for MessageSplitter {
104	type Item = HidPacket;
105
106	fn next(&mut self) -> Option<HidPacket> {	502,351✔
107	let payload_len = self.message.payload.len();	502,351✔
108	match self.seq {	502,351✔
109	None => {	502,351✔
110	// First, send an initialization packet.
111	self.packet[4] = self.message.cmd as u8 \| CtapHid::TYPE_INIT_BIT;	7,622✔
112	self.packet[5] = (payload_len >> 8) as u8;	7,622✔
113	self.packet[6] = payload_len as u8;	7,622✔
114		7,622✔
115	self.seq = Some(0);	7,622✔
116	self.i =	7,622✔
117	MessageSplitter::consume_data(&mut self.packet[7..], &self.message.payload);	7,622✔
118	Some(self.packet)	7,622✔
119	}
120	Some(seq) => {	494,729✔
121	// Send the next continuation packet, if any.	494,729✔
122	if self.i < payload_len {	494,729✔
123	self.packet[4] = seq;	487,106✔
124	self.seq = Some(seq + 1);	487,106✔
125	self.i += MessageSplitter::consume_data(	487,106✔
126	&mut self.packet[5..],	487,106✔
127	&self.message.payload[self.i..],	487,106✔
128	);	487,106✔
129	Some(self.packet)	487,106✔
130	} else {
131	None	7,623✔
132	}
133	}
134	}
135	}	502,351✔
136	}
137
138	#[cfg(test)]
139	mod test {
140	use super::super::CtapHidCommand;
141	use super::*;
142
143	fn assert_packet_output_equality(message: Message, expected_packets: Vec<HidPacket>) {	5✔
144	let packets: Vec<HidPacket> = HidPacketIterator::new(message).unwrap().collect();	5✔
145	assert_eq!(packets.len(), expected_packets.len());	5✔
146	for (packet, expected_packet) in packets.iter().zip(expected_packets.iter()) {	135✔
147	assert_eq!(packet as &[u8], expected_packet as &[u8]);	135✔
148	}
149	}	5✔
150
151	#[test]
152	fn test_hid_packet_iterator_single_packet() {	1✔
153	let message = Message {	1✔
154	cid: [0x12, 0x34, 0x56, 0x78],	1✔
155	cmd: CtapHidCommand::Cbor,	1✔
156	payload: vec![0xAA, 0xBB],	1✔
157	};	1✔
158	let expected_packets: Vec<HidPacket> = vec![[	1✔
159	0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x02, 0xAA, 0xBB, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
160	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
161	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
162	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
163	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
164	]];	1✔
165	assert_packet_output_equality(message, expected_packets);	1✔
166	}	1✔
167
168	#[test]
169	fn test_hid_packet_iterator_big_single_packet() {	1✔
170	let message = Message {	1✔
171	cid: [0x12, 0x34, 0x56, 0x78],	1✔
172	cmd: CtapHidCommand::Cbor,	1✔
173	payload: vec![0xAA; 64 - 7],	1✔
174	};	1✔
175	let expected_packets: Vec<HidPacket> = vec![[	1✔
176	0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x39, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
177	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
178	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
179	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
180	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
181	]];	1✔
182	assert_packet_output_equality(message, expected_packets);	1✔
183	}	1✔
184
185	#[test]
186	fn test_hid_packet_iterator_two_packets() {	1✔
187	let message = Message {	1✔
188	cid: [0x12, 0x34, 0x56, 0x78],	1✔
189	cmd: CtapHidCommand::Cbor,	1✔
190	payload: vec![0xAA; 64 - 7 + 1],	1✔
191	};	1✔
192	let expected_packets: Vec<HidPacket> = vec![	1✔
193	[	1✔
194	0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x3A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
195	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
196	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
197	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
198	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
199	],	1✔
200	[	1✔
201	0x12, 0x34, 0x56, 0x78, 0x00, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
202	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
203	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
204	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
205	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	1✔
206	],	1✔
207	];	1✔
208	assert_packet_output_equality(message, expected_packets);	1✔
209	}	1✔
210
211	#[test]
212	fn test_hid_packet_iterator_two_full_packets() {	1✔
213	let mut payload = vec![0xAA; 64 - 7];	1✔
214	payload.extend(vec![0xBB; 64 - 5]);	1✔
215	let message = Message {	1✔
216	cid: [0x12, 0x34, 0x56, 0x78],	1✔
217	cmd: CtapHidCommand::Cbor,	1✔
218	payload,	1✔
219	};	1✔
220	let expected_packets: Vec<HidPacket> = vec![	1✔
221	[	1✔
222	0x12, 0x34, 0x56, 0x78, 0x90, 0x00, 0x74, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
223	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
224	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
225	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
226	0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,	1✔
227	],	1✔
228	[	1✔
229	0x12, 0x34, 0x56, 0x78, 0x00, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,	1✔
230	0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,	1✔
231	0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,	1✔
232	0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,	1✔
233	0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,	1✔
234	],	1✔
235	];	1✔
236	assert_packet_output_equality(message, expected_packets);	1✔
237	}	1✔
238
239	#[test]
240	fn test_hid_packet_iterator_max_packets() {	1✔
241	let mut payload = vec![0xFF; 64 - 7];	1✔
242	for i in 0..128 {	128✔
243	payload.extend(vec![i + 1; 64 - 5]);	128✔
244	}	128✔
245
246	// Sanity check for the length of the payload.
247	assert_eq!(payload.len(), 0x1db9);	1✔
248
249	let message = Message {	1✔
250	cid: [0x12, 0x34, 0x56, 0x78],	1✔
251	cmd: CtapHidCommand::Msg,	1✔
252	payload,	1✔
253	};	1✔
254		1✔
255	let mut expected_packets: Vec<HidPacket> = vec![[	1✔
256	0x12, 0x34, 0x56, 0x78, 0x83, 0x1D, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	1✔
257	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	1✔
258	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	1✔
259	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	1✔
260	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	1✔
261	]];	1✔
262	for i in 0..128 {	128✔
263	let mut packet: HidPacket = [0; 64];	128✔
264	packet[0] = 0x12;	128✔
265	packet[1] = 0x34;	128✔
266	packet[2] = 0x56;	128✔
267	packet[3] = 0x78;	128✔
268	packet[4] = i;	128✔
269	for byte in packet.iter_mut().skip(5) {	7,552✔
270	*byte = i + 1;	7,552✔
271	}	7,552✔
272	expected_packets.push(packet);	128✔
273	}
274
275	assert_packet_output_equality(message, expected_packets);	1✔
276	}	1✔
277
278	#[test]
279	fn test_hid_packet_iterator_payload_one_too_large() {	1✔
280	let payload = vec![0xFF; (64 - 7) + 128 * (64 - 5) + 1];	1✔
281	assert_eq!(payload.len(), 0x1dba);	1✔
282	let message = Message {	1✔
283	cid: [0x12, 0x34, 0x56, 0x78],	1✔
284	cmd: CtapHidCommand::Msg,	1✔
285	payload,	1✔
286	};	1✔
287	assert!(HidPacketIterator::new(message).is_none());	1✔
288	}	1✔
289
290	#[test]
291	fn test_hid_packet_iterator_payload_way_too_large() {	1✔
292	// Check that overflow of u16 doesn't bypass the size limit.
293	let payload = vec![0xFF; 0x10000];	1✔
294	let message = Message {	1✔
295	cid: [0x12, 0x34, 0x56, 0x78],	1✔
296	cmd: CtapHidCommand::Msg,	1✔
297	payload,	1✔
298	};	1✔
299	assert!(HidPacketIterator::new(message).is_none());	1✔
300	}	1✔
301	}

google / OpenSK / 2708629986

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous