Clock trait

Cargo.toml

@@ -20,7 +20,6 @@ persistent_store = { path = "libraries/persistent_store" }
 byteorder = { version = "1", default-features = false }
 arrayref = "0.3.6"
 subtle = { version = "2.2", default-features = false, features = ["nightly"] }
-embedded-time = "0.12.1"
 arbitrary = { version = "0.4.7", features = ["derive"], optional = true }
 rand = { version = "0.8.4", optional = true }
 ed25519-compact = { version = "1", default-features = false, optional = true }

fuzz/fuzz_helper/src/lib.rs

@@ -20,7 +20,6 @@ use arbitrary::{Arbitrary, Unstructured};
 use arrayref::array_ref;
 use core::convert::TryFrom;
 use ctap2::api::customization::is_valid;
-use ctap2::clock::CtapInstant;
 use ctap2::ctap::command::{
     AuthenticatorClientPinParameters, AuthenticatorGetAssertionParameters,
     AuthenticatorMakeCredentialParameters, Command,
@@ -89,12 +88,8 @@ fn initialize(ctap: &mut Ctap<TestEnv>) -> ChannelID {
     let mut assembler_reply = MessageAssembler::new();
     let mut result_cid: ChannelID = Default::default();
     for pkt_request in HidPacketIterator::new(message).unwrap() {
-        for pkt_reply in
-            ctap.process_hid_packet(&pkt_request, Transport::MainHid, CtapInstant::new(0))
-        {
-            if let Ok(Some(result)) =
-                assembler_reply.parse_packet(ctap.env(), &pkt_reply, CtapInstant::new(0))
-            {
+        for pkt_reply in ctap.process_hid_packet(&pkt_request, Transport::MainHid) {
+            if let Ok(Some(result)) = assembler_reply.parse_packet(ctap.env(), &pkt_reply) {
                 result_cid.copy_from_slice(&result.payload[8..12]);
             }
         }
@@ -131,11 +126,9 @@ fn process_message(data: &[u8], ctap: &mut Ctap<TestEnv>) {
     if let Some(hid_packet_iterator) = HidPacketIterator::new(message) {
         let mut assembler_reply = MessageAssembler::new();
         for pkt_request in hid_packet_iterator {
-            for pkt_reply in
-                ctap.process_hid_packet(&pkt_request, Transport::MainHid, CtapInstant::new(0))
-            {
+            for pkt_reply in ctap.process_hid_packet(&pkt_request, Transport::MainHid) {
                 // Only checks for assembling crashes, not for semantics.
-                let _ = assembler_reply.parse_packet(ctap.env(), &pkt_reply, CtapInstant::new(0));
+                let _ = assembler_reply.parse_packet(ctap.env(), &pkt_reply);
             }
         }
     }
@@ -152,7 +145,7 @@ pub fn process_ctap_any_type(data: &[u8]) -> arbitrary::Result<()> {
 
     let data = unstructured.take_rest();
     // Initialize ctap state and hid and get the allocated cid.
-    let mut ctap = Ctap::new(env, CtapInstant::new(0));
+    let mut ctap = Ctap::new(env);
     let cid = initialize(&mut ctap);
     // Wrap input as message with the allocated cid.
     let mut command = cid.to_vec();
@@ -179,7 +172,7 @@ fn setup_customization(
 
 fn setup_state(
     unstructured: &mut Unstructured,
-    state: &mut CtapState,
+    state: &mut CtapState<TestEnv>,
     env: &mut TestEnv,
 ) -> FuzzResult<()> {
     if bool::arbitrary(unstructured)? {
@@ -202,7 +195,7 @@ pub fn process_ctap_specific_type(data: &[u8], input_type: InputType) -> arbitra
         return Ok(());
     }
     // Initialize ctap state and hid and get the allocated cid.
-    let mut ctap = Ctap::new(env, CtapInstant::new(0));
+    let mut ctap = Ctap::new(env);
     let cid = initialize(&mut ctap);
     // Wrap input as message with allocated cid and command type.
     let mut command = cid.to_vec();
@@ -232,7 +225,7 @@ pub fn process_ctap_structured(data: &[u8], input_type: InputType) -> FuzzResult
     env.rng().seed_from_u64(u64::arbitrary(unstructured)?);
     setup_customization(unstructured, env.customization_mut())?;
 
-    let mut state = CtapState::new(&mut env, CtapInstant::new(0));
+    let mut state = CtapState::new(&mut env);
     setup_state(unstructured, &mut state, &mut env)?;
 
     let command = match input_type {
@@ -255,7 +248,6 @@ pub fn process_ctap_structured(data: &[u8], input_type: InputType) -> FuzzResult
             &mut env,
             command,
             Channel::MainHid(ChannelID::arbitrary(unstructured)?),
-            CtapInstant::new(0),
         )
         .ok();
 
@@ -276,13 +268,10 @@ pub fn split_assemble_hid_packets(data: &[u8]) -> arbitrary::Result<()> {
         let packets: Vec<HidPacket> = hid_packet_iterator.collect();
         if let Some((last_packet, first_packets)) = packets.split_last() {
             for packet in first_packets {
-                assert_eq!(
-                    assembler.parse_packet(&mut env, packet, CtapInstant::new(0)),
-                    Ok(None)
-                );
+                assert_eq!(assembler.parse_packet(&mut env, packet), Ok(None));
             }
             assert_eq!(
-                assembler.parse_packet(&mut env, last_packet, CtapInstant::new(0)),
+                assembler.parse_packet(&mut env, last_packet),
                 Ok(Some(message))
             );
         }

src/api/clock.rs

@@ -0,0 +1,39 @@
+// Copyright 2022-2023 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.
+
+pub trait Clock {
+    /// Stores data for the clock to recognize if this timer is elapsed or not.
+    ///
+    /// The Clock does not keep track of the timers it creates. Therefore, they should not wrap
+    /// unexpectedly. A timer that is elapsed may never return to a non-elapsed state.
+    ///
+    /// A default Timer should return `true` when checked with `is_elapsed`.
+    type Timer: Default;
+
+    /// Creates a new timer that expires after the given time in ms.
+    fn make_timer(&mut self, milliseconds: usize) -> Self::Timer;
+
+    /// Checks whether a given timer is expired.
+    ///
+    /// Until a timer expires, this function consistently returns false. Once it expires, this
+    /// function consistently returns true. In particular, it is valid to continue calling this
+    /// function after the first time it returns true.
+    fn is_elapsed(&mut self, timer: &Self::Timer) -> bool;
+
+    /// Timestamp in microseconds.
+    ///
+    /// Normal operation only needs relative time, absolute timestamps are useful for debugging.
+    #[cfg(feature = "debug_ctap")]
+    fn timestamp_us(&mut self) -> usize;
+}

src/api/connection.rs

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::clock::ClockInt;
-use embedded_time::duration::Milliseconds;
 use libtock_drivers::usb_ctap_hid::UsbEndpoint;
 
 pub enum SendOrRecvStatus {
@@ -27,9 +25,5 @@ pub struct SendOrRecvError;
 pub type SendOrRecvResult = Result<SendOrRecvStatus, SendOrRecvError>;
 
 pub trait HidConnection {
-    fn send_and_maybe_recv(
-        &mut self,
-        buf: &mut [u8; 64],
-        timeout: Milliseconds<ClockInt>,
-    ) -> SendOrRecvResult;
+    fn send_and_maybe_recv(&mut self, buf: &mut [u8; 64], timeout_ms: usize) -> SendOrRecvResult;
 }

src/api/mod.rs

@@ -18,6 +18,7 @@
 //! by a trait. This module gathers the API of those components.
 
 pub mod attestation_store;
+pub mod clock;
 pub mod connection;
 pub mod customization;
 pub mod firmware_protection;

src/api/user_presence.rs

@@ -12,9 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::clock::ClockInt;
-use embedded_time::duration::Milliseconds;
-
 #[derive(Debug)]
 pub enum UserPresenceError {
     /// User explicitly declined user presence check.
@@ -36,7 +33,7 @@ pub trait UserPresence {
     /// Waits until user presence is confirmed, rejected, or the given timeout expires.
     ///
     /// Must be called between calls to [`Self::check_init`] and [`Self::check_complete`].
-    fn wait_with_timeout(&mut self, timeout: Milliseconds<ClockInt>) -> UserPresenceResult;
+    fn wait_with_timeout(&mut self, timeout_ms: usize) -> UserPresenceResult;
 
     /// Finalizes a user presence check.
     ///