@sebastienrousseau/crypto-lib 0.0.2 → 0.0.7

package/dist/accel/native-pqc-bridge.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNativePqc = hasNativePqc;
+exports.resetNativePqcCache = resetNativePqcCache;
+exports._forceNativePqcDetected = _forceNativePqcDetected;
+exports.pqcBackend = pqcBackend;
+exports.bridgedMlKemKeygen = bridgedMlKemKeygen;
+exports.bridgedMlKemEncapsulate = bridgedMlKemEncapsulate;
+exports.bridgedMlKemDecapsulate = bridgedMlKemDecapsulate;
+const ml_kem_js_1 = require("@noble/post-quantum/ml-kem.js");
+const nodeCrypto = __importStar(require("node:crypto"));
+let _nativePqcDetected;
+function hasNativePqc() {
+    if (_nativePqcDetected !== undefined)
+        return _nativePqcDetected;
+    try {
+        const c = nodeCrypto;
+        _nativePqcDetected =
+            typeof c.encapsulate === "function" &&
+                typeof c.decapsulate === "function";
+    }
+    catch {
+        _nativePqcDetected = false;
+    }
+    return _nativePqcDetected;
+}
+function resetNativePqcCache() {
+    _nativePqcDetected = undefined;
+}
+function _forceNativePqcDetected(value) {
+    _nativePqcDetected = value;
+}
+function pqcBackend() {
+    return hasNativePqc() ? "native" : "noble";
+}
+const VALID_LEVELS = new Set([512, 768, 1024]);
+function assertLevel(level) {
+    if (!VALID_LEVELS.has(level)) {
+        throw new Error(`Unsupported ML-KEM level: ${level}. Supported: 512, 768, 1024`);
+    }
+}
+function getNobleKem(level) {
+    switch (level) {
+        case 512:
+            return ml_kem_js_1.ml_kem512;
+        case 768:
+            return ml_kem_js_1.ml_kem768;
+        case 1024:
+            return ml_kem_js_1.ml_kem1024;
+    }
+}
+function bridgedMlKemKeygen(level) {
+    assertLevel(level);
+    const kem = getNobleKem(level);
+    return kem.keygen();
+}
+function bridgedMlKemEncapsulate(level, publicKey) {
+    assertLevel(level);
+    const kem = getNobleKem(level);
+    return kem.encapsulate(publicKey);
+}
+function bridgedMlKemDecapsulate(level, cipherText, secretKey) {
+    assertLevel(level);
+    const kem = getNobleKem(level);
+    return kem.decapsulate(cipherText, secretKey);
+}
+//# sourceMappingURL=native-pqc-bridge.js.map

package/dist/accel/wasm-bridge.d.ts

@@ -0,0 +1,35 @@
+export type WasmBackend = "wasm-simd" | "wasm" | "js";
+export type WasmHashAlgorithm = "sha256" | "sha512" | "sha3-256" | "sha3-512" | "blake3";
+export interface WasmHashOptions {
+    algorithm: WasmHashAlgorithm;
+    data: string | Uint8Array;
+    encoding?: "hex" | "utf8";
+}
+export interface WasmHashResult {
+    digest: string;
+    algorithm: WasmHashAlgorithm;
+    backend: WasmBackend;
+}
+export interface WasmAeadEncryptOptions {
+    key: string | Uint8Array;
+    plaintext: string | Uint8Array;
+    aad?: Uint8Array;
+}
+export interface WasmAeadEncryptResult {
+    ciphertext: string;
+    backend: WasmBackend;
+}
+export interface WasmAeadDecryptResult {
+    plaintext: Uint8Array;
+    backend: WasmBackend;
+}
+export declare function detectWasmBackend(): WasmBackend;
+export declare function _resetWasmDetection(): void;
+export declare function wasmHash(options: WasmHashOptions): WasmHashResult;
+export declare function wasmAeadEncrypt(options: WasmAeadEncryptOptions): WasmAeadEncryptResult;
+export declare function wasmAeadDecrypt(options: {
+    key: string | Uint8Array;
+    ciphertext: string;
+    aad?: Uint8Array;
+}): WasmAeadDecryptResult;
+//# sourceMappingURL=wasm-bridge.d.ts.map

package/dist/accel/wasm-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-bridge.d.ts","sourceRoot":"","sources":["../../src/accel/wasm-bridge.ts"],"names":[],"mappings":"AA8BA,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC;AAGtD,MAAM,MAAM,iBAAiB,GAC3B,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAG3D,MAAM,WAAW,eAAe;IAE9B,SAAS,EAAE,iBAAiB,CAAC;IAE7B,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1B,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;CAC3B;AAGD,MAAM,WAAW,cAAc;IAE7B,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,EAAE,iBAAiB,CAAC;IAE7B,OAAO,EAAE,WAAW,CAAC;CACtB;AAGD,MAAM,WAAW,sBAAsB;IAErC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IAE/B,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,qBAAqB;IAEpC,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,WAAW,CAAC;CACtB;AAGD,MAAM,WAAW,qBAAqB;IAEpC,SAAS,EAAE,UAAU,CAAC;IAEtB,OAAO,EAAE,WAAW,CAAC;CACtB;AAoBD,wBAAgB,iBAAiB,IAAI,WAAW,CA0E/C;AASD,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAkDD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,CAYjE;AAgBD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAsBvB;AAWD,wBAAgB,eAAe,CAAC,OAAO,EAAE;IAEvC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB,GAAG,qBAAqB,CAmBxB"}

package/dist/accel/wasm-bridge.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectWasmBackend = detectWasmBackend;
+exports._resetWasmDetection = _resetWasmDetection;
+exports.wasmHash = wasmHash;
+exports.wasmAeadEncrypt = wasmAeadEncrypt;
+exports.wasmAeadDecrypt = wasmAeadDecrypt;
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const blake3_js_1 = require("@noble/hashes/blake3.js");
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+let cachedBackend;
+function detectWasmBackend() {
+    if (cachedBackend !== undefined)
+        return cachedBackend;
+    const g = globalThis;
+    const WA = g["WebAssembly"];
+    if (!WA) {
+        cachedBackend = "js";
+        return cachedBackend;
+    }
+    try {
+        const simdTest = new Uint8Array([
+            0x00,
+            0x61,
+            0x73,
+            0x6d,
+            0x01,
+            0x00,
+            0x00,
+            0x00,
+            0x01,
+            0x05,
+            0x01,
+            0x60,
+            0x00,
+            0x01,
+            0x7b,
+            0x03,
+            0x02,
+            0x01,
+            0x00,
+            0x0a,
+            0x0a,
+            0x01,
+            0x08,
+            0x00,
+            0xfd,
+            0x0c,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            0x0b,
+        ]);
+        const mod = new WA.Module(simdTest);
+        if (mod) {
+            cachedBackend = "wasm-simd";
+            return cachedBackend;
+        }
+    }
+    catch {
+        if (typeof WA.Module === "function") {
+            cachedBackend = "wasm";
+            return cachedBackend;
+        }
+    }
+    cachedBackend = "js";
+    return cachedBackend;
+}
+function _resetWasmDetection() {
+    cachedBackend = undefined;
+}
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function toBytes(input, encoding = "utf8") {
+    if (input instanceof Uint8Array)
+        return input;
+    if (encoding === "hex") {
+        if (!HEX_RE.test(input))
+            throw new Error("Invalid hex string");
+        return Buffer.from(input, "hex");
+    }
+    return Buffer.from(input, "utf8");
+}
+function getHashFn(algorithm) {
+    switch (algorithm) {
+        case "sha256":
+            return sha2_js_1.sha256;
+        case "sha512":
+            return sha2_js_1.sha512;
+        case "sha3-256":
+            return sha3_js_1.sha3_256;
+        case "sha3-512":
+            return sha3_js_1.sha3_512;
+        case "blake3":
+            return blake3_js_1.blake3;
+        default:
+            throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+    }
+}
+function wasmHash(options) {
+    const data = toBytes(options.data, options.encoding ?? "utf8");
+    const hashFn = getHashFn(options.algorithm);
+    const digest = hashFn(data);
+    return {
+        digest: Buffer.from(digest).toString("hex"),
+        algorithm: options.algorithm,
+        backend: "js",
+    };
+}
+const NONCE_LENGTH = 24;
+function wasmAeadEncrypt(options) {
+    const key = toBytes(options.key, "hex");
+    if (key.length !== 32) {
+        throw new Error(`Key must be 32 bytes (256 bits), got ${key.length}`);
+    }
+    const plaintext = options.plaintext instanceof Uint8Array
+        ? options.plaintext
+        : Buffer.from(options.plaintext, "utf8");
+    const nonce = (0, utils_js_1.randomBytes)(NONCE_LENGTH);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce, options.aad);
+    const sealed = cipher.encrypt(plaintext);
+    const combined = new Uint8Array(NONCE_LENGTH + sealed.length);
+    combined.set(nonce);
+    combined.set(sealed, NONCE_LENGTH);
+    return {
+        ciphertext: Buffer.from(combined).toString("base64"),
+        backend: "js",
+    };
+}
+function wasmAeadDecrypt(options) {
+    const key = toBytes(options.key, "hex");
+    if (key.length !== 32) {
+        throw new Error(`Key must be 32 bytes (256 bits), got ${key.length}`);
+    }
+    const combined = Buffer.from(options.ciphertext, "base64");
+    if (combined.length < NONCE_LENGTH + 16) {
+        throw new Error("Ciphertext too short — missing nonce or auth tag");
+    }
+    const nonce = combined.subarray(0, NONCE_LENGTH);
+    const sealed = combined.subarray(NONCE_LENGTH);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce, options.aad);
+    return {
+        plaintext: cipher.decrypt(sealed),
+        backend: "js",
+    };
+}
+//# sourceMappingURL=wasm-bridge.js.map

package/dist/accel/webcrypto-bridge.d.ts

@@ -0,0 +1,32 @@
+export type WebCryptoHashAlgorithm = "SHA-256" | "SHA-384" | "SHA-512";
+export interface WebCryptoAesGcmEncryptOptions {
+    key: string | Uint8Array;
+    plaintext: string | Uint8Array;
+    aad?: Uint8Array;
+}
+export interface WebCryptoAesGcmEncryptResult {
+    ciphertext: string;
+    accelerated: boolean;
+}
+export interface WebCryptoAesGcmDecryptOptions {
+    key: string | Uint8Array;
+    ciphertext: string;
+    aad?: Uint8Array;
+}
+export interface WebCryptoAesGcmDecryptResult {
+    plaintext: Uint8Array;
+    accelerated: boolean;
+}
+export interface WebCryptoHashOptions {
+    algorithm: WebCryptoHashAlgorithm;
+    data: string | Uint8Array;
+}
+export interface WebCryptoHashResult {
+    digest: string;
+    accelerated: boolean;
+}
+export declare function isWebCryptoAvailable(): boolean;
+export declare function webCryptoAesGcmEncrypt(options: WebCryptoAesGcmEncryptOptions): Promise<WebCryptoAesGcmEncryptResult>;
+export declare function webCryptoAesGcmDecrypt(options: WebCryptoAesGcmDecryptOptions): Promise<WebCryptoAesGcmDecryptResult>;
+export declare function webCryptoHash(options: WebCryptoHashOptions): Promise<WebCryptoHashResult>;
+//# sourceMappingURL=webcrypto-bridge.d.ts.map

package/dist/accel/webcrypto-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto-bridge.d.ts","sourceRoot":"","sources":["../../src/accel/webcrypto-bridge.ts"],"names":[],"mappings":"AAyCA,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAGvE,MAAM,WAAW,6BAA6B;IAE5C,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IAE/B,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,4BAA4B;IAE3C,UAAU,EAAE,MAAM,CAAC;IAEnB,WAAW,EAAE,OAAO,CAAC;CACtB;AAGD,MAAM,WAAW,6BAA6B;IAE5C,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,4BAA4B;IAE3C,SAAS,EAAE,UAAU,CAAC;IAEtB,WAAW,EAAE,OAAO,CAAC;CACtB;AAGD,MAAM,WAAW,oBAAoB;IAEnC,SAAS,EAAE,sBAAsB,CAAC;IAElC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAGD,MAAM,WAAW,mBAAmB;IAElC,MAAM,EAAE,MAAM,CAAC;IAEf,WAAW,EAAE,OAAO,CAAC;CACtB;AA4DD,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAUD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,4BAA4B,CAAC,CAuDvC;AASD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,4BAA4B,CAAC,CAmDvC;AASD,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAiC9B"}

package/dist/accel/webcrypto-bridge.js

@@ -0,0 +1,179 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWebCryptoAvailable = isWebCryptoAvailable;
+exports.webCryptoAesGcmEncrypt = webCryptoAesGcmEncrypt;
+exports.webCryptoAesGcmDecrypt = webCryptoAesGcmDecrypt;
+exports.webCryptoHash = webCryptoHash;
+const aes_js_1 = require("@noble/ciphers/aes.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const nodeCrypto = __importStar(require("node:crypto"));
+function asBufferSource(view) {
+    return view;
+}
+const HEX_RE = /^[0-9a-fA-F]*$/;
+const NONCE_LENGTH = 12;
+const TAG_LENGTH = 16;
+function toBytes(input, encoding = "utf8") {
+    if (input instanceof Uint8Array)
+        return input;
+    if (encoding === "hex") {
+        if (!HEX_RE.test(input)) {
+            throw new Error("Invalid hex string");
+        }
+        return Buffer.from(input, "hex");
+    }
+    return Buffer.from(input, "utf8");
+}
+function validateKey(key) {
+    if (key.length !== 16 && key.length !== 32) {
+        throw new Error(`Key must be 16 bytes (128 bits) or 32 bytes (256 bits), got ${key.length}`);
+    }
+}
+function getSubtle() {
+    try {
+        if (nodeCrypto.webcrypto &&
+            nodeCrypto.webcrypto.subtle &&
+            typeof nodeCrypto.webcrypto.subtle.encrypt === "function") {
+            return nodeCrypto.webcrypto.subtle;
+        }
+    }
+    catch {
+    }
+    return null;
+}
+function isWebCryptoAvailable() {
+    return getSubtle() !== null;
+}
+async function webCryptoAesGcmEncrypt(options) {
+    const key = toBytes(options.key, "hex");
+    validateKey(key);
+    const plaintext = toBytes(options.plaintext, "utf8");
+    const nonce = (0, utils_js_1.randomBytes)(NONCE_LENGTH);
+    const subtle = getSubtle();
+    if (subtle) {
+        const cryptoKey = await subtle.importKey("raw", asBufferSource(key), { name: "AES-GCM" }, false, ["encrypt"]);
+        const algParams = {
+            name: "AES-GCM",
+            iv: asBufferSource(nonce),
+            tagLength: TAG_LENGTH * 8,
+        };
+        if (options.aad) {
+            algParams.additionalData = asBufferSource(options.aad);
+        }
+        const encrypted = await subtle.encrypt(algParams, cryptoKey, asBufferSource(plaintext));
+        const sealed = new Uint8Array(encrypted);
+        const combined = new Uint8Array(NONCE_LENGTH + sealed.length);
+        combined.set(nonce);
+        combined.set(sealed, NONCE_LENGTH);
+        return {
+            ciphertext: Buffer.from(combined).toString("base64"),
+            accelerated: true,
+        };
+    }
+    const cipher = (0, aes_js_1.gcm)(key, nonce, options.aad);
+    const sealed = cipher.encrypt(plaintext);
+    const combined = new Uint8Array(NONCE_LENGTH + sealed.length);
+    combined.set(nonce);
+    combined.set(sealed, NONCE_LENGTH);
+    return {
+        ciphertext: Buffer.from(combined).toString("base64"),
+        accelerated: false,
+    };
+}
+async function webCryptoAesGcmDecrypt(options) {
+    const key = toBytes(options.key, "hex");
+    validateKey(key);
+    const combined = Buffer.from(options.ciphertext, "base64");
+    if (combined.length < NONCE_LENGTH + TAG_LENGTH) {
+        throw new Error("Ciphertext too short — missing nonce or auth tag");
+    }
+    const nonce = combined.subarray(0, NONCE_LENGTH);
+    const sealed = combined.subarray(NONCE_LENGTH);
+    const subtle = getSubtle();
+    if (subtle) {
+        const cryptoKey = await subtle.importKey("raw", asBufferSource(key), { name: "AES-GCM" }, false, ["decrypt"]);
+        const algParams = {
+            name: "AES-GCM",
+            iv: asBufferSource(nonce),
+            tagLength: TAG_LENGTH * 8,
+        };
+        if (options.aad) {
+            algParams.additionalData = asBufferSource(options.aad);
+        }
+        const decrypted = await subtle.decrypt(algParams, cryptoKey, asBufferSource(sealed));
+        return {
+            plaintext: new Uint8Array(decrypted),
+            accelerated: true,
+        };
+    }
+    const cipher = (0, aes_js_1.gcm)(key, nonce, options.aad);
+    const plaintext = cipher.decrypt(sealed);
+    return {
+        plaintext,
+        accelerated: false,
+    };
+}
+async function webCryptoHash(options) {
+    const data = toBytes(options.data, "utf8");
+    const subtle = getSubtle();
+    if (subtle) {
+        const digest = await subtle.digest(options.algorithm, asBufferSource(data));
+        return {
+            digest: Buffer.from(digest).toString("hex"),
+            accelerated: true,
+        };
+    }
+    let digest;
+    switch (options.algorithm) {
+        case "SHA-256":
+            digest = (0, sha2_js_1.sha256)(data);
+            break;
+        case "SHA-384":
+            digest = (0, sha2_js_1.sha384)(data);
+            break;
+        case "SHA-512":
+            digest = (0, sha2_js_1.sha512)(data);
+            break;
+        default:
+            throw new Error(`Unsupported hash algorithm: ${options.algorithm}`);
+    }
+    return {
+        digest: Buffer.from(digest).toString("hex"),
+        accelerated: false,
+    };
+}
+//# sourceMappingURL=webcrypto-bridge.js.map

package/dist/accel/webcrypto-modern.d.ts

@@ -0,0 +1,40 @@
+export interface WebCryptoModernSupport {
+    chacha20poly1305: boolean;
+    sha3: boolean;
+    mlKem: boolean;
+    argon2: boolean;
+    kmac: boolean;
+}
+export type ModernSha3Algorithm = "SHA3-256" | "SHA3-512";
+export interface ModernChaCha20EncryptOptions {
+    key: string | Uint8Array;
+    plaintext: string | Uint8Array;
+    aad?: Uint8Array;
+}
+export interface ModernAeadResult {
+    ciphertext: string;
+    accelerated: boolean;
+}
+export interface ModernChaCha20DecryptOptions {
+    key: string | Uint8Array;
+    ciphertext: string;
+    aad?: Uint8Array;
+}
+export interface ModernChaCha20DecryptResult {
+    plaintext: Uint8Array;
+    accelerated: boolean;
+}
+export interface ModernSha3HashOptions {
+    algorithm: ModernSha3Algorithm;
+    data: string | Uint8Array;
+}
+export interface ModernSha3HashResult {
+    digest: string;
+    accelerated: boolean;
+}
+export declare function detectModernWebCrypto(): WebCryptoModernSupport;
+export declare function _resetModernWebCryptoDetection(): void;
+export declare function modernChaCha20Encrypt(options: ModernChaCha20EncryptOptions): Promise<ModernAeadResult>;
+export declare function modernChaCha20Decrypt(options: ModernChaCha20DecryptOptions): Promise<ModernChaCha20DecryptResult>;
+export declare function modernSha3Hash(options: ModernSha3HashOptions): Promise<ModernSha3HashResult>;
+//# sourceMappingURL=webcrypto-modern.d.ts.map

package/dist/accel/webcrypto-modern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto-modern.d.ts","sourceRoot":"","sources":["../../src/accel/webcrypto-modern.ts"],"names":[],"mappings":"AAkDA,MAAM,WAAW,sBAAsB;IAErC,gBAAgB,EAAE,OAAO,CAAC;IAE1B,IAAI,EAAE,OAAO,CAAC;IAEd,KAAK,EAAE,OAAO,CAAC;IAEf,MAAM,EAAE,OAAO,CAAC;IAEhB,IAAI,EAAE,OAAO,CAAC;CACf;AAGD,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,UAAU,CAAC;AAG1D,MAAM,WAAW,4BAA4B;IAE3C,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IAE/B,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,gBAAgB;IAE/B,UAAU,EAAE,MAAM,CAAC;IAEnB,WAAW,EAAE,OAAO,CAAC;CACtB;AAGD,MAAM,WAAW,4BAA4B;IAE3C,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,2BAA2B;IAE1C,SAAS,EAAE,UAAU,CAAC;IAEtB,WAAW,EAAE,OAAO,CAAC;CACtB;AAGD,MAAM,WAAW,qBAAqB;IAEpC,SAAS,EAAE,mBAAmB,CAAC;IAE/B,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAGD,MAAM,WAAW,oBAAoB;IAEnC,MAAM,EAAE,MAAM,CAAC;IAEf,WAAW,EAAE,OAAO,CAAC;CACtB;AA0ED,wBAAgB,qBAAqB,IAAI,sBAAsB,CAiC9D;AAUD,wBAAgB,8BAA8B,IAAI,IAAI,CAErD;AAmBD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,gBAAgB,CAAC,CAyD3B;AAgBD,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,2BAA2B,CAAC,CAsDtC;AAmBD,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,oBAAoB,CAAC,CA+B/B"}