@pezkuwi/util-crypto 14.0.13 → 14.0.14

package/build-deno/nacl/tweetnacl.ts

@@ -1,344 +0,0 @@
-
-/* eslint-disable brace-style,camelcase,comma-spacing,curly,one-var,padding-line-between-statements,space-infix-ops */
-
-
-
-
-
-
-function L32 (x: number, c: number): number { return (x << c) | (x >>> (32 - c)); }
-
-function ld32 (x: Uint8Array, i: number): number {
-  let u = x[i+3] & 0xff;
-  u = (u<<8)|(x[i+2] & 0xff);
-  u = (u<<8)|(x[i+1] & 0xff);
-  return (u<<8)|(x[i+0] & 0xff);
-}
-
-
-function st32 (x: Uint8Array, j: number, u: number): void {
-  for (let i = 0; i < 4; i++) { x[j+i] = u & 255; u >>>= 8; }
-}
-
-
-function vn (x: Uint8Array, xi: number, y: Uint8Array, yi: number, n: number): number {
-  let d = 0;
-  for (let i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];
-  return (1 & ((d - 1) >>> 8)) - 1;
-}
-
-
-
-function core (out: Uint8Array, inp: Uint8Array, k: Uint8Array, c: Uint8Array, h: boolean): void {
-  const w = new Uint32Array(16), x = new Uint32Array(16), y = new Uint32Array(16), t = new Uint32Array(4);
-  let i, j, m;
-
-  for (i = 0; i < 4; i++) {
-    x[5*i] = ld32(c, 4*i);
-    x[1+i] = ld32(k, 4*i);
-    x[6+i] = ld32(inp, 4*i);
-    x[11+i] = ld32(k, 16+4*i);
-  }
-
-  for (i = 0; i < 16; i++) y[i] = x[i];
-
-  for (i = 0; i < 20; i++) {
-    for (j = 0; j < 4; j++) {
-      for (m = 0; m < 4; m++) t[m] = x[(5*j+4*m)%16];
-      t[1] ^= L32((t[0]+t[3])|0, 7);
-      t[2] ^= L32((t[1]+t[0])|0, 9);
-      t[3] ^= L32((t[2]+t[1])|0,13);
-      t[0] ^= L32((t[3]+t[2])|0,18);
-      for (m = 0; m < 4; m++) w[4*j+(j+m)%4] = t[m];
-    }
-    for (m = 0; m < 16; m++) x[m] = w[m];
-  }
-
-  if (h) {
-    for (i = 0; i < 16; i++) x[i] = (x[i] + y[i]) | 0;
-    for (i = 0; i < 4; i++) {
-      x[5*i] = (x[5*i] - ld32(c, 4*i)) | 0;
-      x[6+i] = (x[6+i] - ld32(inp, 4*i)) | 0;
-    }
-    for (i = 0; i < 4; i++) {
-      st32(out,4*i,x[5*i]);
-      st32(out,16+4*i,x[6+i]);
-    }
-  } else {
-    for (i = 0; i < 16; i++) st32(out, 4 * i, (x[i] + y[i]) | 0);
-  }
-}
-
-
-
-const sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
-
-function crypto_stream_salsa20_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, b: number, n: Uint8Array, k: Uint8Array): number {
-  const z = new Uint8Array(16), x = new Uint8Array(64);
-  let u, i;
-  if (!b) return 0;
-  for (i = 0; i < 16; i++) z[i] = 0;
-  for (i = 0; i < 8; i++) z[i] = n[i];
-  while (b >= 64) {
-    core(x, z, k, sigma, false);
-    for (i = 0; i < 64; i++) c[cpos+i] = (m?m[mpos+i]:0) ^ x[i];
-    u = 1;
-    for (i = 8; i < 16; i++) {
-      u = u + (z[i] & 0xff) | 0;
-      z[i] = u & 0xff;
-      u >>>= 8;
-    }
-    b -= 64;
-    cpos += 64;
-    if (m) mpos += 64;
-  }
-  if (b > 0) {
-    core(x, z, k, sigma, false);
-    for (i = 0; i < b; i++) c[cpos+i] = (m?m[mpos+i]:0) ^ x[i];
-  }
-  return 0;
-}
-
-
-
-function crypto_stream_xor (c: Uint8Array, cpos: number, m: Uint8Array | null, mpos: number, d: number, n: Uint8Array, k: Uint8Array): number {
-  const s = new Uint8Array(32);
-  core(s, n, k, sigma, true);
-  return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, n.subarray(16), s);
-}
-
-function add1305 (h: Uint32Array, c: Uint32Array): void {
-  let u = 0;
-  for (let j = 0; j < 17; j++) {
-    u = (u + ((h[j] + c[j]) | 0)) | 0;
-    h[j] = u & 255;
-    u >>>= 8;
-  }
-}
-
-const minusp = new Uint32Array([5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252]);
-
-function crypto_onetimeauth (out: Uint8Array, outpos: number, m: Uint8Array, mpos: number, n: number, k: Uint8Array): number {
-  let i, j, u;
-  const x = new Uint32Array(17), r = new Uint32Array(17), h = new Uint32Array(17), c = new Uint32Array(17), g = new Uint32Array(17);
-  for (j = 0; j < 17; j++) r[j]=h[j]=0;
-  for (j = 0; j < 16; j++) r[j]=k[j];
-  r[3]&=15;
-  r[4]&=252;
-  r[7]&=15;
-  r[8]&=252;
-  r[11]&=15;
-  r[12]&=252;
-  r[15]&=15;
-
-  while (n > 0) {
-    for (j = 0; j < 17; j++) c[j] = 0;
-    for (j = 0; (j < 16) && (j < n); ++j) c[j] = m[mpos+j];
-    c[j] = 1;
-    mpos += j; n -= j;
-    add1305(h,c);
-    for (i = 0; i < 17; i++) {
-      x[i] = 0;
-      for (j = 0; j < 17; j++) x[i] = (x[i] + (h[j] * ((j <= i) ? r[i - j] : ((320 * r[i + 17 - j])|0))) | 0) | 0;
-    }
-    for (i = 0; i < 17; i++) h[i] = x[i];
-    u = 0;
-    for (j = 0; j < 16; j++) {
-      u = (u + h[j]) | 0;
-      h[j] = u & 255;
-      u >>>= 8;
-    }
-    u = (u + h[16]) | 0; h[16] = u & 3;
-    u = (5 * (u >>> 2)) | 0;
-    for (j = 0; j < 16; j++) {
-      u = (u + h[j]) | 0;
-      h[j] = u & 255;
-      u >>>= 8;
-    }
-    u = (u + h[16]) | 0; h[16] = u;
-  }
-
-  for (j = 0; j < 17; j++) g[j] = h[j];
-  add1305(h,minusp);
-  const s = (-(h[16] >>> 7) | 0);
-  for (j = 0; j < 17; j++) h[j] ^= s & (g[j] ^ h[j]);
-
-  for (j = 0; j < 16; j++) c[j] = k[j + 16];
-  c[16] = 0;
-  add1305(h,c);
-  for (j = 0; j < 16; j++) out[outpos+j] = h[j];
-  return 0;
-}
-
-function crypto_onetimeauth_verify (h: Uint8Array, hpos: number, m: Uint8Array, mpos: number, n: number, k: Uint8Array) {
-  const x = new Uint8Array(16);
-  crypto_onetimeauth(x,0,m,mpos,n,k);
-  return vn(h, hpos, x, 0, 16);
-}
-
-function crypto_secretbox (c: Uint8Array, m: Uint8Array, d: number, n: Uint8Array, k: Uint8Array) {
-  if (d < 32) return -1;
-  crypto_stream_xor(c,0,m,0,d,n,k);
-  crypto_onetimeauth(c, 16, c, 32, d - 32, c);
-  for (let i = 0; i < 16; i++) c[i] = 0;
-  return 0;
-}
-
-function crypto_secretbox_open (m: Uint8Array, c: Uint8Array, d: number, n: Uint8Array, k: Uint8Array): number {
-  const x = new Uint8Array(32);
-  if (d < 32) return -1;
-  crypto_stream_xor(x, 0, null, 0, 32, n, k);
-  if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;
-  crypto_stream_xor(m,0,c,0,d,n,k);
-  for (let i = 0; i < 32; i++) m[i] = 0;
-  return 0;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-const crypto_secretbox_KEYBYTES = 32;
-const crypto_secretbox_NONCEBYTES = 24;
-const crypto_secretbox_ZEROBYTES = 32;
-const crypto_secretbox_BOXZEROBYTES = 16;
-
-
-
-
-
-function checkLengths (k: Uint8Array, n: Uint8Array): void {
-  if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');
-  if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');
-}
-
-
-function checkArrayTypes (...args: unknown[]): void {
-  for (let i = 0, count = args.length; i < count; i++) {
-    if (!(args[i] instanceof Uint8Array))
-      throw new TypeError('unexpected type, use Uint8Array');
-  }
-}
-
-
-
-export function naclSecretbox (msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array {
-  checkArrayTypes(msg, nonce, key);
-  checkLengths(key, nonce);
-  const m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
-  const c = new Uint8Array(m.length);
-  for (let i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];
-  crypto_secretbox(c, m, m.length, nonce, key);
-  return c.subarray(crypto_secretbox_BOXZEROBYTES);
-}
-
-export function naclSecretboxOpen (box: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array | null {
-  checkArrayTypes(box, nonce, key);
-  checkLengths(key, nonce);
-  const c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
-  const m = new Uint8Array(c.length);
-  for (let i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];
-  if (c.length < 32) return null;
-  if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null;
-  return m.subarray(crypto_secretbox_ZEROBYTES);
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

package/build-deno/networks.ts

@@ -1,2 +0,0 @@
-
-export { allNetworks, availableNetworks, selectableNetworks } from 'https://deno.land/x/pezkuwi/networks/mod.ts';

package/build-deno/packageDetect.ts

@@ -1,10 +0,0 @@
-
-
-import { packageInfo as netInfo } from 'https://deno.land/x/pezkuwi/networks/packageInfo.ts';
-import { detectPackage } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { packageInfo as utilInfo } from 'https://deno.land/x/pezkuwi/util/packageInfo.ts';
-import { packageInfo as randomInfo } from 'https://deno.land/x/pezkuwi/x-randomvalues/mod.ts';
-
-import { packageInfo } from './packageInfo.ts';
-
-detectPackage(packageInfo, null, [netInfo, randomInfo, utilInfo]);

package/build-deno/packageInfo.ts

@@ -1,3 +0,0 @@
-
-
-export const packageInfo = { name: '@pezkuwi/util-crypto', path: new URL(import.meta.url).pathname, type: 'deno', version: '14.0.13' };

package/build-deno/pbkdf2/encode.ts

@@ -1,27 +0,0 @@
-
-import { pbkdf2 as pbkdf2Js } from 'https://esm.sh/@noble/hashes@1.3.3/pbkdf2.js';
-import { sha512 } from 'https://esm.sh/@noble/hashes@1.3.3/sha512.js';
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, pbkdf2 } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { randomAsU8a } from '../random/asU8a.ts';
-
-interface Result {
-  password: Uint8Array;
-  rounds: number;
-  salt: Uint8Array;
-}
-
-export function pbkdf2Encode (passphrase?: string | Uint8Array, salt: Uint8Array = randomAsU8a(), rounds = 2048, onlyJs?: boolean): Result {
-  const u8aPass = u8aToU8a(passphrase);
-  const u8aSalt = u8aToU8a(salt);
-
-  return {
-    password: !hasBigInt || (!onlyJs && isReady())
-      ? pbkdf2(u8aPass, u8aSalt, rounds)
-      : pbkdf2Js(sha512, u8aPass, u8aSalt, { c: rounds, dkLen: 64 }),
-    rounds,
-    salt
-  };
-}

package/build-deno/pbkdf2/index.ts

@@ -1,2 +0,0 @@
-
-export { pbkdf2Encode } from './encode.ts';

package/build-deno/random/asNumber.ts

@@ -1,26 +0,0 @@
-
-import { BN, hexToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { randomAsHex } from './asU8a.ts';
-
-const BN_53 = new BN(0b11111111111111111111111111111111111111111111111111111);
-
-/**
- * @name randomAsNumber
- * @summary Creates a random number from random bytes.
- * @description
- * Returns a random number generated from the secure bytes.
- * @example
- * <BR>
- *
- * ```javascript
- * import { randomAsNumber } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * randomAsNumber(); // => <random number>
- * ```
- */
-export function randomAsNumber (): number {
-  return hexToBn(
-    randomAsHex(8)
-  ).and(BN_53).toNumber();
-}

package/build-deno/random/asU8a.ts

@@ -1,28 +0,0 @@
-
-import { getRandomValues } from 'https://deno.land/x/pezkuwi/x-randomvalues/mod.ts';
-
-import { createAsHex } from '../helpers.ts';
-
-/**
- * @name randomAsU8a
- * @summary Creates a Uint8Array filled with random bytes.
- * @description
- * Returns a `Uint8Array` with the specified (optional) length filled with random bytes.
- * @example
- * <BR>
- *
- * ```javascript
- * import { randomAsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * randomAsU8a(); // => Uint8Array([...])
- * ```
- */
-export function randomAsU8a (length = 32): Uint8Array {
-  return getRandomValues(new Uint8Array(length));
-}
-
-/**
- * @name randomAsHex
- * @description Creates a hex string filled with random bytes.
- */
-export const randomAsHex = /*#__PURE__*/ createAsHex(randomAsU8a);

package/build-deno/random/index.ts

@@ -1,7 +0,0 @@
-
-/**
- * @summary Returns a sequence of secure random bytes in a variety of formats
- */
-
-export { randomAsNumber } from './asNumber.ts';
-export { randomAsHex, randomAsU8a } from './asU8a.ts';

package/build-deno/scrypt/defaults.ts

@@ -1,17 +0,0 @@
-
-import type { ScryptParams } from './types.ts';
-
-export const ALLOWED_PARAMS: ScryptParams[] = [
-  { N: 1 << 13, p: 10, r: 8 },
-  { N: 1 << 14, p: 5, r: 8 },
-  { N: 1 << 15, p: 3, r: 8 },
-  { N: 1 << 15, p: 1, r: 8 },
-  { N: 1 << 16, p: 2, r: 8 },
-  { N: 1 << 17, p: 1, r: 8 }
-];
-
-export const DEFAULT_PARAMS: ScryptParams = {
-  N: 1 << 17,
-  p: 1,
-  r: 8
-};

package/build-deno/scrypt/encode.ts

@@ -1,28 +0,0 @@
-
-import type { ScryptParams } from './types.ts';
-
-import { scrypt as scryptJs } from 'https://esm.sh/@noble/hashes@1.3.3/scrypt.js';
-
-import { hasBigInt, objectSpread, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, scrypt } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { randomAsU8a } from '../random/asU8a.ts';
-import { DEFAULT_PARAMS } from './defaults.ts';
-
-interface Result {
-  params: ScryptParams,
-  password: Uint8Array;
-  salt: Uint8Array;
-}
-
-export function scryptEncode (passphrase?: string | Uint8Array, salt = randomAsU8a(), params = DEFAULT_PARAMS, onlyJs?: boolean): Result {
-  const u8a = u8aToU8a(passphrase);
-
-  return {
-    params,
-    password: !hasBigInt || (!onlyJs && isReady())
-      ? scrypt(u8a, salt, Math.log2(params.N), params.r, params.p)
-      : scryptJs(u8a, salt, objectSpread({ dkLen: 64 }, params)),
-    salt
-  };
-}

package/build-deno/scrypt/fromU8a.ts

@@ -1,42 +0,0 @@
-
-import type { ScryptParams } from './types.ts';
-
-import { u8aToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { BN_LE_OPTS } from '../bn.ts';
-import { ALLOWED_PARAMS } from './defaults.ts';
-
-interface Result {
-  params: ScryptParams,
-  salt: Uint8Array;
-}
-
-export function scryptFromU8a (data: Uint8Array): Result {
-  if (!(data instanceof Uint8Array)) {
-    throw new Error('Expected input to be a Uint8Array');
-  }
-
-  // Ensure the input is exactly 44 bytes: 32 for salt + 3 * 4 for N, p, r
-  if (data.length < 32 + 12) {
-    throw new Error(`Invalid input length: expected 44 bytes, found ${data.length}`);
-  }
-
-  const salt = data.subarray(0, 32);
-  const N = u8aToBn(data.subarray(32, 36), BN_LE_OPTS).toNumber();
-  const p = u8aToBn(data.subarray(36, 40), BN_LE_OPTS).toNumber();
-  const r = u8aToBn(data.subarray(40, 44), BN_LE_OPTS).toNumber();
-
-  if (N > (1 << 20) || p > 4 || r > 16) {
-    throw new Error('Scrypt parameters exceed safe limits');
-  }
-
-  const isAllowed = ALLOWED_PARAMS.some((preset) =>
-    preset.N === N && preset.p === p && preset.r === r
-  );
-
-  if (!isAllowed) {
-    throw new Error('Invalid injected scrypt params found');
-  }
-
-  return { params: { N, p, r }, salt };
-}

package/build-deno/scrypt/index.ts

@@ -1,4 +0,0 @@
-
-export { scryptEncode } from './encode.ts';
-export { scryptFromU8a } from './fromU8a.ts';
-export { scryptToU8a } from './toU8a.ts';

package/build-deno/scrypt/toU8a.ts

@@ -1,15 +0,0 @@
-
-import type { ScryptParams } from './types.ts';
-
-import { bnToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { BN_LE_32_OPTS } from '../bn.ts';
-
-export function scryptToU8a (salt: Uint8Array, { N, p, r }: ScryptParams): Uint8Array {
-  return u8aConcat(
-    salt,
-    bnToU8a(N, BN_LE_32_OPTS),
-    bnToU8a(p, BN_LE_32_OPTS),
-    bnToU8a(r, BN_LE_32_OPTS)
-  );
-}

package/build-deno/scrypt/types.ts

@@ -1,7 +0,0 @@
-
-/** The params that control scrypt generation */
-export interface ScryptParams {
-  N: number;
-  p: number;
-  r: number;
-}

package/build-deno/secp256k1/compress.ts

@@ -1,19 +0,0 @@
-
-import { secp256k1 } from 'https://esm.sh/@noble/curves@1.3.0/secp256k1.js';
-
-import { hasBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, secp256k1Compress as wasm } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uint8Array {
-  if (![33, 65].includes(publicKey.length)) {
-    throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
-  }
-
-  if (publicKey.length === 33) {
-    return publicKey;
-  }
-
-  return !hasBigInt || (!onlyJs && isReady())
-    ? wasm(publicKey)
-    : secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(true);
-}

package/build-deno/secp256k1/deriveHard.ts

@@ -1,15 +0,0 @@
-
-import { compactAddLength, isU8a, stringToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../blake2/asU8a.ts';
-
-const HDKD = compactAddLength(stringToU8a('Secp256k1HDKD'));
-
-export function secp256k1DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
-  if (!isU8a(chainCode) || chainCode.length !== 32) {
-    throw new Error('Invalid chainCode passed to derive');
-  }
-
-  // NOTE This is specific to the Substrate HDD derivation, so always use the blake2 hasher
-  return blake2AsU8a(u8aConcat(HDKD, seed, chainCode), 256);
-}

package/build-deno/secp256k1/expand.ts

@@ -1,28 +0,0 @@
-
-import { secp256k1 } from 'https://esm.sh/@noble/curves@1.3.0/secp256k1.js';
-
-import { bnToU8a, hasBigInt, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, secp256k1Expand as wasm } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { BN_BE_256_OPTS } from '../bn.ts';
-
-export function secp256k1Expand (publicKey: Uint8Array, onlyJs?: boolean): Uint8Array {
-  if (![33, 65].includes(publicKey.length)) {
-    throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
-  }
-
-  if (publicKey.length === 65) {
-    return publicKey.subarray(1);
-  }
-
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    return wasm(publicKey).subarray(1);
-  }
-
-  const { px, py } = secp256k1.ProjectivePoint.fromHex(publicKey);
-
-  return u8aConcat(
-    bnToU8a(px, BN_BE_256_OPTS),
-    bnToU8a(py, BN_BE_256_OPTS)
-  );
-}

package/build-deno/secp256k1/hasher.ts

@@ -1,11 +0,0 @@
-
-import type { HashType } from './types.ts';
-
-import { blake2AsU8a } from '../blake2/index.ts';
-import { keccakAsU8a } from '../keccak/index.ts';
-
-export function hasher (hashType: HashType, data: Uint8Array | string, onlyJs?: boolean): Uint8Array {
-  return hashType === 'keccak'
-    ? keccakAsU8a(data, undefined, onlyJs)
-    : blake2AsU8a(data, undefined, undefined, onlyJs);
-}

package/build-deno/secp256k1/index.ts

@@ -1,8 +0,0 @@
-
-export { secp256k1Compress } from './compress.ts';
-export { secp256k1Expand } from './expand.ts';
-export { secp256k1PairFromSeed } from './pair/fromSeed.ts';
-export { secp256k1Recover } from './recover.ts';
-export { secp256k1Sign } from './sign.ts';
-export { secp256k1PrivateKeyTweakAdd } from './tweakAdd.ts';
-export { secp256k1Verify } from './verify.ts';