@reclaimprotocol/attestor-core 3.0.1

package/lib/tests/test.http-provider.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/test.http-provider.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("src/client");
+const describe_with_server_1 = require("src/tests/describe-with-server");
+const utils_1 = require("src/tests/utils");
+jest.setTimeout(300000);
+(0, describe_with_server_1.describeWithServer)('HTTP Provider', opts => {
+    afterEach(async () => {
+        await (0, utils_1.verifyNoDirectRevealLeaks)();
+    });
+    it('should create claim with template params', async () => {
+        var _a;
+        const resp = await (0, client_1.createClaimOnAttestor)({
+            name: 'http',
+            params: {
+                url: 'https://example.{{param1}}/',
+                method: 'GET',
+                responseMatches: [{
+                        type: 'regex',
+                        value: '<title.*?(?<domain>{{param2}} Domain)<\\/title>',
+                    }],
+                responseRedactions: [{
+                        xPath: './html/head/{{param3}}',
+                    }],
+                paramValues: {
+                    param1: 'com',
+                    param2: 'Example',
+                    param3: 'title'
+                }
+            },
+            secretParams: {
+                cookieStr: '<cookie-str>'
+            },
+            ownerPrivateKey: opts.privateKeyHex,
+            client: opts.client,
+            zkEngine: 'gnark'
+        });
+        expect(resp.error).toBeUndefined();
+        expect((_a = resp.claim) === null || _a === void 0 ? void 0 : _a.context)
+            .toContain('0x3bfcf3bf17b83b9c37756d9becf87f76cad712304a23d3335f78e1cc96e83d1f');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5odHRwLXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RzL3Rlc3QuaHR0cC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHVDQUFrRDtBQUNsRCx5RUFBbUU7QUFDbkUsMkNBQTJEO0FBRTNELElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTyxDQUFDLENBQUE7QUFFeEIsSUFBQSx5Q0FBa0IsRUFBQyxlQUFlLEVBQUUsSUFBSSxDQUFDLEVBQUU7SUFFMUMsU0FBUyxDQUFDLEtBQUssSUFBRyxFQUFFO1FBQ25CLE1BQU0sSUFBQSxpQ0FBeUIsR0FBRSxDQUFBO0lBQ2xDLENBQUMsQ0FBQyxDQUFBO0lBRUYsRUFBRSxDQUFDLDBDQUEwQyxFQUFFLEtBQUssSUFBRyxFQUFFOztRQUN4RCxNQUFNLElBQUksR0FBRyxNQUFNLElBQUEsOEJBQXFCLEVBQUM7WUFDeEMsSUFBSSxFQUFFLE1BQU07WUFDWixNQUFNLEVBQUU7Z0JBQ1AsR0FBRyxFQUFFLDZCQUE2QjtnQkFDbEMsTUFBTSxFQUFFLEtBQUs7Z0JBQ2IsZUFBZSxFQUFFLENBQUM7d0JBQ2pCLElBQUksRUFBRSxPQUFPO3dCQUNiLEtBQUssRUFBRSxpREFBaUQ7cUJBQ3hELENBQUM7Z0JBQ0Ysa0JBQWtCLEVBQUUsQ0FBQzt3QkFDcEIsS0FBSyxFQUFFLHdCQUF3QjtxQkFDL0IsQ0FBQztnQkFDRixXQUFXLEVBQUU7b0JBQ1osTUFBTSxFQUFFLEtBQUs7b0JBQ2IsTUFBTSxFQUFFLFNBQVM7b0JBQ2pCLE1BQU0sRUFBRSxPQUFPO2lCQUNmO2FBQ0Q7WUFDRCxZQUFZLEVBQUU7Z0JBQ2IsU0FBUyxFQUFFLGNBQWM7YUFDekI7WUFDRCxlQUFlLEVBQUUsSUFBSSxDQUFDLGFBQWE7WUFDbkMsTUFBTSxFQUFFLElBQUksQ0FBQyxNQUFNO1lBQ25CLFFBQVEsRUFBQyxPQUFPO1NBQ2hCLENBQUMsQ0FBQTtRQUNGLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsYUFBYSxFQUFFLENBQUE7UUFDbEMsTUFBTSxDQUFDLE1BQUEsSUFBSSxDQUFDLEtBQUssMENBQUUsT0FBTyxDQUFDO2FBQ3pCLFNBQVMsQ0FBQyxvRUFBb0UsQ0FBQyxDQUFBO0lBQ2xGLENBQUMsQ0FBQyxDQUFBO0FBQ0gsQ0FBQyxDQUFDLENBQUEifQ==

package/lib/tests/test.rpc-communication.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/test.rpc-communication.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("src/client");
+const describe_with_server_1 = require("src/tests/describe-with-server");
+const utils_1 = require("src/utils");
+const ws_1 = require("ws");
+(0, describe_with_server_1.describeWithServer)('RPC Communication', opts => {
+    const { getClientOnServer } = opts;
+    let client;
+    beforeEach(() => {
+        client = opts.client;
+    });
+    it('should successfully initialise a session', async () => {
+        await expect(client.waitForInit()).resolves.toBeUndefined();
+        expect(client.isInitialised).toBe(true);
+        // ensure the server has our client
+        expect(getClientOnServer()).toBeTruthy();
+    });
+    it('should gracefully handle terminated connection during init', async () => {
+        await client.terminateConnection();
+        client = new client_1.AttestorClient({
+            logger: utils_1.logger,
+            // a URL without a WS server
+            url: `ws://localhost:${opts.mockhttpsServerPort}`
+        });
+        await expect(client.waitForInit()).rejects.toHaveProperty('code');
+    });
+    it('should gracefully handle connection termination', async () => {
+        const err = new utils_1.AttestorError('ERROR_INTERNAL', 'Test error', { abcd: 1 });
+        const waitForEnd = new Promise(resolve => {
+            client.addEventListener('connection-terminated', d => {
+                resolve(d.data);
+            });
+        });
+        const ws = getClientOnServer();
+        await ws.terminateConnection(err);
+        const recvErr = await waitForEnd;
+        expect(recvErr).toEqual(err);
+        expect(client.isOpen).not.toBe(ws_1.WebSocket.OPEN);
+    });
+    it('should terminate connection to server', async () => {
+        const ws = getClientOnServer();
+        const waitForEnd = new Promise(resolve => {
+            ws.addEventListener('connection-terminated', d => {
+                resolve(d.data);
+            });
+        });
+        await client.terminateConnection();
+        await waitForEnd;
+    });
+    it('should handle RPC error response', async () => {
+        const err = new utils_1.AttestorError('ERROR_INTERNAL', 'Test error', { abcd: 1 });
+        const ws = getClientOnServer();
+        ws.addEventListener('rpc-request', ev => {
+            ev.stopImmediatePropagation();
+            ev.data.respond(err);
+        });
+        await expect(client.rpc('createTunnel', {
+            host: 'localhost',
+            port: 9999,
+        })).rejects.toMatchObject(err);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tests/test.rpc-tunnel.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/test.rpc-tunnel.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("src/client");
+const make_rpc_tcp_tunnel_1 = require("src/client/tunnels/make-rpc-tcp-tunnel");
+const make_rpc_tls_tunnel_1 = require("src/client/tunnels/make-rpc-tls-tunnel");
+const describe_with_server_1 = require("src/tests/describe-with-server");
+const utils_1 = require("src/tests/utils");
+const utils_2 = require("src/utils");
+(0, describe_with_server_1.describeWithServer)('RPC Tunnel', opts => {
+    const { mockHttpsServer, getClientOnServer } = opts;
+    let client;
+    beforeEach(async () => {
+        client = opts.client;
+    });
+    afterEach(async () => {
+        await client.terminateConnection();
+    });
+    it('should connect to a server via RPC tunnel', async () => {
+        // setup tunnel for listening & then
+        // connect to it via RPC
+        const tunnel = await (0, make_rpc_tcp_tunnel_1.makeRpcTcpTunnel)({ tunnelId: 1, client });
+        await client.rpc('createTunnel', {
+            id: 1,
+            host: 'localhost',
+            port: opts.mockhttpsServerPort,
+            geoLocation: ''
+        });
+        const ws = getClientOnServer();
+        const socketTunnel = ws === null || ws === void 0 ? void 0 : ws.tunnels[1];
+        expect(socketTunnel).toBeTruthy();
+        await tunnel.close();
+        // check that the server actually closed the tunnel
+        // upon our request
+        await expect(socketTunnel === null || socketTunnel === void 0 ? void 0 : socketTunnel.write(Buffer.from('hello'))).rejects.toMatchObject({
+            code: 'ERR_STREAM_WRITE_AFTER_END'
+        });
+    });
+    describe('TLS', () => {
+        it('should do a TLS handshake via RPC tunnel', async () => {
+            const ws = getClientOnServer();
+            const tunnel = await (0, make_rpc_tls_tunnel_1.makeRpcTlsTunnel)({
+                request: {
+                    id: 1,
+                    host: 'localhost',
+                    port: opts.mockhttpsServerPort,
+                },
+                tlsOpts: {
+                    verifyServerCertificate: false,
+                },
+                logger: client.logger,
+                connect(initMessages) {
+                    client.sendMessage(...initMessages);
+                    // ensure that the client hello message
+                    // was sent to the server along the
+                    // "createTunnel" request -- that saves
+                    // us a round-trip
+                    expect(initMessages[1].tunnelMessage)
+                        .toBeTruthy();
+                    return client;
+                },
+            });
+            expect(ws === null || ws === void 0 ? void 0 : ws.tunnels[1]).toBeTruthy();
+            await tunnel.close();
+        });
+        it('should setup a 0-RTT TLS connection', async () => {
+            let client2;
+            const tunnel = await (0, make_rpc_tls_tunnel_1.makeRpcTlsTunnel)({
+                request: {
+                    id: 1,
+                    host: 'localhost',
+                    port: opts.mockhttpsServerPort,
+                },
+                tlsOpts: {
+                    verifyServerCertificate: false,
+                },
+                logger: client.logger,
+                connect(initMessages) {
+                    client2 = new client_1.AttestorClient({
+                        url: opts.serverUrl,
+                        logger: utils_2.logger.child({ client: 2 }),
+                        initMessages
+                    });
+                    return client2;
+                },
+            });
+            await tunnel.close();
+            await (client2 === null || client2 === void 0 ? void 0 : client2.terminateConnection());
+        });
+        it('should gracefully handle a TLS disconnection alert', async () => {
+            let socket;
+            mockHttpsServer.server.once('secureConnection', s => {
+                socket = s;
+            });
+            let closeResolve;
+            await (0, make_rpc_tls_tunnel_1.makeRpcTlsTunnel)({
+                request: {
+                    id: 1,
+                    host: 'localhost',
+                    port: opts.mockhttpsServerPort,
+                },
+                tlsOpts: {
+                    verifyServerCertificate: false,
+                },
+                logger: client.logger,
+                connect(initMessages) {
+                    client.sendMessage(...initMessages);
+                    return client;
+                },
+                onClose(err) {
+                    closeResolve === null || closeResolve === void 0 ? void 0 : closeResolve(err);
+                },
+            });
+            await (0, utils_1.delay)(100);
+            expect(socket).toBeTruthy();
+            socket === null || socket === void 0 ? void 0 : socket.end();
+            const err = await new Promise((resolve) => {
+                closeResolve = resolve;
+            });
+            // since it was a graceful close, there should be no error
+            expect(err).toBeUndefined();
+        });
+        it('should handle TLS handshake errors', async () => {
+            await expect((0, make_rpc_tls_tunnel_1.makeRpcTlsTunnel)({
+                request: {
+                    id: 1,
+                    host: 'localhost',
+                    port: opts.mockhttpsServerPort,
+                },
+                tlsOpts: {
+                    applicationLayerProtocols: [
+                        'invalid-protocol'
+                    ]
+                },
+                logger: client.logger,
+                connect(initMessages) {
+                    client.sendMessage(...initMessages);
+                    return client;
+                },
+            })).rejects.toMatchObject({
+                message: /NO_APPLICATION_PROTOCOL/
+            });
+        });
+        it('should handle tunnel creation errors', async () => {
+            await expect((0, make_rpc_tls_tunnel_1.makeRpcTlsTunnel)({
+                request: {
+                    id: 1,
+                    host: 'localhost',
+                    port: opts.mockhttpsServerPort,
+                    // invalid geo location
+                    geoLocation: 'XZ'
+                },
+                tlsOpts: {
+                    applicationLayerProtocols: [
+                        'invalid-protocol'
+                    ]
+                },
+                logger: client.logger,
+                connect(initMessages) {
+                    client.sendMessage(...initMessages);
+                    return client;
+                },
+            })).rejects.toMatchObject({
+                message: /NO_APPLICATION_PROTOCOL/
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tests/test.signatures.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/test.signatures.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const api_1 = require("src/proto/api");
+const signatures_1 = require("src/utils/signatures");
+const ALGS = [
+    {
+        title: 'ETH',
+        algorithm: signatures_1.SIGNATURES[api_1.ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH]
+    }
+];
+describe.each(ALGS)('$title Signatures', ({ algorithm }) => {
+    it('should sign & verify', async () => {
+        const alice = ethers_1.Wallet.createRandom();
+        const data = Buffer.from('{"a":"123","b":123}', 'utf8');
+        const signature = await algorithm.sign(data, alice.privateKey);
+        const addr = algorithm.getAddress(ethers_1.utils.arrayify(alice.publicKey));
+        let res = await algorithm.verify(data, signature, addr);
+        expect(res).toBeTruthy();
+        res = await algorithm.verify(data, ethers_1.utils.hexlify(signature), addr);
+        expect(res).toBeTruthy();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5zaWduYXR1cmVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RzL3Rlc3Quc2lnbmF0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG1DQUFzQztBQUN0Qyx1Q0FBb0Q7QUFDcEQscURBQWlEO0FBRWpELE1BQU0sSUFBSSxHQUFHO0lBQ1o7UUFDQyxLQUFLLEVBQUUsS0FBSztRQUNaLFNBQVMsRUFBRSx1QkFBVSxDQUFDLDBCQUFvQixDQUFDLDBCQUEwQixDQUFDO0tBQ3RFO0NBQ0QsQ0FBQTtBQUVELFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsbUJBQW1CLEVBQUUsQ0FBQyxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUU7SUFFMUQsRUFBRSxDQUFDLHNCQUFzQixFQUFFLEtBQUssSUFBRyxFQUFFO1FBRXBDLE1BQU0sS0FBSyxHQUFHLGVBQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQTtRQUVuQyxNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLHFCQUFxQixFQUFFLE1BQU0sQ0FBQyxDQUFBO1FBQ3ZELE1BQU0sU0FBUyxHQUFHLE1BQU0sU0FBUyxDQUFDLElBQUksQ0FDckMsSUFBSSxFQUNKLEtBQUssQ0FBQyxVQUFVLENBQ2hCLENBQUE7UUFFRCxNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsVUFBVSxDQUFDLGNBQUssQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUE7UUFDbEUsSUFBSSxHQUFHLEdBQUcsTUFBTSxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxTQUFTLEVBQUUsSUFBSSxDQUFDLENBQUE7UUFFdkQsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFVBQVUsRUFBRSxDQUFBO1FBQ3hCLEdBQUcsR0FBRyxNQUFNLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLGNBQUssQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUE7UUFFbEUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFVBQVUsRUFBRSxDQUFBO0lBQ3pCLENBQUMsQ0FBQyxDQUFBO0FBQ0gsQ0FBQyxDQUFDLENBQUEifQ==

package/lib/tests/test.tcp-tunnel.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/test.tcp-tunnel.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tls_1 = require("@reclaimprotocol/tls");
+const server_1 = require("src/server");
+const utils_1 = require("src/utils");
+const DEMO_GEO_LOCATIONS = ['in', 'us'];
+jest.setTimeout(15000);
+describe('TCP Tunnel', () => {
+    it.each([...DEMO_GEO_LOCATIONS, 'none'])('should generate a session using a geoLocation (%s)', async (geoLocation) => {
+        const resParser = (0, utils_1.makeHttpResponseParser)();
+        let resolvePromise;
+        let rejectPromise;
+        const session = await (0, server_1.makeTcpTunnel)({
+            host: 'lumtest.com',
+            port: 80,
+            geoLocation: geoLocation === 'none' ? '' : geoLocation,
+            logger: utils_1.logger,
+            onClose(err) {
+                rejectPromise === null || rejectPromise === void 0 ? void 0 : rejectPromise(err || new Error('session closed'));
+            },
+            onMessage(data) {
+                resParser.onChunk(data);
+                if (resParser.res.complete) {
+                    resolvePromise === null || resolvePromise === void 0 ? void 0 : resolvePromise();
+                }
+            },
+        });
+        const waitForRes = new Promise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const str = 'GET /myip.json HTTP/1.1\r\nHost: lumtest.com\r\n\r\n';
+        await session.write((0, tls_1.strToUint8Array)(str));
+        await waitForRes;
+        await session.close();
+        expect(resParser.res.statusCode).toBe(200);
+        const resBody = (0, tls_1.uint8ArrayToStr)(resParser.res.body);
+        const resJson = JSON.parse(resBody);
+        if (geoLocation === 'none') {
+            return;
+        }
+        expect(resJson.country).toBe(geoLocation.toUpperCase());
+    });
+    it('should gracefully fail an invalid geoLocation', async () => {
+        await expect((0, server_1.makeTcpTunnel)({
+            host: 'lumtest.com',
+            port: 80,
+            geoLocation: 'xz',
+            logger: utils_1.logger,
+        })).rejects.toMatchObject({
+            message: /failed with status code: 400/
+        });
+    });
+    it('should connect to restricted server', async () => {
+        const session = await (0, server_1.makeTcpTunnel)({
+            host: 'servicos.acesso.gov.br',
+            port: 80,
+            geoLocation: 'US',
+            logger: utils_1.logger,
+        });
+        await session.close();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tests/test.zk.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/test.zk.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tls_1 = require("@reclaimprotocol/tls");
+const utils_1 = require("src/utils");
+const ZK_CIPHER_SUITES = [
+    'TLS_CHACHA20_POLY1305_SHA256',
+    'TLS_AES_128_GCM_SHA256',
+    'TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384',
+];
+const ZK_ENGINES = [
+    'gnark',
+    'snarkJS'
+];
+jest.setTimeout(90000); // 90s
+describe('ZK Tests', () => {
+    it('should correctly redact blocks', () => {
+        const vectors = [
+            {
+                input: [
+                    'hell',
+                    'o world'
+                ],
+                output: [
+                    'h***',
+                    '* world'
+                ],
+                redactions: [
+                    { fromIndex: 1, toIndex: 5 }
+                ]
+            },
+            {
+                input: [
+                    'hell',
+                    'o world'
+                ],
+                output: [
+                    // first block is completely
+                    // redacted, so it won't be included
+                    '* world'
+                ],
+                redactions: [
+                    { fromIndex: 0, toIndex: 5 }
+                ]
+            },
+            {
+                input: [
+                    'hello',
+                    'how',
+                    'do',
+                    'you',
+                    'do'
+                ],
+                output: [
+                    'he**o',
+                    'd*',
+                    'y*u',
+                    'do'
+                ],
+                redactions: [
+                    { fromIndex: 2, toIndex: 4 },
+                    { fromIndex: 5, toIndex: 8 },
+                    { fromIndex: 9, toIndex: 10 },
+                    { fromIndex: 11, toIndex: 12 }
+                ]
+            }
+        ];
+        for (const { input, output, redactions } of vectors) {
+            const realOutput = (0, utils_1.getBlocksToReveal)(input.map(i => ({ plaintext: Buffer.from(i) })), () => redactions);
+            if (realOutput === 'all') {
+                fail('should not return "all"');
+                continue;
+            }
+            expect(realOutput).toHaveLength(output.length);
+            for (const [i, element] of output.entries()) {
+                expect((0, utils_1.uint8ArrayToStr)(realOutput[i].redactedPlaintext)).toEqual(element);
+            }
+        }
+    });
+});
+describe.each(ZK_CIPHER_SUITES)('[%s] should generate ZK proof for some ciphertext', (cipherSuite) => {
+    describe.each(ZK_ENGINES)('[%s]', (zkEngine) => {
+        it(zkEngine + '-' + cipherSuite, async () => {
+            const alg = cipherSuite.includes('CHACHA20')
+                ? 'CHACHA20-POLY1305'
+                : (cipherSuite.includes('AES_256_GCM')
+                    ? 'AES-256-GCM'
+                    : 'AES-128-GCM');
+            const keylength = alg === 'AES-128-GCM' ? 16 : 32;
+            const key = Buffer.alloc(keylength, 0);
+            key[0] = 1;
+            key[3] = 4;
+            const { ivLength: fixedIvLength, } = tls_1.SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+            const fixedIv = Buffer.alloc(fixedIvLength, 0);
+            fixedIv[0] = 1;
+            fixedIv[3] = 4;
+            const encKey = await tls_1.crypto.importKey(alg, key);
+            const vectors = [
+                {
+                    plaintext: 'My cool API secret is "my name jeff". Please don\'t reveal it',
+                    redactions: [
+                        { fromIndex: 23, toIndex: 35 }
+                    ]
+                },
+                {
+                    plaintext: `lorem ipsum dolor sit amet, consectetur adipiscing elit,
+				sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+				Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
+				nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+				cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
+				cupidatat non proident, sunt in culpa qui officia deserunt mollit anim
+				id est laborum`,
+                    redactions: [
+                        { fromIndex: 5, toIndex: 15 },
+                    ]
+                }
+            ];
+            const proofGenerator = await (0, utils_1.makeZkProofGenerator)({
+                logger: utils_1.logger,
+                cipherSuite,
+                zkEngine: zkEngine
+            });
+            for (const { plaintext, redactions } of vectors) {
+                const plaintextArr = Buffer.from(plaintext);
+                const redactedPlaintext = (0, utils_1.redactSlices)(plaintextArr, redactions);
+                // ensure redaction fn kinda works at least
+                expect(redactedPlaintext).not.toEqual(plaintextArr);
+                const { ciphertext, iv } = await (0, tls_1.encryptWrappedRecord)(plaintextArr, {
+                    key: encKey,
+                    iv: fixedIv,
+                    recordNumber: 1234,
+                    recordHeaderOpts: {
+                        type: 'WRAPPED_RECORD'
+                    },
+                    cipherSuite,
+                    version: cipherSuite.includes('ECDHE_')
+                        ? 'TLS1_2'
+                        : 'TLS1_3',
+                });
+                const packet = {
+                    type: 'ciphertext',
+                    encKey,
+                    iv,
+                    recordNumber: 1234,
+                    plaintext: plaintextArr,
+                    ciphertext,
+                    fixedIv: fixedIv,
+                    data: ciphertext
+                };
+                let proofs;
+                await proofGenerator.addPacketToProve(packet, {
+                    type: 'zk',
+                    redactedPlaintext,
+                }, p => proofs = p);
+                await proofGenerator.generateProofs();
+                const x = await (0, utils_1.verifyZkPacket)({
+                    ciphertext,
+                    zkReveal: { proofs: proofs },
+                    logger: utils_1.logger,
+                    cipherSuite,
+                    zkEngine: zkEngine,
+                    recordNumber: 1234,
+                    iv: fixedIv
+                });
+                expect(redactedPlaintext).toEqual(x.redactedPlaintext);
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tests/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function delay(ms: number): Promise<unknown>;
+export declare function randomPrivateKey(): string;
+export declare function getRandomPort(): number;
+/**
+ * Verifies that no direct reveal accidentally leaked
+ * the key. This is done by checking that no other
+ * application data packets were sent with the same key
+ *
+ * Uses the spy on preparePacketsForReveal to get the
+ * tls transcript and reveals map that was used.
+ */
+export declare function verifyNoDirectRevealLeaks(): void;

package/lib/tests/utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+exports.randomPrivateKey = randomPrivateKey;
+exports.getRandomPort = getRandomPort;
+exports.verifyNoDirectRevealLeaks = verifyNoDirectRevealLeaks;
+const crypto_1 = require("crypto");
+const mocks_1 = require("src/tests/mocks");
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function randomPrivateKey() {
+    return '0x' + (0, crypto_1.randomBytes)(32).toString('hex');
+}
+function getRandomPort() {
+    return Math.floor(Math.random() * 5000 + 5000);
+}
+/**
+ * Verifies that no direct reveal accidentally leaked
+ * the key. This is done by checking that no other
+ * application data packets were sent with the same key
+ *
+ * Uses the spy on preparePacketsForReveal to get the
+ * tls transcript and reveals map that was used.
+ */
+function verifyNoDirectRevealLeaks() {
+    if (!mocks_1.SPY_PREPARER.mock.calls.length) {
+        return;
+    }
+    const [tlsTranscript, revealsMap] = mocks_1.SPY_PREPARER.mock.calls[0];
+    for (const [packet, reveal] of revealsMap.entries()) {
+        if (reveal.type !== 'complete') {
+            continue;
+        }
+        if (packet.type === 'plaintext') {
+            continue;
+        }
+        // find any other packets with the same key
+        // that do not have a reveal & were application data.
+        // If we find any, it means we've leaked the key
+        const otherPacketsWKey = tlsTranscript
+            .filter(({ message }) => (message.type === 'ciphertext'
+            && !revealsMap.get(message)
+            && message.encKey === packet.encKey
+            && message.contentType === 'APPLICATION_DATA'));
+        expect(otherPacketsWKey).toHaveLength(0);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdHMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxzQkFFQztBQUVELDRDQUVDO0FBRUQsc0NBRUM7QUFVRCw4REEyQkM7QUFsREQsbUNBQW9DO0FBQ3BDLDJDQUE4QztBQUU5QyxTQUFnQixLQUFLLENBQUMsRUFBVTtJQUMvQixPQUFPLElBQUksT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUE7QUFDekQsQ0FBQztBQUVELFNBQWdCLGdCQUFnQjtJQUMvQixPQUFPLElBQUksR0FBRyxJQUFBLG9CQUFXLEVBQUMsRUFBRSxDQUFDLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFBO0FBQzlDLENBQUM7QUFFRCxTQUFnQixhQUFhO0lBQzVCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsSUFBSSxHQUFHLElBQUksQ0FBQyxDQUFBO0FBQy9DLENBQUM7QUFFRDs7Ozs7OztHQU9HO0FBQ0gsU0FBZ0IseUJBQXlCO0lBQ3hDLElBQUcsQ0FBQyxvQkFBWSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDcEMsT0FBTTtJQUNQLENBQUM7SUFFRCxNQUFNLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQyxHQUFHLG9CQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUM5RCxLQUFJLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUM7UUFDcEQsSUFBRyxNQUFNLENBQUMsSUFBSSxLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQy9CLFNBQVE7UUFDVCxDQUFDO1FBRUQsSUFBRyxNQUFNLENBQUMsSUFBSSxLQUFLLFdBQVcsRUFBRSxDQUFDO1lBQ2hDLFNBQVE7UUFDVCxDQUFDO1FBRUQsMkNBQTJDO1FBQzNDLHFEQUFxRDtRQUNyRCxnREFBZ0Q7UUFDaEQsTUFBTSxnQkFBZ0IsR0FBRyxhQUFhO2FBQ3BDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQ3hCLE9BQU8sQ0FBQyxJQUFJLEtBQUssWUFBWTtlQUMxQixDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDO2VBQ3hCLE9BQU8sQ0FBQyxNQUFNLEtBQUssTUFBTSxDQUFDLE1BQU07ZUFDaEMsT0FBTyxDQUFDLFdBQVcsS0FBSyxrQkFBa0IsQ0FDN0MsQ0FBQyxDQUFBO1FBQ0gsTUFBTSxDQUFDLGdCQUFnQixDQUFDLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ3pDLENBQUM7QUFDRixDQUFDIn0=