nervur 0.22.0 → 0.22.2-3

package/src/core/crypto/json.ts

@@ -1,241 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// JSON text as the spec's values chapter reads it. Two readers, for two
-// jobs:
-//
-//   readObject   Quo's reading of a payload, a reply text or an invitation:
-//                UTF-8 with no byte order mark, one object, no two own keys
-//                of one name, and every field kept as the text it was
-//                written in. What is inside a field is held to the grammar
-//                alone, at any depth, and read no further.
-//
-//   readValue    Nervur's reading of a text it hands to a being: the
-//                grammar, a nesting bound, no two keys of one name at any
-//                depth, no lone surrogate, and no number a double does not
-//                hold as written. Anything else is undefined, since null
-//                is a value.
-//
-// A runtime's own parser keeps the last of two keys, rounds numbers and
-// mends bad bytes, which is where two kits stop agreeing, so neither reader
-// trusts it with more than the escapes of one string.
-export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
-
-// A field's value exactly as it stood in the text, by its key.
-export type Fields = ReadonlyMap<string, string>;
-
-const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-const NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
-const ESCAPE = /\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4})/y;
-const LONE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
-const LITERALS = ['true', 'false', 'null'];
-
-const skip = (s: string, at: number): number => {
-  while (at < s.length && ' \t\n\r'.includes(s[at]!)) at += 1;
-  return at;
-};
-
-// The end of the string opening at `at`, or -1.
-const stringEnd = (s: string, at: number): number => {
-  if (s[at] !== '"') return -1;
-  for (at += 1; at < s.length; ) {
-    const c = s.charCodeAt(at);
-    if (c === 0x22) return at + 1;
-    if (c < 0x20) return -1;
-    if (c !== 0x5c) {
-      at += 1;
-      continue;
-    }
-    ESCAPE.lastIndex = at;
-    if (!ESCAPE.test(s)) return -1;
-    at = ESCAPE.lastIndex;
-  }
-  return -1;
-};
-
-const scalarEnd = (s: string, at: number): number => {
-  if (s[at] === '"') return stringEnd(s, at);
-  const literal = LITERALS.find((word) => s.startsWith(word, at));
-  if (literal) return at + literal.length;
-  NUMBER.lastIndex = at;
-  return NUMBER.test(s) ? NUMBER.lastIndex : -1;
-};
-
-// A key, its colon and the space after it: the start of the key's value, or -1.
-const keyEnd = (s: string, at: number): number => {
-  const end = stringEnd(s, at);
-  if (end < 0) return -1;
-  const colon = skip(s, end);
-  return s[colon] === ':' ? skip(s, colon + 1) : -1;
-};
-
-// The end of the value starting at `at`, held to the grammar at any depth
-// without recursion, or -1.
-const valueEnd = (s: string, at: number): number => {
-  const open: string[] = [];
-  for (;;) {
-    const c = s[at];
-    if (c === '{' || c === '[') {
-      at = skip(s, at + 1);
-      if (s[at] === (c === '{' ? '}' : ']')) at += 1;
-      else {
-        open.push(c);
-        if (c === '{' && (at = keyEnd(s, at)) < 0) return -1;
-        continue;
-      }
-    } else if ((at = scalarEnd(s, at)) < 0) return -1;
-    for (;;) {
-      if (open.length === 0) return at;
-      at = skip(s, at);
-      const top = open.at(-1);
-      if (s[at] === ',') {
-        at = skip(s, at + 1);
-        if (top === '{' && (at = keyEnd(s, at)) < 0) return -1;
-        break;
-      }
-      if (s[at] !== (top === '{' ? '}' : ']')) return -1;
-      open.pop();
-      at += 1;
-    }
-  }
-};
-
-const text = (input: Uint8Array | string): string | null => {
-  if (typeof input === 'string') return input;
-  try {
-    return decoder.decode(input);
-  } catch {
-    return null;
-  }
-};
-
-export const readObject = (input: Uint8Array | string): Fields | null => {
-  const s = text(input);
-  if (s === null) return null;
-  const fields = new Map<string, string>();
-  let at = skip(s, 0);
-  if (s[at] !== '{') return null;
-  at = skip(s, at + 1);
-  if (s[at] === '}') return skip(s, at + 1) === s.length ? fields : null;
-  for (;;) {
-    const keyStart = at;
-    const valueStart = keyEnd(s, at);
-    if (valueStart < 0) return null;
-    const key = JSON.parse(s.slice(keyStart, stringEnd(s, keyStart))) as string;
-    if (fields.has(key)) return null;
-    const end = valueEnd(s, valueStart);
-    if (end < 0) return null;
-    fields.set(key, s.slice(valueStart, end));
-    at = skip(s, end);
-    if (s[at] === '}') return skip(s, at + 1) === s.length ? fields : null;
-    if (s[at] !== ',') return null;
-    at = skip(s, at + 1);
-  }
-};
-
-// A number text a double holds as written: a fraction, or a whole number
-// the double it reads as is exactly, never past the largest double, never
-// a value that rounds to zero, never minus zero.
-const exactNumber = (literal: string): boolean => {
-  const [, sign, whole, frac = '', exp = '0'] = /^(-?)(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(literal)!;
-  const v = Number(literal);
-  if (!Number.isFinite(v)) return false;
-  const digits = (whole! + frac).replace(/^0+/, '');
-  if (v === 0) return digits === '' && sign === '';
-  const trimmed = digits.replace(/0+$/, '');
-  const e = BigInt(exp) - BigInt(frac.length) + BigInt(digits.length - trimmed.length);
-  if (e < 0n) return true;
-  return BigInt(trimmed) * 10n ** e === (v < 0 ? -BigInt(v) : BigInt(v)) || literal === String(v);
-};
-
-const depthOf = (s: string): number => {
-  let depth = 0;
-  let deepest = 0;
-  for (let at = 0; at < s.length; at += 1) {
-    const c = s[at];
-    if (c === '"') at = stringEnd(s, at) - 1;
-    else if (c === '{' || c === '[') deepest = Math.max(deepest, (depth += 1));
-    else if (c === '}' || c === ']') depth -= 1;
-  }
-  return deepest;
-};
-
-// Parses a text already held to the grammar and to the depth bound.
-const parse = (s: string): Json => {
-  let at = 0;
-  const value = (): Json => {
-    at = skip(s, at);
-    const c = s[at];
-    if (c === '{' || c === '[') {
-      const object = c === '{';
-      const out: Json[] | Record<string, Json> = object ? {} : [];
-      at = skip(s, at + 1);
-      if (s[at] === (object ? '}' : ']')) {
-        at += 1;
-        return out;
-      }
-      for (;;) {
-        if (object) {
-          const key = str();
-          if (Object.hasOwn(out, key)) throw new Error('two keys of one name');
-          at = skip(s, at) + 1;
-          Object.defineProperty(out, key, { value: value(), enumerable: true, writable: true, configurable: true });
-        } else (out as Json[]).push(value());
-        at = skip(s, at);
-        if (s[at++] !== ',') return out;
-      }
-    }
-    if (c === '"') return str();
-    const end = scalarEnd(s, at);
-    const literal = s.slice(at, end);
-    at = end;
-    if (LITERALS.includes(literal)) return JSON.parse(literal) as Json;
-    if (!exactNumber(literal)) throw new Error('a number no double holds as written');
-    return Number(literal);
-  };
-  const str = (): string => {
-    at = skip(s, at);
-    const end = stringEnd(s, at);
-    const out = JSON.parse(s.slice(at, end)) as string;
-    if (LONE.test(out)) throw new Error('a lone surrogate');
-    at = end;
-    return out;
-  };
-  return value();
-};
-
-export const readValue = (input: Uint8Array | string, depth: number): Json | undefined => {
-  const s = text(input);
-  if (s === null) return undefined;
-  const start = skip(s, 0);
-  const end = valueEnd(s, start);
-  if (end < 0 || skip(s, end) !== s.length || depthOf(s) > depth) return undefined;
-  try {
-    return parse(s);
-  } catch {
-    return undefined;
-  }
-};
-
-// A value as JSON text, or undefined for one that JSON would drop, rewrite
-// or refuse: anything but null, a boolean, a finite number other than minus
-// zero, well-formed text, a list with no holes, or a plain object of own
-// string keys, nested no deeper than `depth`, with no cycle.
-export const writeValue = (value: unknown, depth: number): string | undefined => {
-  const fits = (v: unknown, room: number, path: Set<object>): boolean => {
-    if (v === null || typeof v === 'boolean') return true;
-    if (typeof v === 'string') return !LONE.test(v);
-    if (typeof v === 'number') return Number.isFinite(v) && !Object.is(v, -0);
-    if (typeof v !== 'object' || room === 0 || path.has(v)) return false;
-    path.add(v);
-    const ok = Array.isArray(v)
-      ? Object.keys(v).length === v.length && v.every((x) => fits(x, room - 1, path))
-      : [Object.prototype, null].includes(Object.getPrototypeOf(v)) &&
-        Object.getOwnPropertySymbols(v).length === 0 &&
-        Object.entries(Object.getOwnPropertyDescriptors(v)).every(([k, d]) => !LONE.test(k) && d.enumerable === true && 'value' in d && fits(d.value, room - 1, path));
-    path.delete(v);
-    return ok;
-  };
-  return fits(value, depth, new Set()) ? JSON.stringify(value) : undefined;
-};
-
-// A count number: no sign, no fraction, no exponent, from 1 to 2^53 - 1.
-export const isCount = (literal: string): boolean => /^[1-9]\d{0,15}$/.test(literal) && Number(literal) <= Number.MAX_SAFE_INTEGER;

package/src/core/crypto/mlkem.ts

@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// ML-KEM-768 of FIPS 203 encapsulates. Web Crypto has none on every terrain,
-// so it comes from `@noble/post-quantum`.
-import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
-
-export const EK = 1184;
-export const CIPHERTEXT = 1088;
-
-export type Lock = { ek: Uint8Array; dk: Uint8Array };
-
-// KeyGen_internal(d, z): the lock from sixty-four drawn bytes, d then z.
-export const lockFrom = (d: Uint8Array, z: Uint8Array): Lock => {
-  const { publicKey, secretKey } = ml_kem768.keygen(Uint8Array.from([...d, ...z]));
-  return { ek: publicKey, dk: secretKey };
-};
-
-// Encaps_internal(ek, m), or null for an encapsulation key the modulus check
-// of FIPS 203 section 7.2 refuses.
-export const encapsulate = (ek: Uint8Array, m: Uint8Array): { ciphertext: Uint8Array; shared: Uint8Array } | null => {
-  if (ek.length !== EK) return null;
-  try {
-    const { cipherText, sharedSecret } = ml_kem768.encapsulate(ek, m);
-    return { ciphertext: cipherText, shared: sharedSecret };
-  } catch {
-    return null;
-  }
-};
-
-// Decapsulation is implicit rejection: a ciphertext for another lock gives a
-// shared secret that opens nothing.
-export const decapsulate = (dk: Uint8Array, ciphertext: Uint8Array): Uint8Array | null => {
-  if (ciphertext.length !== CIPHERTEXT) return null;
-  try {
-    return ml_kem768.decapsulate(ciphertext, dk);
-  } catch {
-    return null;
-  }
-};

package/src/core/crypto/subtle.ts

@@ -1,13 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Web Crypto, read at every use. A page on a plain http origin has `crypto`
-// without `subtle`, and a terrain may install it after this module loads.
-export const subtle = (): SubtleCrypto => {
-  const found = globalThis.crypto?.subtle;
-  if (!found) throw new Error('this terrain has no crypto.subtle: a ward needs a secure context');
-  return found;
-};
-
-export type Bytes = Uint8Array<ArrayBuffer>;
-
-// Web Crypto takes a buffer it owns, so every input is copied into one.
-export const own = (bytes: Uint8Array): Bytes => Uint8Array.from(bytes);

package/src/core/crypto/x25519.ts

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// X25519 agrees, by `@noble/curves` in every engine, since an engine's Web
-// Crypto may refuse a secret the curve takes. A secret is thirty-two bytes,
-// clamped by the function and never before.
-import { x25519 } from '@noble/curves/ed25519.js';
-import { zero } from './bytes.ts';
-
-export const x25519Public = async (secret: Uint8Array): Promise<Uint8Array> => {
-  if (secret.length !== 32) throw new TypeError('a secret is thirty-two bytes');
-  return x25519.getPublicKey(secret);
-};
-
-// The agreement, or null for a public key that takes no seal: one whose
-// agreement is thirty-two zero bytes.
-export const agree = async (secret: Uint8Array, pk: Uint8Array): Promise<Uint8Array | null> => {
-  if (pk.length !== 32 || secret.length !== 32) return null;
-  try {
-    const shared = x25519.getSharedSecret(secret, pk);
-    return zero(shared) ? null : shared;
-  } catch {
-    return null;
-  }
-};