From fc818c746cbadcf41347b0cb1cdadf949703b650 Mon Sep 17 00:00:00 2001 From: Belma Gutlic Date: Tue, 7 Jan 2020 10:16:57 +0100 Subject: [PATCH] Create fallback test --- src/handshake-xx-fallback.ts | 15 ++-- src/handshake-xx.ts | 6 +- test/xx-fallback-handshake.test.ts | 83 +++++++++++++++++++ ...handshake.test.ts => xx-handshake.test.ts} | 2 +- 4 files changed, 94 insertions(+), 12 deletions(-) create mode 100644 test/xx-fallback-handshake.test.ts rename test/{handshake.test.ts => xx-handshake.test.ts} (99%) diff --git a/src/handshake-xx-fallback.ts b/src/handshake-xx-fallback.ts index 1666785..594f6e4 100644 --- a/src/handshake-xx-fallback.ts +++ b/src/handshake-xx-fallback.ts @@ -39,17 +39,16 @@ export class Handshake extends XXHandshake { // stage 0 public async propose(): Promise { 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 { 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.'); diff --git a/src/handshake-xx.ts b/src/handshake-xx.ts index 4e34c54..61611cc 100644 --- a/src/handshake-xx.ts +++ b/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, diff --git a/test/xx-fallback-handshake.test.ts b/test/xx-fallback-handshake.test.ts new file mode 100644 index 0000000..9eb7b70 --- /dev/null +++ b/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); + } + }); +}) diff --git a/test/handshake.test.ts b/test/xx-handshake.test.ts similarity index 99% rename from test/handshake.test.ts rename to test/xx-handshake.test.ts index 1ed6fa7..e1f2cb2 100644 --- a/test/handshake.test.ts +++ b/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 () => {