shorter names, more typestate

Author: cowlicks

src/sstream.rs

@@ -48,12 +48,9 @@ impl<Step> SecStream<Step> {
     }
 }
 
-/// Initial initiator state
+/// Initiator
 #[derive(Debug)]
-pub struct InitiatorInitial;
-/// Initiator has sent the first message
-#[derive(Debug)]
-pub struct InitiatorInitialSent<Step> {
+pub struct Initiator<Step> {
     _res_step: PhantomData<Step>,
 }
 
@@ -63,11 +60,17 @@ pub struct InitiatorInitialSent<Step> {
 /// emitting the next message. This distinction is necessary so we can handle the received payload
 /// and send a new one
 #[derive(Debug)]
-pub struct Responder<RespStep> {
-    _res_step: PhantomData<RespStep>,
+pub struct Responder<Step> {
+    _res_step: PhantomData<Step>,
 }
-struct One;
-struct Two;
+/// The first step. We must send or receive a handshake message to proceed.
+struct Start;
+/// The handshake message has been sent. We must receive a handshake message to proceed to
+/// [`HsDone`]. Only on [`Initiator`].
+struct HsMsgSent;
+/// [`snow::HandshakeState::is_handshake_finished`] is `true`.
+/// We are ready create a [`PushStream`] and proeed to [`EncryptorReady`].
+struct HsDone;
 
 /// No decryptor yet
 pub struct EncryptorReady {
@@ -99,7 +102,7 @@ impl Debug for Ready {
     }
 }
 
-impl SecStream<InitiatorInitial> {
+impl SecStream<Initiator<Start>> {
     /// Create an initiator of a secret stream
     pub fn new_initiator(config: InitiatorConfig) -> Result<Self, Error> {
         let params: NoiseParams = PARAMS.parse().expect("known to work");
@@ -113,15 +116,17 @@ impl SecStream<InitiatorInitial> {
             is_initiator: true,
             state,
             msg_buf: [0; 1024],
-            step: InitiatorInitial,
+            step: Initiator {
+                _res_step: PhantomData,
+            },
         })
     }
 
     /// Create the first message the initiator sends to the responder
-    pub fn make_first_msg(
+    pub fn write_msg(
         mut self,
         prologue: &[u8],
-    ) -> Result<(SecStream<InitiatorInitialSent<One>>, Vec<u8>), Error> {
+    ) -> Result<(SecStream<Initiator<HsMsgSent>>, Vec<u8>), Error> {
         let len = self.state.write_message(prologue, &mut self.msg_buf)?;
         let msg = self.msg_buf[..len].to_vec();
         let Self {
@@ -135,7 +140,7 @@ impl SecStream<InitiatorInitial> {
                 is_initiator,
                 state,
                 msg_buf,
-                step: InitiatorInitialSent {
+                step: Initiator {
                     _res_step: PhantomData,
                 },
             },
@@ -144,7 +149,7 @@ impl SecStream<InitiatorInitial> {
     }
 }
 
-impl SecStream<Responder<One>> {
+impl SecStream<Responder<Start>> {
     /// Create a responder of a secret stream
     pub fn new_responder(private: &[u8]) -> Result<Self, Error> {
         let params: NoiseParams = PARAMS.parse().expect("known to work");
@@ -162,10 +167,10 @@ impl SecStream<Responder<One>> {
     }
 
     /// Read msg and return it's payload
-    pub fn read_first_msg_get_payload(
+    pub fn read_msg(
         mut self,
         msg: &[u8],
-    ) -> Result<(SecStream<Responder<Two>>, Vec<u8>), Error> {
+    ) -> Result<(SecStream<Responder<HsDone>>, Vec<u8>), Error> {
         let len = self.state.read_message(msg, &mut self.msg_buf)?;
         let payload = &self.msg_buf[..len];
         let Self {
@@ -187,19 +192,19 @@ impl SecStream<Responder<One>> {
         ))
     }
     /// Read the first message of the protocol, create the next two messages to send to the initiator.
-    pub fn read_first_msg(
+    pub fn read_and_write_msg(
         self,
         msg: &[u8],
     ) -> Result<(SecStream<EncryptorReady>, [Vec<u8>; 2]), Error> {
-        let (self2, _rx_payload) = self.read_first_msg_get_payload(msg)?;
-        self2.make_second_msg(&[])
+        let (self2, _rx_payload) = self.read_msg(msg)?;
+        self2.write_msg(&[])
     }
 }
 
-impl SecStream<Responder<Two>> {
+impl SecStream<Responder<HsDone>> {
     /// Make second message with the given payload. Returns two messages, the first completes the
     /// Noise handshake. The second has the shared key for the remote to set up a Decryptor.
-    pub fn make_second_msg(
+    pub fn write_msg(
         mut self,
         payload: &[u8],
     ) -> Result<(SecStream<EncryptorReady>, [Vec<u8>; 2]), Error> {
@@ -244,12 +249,12 @@ impl SecStream<Responder<Two>> {
     }
 }
 
-impl SecStream<InitiatorInitialSent<One>> {
+impl SecStream<Initiator<HsMsgSent>> {
     /// Recieve the last message to complet the handsake
-    pub fn read_first_msg_get_payload(
+    pub fn read_msg(
         mut self,
         msg: &[u8],
-    ) -> Result<(SecStream<InitiatorInitialSent<Two>>, Vec<u8>), Error> {
+    ) -> Result<(SecStream<Initiator<HsDone>>, Vec<u8>), Error> {
         let len = self.state.read_message(msg, &mut self.msg_buf)?;
         let payload = &self.msg_buf[..len];
         let Self {
@@ -263,25 +268,27 @@ impl SecStream<InitiatorInitialSent<One>> {
                 is_initiator,
                 state,
                 msg_buf,
-                step: InitiatorInitialSent {
+                step: Initiator {
                     _res_step: PhantomData,
                 },
             },
             payload.to_vec(),
         ))
     }
 
-    pub fn receive_msg(
-        mut self,
+    /// read in a message, and write the next message. Any payload in the recieved message is
+    /// dropped.
+    pub fn read_and_write_msg(
+        self,
         msg: &[u8],
     ) -> Result<(SecStream<EncryptorReady>, Vec<u8>), Error> {
-        let (mut self2, _payload) = self.read_first_msg_get_payload(msg)?;
-        self2.make_msg()
+        let (self2, _payload) = self.read_msg(msg)?;
+        self2.write_msg()
     }
 }
 
-impl SecStream<InitiatorInitialSent<Two>> {
-    fn make_msg(mut self) -> Result<(SecStream<EncryptorReady>, Vec<u8>), Error> {
+impl SecStream<Initiator<HsDone>> {
+    fn write_msg(mut self) -> Result<(SecStream<EncryptorReady>, Vec<u8>), Error> {
         let (tx, rx) = self.split_handshake();
         let key: [u8; SNOW_CIPHERKEYLEN] = tx[..SNOW_CIPHERKEYLEN]
             .try_into()
@@ -324,7 +331,7 @@ impl SecStream<InitiatorInitialSent<Two>> {
 
 impl SecStream<EncryptorReady> {
     /// Recieve message the last message, used to set up the decryption stream
-    pub fn receive_msg(self, msg: &[u8]) -> Result<SecStream<Ready>, Error> {
+    pub fn read_msg(self, msg: &[u8]) -> Result<SecStream<Ready>, Error> {
         let Self {
             is_initiator,
             step:
@@ -377,31 +384,36 @@ mod test {
 
     #[tokio::test]
     async fn set_up_secret_steram() -> std::result::Result<(), Box<dyn std::error::Error>> {
-        /// Excessive typing to demonstrate flow through typestates
+        // Excessive typing to demonstrate flow through typestates
         let params: NoiseParams = PARAMS.parse().expect("known to work");
         let kp = Builder::new(params.clone()).generate_keypair()?;
         let config = InitiatorConfig::new(kp.public.try_into().unwrap());
-        let init: SecStream<InitiatorInitial> = SecStream::new_initiator(config)?;
-        let resp: SecStream<Responder<One>> = SecStream::new_responder(&kp.private)?;
+        // Create an initiator and responder
+        let init: SecStream<Initiator<Start>> = SecStream::new_initiator(config)?;
+        let resp: SecStream<Responder<Start>> = SecStream::new_responder(&kp.private)?;
 
-        let (init, msg): (SecStream<InitiatorInitialSent<One>>, Vec<u8>) =
-            init.make_first_msg(b"hello")?;
+        // initiator sends the first handshake message, a payload can be included to send extra data to the
+        // responder.
+        let (init, msg): (SecStream<Initiator<HsMsgSent>>, Vec<u8>) = init.write_msg(b"hello")?;
 
-        let (resp, payload): (SecStream<Responder<Two>>, Vec<u8>) =
-            resp.read_first_msg_get_payload(&msg)?;
+        // responder receives the hs message, extracts the payload
+        let (resp, payload): (SecStream<Responder<HsDone>>, Vec<u8>) = resp.read_msg(&msg)?;
         assert_eq!(payload, b"hello");
 
-        let payload2 = b"goodbye";
+        // responder sends a handshake message, which can include a payload. As well as a second
+        // message which contains the symmetric key needed to set up the decryptor
         let (resp, [msg1, msg2]): (SecStream<EncryptorReady>, [Vec<u8>; 2]) =
-            resp.make_second_msg(payload2)?;
+            resp.write_msg(b"goodbye")?;
 
-        let (init, payload_recv) = init.read_first_msg_get_payload(&msg1)?;
+        // Initiator receives last handshake message, use handshake to create the extract payload.
+        let (init, payload_recv): (SecStream<Initiator<HsDone>>, Vec<u8>) = init.read_msg(&msg1)?;
         assert_eq!(payload_recv, b"goodbye");
 
-        let (init, to_resp): (SecStream<EncryptorReady>, Vec<u8>) = init.make_msg()?;
+        // receive decryptor keey
+        let (init, to_resp): (SecStream<EncryptorReady>, Vec<u8>) = init.write_msg()?;
 
-        let mut init: SecStream<Ready> = init.receive_msg(&msg2)?;
-        let mut resp: SecStream<Ready> = resp.receive_msg(&to_resp)?;
+        let mut init: SecStream<Ready> = init.read_msg(&msg2)?;
+        let mut resp: SecStream<Ready> = resp.read_msg(&to_resp)?;
 
         let hello = b"hello".to_vec();
         let mut msg = hello.clone();

tests/js/mod.rs

@@ -30,9 +30,9 @@ pub fn cleanup() {
 }
 
 pub fn install() {
-    let status = Command::new("npm")
+    let status = Command::new("cp")
         .current_dir("tests/js")
-        .args(["install"])
+        .args(["-r", "node_modules_for_tests", "node_modules"])
         .status()
         .expect("Unable to run npm install");
     assert_eq!(