@pezkuwi/util-crypto 14.0.12 → 14.0.14

package/src/hmac/shaAsU8a.spec.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { hexToU8a, stringToU8a } from '@pezkuwi/util';
-import { waitReady } from '@pezkuwi/wasm-crypto';
-
-import { perfWasm } from '../test/index.js';
-import { hmacShaAsU8a } from './index.js';
-
-describe('hmacShaAsU8a', (): void => {
-  beforeEach(async (): Promise<void> => {
-    await waitReady();
-  });
-
-  const key = stringToU8a('secret');
-  const data = stringToU8a('some message');
-  const output = {
-    256: hexToU8a(
-      '0xf28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7'
-    ),
-    512: hexToU8a(
-      '0x295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841'
-    )
-  };
-
-  for (const bitLength of [256, 512] as const) {
-    describe(`bitLength=${bitLength}`, (): void => {
-      for (const onlyJs of [false, true]) {
-        describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
-          it('returns an hex representation (string)', (): void => {
-            expect(
-              hmacShaAsU8a(key, data, bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-        });
-      }
-    });
-
-    perfWasm(`hmacShaAsU8a, bitLength=${bitLength}`, 16000, (input, onlyJs) =>
-      hmacShaAsU8a(input, input, bitLength, onlyJs)
-    );
-  }
-});

package/src/hmac/shaAsU8a.ts

@@ -1,48 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { hmac } from '@noble/hashes/hmac';
-import { sha256 } from '@noble/hashes/sha256';
-import { sha512 } from '@noble/hashes/sha512';
-
-import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
-import { hmacSha256, hmacSha512, isReady } from '@pezkuwi/wasm-crypto';
-
-const JS_HASH = {
-  256: sha256,
-  512: sha512
-};
-
-const WA_MHAC = {
-  256: hmacSha256,
-  512: hmacSha512
-};
-
-function createSha (bitLength: 256 | 512): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
-  return (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean): Uint8Array =>
-    hmacShaAsU8a(key, data, bitLength, onlyJs);
-}
-
-/**
- * @name hmacShaAsU8a
- * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
- */
-export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array {
-  const u8aKey = u8aToU8a(key);
-
-  return !hasBigInt || (!onlyJs && isReady())
-    ? WA_MHAC[bitLength](u8aKey, data)
-    : hmac(JS_HASH[bitLength], u8aKey, data);
-}
-
-/**
- * @name hmacSha256AsU8a
- * @description creates a Hmac Sha256 Uint8Array from the key & data
- */
-export const hmacSha256AsU8a = /*#__PURE__*/ createSha(256);
-
-/**
- * @name hmacSha512AsU8a
- * @description creates a Hmac Sha512 Uint8Array from the key & data
- */
-export const hmacSha512AsU8a = /*#__PURE__*/ createSha(512);

package/src/index.ts

@@ -1,6 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import './packageDetect.js';
-
-export * from './bundle.js';

package/src/json/constants.ts

@@ -1,11 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.js';
-
-export const ENCODING: EncryptedJsonEncoding[] = ['scrypt', 'xsalsa20-poly1305'];
-export const ENCODING_NONE: EncryptedJsonEncoding[] = ['none'];
-export const ENCODING_VERSION: EncryptedJsonVersion = '3';
-
-export const NONCE_LENGTH = 24;
-export const SCRYPT_LENGTH = 32 + (3 * 4);

package/src/json/decrypt.ts

@@ -1,25 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJson } from './types.js';
-
-import { hexToU8a, isHex } from '@pezkuwi/util';
-
-import { base64Decode } from '../base64/index.js';
-import { jsonDecryptData } from './decryptData.js';
-
-export function jsonDecrypt ({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array {
-  if (!encoded) {
-    throw new Error('No encrypted data available to decode');
-  }
-
-  return jsonDecryptData(
-    isHex(encoded)
-      ? hexToU8a(encoded)
-      : base64Decode(encoded),
-    passphrase,
-    Array.isArray(encoding.type)
-      ? encoding.type
-      : [encoding.type]
-  );
-}

package/src/json/decryptData.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJsonEncoding } from './types.js';
-
-import { stringToU8a, u8aFixLength } from '@pezkuwi/util';
-
-import { naclDecrypt } from '../nacl/index.js';
-import { scryptEncode, scryptFromU8a } from '../scrypt/index.js';
-import { ENCODING, NONCE_LENGTH, SCRYPT_LENGTH } from './constants.js';
-
-export function jsonDecryptData (encrypted?: Uint8Array | null, passphrase?: string | null, encType: EncryptedJsonEncoding[] = ENCODING): Uint8Array {
-  if (!encrypted) {
-    throw new Error('No encrypted data available to decode');
-  } else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
-    throw new Error('Password required to decode encrypted data');
-  }
-
-  let encoded: Uint8Array | null = encrypted;
-
-  if (passphrase) {
-    let password: Uint8Array;
-
-    if (encType.includes('scrypt')) {
-      const { params, salt } = scryptFromU8a(encrypted);
-
-      password = scryptEncode(passphrase, salt, params).password;
-      encrypted = encrypted.subarray(SCRYPT_LENGTH);
-    } else {
-      password = stringToU8a(passphrase);
-    }
-
-    encoded = naclDecrypt(
-      encrypted.subarray(NONCE_LENGTH),
-      encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(password, 256, true)
-    );
-  }
-
-  if (!encoded) {
-    throw new Error('Unable to decode using the supplied passphrase');
-  }
-
-  return encoded;
-}

package/src/json/encrypt.ts

@@ -1,25 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJson } from './types.js';
-
-import { u8aConcat } from '@pezkuwi/util';
-
-import { naclEncrypt } from '../nacl/index.js';
-import { scryptEncode, scryptToU8a } from '../scrypt/index.js';
-import { jsonEncryptFormat } from './encryptFormat.js';
-
-export function jsonEncrypt (data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson {
-  let isEncrypted = false;
-  let encoded = data;
-
-  if (passphrase) {
-    const { params, password, salt } = scryptEncode(passphrase);
-    const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
-
-    isEncrypted = true;
-    encoded = u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
-  }
-
-  return jsonEncryptFormat(encoded, contentType, isEncrypted);
-}

package/src/json/encryptFormat.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJson } from './types.js';
-
-import { base64Encode } from '../base64/index.js';
-import { ENCODING, ENCODING_NONE, ENCODING_VERSION } from './constants.js';
-
-export function jsonEncryptFormat (encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson {
-  return {
-    encoded: base64Encode(encoded),
-    encoding: {
-      content: contentType,
-      type: isEncrypted
-        ? ENCODING
-        : ENCODING_NONE,
-      version: ENCODING_VERSION
-    }
-  };
-}

package/src/json/index.ts

@@ -1,7 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { jsonDecrypt } from './decrypt.js';
-export { jsonDecryptData } from './decryptData.js';
-export { jsonEncrypt } from './encrypt.js';
-export { jsonEncryptFormat } from './encryptFormat.js';

package/src/json/types.ts

@@ -1,22 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
-
-export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
-
-export interface EncryptedJsonDescriptor {
-  /** Descriptor for the content */
-  content: string[];
-  /** The encoding (in current/latest versions this is always an array) */
-  type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
-  /** The version of encoding applied */
-  version: EncryptedJsonVersion;
-}
-
-export interface EncryptedJson {
-  /** The encoded string */
-  encoded: string;
-  /** The encoding used */
-  encoding: EncryptedJsonDescriptor;
-}

package/src/keccak/asHex.spec.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { waitReady } from '@pezkuwi/wasm-crypto';
-
-import { keccakAsHex } from './index.js';
-
-const BITS: (256 | 512)[] = [256, 512];
-
-const value = 'test';
-const result = {
-  256: '9c22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658',
-  512: '1e2e9fc2002b002d75198b7503210c05a1baac4560916a3c6d93bcce3a50d7f00fd395bf1647b9abb8d1afcc9c76c289b0c9383ba386a956da4b38934417789e'
-};
-
-describe('keccakAsHex', (): void => {
-  beforeEach(async (): Promise<void> => {
-    await waitReady();
-  });
-
-  BITS.forEach((bitLength): void => {
-    it('returns a prefixed hex representation', (): void => {
-      expect(
-        keccakAsHex(value, bitLength)
-      ).toEqual(`0x${result[bitLength]}`);
-    });
-  });
-});

package/src/keccak/asU8a.spec.ts

@@ -1,56 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { hexToU8a, stringToU8a } from '@pezkuwi/util';
-import { waitReady } from '@pezkuwi/wasm-crypto';
-
-import { perfWasm } from '../test/index.js';
-import { keccakAsU8a } from './index.js';
-
-describe('keccakAsU8a', (): void => {
-  beforeEach(async (): Promise<void> => {
-    await waitReady();
-  });
-
-  const input = 'test value';
-  const output = {
-    256: hexToU8a(
-      '0x2d07364b5c231c56ce63d49430e085ea3033c750688ba532b24029124c26ca5e'
-    ),
-    512: hexToU8a(
-      '0xc1b50cc57f85ccd968a9d7c7a809dcebd140a548c8e0b67f3afcdd6fc14cca2b1d04187aef24ba0081b74f2ec362431e425760febe94a5607790854cafe5b197'
-    )
-  };
-
-  for (const bitLength of [256, 512] as const) {
-    describe(`bitLength=${bitLength}`, (): void => {
-      for (const onlyJs of [false, true]) {
-        describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
-          it('returns an hex representation (string)', (): void => {
-            expect(
-              keccakAsU8a(input, bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-
-          it('returns an hex representation (Buffer)', (): void => {
-            expect(
-              keccakAsU8a(Buffer.from(input), bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-
-          it('returns an hex representation (Uint8Array)', (): void => {
-            expect(
-              keccakAsU8a(stringToU8a(input), bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-        });
-      }
-
-      perfWasm(`keccakAsU8a, bitLength=${bitLength}`, 128000, (input, onlyJs) =>
-        keccakAsU8a(input, bitLength, onlyJs)
-      );
-    });
-  }
-});

package/src/keccak/asU8a.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { keccak_256 as keccak256Js, keccak_512 as keccak512Js } from '@noble/hashes/sha3';
-
-import { keccak256, keccak512 } from '@pezkuwi/wasm-crypto';
-
-import { createAsHex, createBitHasher, createDualHasher } from '../helpers.js';
-
-/**
- * @name keccakAsU8a
- * @summary Creates a keccak Uint8Array from the input.
- * @description
- * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
- * @example
- * <BR>
- *
- * ```javascript
- * import { keccakAsU8a } from '@pezkuwi/util-crypto';
- *
- * keccakAsU8a('123'); // => Uint8Array
- * ```
- */
-export const keccakAsU8a = /*#__PURE__*/ createDualHasher(
-  { 256: keccak256, 512: keccak512 },
-  { 256: keccak256Js, 512: keccak512Js }
-);
-
-/**
- * @name keccak256AsU8a
- * @description Creates a keccak256 Uint8Array from the input.
- */
-export const keccak256AsU8a = /*#__PURE__*/ createBitHasher(256, keccakAsU8a);
-
-/**
- * @name keccak512AsU8a
- * @description Creates a keccak512 Uint8Array from the input.
- */
-export const keccak512AsU8a = /*#__PURE__*/ createBitHasher(512, keccakAsU8a);
-
-/**
- * @name keccakAsHex
- * @description Creates a keccak hex string from the input.
- */
-export const keccakAsHex = /*#__PURE__*/ createAsHex(keccakAsU8a);

package/src/keccak/index.ts

@@ -1,8 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @summary Create Keccak256/512 values as hex & Uint8Array output
- */
-
-export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

package/src/key/DeriveJunction.ts

@@ -1,79 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { BN, bnToU8a, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from '@pezkuwi/util';
-
-import { blake2AsU8a } from '../blake2/asU8a.js';
-import { BN_LE_256_OPTS } from '../bn.js';
-
-const RE_NUMBER = /^\d+$/;
-
-const JUNCTION_ID_LEN = 32;
-
-export class DeriveJunction {
-  readonly #chainCode: Uint8Array = new Uint8Array(32);
-
-  #isHard = false;
-
-  public static from (value: string): DeriveJunction {
-    const result = new DeriveJunction();
-    const [code, isHard] = value.startsWith('/')
-      ? [value.substring(1), true]
-      : [value, false];
-
-    result.soft(
-      RE_NUMBER.test(code)
-        ? new BN(code, 10)
-        : code
-    );
-
-    return isHard
-      ? result.harden()
-      : result;
-  }
-
-  public get chainCode (): Uint8Array {
-    return this.#chainCode;
-  }
-
-  public get isHard (): boolean {
-    return this.#isHard;
-  }
-
-  public get isSoft (): boolean {
-    return !this.#isHard;
-  }
-
-  public hard (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
-    return this.soft(value).harden();
-  }
-
-  public harden (): DeriveJunction {
-    this.#isHard = true;
-
-    return this;
-  }
-
-  public soft (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
-    if (isNumber(value) || isBn(value) || isBigInt(value)) {
-      return this.soft(bnToU8a(value, BN_LE_256_OPTS));
-    } else if (isHex(value)) {
-      return this.soft(hexToU8a(value));
-    } else if (isString(value)) {
-      return this.soft(compactAddLength(stringToU8a(value)));
-    } else if (value.length > JUNCTION_ID_LEN) {
-      return this.soft(blake2AsU8a(value));
-    }
-
-    this.#chainCode.fill(0);
-    this.#chainCode.set(value, 0);
-
-    return this;
-  }
-
-  public soften (): DeriveJunction {
-    this.#isHard = false;
-
-    return this;
-  }
-}

package/src/key/extractPath.spec.ts

@@ -1,51 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { ExtractResult } from './extractPath.js';
-
-import { keyExtractPath } from './extractPath.js';
-
-describe('keyExtractPath', (): void => {
-  it('extracts properly from soft', (): void => {
-    const test = keyExtractPath('/1');
-
-    expect(test.parts).toEqual(['/1']);
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(false);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('extracts properly from hard', (): void => {
-    const test = keyExtractPath('//1');
-
-    expect(test.parts).toEqual(['//1']);
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('extracts properly from hard/soft', (): void => {
-    const test = keyExtractPath('//1/2');
-
-    expect(test.parts).toEqual(['//1', '/2']);
-    expect(test.path.length).toEqual(2);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    expect(test.path[1].isHard).toEqual(false);
-    expect(test.path[1].chainCode).toEqual(Uint8Array.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('does not extract from invalid paths (1)', (): void => {
-    expect(
-      (): ExtractResult => keyExtractPath('1/2')
-    ).toThrow(/does not match input/);
-  });
-
-  it('does not extract from invalid paths (2)', (): void => {
-    expect(
-      (): ExtractResult => keyExtractPath('hello')
-    ).toThrow(/does not match input/);
-  });
-});

package/src/key/extractPath.ts

@@ -1,37 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { DeriveJunction } from './DeriveJunction.js';
-
-const RE_JUNCTION = /\/(\/?)([^/]+)/g;
-
-export interface ExtractResult {
-  parts: string[] | null;
-  path: DeriveJunction[];
-}
-
-/**
- * @description Extract derivation junctions from the supplied path
- */
-export function keyExtractPath (derivePath: string): ExtractResult {
-  const parts = derivePath.match(RE_JUNCTION);
-  const path: DeriveJunction[] = [];
-  let constructed = '';
-
-  if (parts) {
-    constructed = parts.join('');
-
-    for (const p of parts) {
-      path.push(DeriveJunction.from(p.substring(1)));
-    }
-  }
-
-  if (constructed !== derivePath) {
-    throw new Error(`Re-constructed path "${constructed}" does not match input`);
-  }
-
-  return {
-    parts,
-    path
-  };
-}