4261611727

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/<a class="double-link" href="https://git"><a class=hub.com/google/OpenSK/commit/6389b48bc2ef443a69ee44788c290cb8cbe6ce47">6389b48bc">&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/6389b48bc2ef443a69ee44788c290cb8cbe6ce47">6389b48bc</a><a href="https://github.com/google/OpenSK/commit/6389b48bc2ef443a69ee44788c290cb8cbe6ce47">&lt;a href=&quot;https://github.com/google/OpenSK/commit/6389b48bc2ef443a69ee44788c290cb8cbe6ce47&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;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/google/OpenSK/commit/6389b48bc2ef443a69ee44788c290cb8cbe6ce47&amp;quot;&amp;gt;6389b48bc&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/google/OpenSK/commit/6389b48bc2ef443a69ee44788c290cb8cbe6ce47&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/OpenSK/commit/6389b48bc2ef443a69ee44788c290cb8&amp;lt;/a&amp;gt;c</a>be6ce47&quot;&gt;&amp;quot;&amp;gt;Merge &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;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/OpenSK/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/google/OpenSK/commit/da9814b56&quot;&gt;da9814b56&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/co... (continued)

Pull Request Pull Request #596: Clock trait

Run Details

790 of 790 new or added lines in 17 files covered. (100.0%)

14194 of 16142 relevant lines covered (87.93%)

776014.26 hits per line

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

87.5

/src/ctap/vendor_hid.rs

// Copyright 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 crate::ctap::hid::{
    CtapHid, CtapHidCommand, CtapHidError, HidPacket, HidPacketIterator, Message,
};
use crate::ctap::{Channel, CtapState};
use crate::env::Env;

/// Implements the non-standard command processing for HID.
///
/// Outside of the pure HID commands like INIT, only PING and CBOR commands are allowed.
pub struct VendorHid<E: Env> {
    hid: CtapHid<E>,
}

impl<E: Env> VendorHid<E> {
    /// Instantiates a HID handler for CTAP1, CTAP2 and Wink.
    pub fn new() -> Self {
        let hid = CtapHid::<E>::new(CtapHid::<E>::CAPABILITY_CBOR | CtapHid::<E>::CAPABILITY_NMSG);
        VendorHid { hid }
    }

    /// Processes an incoming USB HID packet, and returns an iterator for all outgoing packets.
    pub fn process_hid_packet(
        &mut self,
        env: &mut E,
        packet: &HidPacket,
        ctap_state: &mut CtapState<E>,
    ) -> HidPacketIterator {
        if let Some(message) = self.hid.parse_packet(env, packet) {
            let processed_message = self.process_message(env, message, ctap_state);
            debug_ctap!(
                env,
                "Sending message through the second usage page: {:02x?}",
                processed_message
            );
            CtapHid::<E>::split_message(processed_message)
        } else {
            HidPacketIterator::none()
        }
    }

    /// Processes a message's commands that affect the protocol outside HID.
    pub fn process_message(
        &mut self,
        env: &mut E,
        message: Message,
        ctap_state: &mut CtapState<E>,
    ) -> Message {
        let cid = message.cid;
        match message.cmd {
            // There are no custom CTAP1 commands.
            CtapHidCommand::Msg => CtapHid::<E>::error_message(cid, CtapHidError::InvalidCmd),
            // The CTAP2 processing function multiplexes internally.
            CtapHidCommand::Cbor => {
                let response =
                    ctap_state.process_command(env, &message.payload, Channel::VendorHid(cid));
                Message {
                    cid,
                    cmd: CtapHidCommand::Cbor,
                    payload: response,
                }
            }
            // Call Wink over the main HID.
            CtapHidCommand::Wink => CtapHid::<E>::error_message(cid, CtapHidError::InvalidCmd),
            // All other commands have already been processed, keep them as is.
            _ => message,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::ctap::hid::ChannelID;
    use crate::env::test::TestEnv;

    fn new_initialized() -> (VendorHid<TestEnv>, ChannelID) {
        let (hid, cid) = CtapHid::new_initialized();
        (VendorHid::<TestEnv> { hid }, cid)
    }

    #[test]
    fn test_process_hid_packet() {
        let mut env = TestEnv::new();
        let mut ctap_state = CtapState::<TestEnv>::new(&mut env);
        let (mut vendor_hid, cid) = new_initialized();

        let mut ping_packet = [0x00; 64];
        ping_packet[..4].copy_from_slice(&cid);
        ping_packet[4..9].copy_from_slice(&[0x81, 0x00, 0x02, 0x99, 0x99]);

        let mut response = vendor_hid.process_hid_packet(&mut env, &ping_packet, &mut ctap_state);
        assert_eq!(response.next(), Some(ping_packet));
        assert_eq!(response.next(), None);
    }

    #[test]
    fn test_process_hid_packet_empty() {
        let mut env = TestEnv::new();
        let mut ctap_state = CtapState::<TestEnv>::new(&mut env);
        let (mut vendor_hid, cid) = new_initialized();

        let mut cancel_packet = [0x00; 64];
        cancel_packet[..4].copy_from_slice(&cid);
        cancel_packet[4..7].copy_from_slice(&[0x91, 0x00, 0x00]);

        let mut response = vendor_hid.process_hid_packet(&mut env, &cancel_packet, &mut ctap_state);
        assert_eq!(response.next(), None);
    }

    #[test]
    fn test_blocked_commands() {
        let mut env = TestEnv::new();
        let mut ctap_state = CtapState::<TestEnv>::new(&mut env);
        let (mut vendor_hid, cid) = new_initialized();

        // Usually longer, but we don't parse them anyway.
        let mut msg_packet = [0x00; 64];
        msg_packet[..4].copy_from_slice(&cid);
        msg_packet[4..7].copy_from_slice(&[0x83, 0x00, 0x00]);

        let mut wink_packet = [0x00; 64];
        wink_packet[..4].copy_from_slice(&cid);
        wink_packet[4..7].copy_from_slice(&[0x88, 0x00, 0x00]);

        let mut error_packet = [0x00; 64];
        error_packet[..4].copy_from_slice(&cid);
        error_packet[4..8].copy_from_slice(&[0xBF, 0x00, 0x01, 0x01]);

        let mut response = vendor_hid.process_hid_packet(&mut env, &msg_packet, &mut ctap_state);
        assert_eq!(response.next(), Some(error_packet));
        assert_eq!(response.next(), None);

        let mut response = vendor_hid.process_hid_packet(&mut env, &wink_packet, &mut ctap_state);
        assert_eq!(response.next(), Some(error_packet));
        assert_eq!(response.next(), None);
    }
}

1	// Copyright 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 crate::ctap::hid::{
16	CtapHid, CtapHidCommand, CtapHidError, HidPacket, HidPacketIterator, Message,
17	};
18	use crate::ctap::{Channel, CtapState};
19	use crate::env::Env;
20
21	/// Implements the non-standard command processing for HID.
22	///
23	/// Outside of the pure HID commands like INIT, only PING and CBOR commands are allowed.
24	pub struct VendorHid<E: Env> {
25	hid: CtapHid<E>,
26	}
27
28	impl<E: Env> VendorHid<E> {
29	/// Instantiates a HID handler for CTAP1, CTAP2 and Wink.
30	pub fn new() -> Self {	×
31	let hid = CtapHid::<E>::new(CtapHid::<E>::CAPABILITY_CBOR \| CtapHid::<E>::CAPABILITY_NMSG);	×
32	VendorHid { hid }	×
33	}	×
34
35	/// Processes an incoming USB HID packet, and returns an iterator for all outgoing packets.
36	pub fn process_hid_packet(
37	&mut self,
38	env: &mut E,
39	packet: &HidPacket,
40	ctap_state: &mut CtapState<E>,
41	) -> HidPacketIterator {
42	if let Some(message) = self.hid.parse_packet(env, packet) {	8✔
43	let processed_message = self.process_message(env, message, ctap_state);	6✔
44	debug_ctap!(	6✔
45	env,	6✔
46	"Sending message through the second usage page: {:02x?}",	6✔
47	processed_message	6✔
48	);	6✔
49	CtapHid::<E>::split_message(processed_message)	6✔
50	} else {
51	HidPacketIterator::none()	2✔
52	}
53	}	8✔
54
55	/// Processes a message's commands that affect the protocol outside HID.
56	pub fn process_message(	6✔
57	&mut self,	6✔
58	env: &mut E,	6✔
59	message: Message,	6✔
60	ctap_state: &mut CtapState<E>,	6✔
61	) -> Message {	6✔
62	let cid = message.cid;	6✔
63	match message.cmd {	6✔
64	// There are no custom CTAP1 commands.	6✔
65	CtapHidCommand::Msg => CtapHid::<E>::error_message(cid, CtapHidError::InvalidCmd),	6✔
66	// The CTAP2 processing function multiplexes internally.
67	CtapHidCommand::Cbor => {
68	let response =	×
69	ctap_state.process_command(env, &message.payload, Channel::VendorHid(cid));	×
70	Message {	×
71	cid,	×
72	cmd: CtapHidCommand::Cbor,	×
73	payload: response,	×
74	}	×
75	}
76	// Call Wink over the main HID.
77	CtapHidCommand::Wink => CtapHid::<E>::error_message(cid, CtapHidError::InvalidCmd),	2✔
78	// All other commands have already been processed, keep them as is.
79	_ => message,	2✔
80	}
81	}	6✔
82	}
83
84	#[cfg(test)]
85	mod test {
86	use super::*;
87	use crate::ctap::hid::ChannelID;
88	use crate::env::test::TestEnv;
89
90	fn new_initialized() -> (VendorHid<TestEnv>, ChannelID) {	6✔
91	let (hid, cid) = CtapHid::new_initialized();	6✔
92	(VendorHid::<TestEnv> { hid }, cid)	6✔
93	}	6✔
94
95	#[test]
96	fn test_process_hid_packet() {	3✔
97	let mut env = TestEnv::new();	2✔
98	let mut ctap_state = CtapState::<TestEnv>::new(&mut env);	2✔
99	let (mut vendor_hid, cid) = new_initialized();	2✔
100		2✔
101	let mut ping_packet = [0x00; 64];	2✔
102	ping_packet[..4].copy_from_slice(&cid);	2✔
103	ping_packet[4..9].copy_from_slice(&[0x81, 0x00, 0x02, 0x99, 0x99]);	2✔
104		2✔
105	let mut response = vendor_hid.process_hid_packet(&mut env, &ping_packet, &mut ctap_state);	2✔
106	assert_eq!(response.next(), Some(ping_packet));	2✔
107	assert_eq!(response.next(), None);	2✔
108	}	2✔
109
110	#[test]
111	fn test_process_hid_packet_empty() {	3✔
112	let mut env = TestEnv::new();	2✔
113	let mut ctap_state = CtapState::<TestEnv>::new(&mut env);	2✔
114	let (mut vendor_hid, cid) = new_initialized();	2✔
115		2✔
116	let mut cancel_packet = [0x00; 64];	2✔
117	cancel_packet[..4].copy_from_slice(&cid);	2✔
118	cancel_packet[4..7].copy_from_slice(&[0x91, 0x00, 0x00]);	2✔
119		2✔
120	let mut response = vendor_hid.process_hid_packet(&mut env, &cancel_packet, &mut ctap_state);	2✔
121	assert_eq!(response.next(), None);	2✔
122	}	2✔
123
124	#[test]
125	fn test_blocked_commands() {	3✔
126	let mut env = TestEnv::new();	2✔
127	let mut ctap_state = CtapState::<TestEnv>::new(&mut env);	2✔
128	let (mut vendor_hid, cid) = new_initialized();	2✔
129		2✔
130	// Usually longer, but we don't parse them anyway.	2✔
131	let mut msg_packet = [0x00; 64];	2✔
132	msg_packet[..4].copy_from_slice(&cid);	2✔
133	msg_packet[4..7].copy_from_slice(&[0x83, 0x00, 0x00]);	2✔
134		2✔
135	let mut wink_packet = [0x00; 64];	2✔
136	wink_packet[..4].copy_from_slice(&cid);	2✔
137	wink_packet[4..7].copy_from_slice(&[0x88, 0x00, 0x00]);	2✔
138		2✔
139	let mut error_packet = [0x00; 64];	2✔
140	error_packet[..4].copy_from_slice(&cid);	2✔
141	error_packet[4..8].copy_from_slice(&[0xBF, 0x00, 0x01, 0x01]);	2✔
142		2✔
143	let mut response = vendor_hid.process_hid_packet(&mut env, &msg_packet, &mut ctap_state);	2✔
144	assert_eq!(response.next(), Some(error_packet));	2✔
145	assert_eq!(response.next(), None);	2✔
146
147	let mut response = vendor_hid.process_hid_packet(&mut env, &wink_packet, &mut ctap_state);	2✔
148	assert_eq!(response.next(), Some(error_packet));	2✔
149	assert_eq!(response.next(), None);	2✔
150	}	2✔
151	}

google / OpenSK / 4261611727

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