2474610911

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/4b7a663d673e47f22a893577703a81ff8fe7c6d8">4b7a663d6">&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/4b7a663d673e47f22a893577703a81ff8fe7c6d8">4b7a663d6</a><a href="https://github.com/google/OpenSK/commit/4b7a663d673e47f22a893577703a81ff8fe7c6d8">&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/4b7a663d673e47f22a893577703a81ff8fe7c6d8&quot;&gt;4b7a663d6&lt;/a&gt;&lt;a href=&quot;https://github.com/google/OpenSK/commit/4b7a663d673e47f22a893577703a81ff8fe7c6d8&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 #496: allows passing in capabilities to CtapHid

Run Details

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

14162 of 16035 relevant lines covered (88.32%)

540764.61 hits per line

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

89.91

/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::clock::CtapInstant;
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 {
    hid: CtapHid,
}

impl VendorHid {
    /// Instantiates a HID handler for CTAP1, CTAP2 and Wink.
    pub fn new() -> Self {
        let hid = CtapHid::new(CtapHid::CAPABILITY_CBOR | CtapHid::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 impl Env,
        packet: &HidPacket,
        now: CtapInstant,
        ctap_state: &mut CtapState,
    ) -> HidPacketIterator {
        if let Some(message) = self.hid.parse_packet(env, packet, now) {
            let processed_message = self.process_message(env, message, now, ctap_state);
            debug_ctap!(
                env,
                "Sending message through the second usage page: {:02x?}",
                processed_message
            );
            CtapHid::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 impl Env,
        message: Message,
        now: CtapInstant,
        ctap_state: &mut CtapState,
    ) -> Message {
        let cid = message.cid;
        match message.cmd {
            // There are no custom CTAP1 commands.
            CtapHidCommand::Msg => CtapHid::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), now);
                Message {
                    cid,
                    cmd: CtapHidCommand::Cbor,
                    payload: response,
                }
            }
            // Call Wink over the main HID.
            CtapHidCommand::Wink => CtapHid::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, ChannelID) {
        let (hid, cid) = CtapHid::new_initialized();
        (VendorHid { hid }, cid)
    }

    #[test]
    fn test_process_hid_packet() {
        let mut env = TestEnv::new();
        let mut ctap_state = CtapState::new(&mut env, CtapInstant::new(0));
        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,
            CtapInstant::new(0),
            &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::new(&mut env, CtapInstant::new(0));
        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,
            CtapInstant::new(0),
            &mut ctap_state,
        );
        assert_eq!(response.next(), None);
    }

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

google / OpenSK / 2474610911

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