fluencelabs/js-libp2p-noise
1
0
Fork 0
mirror of https://github.com/fluencelabs/js-libp2p-noise synced 2025-04-25 14:12:30 +00:00
Code Issues Projects Releases Wiki Activity

Address PR comments

Browse Source
This commit is contained in:
Belma Gutlic 2020-01-07 13:34:45 +01:00
parent 28bf51c492
commit c3ab986d3d
10 changed files with 51 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.eslintrc
View File

@ -15,6 +15,7 @@
"@typescript-eslint/indent": ["error", 2], "@typescript-eslint/indent": ["error", 2],
"@typescript-eslint/no-use-before-define": "off", "@typescript-eslint/no-use-before-define": "off",
"@typescript-eslint/no-explicit-any": "off", "@typescript-eslint/no-explicit-any": "off",
"@typescript-eslint/interface-name-prefix": "off",
"no-console": "warn" "no-console": "warn"
} }
} }

2
src/@types/handshake-interface.ts
View File

@ -1,7 +1,7 @@
import {bytes} from "./basic"; import {bytes} from "./basic";
import {NoiseSession} from "./handshake"; import {NoiseSession} from "./handshake";
export interface HandshakeInterface { export interface IHandshake {
session: NoiseSession; session: NoiseSession;
encrypt(plaintext: bytes, session: NoiseSession): bytes; encrypt(plaintext: bytes, session: NoiseSession): bytes;
decrypt(ciphertext: bytes, session: NoiseSession): bytes; decrypt(ciphertext: bytes, session: NoiseSession): bytes;

6
src/crypto.ts
View File

@ -1,5 +1,5 @@
import { Buffer } from "buffer"; import { Buffer } from "buffer";
import {HandshakeInterface} from "./@types/handshake-interface"; import {IHandshake} from "./@types/handshake-interface";
interface ReturnEncryptionWrapper { interface ReturnEncryptionWrapper {
(source: Iterable<Uint8Array>): AsyncIterableIterator<Uint8Array>; (source: Iterable<Uint8Array>): AsyncIterableIterator<Uint8Array>;
@ -8,7 +8,7 @@ interface ReturnEncryptionWrapper {
const maxPlaintextLength = 65519; const maxPlaintextLength = 65519;
// Returns generator that encrypts payload from the user // Returns generator that encrypts payload from the user
export function encryptStream(handshake: HandshakeInterface): ReturnEncryptionWrapper { export function encryptStream(handshake: IHandshake): ReturnEncryptionWrapper {
return async function * (source) { return async function * (source) {
for await (const chunk of source) { for await (const chunk of source) {
const chunkBuffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.length); const chunkBuffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.length);
@ -28,7 +28,7 @@ export function encryptStream(handshake: HandshakeInterface): ReturnEncryptionWr
// Decrypt received payload to the user // Decrypt received payload to the user
export function decryptStream(handshake: HandshakeInterface): ReturnEncryptionWrapper { export function decryptStream(handshake: IHandshake): ReturnEncryptionWrapper {
return async function * (source) { return async function * (source) {
for await (const chunk of source) { for await (const chunk of source) {
const chunkBuffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.length); const chunkBuffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.length);

14
src/handshake-ik.ts
View File

@ -3,17 +3,17 @@ import {IK} from "./handshakes/ik";
import {NoiseSession} from "./@types/handshake"; import {NoiseSession} from "./@types/handshake";
import {bytes, bytes32} from "./@types/basic"; import {bytes, bytes32} from "./@types/basic";
import {KeyPair, PeerId} from "./@types/libp2p"; import {KeyPair, PeerId} from "./@types/libp2p";
import {HandshakeInterface} from "./@types/handshake-interface"; import {IHandshake} from "./@types/handshake-interface";
import {Buffer} from "buffer"; import {Buffer} from "buffer";
export class Handshake implements HandshakeInterface { export class IKHandshake implements IHandshake {
public isInitiator: boolean; public isInitiator: boolean;
public session: NoiseSession; public session: NoiseSession;
private libp2pPrivateKey: bytes; private libp2pPrivateKey: bytes;
private libp2pPublicKey: bytes; private libp2pPublicKey: bytes;
private prologue: bytes32; private prologue: bytes32;
private staticKeys: KeyPair; private staticKeypair: KeyPair;
private connection: WrappedConnection; private connection: WrappedConnection;
private remotePeer: PeerId; private remotePeer: PeerId;
private ik: IK; private ik: IK;
@ -23,7 +23,7 @@ export class Handshake implements HandshakeInterface {
libp2pPrivateKey: bytes, libp2pPrivateKey: bytes,
libp2pPublicKey: bytes, libp2pPublicKey: bytes,
prologue: bytes32, prologue: bytes32,
staticKeys: KeyPair, staticKeypair: KeyPair,
connection: WrappedConnection, connection: WrappedConnection,
remotePeer: PeerId, remotePeer: PeerId,
handshake?: IK, handshake?: IK,
@ -32,7 +32,7 @@ export class Handshake implements HandshakeInterface {
this.libp2pPrivateKey = libp2pPrivateKey; this.libp2pPrivateKey = libp2pPrivateKey;
this.libp2pPublicKey = libp2pPublicKey; this.libp2pPublicKey = libp2pPublicKey;
this.prologue = prologue; this.prologue = prologue;
this.staticKeys = staticKeys; this.staticKeypair = staticKeypair;
this.connection = connection; this.connection = connection;
this.remotePeer = remotePeer; this.remotePeer = remotePeer;
@ -40,8 +40,8 @@ export class Handshake implements HandshakeInterface {
// Dummy data // Dummy data
// TODO: Load remote static keys if found // TODO: Load remote static keys if found
const remoteStaticKeys = this.staticKeys; const remoteStaticKeys = this.staticKeypair;
this.session = this.ik.initSession(this.isInitiator, this.prologue, this.staticKeys, remoteStaticKeys.publicKey); this.session = this.ik.initSession(this.isInitiator, this.prologue, this.staticKeypair, remoteStaticKeys.publicKey);
} }
public decrypt(ciphertext: Buffer, session: NoiseSession): Buffer { public decrypt(ciphertext: Buffer, session: NoiseSession): Buffer {

12
src/handshake-xx-fallback.ts
View File

@ -1,6 +1,6 @@
import { Buffer } from "buffer"; import { Buffer } from "buffer";
import { Handshake as XXHandshake } from "./handshake-xx"; import { XXHandshake } from "./handshake-xx";
import { XX } from "./handshakes/xx"; import { XX } from "./handshakes/xx";
import { KeyPair, PeerId } from "./@types/libp2p"; import { KeyPair, PeerId } from "./@types/libp2p";
import { bytes, bytes32 } from "./@types/basic"; import { bytes, bytes32 } from "./@types/basic";
@ -15,7 +15,7 @@ import { logger } from "./logger";
import { WrappedConnection } from "./noise"; import { WrappedConnection } from "./noise";
import {decode0, decode1, encode1} from "./encoder"; import {decode0, decode1, encode1} from "./encoder";
export class Handshake extends XXHandshake { export class XXFallbackHandshake extends XXHandshake {
private ephemeralKeys?: KeyPair; private ephemeralKeys?: KeyPair;
private initialMsg: bytes; private initialMsg: bytes;
@ -24,14 +24,14 @@ export class Handshake extends XXHandshake {
libp2pPrivateKey: bytes, libp2pPrivateKey: bytes,
libp2pPublicKey: bytes, libp2pPublicKey: bytes,
prologue: bytes32, prologue: bytes32,
staticKeys: KeyPair, staticKeypair: KeyPair,
connection: WrappedConnection, connection: WrappedConnection,
remotePeer: PeerId, remotePeer: PeerId,
initialMsg: bytes, initialMsg: bytes,
ephemeralKeys?: KeyPair, ephemeralKeys?: KeyPair,
handshake?: XX, handshake?: XX,
) { ) {
super(isInitiator, libp2pPrivateKey, libp2pPublicKey, prologue, staticKeys, connection, remotePeer, handshake); super(isInitiator, libp2pPrivateKey, libp2pPublicKey, prologue, staticKeypair, connection, remotePeer, handshake);
if (ephemeralKeys) { if (ephemeralKeys) {
this.ephemeralKeys = ephemeralKeys; this.ephemeralKeys = ephemeralKeys;
} }
@ -59,7 +59,7 @@ export class Handshake extends XXHandshake {
public async exchange(): Promise<void> { public async exchange(): Promise<void> {
if (this.isInitiator) { if (this.isInitiator) {
logger('XX Fallback Stage 1 - Initiator waiting to receive first message from responder...'); logger('XX Fallback Stage 1 - Initiator waiting to receive first message from responder...');
const receivedMessageBuffer = decode1((await this.connection.readLP()).slice()); const receivedMessageBuffer = decode1((await this.connection.readLP()));
// const receivedMessageBuffer = decode1(this.initialMsg); // const receivedMessageBuffer = decode1(this.initialMsg);
logger("Initiator receivedMessageBuffer in stage 1", receivedMessageBuffer); logger("Initiator receivedMessageBuffer in stage 1", receivedMessageBuffer);
const plaintext = this.xx.recvMessage(this.session, receivedMessageBuffer); const plaintext = this.xx.recvMessage(this.session, receivedMessageBuffer);
@ -74,7 +74,7 @@ export class Handshake extends XXHandshake {
logger("All good with the signature!"); logger("All good with the signature!");
} else { } else {
logger('XX Fallback Stage 1 - Responder sending out first message with signed payload and static key.'); logger('XX Fallback Stage 1 - Responder sending out first message with signed payload and static key.');
const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeys.publicKey)); const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeypair.publicKey));
const signedEarlyDataPayload = signEarlyDataPayload(this.libp2pPrivateKey, Buffer.alloc(0)); const signedEarlyDataPayload = signEarlyDataPayload(this.libp2pPrivateKey, Buffer.alloc(0));
const handshakePayload = await createHandshakePayload( const handshakePayload = await createHandshakePayload(
this.libp2pPublicKey, this.libp2pPublicKey,

16
src/handshake-xx.ts
View File

@ -4,7 +4,7 @@ import { XX } from "./handshakes/xx";
import { KeyPair, PeerId } from "./@types/libp2p"; import { KeyPair, PeerId } from "./@types/libp2p";
import { bytes, bytes32 } from "./@types/basic"; import { bytes, bytes32 } from "./@types/basic";
import { NoiseSession } from "./@types/handshake"; import { NoiseSession } from "./@types/handshake";
import {HandshakeInterface} from "./@types/handshake-interface"; import {IHandshake} from "./@types/handshake-interface";
import { import {
createHandshakePayload, createHandshakePayload,
getHandshakePayload, getHandshakePayload,
@ -16,7 +16,7 @@ import { logger } from "./logger";
import { decode0, decode1, encode0, encode1 } from "./encoder"; import { decode0, decode1, encode0, encode1 } from "./encoder";
import { WrappedConnection } from "./noise"; import { WrappedConnection } from "./noise";
export class Handshake implements HandshakeInterface { export class XXHandshake implements IHandshake {
public isInitiator: boolean; public isInitiator: boolean;
public session: NoiseSession; public session: NoiseSession;
@ -24,7 +24,7 @@ export class Handshake implements HandshakeInterface {
protected xx: XX; protected xx: XX;
protected libp2pPrivateKey: bytes; protected libp2pPrivateKey: bytes;
protected libp2pPublicKey: bytes; protected libp2pPublicKey: bytes;
protected staticKeys: KeyPair; protected staticKeypair: KeyPair;
protected remotePeer: PeerId; protected remotePeer: PeerId;
private prologue: bytes32; private prologue: bytes32;
@ -34,7 +34,7 @@ export class Handshake implements HandshakeInterface {
libp2pPrivateKey: bytes, libp2pPrivateKey: bytes,
libp2pPublicKey: bytes, libp2pPublicKey: bytes,
prologue: bytes32, prologue: bytes32,
staticKeys: KeyPair, staticKeypair: KeyPair,
connection: WrappedConnection, connection: WrappedConnection,
remotePeer: PeerId, remotePeer: PeerId,
handshake?: XX, handshake?: XX,
@ -43,12 +43,12 @@ export class Handshake implements HandshakeInterface {
this.libp2pPrivateKey = libp2pPrivateKey; this.libp2pPrivateKey = libp2pPrivateKey;
this.libp2pPublicKey = libp2pPublicKey; this.libp2pPublicKey = libp2pPublicKey;
this.prologue = prologue; this.prologue = prologue;
this.staticKeys = staticKeys; this.staticKeypair = staticKeypair;
this.connection = connection; this.connection = connection;
this.remotePeer = remotePeer; this.remotePeer = remotePeer;
this.xx = handshake || new XX(); this.xx = handshake || new XX();
this.session = this.xx.initSession(this.isInitiator, this.prologue, this.staticKeys); this.session = this.xx.initSession(this.isInitiator, this.prologue, this.staticKeypair);
} }
// stage 0 // stage 0
@ -83,7 +83,7 @@ export class Handshake implements HandshakeInterface {
logger("All good with the signature!"); logger("All good with the signature!");
} else { } else {
logger('Stage 1 - Responder sending out first message with signed payload and static key.'); logger('Stage 1 - Responder sending out first message with signed payload and static key.');
const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeys.publicKey)); const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeypair.publicKey));
const signedEarlyDataPayload = signEarlyDataPayload(this.libp2pPrivateKey, Buffer.alloc(0)); const signedEarlyDataPayload = signEarlyDataPayload(this.libp2pPrivateKey, Buffer.alloc(0));
const handshakePayload = await createHandshakePayload( const handshakePayload = await createHandshakePayload(
this.libp2pPublicKey, this.libp2pPublicKey,
@ -102,7 +102,7 @@ export class Handshake implements HandshakeInterface {
public async finish(earlyData?: bytes): Promise<void> { public async finish(earlyData?: bytes): Promise<void> {
if (this.isInitiator) { if (this.isInitiator) {
logger('Stage 2 - Initiator sending third handshake message.'); logger('Stage 2 - Initiator sending third handshake message.');
const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeys.publicKey)); const signedPayload = signPayload(this.libp2pPrivateKey, getHandshakePayload(this.staticKeypair.publicKey));
const signedEarlyDataPayload = signEarlyDataPayload(this.libp2pPrivateKey, earlyData || Buffer.alloc(0)); const signedEarlyDataPayload = signEarlyDataPayload(this.libp2pPrivateKey, earlyData || Buffer.alloc(0));
const handshakePayload = await createHandshakePayload( const handshakePayload = await createHandshakePayload(
this.libp2pPublicKey, this.libp2pPublicKey,

24
src/noise.ts
View File

@ -6,16 +6,16 @@ import ensureBuffer from 'it-buffer';
import pipe from 'it-pipe'; import pipe from 'it-pipe';
import lp from 'it-length-prefixed'; import lp from 'it-length-prefixed';
import { Handshake as XX } from "./handshake-xx"; import { XXHandshake } from "./handshake-xx";
import { Handshake as IK } from "./handshake-ik"; import { IKHandshake } from "./handshake-ik";
import { Handshake as XXFallback } from "./handshake-xx-fallback"; import { XXFallbackHandshake } from "./handshake-xx-fallback";
import { generateKeypair } from "./utils"; import { generateKeypair } from "./utils";
import { uint16BEDecode, uint16BEEncode } from "./encoder"; import { uint16BEDecode, uint16BEEncode } from "./encoder";
import { decryptStream, encryptStream } from "./crypto"; import { decryptStream, encryptStream } from "./crypto";
import { bytes } from "./@types/basic"; import { bytes } from "./@types/basic";
import { NoiseConnection, PeerId, KeyPair, SecureOutbound } from "./@types/libp2p"; import { NoiseConnection, PeerId, KeyPair, SecureOutbound } from "./@types/libp2p";
import { Duplex } from "./@types/it-pair"; import { Duplex } from "./@types/it-pair";
import {HandshakeInterface} from "./@types/handshake-interface"; import {IHandshake} from "./@types/handshake-interface";
export type WrappedConnection = ReturnType<typeof Wrap>; export type WrappedConnection = ReturnType<typeof Wrap>;
@ -105,7 +105,7 @@ export class Noise implements NoiseConnection {
* @param libp2pPublicKey * @param libp2pPublicKey
* @param remotePeer * @param remotePeer
*/ */
private async performHandshake(params: HandshakeParams): Promise<HandshakeInterface> { private async performHandshake(params: HandshakeParams): Promise<IHandshake> {
// TODO: Implement noise pipes // TODO: Implement noise pipes
if (false) { if (false) {
@ -127,10 +127,10 @@ export class Noise implements NoiseConnection {
params: HandshakeParams, params: HandshakeParams,
ephemeralKeys: KeyPair, ephemeralKeys: KeyPair,
initialMsg: bytes, initialMsg: bytes,
): Promise<XXFallback> { ): Promise<XXFallbackHandshake> {
const { isInitiator, libp2pPublicKey, remotePeer, connection } = params; const { isInitiator, libp2pPublicKey, remotePeer, connection } = params;
const handshake = const handshake =
new XXFallback(isInitiator, this.privateKey, libp2pPublicKey, this.prologue, this.staticKeys, connection, remotePeer, initialMsg, ephemeralKeys); new XXFallbackHandshake(isInitiator, this.privateKey, libp2pPublicKey, this.prologue, this.staticKeys, connection, remotePeer, initialMsg, ephemeralKeys);
try { try {
await handshake.propose(); await handshake.propose();
@ -145,9 +145,9 @@ export class Noise implements NoiseConnection {
private async performXXHandshake( private async performXXHandshake(
params: HandshakeParams, params: HandshakeParams,
): Promise<XX> { ): Promise<XXHandshake> {
const { isInitiator, libp2pPublicKey, remotePeer, connection } = params; const { isInitiator, libp2pPublicKey, remotePeer, connection } = params;
const handshake = new XX(isInitiator, this.privateKey, libp2pPublicKey, this.prologue, this.staticKeys, connection, remotePeer); const handshake = new XXHandshake(isInitiator, this.privateKey, libp2pPublicKey, this.prologue, this.staticKeys, connection, remotePeer);
try { try {
await handshake.propose(); await handshake.propose();
@ -162,9 +162,9 @@ export class Noise implements NoiseConnection {
private async performIKHandshake( private async performIKHandshake(
params: HandshakeParams, params: HandshakeParams,
): Promise<IK> { ): Promise<IKHandshake> {
const { isInitiator, libp2pPublicKey, remotePeer, connection } = params; const { isInitiator, libp2pPublicKey, remotePeer, connection } = params;
const handshake = new IK(isInitiator, this.privateKey, libp2pPublicKey, this.prologue, this.staticKeys, connection, remotePeer); const handshake = new IKHandshake(isInitiator, this.privateKey, libp2pPublicKey, this.prologue, this.staticKeys, connection, remotePeer);
// TODO // TODO
@ -173,7 +173,7 @@ export class Noise implements NoiseConnection {
private async createSecureConnection( private async createSecureConnection(
connection: WrappedConnection, connection: WrappedConnection,
handshake: HandshakeInterface, handshake: IHandshake,
): Promise<Duplex> { ): Promise<Duplex> {
// Create encryption box/unbox wrapper // Create encryption box/unbox wrapper
const [secure, user] = DuplexPair(); const [secure, user] = DuplexPair();

4
test/noise.test.ts
View File

@ -5,7 +5,7 @@ import { Noise } from "../src";
import {createPeerIdsFromFixtures} from "./fixtures/peer"; import {createPeerIdsFromFixtures} from "./fixtures/peer";
import Wrap from "it-pb-rpc"; import Wrap from "it-pb-rpc";
import { random } from "bcrypto"; import { random } from "bcrypto";
import {Handshake} from "../src/handshake-xx"; import {XXHandshake} from "../src/handshake-xx";
import { import {
createHandshakePayload, createHandshakePayload,
generateKeypair, generateKeypair,
@ -61,7 +61,7 @@ describe("Noise", () => {
const xx = new XX(); const xx = new XX();
const { privateKey: libp2pPrivKey, publicKey: libp2pPubKey } = getKeyPairFromPeerId(remotePeer); const { privateKey: libp2pPrivKey, publicKey: libp2pPubKey } = getKeyPairFromPeerId(remotePeer);
const handshake = new Handshake(false, libp2pPrivKey, libp2pPubKey, prologue, staticKeys, wrapped, localPeer, xx); const handshake = new XXHandshake(false, libp2pPrivKey, libp2pPubKey, prologue, staticKeys, wrapped, localPeer, xx);
let receivedMessageBuffer = decode0((await wrapped.readLP()).slice()); let receivedMessageBuffer = decode0((await wrapped.readLP()).slice());
// The first handshake message contains the initiator's ephemeral public key // The first handshake message contains the initiator's ephemeral public key

6
test/xx-fallback-handshake.test.ts
View File

@ -9,7 +9,7 @@ import {
signPayload signPayload
} from "../src/utils"; } from "../src/utils";
import {generateEd25519Keys, getKeyPairFromPeerId} from "./utils"; import {generateEd25519Keys, getKeyPairFromPeerId} from "./utils";
import {Handshake} from "../src/handshake-xx-fallback"; import {XXFallbackHandshake} from "../src/handshake-xx-fallback";
import {createPeerIdsFromFixtures} from "./fixtures/peer"; import {createPeerIdsFromFixtures} from "./fixtures/peer";
import {assert} from "chai"; import {assert} from "chai";
import {encode0, encode1} from "../src/encoder"; import {encode0, encode1} from "../src/encoder";
@ -48,10 +48,10 @@ describe("XX Fallback Handshake", () => {
}); });
const handshakeInit = const handshakeInit =
new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB, initialMsg, ephemeralKeys); new XXFallbackHandshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB, initialMsg, ephemeralKeys);
const handshakeResp = const handshakeResp =
new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA, initialMsg); new XXFallbackHandshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA, initialMsg);
await handshakeInit.propose(); await handshakeInit.propose();

14
test/xx-handshake.test.ts
View File

@ -3,7 +3,7 @@ import Duplex from 'it-pair/duplex';
import {Buffer} from "buffer"; import {Buffer} from "buffer";
import Wrap from "it-pb-rpc"; import Wrap from "it-pb-rpc";
import {Handshake} from "../src/handshake-xx"; import {XXHandshake} from "../src/handshake-xx";
import {generateKeypair} from "../src/utils"; import {generateKeypair} from "../src/utils";
import {createPeerIdsFromFixtures} from "./fixtures/peer"; import {createPeerIdsFromFixtures} from "./fixtures/peer";
import {getKeyPairFromPeerId} from "./utils"; import {getKeyPairFromPeerId} from "./utils";
@ -27,10 +27,10 @@ describe("XX Handshake", () => {
const staticKeysResponder = generateKeypair(); const staticKeysResponder = generateKeypair();
const { privateKey: initiatorPrivKey, publicKey: initiatorPubKey } = getKeyPairFromPeerId(peerA); const { privateKey: initiatorPrivKey, publicKey: initiatorPubKey } = getKeyPairFromPeerId(peerA);
const handshakeInitator = new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB); const handshakeInitator = new XXHandshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB);
const { privateKey: responderPrivKey, publicKey: responderPubKey } = getKeyPairFromPeerId(peerB); const { privateKey: responderPrivKey, publicKey: responderPubKey } = getKeyPairFromPeerId(peerB);
const handshakeResponder = new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA); const handshakeResponder = new XXHandshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA);
await handshakeInitator.propose(); await handshakeInitator.propose();
await handshakeResponder.propose(); await handshakeResponder.propose();
@ -72,10 +72,10 @@ describe("XX Handshake", () => {
const staticKeysResponder = generateKeypair(); const staticKeysResponder = generateKeypair();
const { privateKey: initiatorPrivKey, publicKey: initiatorPubKey } = getKeyPairFromPeerId(peerA); const { privateKey: initiatorPrivKey, publicKey: initiatorPubKey } = getKeyPairFromPeerId(peerA);
const handshakeInitator = new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, fakePeer); const handshakeInitator = new XXHandshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, fakePeer);
const { privateKey: responderPrivKey, publicKey: responderPubKey } = getKeyPairFromPeerId(peerB); const { privateKey: responderPrivKey, publicKey: responderPubKey } = getKeyPairFromPeerId(peerB);
const handshakeResponder = new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA); const handshakeResponder = new XXHandshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, peerA);
await handshakeInitator.propose(); await handshakeInitator.propose();
await handshakeResponder.propose(); await handshakeResponder.propose();
@ -100,10 +100,10 @@ describe("XX Handshake", () => {
const staticKeysResponder = generateKeypair(); const staticKeysResponder = generateKeypair();
const { privateKey: initiatorPrivKey, publicKey: initiatorPubKey } = getKeyPairFromPeerId(peerA); const { privateKey: initiatorPrivKey, publicKey: initiatorPubKey } = getKeyPairFromPeerId(peerA);
const handshakeInitator = new Handshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB); const handshakeInitator = new XXHandshake(true, initiatorPrivKey, initiatorPubKey, prologue, staticKeysInitiator, connectionFrom, peerB);
const { privateKey: responderPrivKey, publicKey: responderPubKey } = getKeyPairFromPeerId(peerB); const { privateKey: responderPrivKey, publicKey: responderPubKey } = getKeyPairFromPeerId(peerB);
const handshakeResponder = new Handshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, fakePeer); const handshakeResponder = new XXHandshake(false, responderPrivKey, responderPubKey, prologue, staticKeysResponder, connectionTo, fakePeer);
await handshakeInitator.propose(); await handshakeInitator.propose();
await handshakeResponder.propose(); await handshakeResponder.propose();