pinomad 0.3.0 → 0.5.0

package/dist/chunk-z4x88s0q.js

@@ -1,347 +0,0 @@
-// packages/protocol/src/relay.ts
-import { ed25519 } from "@noble/curves/ed25519.js";
-
-// packages/protocol/src/noise.ts
-import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
-import { x25519 } from "@noble/curves/ed25519.js";
-import { blake2s } from "@noble/hashes/blake2.js";
-import { hmac } from "@noble/hashes/hmac.js";
-var PROTOCOL_NAME = new TextEncoder().encode("Noise_IK_25519_ChaChaPoly_BLAKE2s");
-var KEY_LENGTH = 32;
-var TAG_LENGTH = 16;
-var MAX_MESSAGE = 65535;
-var MAX_NONCE = 2n ** 64n - 1n;
-var hash = (data) => blake2s(data, { dkLen: KEY_LENGTH });
-var concat = (...parts) => {
-  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-};
-function hkdf(chainingKey, ikm, outputs) {
-  const tempKey = hmac(blake2s, chainingKey, ikm);
-  const out1 = hmac(blake2s, tempKey, new Uint8Array([1]));
-  const out2 = hmac(blake2s, tempKey, concat(out1, new Uint8Array([2])));
-  return [out1, out2];
-}
-function generateKeyPair() {
-  return keyPairFromPrivate(x25519.utils.randomSecretKey());
-}
-function keyPairFromPrivate(privateKey) {
-  if (privateKey.length !== KEY_LENGTH)
-    throw new Error(`X25519 private key must be ${KEY_LENGTH} bytes`);
-  return { publicKey: x25519.getPublicKey(privateKey), privateKey };
-}
-var dh = (pair, remotePublic) => x25519.getSharedSecret(pair.privateKey, remotePublic);
-
-class NoiseCipherState {
-  #key;
-  #nonce = 0n;
-  setKey(key) {
-    this.#key = key;
-    this.#nonce = 0n;
-  }
-  encrypt(plaintext, ad = new Uint8Array(0)) {
-    const key = this.#key;
-    if (key === undefined)
-      return plaintext;
-    return chacha20poly1305(key, this.#takeNonce(), ad).encrypt(plaintext);
-  }
-  decrypt(ciphertext, ad = new Uint8Array(0)) {
-    const key = this.#key;
-    if (key === undefined)
-      return ciphertext;
-    return chacha20poly1305(key, this.#takeNonce(), ad).decrypt(ciphertext);
-  }
-  #takeNonce() {
-    if (this.#nonce === MAX_NONCE)
-      throw new Error("nonce exhausted");
-    const nonce = new Uint8Array(12);
-    new DataView(nonce.buffer).setBigUint64(4, this.#nonce, true);
-    this.#nonce += 1n;
-    return nonce;
-  }
-}
-
-class SymmetricState {
-  #ck;
-  #h;
-  cipher = new NoiseCipherState;
-  constructor() {
-    const name = PROTOCOL_NAME;
-    this.#h = name.length <= KEY_LENGTH ? concat(name, new Uint8Array(KEY_LENGTH - name.length)) : hash(name);
-    this.#ck = this.#h.slice();
-  }
-  mixKey(ikm) {
-    const [ck, tempKey] = hkdf(this.#ck, ikm, 2);
-    this.#ck = ck;
-    this.cipher.setKey(tempKey.subarray(0, KEY_LENGTH));
-  }
-  mixHash(data) {
-    this.#h = hash(concat(this.#h, data));
-  }
-  encryptAndHash(plaintext) {
-    const ciphertext = this.cipher.encrypt(plaintext, this.#h);
-    this.mixHash(ciphertext);
-    return ciphertext;
-  }
-  decryptAndHash(ciphertext) {
-    const plaintext = this.cipher.decrypt(ciphertext, this.#h);
-    this.mixHash(ciphertext);
-    return plaintext;
-  }
-  get handshakeHash() {
-    return this.#h;
-  }
-  split() {
-    const [key1, key2] = hkdf(this.#ck, new Uint8Array(0), 2);
-    const first = new NoiseCipherState;
-    first.setKey(key1.subarray(0, KEY_LENGTH));
-    const second = new NoiseCipherState;
-    second.setKey(key2.subarray(0, KEY_LENGTH));
-    return [first, second];
-  }
-}
-function take(message, size) {
-  if (message.offset + size > message.buffer.length)
-    throw new Error("malformed Noise message");
-  const slice = message.buffer.subarray(message.offset, message.offset + size);
-  message.offset += size;
-  return slice;
-}
-function readMessage1(state, message, own) {
-  const remoteEphemeral = take(message, KEY_LENGTH).slice();
-  state.mixHash(remoteEphemeral);
-  state.mixKey(dh(own.static, remoteEphemeral));
-  const remoteStatic = state.decryptAndHash(take(message, KEY_LENGTH + TAG_LENGTH)).slice();
-  if (remoteStatic.length !== KEY_LENGTH)
-    throw new Error("bad remote static key");
-  state.mixKey(dh(own.static, remoteStatic));
-  return { remoteEphemeral, remoteStatic };
-}
-function writeMessage2(state, buffer, own, remoteEphemeral, remoteStatic) {
-  buffer.push(own.ephemeral.publicKey);
-  state.mixHash(own.ephemeral.publicKey);
-  state.mixKey(dh(own.ephemeral, remoteEphemeral));
-  state.mixKey(dh(own.ephemeral, remoteStatic));
-}
-var checkLength = (message, what) => {
-  if (message.length > MAX_MESSAGE)
-    throw new Error(`${what} exceeds ${MAX_MESSAGE} bytes`);
-};
-function initialize(prologue, responderStatic) {
-  const state = new SymmetricState;
-  state.mixHash(prologue);
-  state.mixHash(responderStatic);
-  return state;
-}
-function respondIK(options) {
-  const ephemeral = options.ephemeral ?? generateKeyPair();
-  const state = initialize(options.prologue, options.static.publicKey);
-  let remoteEphemeral;
-  let remoteStatic;
-  return {
-    readMessage1(message) {
-      checkLength(message, "handshake message");
-      const reader = { buffer: message, offset: 0 };
-      const remote = readMessage1(state, reader, { static: options.static });
-      remoteEphemeral = remote.remoteEphemeral;
-      remoteStatic = remote.remoteStatic;
-      const payload = state.decryptAndHash(take(reader, message.length - reader.offset));
-      return { payload, remoteStatic };
-    },
-    writeMessage2(payload) {
-      if (remoteEphemeral === undefined || remoteStatic === undefined)
-        throw new Error("message 2 before message 1");
-      const buffer = [];
-      writeMessage2(state, buffer, { ephemeral }, remoteEphemeral, remoteStatic);
-      buffer.push(state.encryptAndHash(payload));
-      const message = concat(...buffer);
-      checkLength(message, "handshake message");
-      const [receive, send] = state.split();
-      return { message, result: { send, receive, handshakeHash: state.handshakeHash } };
-    }
-  };
-}
-
-// packages/protocol/src/secure-channel.ts
-var SECURE_PROLOGUE = new TextEncoder().encode("pinomad/1");
-var utf8 = new TextEncoder;
-var utf8Decode = new TextDecoder("utf-8", { fatal: true });
-var encodeHostHello = (hello) => utf8.encode(JSON.stringify(hello));
-function decodeJson(bytes) {
-  try {
-    return JSON.parse(utf8Decode.decode(bytes));
-  } catch {
-    throw new Error("handshake payload is not JSON");
-  }
-}
-var isString = (value) => typeof value === "string";
-function decodeClientHello(bytes) {
-  const value = decodeJson(bytes);
-  if (value?.v !== 1)
-    throw new Error("unsupported client hello");
-  const pair = value.pair;
-  if (pair === undefined)
-    return { v: 1 };
-  const secret = pair.secret;
-  const name = pair.name;
-  if (!isString(secret) || !isString(name))
-    throw new Error("malformed pair");
-  return { v: 1, pair: { secret, name } };
-}
-var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-function toBase64Url(bytes) {
-  let out = "";
-  for (let index = 0;index < bytes.length; index += 3) {
-    const a = bytes[index];
-    const b = bytes[index + 1];
-    const c = bytes[index + 2];
-    out += B64_ALPHABET[a >> 2] + B64_ALPHABET[(a & 3) << 4 | (b ?? 0) >> 4];
-    if (b !== undefined)
-      out += B64_ALPHABET[(b & 15) << 2 | (c ?? 0) >> 6];
-    if (c !== undefined)
-      out += B64_ALPHABET[c & 63];
-  }
-  return out;
-}
-function fromBase64Url(text) {
-  if (text.length % 4 === 1)
-    throw new Error("invalid base64url");
-  const lookup = new Map(Array.from(B64_ALPHABET, (char, index) => [char, index]));
-  const bytes = [];
-  for (let index = 0;index < text.length; index += 4) {
-    const quad = text.slice(index, index + 4);
-    const values = [...quad].map((char) => {
-      const value = lookup.get(char);
-      if (value === undefined)
-        throw new Error("invalid base64url");
-      return value;
-    });
-    const packed = values.reduce((bits, value, index2) => bits | value << 18 - index2 * 6, 0);
-    bytes.push(packed >> 16 & 255);
-    if (values.length > 2)
-      bytes.push(packed >> 8 & 255);
-    if (values.length > 3)
-      bytes.push(packed & 255);
-  }
-  return new Uint8Array(bytes);
-}
-var MAX_BODY = 65535 - 16 - 1;
-
-class SecureSession {
-  #send;
-  #receive;
-  #pending = [];
-  constructor(result) {
-    this.#send = result.send;
-    this.#receive = result.receive;
-  }
-  seal(text) {
-    const body = utf8.encode(text);
-    const chunks = [];
-    for (let offset = 0;offset <= body.length; offset += MAX_BODY) {
-      const last = offset + MAX_BODY >= body.length;
-      const record = new Uint8Array(1 + Math.min(MAX_BODY, body.length - offset));
-      record[0] = last ? 0 : 1;
-      record.set(body.subarray(offset, offset + MAX_BODY), 1);
-      chunks.push(this.#send.encrypt(record));
-      if (last)
-        break;
-    }
-    return chunks;
-  }
-  open(chunk) {
-    const record = this.#receive.decrypt(chunk);
-    const flag = record[0];
-    if (flag !== 0 && flag !== 1)
-      throw new Error("bad record flag");
-    this.#pending.push(record.subarray(1));
-    if (flag === 1)
-      return;
-    const whole = concatParts(this.#pending);
-    this.#pending = [];
-    return utf8Decode.decode(whole);
-  }
-}
-function concatParts(parts) {
-  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
-  let offset = 0;
-  for (const part of parts) {
-    out.set(part, offset);
-    offset += part.length;
-  }
-  return out;
-}
-
-// packages/protocol/src/relay.ts
-var RELAY_CLOSE = {
-  badSignature: 4601,
-  hostNotAllowed: 4603,
-  hostOffline: 4604,
-  unknownConnection: 4605,
-  replaced: 4609,
-  acceptTimeout: 4610
-};
-function encodeRelayFrame(frame) {
-  return JSON.stringify(frame);
-}
-var isString2 = (value) => typeof value === "string";
-function decodeJson2(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error("relay frame is not JSON");
-  }
-}
-function decodeRelayToHost(text) {
-  const value = decodeJson2(text);
-  switch (value?.t) {
-    case "challenge":
-      if (!isString2(value.nonce))
-        throw new Error("malformed challenge");
-      return { t: "challenge", nonce: value.nonce };
-    case "registered":
-      return { t: "registered" };
-    case "incoming":
-      if (!isString2(value.connId))
-        throw new Error("malformed incoming");
-      return { t: "incoming", connId: value.connId };
-    default:
-      throw new Error("unknown relay frame");
-  }
-}
-function decodeHostToRelay(text) {
-  const value = decodeJson2(text);
-  if (value?.t !== "register" || !isString2(value.hostId) || !isString2(value.signature)) {
-    throw new Error("malformed register");
-  }
-  return { t: "register", hostId: value.hostId, signature: value.signature };
-}
-function relayHostId(publicKey) {
-  if (publicKey.length !== 32)
-    throw new Error("Ed25519 public key must be 32 bytes");
-  return toBase64Url(publicKey);
-}
-var utf82 = new TextEncoder;
-function relayChallengeMessage(args) {
-  return utf82.encode(`pinomad-relay/1
-${args.relayOrigin}
-${args.hostId}
-${args.nonce}`);
-}
-function signRelayChallenge(secretKey, args) {
-  return toBase64Url(ed25519.sign(relayChallengeMessage(args), secretKey));
-}
-function verifyRelayChallenge(signature, args) {
-  try {
-    return ed25519.verify(fromBase64Url(signature), relayChallengeMessage(args), fromBase64Url(args.hostId));
-  } catch {
-    return false;
-  }
-}
-
-export { generateKeyPair, keyPairFromPrivate, respondIK, SECURE_PROLOGUE, encodeHostHello, decodeClientHello, toBase64Url, fromBase64Url, SecureSession, RELAY_CLOSE, encodeRelayFrame, decodeRelayToHost, decodeHostToRelay, relayHostId, signRelayChallenge, verifyRelayChallenge };