logos-messaging/js-noise
1
0
Fork 0
mirror of https://github.com/logos-messaging/js-noise.git synced 2026-01-07 16:13:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat!: add pubsub topic as parameter

Browse Source 
feat!: add pubsub topic as parameter
This commit is contained in:
Sasha 2024-04-18 23:55:25 +02:00 committed by GitHub
commit 056e6509a1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 74 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/codec.ts
View File

@ -8,7 +8,6 @@ import {
type IProtoMessage, type IProtoMessage,
} from "@waku/interfaces"; } from "@waku/interfaces";
import { WakuMessage } from "@waku/proto"; import { WakuMessage } from "@waku/proto";
import { contentTopicToPubsubTopic } from "@waku/utils";
import debug from "debug"; import debug from "debug";
import { HandshakeResult, HandshakeStepResult } from "./handshake.js"; import { HandshakeResult, HandshakeStepResult } from "./handshake.js";
@ -37,19 +36,18 @@ export class NoiseHandshakeMessage extends DecodedMessage implements IDecodedMes
*/ */
export class NoiseHandshakeEncoder implements IEncoder { export class NoiseHandshakeEncoder implements IEncoder {
/** /**
* @param pubsubTopic pubsub topic on which handshake happens
* @param contentTopic content topic on which the encoded WakuMessages will be sent * @param contentTopic content topic on which the encoded WakuMessages will be sent
* @param hsStepResult the result of a step executed while performing the handshake process * @param hsStepResult the result of a step executed while performing the handshake process
* @param ephemeral makes messages ephemeral in the Waku network * @param ephemeral makes messages ephemeral in the Waku network
*/ */
pubsubTopic: string;
constructor( constructor(
public contentTopic: string, public contentTopic: string,
public pubsubTopic: string,
private hsStepResult: HandshakeStepResult, private hsStepResult: HandshakeStepResult,
public ephemeral: boolean = true public ephemeral: boolean = true
) { ) {}
this.pubsubTopic = contentTopicToPubsubTopic(contentTopic);
}
async toWire(message: IMessage): Promise<Uint8Array | undefined> { async toWire(message: IMessage): Promise<Uint8Array | undefined> {
const protoMessage = await this.toProtoObj(message); const protoMessage = await this.toProtoObj(message);
@ -77,13 +75,11 @@ export class NoiseHandshakeEncoder implements IEncoder {
*/ */
export class NoiseHandshakeDecoder implements IDecoder<NoiseHandshakeMessage> { export class NoiseHandshakeDecoder implements IDecoder<NoiseHandshakeMessage> {
/** /**
* @param pubsubTopic pubsub topic on which handshake happens
* @param contentTopic content topic on which the encoded WakuMessages were sent * @param contentTopic content topic on which the encoded WakuMessages were sent
*/ */
pubsubTopic: string;
constructor(public contentTopic: string) { constructor(public contentTopic: string, public pubsubTopic: string) {}
this.pubsubTopic = contentTopicToPubsubTopic(contentTopic);
}
fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> { fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
const protoMessage = WakuMessage.decode(bytes); const protoMessage = WakuMessage.decode(bytes);
@ -139,20 +135,19 @@ export class NoiseSecureMessage extends DecodedMessage implements IDecodedMessag
export class NoiseSecureTransferEncoder implements IEncoder { export class NoiseSecureTransferEncoder implements IEncoder {
/** /**
* @param contentTopic content topic on which the encoded WakuMessages were sent. * @param contentTopic content topic on which the encoded WakuMessages were sent.
* @param pubsubTopic pubsub topic on which handshake happens
* @param hsResult handshake result obtained after the handshake is successful. * @param hsResult handshake result obtained after the handshake is successful.
* @param ephemeral whether messages should be tagged as ephemeral defaults to true. * @param ephemeral whether messages should be tagged as ephemeral defaults to true.
* @param metaSetter callback function that set the `meta` field. * @param metaSetter callback function that set the `meta` field.
*/ */
pubsubTopic: string;
constructor( constructor(
public contentTopic: string, public contentTopic: string,
public pubsubTopic: string,
private hsResult: HandshakeResult, private hsResult: HandshakeResult,
public ephemeral: boolean = true, public ephemeral: boolean = true,
public metaSetter?: IMetaSetter public metaSetter?: IMetaSetter
) { ) {}
this.pubsubTopic = contentTopicToPubsubTopic(contentTopic);
}
async toWire(message: IMessage): Promise<Uint8Array | undefined> { async toWire(message: IMessage): Promise<Uint8Array | undefined> {
const protoMessage = await this.toProtoObj(message); const protoMessage = await this.toProtoObj(message);
@ -199,13 +194,11 @@ export class NoiseSecureTransferEncoder implements IEncoder {
export class NoiseSecureTransferDecoder implements IDecoder<NoiseSecureMessage> { export class NoiseSecureTransferDecoder implements IDecoder<NoiseSecureMessage> {
/** /**
* @param contentTopic content topic on which the encoded WakuMessages were sent * @param contentTopic content topic on which the encoded WakuMessages were sent
* @param pubsubTopic pubsub topic on which handshake happens
* @param hsResult handshake result obtained after the handshake is successful * @param hsResult handshake result obtained after the handshake is successful
*/ */
pubsubTopic: string;
constructor(public contentTopic: string, private hsResult: HandshakeResult) { constructor(public contentTopic: string, public pubsubTopic: string, private hsResult: HandshakeResult) {}
this.pubsubTopic = contentTopicToPubsubTopic(contentTopic);
}
fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> { fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
const protoMessage = WakuMessage.decode(bytes); const protoMessage = WakuMessage.decode(bytes);

40
src/pairing.spec.ts
View File

@ -11,7 +11,7 @@ import { DH25519 } from "./dh25519";
import { MessageNametagBufferSize } from "./messagenametag"; import { MessageNametagBufferSize } from "./messagenametag";
import { ResponderParameters, WakuPairing } from "./pairing"; import { ResponderParameters, WakuPairing } from "./pairing";
const PUBSUB_TOPIC = "default"; const PUBSUB_TOPIC = "/waku/2/default-waku/proto";
const EMPTY_PROTOMESSAGE = { const EMPTY_PROTOMESSAGE = {
timestamp: undefined, timestamp: undefined,
@ -72,14 +72,14 @@ describe("js-noise: pairing object", () => {
const aliceStaticKey = dhKey.generateKeyPair(); const aliceStaticKey = dhKey.generateKeyPair();
const recvParameters = new ResponderParameters(); const recvParameters = new ResponderParameters();
const bobPairingObj = new WakuPairing(sender, responder, bobStaticKey, recvParameters); const bobPairingObj = new WakuPairing(PUBSUB_TOPIC, sender, responder, bobStaticKey, recvParameters);
const bobExecP1 = bobPairingObj.execute(); const bobExecP1 = bobPairingObj.execute();
// Confirmation is done by manually // Confirmation is done by manually
confirmAuthCodeFlow(bobPairingObj, true); confirmAuthCodeFlow(bobPairingObj, true);
const initParameters = bobPairingObj.getPairingInfo(); const initParameters = bobPairingObj.getPairingInfo();
const alicePairingObj = new WakuPairing(sender, responder, aliceStaticKey, initParameters); const alicePairingObj = new WakuPairing(PUBSUB_TOPIC, sender, responder, aliceStaticKey, initParameters);
const aliceExecP1 = alicePairingObj.execute(); const aliceExecP1 = alicePairingObj.execute();
// Confirmation is done manually // Confirmation is done manually
@ -115,8 +115,20 @@ describe("js-noise: pairing object", () => {
it("should timeout", async function () { it("should timeout", async function () {
const dhKey = new DH25519(); const dhKey = new DH25519();
const bobPairingObj = new WakuPairing(sender, responder, dhKey.generateKeyPair(), new ResponderParameters()); const bobPairingObj = new WakuPairing(
const alicePairingObj = new WakuPairing(sender, responder, dhKey.generateKeyPair(), bobPairingObj.getPairingInfo()); PUBSUB_TOPIC,
sender,
responder,
dhKey.generateKeyPair(),
new ResponderParameters()
);
const alicePairingObj = new WakuPairing(
PUBSUB_TOPIC,
sender,
responder,
dhKey.generateKeyPair(),
bobPairingObj.getPairingInfo()
);
const bobExecP1 = bobPairingObj.execute(1000); const bobExecP1 = bobPairingObj.execute(1000);
const aliceExecP1 = alicePairingObj.execute(1000); const aliceExecP1 = alicePairingObj.execute(1000);
@ -147,16 +159,26 @@ describe("js-noise: pairing object", () => {
}; };
const recvParameters = new ResponderParameters(); const recvParameters = new ResponderParameters();
const bobPairingObj = new WakuPairing(sender, responder, bobStaticKey, recvParameters, undefined, { metaSetter }); const bobPairingObj = new WakuPairing(PUBSUB_TOPIC, sender, responder, bobStaticKey, recvParameters, undefined, {
metaSetter,
});
const bobExecP1 = bobPairingObj.execute(); const bobExecP1 = bobPairingObj.execute();
// Confirmation is done by manually // Confirmation is done by manually
confirmAuthCodeFlow(bobPairingObj, true); confirmAuthCodeFlow(bobPairingObj, true);
const initParameters = bobPairingObj.getPairingInfo(); const initParameters = bobPairingObj.getPairingInfo();
const alicePairingObj = new WakuPairing(sender, responder, aliceStaticKey, initParameters, undefined, { const alicePairingObj = new WakuPairing(
metaSetter, PUBSUB_TOPIC,
}); sender,
responder,
aliceStaticKey,
initParameters,
undefined,
{
metaSetter,
}
);
const aliceExecP1 = alicePairingObj.execute(); const aliceExecP1 = alicePairingObj.execute();
// Confirmation is done manually // Confirmation is done manually

30
src/pairing.ts
View File

@ -82,6 +82,7 @@ export class WakuPairing {
} }
/** /**
* @param pubsubTopic pubsubTopic to be used for handshake
* @param sender object that implements Sender interface to publish waku messages * @param sender object that implements Sender interface to publish waku messages
* @param responder object that implements Responder interface to subscribe and receive waku messages * @param responder object that implements Responder interface to subscribe and receive waku messages
* @param myStaticKey x25519 keypair * @param myStaticKey x25519 keypair
@ -90,6 +91,7 @@ export class WakuPairing {
* @param encoderParameters optional parameters for the resulting encoders * @param encoderParameters optional parameters for the resulting encoders
*/ */
constructor( constructor(
private pubsubTopic: string,
private sender: ISender, private sender: ISender,
private responder: IReceiver, private responder: IReceiver,
private myStaticKey: KeyPair, private myStaticKey: KeyPair,
@ -223,7 +225,7 @@ export class WakuPairing {
private async initiatorHandshake(): Promise<[NoiseSecureTransferEncoder, NoiseSecureTransferDecoder]> { private async initiatorHandshake(): Promise<[NoiseSecureTransferEncoder, NoiseSecureTransferDecoder]> {
// Subscribe to the contact content topic // Subscribe to the contact content topic
const decoder = new NoiseHandshakeDecoder(this.contentTopic); const decoder = new NoiseHandshakeDecoder(this.contentTopic, this.pubsubTopic);
const subscriptionIterator = await this.responder.toSubscriptionIterator(decoder); const subscriptionIterator = await this.responder.toSubscriptionIterator(decoder);
// The handshake initiator writes a Waku2 payload v2 containing the handshake message // The handshake initiator writes a Waku2 payload v2 containing the handshake message
@ -236,7 +238,7 @@ export class WakuPairing {
// We prepare a message from initiator's payload2 // We prepare a message from initiator's payload2
// At this point wakuMsg is sent over the Waku network to responder content topic // At this point wakuMsg is sent over the Waku network to responder content topic
let encoder = new NoiseHandshakeEncoder(this.contentTopic, hsStep); let encoder = new NoiseHandshakeEncoder(this.contentTopic, this.pubsubTopic, hsStep);
await this.sender.send(encoder, { await this.sender.send(encoder, {
payload: new Uint8Array(), payload: new Uint8Array(),
}); });
@ -281,7 +283,7 @@ export class WakuPairing {
messageNametag: this.handshake.hs.toMessageNametag(), messageNametag: this.handshake.hs.toMessageNametag(),
}); });
encoder = new NoiseHandshakeEncoder(this.contentTopic, hsStep); encoder = new NoiseHandshakeEncoder(this.contentTopic, this.pubsubTopic, hsStep);
await this.sender.send(encoder, { await this.sender.send(encoder, {
payload: new Uint8Array(), payload: new Uint8Array(),
}); });
@ -291,12 +293,17 @@ export class WakuPairing {
this.eventEmitter.emit("pairingComplete"); this.eventEmitter.emit("pairingComplete");
return WakuPairing.getSecureCodec(this.contentTopic, this.handshakeResult, this.encoderParameters); return WakuPairing.getSecureCodec(
this.contentTopic,
this.pubsubTopic,
this.handshakeResult,
this.encoderParameters
);
} }
private async responderHandshake(): Promise<[NoiseSecureTransferEncoder, NoiseSecureTransferDecoder]> { private async responderHandshake(): Promise<[NoiseSecureTransferEncoder, NoiseSecureTransferDecoder]> {
// Subscribe to the contact content topic // Subscribe to the contact content topic
const decoder = new NoiseHandshakeDecoder(this.contentTopic); const decoder = new NoiseHandshakeDecoder(this.contentTopic, this.pubsubTopic);
const subscriptionIterator = await this.responder.toSubscriptionIterator(decoder); const subscriptionIterator = await this.responder.toSubscriptionIterator(decoder);
// the received reads the initiator's payloads, and returns the (decrypted) transport message the initiator sent // the received reads the initiator's payloads, and returns the (decrypted) transport message the initiator sent
@ -322,7 +329,7 @@ export class WakuPairing {
}); });
// We prepare a Waku message from responder's payload2 // We prepare a Waku message from responder's payload2
const encoder = new NoiseHandshakeEncoder(this.contentTopic, hsStep); const encoder = new NoiseHandshakeEncoder(this.contentTopic, this.pubsubTopic, hsStep);
await this.sender.send(encoder, { await this.sender.send(encoder, {
payload: new Uint8Array(), payload: new Uint8Array(),
}); });
@ -355,7 +362,12 @@ export class WakuPairing {
this.eventEmitter.emit("pairingComplete"); this.eventEmitter.emit("pairingComplete");
return WakuPairing.getSecureCodec(this.contentTopic, this.handshakeResult, this.encoderParameters); return WakuPairing.getSecureCodec(
this.contentTopic,
this.pubsubTopic,
this.handshakeResult,
this.encoderParameters
);
} }
/** /**
@ -368,16 +380,18 @@ export class WakuPairing {
*/ */
static getSecureCodec( static getSecureCodec(
contentTopic: string, contentTopic: string,
pubsubTopic: string,
hsResult: HandshakeResult, hsResult: HandshakeResult,
encoderParameters: EncoderParameters encoderParameters: EncoderParameters
): [NoiseSecureTransferEncoder, NoiseSecureTransferDecoder] { ): [NoiseSecureTransferEncoder, NoiseSecureTransferDecoder] {
const secureEncoder = new NoiseSecureTransferEncoder( const secureEncoder = new NoiseSecureTransferEncoder(
contentTopic, contentTopic,
pubsubTopic,
hsResult, hsResult,
encoderParameters.ephemeral, encoderParameters.ephemeral,
encoderParameters.metaSetter encoderParameters.metaSetter
); );
const secureDecoder = new NoiseSecureTransferDecoder(contentTopic, hsResult); const secureDecoder = new NoiseSecureTransferDecoder(contentTopic, pubsubTopic, hsResult);
return [secureEncoder, secureDecoder]; return [secureEncoder, secureDecoder];
} }

22
src/waku-noise-pairing.spec.ts
View File

@ -18,7 +18,7 @@ import { NoiseHandshakePatterns } from "./patterns.js";
import { NoisePublicKey } from "./publickey.js"; import { NoisePublicKey } from "./publickey.js";
import { QR } from "./qr.js"; import { QR } from "./qr.js";
const PUBSUB_TOPIC = "default"; const PUBSUB_TOPIC = "/waku/2/default-waku/proto";
describe("Waku Noise Sessions", () => { describe("Waku Noise Sessions", () => {
const rng = new HMACDRBG(); const rng = new HMACDRBG();
@ -114,7 +114,7 @@ describe("Waku Noise Sessions", () => {
messageNametag: qrMessageNameTag, messageNametag: qrMessageNameTag,
}); });
let encoder = new NoiseHandshakeEncoder(contentTopic, aliceStep); let encoder = new NoiseHandshakeEncoder(contentTopic, PUBSUB_TOPIC, aliceStep);
// We prepare a Waku message from Alice's payload2 // We prepare a Waku message from Alice's payload2
// At this point wakuMsg is sent over the Waku network and is received // At this point wakuMsg is sent over the Waku network and is received
@ -122,7 +122,7 @@ describe("Waku Noise Sessions", () => {
let wakuMsgBytes = await encoder.toWire({ payload: new Uint8Array() }); let wakuMsgBytes = await encoder.toWire({ payload: new Uint8Array() });
// We decode the WakuMessage from the ProtoBuffer // We decode the WakuMessage from the ProtoBuffer
let decoder = new NoiseHandshakeDecoder(contentTopic); let decoder = new NoiseHandshakeDecoder(contentTopic, PUBSUB_TOPIC);
let wakuMsgProto = await decoder.fromWireToProtoObj(wakuMsgBytes!); let wakuMsgProto = await decoder.fromWireToProtoObj(wakuMsgBytes!);
let v2Msg = await decoder.fromProtoObj(PUBSUB_TOPIC, wakuMsgProto!); let v2Msg = await decoder.fromProtoObj(PUBSUB_TOPIC, wakuMsgProto!);
@ -157,14 +157,14 @@ describe("Waku Noise Sessions", () => {
bobStep = bobHS.stepHandshake({ transportMessage: sentTransportMessage, messageNametag: bobMessageNametag }); bobStep = bobHS.stepHandshake({ transportMessage: sentTransportMessage, messageNametag: bobMessageNametag });
// We prepare a Waku message from Bob's payload2 // We prepare a Waku message from Bob's payload2
encoder = new NoiseHandshakeEncoder(contentTopic, bobStep); encoder = new NoiseHandshakeEncoder(contentTopic, PUBSUB_TOPIC, bobStep);
// At this point wakuMsg is sent over the Waku network and is received // At this point wakuMsg is sent over the Waku network and is received
// We simulate this by creating the ProtoBuffer from wakuMsg // We simulate this by creating the ProtoBuffer from wakuMsg
wakuMsgBytes = await encoder.toWire({ payload: new Uint8Array() }); wakuMsgBytes = await encoder.toWire({ payload: new Uint8Array() });
// We decode the WakuMessage from the ProtoBuffer // We decode the WakuMessage from the ProtoBuffer
decoder = new NoiseHandshakeDecoder(contentTopic); decoder = new NoiseHandshakeDecoder(contentTopic, PUBSUB_TOPIC);
wakuMsgProto = await decoder.fromWireToProtoObj(wakuMsgBytes!); wakuMsgProto = await decoder.fromWireToProtoObj(wakuMsgBytes!);
v2Msg = await decoder.fromProtoObj(PUBSUB_TOPIC, wakuMsgProto!); v2Msg = await decoder.fromProtoObj(PUBSUB_TOPIC, wakuMsgProto!);
@ -194,14 +194,14 @@ describe("Waku Noise Sessions", () => {
aliceStep = aliceHS.stepHandshake({ transportMessage: sentTransportMessage, messageNametag: aliceMessageNametag }); aliceStep = aliceHS.stepHandshake({ transportMessage: sentTransportMessage, messageNametag: aliceMessageNametag });
// We prepare a Waku message from Alice's payload2 // We prepare a Waku message from Alice's payload2
encoder = new NoiseHandshakeEncoder(contentTopic, aliceStep); encoder = new NoiseHandshakeEncoder(contentTopic, PUBSUB_TOPIC, aliceStep);
// At this point wakuMsg is sent over the Waku network and is received // At this point wakuMsg is sent over the Waku network and is received
// We simulate this by creating the ProtoBuffer from wakuMsg // We simulate this by creating the ProtoBuffer from wakuMsg
wakuMsgBytes = await encoder.toWire({ payload: new Uint8Array() }); wakuMsgBytes = await encoder.toWire({ payload: new Uint8Array() });
// We decode the WakuMessage from the ProtoBuffer // We decode the WakuMessage from the ProtoBuffer
decoder = new NoiseHandshakeDecoder(contentTopic); decoder = new NoiseHandshakeDecoder(contentTopic, PUBSUB_TOPIC);
wakuMsgProto = await decoder.fromWireToProtoObj(wakuMsgBytes!); wakuMsgProto = await decoder.fromWireToProtoObj(wakuMsgBytes!);
v2Msg = await decoder.fromProtoObj(PUBSUB_TOPIC, wakuMsgProto!); v2Msg = await decoder.fromProtoObj(PUBSUB_TOPIC, wakuMsgProto!);
@ -224,11 +224,11 @@ describe("Waku Noise Sessions", () => {
const aliceHSResult = aliceHS.finalizeHandshake(); const aliceHSResult = aliceHS.finalizeHandshake();
const bobHSResult = bobHS.finalizeHandshake(); const bobHSResult = bobHS.finalizeHandshake();
const aliceEncoder = new NoiseSecureTransferEncoder(contentTopic, aliceHSResult); const aliceEncoder = new NoiseSecureTransferEncoder(contentTopic, PUBSUB_TOPIC, aliceHSResult);
const bobEncoder = new NoiseSecureTransferEncoder(contentTopic, bobHSResult); const bobEncoder = new NoiseSecureTransferEncoder(contentTopic, PUBSUB_TOPIC, bobHSResult);
const aliceDecoder = new NoiseSecureTransferDecoder(contentTopic, aliceHSResult); const aliceDecoder = new NoiseSecureTransferDecoder(contentTopic, PUBSUB_TOPIC, aliceHSResult);
const bobDecoder = new NoiseSecureTransferDecoder(contentTopic, bobHSResult); const bobDecoder = new NoiseSecureTransferDecoder(contentTopic, PUBSUB_TOPIC, bobHSResult);
// We test read/write of random messages exchanged between Alice and Bob // We test read/write of random messages exchanged between Alice and Bob
// Note that we exchange more than the number of messages contained in the nametag buffer to test if they are filled correctly as the communication proceeds // Note that we exchange more than the number of messages contained in the nametag buffer to test if they are filled correctly as the communication proceeds