eteres 0.0.1-security → 6.7.1

package/lib.commonjs/crypto/keccak.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ *  Cryptographic hashing functions
+ *
+ *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256 = void 0;
+const sha3_1 = require("@noble/hashes/sha3");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _keccak256 = function (data) {
+    return (0, sha3_1.keccak_256)(data);
+};
+let __keccak256 = _keccak256;
+/**
+ *  Compute the cryptographic KECCAK256 hash of %%data%%.
+ *
+ *  The %%data%% **must** be a data representation, to compute the
+ *  hash of UTF-8 data use the [[id]] function.
+ *
+ *  @returns DataHexstring
+ *  @example:
+ *    keccak256("0x")
+ *    //_result:
+ *
+ *    keccak256("0x1337")
+ *    //_result:
+ *
+ *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ *    // Strings are assumed to be DataHexString, otherwise it will
+ *    // throw. To hash UTF-8 data, see the note above.
+ *    keccak256("Hello World")
+ *    //_error:
+ */
+function keccak256(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__keccak256(data));
+}
+exports.keccak256 = keccak256;
+keccak256._ = _keccak256;
+keccak256.lock = function () { locked = true; };
+keccak256.register = function (func) {
+    if (locked) {
+        throw new TypeError("keccak256 is locked");
+    }
+    __keccak256 = func;
+};
+Object.freeze(keccak256);
+//# sourceMappingURL=keccak.js.map

package/lib.commonjs/crypto/keccak.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keccak.js","sourceRoot":"","sources":["../../src.ts/crypto/keccak.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,6CAAgD;AAEhD,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,UAAU,GAAG,UAAS,IAAgB;IACxC,OAAO,IAAA,iBAAU,EAAC,IAAI,CAAC,CAAC;AAC5B,CAAC,CAAA;AAED,IAAI,WAAW,GAAoC,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,SAAS,CAAC,KAAgB;IACtC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAHD,8BAGC;AACD,SAAS,CAAC,CAAC,GAAG,UAAU,CAAC;AACzB,SAAS,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,SAAS,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC/D,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,CAAC;KAAE;IAC3D,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC"}

package/lib.commonjs/crypto/pbkdf2.d.ts

@@ -0,0 +1,35 @@
+/**
+ *  A **Password-Based Key-Derivation Function** is designed to create
+ *  a sequence of bytes suitible as a **key** from a human-rememberable
+ *  password.
+ *
+ *  @_subsection: api/crypto:Passwords  [about-pbkdf]
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
+ *  the %%salt%% and using %%iterations%% of %%algo%%.
+ *
+ *  This PBKDF is outdated and should not be used in new projects, but is
+ *  required to decrypt older files.
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the PBKDF2
+ *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
+ *    //_result:
+ */
+export declare function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string;
+export declare namespace pbkdf2 {
+    var _: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike;
+    var lock: () => void;
+    var register: (func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) => void;
+}
+//# sourceMappingURL=pbkdf2.d.ts.map

package/lib.commonjs/crypto/pbkdf2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/pbkdf2.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAIpI;yBAJe,MAAM"}

package/lib.commonjs/crypto/pbkdf2.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ *  A **Password-Based Key-Derivation Function** is designed to create
+ *  a sequence of bytes suitible as a **key** from a human-rememberable
+ *  password.
+ *
+ *  @_subsection: api/crypto:Passwords  [about-pbkdf]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pbkdf2 = void 0;
+const crypto_js_1 = require("./crypto.js");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _pbkdf2 = function (password, salt, iterations, keylen, algo) {
+    return (0, crypto_js_1.pbkdf2Sync)(password, salt, iterations, keylen, algo);
+};
+let __pbkdf2 = _pbkdf2;
+/**
+ *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
+ *  the %%salt%% and using %%iterations%% of %%algo%%.
+ *
+ *  This PBKDF is outdated and should not be used in new projects, but is
+ *  required to decrypt older files.
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the PBKDF2
+ *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
+ *    //_result:
+ */
+function pbkdf2(_password, _salt, iterations, keylen, algo) {
+    const password = (0, index_js_1.getBytes)(_password, "password");
+    const salt = (0, index_js_1.getBytes)(_salt, "salt");
+    return (0, index_js_1.hexlify)(__pbkdf2(password, salt, iterations, keylen, algo));
+}
+exports.pbkdf2 = pbkdf2;
+pbkdf2._ = _pbkdf2;
+pbkdf2.lock = function () { locked = true; };
+pbkdf2.register = function (func) {
+    if (locked) {
+        throw new Error("pbkdf2 is locked");
+    }
+    __pbkdf2 = func;
+};
+Object.freeze(pbkdf2);
+//# sourceMappingURL=pbkdf2.js.map

package/lib.commonjs/crypto/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["../../src.ts/crypto/pbkdf2.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,2CAAyC;AAEzC,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,OAAO,GAAG,UAAS,QAAoB,EAAE,IAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,IAAyB;IAC1H,OAAO,IAAA,sBAAU,EAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AAChE,CAAC,CAAA;AAED,IAAI,QAAQ,GAAG,OAAO,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,MAAM,CAAC,SAAoB,EAAE,KAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,IAAyB;IACxH,MAAM,QAAQ,GAAG,IAAA,mBAAQ,EAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACvE,CAAC;AAJD,wBAIC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACjD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAA0H;IACjJ,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACpD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}

package/lib.commonjs/crypto/random.d.ts

@@ -0,0 +1,14 @@
+/**
+ *  Return %%length%% bytes of cryptographically secure random data.
+ *
+ *  @example:
+ *    randomBytes(8)
+ *    //_result:
+ */
+export declare function randomBytes(length: number): Uint8Array;
+export declare namespace randomBytes {
+    var _: (length: number) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (length: number) => Uint8Array) => void;
+}
+//# sourceMappingURL=random.d.ts.map

package/lib.commonjs/crypto/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/random.ts"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAEtD;yBAFe,WAAW"}

package/lib.commonjs/crypto/random.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = void 0;
+/**
+ *  A **Cryptographically Secure Random Value** is one that has been
+ *  generated with additional care take to prevent side-channels
+ *  from allowing others to detect it and prevent others from through
+ *  coincidence generate the same values.
+ *
+ *  @_subsection: api/crypto:Random Values  [about-crypto-random]
+ */
+const crypto_js_1 = require("./crypto.js");
+let locked = false;
+const _randomBytes = function (length) {
+    return new Uint8Array((0, crypto_js_1.randomBytes)(length));
+};
+let __randomBytes = _randomBytes;
+/**
+ *  Return %%length%% bytes of cryptographically secure random data.
+ *
+ *  @example:
+ *    randomBytes(8)
+ *    //_result:
+ */
+function randomBytes(length) {
+    return __randomBytes(length);
+}
+exports.randomBytes = randomBytes;
+randomBytes._ = _randomBytes;
+randomBytes.lock = function () { locked = true; };
+randomBytes.register = function (func) {
+    if (locked) {
+        throw new Error("randomBytes is locked");
+    }
+    __randomBytes = func;
+};
+Object.freeze(randomBytes);
+//# sourceMappingURL=random.js.map

package/lib.commonjs/crypto/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../src.ts/crypto/random.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,2CAA2D;AAE3D,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,YAAY,GAAG,UAAS,MAAc;IACxC,OAAO,IAAI,UAAU,CAAC,IAAA,uBAAa,EAAC,MAAM,CAAC,CAAC,CAAC;AACjD,CAAC,CAAA;AAED,IAAI,aAAa,GAAG,YAAY,CAAC;AAEjC;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,MAAc;IACtC,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AACjC,CAAC;AAFD,kCAEC;AAED,WAAW,CAAC,CAAC,GAAG,YAAY,CAAC;AAC7B,WAAW,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACtD,WAAW,CAAC,QAAQ,GAAG,UAAS,IAAoC;IAChE,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC"}

package/lib.commonjs/crypto/ripemd160.d.ts

@@ -0,0 +1,25 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    ripemd160("0x")
+ *    //_result:
+ *
+ *    ripemd160("0x1337")
+ *    //_result:
+ *
+ *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+export declare function ripemd160(_data: BytesLike): string;
+export declare namespace ripemd160 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+//# sourceMappingURL=ripemd160.d.ts.map

package/lib.commonjs/crypto/ripemd160.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/ripemd160.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAGlD;yBAHe,SAAS"}

package/lib.commonjs/crypto/ripemd160.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ripemd160 = void 0;
+const ripemd160_1 = require("@noble/hashes/ripemd160");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _ripemd160 = function (data) {
+    return (0, ripemd160_1.ripemd160)(data);
+};
+let __ripemd160 = _ripemd160;
+/**
+ *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    ripemd160("0x")
+ *    //_result:
+ *
+ *    ripemd160("0x1337")
+ *    //_result:
+ *
+ *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+function ripemd160(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__ripemd160(data));
+}
+exports.ripemd160 = ripemd160;
+ripemd160._ = _ripemd160;
+ripemd160.lock = function () { locked = true; };
+ripemd160.register = function (func) {
+    if (locked) {
+        throw new TypeError("ripemd160 is locked");
+    }
+    __ripemd160 = func;
+};
+Object.freeze(ripemd160);
+//# sourceMappingURL=ripemd160.js.map

package/lib.commonjs/crypto/ripemd160.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.js","sourceRoot":"","sources":["../../src.ts/crypto/ripemd160.ts"],"names":[],"mappings":";;;AAAA,uDAAuE;AAEvE,gDAAuD;AAKvD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,UAAU,GAAG,UAAS,IAAgB;IACxC,OAAO,IAAA,qBAAe,EAAC,IAAI,CAAC,CAAC;AACjC,CAAC,CAAA;AAED,IAAI,WAAW,GAAoC,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,SAAS,CAAC,KAAgB;IACtC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAHD,8BAGC;AACD,SAAS,CAAC,CAAC,GAAG,UAAU,CAAC;AACzB,SAAS,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,SAAS,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC/D,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,CAAC;KAAE;IAC3D,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC"}

package/lib.commonjs/crypto/scrypt.d.ts

@@ -0,0 +1,82 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  A callback during long-running operations to update any
+ *  UI or provide programatic access to the progress.
+ *
+ *  The %%percent%% is a value between ``0`` and ``1``.
+ *
+ *  @_docloc: api/crypto:Passwords
+ */
+export type ProgressCallback = (percent: number) => void;
+/**
+ *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
+ *  derivation to increase the resource cost to brute-force a password
+ *  for a given key.
+ *
+ *  This means this algorithm is intentionally slow, and can be tuned to
+ *  become slower. As computation and memory speed improve over time,
+ *  increasing the difficulty maintains the cost of an attacker.
+ *
+ *  For example, if a target time of 5 seconds is used, a legitimate user
+ *  which knows their password requires only 5 seconds to unlock their
+ *  account. A 6 character password has 68 billion possibilities, which
+ *  would require an attacker to invest over 10,000 years of CPU time. This
+ *  is of course a crude example (as password generally aren't random),
+ *  but demonstrates to value of imposing large costs to decryption.
+ *
+ *  For this reason, if building a UI which involved decrypting or
+ *  encrypting datsa using scrypt, it is recommended to use a
+ *  [[ProgressCallback]] (as event short periods can seem lik an eternity
+ *  if the UI freezes). Including the phrase //"decrypting"// in the UI
+ *  can also help, assuring the user their waiting is for a good reason.
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+export declare function scrypt(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback): Promise<string>;
+export declare namespace scrypt {
+    var _: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback | undefined) => Promise<Uint8Array>;
+    var lock: () => void;
+    var register: (func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback | undefined) => Promise<BytesLike>) => void;
+}
+/**
+ *  Provides a synchronous variant of [[scrypt]].
+ *
+ *  This will completely lock up and freeze the UI in a browser and will
+ *  prevent any event loop from progressing. For this reason, it is
+ *  preferred to use the [async variant](scrypt).
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+export declare function scryptSync(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number): string;
+export declare namespace scryptSync {
+    var _: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike) => void;
+}
+//# sourceMappingURL=scrypt.d.ts.map

package/lib.commonjs/crypto/scrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/scrypt.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAgBzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAI/J;yBAJqB,MAAM;;;;;AAa5B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIvH;yBAJe,UAAU"}

package/lib.commonjs/crypto/scrypt.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scryptSync = exports.scrypt = void 0;
+const scrypt_1 = require("@noble/hashes/scrypt");
+const index_js_1 = require("../utils/index.js");
+let lockedSync = false, lockedAsync = false;
+const _scryptAsync = async function (passwd, salt, N, r, p, dkLen, onProgress) {
+    return await (0, scrypt_1.scryptAsync)(passwd, salt, { N, r, p, dkLen, onProgress });
+};
+const _scryptSync = function (passwd, salt, N, r, p, dkLen) {
+    return (0, scrypt_1.scrypt)(passwd, salt, { N, r, p, dkLen });
+};
+let __scryptAsync = _scryptAsync;
+let __scryptSync = _scryptSync;
+/**
+ *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
+ *  derivation to increase the resource cost to brute-force a password
+ *  for a given key.
+ *
+ *  This means this algorithm is intentionally slow, and can be tuned to
+ *  become slower. As computation and memory speed improve over time,
+ *  increasing the difficulty maintains the cost of an attacker.
+ *
+ *  For example, if a target time of 5 seconds is used, a legitimate user
+ *  which knows their password requires only 5 seconds to unlock their
+ *  account. A 6 character password has 68 billion possibilities, which
+ *  would require an attacker to invest over 10,000 years of CPU time. This
+ *  is of course a crude example (as password generally aren't random),
+ *  but demonstrates to value of imposing large costs to decryption.
+ *
+ *  For this reason, if building a UI which involved decrypting or
+ *  encrypting datsa using scrypt, it is recommended to use a
+ *  [[ProgressCallback]] (as event short periods can seem lik an eternity
+ *  if the UI freezes). Including the phrase //"decrypting"// in the UI
+ *  can also help, assuring the user their waiting is for a good reason.
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+async function scrypt(_passwd, _salt, N, r, p, dkLen, progress) {
+    const passwd = (0, index_js_1.getBytes)(_passwd, "passwd");
+    const salt = (0, index_js_1.getBytes)(_salt, "salt");
+    return (0, index_js_1.hexlify)(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress));
+}
+exports.scrypt = scrypt;
+scrypt._ = _scryptAsync;
+scrypt.lock = function () { lockedAsync = true; };
+scrypt.register = function (func) {
+    if (lockedAsync) {
+        throw new Error("scrypt is locked");
+    }
+    __scryptAsync = func;
+};
+Object.freeze(scrypt);
+/**
+ *  Provides a synchronous variant of [[scrypt]].
+ *
+ *  This will completely lock up and freeze the UI in a browser and will
+ *  prevent any event loop from progressing. For this reason, it is
+ *  preferred to use the [async variant](scrypt).
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+function scryptSync(_passwd, _salt, N, r, p, dkLen) {
+    const passwd = (0, index_js_1.getBytes)(_passwd, "passwd");
+    const salt = (0, index_js_1.getBytes)(_salt, "salt");
+    return (0, index_js_1.hexlify)(__scryptSync(passwd, salt, N, r, p, dkLen));
+}
+exports.scryptSync = scryptSync;
+scryptSync._ = _scryptSync;
+scryptSync.lock = function () { lockedSync = true; };
+scryptSync.register = function (func) {
+    if (lockedSync) {
+        throw new Error("scryptSync is locked");
+    }
+    __scryptSync = func;
+};
+Object.freeze(scryptSync);
+//# sourceMappingURL=scrypt.js.map

package/lib.commonjs/crypto/scrypt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.js","sourceRoot":"","sources":["../../src.ts/crypto/scrypt.ts"],"names":[],"mappings":";;;AAAA,iDAAwF;AAExF,gDAA2D;AAe3D,IAAI,UAAU,GAAG,KAAK,EAAE,WAAW,GAAG,KAAK,CAAC;AAE5C,MAAM,YAAY,GAAG,KAAK,WAAU,MAAkB,EAAE,IAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,UAA6B;IACnJ,OAAO,MAAM,IAAA,oBAAW,EAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;AAC3E,CAAC,CAAA;AACD,MAAM,WAAW,GAAG,UAAS,MAAkB,EAAE,IAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa;IAC7G,OAAO,IAAA,eAAU,EAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACxD,CAAC,CAAA;AAED,IAAI,aAAa,GAAgJ,YAAY,CAAC;AAC9K,IAAI,YAAY,GAAwG,WAAW,CAAA;AAGnI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACI,KAAK,UAAU,MAAM,CAAC,OAAkB,EAAE,KAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,QAA2B;IAC1I,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAC,EAAC,MAAM,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC1E,CAAC;AAJD,wBAIC;AACD,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC;AACxB,MAAM,CAAC,IAAI,GAAG,cAAmB,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACtD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAA+I;IACtK,IAAI,WAAW,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,UAAU,CAAC,OAAkB,EAAE,KAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa;IAC3G,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAC,EAAC,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AACzD,CAAC;AAJD,gCAIC;AACD,UAAU,CAAC,CAAC,GAAG,WAAW,CAAC;AAC3B,UAAU,CAAC,IAAI,GAAG,cAAmB,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACzD,UAAU,CAAC,QAAQ,GAAG,UAAS,IAAyG;IACpI,IAAI,UAAU,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;KAAE;IAC5D,YAAY,GAAG,IAAI,CAAC;AACxB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC"}

package/lib.commonjs/crypto/sha2.d.ts

@@ -0,0 +1,47 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic SHA2-256 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha256("0x")
+ *    //_result:
+ *
+ *    sha256("0x1337")
+ *    //_result:
+ *
+ *    sha256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+export declare function sha256(_data: BytesLike): string;
+export declare namespace sha256 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+/**
+ *  Compute the cryptographic SHA2-512 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha512("0x")
+ *    //_result:
+ *
+ *    sha512("0x1337")
+ *    //_result:
+ *
+ *    sha512(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ */
+export declare function sha512(_data: BytesLike): string;
+export declare namespace sha512 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+//# sourceMappingURL=sha2.d.ts.map

package/lib.commonjs/crypto/sha2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha2.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/sha2.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAiBnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAG/C;yBAHe,MAAM;;;;;AAatB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAG/C;yBAHe,MAAM"}

package/lib.commonjs/crypto/sha2.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha512 = exports.sha256 = void 0;
+const crypto_js_1 = require("./crypto.js");
+const index_js_1 = require("../utils/index.js");
+const _sha256 = function (data) {
+    return (0, crypto_js_1.createHash)("sha256").update(data).digest();
+};
+const _sha512 = function (data) {
+    return (0, crypto_js_1.createHash)("sha512").update(data).digest();
+};
+let __sha256 = _sha256;
+let __sha512 = _sha512;
+let locked256 = false, locked512 = false;
+/**
+ *  Compute the cryptographic SHA2-256 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha256("0x")
+ *    //_result:
+ *
+ *    sha256("0x1337")
+ *    //_result:
+ *
+ *    sha256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+function sha256(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__sha256(data));
+}
+exports.sha256 = sha256;
+sha256._ = _sha256;
+sha256.lock = function () { locked256 = true; };
+sha256.register = function (func) {
+    if (locked256) {
+        throw new Error("sha256 is locked");
+    }
+    __sha256 = func;
+};
+Object.freeze(sha256);
+/**
+ *  Compute the cryptographic SHA2-512 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha512("0x")
+ *    //_result:
+ *
+ *    sha512("0x1337")
+ *    //_result:
+ *
+ *    sha512(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ */
+function sha512(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__sha512(data));
+}
+exports.sha512 = sha512;
+sha512._ = _sha512;
+sha512.lock = function () { locked512 = true; };
+sha512.register = function (func) {
+    if (locked512) {
+        throw new Error("sha512 is locked");
+    }
+    __sha512 = func;
+};
+Object.freeze(sha256);
+//# sourceMappingURL=sha2.js.map

package/lib.commonjs/crypto/sha2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha2.js","sourceRoot":"","sources":["../../src.ts/crypto/sha2.ts"],"names":[],"mappings":";;;AAAA,2CAAyC;AAEzC,gDAAsD;AAKtD,MAAM,OAAO,GAAG,UAAS,IAAgB;IACrC,OAAO,IAAA,sBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AACtD,CAAC,CAAA;AAED,MAAM,OAAO,GAAG,UAAS,IAAgB;IACrC,OAAO,IAAA,sBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AACtD,CAAC,CAAA;AAED,IAAI,QAAQ,GAAoC,OAAO,CAAC;AACxD,IAAI,QAAQ,GAAoC,OAAO,CAAC;AAExD,IAAI,SAAS,GAAG,KAAK,EAAE,SAAS,GAAG,KAAK,CAAC;AAGzC;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,MAAM,CAAC,KAAgB;IACnC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,CAAC;AAHD,wBAGC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC5D,IAAI,SAAS,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACvD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAGtB;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,MAAM,CAAC,KAAgB;IACnC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,CAAC;AAHD,wBAGC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC5D,IAAI,SAAS,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACvD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}