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

use types in the most straightforward way

Browse Source
This commit is contained in:
weboko 2023-01-28 01:59:54 +01:00
parent ea5f124a0d
commit 152595e027
No known key found for this signature in database
4 changed files with 472 additions and 1394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1756
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

4
package.json
View File

@ -72,7 +72,9 @@
"gh-pages": "^3.2.3",
"husky": "^7.0.4",
"ignore-loader": "^0.1.2",
"js-waku": "^0.30.0",
"@waku/core": "^0.0.10",
"@waku/interfaces": "^0.0.7",
"@waku/proto": "^0.0.2",
"jsdom": "^19.0.0",
"jsdom-global": "^3.0.2",
"karma": "^6.3.12",

100
src/codec.ts
View File

@ -1,7 +1,5 @@
import debug from "debug";
import { proto_message } from "js-waku";
import { Decoder, Encoder, Message, ProtoMessage } from "js-waku/lib/interfaces";
import { MessageV0 } from "js-waku/lib/waku_message/version_0";
import { DecodedMessage, Decoder, Encoder, proto } from "@waku/core/lib/message/version_0";
import { HandshakeResult, HandshakeStepResult } from "./handshake.js";
import { PayloadV2 } from "./payload.js";
@ -16,7 +14,7 @@ const version = 2;
/**
* Used internally in the pairing object to represent a handshake message
*/
export class NoiseHandshakeMessage extends MessageV0 implements Message {
export class NoiseHandshakeMessage extends DecodedMessage {
get payloadV2(): PayloadV2 {
if (!this.payload) throw new Error("no payload available");
return PayloadV2.deserialize(this.payload);
@ -27,28 +25,13 @@ export class NoiseHandshakeMessage extends MessageV0 implements Message {
* Used in the pairing object for encoding the messages exchanged
* during the handshake process
*/
export class NoiseHandshakeEncoder implements Encoder {
export class NoiseHandshakeEncoder extends Encoder {
/**
* @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
*/
constructor(public contentTopic: string, private hsStepResult: HandshakeStepResult) {}
async toWire(message: Partial<Message>): Promise<Uint8Array | undefined> {
const protoMessage = await this.toProtoObj(message);
if (!protoMessage) return;
return proto_message.WakuMessage.encode(protoMessage);
}
async toProtoObj(message: Partial<Message>): Promise<ProtoMessage | undefined> {
const timestamp = message.timestamp ?? new Date();
return {
rateLimitProof: undefined,
payload: this.hsStepResult.payload2.serialize(),
version: version,
contentTopic: this.contentTopic,
timestamp: BigInt(timestamp.valueOf()) * OneMillion,
};
constructor(public contentTopic: string, private hsStepResult: HandshakeStepResult) {
super(contentTopic);
}
}
@ -56,21 +39,15 @@ export class NoiseHandshakeEncoder implements Encoder {
* Used in the pairing object for decoding the messages exchanged
* during the handshake process
*/
export class NoiseHandshakeDecoder implements Decoder<NoiseHandshakeMessage> {
export class NoiseHandshakeDecoder extends Decoder {
/**
* @param contentTopic content topic on which the encoded WakuMessages were sent
*/
constructor(public contentTopic: string) {}
fromWireToProtoObj(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
const protoMessage = proto_message.WakuMessage.decode(bytes);
log("Message decoded", protoMessage);
// TODO(@weboko): remove type casting when released
// https://github.com/waku-org/js-waku/pull/1136
return Promise.resolve(protoMessage as ProtoMessage);
constructor(public contentTopic: string) {
super(contentTopic);
}
async fromProtoObj(proto: ProtoMessage): Promise<NoiseHandshakeMessage | undefined> {
async fromProtoObj(proto: proto.WakuMessage): Promise<NoiseHandshakeMessage | undefined> {
// https://github.com/status-im/js-waku/issues/921
if (proto.version === undefined) {
proto.version = 0;
@ -94,18 +71,7 @@ export class NoiseHandshakeDecoder implements Decoder<NoiseHandshakeMessage> {
* Represents a secure message. These are messages that are transmitted
* after a successful handshake is performed.
*/
export class NoiseSecureMessage extends MessageV0 implements Message {
private readonly _decodedPayload: Uint8Array;
constructor(proto: proto_message.WakuMessage, decodedPayload: Uint8Array) {
super(proto);
this._decodedPayload = decodedPayload;
}
get payload(): Uint8Array {
return this._decodedPayload;
}
}
export class NoiseSecureMessage extends DecodedMessage {}
/**
* js-waku encoder for secure messages. After a handshake is successful, a
@ -113,37 +79,13 @@ export class NoiseSecureMessage extends MessageV0 implements Message {
* codec will be encrypted with the cipherstates and message nametags that were
* created after a handshake is complete
*/
export class NoiseSecureTransferEncoder implements Encoder {
export class NoiseSecureTransferEncoder extends Encoder {
/**
* @param contentTopic content topic on which the encoded WakuMessages were sent
* @param hsResult handshake result obtained after the handshake is successful
*/
constructor(public contentTopic: string, private hsResult: HandshakeResult) {}
async toWire(message: Partial<Message>): Promise<Uint8Array | undefined> {
const protoMessage = await this.toProtoObj(message);
if (!protoMessage) return;
return proto_message.WakuMessage.encode(protoMessage);
}
async toProtoObj(message: Partial<Message>): Promise<ProtoMessage | undefined> {
const timestamp = message.timestamp ?? new Date();
if (!message.payload) {
log("No payload to encrypt, skipping: ", message);
return;
}
const preparedPayload = this.hsResult.writeMessage(message.payload);
const payload = preparedPayload.serialize();
return {
payload,
rateLimitProof: undefined,
version: version,
contentTopic: this.contentTopic,
timestamp: BigInt(timestamp.valueOf()) * OneMillion,
};
constructor(public contentTopic: string, private hsResult: HandshakeResult) {
super(contentTopic);
}
}
@ -153,22 +95,16 @@ export class NoiseSecureTransferEncoder implements Encoder {
* messages with the cipherstates and message nametags that were created after a
* handshake is complete
*/
export class NoiseSecureTransferDecoder implements Decoder<NoiseSecureMessage> {
export class NoiseSecureTransferDecoder extends Decoder {
/**
* @param contentTopic content topic on which the encoded WakuMessages were sent
* @param hsResult handshake result obtained after the handshake is successful
*/
constructor(public contentTopic: string, private hsResult: HandshakeResult) {}
fromWireToProtoObj(bytes: Uint8Array): Promise<ProtoMessage | undefined> {
const protoMessage = proto_message.WakuMessage.decode(bytes);
log("Message decoded", protoMessage);
// TODO(@weboko): remove type casting when released
// https://github.com/waku-org/js-waku/pull/1136
return Promise.resolve(protoMessage as ProtoMessage);
constructor(public contentTopic: string, private hsResult: HandshakeResult) {
super(contentTopic);
}
async fromProtoObj(proto: ProtoMessage): Promise<NoiseSecureMessage | undefined> {
async fromProtoObj(proto: proto.WakuMessage): Promise<NoiseSecureMessage | undefined> {
// https://github.com/status-im/js-waku/issues/921
if (proto.version === undefined) {
proto.version = 0;
@ -187,7 +123,7 @@ export class NoiseSecureTransferDecoder implements Decoder<NoiseSecureMessage> {
try {
const payloadV2 = PayloadV2.deserialize(proto.payload);
const decryptedPayload = this.hsResult.readMessage(payloadV2);
return new NoiseSecureMessage(proto, decryptedPayload);
return new NoiseSecureMessage(proto);
} catch (err) {
log("could not decode message ", err);
return;

6
src/pairing.ts
View File

@ -2,7 +2,7 @@ import { HMACDRBG } from "@stablelib/hmac-drbg";
import { randomBytes } from "@stablelib/random";
import debug from "debug";
import { EventEmitter } from "eventemitter3";
import { Decoder, Encoder, Message } from "js-waku/lib/interfaces";
import { Decoder, Encoder, DecodedMessage } from "@waku/core/lib/message/version_0";
import { pEvent } from "p-event";
import { equals as uint8ArrayEquals } from "uint8arrays/equals";
@ -32,7 +32,7 @@ export interface Sender {
* @param encoder NoiseHandshakeEncoder encoder to use to encrypt the messages
* @param msg message to broadcast
*/
publish(encoder: Encoder, msg: Message): Promise<void>;
publish(encoder: Encoder, msg: DecodedMessage): Promise<void>;
}
/**
@ -43,7 +43,7 @@ export interface Responder {
* subscribe to receive the messages from a content topic
* @param decoder Decoder to use to decrypt the NoiseHandshakeMessages
*/
subscribe(decoder: Decoder<NoiseHandshakeMessage>): Promise<void>;
subscribe(decoder: Decoder): Promise<void>;
/**
* should return messages received in a content topic