ts-mls/dist/test/scenario/requiredCapabilites.test.js

[](https://github.com/LukaJCB/ts-mls/actions/workflows/ci.yml) [](https://badge.fury.io/js/ts-mls) [![Coverage Status](https://co

import { createGroup, joinGroup } from "../../src/clientState";
import { createCommit } from "../../src/createCommit";
import { emptyPskIndex } from "../../src/pskIndex";
import { getCiphersuiteImpl, getCiphersuiteFromName, ciphersuites } from "../../src/crypto/ciphersuite";
import { generateKeyPackage } from "../../src/keyPackage";
import { defaultLifetime } from "../../src/lifetime";
import { encodeRequiredCapabilities } from "../../src/requiredCapabilities";
import { ValidationError } from "../../src/mlsError";
for (const cs of Object.keys(ciphersuites)) {
    test(`Required Capabilities extension ${cs}`, async () => {
        await requiredCapatabilitiesTest(cs);
    });
}
async function requiredCapatabilitiesTest(cipherSuite) {
    const impl = await getCiphersuiteImpl(getCiphersuiteFromName(cipherSuite));
    const requiredCapabilities = {
        extensionTypes: [7, 8],
        credentialTypes: ["x509", "basic"],
        proposalTypes: [],
    };
    const capabilities = {
        extensions: [7, 8, 9],
        credentials: ["x509", "basic"],
        proposals: [],
        versions: ["mls10"],
        ciphersuites: [cipherSuite],
    };
    const aliceCredential = { credentialType: "basic", identity: new TextEncoder().encode("alice") };
    const alice = await generateKeyPackage(aliceCredential, capabilities, defaultLifetime, [], impl);
    const groupId = new TextEncoder().encode("group1");
    const requiredCapabilitiesExtension = {
        extensionType: "required_capabilities",
        extensionData: encodeRequiredCapabilities(requiredCapabilities),
    };
    let aliceGroup = await createGroup(groupId, alice.publicPackage, alice.privatePackage, [requiredCapabilitiesExtension], impl);
    const bobCredential = { credentialType: "basic", identity: new TextEncoder().encode("bob") };
    const bob = await generateKeyPackage(bobCredential, capabilities, defaultLifetime, [], impl);
    const minimalCapabilites = {
        extensions: [],
        credentials: ["basic"],
        proposals: [],
        versions: ["mls10"],
        ciphersuites: [cipherSuite],
    };
    const charlieCredential = { credentialType: "basic", identity: new TextEncoder().encode("charlie") };
    const charlie = await generateKeyPackage(charlieCredential, minimalCapabilites, defaultLifetime, [], impl);
    const addBobProposal = {
        proposalType: "add",
        add: {
            keyPackage: bob.publicPackage,
        },
    };
    const addBobCommitResult = await createCommit(aliceGroup, emptyPskIndex, false, [addBobProposal], impl);
    aliceGroup = addBobCommitResult.newState;
    let bobGroup = await joinGroup(addBobCommitResult.welcome, bob.publicPackage, bob.privatePackage, emptyPskIndex, impl, aliceGroup.ratchetTree);
    expect(bobGroup.keySchedule.epochAuthenticator).toStrictEqual(aliceGroup.keySchedule.epochAuthenticator);
    const addCharlieProposal = {
        proposalType: "add",
        add: {
            keyPackage: charlie.publicPackage,
        },
    };
    await expect(createCommit(aliceGroup, emptyPskIndex, false, [addCharlieProposal], impl)).rejects.toThrow(ValidationError);
}
//# sourceMappingURL=requiredCapabilites.test.js.map