@waku/core 0.0.1

package/src/lib/waku_filter/index.ts

@@ -0,0 +1,291 @@
+import type { Stream } from "@libp2p/interface-connection";
+import type { PeerId } from "@libp2p/interface-peer-id";
+import type { Peer } from "@libp2p/interface-peer-store";
+import type { IncomingStreamData } from "@libp2p/interface-registrar";
+import type {
+  Callback,
+  Decoder,
+  Filter,
+  Message,
+  ProtocolOptions,
+} from "@waku/interfaces";
+import debug from "debug";
+import all from "it-all";
+import * as lp from "it-length-prefixed";
+import { pipe } from "it-pipe";
+import type { Libp2p } from "libp2p";
+
+import { WakuMessage as WakuMessageProto } from "../../proto/message";
+import { DefaultPubSubTopic } from "../constants";
+import { groupByContentTopic } from "../group_by";
+import { selectConnection } from "../select_connection";
+import {
+  getPeersForProtocol,
+  selectPeerForProtocol,
+  selectRandomPeer,
+} from "../select_peer";
+import { toProtoMessage } from "../to_proto_message";
+
+import { ContentFilter, FilterRPC } from "./filter_rpc";
+export { ContentFilter };
+
+export const FilterCodec = "/vac/waku/filter/2.0.0-beta1";
+
+const log = debug("waku:filter");
+
+export interface CreateOptions {
+  /**
+   * The PubSub Topic to use. Defaults to {@link DefaultPubSubTopic}.
+   *
+   * The usage of the default pubsub topic is recommended.
+   * See [Waku v2 Topic Usage Recommendations](https://rfc.vac.dev/spec/23/) for details.
+   *
+   * @default {@link DefaultPubSubTopic}
+   */
+  pubSubTopic?: string;
+}
+
+export type UnsubscribeFunction = () => Promise<void>;
+
+/**
+ * Implements client side of the [Waku v2 Filter protocol](https://rfc.vac.dev/spec/12/).
+ *
+ * Note this currently only works in NodeJS when the Waku node is listening on a port, see:
+ * - https://github.com/status-im/go-waku/issues/245
+ * - https://github.com/status-im/nwaku/issues/948
+ */
+export class WakuFilter implements Filter {
+  pubSubTopic: string;
+  private subscriptions: Map<string, Callback<any>>;
+  private decoders: Map<
+    string, // content topic
+    Set<Decoder<any>>
+  >;
+
+  constructor(public libp2p: Libp2p, options?: CreateOptions) {
+    this.subscriptions = new Map();
+    this.decoders = new Map();
+    this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+    this.libp2p
+      .handle(FilterCodec, this.onRequest.bind(this))
+      .catch((e) => log("Failed to register filter protocol", e));
+  }
+
+  /**
+   * @param decoders Array of Decoders to use to decode messages, it also specifies the content topics.
+   * @param callback A function that will be called on each message returned by the filter.
+   * @param opts The FilterSubscriptionOpts used to narrow which messages are returned, and which peer to connect to.
+   * @returns Unsubscribe function that can be used to end the subscription.
+   */
+  async subscribe<T extends Message>(
+    decoders: Decoder<T>[],
+    callback: Callback<T>,
+    opts?: ProtocolOptions
+  ): Promise<UnsubscribeFunction> {
+    const topic = opts?.pubSubTopic ?? this.pubSubTopic;
+
+    const groupedDecoders = groupByContentTopic(decoders);
+    const contentTopics = Array.from(groupedDecoders.keys());
+
+    const contentFilters = contentTopics.map((contentTopic) => ({
+      contentTopic,
+    }));
+    const request = FilterRPC.createRequest(
+      topic,
+      contentFilters,
+      undefined,
+      true
+    );
+
+    const requestId = request.requestId;
+    if (!requestId)
+      throw new Error(
+        "Internal error: createRequest expected to set `requestId`"
+      );
+
+    const peer = await this.getPeer(opts?.peerId);
+    const stream = await this.newStream(peer);
+
+    try {
+      const res = await pipe(
+        [request.encode()],
+        lp.encode(),
+        stream,
+        lp.decode(),
+        async (source) => await all(source)
+      );
+
+      log("response", res);
+    } catch (e) {
+      log(
+        "Error subscribing to peer ",
+        peer.id.toString(),
+        "for content topics",
+        contentTopics,
+        ": ",
+        e
+      );
+      throw e;
+    }
+
+    this.addDecoders(groupedDecoders);
+    this.addCallback(requestId, callback);
+
+    return async () => {
+      await this.unsubscribe(topic, contentFilters, requestId, peer);
+      this.deleteDecoders(groupedDecoders);
+      this.deleteCallback(requestId);
+    };
+  }
+
+  private onRequest(streamData: IncomingStreamData): void {
+    log("Receiving message push");
+    try {
+      pipe(streamData.stream, lp.decode(), async (source) => {
+        for await (const bytes of source) {
+          const res = FilterRPC.decode(bytes.slice());
+          if (res.requestId && res.push?.messages?.length) {
+            await this.pushMessages(res.requestId, res.push.messages);
+          }
+        }
+      }).then(
+        () => {
+          log("Receiving pipe closed.");
+        },
+        (e) => {
+          log("Error with receiving pipe", e);
+        }
+      );
+    } catch (e) {
+      log("Error decoding message", e);
+    }
+  }
+
+  private async pushMessages(
+    requestId: string,
+    messages: WakuMessageProto[]
+  ): Promise<void> {
+    const callback = this.subscriptions.get(requestId);
+    if (!callback) {
+      log(`No callback registered for request ID ${requestId}`);
+      return;
+    }
+
+    for (const protoMessage of messages) {
+      const contentTopic = protoMessage.contentTopic;
+      if (!contentTopic) {
+        log("Message has no content topic, skipping");
+        return;
+      }
+
+      const decoders = this.decoders.get(contentTopic);
+      if (!decoders) {
+        log("No decoder for", contentTopic);
+        return;
+      }
+
+      let msg: Message | undefined;
+      // We don't want to wait for decoding failure, just attempt to decode
+      // all messages and do the call back on the one that works
+      // noinspection ES6MissingAwait
+      decoders.forEach(async (dec) => {
+        if (msg) return;
+        const decoded = await dec.fromProtoObj(toProtoMessage(protoMessage));
+        if (!decoded) {
+          log("Not able to decode message");
+          return;
+        }
+        // This is just to prevent more decoding attempt
+        // TODO: Could be better if we were to abort promises
+        msg = decoded;
+        await callback(decoded);
+      });
+    }
+  }
+
+  private addCallback(requestId: string, callback: Callback<any>): void {
+    this.subscriptions.set(requestId, callback);
+  }
+
+  private deleteCallback(requestId: string): void {
+    this.subscriptions.delete(requestId);
+  }
+
+  private addDecoders<T extends Message>(
+    decoders: Map<string, Array<Decoder<T>>>
+  ): void {
+    decoders.forEach((decoders, contentTopic) => {
+      const currDecs = this.decoders.get(contentTopic);
+      if (!currDecs) {
+        this.decoders.set(contentTopic, new Set(decoders));
+      } else {
+        this.decoders.set(contentTopic, new Set([...currDecs, ...decoders]));
+      }
+    });
+  }
+
+  private deleteDecoders<T extends Message>(
+    decoders: Map<string, Array<Decoder<T>>>
+  ): void {
+    decoders.forEach((decoders, contentTopic) => {
+      const currDecs = this.decoders.get(contentTopic);
+      if (currDecs) {
+        decoders.forEach((dec) => {
+          currDecs.delete(dec);
+        });
+      }
+    });
+  }
+
+  private async unsubscribe(
+    topic: string,
+    contentFilters: ContentFilter[],
+    requestId: string,
+    peer: Peer
+  ): Promise<void> {
+    const unsubscribeRequest = FilterRPC.createRequest(
+      topic,
+      contentFilters,
+      requestId,
+      false
+    );
+
+    const stream = await this.newStream(peer);
+    try {
+      await pipe([unsubscribeRequest.encode()], lp.encode(), stream.sink);
+    } catch (e) {
+      log("Error unsubscribing", e);
+      throw e;
+    }
+  }
+
+  private async newStream(peer: Peer): Promise<Stream> {
+    const connections = this.libp2p.connectionManager.getConnections(peer.id);
+    const connection = selectConnection(connections);
+    if (!connection) {
+      throw new Error("Failed to get a connection to the peer");
+    }
+
+    return connection.newStream(FilterCodec);
+  }
+
+  private async getPeer(peerId?: PeerId): Promise<Peer> {
+    const res = await selectPeerForProtocol(
+      this.libp2p.peerStore,
+      [FilterCodec],
+      peerId
+    );
+    if (!res) {
+      throw new Error(`Failed to select peer for ${FilterCodec}`);
+    }
+    return res.peer;
+  }
+
+  async peers(): Promise<Peer[]> {
+    return getPeersForProtocol(this.libp2p.peerStore, [FilterCodec]);
+  }
+
+  async randomPeer(): Promise<Peer | undefined> {
+    return selectRandomPeer(await this.peers());
+  }
+}

package/src/lib/waku_light_push/index.ts

@@ -0,0 +1,137 @@
+import type { PeerId } from "@libp2p/interface-peer-id";
+import type { Peer } from "@libp2p/interface-peer-store";
+import type {
+  Encoder,
+  Message,
+  ProtocolOptions,
+  SendResult,
+} from "@waku/interfaces";
+import debug from "debug";
+import all from "it-all";
+import * as lp from "it-length-prefixed";
+import { pipe } from "it-pipe";
+import { Libp2p } from "libp2p";
+import { Uint8ArrayList } from "uint8arraylist";
+
+import { PushResponse } from "../../proto/light_push";
+import { DefaultPubSubTopic } from "../constants";
+import { selectConnection } from "../select_connection";
+import {
+  getPeersForProtocol,
+  selectPeerForProtocol,
+  selectRandomPeer,
+} from "../select_peer";
+
+import { PushRPC } from "./push_rpc";
+
+const log = debug("waku:light-push");
+
+export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
+export { PushResponse };
+
+export interface CreateOptions {
+  /**
+   * The PubSub Topic to use. Defaults to {@link DefaultPubSubTopic}.
+   *
+   * The usage of the default pubsub topic is recommended.
+   * See [Waku v2 Topic Usage Recommendations](https://rfc.vac.dev/spec/23/) for details.
+   *
+   * @default {@link DefaultPubSubTopic}
+   */
+  pubSubTopic?: string;
+}
+
+/**
+ * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
+ */
+export class WakuLightPush {
+  pubSubTopic: string;
+
+  constructor(public libp2p: Libp2p, options?: CreateOptions) {
+    this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+  }
+
+  async push(
+    encoder: Encoder,
+    message: Partial<Message>,
+    opts?: ProtocolOptions
+  ): Promise<SendResult> {
+    const pubSubTopic = opts?.pubSubTopic ? opts.pubSubTopic : this.pubSubTopic;
+
+    const res = await selectPeerForProtocol(
+      this.libp2p.peerStore,
+      [LightPushCodec],
+      opts?.peerId
+    );
+
+    if (!res) {
+      throw new Error("Failed to get a peer");
+    }
+    const { peer } = res;
+
+    const connections = this.libp2p.connectionManager.getConnections(peer.id);
+    const connection = selectConnection(connections);
+
+    if (!connection) throw "Failed to get a connection to the peer";
+
+    const stream = await connection.newStream(LightPushCodec);
+
+    const recipients: PeerId[] = [];
+
+    try {
+      const protoMessage = await encoder.toProtoObj(message);
+      if (!protoMessage) {
+        log("Failed to encode to protoMessage, aborting push");
+        return { recipients };
+      }
+      const query = PushRPC.createRequest(protoMessage, pubSubTopic);
+      const res = await pipe(
+        [query.encode()],
+        lp.encode(),
+        stream,
+        lp.decode(),
+        async (source) => await all(source)
+      );
+      try {
+        const bytes = new Uint8ArrayList();
+        res.forEach((chunk) => {
+          bytes.append(chunk);
+        });
+
+        const response = PushRPC.decode(bytes).response;
+
+        if (!response) {
+          log("No response in PushRPC");
+          return { recipients };
+        }
+
+        if (response.isSuccess) {
+          recipients.push(peer.id);
+        }
+      } catch (err) {
+        log("Failed to decode push reply", err);
+      }
+    } catch (err) {
+      log("Failed to send waku light push request", err);
+    }
+    return { recipients };
+  }
+
+  /**
+   * Returns known peers from the address book (`libp2p.peerStore`) that support
+   * light push protocol. Waku may or may not be currently connected to these
+   * peers.
+   */
+  async peers(): Promise<Peer[]> {
+    return getPeersForProtocol(this.libp2p.peerStore, [LightPushCodec]);
+  }
+
+  /**
+   * Returns a random peer that supports light push protocol from the address
+   * book (`libp2p.peerStore`). Waku may or  may not be currently connected to
+   * this peer.
+   */
+  async randomPeer(): Promise<Peer | undefined> {
+    return selectRandomPeer(await this.peers());
+  }
+}

package/src/lib/waku_light_push/push_rpc.ts

@@ -0,0 +1,39 @@
+import type { Uint8ArrayList } from "uint8arraylist";
+import { v4 as uuid } from "uuid";
+
+import * as proto from "../../proto/light_push";
+
+export class PushRPC {
+  public constructor(public proto: proto.PushRPC) {}
+
+  static createRequest(
+    message: proto.WakuMessage,
+    pubSubTopic: string
+  ): PushRPC {
+    return new PushRPC({
+      requestId: uuid(),
+      request: {
+        message: message,
+        pubSubTopic: pubSubTopic,
+      },
+      response: undefined,
+    });
+  }
+
+  static decode(bytes: Uint8ArrayList): PushRPC {
+    const res = proto.PushRPC.decode(bytes);
+    return new PushRPC(res);
+  }
+
+  encode(): Uint8Array {
+    return proto.PushRPC.encode(this.proto);
+  }
+
+  get query(): proto.PushRequest | undefined {
+    return this.proto.request;
+  }
+
+  get response(): proto.PushResponse | undefined {
+    return this.proto.response;
+  }
+}

package/src/lib/waku_message/constants.ts

@@ -0,0 +1,10 @@
+export const Symmetric = {
+  keySize: 32,
+  ivSize: 12,
+  tagSize: 16,
+  algorithm: { name: "AES-GCM", length: 128 },
+};
+
+export const Asymmetric = {
+  keySize: 32,
+};

package/src/lib/waku_message/ecies.ts

@@ -0,0 +1,194 @@
+import * as secp from "@noble/secp256k1";
+
+import { getSubtle, randomBytes, sha256 } from "../crypto";
+import { concat, hexToBytes } from "../utils";
+/**
+ * HKDF as implemented in go-ethereum.
+ */
+function kdf(secret: Uint8Array, outputLength: number): Promise<Uint8Array> {
+  let ctr = 1;
+  let written = 0;
+  let willBeResult = Promise.resolve(new Uint8Array());
+  while (written < outputLength) {
+    const counters = new Uint8Array([ctr >> 24, ctr >> 16, ctr >> 8, ctr]);
+    const countersSecret = concat(
+      [counters, secret],
+      counters.length + secret.length
+    );
+    const willBeHashResult = sha256(countersSecret);
+    willBeResult = willBeResult.then((result) =>
+      willBeHashResult.then((hashResult) => {
+        const _hashResult = new Uint8Array(hashResult);
+        return concat(
+          [result, _hashResult],
+          result.length + _hashResult.length
+        );
+      })
+    );
+    written += 32;
+    ctr += 1;
+  }
+  return willBeResult;
+}
+
+function aesCtrEncrypt(
+  counter: Uint8Array,
+  key: ArrayBufferLike,
+  data: ArrayBufferLike
+): Promise<Uint8Array> {
+  return getSubtle()
+    .importKey("raw", key, "AES-CTR", false, ["encrypt"])
+    .then((cryptoKey) =>
+      getSubtle().encrypt(
+        { name: "AES-CTR", counter: counter, length: 128 },
+        cryptoKey,
+        data
+      )
+    )
+    .then((bytes) => new Uint8Array(bytes));
+}
+
+function aesCtrDecrypt(
+  counter: Uint8Array,
+  key: ArrayBufferLike,
+  data: ArrayBufferLike
+): Promise<Uint8Array> {
+  return getSubtle()
+    .importKey("raw", key, "AES-CTR", false, ["decrypt"])
+    .then((cryptoKey) =>
+      getSubtle().decrypt(
+        { name: "AES-CTR", counter: counter, length: 128 },
+        cryptoKey,
+        data
+      )
+    )
+    .then((bytes) => new Uint8Array(bytes));
+}
+
+function hmacSha256Sign(
+  key: ArrayBufferLike,
+  msg: ArrayBufferLike
+): PromiseLike<Uint8Array> {
+  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
+  return getSubtle()
+    .importKey("raw", key, algorithm, false, ["sign"])
+    .then((cryptoKey) => getSubtle().sign(algorithm, cryptoKey, msg))
+    .then((bytes) => new Uint8Array(bytes));
+}
+
+function hmacSha256Verify(
+  key: ArrayBufferLike,
+  msg: ArrayBufferLike,
+  sig: ArrayBufferLike
+): Promise<boolean> {
+  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
+  const _key = getSubtle().importKey("raw", key, algorithm, false, ["verify"]);
+  return _key.then((cryptoKey) =>
+    getSubtle().verify(algorithm, cryptoKey, sig, msg)
+  );
+}
+
+/**
+ * Derive shared secret for given private and public keys.
+ *
+ * @param  privateKeyA Sender's private key (32 bytes)
+ * @param  publicKeyB Recipient's public key (65 bytes)
+ * @returns  A promise that resolves with the derived shared secret (Px, 32 bytes)
+ * @throws Error If arguments are invalid
+ */
+function derive(privateKeyA: Uint8Array, publicKeyB: Uint8Array): Uint8Array {
+  if (privateKeyA.length !== 32) {
+    throw new Error(
+      `Bad private key, it should be 32 bytes but it's actually ${privateKeyA.length} bytes long`
+    );
+  } else if (publicKeyB.length !== 65) {
+    throw new Error(
+      `Bad public key, it should be 65 bytes but it's actually ${publicKeyB.length} bytes long`
+    );
+  } else if (publicKeyB[0] !== 4) {
+    throw new Error("Bad public key, a valid public key would begin with 4");
+  } else {
+    const px = secp.getSharedSecret(privateKeyA, publicKeyB, true);
+    // Remove the compression prefix
+    return new Uint8Array(hexToBytes(px).slice(1));
+  }
+}
+
+/**
+ * Encrypt message for given recipient's public key.
+ *
+ * @param  publicKeyTo Recipient's public key (65 bytes)
+ * @param  msg The message being encrypted
+ * @return A promise that resolves with the ECIES structure serialized
+ */
+export async function encrypt(
+  publicKeyTo: Uint8Array,
+  msg: Uint8Array
+): Promise<Uint8Array> {
+  const ephemPrivateKey = randomBytes(32);
+
+  const sharedPx = await derive(ephemPrivateKey, publicKeyTo);
+
+  const hash = await kdf(sharedPx, 32);
+
+  const iv = randomBytes(16);
+  const encryptionKey = hash.slice(0, 16);
+  const cipherText = await aesCtrEncrypt(iv, encryptionKey, msg);
+
+  const ivCipherText = concat([iv, cipherText], iv.length + cipherText.length);
+
+  const macKey = await sha256(hash.slice(16));
+  const hmac = await hmacSha256Sign(macKey, ivCipherText);
+  const ephemPublicKey = secp.getPublicKey(ephemPrivateKey, false);
+
+  return concat(
+    [ephemPublicKey, ivCipherText, hmac],
+    ephemPublicKey.length + ivCipherText.length + hmac.length
+  );
+}
+
+const metaLength = 1 + 64 + 16 + 32;
+
+/**
+ * Decrypt message using given private key.
+ *
+ * @param privateKey A 32-byte private key of recipient of the message
+ * @param encrypted ECIES serialized structure (result of ECIES encryption)
+ * @returns The clear text
+ * @throws Error If decryption fails
+ */
+export async function decrypt(
+  privateKey: Uint8Array,
+  encrypted: Uint8Array
+): Promise<Uint8Array> {
+  if (encrypted.length <= metaLength) {
+    throw new Error(
+      `Invalid Ciphertext. Data is too small. It should ba at least ${metaLength} bytes`
+    );
+  } else if (encrypted[0] !== 4) {
+    throw new Error(
+      `Not a valid ciphertext. It should begin with 4 but actually begin with ${encrypted[0]}`
+    );
+  } else {
+    // deserialize
+    const ephemPublicKey = encrypted.slice(0, 65);
+    const cipherTextLength = encrypted.length - metaLength;
+    const iv = encrypted.slice(65, 65 + 16);
+    const cipherAndIv = encrypted.slice(65, 65 + 16 + cipherTextLength);
+    const ciphertext = cipherAndIv.slice(16);
+    const msgMac = encrypted.slice(65 + 16 + cipherTextLength);
+
+    // check HMAC
+    const px = derive(privateKey, ephemPublicKey);
+    const hash = await kdf(px, 32);
+    const [encryptionKey, macKey] = await sha256(hash.slice(16)).then(
+      (macKey) => [hash.slice(0, 16), macKey]
+    );
+
+    if (!(await hmacSha256Verify(macKey, cipherAndIv, msgMac))) {
+      throw new Error("Incorrect MAC");
+    }
+
+    return aesCtrDecrypt(iv, encryptionKey, ciphertext);
+  }
+}

package/src/lib/waku_message/symmetric.ts

@@ -0,0 +1,33 @@
+import { getSubtle, randomBytes } from "../crypto";
+
+import { Symmetric } from "./constants";
+
+export async function encrypt(
+  iv: Uint8Array,
+  key: Uint8Array,
+  clearText: Uint8Array
+): Promise<Uint8Array> {
+  return getSubtle()
+    .importKey("raw", key, Symmetric.algorithm, false, ["encrypt"])
+    .then((cryptoKey) =>
+      getSubtle().encrypt({ iv, ...Symmetric.algorithm }, cryptoKey, clearText)
+    )
+    .then((cipher) => new Uint8Array(cipher));
+}
+
+export async function decrypt(
+  iv: Uint8Array,
+  key: Uint8Array,
+  cipherText: Uint8Array
+): Promise<Uint8Array> {
+  return getSubtle()
+    .importKey("raw", key, Symmetric.algorithm, false, ["decrypt"])
+    .then((cryptoKey) =>
+      getSubtle().decrypt({ iv, ...Symmetric.algorithm }, cryptoKey, cipherText)
+    )
+    .then((clear) => new Uint8Array(clear));
+}
+
+export function generateIv(): Uint8Array {
+  return randomBytes(Symmetric.ivSize);
+}