shogun-core 6.2.3 → 6.3.0

package/dist/src/examples/crypto-identity-example.js

@@ -0,0 +1,294 @@
+/**
+ * Esempio di utilizzo del CryptoIdentityManager
+ * Mostra come generare le identità crypto
+ */
+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 SEA as side-effect to load it globally
+import "gun/sea";
+import "gun/lib/then";
+import "gun/axe";
+// Ensure Gun.SEA is available globally
+// In Node.js, SEA should attach to Gun.SEA or globalThis.SEA
+if (typeof window === "undefined") {
+    // Node.js environment
+    var GunModule = require("gun");
+    if (GunModule && GunModule.SEA) {
+        globalThis.Gun = GunModule;
+        globalThis.SEA = GunModule.SEA;
+    }
+}
+// Suppress expected Gun.js SEA verification errors globally
+// These errors are normal when verifying non-existent or corrupted data
+var originalLog = console.log;
+var originalError = console.error;
+var errorSuppressionActive = false;
+var suppressedLog = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (!errorSuppressionActive) {
+        originalLog.apply(console, args);
+        return;
+    }
+    var message = args.join(" ");
+    // Suppress expected SEA verification errors
+    if (message.includes("Signature did not match") ||
+        message.includes("base64Text") ||
+        message.includes("Could not decrypt") ||
+        message.includes("Argument 'base64Text' is not Base64 encoded")) {
+        return; // Suppress these expected errors
+    }
+    originalLog.apply(console, args);
+};
+var suppressedError = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (!errorSuppressionActive) {
+        originalError.apply(console, args);
+        return;
+    }
+    var message = args.join(" ");
+    if (message.includes("Signature did not match") ||
+        message.includes("base64Text") ||
+        message.includes("Could not decrypt") ||
+        message.includes("Argument 'base64Text' is not Base64 encoded")) {
+        return;
+    }
+    originalError.apply(console, args);
+};
+// Enable error suppression
+errorSuppressionActive = true;
+console.log = suppressedLog;
+console.error = suppressedError;
+import { CryptoIdentityManager } from "../index.js";
+// Esempio base di generazione identità
+function basicIdentityExample() {
+    return __awaiter(this, void 0, void 0, function () {
+        var SEA, exampleUser, examplePassword, seaPair, cryptoManager, generateResult, identities, identitiesJson;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    console.log("🚀 Avvio esempio CryptoIdentityManager");
+                    if (!(!globalThis.SEA && !((_a = globalThis.Gun) === null || _a === void 0 ? void 0 : _a.SEA))) return [3 /*break*/, 2];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                case 1:
+                    _c.sent();
+                    _c.label = 2;
+                case 2:
+                    SEA = globalThis.SEA || ((_b = globalThis.Gun) === null || _b === void 0 ? void 0 : _b.SEA);
+                    if (!SEA) {
+                        console.error("❌ SEA non disponibile. Assicurati che gun/sea sia importato.");
+                        return [2 /*return*/];
+                    }
+                    console.log("✅ SEA disponibile");
+                    exampleUser = "example_user_" + Date.now();
+                    examplePassword = "example_password";
+                    console.log("\uD83D\uDD10 Generazione SEA pair di esempio per: ".concat(exampleUser));
+                    return [4 /*yield*/, SEA.pair()];
+                case 3:
+                    seaPair = _c.sent();
+                    if (!seaPair) {
+                        console.error("❌ Impossibile generare SEA pair di esempio");
+                        return [2 /*return*/];
+                    }
+                    console.log("✅ SEA pair generato");
+                    cryptoManager = new CryptoIdentityManager();
+                    // Genera le identità crypto
+                    console.log("🔐 Generazione delle identità crypto...");
+                    return [4 /*yield*/, cryptoManager.generateAllIdentities(exampleUser, seaPair)];
+                case 4:
+                    generateResult = _c.sent();
+                    if (generateResult.success && generateResult.identities) {
+                        identities = generateResult.identities;
+                        console.log("✅ Identità crypto generate con successo!");
+                        console.log("🔐 Identità crypto generate:");
+                        console.log("- RSA Key Pair:", !!identities.rsa);
+                        console.log("- AES Symmetric Key:", !!identities.aes);
+                        console.log("- Signal Protocol Identity:", !!identities.signal);
+                        console.log("- PGP Key Pair:", !!identities.pgp);
+                        console.log("- MLS Group:", !!identities.mls);
+                        console.log("- SFrame Key:", !!identities.sframe);
+                        console.log("- Created At:", new Date(identities.createdAt).toISOString());
+                        console.log("- Version:", identities.version);
+                        console.log("\nℹ️ Nota: Le identità generate dovranno essere salvate lato frontend se necessario.");
+                        identitiesJson = JSON.stringify(identities);
+                        console.log("\n\uD83D\uDCE6 Identit\u00E0 serializzate (".concat(identitiesJson.length, " caratteri)"));
+                        console.log("💡 Puoi criptare e salvare questa stringa usando SEA.encrypt() lato frontend");
+                    }
+                    else {
+                        console.warn("⚠️ Impossibile generare le identità crypto:", generateResult.error);
+                    }
+                    console.log("\n🎉 Esempio completato!");
+                    // Restore original console methods at the end
+                    errorSuppressionActive = false;
+                    console.log = originalLog;
+                    console.error = originalError;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// Esempio di rigenerazione delle identità
+function regenerateIdentityExample() {
+    return __awaiter(this, void 0, void 0, function () {
+        var SEA, exampleUser, seaPair, cryptoManager, firstResult, secondResult;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    console.log("\n🔄 Esempio di rigenerazione identità");
+                    SEA = globalThis.SEA || ((_a = globalThis.Gun) === null || _a === void 0 ? void 0 : _a.SEA);
+                    if (!SEA) {
+                        console.error("❌ SEA non disponibile");
+                        return [2 /*return*/];
+                    }
+                    exampleUser = "example_user_regenerate";
+                    return [4 /*yield*/, SEA.pair()];
+                case 1:
+                    seaPair = _b.sent();
+                    cryptoManager = new CryptoIdentityManager();
+                    console.log("🔐 Prima generazione...");
+                    return [4 /*yield*/, cryptoManager.generateAllIdentities(exampleUser, seaPair)];
+                case 2:
+                    firstResult = _b.sent();
+                    if (firstResult.success && firstResult.identities) {
+                        console.log("✅ Prima generazione completata");
+                        console.log("- RSA:", !!firstResult.identities.rsa);
+                        console.log("- AES:", !!firstResult.identities.aes);
+                    }
+                    console.log("\n🔐 Seconda generazione (nuove identità)...");
+                    return [4 /*yield*/, cryptoManager.generateAllIdentities(exampleUser, seaPair)];
+                case 3:
+                    secondResult = _b.sent();
+                    if (secondResult.success && secondResult.identities) {
+                        console.log("✅ Seconda generazione completata");
+                        console.log("- RSA:", !!secondResult.identities.rsa);
+                        console.log("- AES:", !!secondResult.identities.aes);
+                        console.log("ℹ️ Nota: Ogni generazione crea nuove identità uniche");
+                    }
+                    // Restore original console methods at the end
+                    errorSuppressionActive = false;
+                    console.log = originalLog;
+                    console.error = originalError;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// Esempio usando setupCryptoIdentities (wrapper)
+function setupIdentityExample() {
+    return __awaiter(this, void 0, void 0, function () {
+        var SEA, exampleUser, seaPair, cryptoManager, result;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    console.log("\n🔧 Esempio usando setupCryptoIdentities");
+                    SEA = globalThis.SEA || ((_a = globalThis.Gun) === null || _a === void 0 ? void 0 : _a.SEA);
+                    if (!SEA) {
+                        console.error("❌ SEA non disponibile");
+                        return [2 /*return*/];
+                    }
+                    exampleUser = "example_user_setup";
+                    return [4 /*yield*/, SEA.pair()];
+                case 1:
+                    seaPair = _b.sent();
+                    cryptoManager = new CryptoIdentityManager();
+                    console.log("🔐 Usando setupCryptoIdentities (wrapper)...");
+                    return [4 /*yield*/, cryptoManager.setupCryptoIdentities(exampleUser, seaPair, false)];
+                case 2:
+                    result = _b.sent();
+                    if (result.success && result.identities) {
+                        console.log("✅ Identità generate usando setupCryptoIdentities");
+                        console.log("- RSA:", !!result.identities.rsa);
+                        console.log("- AES:", !!result.identities.aes);
+                        console.log("- Signal:", !!result.identities.signal);
+                        console.log("- PGP:", !!result.identities.pgp);
+                        console.log("- MLS:", !!result.identities.mls);
+                        console.log("- SFrame:", !!result.identities.sframe);
+                    }
+                    // Restore original console methods at the end
+                    errorSuppressionActive = false;
+                    console.log = originalLog;
+                    console.error = originalError;
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+// Funzione principale per eseguire gli esempi
+export function runCryptoIdentityExamples() {
+    return __awaiter(this, void 0, void 0, function () {
+        var error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 4, 5, 6]);
+                    return [4 /*yield*/, basicIdentityExample()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, regenerateIdentityExample()];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, setupIdentityExample()];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 6];
+                case 4:
+                    error_1 = _a.sent();
+                    console.error("❌ Errore durante l'esecuzione degli esempi:", error_1);
+                    return [3 /*break*/, 6];
+                case 5:
+                    // Always restore console methods
+                    errorSuppressionActive = false;
+                    console.log = originalLog;
+                    console.error = originalError;
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Esegui gli esempi se il file viene eseguito direttamente
+if (typeof window === "undefined" && require.main === module) {
+    runCryptoIdentityExamples();
+}

package/dist/src/examples/crypto-working-test.js

@@ -0,0 +1,149 @@
+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 };
+    }
+};
+// Simple crypto test that actually works
+import { randomString, sha256Hash, generateKeyPair, encrypt, decrypt, generateSymmetricKey, encryptWithSymmetricKey, decryptWithSymmetricKey, encryptTextFile, decryptTextFile, deserializePublicKey, deserializePrivateKey, deserializeSymmetricKey, } from "../crypto/index.js";
+// Simple test function
+function testCrypto() {
+    return __awaiter(this, void 0, void 0, function () {
+        var randomStr, hash, keyPair, publicKey, privateKey, encryptedMessage, decryptedMessage, symmetricKey, deserializedKey, encryptedData, decryptedData, fileContent, password, encryptedFile, decryptedFile, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 13, , 14]);
+                    console.log("🔐 Starting crypto test...");
+                    // Test 1: Random string generation
+                    console.log("\n1. Testing random string generation...");
+                    randomStr = randomString("test-");
+                    console.log("✅ Random string:", randomStr);
+                    // Test 2: Hashing
+                    console.log("\n2. Testing hashing...");
+                    return [4 /*yield*/, sha256Hash({
+                            message: "Hello Crypto!",
+                            timestamp: Date.now(),
+                        })];
+                case 1:
+                    hash = _a.sent();
+                    console.log("✅ SHA-256 hash:", hash.substring(0, 20) + "...");
+                    // Test 3: RSA key generation and encryption
+                    console.log("\n3. Testing RSA encryption...");
+                    return [4 /*yield*/, generateKeyPair()];
+                case 2:
+                    keyPair = _a.sent();
+                    console.log("✅ RSA key pair generated");
+                    return [4 /*yield*/, deserializePublicKey(keyPair.publicKey)];
+                case 3:
+                    publicKey = _a.sent();
+                    return [4 /*yield*/, deserializePrivateKey(keyPair.privateKey)];
+                case 4:
+                    privateKey = _a.sent();
+                    return [4 /*yield*/, encrypt("Secret RSA message", publicKey)];
+                case 5:
+                    encryptedMessage = _a.sent();
+                    return [4 /*yield*/, decrypt(encryptedMessage, privateKey)];
+                case 6:
+                    decryptedMessage = _a.sent();
+                    console.log("✅ RSA encrypted:", encryptedMessage.substring(0, 30) + "...");
+                    console.log("✅ RSA decrypted:", decryptedMessage);
+                    // Test 4: AES symmetric encryption
+                    console.log("\n4. Testing AES symmetric encryption...");
+                    return [4 /*yield*/, generateSymmetricKey()];
+                case 7:
+                    symmetricKey = _a.sent();
+                    return [4 /*yield*/, deserializeSymmetricKey(symmetricKey)];
+                case 8:
+                    deserializedKey = _a.sent();
+                    return [4 /*yield*/, encryptWithSymmetricKey("Secret AES message", deserializedKey)];
+                case 9:
+                    encryptedData = _a.sent();
+                    return [4 /*yield*/, decryptWithSymmetricKey(encryptedData, deserializedKey)];
+                case 10:
+                    decryptedData = _a.sent();
+                    console.log("✅ AES encrypted:", encryptedData.ciphertext.substring(0, 30) + "...");
+                    console.log("✅ AES decrypted:", decryptedData);
+                    // Test 5: File encryption
+                    console.log("\n5. Testing file encryption...");
+                    fileContent = "This is a secret file content for testing!";
+                    password = "testPassword123";
+                    return [4 /*yield*/, encryptTextFile(fileContent, password, "test.txt")];
+                case 11:
+                    encryptedFile = _a.sent();
+                    return [4 /*yield*/, decryptTextFile(encryptedFile, password)];
+                case 12:
+                    decryptedFile = _a.sent();
+                    console.log("✅ File encrypted:", encryptedFile.fileName);
+                    console.log("✅ File decrypted:", decryptedFile.textContent);
+                    console.log("\n🎉 All crypto tests completed successfully!");
+                    return [2 /*return*/, {
+                            success: true,
+                            tests: {
+                                randomString: randomStr,
+                                hash: hash.substring(0, 20) + "...",
+                                rsaEncryption: {
+                                    encrypted: encryptedMessage.substring(0, 30) + "...",
+                                    decrypted: decryptedMessage,
+                                },
+                                aesEncryption: {
+                                    encrypted: encryptedData.ciphertext.substring(0, 30) + "...",
+                                    decrypted: decryptedData,
+                                },
+                                fileEncryption: {
+                                    fileName: encryptedFile.fileName,
+                                    decrypted: decryptedFile.textContent,
+                                },
+                            },
+                        }];
+                case 13:
+                    error_1 = _a.sent();
+                    console.error("❌ Crypto test failed:", error_1);
+                    return [2 /*return*/, {
+                            success: false,
+                            error: error_1 instanceof Error ? error_1.message : "Unknown error",
+                        }];
+                case 14: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Run the test
+testCrypto()
+    .then(function (result) {
+    console.log("\n📊 Final Result:");
+    console.log(JSON.stringify(result, null, 2));
+})
+    .catch(function (error) {
+    console.error("💥 Test execution failed:", error);
+});