fortify2-js/dist/cjs/components/cache/cacheSys.utils.js

MOST POWERFUL JavaScript Security Library! Military-grade cryptography + 19 enhanced object methods + quantum-resistant algorithms + perfect TypeScript support. More powerful than Lodash with built-in security.

'use strict';

var util = require('util');
var fs = require('fs');
var path = require('path');
var zlib = require('zlib');
require('../../types.js');
require('../../core/hash/hash-core.js');
require('../../core/hash/hash-types.js');
var crypto = require('crypto');
require('../../core/hash/hash-security.js');
require('../../core/hash/hash-advanced.js');
require('../../algorithms/hash-algorithms.js');
require('../../core/keys/keys-types.js');
require('../../core/keys/keys-logger.js');
require('../../core/keys/keys-utils.js');
require('../../core/keys/algorithms/mods/PBKDF2Algo.js');
var randomCore = require('../../core/random/random-core.js');
require('../../core/random/random-types.js');
require('../../core/random/random-sources.js');
require('nehonix-uri-processor');
require('../../utils/memory/index.js');
require('argon2');
require('child_process');
require('../../types/secure-memory.js');
require('https');
require('../runtime-verification.js');
require('../tamper-evident-logging.js');
require('../secure-string/advanced/entropy-analyzer.js');
require('../secure-string/advanced/quantum-safe.js');
require('../secure-string/advanced/performance-monitor.js');
require('nehoid');
require('../../core/password/index.js');

function _interopNamespaceDefault(e) {
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n.default = e;
    return Object.freeze(n);
}

var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);

/**
 * Ensure directory exists for file cache operations
 */
const ensureDirectoryExists = async (filePath) => {
    const dir = path.dirname(filePath);
    if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
    }
};
/**
 * Encrypt data for file storage
 */
const encryptFileData = (data, key) => {
    const encryptionKey = key || randomCore.SecureRandom.getRandomBytes(32);
    const iv = randomCore.SecureRandom.getRandomBytes(16);
    const cipher = crypto__namespace.createCipheriv("aes-256-gcm", encryptionKey, iv);
    let encrypted = cipher.update(data, "utf8", "base64");
    encrypted += cipher.final("base64");
    const authTag = cipher.getAuthTag();
    return {
        encrypted,
        iv: iv.toString("base64"),
        authTag: authTag.toString("base64"),
        key: encryptionKey.toString("base64"),
    };
};
/**
 * Decrypt data from file storage
 */
const decryptFileData = (encrypted, iv, authTag, key) => {
    const keyBuffer = Buffer.from(key, "base64");
    const ivBuffer = Buffer.from(iv, "base64");
    const authTagBuffer = Buffer.from(authTag, "base64");
    const decipher = crypto__namespace.createDecipheriv("aes-256-gcm", keyBuffer, ivBuffer);
    decipher.setAuthTag(authTagBuffer);
    let decrypted = decipher.update(encrypted, "base64", "utf8");
    decrypted += decipher.final("utf8");
    return decrypted;
};
/**
 * Compress data if beneficial
 */
const compressFileData = async (data) => {
    if (data.length < 1024) {
        // Don't compress small data
        return { data, compressed: false };
    }
    try {
        const deflate = util.promisify(zlib.deflate);
        const compressed = await deflate(Buffer.from(data, "utf8"));
        const compressedString = compressed.toString("base64");
        if (compressedString.length < data.length * 0.9) {
            return { data: compressedString, compressed: true };
        }
    }
    catch (error) {
        console.warn("File compression failed:", error);
    }
    return { data, compressed: false };
};
/**
 * Decompress data
 */
const decompressFileData = async (data, compressed) => {
    if (!compressed)
        return data;
    try {
        const inflate = util.promisify(zlib.inflate);
        const decompressed = await inflate(Buffer.from(data, "base64"));
        return decompressed.toString("utf8");
    }
    catch (error) {
        console.error("File decompression failed:", error);
        throw new Error("Data decompression failed");
    }
};

exports.compressFileData = compressFileData;
exports.decompressFileData = decompressFileData;
exports.decryptFileData = decryptFileData;
exports.encryptFileData = encryptFileData;
exports.ensureDirectoryExists = ensureDirectoryExists;
//# sourceMappingURL=cacheSys.utils.js.map