shogun-core 6.2.4 → 6.3.0

package/dist/src/crypto/symmetric.js

@@ -0,0 +1,165 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { arrayBufferToBase64, base64ToArrayBuffer } from "./hashing.js";
+// Symmetric Key Generation and Encryption/Decryption Methods
+export var generateSymmetricKey = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var key, keyJWK;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, crypto.subtle.generateKey({
+                    name: "AES-GCM",
+                    length: 256, // can be 128, 192, or 256
+                }, true, // whether the key is extractable
+                ["encrypt", "decrypt"])];
+            case 1:
+                key = _a.sent();
+                return [4 /*yield*/, crypto.subtle.exportKey("jwk", key)];
+            case 2:
+                keyJWK = _a.sent();
+                return [2 /*return*/, keyJWK];
+        }
+    });
+}); };
+export var deserializeSymmetricKey = function (key) { return __awaiter(void 0, void 0, void 0, function () {
+    var jwkKey, deSerializedSymmetricKey, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                jwkKey = typeof key === "string" ? JSON.parse(key) : key;
+                // Validate that required JWK properties exist for symmetric keys
+                if (!jwkKey.kty) {
+                    throw new Error('Invalid JWK: missing "kty" property');
+                }
+                // Ensure the key type is correct for symmetric keys
+                if (jwkKey.kty !== "oct") {
+                    jwkKey.kty = "oct";
+                }
+                return [4 /*yield*/, crypto.subtle.importKey("jwk", jwkKey, {
+                        name: "AES-GCM",
+                    }, true, ["encrypt", "decrypt"])];
+            case 1:
+                deSerializedSymmetricKey = _a.sent();
+                return [2 /*return*/, deSerializedSymmetricKey];
+            case 2:
+                error_1 = _a.sent();
+                console.error("Error deserializing symmetric key:", error_1);
+                throw error_1;
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+export var encryptWithSymmetricKey = function (message, key) { return __awaiter(void 0, void 0, void 0, function () {
+    var encodedMessage, iv, encrypted;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                encodedMessage = new TextEncoder().encode(message);
+                iv = crypto.getRandomValues(new Uint8Array(12));
+                return [4 /*yield*/, crypto.subtle.encrypt({
+                        name: "AES-GCM",
+                        iv: iv,
+                    }, key, encodedMessage)];
+            case 1:
+                encrypted = _a.sent();
+                return [2 /*return*/, {
+                        ciphertext: arrayBufferToBase64(encrypted),
+                        iv: arrayBufferToBase64(iv.buffer),
+                    }];
+        }
+    });
+}); };
+export var decryptWithSymmetricKey = function (encryptedData, key) { return __awaiter(void 0, void 0, void 0, function () {
+    var ciphertext, iv, buffer, ivBuffer, decrypted, message, error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                ciphertext = encryptedData.ciphertext, iv = encryptedData.iv;
+                buffer = base64ToArrayBuffer(ciphertext);
+                ivBuffer = base64ToArrayBuffer(iv);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, crypto.subtle.decrypt({
+                        name: "AES-GCM",
+                        iv: ivBuffer,
+                    }, key, buffer)];
+            case 2:
+                decrypted = _a.sent();
+                message = new TextDecoder().decode(decrypted);
+                return [2 /*return*/, message];
+            case 3:
+                error_2 = _a.sent();
+                throw new Error("Unable to decrypt message. Incorrect key.");
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+// Password-based key derivation
+export var deriveKeyFromPassword = function (password, salt) { return __awaiter(void 0, void 0, void 0, function () {
+    var encoder, actualSalt, _a, passwordKey, derivedKey;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                encoder = new TextEncoder();
+                _a = salt;
+                if (_a) return [3 /*break*/, 2];
+                return [4 /*yield*/, crypto.subtle.digest("SHA-256", encoder.encode(password))];
+            case 1:
+                _a = (_b.sent());
+                _b.label = 2;
+            case 2:
+                actualSalt = _a;
+                return [4 /*yield*/, crypto.subtle.importKey("raw", encoder.encode(password), "PBKDF2", false, ["deriveKey"])];
+            case 3:
+                passwordKey = _b.sent();
+                return [4 /*yield*/, crypto.subtle.deriveKey({
+                        name: "PBKDF2",
+                        salt: actualSalt,
+                        iterations: 100000, // Strong iteration count
+                        hash: "SHA-256",
+                    }, passwordKey, {
+                        name: "AES-GCM",
+                        length: 256,
+                    }, false, // Not extractable for security
+                    ["encrypt", "decrypt"])];
+            case 4:
+                derivedKey = _b.sent();
+                return [2 /*return*/, { key: derivedKey, salt: actualSalt }];
+        }
+    });
+}); };

package/dist/src/crypto/utils.js

@@ -0,0 +1,220 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// Common utility functions for crypto operations
+export var validatePassword = function (password) {
+    // Basic password validation
+    return password.length >= 8;
+};
+export var generateSecurePassword = function (length) {
+    if (length === void 0) { length = 16; }
+    var charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+    var randomValues = crypto.getRandomValues(new Uint8Array(length));
+    var password = "";
+    for (var i = 0; i < length; i++) {
+        password += charset[randomValues[i] % charset.length];
+    }
+    return password;
+};
+export var measurePerformance = function (operation, operationName) { return __awaiter(void 0, void 0, void 0, function () {
+    var start, result, end, duration;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                start = performance.now();
+                return [4 /*yield*/, operation()];
+            case 1:
+                result = _a.sent();
+                end = performance.now();
+                duration = end - start;
+                console.log("\u23F1\uFE0F ".concat(operationName, " took ").concat(duration.toFixed(2), "ms"));
+                return [2 /*return*/, { result: result, duration: duration }];
+        }
+    });
+}); };
+export var formatBytes = function (bytes) {
+    if (bytes === 0)
+        return "0 Bytes";
+    var k = 1024;
+    var sizes = ["Bytes", "KB", "MB", "GB"];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+};
+export var formatDuration = function (ms) {
+    if (ms < 1000)
+        return "".concat(ms.toFixed(2), "ms");
+    if (ms < 60000)
+        return "".concat((ms / 1000).toFixed(2), "s");
+    return "".concat((ms / 60000).toFixed(2), "m");
+};
+export var createProgressCallback = function (onProgress, total) {
+    var current = 0;
+    return {
+        increment: function (amount) {
+            if (amount === void 0) { amount = 1; }
+            current += amount;
+            var progress = Math.min((current / total) * 100, 100);
+            onProgress(progress);
+        },
+        setProgress: function (progress) {
+            current = (progress / 100) * total;
+            onProgress(progress);
+        },
+        complete: function () {
+            current = total;
+            onProgress(100);
+        },
+    };
+};
+export var sanitizeFileName = function (fileName) {
+    // Remove or replace invalid characters
+    return fileName.replace(/[<>:"/\\|?*]/g, "_");
+};
+export var getFileExtension = function (fileName) {
+    var lastDot = fileName.lastIndexOf(".");
+    return lastDot !== -1 ? fileName.substring(lastDot + 1).toLowerCase() : "";
+};
+export var isTextFile = function (fileName) {
+    var textExtensions = [
+        "txt",
+        "md",
+        "json",
+        "js",
+        "ts",
+        "html",
+        "css",
+        "xml",
+        "csv",
+    ];
+    var extension = getFileExtension(fileName);
+    return textExtensions.includes(extension);
+};
+export var createFileHash = function (file) { return __awaiter(void 0, void 0, void 0, function () {
+    var buffer, hashBuffer, hashArray;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, file.arrayBuffer()];
+            case 1:
+                buffer = _a.sent();
+                return [4 /*yield*/, crypto.subtle.digest("SHA-256", buffer)];
+            case 2:
+                hashBuffer = _a.sent();
+                hashArray = Array.from(new Uint8Array(hashBuffer));
+                return [2 /*return*/, hashArray.map(function (b) { return b.toString(16).padStart(2, "0"); }).join("")];
+        }
+    });
+}); };
+export var compareFiles = function (file1, file2) { return __awaiter(void 0, void 0, void 0, function () {
+    var hash1, hash2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (file1.size !== file2.size)
+                    return [2 /*return*/, false];
+                return [4 /*yield*/, createFileHash(file1)];
+            case 1:
+                hash1 = _a.sent();
+                return [4 /*yield*/, createFileHash(file2)];
+            case 2:
+                hash2 = _a.sent();
+                return [2 /*return*/, hash1 === hash2];
+        }
+    });
+}); };
+export var createBackup = function (data) {
+    return JSON.stringify({
+        data: data,
+        timestamp: new Date().toISOString(),
+        version: "1.0",
+    }, null, 2);
+};
+export var restoreBackup = function (backupString) {
+    var backup = JSON.parse(backupString);
+    if (!backup.timestamp || !backup.data) {
+        throw new Error("Invalid backup format");
+    }
+    return backup.data;
+};
+export var debounce = function (func, wait) {
+    var timeout;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        clearTimeout(timeout);
+        timeout = setTimeout(function () { return func.apply(void 0, __spreadArray([], __read(args), false)); }, wait);
+    };
+};
+export var throttle = function (func, limit) {
+    var inThrottle;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (!inThrottle) {
+            func.apply(void 0, __spreadArray([], __read(args), false));
+            inThrottle = true;
+            setTimeout(function () { return (inThrottle = false); }, limit);
+        }
+    };
+};