shogun-core 6.2.3 → 6.3.0

package/dist/src/examples/mls-multi-member.js

@@ -0,0 +1,439 @@
+/**
+ * MLS Working Multi-Member Test
+ * Usa l'approccio corretto basato sull'implementazione funzionante
+ */
+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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+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;
+};
+import { MLSManager } from "../crypto/index.js";
+function testMLSWorkingMultiMembers() {
+    return __awaiter(this, void 0, void 0, function () {
+        var members, managers, members_1, members_1_1, memberId, manager, e_1_1, groupId, alice, otherMembers, keyPackages, addResult, otherMembers_1, otherMembers_1_1, memberId, manager, e_2_1, epochInfos, members_2, members_2_1, memberId, info, e_3_1, epochInfos_1, epochInfos_1_1, _a, memberId, epoch, epochs_1, allSameEpoch, members_3, members_3_1, senderId, sender, message, envelope, successCount, managers_1, managers_1_1, _b, memberId, manager, decrypted, error_1, e_4_1, e_5_1, initiator, updateCommit, managers_2, managers_2_1, _c, memberId, manager, error_2, e_6_1, testMessage, aliceEnvelope, postRotationSuccess, managers_3, managers_3_1, _d, memberId, manager, decrypted, error_3, e_7_1, managers_4, managers_4_1, _e, memberId, manager, e_8_1, error_4;
+        var e_1, _f, e_2, _g, e_3, _h, e_9, _j, e_5, _k, e_4, _l, e_6, _m, e_7, _o, e_8, _p;
+        return __generator(this, function (_q) {
+            switch (_q.label) {
+                case 0:
+                    console.log("🚀 Starting MLS Working Multi-Member Test");
+                    console.log("=".repeat(50));
+                    members = ["alice", "bob", "charlie", "david", "eve"];
+                    managers = new Map();
+                    _q.label = 1;
+                case 1:
+                    _q.trys.push([1, 76, , 77]);
+                    // Step 1: Initialize all managers
+                    console.log("\n📋 Step 1: Initializing all managers");
+                    _q.label = 2;
+                case 2:
+                    _q.trys.push([2, 7, 8, 9]);
+                    members_1 = __values(members), members_1_1 = members_1.next();
+                    _q.label = 3;
+                case 3:
+                    if (!!members_1_1.done) return [3 /*break*/, 6];
+                    memberId = members_1_1.value;
+                    manager = new MLSManager(memberId);
+                    return [4 /*yield*/, manager.initialize()];
+                case 4:
+                    _q.sent();
+                    managers.set(memberId, manager);
+                    console.log("\u2705 ".concat(memberId, " initialized"));
+                    _q.label = 5;
+                case 5:
+                    members_1_1 = members_1.next();
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_1_1 = _q.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (members_1_1 && !members_1_1.done && (_f = members_1.return)) _f.call(members_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 9:
+                    // Step 2: Alice creates group
+                    console.log("\n📋 Step 2: Creating group");
+                    groupId = "working-multi-member-group";
+                    alice = managers.get("alice");
+                    return [4 /*yield*/, alice.createGroup(groupId)];
+                case 10:
+                    _q.sent();
+                    console.log("✅ Group created by Alice");
+                    // Step 3: Add all members at once (this is the key!)
+                    console.log("\n📋 Step 3: Adding all members at once");
+                    otherMembers = members.slice(1);
+                    keyPackages = otherMembers.map(function (id) { return managers.get(id).getKeyPackage(); });
+                    console.log("\u2795 Adding ".concat(otherMembers.length, " members: ").concat(otherMembers.join(", ")));
+                    return [4 /*yield*/, alice.addMembers(groupId, keyPackages)];
+                case 11:
+                    addResult = _q.sent();
+                    console.log("✅ All members added by Alice");
+                    // Step 4: All other members join via welcome
+                    console.log("\n📋 Step 4: All members join via welcome");
+                    _q.label = 12;
+                case 12:
+                    _q.trys.push([12, 17, 18, 19]);
+                    otherMembers_1 = __values(otherMembers), otherMembers_1_1 = otherMembers_1.next();
+                    _q.label = 13;
+                case 13:
+                    if (!!otherMembers_1_1.done) return [3 /*break*/, 16];
+                    memberId = otherMembers_1_1.value;
+                    manager = managers.get(memberId);
+                    return [4 /*yield*/, manager.processWelcome(addResult.welcome, addResult.ratchetTree)];
+                case 14:
+                    _q.sent();
+                    console.log("\u2705 ".concat(memberId, " joined group"));
+                    _q.label = 15;
+                case 15:
+                    otherMembers_1_1 = otherMembers_1.next();
+                    return [3 /*break*/, 13];
+                case 16: return [3 /*break*/, 19];
+                case 17:
+                    e_2_1 = _q.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 19];
+                case 18:
+                    try {
+                        if (otherMembers_1_1 && !otherMembers_1_1.done && (_g = otherMembers_1.return)) _g.call(otherMembers_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 19:
+                    // Step 5: Verify synchronization
+                    console.log("\n📋 Step 5: Verifying synchronization");
+                    epochInfos = new Map();
+                    _q.label = 20;
+                case 20:
+                    _q.trys.push([20, 25, 26, 27]);
+                    members_2 = __values(members), members_2_1 = members_2.next();
+                    _q.label = 21;
+                case 21:
+                    if (!!members_2_1.done) return [3 /*break*/, 24];
+                    memberId = members_2_1.value;
+                    return [4 /*yield*/, managers.get(memberId).getGroupKeyInfo(groupId)];
+                case 22:
+                    info = _q.sent();
+                    epochInfos.set(memberId, info === null || info === void 0 ? void 0 : info.epoch);
+                    _q.label = 23;
+                case 23:
+                    members_2_1 = members_2.next();
+                    return [3 /*break*/, 21];
+                case 24: return [3 /*break*/, 27];
+                case 25:
+                    e_3_1 = _q.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 27];
+                case 26:
+                    try {
+                        if (members_2_1 && !members_2_1.done && (_h = members_2.return)) _h.call(members_2);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                    return [7 /*endfinally*/];
+                case 27:
+                    console.log("📊 Epoch verification:");
+                    try {
+                        for (epochInfos_1 = __values(epochInfos), epochInfos_1_1 = epochInfos_1.next(); !epochInfos_1_1.done; epochInfos_1_1 = epochInfos_1.next()) {
+                            _a = __read(epochInfos_1_1.value, 2), memberId = _a[0], epoch = _a[1];
+                            console.log("  ".concat(memberId, ": ").concat(epoch));
+                        }
+                    }
+                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (epochInfos_1_1 && !epochInfos_1_1.done && (_j = epochInfos_1.return)) _j.call(epochInfos_1);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                    }
+                    epochs_1 = Array.from(epochInfos.values());
+                    allSameEpoch = epochs_1.every(function (epoch) { return epoch === epochs_1[0]; });
+                    if (!allSameEpoch) {
+                        console.log("\u274C CRITICAL: Members at different epochs - aborting test");
+                        return [2 /*return*/];
+                    }
+                    console.log("\u2705 All ".concat(members.length, " members synchronized at epoch ").concat(epochs_1[0]));
+                    // Step 6: Test message exchange
+                    console.log("\n📋 Step 6: Testing message exchange");
+                    _q.label = 28;
+                case 28:
+                    _q.trys.push([28, 43, 44, 45]);
+                    members_3 = __values(members), members_3_1 = members_3.next();
+                    _q.label = 29;
+                case 29:
+                    if (!!members_3_1.done) return [3 /*break*/, 42];
+                    senderId = members_3_1.value;
+                    console.log("\n\uD83D\uDCAC ".concat(senderId, " sending message..."));
+                    sender = managers.get(senderId);
+                    message = "Hello from ".concat(senderId, " to everyone!");
+                    return [4 /*yield*/, sender.encryptMessage(groupId, message)];
+                case 30:
+                    envelope = _q.sent();
+                    console.log("\u2705 ".concat(senderId, " encrypted message"));
+                    successCount = 0;
+                    _q.label = 31;
+                case 31:
+                    _q.trys.push([31, 38, 39, 40]);
+                    managers_1 = (e_4 = void 0, __values(managers)), managers_1_1 = managers_1.next();
+                    _q.label = 32;
+                case 32:
+                    if (!!managers_1_1.done) return [3 /*break*/, 37];
+                    _b = __read(managers_1_1.value, 2), memberId = _b[0], manager = _b[1];
+                    if (memberId === senderId) {
+                        console.log("\u2705 ".concat(memberId, " (sender) does not need to decrypt their own message."));
+                        successCount++;
+                        return [3 /*break*/, 36];
+                    }
+                    _q.label = 33;
+                case 33:
+                    _q.trys.push([33, 35, , 36]);
+                    return [4 /*yield*/, manager.decryptMessage(envelope)];
+                case 34:
+                    decrypted = _q.sent();
+                    console.log("\u2705 ".concat(memberId, " decrypted: \"").concat(decrypted, "\""));
+                    successCount++;
+                    return [3 /*break*/, 36];
+                case 35:
+                    error_1 = _q.sent();
+                    console.error("\u274C ".concat(memberId, " failed to decrypt:"), error_1);
+                    return [3 /*break*/, 36];
+                case 36:
+                    managers_1_1 = managers_1.next();
+                    return [3 /*break*/, 32];
+                case 37: return [3 /*break*/, 40];
+                case 38:
+                    e_4_1 = _q.sent();
+                    e_4 = { error: e_4_1 };
+                    return [3 /*break*/, 40];
+                case 39:
+                    try {
+                        if (managers_1_1 && !managers_1_1.done && (_l = managers_1.return)) _l.call(managers_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                    return [7 /*endfinally*/];
+                case 40:
+                    if (successCount === members.length) {
+                        console.log("\uD83C\uDF89 All ".concat(members.length, " members successfully decrypted ").concat(senderId, "'s message"));
+                    }
+                    else {
+                        console.log("\u26A0\uFE0F Only ".concat(successCount, "/").concat(members.length, " members could decrypt ").concat(senderId, "'s message"));
+                    }
+                    _q.label = 41;
+                case 41:
+                    members_3_1 = members_3.next();
+                    return [3 /*break*/, 29];
+                case 42: return [3 /*break*/, 45];
+                case 43:
+                    e_5_1 = _q.sent();
+                    e_5 = { error: e_5_1 };
+                    return [3 /*break*/, 45];
+                case 44:
+                    try {
+                        if (members_3_1 && !members_3_1.done && (_k = members_3.return)) _k.call(members_3);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                    return [7 /*endfinally*/];
+                case 45:
+                    // Step 7: Test key rotation
+                    console.log("\n📋 Step 7: Testing key rotation");
+                    initiator = managers.get("alice");
+                    console.log("🔄 Alice initiating key rotation...");
+                    return [4 /*yield*/, initiator.updateKey(groupId)];
+                case 46:
+                    updateCommit = _q.sent();
+                    console.log("✅ Key rotation commit created");
+                    _q.label = 47;
+                case 47:
+                    _q.trys.push([47, 54, 55, 56]);
+                    managers_2 = __values(managers), managers_2_1 = managers_2.next();
+                    _q.label = 48;
+                case 48:
+                    if (!!managers_2_1.done) return [3 /*break*/, 53];
+                    _c = __read(managers_2_1.value, 2), memberId = _c[0], manager = _c[1];
+                    if (memberId === initiator.getUserId()) {
+                        console.log("\u2705 ".concat(memberId, " (initiator) already processed key rotation."));
+                        return [3 /*break*/, 52];
+                    }
+                    _q.label = 49;
+                case 49:
+                    _q.trys.push([49, 51, , 52]);
+                    return [4 /*yield*/, manager.processCommit(groupId, updateCommit)];
+                case 50:
+                    _q.sent();
+                    console.log("\u2705 ".concat(memberId, " processed key rotation"));
+                    return [3 /*break*/, 52];
+                case 51:
+                    error_2 = _q.sent();
+                    console.error("\u274C ".concat(memberId, " failed to process key rotation:"), error_2);
+                    return [3 /*break*/, 52];
+                case 52:
+                    managers_2_1 = managers_2.next();
+                    return [3 /*break*/, 48];
+                case 53: return [3 /*break*/, 56];
+                case 54:
+                    e_6_1 = _q.sent();
+                    e_6 = { error: e_6_1 };
+                    return [3 /*break*/, 56];
+                case 55:
+                    try {
+                        if (managers_2_1 && !managers_2_1.done && (_m = managers_2.return)) _m.call(managers_2);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                    return [7 /*endfinally*/];
+                case 56:
+                    // Step 8: Test messages after key rotation
+                    console.log("\n📋 Step 8: Testing messages after key rotation");
+                    testMessage = "This message is sent after key rotation!";
+                    return [4 /*yield*/, alice.encryptMessage(groupId, testMessage)];
+                case 57:
+                    aliceEnvelope = _q.sent();
+                    postRotationSuccess = 0;
+                    _q.label = 58;
+                case 58:
+                    _q.trys.push([58, 65, 66, 67]);
+                    managers_3 = __values(managers), managers_3_1 = managers_3.next();
+                    _q.label = 59;
+                case 59:
+                    if (!!managers_3_1.done) return [3 /*break*/, 64];
+                    _d = __read(managers_3_1.value, 2), memberId = _d[0], manager = _d[1];
+                    if (memberId === alice.getUserId()) {
+                        console.log("\u2705 ".concat(memberId, " (sender) does not need to decrypt their own message after rotation."));
+                        postRotationSuccess++;
+                        return [3 /*break*/, 63];
+                    }
+                    _q.label = 60;
+                case 60:
+                    _q.trys.push([60, 62, , 63]);
+                    return [4 /*yield*/, manager.decryptMessage(aliceEnvelope)];
+                case 61:
+                    decrypted = _q.sent();
+                    console.log("\u2705 ".concat(memberId, " decrypted after rotation: \"").concat(decrypted, "\""));
+                    postRotationSuccess++;
+                    return [3 /*break*/, 63];
+                case 62:
+                    error_3 = _q.sent();
+                    console.error("\u274C ".concat(memberId, " failed to decrypt after rotation:"), error_3);
+                    return [3 /*break*/, 63];
+                case 63:
+                    managers_3_1 = managers_3.next();
+                    return [3 /*break*/, 59];
+                case 64: return [3 /*break*/, 67];
+                case 65:
+                    e_7_1 = _q.sent();
+                    e_7 = { error: e_7_1 };
+                    return [3 /*break*/, 67];
+                case 66:
+                    try {
+                        if (managers_3_1 && !managers_3_1.done && (_o = managers_3.return)) _o.call(managers_3);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                    return [7 /*endfinally*/];
+                case 67:
+                    console.log("\n🎉 MLS Working Multi-Member Test completed!");
+                    console.log("\u2705 Group creation with ".concat(members.length, " members"));
+                    console.log("\u2705 Bidirectional encrypted messaging");
+                    console.log("\u2705 Key rotation and forward secrecy");
+                    console.log("\u2705 All members can send and receive messages");
+                    // Cleanup
+                    console.log("\n📋 Cleanup");
+                    _q.label = 68;
+                case 68:
+                    _q.trys.push([68, 73, 74, 75]);
+                    managers_4 = __values(managers), managers_4_1 = managers_4.next();
+                    _q.label = 69;
+                case 69:
+                    if (!!managers_4_1.done) return [3 /*break*/, 72];
+                    _e = __read(managers_4_1.value, 2), memberId = _e[0], manager = _e[1];
+                    return [4 /*yield*/, manager.destroy()];
+                case 70:
+                    _q.sent();
+                    console.log("\u2705 ".concat(memberId, " destroyed"));
+                    _q.label = 71;
+                case 71:
+                    managers_4_1 = managers_4.next();
+                    return [3 /*break*/, 69];
+                case 72: return [3 /*break*/, 75];
+                case 73:
+                    e_8_1 = _q.sent();
+                    e_8 = { error: e_8_1 };
+                    return [3 /*break*/, 75];
+                case 74:
+                    try {
+                        if (managers_4_1 && !managers_4_1.done && (_p = managers_4.return)) _p.call(managers_4);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                    return [7 /*endfinally*/];
+                case 75: return [3 /*break*/, 77];
+                case 76:
+                    error_4 = _q.sent();
+                    console.error("❌ Test failed:", error_4);
+                    return [3 /*break*/, 77];
+                case 77: return [2 /*return*/];
+            }
+        });
+    });
+}
+// Run the test
+if (require.main === module) {
+    testMLSWorkingMultiMembers().catch(console.error);
+}
+export { testMLSWorkingMultiMembers };