Create fallback test

src/handshake-xx-fallback.ts

@@ -39,17 +39,16 @@ export class Handshake extends XXHandshake {
   // stage 0
   public async propose(): Promise<void> {
     if (this.isInitiator) {
-      logger("XX Fallback Stage 0 - Initiator starting to send first message.");
-      const messageBuffer = this.xx.sendMessage(this.session, Buffer.alloc(0), this.ephemeralKeys);
-      this.connection.writeLP(encodeMessageBuffer(messageBuffer));
-      logger("XX Fallback Stage 0 - Initiator finished sending first message.");
+      this.xx.sendMessage(this.session, Buffer.alloc(0), this.ephemeralKeys);
+      logger("XX Fallback Stage 0 - Initialized state as the first message was sent by initiator.");
     } else {
       logger("XX Fallback Stage 0 - Responder waiting to receive first message...");
-      const receivedMessageBuffer = this.xx.decode0(this.initialMsg);
+      const receivedMessageBuffer = decodeMessageBuffer(this.initialMsg);
+      console.log("receivedMessageBuffer: ", receivedMessageBuffer)
       this.xx.recvMessage(this.session, {
         ne: receivedMessageBuffer.ne,
-        ns: Buffer.alloc(0),
-        ciphertext: Buffer.alloc(0),
+        ns: Buffer.alloc(32),
+        ciphertext: Buffer.alloc(32),
       });
       logger("XX Fallback Stage 0 - Responder received first message.");
     }
@@ -59,7 +58,7 @@ export class Handshake extends XXHandshake {
   public async exchange(): Promise<void> {
     if (this.isInitiator) {
       logger('XX Fallback Stage 1 - Initiator waiting to receive first message from responder...');
-      const receivedMessageBuffer = this.xx.decode1(this.initialMsg);
+      const receivedMessageBuffer = decodeMessageBuffer(this.initialMsg);
       const plaintext = this.xx.recvMessage(this.session, receivedMessageBuffer);
       logger('XX Fallback Stage 1 - Initiator received the message. Got remote\'s static key.');
 

src/handshake-xx.ts

@@ -22,12 +22,12 @@ export class Handshake implements HandshakeInterface {
 
   protected connection: WrappedConnection;
   protected xx: XX;
-
   protected libp2pPrivateKey: bytes;
   protected libp2pPublicKey: bytes;
-  private prologue: bytes32;
   protected staticKeys: KeyPair;
-  private remotePeer: PeerId;
+  protected remotePeer: PeerId;
+
+  private prologue: bytes32;
 
   constructor(
     isInitiator: boolean,

test/xx-fallback-handshake.test.ts

@@ -0,0 +1,83 @@
+import Wrap from "it-pb-rpc";
+import {Buffer} from "buffer";
+import Duplex from 'it-pair/duplex';
+
+import {
+  createHandshakePayload,
+  generateKeypair,
+  getHandshakePayload,
+  signEarlyDataPayload,
+  signPayload
+} from "../src/utils";
+import {generateEd25519Keys, getKeyPairFromPeerId} from "./utils";
+import {Handshake} from "../src/handshake-xx-fallback";
+import {createPeerIdsFromFixtures} from "./fixtures/peer";
+import {assert} from "chai";
+import {encodeMessageBuffer} from "../src/encoder";
+
+describe("XX Fallback Handshake", () => {
+  let peerA, peerB, fakePeer;
+
+  before(async () => {
+    [peerA, peerB] = await createPeerIdsFromFixtures(2);
+  });
+
+  it("should make handshake with received ephemeral key (from initial IK message)", async () => {
+    try {
+      const duplex = Duplex();
+      const connectionFrom = Wrap(duplex[0]);
+      const connectionTo = Wrap(duplex[1]);
+
+      const prologue = Buffer.from('/noise');
+      const staticKeysInitiator = generateKeypair();
+      const staticKeysResponder = generateKeypair();
+
+      const {privateKey: initiatorPrivKey, publicKey: initiatorPubKey} = getKeyPairFromPeerId(peerA);
+      const {privateKey: responderPrivKey, publicKey: responderPubKey} = getKeyPairFromPeerId(peerB);
+
+      const signedPayload = signPayload(initiatorPrivKey, getHandshakePayload(staticKeysInitiator.publicKey));
+      const signedEarlyDataPayload = signEarlyDataPayload(initiatorPrivKey, Buffer.alloc(0));
+      const handshakePayload = await createHandshakePayload(
+        initiatorPubKey,
+        initiatorPrivKey,
+        signedPayload,
+        signedEarlyDataPayload,
+      );
+      const initialMsg = encodeMessageBuffer({
+        ne: staticKeysInitiator.publicKey,
+        ns: Buffer.alloc(32),
+        ciphertext: handshakePayload,
+      });
+
+      const handshakeInit =
+        new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB, staticKeysInitiator, initialMsg);
+
+      const handshakeResp =
+        new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA, staticKeysInitiator, initialMsg);
+
+
+      await handshakeInit.propose();
+      await handshakeResp.propose();
+
+      await handshakeResp.exchange();
+      await handshakeInit.exchange();
+
+      await handshakeInit.finish();
+      await handshakeResp.finish();
+
+      const sessionInitator = handshakeInit.session;
+      const sessionResponder = handshakeResp.session;
+
+      // Test shared key
+      if (sessionInitator.cs1 && sessionResponder.cs1 && sessionInitator.cs2 && sessionResponder.cs2) {
+        assert(sessionInitator.cs1.k.equals(sessionResponder.cs1.k));
+        assert(sessionInitator.cs2.k.equals(sessionResponder.cs2.k));
+      } else {
+        assert(false);
+      }
+    } catch (e) {
+      console.error(e);
+      assert(false, e.message);
+    }
+  });
+})

test/xx-handshake.test.ts

@@ -9,7 +9,7 @@ import {createPeerIdsFromFixtures} from "./fixtures/peer";
 import {getKeyPairFromPeerId} from "./utils";
 
 
-describe("Handshake", () => {
+describe("XX Handshake", () => {
   let peerA, peerB, fakePeer;
 
   before(async () => {