toolcraft 0.0.749 → 0.0.751

package/node_modules/@noble/hashes/hkdf.d.ts

@@ -0,0 +1,70 @@
+/**
+ * HKDF (RFC 5869): extract + expand in one step.
+ * See {@link https://soatok.blog/2021/11/17/understanding-hkdf/}.
+ * @module
+ */
+import { type _HMAC } from './hmac.ts';
+import { type CHash, type TArg, type TRet } from './utils.ts';
+/**
+ * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * Local validation only checks `hash`; `ikm` / `salt` byte validation is delegated to `hmac()`.
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @returns Pseudorandom key derived from input keying material.
+ * @example
+ * Run the HKDF extract step.
+ * ```ts
+ * import { extract } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * extract(sha256, new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6]));
+ * ```
+ */
+export declare function extract(hash: TArg<CHash>, ikm: TArg<Uint8Array>, salt?: TArg<Uint8Array>): TRet<Uint8Array>;
+/**
+ * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param prk - a pseudorandom key of at least HashLen octets
+ *   (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
+ * @param _recycled - Internal destroyed extract hashes owned by the combined `hkdf()` call.
+ * @returns Output keying material with the requested length.
+ * @throws If the requested output length exceeds the HKDF limit
+ *   for the selected hash. {@link Error}
+ * @example
+ * Run the HKDF expand step.
+ * ```ts
+ * import { expand } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * expand(sha256, new Uint8Array(32), new Uint8Array([1, 2, 3]), 16);
+ * ```
+ */
+export declare function expand(hash: TArg<CHash>, prk: TArg<Uint8Array>, info?: TArg<Uint8Array>, length?: number, _recycled?: _HMAC<any>): TRet<Uint8Array>;
+/**
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information bytes
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
+ * @returns Output keying material derived from the input key.
+ * @throws If the requested output length exceeds the HKDF limit
+ *   for the selected hash. {@link Error}
+ * @example
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * ```ts
+ * import { hkdf } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * import { randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = utf8ToBytes('application-key');
+ * const okm = hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export declare const hkdf: (hash: TArg<CHash>, ikm: TArg<Uint8Array>, salt: TArg<Uint8Array | undefined>, info: TArg<Uint8Array | undefined>, length: number) => TRet<Uint8Array>;

package/node_modules/@noble/hashes/hkdf.js

@@ -0,0 +1,152 @@
+/**
+ * HKDF (RFC 5869): extract + expand in one step.
+ * See {@link https://soatok.blog/2021/11/17/understanding-hkdf/}.
+ * @module
+ */
+import { hmac } from "./hmac.js";
+import { abytes, ahash, anumber, clean } from "./utils.js";
+/**
+ * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * Local validation only checks `hash`; `ikm` / `salt` byte validation is delegated to `hmac()`.
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @returns Pseudorandom key derived from input keying material.
+ * @example
+ * Run the HKDF extract step.
+ * ```ts
+ * import { extract } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * extract(sha256, new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6]));
+ * ```
+ */
+export function extract(hash, ikm, salt) {
+    ahash(hash);
+    // NOTE: some libraries treat zero-length array as 'not provided';
+    // we don't, since we have undefined as 'not provided'
+    // https://github.com/RustCrypto/KDFs/issues/15
+    if (salt === undefined)
+        salt = new Uint8Array(hash.outputLen);
+    return hmac(hash, salt, ikm);
+}
+// Shared mutable scratch byte for the RFC 5869 block counter `N`.
+// Safe to reuse because `expand()` is synchronous and resets it with `clean(...)` before returning.
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
+// Shared RFC 5869 empty string for both `info === undefined` and the first-block `T(0)` input.
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+/**
+ * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param prk - a pseudorandom key of at least HashLen octets
+ *   (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
+ * @param _recycled - Internal destroyed extract hashes owned by the combined `hkdf()` call.
+ * @returns Output keying material with the requested length.
+ * @throws If the requested output length exceeds the HKDF limit
+ *   for the selected hash. {@link Error}
+ * @example
+ * Run the HKDF expand step.
+ * ```ts
+ * import { expand } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * expand(sha256, new Uint8Array(32), new Uint8Array([1, 2, 3]), 16);
+ * ```
+ */
+export function expand(hash, prk, info, length = 32, _recycled) {
+    ahash(hash);
+    anumber(length, 'length');
+    abytes(prk, undefined, 'prk');
+    const olen = hash.outputLen;
+    // RFC 5869 §2.3: PRK is "a pseudorandom key of at least HashLen octets".
+    if (prk.length < olen)
+        throw new Error('"prk" must be at least HashLen octets');
+    // RFC 5869 §2.3 only bounds `L` by `<= 255*HashLen`; `L=0` is valid and yields empty OKM.
+    if (length > 255 * olen)
+        throw new Error('Length must be <= 255*HashLen');
+    const blocks = Math.ceil(length / olen);
+    if (info === undefined)
+        info = EMPTY_BUFFER;
+    else
+        abytes(info, undefined, 'info');
+    if (!blocks) {
+        if (_recycled)
+            clean(prk); // Full hkdf() owns this intermediate PRK.
+        return new Uint8Array();
+    }
+    // first L(ength) octets of T
+    // The private PRK can become both T and a one-block result after HMAC consumes the key.
+    const okm = _recycled && blocks === 1 ? prk : new Uint8Array(blocks * olen);
+    const { iHash, oHash } = hmac.create(hash, prk);
+    // Driving them directly also skips `_HMAC.digestInto`'s per-digest destroy.
+    const T = _recycled ? prk : new Uint8Array(olen);
+    // Full hkdf() donates one destroyed extract hash; standalone creates one alternating worker.
+    const worker = blocks > 1 ? _recycled?.iHash || hash.create() : undefined;
+    for (let counter = 0; counter < blocks - 1; counter++) {
+        HKDF_COUNTER[0] = counter + 1;
+        const iWork = iHash._cloneInto(worker);
+        // T(0) = empty string (zero length)
+        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
+        if (counter)
+            iWork.update(T);
+        iWork.update(info).update(HKDF_COUNTER).digestInto(T);
+        oHash._cloneInto(worker).update(T).digestInto(T);
+        okm.set(T, olen * counter);
+    }
+    // Midstates are key-equivalent: they allow computing HMAC(prk, ...) for any message.
+    HKDF_COUNTER[0] = blocks; // Final block consumes them; retain worker for cleanup.
+    if (blocks > 1)
+        iHash.update(T);
+    iHash.update(info).update(HKDF_COUNTER).digestInto(T);
+    oHash.update(T).digestInto(T);
+    okm.set(T, olen * (blocks - 1));
+    iHash.destroy(); // Raw digests may leave key-derived base/worker state; wipe all explicitly.
+    oHash.destroy();
+    worker?.destroy();
+    if (T !== okm)
+        clean(T); // Wipe private T/PRK; standalone preserves caller-owned PRK.
+    clean(HKDF_COUNTER);
+    // Exact fit: return without the extra copy.
+    if (length === okm.length)
+        return okm;
+    // Copy the requested prefix, then wipe the full buffer: its tail holds
+    // up to HashLen-1 bytes of derived key material past `length`.
+    const res = okm.slice(0, length);
+    clean(okm);
+    return res;
+}
+/**
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information bytes
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
+ * @returns Output keying material derived from the input key.
+ * @throws If the requested output length exceeds the HKDF limit
+ *   for the selected hash. {@link Error}
+ * @example
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * ```ts
+ * import { hkdf } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * import { randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = utf8ToBytes('application-key');
+ * const okm = hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export const hkdf = (hash, ikm, salt, info, length) => {
+    ahash(hash);
+    if (salt === undefined)
+        salt = new Uint8Array(hash.outputLen);
+    const HMAC = hmac.create(hash, salt).update(ikm);
+    // The intermediate PRK is secret key material; wipe it instead of
+    // leaving it for GC.
+    return expand(hash, HMAC.digest(), info, length, HMAC); // expand() owns and consumes it.
+};

package/node_modules/@noble/hashes/hmac.d.ts

@@ -0,0 +1,50 @@
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+import { type CHash, type Hash, type TArg, type TRet } from './utils.ts';
+/**
+ * Internal class for HMAC.
+ * Accepts any byte key, although RFC 2104 §3 recommends keys at least
+ * `HashLen` bytes long.
+ */
+export declare class _HMAC<T extends Hash<T>> implements Hash<_HMAC<T>> {
+    oHash: T;
+    iHash: T;
+    blockLen: number;
+    outputLen: number;
+    canXOF: boolean;
+    private finished;
+    private destroyed;
+    constructor(hash: TArg<CHash>, key: TArg<Uint8Array>);
+    update(buf: TArg<Uint8Array>): this;
+    digestInto(out: TArg<Uint8Array>): void;
+    digest(): TRet<Uint8Array>;
+    _cloneInto(to?: _HMAC<T>): _HMAC<T>;
+    clone(): _HMAC<T>;
+    destroy(): void;
+}
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - authentication key bytes
+ * @param message - message bytes to authenticate
+ * @returns Authentication tag bytes.
+ * @example
+ * Compute an RFC 2104 HMAC directly and with an incremental state.
+ * ```ts
+ * import { hmac } from '@noble/hashes/hmac.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * const key = new Uint8Array([1, 2, 3]);
+ * const message = new Uint8Array([4, 5, 6]);
+ * const mac = hmac(sha256, key, message);
+ * const out = new Uint8Array(sha256.outputLen);
+ * hmac.create(sha256, key).update(message).digestInto(out);
+ * ```
+ */
+type HmacFn = {
+    (hash: TArg<CHash>, key: TArg<Uint8Array>, message: TArg<Uint8Array>): TRet<Uint8Array>;
+    create(hash: TArg<CHash>, key: TArg<Uint8Array>): TRet<_HMAC<any>>;
+};
+export declare const hmac: TRet<HmacFn>;
+export {};

package/node_modules/@noble/hashes/hmac.js

@@ -0,0 +1,93 @@
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+import { abytes, aexists, ahash, aoutput, clean, } from "./utils.js";
+/**
+ * Internal class for HMAC.
+ * Accepts any byte key, although RFC 2104 §3 recommends keys at least
+ * `HashLen` bytes long.
+ */
+export class _HMAC {
+    oHash;
+    iHash;
+    blockLen;
+    outputLen;
+    canXOF = false;
+    finished = false;
+    destroyed = false;
+    constructor(hash, key) {
+        ahash(hash);
+        abytes(key, undefined, 'key');
+        this.iHash = hash.create();
+        if (typeof this.iHash.update !== 'function')
+            throw new Error('expected Hash instance');
+        this.blockLen = this.iHash.blockLen;
+        this.outputLen = this.iHash.outputLen;
+        const blockLen = this.blockLen;
+        const pad = new Uint8Array(blockLen);
+        // blockLen can be bigger than outputLen
+        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36;
+        this.iHash.update(pad);
+        // By doing update (processing of the first block) of the outer hash here,
+        // we can re-use it between multiple calls via clone.
+        this.oHash = hash.create();
+        // Undo internal XOR && apply outer XOR
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        this.oHash.update(pad);
+        clean(pad);
+    }
+    update(buf) {
+        aexists(this);
+        this.iHash.update(buf);
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        this.finished = true;
+        const buf = out.subarray(0, this.outputLen);
+        // Reuse the first outputLen bytes for the inner digest; the outer hash consumes them before
+        // overwriting that same prefix with the final tag, leaving any oversized tail untouched.
+        this.iHash.digestInto(buf);
+        this.oHash.update(buf);
+        this.oHash.digestInto(buf);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since the key
+        // is already in state and we don't know it.
+        to ||= Object.create(Object.getPrototypeOf(this), {});
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        to.canXOF = canXOF;
+        to.oHash = oHash._cloneInto(to.oHash);
+        to.iHash = iHash._cloneInto(to.iHash);
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    destroy() {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
+    }
+}
+export const hmac = /* @__PURE__ */ (() => {
+    const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());
+    hmac_.create = (hash, key) => new _HMAC(hash, key);
+    return hmac_;
+})();

package/node_modules/@noble/hashes/index.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@noble/hashes/index.js

@@ -0,0 +1,34 @@
+/**
+ * Audited & minimal JS implementation of hash functions, MACs, and KDFs.
+ * Check out individual modules.
+ * @module
+ * @example
+```js
+import {
+  sha256, sha384, sha512, sha224, sha512_224, sha512_256
+} from '@noble/hashes/sha2.js';
+import {
+  sha3_224, sha3_256, sha3_384, sha3_512,
+  keccak_224, keccak_256, keccak_384, keccak_512,
+  shake128, shake256
+} from '@noble/hashes/sha3.js';
+import {
+  cshake128, cshake256,
+  turboshake128, turboshake256,
+  kt128, kt256,
+  kmac128, kmac256,
+  tuplehash256, parallelhash256,
+  keccakprg
+} from '@noble/hashes/sha3-addons.js';
+import { blake3 } from '@noble/hashes/blake3.js';
+import { blake2b, blake2s } from '@noble/hashes/blake2.js';
+import { hmac } from '@noble/hashes/hmac.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';
+import { scrypt, scryptAsync } from '@noble/hashes/scrypt.js';
+import { md5, ripemd160, sha1 } from '@noble/hashes/legacy.js';
+import * as utils from '@noble/hashes/utils.js';
+```
+ */
+throw new Error('root module cannot be imported: import submodules instead. Check out README');
+export {};

package/node_modules/@noble/hashes/legacy.d.ts

@@ -0,0 +1,107 @@
+/**
+
+SHA1 (RFC 3174), MD5 (RFC 1321), and RIPEMD160 legacy, weak hash functions.
+RFC 2286 only covers HMAC-RIPEMD160 wrapper material and test vectors,
+not the base RIPEMD-160 compression spec.
+Don't use them in a new protocol. What "weak" means:
+
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://www.rfc-editor.org/rfc/rfc6151
+ * @module
+ */
+import { HashMD } from './_md.ts';
+import { type CHash, type TRet } from './utils.ts';
+/** Internal SHA1 legacy hash class. */
+export declare class _SHA1 extends HashMD<_SHA1> {
+    private A;
+    private B;
+    private C;
+    private D;
+    private E;
+    constructor();
+    protected get(): [number, number, number, number, number];
+    protected set(A: number, B: number, C: number, D: number, E: number): void;
+    _cloneInto(to?: _SHA1): _SHA1;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/**
+ * SHA1 (RFC 3174) legacy hash function. It was cryptographically broken.
+ * @param msg - message bytes to hash
+ * @param opts - Reserved hash options.
+ * @returns Digest bytes.
+ * @example
+ * Hash a message with SHA1.
+ * ```ts
+ * sha1(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export declare const sha1: TRet<CHash>;
+/** Internal MD5 legacy hash class. */
+export declare class _MD5 extends HashMD<_MD5> {
+    private A;
+    private B;
+    private C;
+    private D;
+    constructor();
+    protected get(): [number, number, number, number];
+    protected set(A: number, B: number, C: number, D: number): void;
+    _cloneInto(to?: _MD5): _MD5;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/**
+ * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.
+ * MD5 architecture is similar to SHA1, with some differences:
+ * - Reduced output length: 16 bytes (128 bit) instead of 20
+ * - 64 rounds, instead of 80
+ * - Little-endian: could be faster, but will require more code
+ * - Non-linear index selection: huge speed-up for unroll
+ * - Per round constants: more memory accesses, additional speed-up for unroll
+ * @param msg - message bytes to hash
+ * @param opts - Reserved hash options.
+ * @returns Digest bytes.
+ * @example
+ * Hash a message with MD5.
+ * ```ts
+ * md5(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export declare const md5: TRet<CHash>;
+/**
+ * Internal RIPEMD-160 legacy hash class.
+ * RFC 2286 only adds HMAC-RIPEMD160 material, not the core hash specification.
+ */
+export declare class _RIPEMD160 extends HashMD<_RIPEMD160> {
+    private h0;
+    private h1;
+    private h2;
+    private h3;
+    private h4;
+    constructor();
+    protected get(): [number, number, number, number, number];
+    protected set(h0: number, h1: number, h2: number, h3: number, h4: number): void;
+    _cloneInto(to?: _RIPEMD160): _RIPEMD160;
+    protected process(view: DataView, offset: number): void;
+    protected roundClean(): void;
+    destroy(): void;
+}
+/**
+ * RIPEMD-160 - a legacy hash function from 1990s.
+ * RFC 2286 only covers HMAC-RIPEMD160 test material; the links below point
+ * at the base RIPEMD-160 references.
+ * * {@link https://homes.esat.kuleuven.be/~bosselae/ripemd160.html}
+ * * {@link https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf}
+ * @param msg - message bytes to hash
+ * @param opts - Reserved hash options.
+ * @returns Digest bytes.
+ * @example
+ * Hash a message with RIPEMD-160.
+ * ```ts
+ * ripemd160(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export declare const ripemd160: TRet<CHash>;