xypriss 1.1.0 → 1.1.3

package/dist/esm/mods/toolkit/src/components/secure-serialization.js

@@ -1,769 +0,0 @@
-import { Hash } from '../core/hash/hash-core.js';
-import '../core/hash/hash-types.js';
-import 'crypto';
-import { bufferToHex, hexToBuffer } from '../utils/encoding.js';
-import '../core/hash/hash-security.js';
-import '../core/hash/hash-advanced.js';
-import '../algorithms/hash-algorithms.js';
-import { SecureRandom } from '../core/random/random-core.js';
-import '../core/random/random-types.js';
-import '../core/random/random-sources.js';
-import 'nehonix-uri-processor';
-import '../utils/memory/index.js';
-import '../types.js';
-
-/**
- * Secure Serialization Module
- *
- * This module provides secure methods for serializing and deserializing data,
- * protecting against prototype pollution, object injection, and other
- * serialization-related vulnerabilities.
- */
-/**
- * Securely serializes data
- *
- * @param data - Data to serialize
- * @param options - Serialization options
- * @returns Serialization result
- */
-function secureSerialize(data, options = {}) {
-    // Set default options
-    const opts = {
-        sign: options.sign !== false,
-        encrypt: options.encrypt || false,
-        includeTimestamp: options.includeTimestamp !== false,
-        includeNonce: options.includeNonce !== false,
-        validateTypes: options.validateTypes !== false,
-        allowedClasses: options.allowedClasses || [],
-    };
-    // Generate keys if needed
-    const signKey = options.signKey || bufferToHex(SecureRandom.getRandomBytes(32));
-    const encryptKey = options.encryptKey || bufferToHex(SecureRandom.getRandomBytes(32));
-    // Create metadata
-    const metadata = {};
-    if (opts.includeTimestamp) {
-        metadata.timestamp = Date.now();
-    }
-    if (opts.includeNonce) {
-        metadata.nonce = bufferToHex(SecureRandom.getRandomBytes(16));
-    }
-    // Prepare the data for serialization
-    const preparedData = prepareForSerialization(data, opts.validateTypes, opts.allowedClasses);
-    // Create the payload
-    const payload = {
-        data: preparedData,
-        metadata,
-    };
-    // Serialize the payload
-    let serialized = JSON.stringify(payload);
-    // Encrypt if requested
-    if (opts.encrypt) {
-        if (!options.encryptKey) {
-            throw new Error("Encryption key is required when encrypt is true");
-        }
-        serialized = encryptData(serialized, encryptKey);
-    }
-    // Create the result
-    const result = {
-        data: serialized,
-    };
-    // Add metadata to the result
-    if (opts.includeTimestamp) {
-        result.timestamp = metadata.timestamp;
-    }
-    if (opts.includeNonce) {
-        result.nonce = metadata.nonce;
-    }
-    // Sign if requested
-    if (opts.sign) {
-        result.signature = signData(serialized, signKey);
-    }
-    return result;
-}
-/**
- * Securely deserializes data
- *
- * @param serialized - Serialized data
- * @param options - Deserialization options
- * @returns Deserialization result
- */
-function secureDeserialize(serialized, options = {}) {
-    // Set default options
-    const opts = {
-        verifySignature: options.verifySignature !== false,
-        decrypt: options.decrypt || false,
-        validateTimestamp: options.validateTimestamp !== false,
-        maxAge: options.maxAge || 3600000, // 1 hour
-        validateTypes: options.validateTypes !== false,
-        allowedClasses: options.allowedClasses || [],
-    };
-    // Verify signature if requested
-    let validSignature = undefined;
-    if (opts.verifySignature) {
-        if (!options.signKey) {
-            throw new Error("Signature key is required when verifySignature is true");
-        }
-        if (!serialized.signature) {
-            throw new Error("Signature is missing from serialized data");
-        }
-        validSignature = verifySignature(serialized.data, serialized.signature, options.signKey);
-        if (!validSignature) {
-            throw new Error("Invalid signature");
-        }
-    }
-    // Decrypt if requested
-    let dataString = serialized.data;
-    if (opts.decrypt) {
-        if (!options.decryptKey) {
-            throw new Error("Decryption key is required when decrypt is true");
-        }
-        dataString = decryptData(dataString, options.decryptKey);
-    }
-    // Parse the data
-    let payload;
-    try {
-        payload = JSON.parse(dataString);
-    }
-    catch (e) {
-        throw new Error(`Failed to parse serialized data: ${e.message}`);
-    }
-    // Validate the payload structure
-    if (!payload || typeof payload !== "object") {
-        throw new Error("Invalid payload structure");
-    }
-    if (!("data" in payload)) {
-        throw new Error("Missing data in payload");
-    }
-    // Validate timestamp if requested
-    let validTimestamp = undefined;
-    let timestamp = undefined;
-    let age = undefined;
-    if (opts.validateTimestamp) {
-        if (!payload.metadata || !payload.metadata.timestamp) {
-            throw new Error("Timestamp is missing from payload");
-        }
-        timestamp = payload.metadata.timestamp;
-        const now = Date.now();
-        age = now - timestamp;
-        validTimestamp = age <= opts.maxAge;
-        if (!validTimestamp) {
-            throw new Error(`Data is too old (${age}ms, max ${opts.maxAge}ms)`);
-        }
-    }
-    // Deserialize the data
-    const deserializedData = deserializeData(payload.data, opts.validateTypes, opts.allowedClasses);
-    // Create the result
-    const result = {
-        data: deserializedData,
-    };
-    // Add metadata to the result
-    if (validSignature !== undefined) {
-        result.validSignature = validSignature;
-    }
-    if (validTimestamp !== undefined) {
-        result.validTimestamp = validTimestamp;
-    }
-    if (timestamp !== undefined) {
-        result.timestamp = timestamp;
-    }
-    if (age !== undefined) {
-        result.age = age;
-    }
-    return result;
-}
-/**
- * Prepares data for serialization
- *
- * @param data - Data to prepare
- * @param validateTypes - Whether to validate object types
- * @param allowedClasses - Allowed classes for serialization
- * @returns Prepared data
- */
-function prepareForSerialization(data, validateTypes, allowedClasses) {
-    // Handle null and undefined
-    if (data === null || data === undefined) {
-        return { type: "null", value: null };
-    }
-    // Handle primitive types
-    if (typeof data === "string" ||
-        typeof data === "number" ||
-        typeof data === "boolean") {
-        return { type: typeof data, value: data };
-    }
-    // Handle Date
-    if (data instanceof Date) {
-        return { type: "date", value: data.toISOString() };
-    }
-    // Handle RegExp
-    if (data instanceof RegExp) {
-        return {
-            type: "regexp",
-            value: {
-                pattern: data.source,
-                flags: data.flags,
-            },
-        };
-    }
-    // Handle Uint8Array
-    if (data instanceof Uint8Array) {
-        return { type: "uint8array", value: bufferToHex(data) };
-    }
-    // Handle Array
-    if (Array.isArray(data)) {
-        return {
-            type: "array",
-            value: data.map((item) => prepareForSerialization(item, validateTypes, allowedClasses)),
-        };
-    }
-    // Handle Object
-    if (typeof data === "object") {
-        const constructor = data.constructor?.name || "Object";
-        // Validate class if requested
-        if (validateTypes &&
-            constructor !== "Object" &&
-            !allowedClasses.includes(constructor)) {
-            throw new Error(`Class ${constructor} is not allowed for serialization`);
-        }
-        const result = {};
-        for (const key in data) {
-            if (Object.prototype.hasOwnProperty.call(data, key)) {
-                result[key] = prepareForSerialization(data[key], validateTypes, allowedClasses);
-            }
-        }
-        return {
-            type: "object",
-            class: constructor,
-            value: result,
-        };
-    }
-    // Handle unsupported types
-    return { type: "unsupported", value: String(data) };
-}
-/**
- * Deserializes data
- *
- * @param data - Data to deserialize
- * @param validateTypes - Whether to validate object types
- * @param allowedClasses - Allowed classes for deserialization
- * @returns Deserialized data
- */
-function deserializeData(data, validateTypes, allowedClasses) {
-    // Validate data structure
-    if (!data || typeof data !== "object" || !("type" in data)) {
-        throw new Error("Invalid data structure for deserialization");
-    }
-    const { type, value } = data;
-    // Handle null
-    if (type === "null") {
-        return null;
-    }
-    // Handle primitive types
-    if (type === "string" || type === "number" || type === "boolean") {
-        return value;
-    }
-    // Handle Date
-    if (type === "date") {
-        return new Date(value);
-    }
-    // Handle RegExp
-    if (type === "regexp") {
-        return new RegExp(value.pattern, value.flags);
-    }
-    // Handle Uint8Array
-    if (type === "uint8array") {
-        return hexToBuffer(value);
-    }
-    // Handle Array
-    if (type === "array") {
-        return value.map((item) => deserializeData(item, validateTypes, allowedClasses));
-    }
-    // Handle Object
-    if (type === "object") {
-        const className = data.class || "Object";
-        // Validate class if requested
-        if (validateTypes &&
-            className !== "Object" &&
-            !allowedClasses.includes(className)) {
-            throw new Error(`Class ${className} is not allowed for deserialization`);
-        }
-        const result = {};
-        for (const key in value) {
-            if (Object.prototype.hasOwnProperty.call(value, key)) {
-                result[key] = deserializeData(value[key], validateTypes, allowedClasses);
-            }
-        }
-        return result;
-    }
-    // Handle unsupported types
-    if (type === "unsupported") {
-        return value;
-    }
-    throw new Error(`Unsupported type: ${type}`);
-}
-/**
- * Signs data
- *
- * @param data - Data to sign
- * @param key - Key to use for signing
- * @returns Signature
- */
-function signData(data, key) {
-    return Hash.create(data, {
-        salt: key,
-        algorithm: "sha256",
-        iterations: 1000,
-        outputFormat: "hex",
-    });
-}
-/**
- * Verifies a signature
- *
- * @param data - Data to verify
- * @param signature - Signature to verify
- * @param key - Key to use for verification
- * @returns True if the signature is valid
- */
-function verifySignature(data, signature, key) {
-    const expectedSignature = signData(data, key);
-    return expectedSignature === signature;
-}
-/**
- * Encrypts data using AES-GCM
- *
- * @param data - Data to encrypt
- * @param key - Key to use for encryption (hex encoded)
- * @returns Encrypted data (hex encoded)
- */
-function encryptData(data, key) {
-    try {
-        // Convert data to bytes
-        const dataBytes = new TextEncoder().encode(data);
-        // Generate a random IV (Initialization Vector)
-        const iv = SecureRandom.getRandomBytes(12); // 96 bits for AES-GCM
-        // Derive encryption key from the provided key
-        const keyBytes = hexToBuffer(key);
-        const derivedKey = Hash.create(keyBytes, {
-            algorithm: "sha256",
-            outputFormat: "buffer",
-        });
-        // Use our own implementation since Web Crypto API is async
-        // and our interface is synchronous
-        return encryptWithAesGcm(dataBytes, derivedKey, iv);
-    }
-    catch (error) {
-        console.error("Encryption error:", error);
-        throw new Error(`Failed to encrypt data: ${error.message}`);
-    }
-}
-// Web Crypto API implementation removed since we're using a synchronous interface
-/**
- * Encrypts data using a proper AES-GCM implementation
- *
- * @param data - Data to encrypt
- * @param key - Encryption key
- * @param iv - Initialization vector
- * @returns Encrypted data (hex encoded)
- */
-function encryptWithAesGcm(data, key, iv) {
-    try {
-        // Try to use Node.js crypto if available
-        if (typeof require === "function") {
-            const nodeCrypto = require("crypto");
-            if (typeof nodeCrypto.createCipheriv === "function") {
-                // Use Node.js crypto for AES-GCM
-                const cipher = nodeCrypto.createCipheriv("aes-256-gcm", key.slice(0, 32), // Use first 32 bytes for AES-256
-                iv);
-                // Encrypt the data
-                const encrypted = Buffer.concat([
-                    cipher.update(Buffer.from(data)),
-                    cipher.final(),
-                ]);
-                // Get the authentication tag
-                const authTag = cipher.getAuthTag();
-                // Combine IV, encrypted data, and authentication tag
-                const result = new Uint8Array(iv.length + encrypted.length + authTag.length);
-                result.set(iv, 0);
-                result.set(new Uint8Array(encrypted), iv.length);
-                result.set(new Uint8Array(authTag), iv.length + encrypted.length);
-                return bufferToHex(result);
-            }
-        }
-    }
-    catch (e) {
-        console.warn("Node.js crypto AES-GCM failed:", e);
-        // Fall back to aes-js implementation
-    }
-    try {
-        // Use aes-js library
-        const aesJs = require("aes-js");
-        // Prepare the key (must be 16, 24, or 32 bytes)
-        const aesKey = key.slice(0, 32); // Use first 32 bytes for AES-256
-        // Create AES counter mode for encryption (we'll implement GCM on top of CTR)
-        const aesCtr = new aesJs.ModeOfOperation.ctr(aesKey, new aesJs.Counter(iv));
-        // Encrypt the data
-        const encrypted = aesCtr.encrypt(data);
-        // For GCM, we need to compute a GHASH of the ciphertext and AAD
-        // This is a simplified GHASH implementation
-        const ghash = computeGHash(encrypted, aesKey, iv);
-        // Combine IV, encrypted data, and authentication tag
-        const result = new Uint8Array(iv.length + encrypted.length + ghash.length);
-        result.set(iv, 0);
-        result.set(encrypted, iv.length);
-        result.set(ghash, iv.length + encrypted.length);
-        return bufferToHex(result);
-    }
-    catch (e) {
-        console.warn("aes-js implementation failed:", e);
-        // Fall back to our own implementation
-    }
-    // If all else fails, use our own implementation
-    console.warn("Using fallback AES-GCM implementation");
-    // Implement AES-GCM from scratch
-    // 1. Use AES in CTR mode for encryption
-    const aesKey = key.slice(0, 32); // Use first 32 bytes for AES-256
-    const counter = new Uint8Array(16);
-    counter.set(iv, 0);
-    counter[15] = 1; // Start counter at 1 for GCM
-    // Encrypt using AES-CTR
-    const encrypted = new Uint8Array(data.length);
-    let counterBlock = aesEncryptBlock(counter, aesKey);
-    for (let i = 0; i < data.length; i++) {
-        // Update counter and generate new keystream block when needed
-        if (i > 0 && i % 16 === 0) {
-            incrementCounter(counter);
-            counterBlock = aesEncryptBlock(counter, aesKey);
-        }
-        // XOR data with keystream
-        encrypted[i] = data[i] ^ counterBlock[i % 16];
-    }
-    // 2. Compute GHASH for authentication
-    const authTag = computeGCMTag(encrypted, aesKey, iv);
-    // 3. Combine IV, encrypted data, and authentication tag
-    const result = new Uint8Array(iv.length + encrypted.length + authTag.length);
-    result.set(iv, 0);
-    result.set(encrypted, iv.length);
-    result.set(authTag, iv.length + encrypted.length);
-    return bufferToHex(result);
-}
-/**
- * Encrypts a single AES block
- *
- * @param block - 16-byte block to encrypt
- * @param key - AES key
- * @returns Encrypted block
- */
-function aesEncryptBlock(block, key) {
-    try {
-        // Try to use Node.js crypto if available
-        if (typeof require === "function") {
-            const crypto = require("crypto");
-            if (typeof crypto.createCipheriv === "function") {
-                const cipher = crypto.createCipheriv("aes-256-ecb", key.slice(0, 32), Buffer.alloc(0));
-                cipher.setAutoPadding(false);
-                return new Uint8Array(Buffer.concat([
-                    cipher.update(Buffer.from(block)),
-                    cipher.final(),
-                ]));
-            }
-        }
-    }
-    catch (e) {
-        // Fall back to our implementation
-    }
-    try {
-        // Try to use aes-js if available
-        const aesJs = require("aes-js");
-        const aesEcb = new aesJs.ModeOfOperation.ecb(key.slice(0, 32));
-        return new Uint8Array(aesEcb.encrypt(block));
-    }
-    catch (e) {
-        // Fall back to our implementation
-    }
-    // If all else fails, use a secure hash as a substitute
-    // This is not ideal but better than nothing
-    const combinedData = new Uint8Array(block.length + key.length);
-    combinedData.set(block, 0);
-    combinedData.set(key, block.length);
-    const hash = Hash.create(combinedData, {
-        algorithm: "sha256",
-        outputFormat: "buffer",
-    });
-    return hash.slice(0, 16);
-}
-/**
- * Increments a counter for AES-CTR mode
- *
- * @param counter - Counter to increment (modified in place)
- */
-function incrementCounter(counter) {
-    for (let i = counter.length - 1; i >= 0; i--) {
-        if (++counter[i] !== 0) {
-            break;
-        }
-    }
-}
-/**
- * Computes the authentication tag for AES-GCM
- *
- * @param ciphertext - Encrypted data
- * @param key - Encryption key
- * @param iv - Initialization vector
- * @returns Authentication tag
- */
-function computeGCMTag(ciphertext, key, iv, aad = new Uint8Array(0)) {
-    // Full GCM implementation with proper GHASH computation and authentication
-    // Step 1: Generate the hash subkey H by encrypting a zero block with AES
-    const zeroBlock = new Uint8Array(16);
-    const hashSubkey = aesEncryptBlock(zeroBlock, key);
-    // Step 2: Compute GHASH of AAD and ciphertext
-    const ghashResult = computeGHash(ciphertext, hashSubkey, aad);
-    // Step 3: Generate the initial counter block for GCTR
-    let j0;
-    if (iv.length === 12) {
-        // Standard 96-bit IV
-        j0 = new Uint8Array(16);
-        j0.set(iv, 0);
-        j0[15] = 1; // Set the counter to 1
-    }
-    else {
-        // Non-standard IV length, hash it
-        j0 = computeGHash(iv, hashSubkey);
-    }
-    // Step 4: Encrypt the GHASH result with GCTR using J0
-    const tag = new Uint8Array(16);
-    const j0Encrypted = aesEncryptBlock(j0, key);
-    // XOR the GHASH result with the encrypted J0 to get the authentication tag
-    for (let i = 0; i < 16; i++) {
-        tag[i] = ghashResult[i] ^ j0Encrypted[i];
-    }
-    return tag;
-}
-/**
- * Compute GHASH function for GCM authentication
- */
-function computeGHash(data, hashSubkey, aad = new Uint8Array(0)) {
-    // Initialize the hash to zero
-    let hash = new Uint8Array(16);
-    // Process AAD first
-    if (aad.length > 0) {
-        hash = processGHashBlocks(aad, hash, hashSubkey);
-    }
-    // Process ciphertext
-    if (data.length > 0) {
-        hash = processGHashBlocks(data, hash, hashSubkey);
-    }
-    // Process the length block (AAD length || ciphertext length)
-    const lengthBlock = new Uint8Array(16);
-    const view = new DataView(lengthBlock.buffer);
-    view.setBigUint64(0, BigInt(aad.length * 8), false); // AAD length in bits
-    view.setBigUint64(8, BigInt(data.length * 8), false); // Ciphertext length in bits
-    // Final GHASH operation with length block
-    hash = gfMultiply(xorBlocks(hash, lengthBlock), hashSubkey);
-    return hash;
-}
-/**
- * Process blocks for GHASH computation
- */
-function processGHashBlocks(data, initialHash, hashSubkey) {
-    let hash = new Uint8Array(initialHash);
-    // Process complete 16-byte blocks
-    for (let i = 0; i < data.length; i += 16) {
-        const block = new Uint8Array(16);
-        const remainingBytes = Math.min(16, data.length - i);
-        block.set(data.slice(i, i + remainingBytes), 0);
-        // GHASH operation: hash = (hash XOR block) * H
-        hash = gfMultiply(xorBlocks(hash, block), hashSubkey);
-    }
-    return hash;
-}
-/**
- * Galois Field multiplication for GHASH
- */
-function gfMultiply(a, b) {
-    const result = new Uint8Array(16);
-    const v = new Uint8Array(b);
-    for (let i = 0; i < 16; i++) {
-        for (let j = 0; j < 8; j++) {
-            if ((a[i] & (1 << (7 - j))) !== 0) {
-                xorInPlace(result, v);
-            }
-            // Shift v right by 1 bit
-            const carry = v[15] & 1;
-            for (let k = 15; k > 0; k--) {
-                v[k] = (v[k] >>> 1) | ((v[k - 1] & 1) << 7);
-            }
-            v[0] = v[0] >>> 1;
-            // If there was a carry, XOR with the reduction polynomial
-            if (carry) {
-                v[0] ^= 0xe1; // Reduction polynomial for GF(2^128)
-            }
-        }
-    }
-    return result;
-}
-/**
- * XOR two blocks in place
- */
-function xorInPlace(a, b) {
-    for (let i = 0; i < Math.min(a.length, b.length); i++) {
-        a[i] ^= b[i];
-    }
-}
-/**
- * XOR two blocks and return result
- */
-function xorBlocks(a, b) {
-    const result = new Uint8Array(Math.max(a.length, b.length));
-    for (let i = 0; i < result.length; i++) {
-        result[i] = (a[i] || 0) ^ (b[i] || 0);
-    }
-    return result;
-}
-// Note: The generateKeyStream and generateAuthTag functions have been replaced
-// with more secure implementations: computeGHash, aesEncryptBlock, incrementCounter, and computeGCMTag
-/**
- * Decrypts data
- *
- * @param data - Data to decrypt (hex encoded)
- * @param key - Key to use for decryption (hex encoded)
- * @returns Decrypted data
- */
-function decryptData(data, key) {
-    try {
-        // Convert data to bytes
-        const dataBytes = hexToBuffer(data);
-        // Extract IV, ciphertext, and authentication tag
-        if (dataBytes.length < 28) {
-            // 12 (IV) + 16 (minimum auth tag)
-            throw new Error("Invalid encrypted data format");
-        }
-        const iv = dataBytes.slice(0, 12);
-        const authTagLength = 16;
-        const ciphertext = dataBytes.slice(12, dataBytes.length - authTagLength);
-        const authTag = dataBytes.slice(dataBytes.length - authTagLength);
-        // Derive decryption key from the provided key
-        const keyBytes = hexToBuffer(key);
-        const derivedKey = Hash.create(keyBytes, {
-            algorithm: "sha256",
-            outputFormat: "buffer",
-        });
-        // Decrypt the data
-        const decrypted = decryptWithAesGcm(ciphertext, derivedKey, iv, authTag);
-        return new TextDecoder().decode(decrypted);
-    }
-    catch (error) {
-        console.error("Decryption error:", error);
-        throw new Error(`Failed to decrypt data: ${error.message}`);
-    }
-}
-/**
- * Decrypts data using a proper AES-GCM implementation
- *
- * @param data - Encrypted data
- * @param key - Decryption key
- * @param iv - Initialization vector
- * @param authTag - Authentication tag
- * @returns Decrypted data
- */
-function decryptWithAesGcm(data, key, iv, authTag) {
-    try {
-        // Try to use Node.js crypto if available
-        if (typeof require === "function") {
-            const nodeCrypto = require("crypto");
-            if (typeof nodeCrypto.createDecipheriv === "function") {
-                // Use Node.js crypto for AES-GCM
-                const decipher = nodeCrypto.createDecipheriv("aes-256-gcm", key.slice(0, 32), // Use first 32 bytes for AES-256
-                iv);
-                // Set the authentication tag
-                decipher.setAuthTag(Buffer.from(authTag));
-                // Decrypt the data
-                try {
-                    const decrypted = Buffer.concat([
-                        decipher.update(Buffer.from(data)),
-                        decipher.final(),
-                    ]);
-                    return new Uint8Array(decrypted);
-                }
-                catch (e) {
-                    throw new Error("Authentication tag mismatch - data may be corrupted or tampered with");
-                }
-            }
-        }
-    }
-    catch (e) {
-        console.warn("Node.js crypto AES-GCM decryption failed:", e);
-        // Fall back to aes-js implementation
-    }
-    try {
-        // Use aes-js library
-        const aesJs = require("aes-js");
-        // Prepare the key (must be 16, 24, or 32 bytes)
-        const aesKey = key.slice(0, 32); // Use first 32 bytes for AES-256
-        // Create AES counter mode for decryption (we'll implement GCM on top of CTR)
-        const aesCtr = new aesJs.ModeOfOperation.ctr(aesKey, new aesJs.Counter(iv));
-        // Decrypt the data
-        const decrypted = aesCtr.decrypt(data);
-        // Verify the authentication tag
-        const expectedTag = computeGHash(decrypted, aesKey, iv);
-        // Constant-time comparison of the authentication tags
-        let tagMatch = true;
-        if (authTag.length !== expectedTag.length) {
-            tagMatch = false;
-        }
-        else {
-            let diff = 0;
-            for (let i = 0; i < authTag.length; i++) {
-                diff |= authTag[i] ^ expectedTag[i];
-            }
-            tagMatch = diff === 0;
-        }
-        if (!tagMatch) {
-            throw new Error("Authentication tag mismatch - data may be corrupted or tampered with");
-        }
-        return decrypted;
-    }
-    catch (e) {
-        console.warn("aes-js decryption failed:", e);
-        // Fall back to our own implementation
-    }
-    // If all else fails, use our own implementation
-    console.warn("Using fallback AES-GCM decryption implementation");
-    // 1. Use AES in CTR mode for decryption
-    const aesKey = key.slice(0, 32); // Use first 32 bytes for AES-256
-    const counter = new Uint8Array(16);
-    counter.set(iv, 0);
-    counter[15] = 1; // Start counter at 1 for GCM
-    // Decrypt using AES-CTR
-    const decrypted = new Uint8Array(data.length);
-    let counterBlock = aesEncryptBlock(counter, aesKey);
-    for (let i = 0; i < data.length; i++) {
-        // Update counter and generate new keystream block when needed
-        if (i > 0 && i % 16 === 0) {
-            incrementCounter(counter);
-            counterBlock = aesEncryptBlock(counter, aesKey);
-        }
-        // XOR data with keystream
-        decrypted[i] = data[i] ^ counterBlock[i % 16];
-    }
-    // 2. Verify the authentication tag
-    const expectedTag = computeGCMTag(decrypted, aesKey, iv);
-    // Constant-time comparison of the authentication tags
-    let tagMatch = true;
-    if (authTag.length !== expectedTag.length) {
-        tagMatch = false;
-    }
-    else {
-        let diff = 0;
-        for (let i = 0; i < authTag.length; i++) {
-            diff |= authTag[i] ^ expectedTag[i];
-        }
-        tagMatch = diff === 0;
-    }
-    if (!tagMatch) {
-        throw new Error("Authentication tag mismatch - data may be corrupted or tampered with");
-    }
-    return decrypted;
-}
-
-export { secureDeserialize, secureSerialize };
-//# sourceMappingURL=secure-serialization.js.map