feat(IPC framework): [PM-18039] Complete initial IPC implementation

## 🎟️ Tracking

<!-- Paste the link to the Jira or GitHub issue or otherwise describe /
point to where this change is coming from. -->

## 📔 Objective

Client PR bitwarden/clients#13373

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

---------

Co-authored-by: Todd Martin <[email protected]>
Co-authored-by: Todd Martin <[email protected]>

Author: coroiu

Cargo.lock

@@ -27,6 +27,7 @@ bitwarden-crypto = { path = "crates/bitwarden-crypto", version = "=1.0.0" }
 bitwarden-exporters = { path = "crates/bitwarden-exporters", version = "=1.0.0" }
 bitwarden-fido = { path = "crates/bitwarden-fido", version = "=1.0.0" }
 bitwarden-generators = { path = "crates/bitwarden-generators", version = "=1.0.0" }
+bitwarden-ipc = { path = "crates/bitwarden-ipc", version = "=1.0.0" }
 bitwarden-send = { path = "crates/bitwarden-send", version = "=1.0.0" }
 bitwarden-sm = { path = "bitwarden_license/bitwarden-sm", version = "=1.0.0" }
 bitwarden-ssh = { path = "crates/bitwarden-ssh", version = "=1.0.0" }

Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "bitwarden-ipc"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license-file.workspace = true
+keywords.workspace = true
+
+[features]
+wasm = [
+    "dep:tsify-next",
+    "dep:wasm-bindgen",
+    "dep:wasm-bindgen-futures",
+    "dep:js-sys"
+] # WASM support
+
+[dependencies]
+bitwarden-error = { workspace = true }
+js-sys = { workspace = true, optional = true }
+serde = { workspace = true }
+thiserror = { workspace = true }
+tokio = { features = ["sync"], workspace = true }
+tsify-next = { workspace = true, optional = true }
+wasm-bindgen = { workspace = true, optional = true }
+wasm-bindgen-futures = { workspace = true, optional = true }
+
+[lints]
+workspace = true

crates/bitwarden-ipc/Cargo.toml

@@ -0,0 +1,13 @@
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "wasm")]
+use {tsify_next::Tsify, wasm_bindgen::prelude::*};
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
+pub enum Endpoint {
+    Web { id: i32 },
+    BrowserForeground,
+    BrowserBackground,
+    DesktopRenderer,
+    DesktopMain,
+}

crates/bitwarden-ipc/src/endpoint.rs

@@ -0,0 +1,19 @@
+use thiserror::Error;
+
+#[derive(Clone, Debug, Error, PartialEq, Eq)]
+pub enum SendError<Crypto, Com> {
+    #[error("Crypto error: {0}")]
+    CryptoError(Crypto),
+
+    #[error("Communication error: {0}")]
+    CommunicationError(Com),
+}
+
+#[derive(Clone, Debug, Error, PartialEq, Eq)]
+pub enum ReceiveError<Crypto, Com> {
+    #[error("Crypto error: {0}")]
+    CryptoError(Crypto),
+
+    #[error("Communication error: {0}")]
+    CommunicationError(Com),
+}

crates/bitwarden-ipc/src/error.rs

@@ -0,0 +1,142 @@
+use crate::{
+    error::{ReceiveError, SendError},
+    message::{IncomingMessage, OutgoingMessage},
+    traits::{CommunicationBackend, CryptoProvider, SessionRepository},
+};
+
+pub struct IpcClient<Crypto, Com, Ses>
+where
+    Crypto: CryptoProvider<Com, Ses>,
+    Com: CommunicationBackend,
+    Ses: SessionRepository<Session = Crypto::Session>,
+{
+    crypto: Crypto,
+    communication: Com,
+    sessions: Ses,
+}
+
+impl<Crypto, Com, Ses> IpcClient<Crypto, Com, Ses>
+where
+    Crypto: CryptoProvider<Com, Ses>,
+    Com: CommunicationBackend,
+    Ses: SessionRepository<Session = Crypto::Session>,
+{
+    pub fn new(crypto: Crypto, communication: Com, sessions: Ses) -> Self {
+        Self {
+            crypto,
+            communication,
+            sessions,
+        }
+    }
+
+    pub async fn send(
+        &self,
+        message: OutgoingMessage,
+    ) -> Result<(), SendError<Crypto::SendError, Com::SendError>> {
+        self.crypto
+            .send(&self.communication, &self.sessions, message)
+            .await
+    }
+
+    pub async fn receive(
+        &self,
+    ) -> Result<IncomingMessage, ReceiveError<Crypto::ReceiveError, Com::ReceiveError>> {
+        self.crypto
+            .receive(&self.communication, &self.sessions)
+            .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use super::*;
+    use crate::{endpoint::Endpoint, traits::InMemorySessionRepository};
+
+    struct TestCommunicationProvider;
+
+    impl CommunicationBackend for TestCommunicationProvider {
+        type SendError = ();
+        type ReceiveError = ();
+
+        async fn send(&self, _message: OutgoingMessage) -> Result<(), Self::SendError> {
+            todo!()
+        }
+
+        async fn receive(&self) -> Result<IncomingMessage, Self::ReceiveError> {
+            todo!()
+        }
+    }
+
+    struct TestCryptoProvider {
+        send_result: Result<(), SendError<String, ()>>,
+        receive_result: Result<IncomingMessage, ReceiveError<String, ()>>,
+    }
+
+    type TestSessionRepository = InMemorySessionRepository<String>;
+    impl CryptoProvider<TestCommunicationProvider, TestSessionRepository> for TestCryptoProvider {
+        type Session = String;
+        type SendError = String;
+        type ReceiveError = String;
+
+        async fn receive(
+            &self,
+            _communication: &TestCommunicationProvider,
+            _sessions: &TestSessionRepository,
+        ) -> Result<IncomingMessage, ReceiveError<String, ()>> {
+            self.receive_result.clone()
+        }
+
+        async fn send(
+            &self,
+            _communication: &TestCommunicationProvider,
+            _sessions: &TestSessionRepository,
+            _message: OutgoingMessage,
+        ) -> Result<
+            (),
+            SendError<
+                Self::SendError,
+                <TestCommunicationProvider as CommunicationBackend>::SendError,
+            >,
+        > {
+            self.send_result.clone()
+        }
+    }
+
+    #[tokio::test]
+    async fn returns_send_error_when_crypto_provider_returns_error() {
+        let message = OutgoingMessage {
+            data: vec![],
+            destination: Endpoint::BrowserBackground,
+        };
+        let crypto_provider = TestCryptoProvider {
+            send_result: Err(SendError::CryptoError("Crypto error".to_string())),
+            receive_result: Err(ReceiveError::CryptoError(
+                "Should not have be called".to_string(),
+            )),
+        };
+        let communication_provider = TestCommunicationProvider;
+        let session_map = TestSessionRepository::new(HashMap::new());
+        let client = IpcClient::new(crypto_provider, communication_provider, session_map);
+
+        let error = client.send(message).await.unwrap_err();
+
+        assert_eq!(error, SendError::CryptoError("Crypto error".to_string()));
+    }
+
+    #[tokio::test]
+    async fn returns_receive_error_when_crypto_provider_returns_error() {
+        let crypto_provider = TestCryptoProvider {
+            send_result: Ok(()),
+            receive_result: Err(ReceiveError::CryptoError("Crypto error".to_string())),
+        };
+        let communication_provider = TestCommunicationProvider;
+        let session_map = TestSessionRepository::new(HashMap::new());
+        let client = IpcClient::new(crypto_provider, communication_provider, session_map);
+
+        let error = client.receive().await.unwrap_err();
+
+        assert_eq!(error, ReceiveError::CryptoError("Crypto error".to_string()));
+    }
+}

crates/bitwarden-ipc/src/ipc_client.rs

@@ -0,0 +1,11 @@
+mod endpoint;
+mod error;
+mod ipc_client;
+mod message;
+mod traits;
+
+// Re-export types to make sure wasm_bindgen picks them up
+#[cfg(feature = "wasm")]
+pub mod wasm;
+
+pub use ipc_client::IpcClient;

crates/bitwarden-ipc/src/lib.rs

@@ -0,0 +1,20 @@
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "wasm")]
+use {tsify_next::Tsify, wasm_bindgen::prelude::*};
+
+use crate::endpoint::Endpoint;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
+pub struct OutgoingMessage {
+    pub data: Vec<u8>,
+    pub destination: Endpoint,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
+pub struct IncomingMessage {
+    pub data: Vec<u8>,
+    pub destination: Endpoint,
+    pub source: Endpoint,
+}

crates/bitwarden-ipc/src/message.rs

@@ -0,0 +1,23 @@
+use crate::message::{IncomingMessage, OutgoingMessage};
+
+/// This trait defines the interface that will be used to send and receive messages over IPC.
+/// It is up to the platform to implement this trait and any necessary thread synchronization and
+/// broadcasting.
+pub trait CommunicationBackend {
+    type SendError;
+    type ReceiveError;
+
+    /// Send a message to the destination specified in the message. This function may be called
+    /// from any thread at any time. The implementation will handle any necessary synchronization.
+    fn send(
+        &self,
+        message: OutgoingMessage,
+    ) -> impl std::future::Future<Output = Result<(), Self::SendError>>;
+
+    /// Receive a message. This function will block asynchronously until a message is received.
+    /// Multiple calls to this function may be made from different threads, in which case all
+    /// threads will receive the same message.
+    fn receive(
+        &self,
+    ) -> impl std::future::Future<Output = Result<IncomingMessage, Self::ReceiveError>>;
+}

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

@@ -0,0 +1,64 @@
+use super::{CommunicationBackend, SessionRepository};
+use crate::{
+    error::{ReceiveError, SendError},
+    message::{IncomingMessage, OutgoingMessage},
+};
+
+pub trait CryptoProvider<Com, Ses>
+where
+    Com: CommunicationBackend,
+    Ses: SessionRepository<Session = Self::Session>,
+{
+    type Session;
+    type SendError;
+    type ReceiveError;
+
+    fn send(
+        &self,
+        communication: &Com,
+        sessions: &Ses,
+        message: OutgoingMessage,
+    ) -> impl std::future::Future<Output = Result<(), SendError<Self::SendError, Com::SendError>>>;
+    fn receive(
+        &self,
+        communication: &Com,
+        sessions: &Ses,
+    ) -> impl std::future::Future<
+        Output = Result<IncomingMessage, ReceiveError<Self::ReceiveError, Com::ReceiveError>>,
+    >;
+}
+
+pub struct NoEncryptionCryptoProvider;
+
+impl<Com, Ses> CryptoProvider<Com, Ses> for NoEncryptionCryptoProvider
+where
+    Com: CommunicationBackend,
+    Ses: SessionRepository<Session = ()>,
+{
+    type Session = ();
+    type SendError = Com::SendError;
+    type ReceiveError = Com::ReceiveError;
+
+    async fn send(
+        &self,
+        communication: &Com,
+        _sessions: &Ses,
+        message: OutgoingMessage,
+    ) -> Result<(), SendError<Self::SendError, Com::SendError>> {
+        communication
+            .send(message)
+            .await
+            .map_err(SendError::CommunicationError)
+    }
+
+    async fn receive(
+        &self,
+        communication: &Com,
+        _sessions: &Ses,
+    ) -> Result<IncomingMessage, ReceiveError<Self::ReceiveError, Com::ReceiveError>> {
+        communication
+            .receive()
+            .await
+            .map_err(ReceiveError::CommunicationError)
+    }
+}