Merge branch 'ui-traits'

Author: benma

src/rust/bitbox02-rust/src/hww.rs

@@ -17,6 +17,8 @@ pub mod noise;
 
 use alloc::vec::Vec;
 
+use crate::workflow::RealWorkflows;
+
 const OP_UNLOCK: u8 = b'u';
 const OP_ATTESTATION: u8 = b'a';
 
@@ -113,14 +115,16 @@ fn api_attestation(usb_in: &[u8]) -> Vec<u8> {
 /// `usb_in` - api request bytes.
 /// Returns the usb response bytes.
 pub async fn process_packet(usb_in: Vec<u8>) -> Vec<u8> {
+    let workflows = &mut RealWorkflows;
+
     match usb_in.split_first() {
         Some((&OP_UNLOCK, b"")) => return api_unlock().await,
         Some((&OP_ATTESTATION, rest)) => return api_attestation(rest),
         _ => (),
     }
 
     let mut out = [OP_STATUS_SUCCESS].to_vec();
-    match noise::process(usb_in, &mut out).await {
+    match noise::process(workflows, usb_in, &mut out).await {
         Ok(()) => out,
         Err(noise::Error) => [OP_STATUS_FAILURE].to_vec(),
     }

src/rust/bitbox02-rust/src/hww/api.rs

@@ -46,7 +46,7 @@ use pb::request::Request;
 use pb::response::Response;
 use prost::Message;
 
-use crate::workflow::{RealWorkflows, Workflows};
+use crate::workflow::Workflows;
 
 /// Encodes a protobuf Response message.
 pub fn encode(response: Response) -> Vec<u8> {
@@ -159,8 +159,10 @@ fn can_call(request: &Request) -> bool {
 }
 
 /// Handle a protobuf api call.
-async fn process_api(request: &Request) -> Result<Response, Error> {
-    let workflows = &mut RealWorkflows;
+async fn process_api<W: Workflows>(
+    workflows: &mut W,
+    request: &Request,
+) -> Result<Response, Error> {
     match request {
         Request::Reboot(ref request) => system::reboot(request).await,
         Request::DeviceInfo(_) => device_info::process(),
@@ -213,7 +215,7 @@ async fn process_api(request: &Request) -> Result<Response, Error> {
 ///
 /// `input` is a hww.proto Request message, protobuf encoded.
 /// Returns a protobuf encoded hww.proto Response message.
-pub async fn process(input: Vec<u8>) -> Vec<u8> {
+pub async fn process<W: Workflows>(workflows: &mut W, input: Vec<u8>) -> Vec<u8> {
     let request = match decode(&input[..]) {
         Ok(request) => request,
         Err(err) => return encode(make_error(err)),
@@ -222,7 +224,7 @@ pub async fn process(input: Vec<u8>) -> Vec<u8> {
         return encode(make_error(Error::InvalidState));
     }
 
-    match process_api(&request).await {
+    match process_api(workflows, &request).await {
         Ok(response) => encode(response),
         Err(error) => encode(make_error(error)),
     }

src/rust/bitbox02-rust/src/hww/noise.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::workflow::pairing;
+use crate::workflow::{pairing, Workflows};
 use alloc::vec::Vec;
 use bitbox02::memory;
 use core::cell::RefCell;
@@ -75,7 +75,11 @@ pub fn decrypt(msg: &[u8]) -> Result<Vec<u8>, Error> {
 /// Returns Err if anything goes wrong:
 /// - Invalid OP-code
 /// - Noise message in the wrong state (e.g. handshake before init, etc.).
-pub(crate) async fn process(usb_in: Vec<u8>, usb_out: &mut Vec<u8>) -> Result<(), Error> {
+pub(crate) async fn process<W: Workflows>(
+    workflows: &mut W,
+    usb_in: Vec<u8>,
+    usb_out: &mut Vec<u8>,
+) -> Result<(), Error> {
     match usb_in.split_first() {
         Some((&OP_I_CAN_HAS_HANDSHAEK, b"")) => {
             // The previous screen was "See the BitBoxApp".
@@ -117,7 +121,7 @@ pub(crate) async fn process(usb_in: Vec<u8>, usb_out: &mut Vec<u8>) -> Result<()
                 let state = NOISE_STATE.0.borrow();
                 state.get_handshake_hash()?
             };
-            match pairing::confirm(&hash).await {
+            match pairing::confirm(workflows, &hash).await {
                 Ok(()) => {
                     let mut state = NOISE_STATE.0.borrow_mut();
                     state.set_pairing_verified()?;
@@ -138,7 +142,7 @@ pub(crate) async fn process(usb_in: Vec<u8>, usb_out: &mut Vec<u8>) -> Result<()
         }
         Some((&OP_NOISE_MSG, encrypted_msg)) => {
             let decrypted_msg = decrypt(encrypted_msg)?;
-            let response = super::api::process(decrypted_msg).await;
+            let response = super::api::process(workflows, decrypted_msg).await;
             encrypt(&response, usb_out)?;
             Ok(())
         }

src/rust/bitbox02-rust/src/workflow/pairing.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::workflow::confirm;
+use crate::workflow::{confirm, Workflows};
 pub use confirm::UserAbort;
 
 use alloc::string::String;
@@ -32,43 +32,42 @@ pub fn format_hash(hash: &[u8; 32]) -> String {
     )
 }
 
-pub async fn confirm(hash: &[u8; 32]) -> Result<(), UserAbort> {
+pub async fn confirm<W: Workflows>(workflows: &mut W, hash: &[u8; 32]) -> Result<(), UserAbort> {
     let params = confirm::Params {
         title: "Pairing code",
         body: &format_hash(hash),
         font: confirm::Font::Monogram5X9,
         ..Default::default()
     };
 
-    confirm::confirm(&params).await
+    workflows.confirm(&params).await
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     use crate::bb02_async::block_on;
+    use crate::workflow::testing::{Screen, TestingWorkflows};
     use bitbox02::testing::{mock, Data};
 
     use alloc::boxed::Box;
 
     #[test]
     fn test_confirm() {
-        static mut CONFIRMED: bool = false;
-        mock(Data {
-            ui_confirm_create: Some(Box::new(|params| {
-                assert_eq!(params.title, "Pairing code");
-                assert_eq!(params.body, "LEUJX W53W2\n3I5DY SP5E2");
-                unsafe {
-                    CONFIRMED = true;
-                }
-                true
-            })),
+        let mut mock_workflows = TestingWorkflows::new();
 
-            ..Default::default()
-        });
         assert!(block_on(confirm(
+            &mut mock_workflows,
             b"\x59\x28\x9b\xdb\xbb\xb6\xb6\x8e\x8f\x12\x7f\x49\xa5\x25\xb0\x30\x13\x50\x0b\x3c\x1a\xf2\x62\x6f\x40\x07\xeb\xe4\x4f\x09\xc8\x6b")).is_ok());
-        assert!(unsafe { CONFIRMED });
+
+        assert_eq!(
+            mock_workflows.screens,
+            vec![Screen::Confirm {
+                title: "Pairing code".into(),
+                body: "LEUJX W53W2\n3I5DY SP5E2".into(),
+                longtouch: false,
+            },]
+        );
     }
 }