[BEEEP/POC] Noise IPC CryptoProvider

crates/bitwarden-ipc/Cargo.toml

@@ -19,9 +19,11 @@ wasm = [
 
 [dependencies]
 bitwarden-error = { workspace = true }
+ciborium = "0.2.2"
 js-sys = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+snow = "0.9.6"
 thiserror = { workspace = true }
 tokio = { features = ["sync", "time"], workspace = true }
 tsify-next = { workspace = true, optional = true }

crates/bitwarden-ipc/src/error.rs

@@ -7,6 +7,9 @@
 
     #[error("Communication error: {0}")]
     Communication(Com),
+
+    #[error("Handshake error")]
+    HandshakeError,
 }
 
 #[derive(Clone, Debug, Error, PartialEq, Eq)]
@@ -19,6 +22,12 @@
 
     #[error("Communication error: {0}")]
     Communication(Com),
+
+    #[error("Handshake error")]
+    HandshakeError,
+
+    #[error("Decode Error")]
+    DecodeError,
 }
 
 #[derive(Clone, Debug, Error, PartialEq, Eq)]
@@ -44,6 +53,9 @@
             ReceiveError::Timeout => TypedReceiveError::Timeout,
             ReceiveError::Crypto(crypto) => TypedReceiveError::Crypto(crypto),
             ReceiveError::Communication(com) => TypedReceiveError::Communication(com),
+            // todo
+            ReceiveError::HandshakeError => TypedReceiveError::Timeout,
+            ReceiveError::DecodeError => TypedReceiveError::Timeout,
         }
     }
 }

crates/bitwarden-ipc/src/ipc_client.rs

@@ -102,8 +102,11 @@ mod tests {
     use crate::{
         endpoint::Endpoint,
         traits::{
-            tests::{TestCommunicationBackend, TestCommunicationBackendReceiveError},
-            InMemorySessionRepository, NoEncryptionCryptoProvider,
+            tests::{
+                TestCommunicationBackend, TestCommunicationBackendReceiveError,
+                TestTwoWayCommunicationBackend,
+            },
+            InMemorySessionRepository, NoEncryptionCryptoProvider, NoiseCryptoProvider,
         },
     };
 
@@ -369,4 +372,64 @@ mod tests {
             Err(TypedReceiveError::Typing(serde_json::Error { .. }))
         ));
     }
+
+    #[tokio::test]
+    async fn communication_provider_ping_pong() {
+        let (sender_communication_provider, receiver_communication_provider) =
+            TestTwoWayCommunicationBackend::new();
+
+        let a = tokio::spawn(async move {
+            let receiver_crypto_provider = NoiseCryptoProvider;
+            let receiver_session_map = InMemorySessionRepository::new(HashMap::new());
+            let receiver_client = IpcClient::new(
+                receiver_crypto_provider,
+                receiver_communication_provider.clone(),
+                receiver_session_map,
+            );
+
+            for i in 0..10 {
+                let recv_message = receiver_client.receive(None, None).await.unwrap();
+                println!(
+                    "A: Received Message {:?}",
+                    String::from_utf8(recv_message.payload.clone())
+                );
+                let message = OutgoingMessage {
+                    payload: format!("Hello, world! {}", i).as_bytes().to_vec(),
+                    destination: Endpoint::BrowserBackground,
+                    topic: None,
+                };
+                println!("A: Sending Message {:?}", message);
+                receiver_client.send(message.clone()).await.unwrap();
+            }
+        });
+
+        let b = tokio::spawn(async move {
+            let sender_crypto_provider = NoiseCryptoProvider;
+            let sender_session_map = InMemorySessionRepository::new(HashMap::new());
+            let sender_client = IpcClient::new(
+                sender_crypto_provider,
+                sender_communication_provider.clone(),
+                sender_session_map,
+            );
+
+            for i in 0..10 {
+                let message = OutgoingMessage {
+                    payload: format!("Hello, world! {}", i).as_bytes().to_vec(),
+                    destination: Endpoint::BrowserBackground,
+                    topic: None,
+                };
+                println!("B: Sending Message {:?}", message);
+                sender_client.send(message.clone()).await.unwrap();
+
+                let recv_message = sender_client.receive(None, None).await.unwrap();
+                println!(
+                    "B: Received Message {:?}",
+                    String::from_utf8(recv_message.payload.clone())
+                );
+                assert_eq!(recv_message.payload, message.payload);
+            }
+        });
+
+        let _ = tokio::join!(a, b);
+    }
 }

crates/bitwarden-ipc/src/traits/communication_backend.rs

@@ -23,10 +23,13 @@ pub trait CommunicationBackend {
 }
 #[cfg(test)]
 pub mod tests {
-    use std::{collections::VecDeque, rc::Rc};
+    use std::{collections::VecDeque, rc::Rc, sync::Arc};
 
     use thiserror::Error;
-    use tokio::sync::RwLock;
+    use tokio::sync::{
+        mpsc::{self, Receiver, Sender},
+        Mutex, RwLock,
+    };
 
     use super::*;
 
@@ -80,4 +83,47 @@ pub mod tests {
             }
         }
     }
+
+    #[derive(Debug, Clone)]
+    pub struct TestTwoWayCommunicationBackend {
+        outgoing: Sender<OutgoingMessage>,
+        incoming: Arc<Mutex<Receiver<OutgoingMessage>>>,
+    }
+
+    impl TestTwoWayCommunicationBackend {
+        pub fn new() -> (Self, Self) {
+            let (outgoing0, incoming0) = mpsc::channel(10);
+            let (outgoing1, incoming1) = mpsc::channel(10);
+            let one = TestTwoWayCommunicationBackend {
+                outgoing: outgoing0,
+                incoming: Arc::new(Mutex::new(incoming1)),
+            };
+            let two = TestTwoWayCommunicationBackend {
+                outgoing: outgoing1,
+                incoming: Arc::new(Mutex::new(incoming0)),
+            };
+            (one, two)
+        }
+    }
+
+    impl CommunicationBackend for TestTwoWayCommunicationBackend {
+        type SendError = ();
+        type ReceiveError = TestCommunicationBackendReceiveError;
+
+        async fn send(&self, message: OutgoingMessage) -> Result<(), Self::SendError> {
+            self.outgoing.send(message).await.unwrap();
+            Ok(())
+        }
+
+        async fn receive(&self) -> Result<IncomingMessage, Self::ReceiveError> {
+            let mut receiver = self.incoming.lock().await;
+            let message = receiver.recv().await.unwrap();
+            Ok(IncomingMessage {
+                payload: message.payload,
+                destination: message.destination,
+                source: crate::endpoint::Endpoint::DesktopRenderer,
+                topic: None,
+            })
+        }
+    }
 }

crates/bitwarden-ipc/src/traits/mod.rs

@@ -1,9 +1,12 @@
 mod communication_backend;
 mod crypto_provider;
+mod noise_crypto_provider;
 mod session_repository;
 
 #[cfg(test)]
 pub use communication_backend::tests;
 pub use communication_backend::CommunicationBackend;
 pub use crypto_provider::{CryptoProvider, NoEncryptionCryptoProvider};
+#[cfg(test)]
+pub use noise_crypto_provider::NoiseCryptoProvider;
 pub use session_repository::{InMemorySessionRepository, SessionRepository};