ss over ws

pop-mpc-aio/examples/secret_share.rs

@@ -0,0 +1,68 @@
+use p256::elliptic_curve::sec1::ToEncodedPoint;
+use p256::{EncodedPoint, SecretKey};
+use pop_mpc_aio::secret_share::{AsyncSecretShareMaster, AsyncSecretShareSlave};
+use pop_mpc_core::secret_share::{SecretShare, P};
+use rand::thread_rng;
+use std::time::Instant;
+use tokio;
+use tokio::net::UnixStream;
+
+async fn master(stream: UnixStream, point: EncodedPoint) -> SecretShare {
+    println!("Master: Trying to connect");
+
+    let mut ws_stream = tokio_tungstenite::accept_async(stream)
+        .await
+        .expect("Master: Error during the websocket handshake occurred");
+
+    let mut master = AsyncSecretShareMaster::new();
+
+    println!("Master: Websocket connected");
+
+    let share = master.run(&mut ws_stream, &point).await.unwrap();
+
+    println!("Master: {:?}", share);
+
+    share
+}
+
+async fn slave(stream: UnixStream, point: EncodedPoint) -> SecretShare {
+    println!("Slave: Trying to connect");
+
+    let (mut ws_stream, _) = tokio_tungstenite::client_async("ws://local/ss", stream)
+        .await
+        .expect("Slave: Error during the websocket handshake occurred");
+
+    println!("Slave: Websocket connected");
+
+    let mut slave = AsyncSecretShareSlave::new();
+
+    let share = slave.run(&mut ws_stream, &point).await.unwrap();
+
+    println!("Slave: {:?}", share);
+
+    share
+}
+
+#[tokio::main]
+async fn main() {
+    let (unix_s, unix_r) = UnixStream::pair().unwrap();
+
+    let master_point = SecretKey::random(&mut thread_rng())
+        .public_key()
+        .to_projective()
+        .to_encoded_point(false);
+    let slave_point = SecretKey::random(&mut thread_rng())
+        .public_key()
+        .to_projective()
+        .to_encoded_point(false);
+
+    let master = master(unix_s, master_point);
+    let slave = slave(unix_r, slave_point);
+
+    let t = Instant::now();
+    let _ = tokio::join!(
+        tokio::spawn(async move { master.await }),
+        tokio::spawn(async move { slave.await })
+    );
+    println!("Took {:?}", t.elapsed());
+}

pop-mpc-aio/src/secret_share/mod.rs

@@ -1,5 +1,8 @@
+use futures_util::{SinkExt, StreamExt};
 use p256::EncodedPoint;
-use pop_mpc_core::secret_share::{SecretShare, SecretShareMaster};
+use pop_mpc_core::proto;
+use pop_mpc_core::secret_share::{SecretShare, SecretShareMaster, SecretShareSlave};
+use prost::Message as ProtoMessage;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_tungstenite::{tungstenite::protocol::Message, WebSocketStream};
 
@@ -12,12 +15,129 @@ impl AsyncSecretShareMaster {
 
     pub async fn run<S: AsyncWrite + AsyncRead + Unpin>(
         &mut self,
-        point: &EncodedPoint,
         stream: &mut WebSocketStream<S>,
+        point: &EncodedPoint,
     ) -> Result<SecretShare, ()> {
         let master = SecretShareMaster::new(&point);
-        let (message, master) = master.next();
 
-        todo!()
+        // Step 1
+        let (message, master) = master.next();
+        stream
+            .send(Message::Binary(
+                proto::secret_share::MasterStepOne::from(message).encode_to_vec(),
+            ))
+            .await
+            .unwrap();
+        let slave_message = match stream.next().await {
+            Some(message) => {
+                proto::secret_share::SlaveStepOne::decode(message.unwrap().into_data().as_slice())
+                    .expect("Expected SlaveStepOne")
+            }
+            _ => return Err(()),
+        };
+
+        // Step 2
+        let (message, master) = master.next(slave_message.into());
+        stream
+            .send(Message::Binary(
+                proto::secret_share::MasterStepTwo::from(message).encode_to_vec(),
+            ))
+            .await
+            .unwrap();
+        let slave_message = match stream.next().await {
+            Some(message) => {
+                proto::secret_share::SlaveStepTwo::decode(message.unwrap().into_data().as_slice())
+                    .expect("Expected SlaveStepTwo")
+            }
+            _ => return Err(()),
+        };
+
+        // Step 3
+        let (message, master) = master.next(slave_message.into());
+        stream
+            .send(Message::Binary(
+                proto::secret_share::MasterStepThree::from(message).encode_to_vec(),
+            ))
+            .await
+            .unwrap();
+        let slave_message = match stream.next().await {
+            Some(message) => {
+                proto::secret_share::SlaveStepThree::decode(message.unwrap().into_data().as_slice())
+                    .expect("Expected SlaveStepThree")
+            }
+            _ => return Err(()),
+        };
+
+        // Complete
+        let master = master.next(slave_message.into());
+
+        Ok(master.secret())
+    }
+}
+
+pub struct AsyncSecretShareSlave;
+
+impl AsyncSecretShareSlave {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub async fn run<S: AsyncWrite + AsyncRead + Unpin>(
+        &mut self,
+        stream: &mut WebSocketStream<S>,
+        point: &EncodedPoint,
+    ) -> Result<SecretShare, ()> {
+        let slave = SecretShareSlave::new(&point);
+
+        // Step 1
+        let master_message = match stream.next().await {
+            Some(message) => {
+                proto::secret_share::MasterStepOne::decode(message.unwrap().into_data().as_slice())
+                    .expect("Expected MasterStepOne")
+            }
+            _ => return Err(()),
+        };
+        let (message, slave) = slave.next(master_message.into());
+        stream
+            .send(Message::Binary(
+                proto::secret_share::SlaveStepOne::from(message).encode_to_vec(),
+            ))
+            .await
+            .unwrap();
+
+        // Step 2
+        let master_message = match stream.next().await {
+            Some(message) => {
+                proto::secret_share::MasterStepTwo::decode(message.unwrap().into_data().as_slice())
+                    .expect("Expected MasterStepTwo")
+            }
+            _ => return Err(()),
+        };
+        let (message, slave) = slave.next(master_message.into());
+        stream
+            .send(Message::Binary(
+                proto::secret_share::SlaveStepTwo::from(message).encode_to_vec(),
+            ))
+            .await
+            .unwrap();
+
+        // Complete
+        let master_message = match stream.next().await {
+            Some(message) => proto::secret_share::MasterStepThree::decode(
+                message.unwrap().into_data().as_slice(),
+            )
+            .expect("Expected MasterStepThree"),
+            _ => return Err(()),
+        };
+
+        let (message, slave) = slave.next(master_message.into());
+        stream
+            .send(Message::Binary(
+                proto::secret_share::SlaveStepThree::from(message).encode_to_vec(),
+            ))
+            .await
+            .unwrap();
+
+        Ok(slave.secret())
     }
 }

pop-mpc-core/src/proto/core/secret_share.rs

@@ -1,4 +1,3 @@
-use super::super::errors::ProtoError;
 use crate::secret_share::{master, slave};
 use curv::{arithmetic::Converter, BigInt};
 

pop-mpc-core/src/secret_share/mod.rs

@@ -6,7 +6,7 @@ pub use master::SecretShareMaster;
 pub use slave::SecretShareSlave;
 
 /// NIST P-256 Prime
-const P: &str = "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff";
+pub const P: &str = "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff";
 
 pub type SecretShare = BigInt;