@reclaimprotocol/attestor-core 3.0.1

package/lib/types/providers.gen.d.ts

@@ -0,0 +1,414 @@
+type BinaryData = Uint8Array | string;
+export interface HttpProviderParameters {
+    /**
+     * which URL does the request have to be made to Has to be a valid https URL for eg. https://amazon.in/orders?q=abcd
+     */
+    url: string;
+    method: "GET" | "POST" | "PUT" | "PATCH";
+    /**
+     * Specify the geographical location from where to proxy the request. 2-letter ISO country code
+     */
+    geoLocation?: string;
+    /**
+     * Any additional headers to be sent with the request Note: these will be revealed to the attestor & won't be redacted from the transcript. To add hidden headers, use 'secretParams.headers' instead
+     */
+    headers?: {
+        [k: string]: string;
+    };
+    /**
+     * Body of the HTTP request
+     */
+    body?: BinaryData;
+    /**
+     * If the API doesn't perform well with the "key-update" method of redaction, you can switch to "zk" mode by setting this to "zk"
+     */
+    writeRedactionMode?: "zk" | "key-update";
+    /**
+     * Apply TLS configuration when creating the tunnel to the attestor.
+     */
+    additionalClientOptions?: {
+        /**
+         * @minItems 1
+         */
+        supportedProtocolVersions?: ("TLS1_2" | "TLS1_3")[];
+    };
+    /**
+     * The attestor will use this list to check that the redacted response does indeed match all the provided strings/regexes
+     *
+     * @minItems 1
+     */
+    responseMatches: {
+        /**
+         * "regex": the response must match the regex "contains": the response must contain the provided
+         *  string exactly
+         */
+        value: string;
+        /**
+         * The string/regex to match against
+         */
+        type: "regex" | "contains";
+        /**
+         * Inverses the matching logic. Fail when match is found and proceed otherwise
+         */
+        invert?: boolean;
+    }[];
+    /**
+     * which portions to select from a response. These are selected in order, xpath => jsonPath => regex * These redactions are done client side and only the selected portions are sent to the attestor. The attestor will only be able to see the selected portions alongside the first line of the HTTP response (i.e. "HTTP/1.1 200 OK") * To disable any redactions, pass an empty array
+     */
+    responseRedactions?: {
+        /**
+         * expect an HTML response, and to contain a certain xpath for eg. "/html/body/div.a1/div.a2/span.a5"
+         */
+        xPath?: string;
+        /**
+         * expect a JSON response, retrieve the item at this path using dot notation for e.g. 'email.addresses.0'
+         */
+        jsonPath?: string;
+        /**
+         * select a regex match from the response
+         */
+        regex?: string;
+    }[];
+    /**
+     * A map of parameter values which are user in form of {{param}} in URL, responseMatches, responseRedactions, body, geolocation. Those in URL, responseMatches & geo will be put into context and signed This value will NOT be included in provider hash
+     */
+    paramValues?: {
+        [k: string]: string;
+    };
+}
+export declare const HttpProviderParametersJson: {
+    title: string;
+    type: string;
+    required: string[];
+    properties: {
+        url: {
+            type: string;
+            format: string;
+            description: string;
+        };
+        method: {
+            type: string;
+            enum: string[];
+        };
+        geoLocation: {
+            type: string;
+            nullable: boolean;
+            pattern: string;
+            description: string;
+        };
+        headers: {
+            type: string;
+            description: string;
+            additionalProperties: {
+                type: string;
+            };
+        };
+        body: {
+            description: string;
+            oneOf: ({
+                type: string;
+                format: string;
+            } | {
+                type: string;
+                format?: undefined;
+            })[];
+        };
+        writeRedactionMode: {
+            type: string;
+            description: string;
+            enum: string[];
+        };
+        additionalClientOptions: {
+            type: string;
+            description: string;
+            nullable: boolean;
+            properties: {
+                supportedProtocolVersions: {
+                    type: string;
+                    minItems: number;
+                    uniqueItems: boolean;
+                    items: {
+                        type: string;
+                        enum: string[];
+                    };
+                };
+            };
+        };
+        responseMatches: {
+            type: string;
+            minItems: number;
+            uniqueItems: boolean;
+            description: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    value: {
+                        type: string;
+                        description: string;
+                    };
+                    type: {
+                        type: string;
+                        description: string;
+                        enum: string[];
+                    };
+                    invert: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        responseRedactions: {
+            type: string;
+            uniqueItems: boolean;
+            description: string;
+            items: {
+                type: string;
+                properties: {
+                    xPath: {
+                        type: string;
+                        nullable: boolean;
+                        description: string;
+                    };
+                    jsonPath: {
+                        type: string;
+                        nullable: boolean;
+                        description: string;
+                    };
+                    regex: {
+                        type: string;
+                        nullable: boolean;
+                        description: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        paramValues: {
+            type: string;
+            description: string;
+            additionalProperties: {
+                type: string;
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+/**
+ * Secret parameters to be used with HTTP provider. None of the values in this object will be shown to the attestor
+ */
+export interface HttpProviderSecretParameters {
+    /**
+     * cookie string for authorisation.
+     */
+    cookieStr?: string;
+    /**
+     * authorisation header value
+     */
+    authorisationHeader?: string;
+    /**
+     * Headers that need to be hidden from the attestor
+     */
+    headers?: {
+        [k: string]: string;
+    };
+    /**
+     * A map of parameter values which are user in form of {{param}} in body these parameters will NOT be shown to attestor and extracted
+     */
+    paramValues?: {
+        [k: string]: string;
+    };
+}
+export declare const HttpProviderSecretParametersJson: {
+    title: string;
+    type: string;
+    description: string;
+    properties: {
+        cookieStr: {
+            type: string;
+            description: string;
+        };
+        authorisationHeader: {
+            type: string;
+            description: string;
+        };
+        headers: {
+            type: string;
+            description: string;
+            additionalProperties: {
+                type: string;
+            };
+        };
+        paramValues: {
+            type: string;
+            description: string;
+            additionalProperties: {
+                type: string;
+            };
+        };
+    };
+    additionalProperties: boolean;
+};
+export interface ProvidersConfig {
+    http: {
+        parameters: HttpProviderParameters;
+        secretParameters: HttpProviderSecretParameters;
+    };
+}
+export declare const PROVIDER_SCHEMAS: {
+    http: {
+        parameters: {
+            title: string;
+            type: string;
+            required: string[];
+            properties: {
+                url: {
+                    type: string;
+                    format: string;
+                    description: string;
+                };
+                method: {
+                    type: string;
+                    enum: string[];
+                };
+                geoLocation: {
+                    type: string;
+                    nullable: boolean;
+                    pattern: string;
+                    description: string;
+                };
+                headers: {
+                    type: string;
+                    description: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+                body: {
+                    description: string;
+                    oneOf: ({
+                        type: string;
+                        format: string;
+                    } | {
+                        type: string;
+                        format?: undefined;
+                    })[];
+                };
+                writeRedactionMode: {
+                    type: string;
+                    description: string;
+                    enum: string[];
+                };
+                additionalClientOptions: {
+                    type: string;
+                    description: string;
+                    nullable: boolean;
+                    properties: {
+                        supportedProtocolVersions: {
+                            type: string;
+                            minItems: number;
+                            uniqueItems: boolean;
+                            items: {
+                                type: string;
+                                enum: string[];
+                            };
+                        };
+                    };
+                };
+                responseMatches: {
+                    type: string;
+                    minItems: number;
+                    uniqueItems: boolean;
+                    description: string;
+                    items: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            value: {
+                                type: string;
+                                description: string;
+                            };
+                            type: {
+                                type: string;
+                                description: string;
+                                enum: string[];
+                            };
+                            invert: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
+                };
+                responseRedactions: {
+                    type: string;
+                    uniqueItems: boolean;
+                    description: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            xPath: {
+                                type: string;
+                                nullable: boolean;
+                                description: string;
+                            };
+                            jsonPath: {
+                                type: string;
+                                nullable: boolean;
+                                description: string;
+                            };
+                            regex: {
+                                type: string;
+                                nullable: boolean;
+                                description: string;
+                            };
+                        };
+                        additionalProperties: boolean;
+                    };
+                };
+                paramValues: {
+                    type: string;
+                    description: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            additionalProperties: boolean;
+        };
+        secretParameters: {
+            title: string;
+            type: string;
+            description: string;
+            properties: {
+                cookieStr: {
+                    type: string;
+                    description: string;
+                };
+                authorisationHeader: {
+                    type: string;
+                    description: string;
+                };
+                headers: {
+                    type: string;
+                    description: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+                paramValues: {
+                    type: string;
+                    description: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            additionalProperties: boolean;
+        };
+    };
+};
+export {};

package/lib/types/providers.gen.js

@@ -0,0 +1,14 @@
+"use strict";
+/* eslint-disable */
+/* Generated file. Do not edit */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_SCHEMAS = exports.HttpProviderSecretParametersJson = exports.HttpProviderParametersJson = void 0;
+exports.HttpProviderParametersJson = { "title": "HttpProviderParameters", "type": "object", "required": ["url", "method", "responseMatches"], "properties": { "url": { "type": "string", "format": "url", "description": "which URL does the request have to be made to Has to be a valid https URL for eg. https://amazon.in/orders?q=abcd" }, "method": { "type": "string", "enum": ["GET", "POST", "PUT", "PATCH"] }, "geoLocation": { "type": "string", "nullable": true, "pattern": "^[A-Za-z]{0,2}$", "description": "Specify the geographical location from where to proxy the request. 2-letter ISO country code" }, "headers": { "type": "object", "description": "Any additional headers to be sent with the request Note: these will be revealed to the attestor & won't be redacted from the transcript. To add hidden headers, use 'secretParams.headers' instead", "additionalProperties": { "type": "string" } }, "body": { "description": "Body of the HTTP request", "oneOf": [{ "type": "string", "format": "binary" }, { "type": "string" }] }, "writeRedactionMode": { "type": "string", "description": "If the API doesn't perform well with the \"key-update\" method of redaction, you can switch to \"zk\" mode by setting this to \"zk\"", "enum": ["zk", "key-update"] }, "additionalClientOptions": { "type": "object", "description": "Apply TLS configuration when creating the tunnel to the attestor.", "nullable": true, "properties": { "supportedProtocolVersions": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string", "enum": ["TLS1_2", "TLS1_3"] } } } }, "responseMatches": { "type": "array", "minItems": 1, "uniqueItems": true, "description": "The attestor will use this list to check that the redacted response does indeed match all the provided strings/regexes", "items": { "type": "object", "required": ["value", "type"], "properties": { "value": { "type": "string", "description": "\"regex\": the response must match the regex \"contains\": the response must contain the provided\n string exactly" }, "type": { "type": "string", "description": "The string/regex to match against", "enum": ["regex", "contains"] }, "invert": { "type": "boolean", "description": "Inverses the matching logic. Fail when match is found and proceed otherwise" } }, "additionalProperties": false } }, "responseRedactions": { "type": "array", "uniqueItems": true, "description": "which portions to select from a response. These are selected in order, xpath => jsonPath => regex * These redactions are done client side and only the selected portions are sent to the attestor. The attestor will only be able to see the selected portions alongside the first line of the HTTP response (i.e. \"HTTP/1.1 200 OK\") * To disable any redactions, pass an empty array", "items": { "type": "object", "properties": { "xPath": { "type": "string", "nullable": true, "description": "expect an HTML response, and to contain a certain xpath for eg. \"/html/body/div.a1/div.a2/span.a5\"" }, "jsonPath": { "type": "string", "nullable": true, "description": "expect a JSON response, retrieve the item at this path using dot notation for e.g. 'email.addresses.0'" }, "regex": { "type": "string", "nullable": true, "description": "select a regex match from the response" } }, "additionalProperties": false } }, "paramValues": { "type": "object", "description": "A map of parameter values which are user in form of {{param}} in URL, responseMatches, responseRedactions, body, geolocation. Those in URL, responseMatches & geo will be put into context and signed This value will NOT be included in provider hash", "additionalProperties": { "type": "string" } } }, "additionalProperties": false };
+exports.HttpProviderSecretParametersJson = { "title": "HttpProviderSecretParameters", "type": "object", "description": "Secret parameters to be used with HTTP provider. None of the values in this object will be shown to the attestor", "properties": { "cookieStr": { "type": "string", "description": "cookie string for authorisation." }, "authorisationHeader": { "type": "string", "description": "authorisation header value" }, "headers": { "type": "object", "description": "Headers that need to be hidden from the attestor", "additionalProperties": { "type": "string" } }, "paramValues": { "type": "object", "description": "A map of parameter values which are user in form of {{param}} in body these parameters will NOT be shown to attestor and extracted", "additionalProperties": { "type": "string" } } }, "additionalProperties": false };
+exports.PROVIDER_SCHEMAS = {
+    http: {
+        parameters: exports.HttpProviderParametersJson,
+        secretParameters: exports.HttpProviderSecretParametersJson
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/providers.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL3Byb3ZpZGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/lib/types/rpc.d.ts

@@ -0,0 +1,35 @@
+import type { RPCMessage, TunnelDisconnectEvent, TunnelMessage } from 'src/proto/api';
+import type { AttestorError } from 'src/utils/error';
+type ExtractPrefix<T, S extends string> = T extends `${infer _}${S}` ? _ : never;
+export type RPCType = ExtractPrefix<keyof RPCMessage, 'Request'>;
+type RPCRequestType<T extends RPCType> = `${T}Request`;
+type RPCResponseType<T extends RPCType> = `${T}Response`;
+export type RPCRequestData<T extends RPCType> = Exclude<RPCMessage[RPCRequestType<T>], undefined>;
+export type RPCResponseData<T extends RPCType> = Exclude<RPCMessage[RPCResponseType<T>], undefined>;
+export type RPCRequest<T extends RPCType> = {
+    requestId: RPCMessage['id'];
+    type: T;
+    data: RPCRequestData<T>;
+    respond(res: RPCResponseData<T> | AttestorError): void;
+};
+export type RPCResponse<T extends RPCType> = {
+    id: RPCMessage['id'];
+    type: T;
+    data: RPCResponseData<T>;
+} | {
+    id: RPCMessage['id'];
+    error: AttestorError;
+};
+export type RPCEventMap = {
+    'connection-terminated': AttestorError;
+    'tunnel-message': TunnelMessage;
+    'tunnel-disconnect-event': TunnelDisconnectEvent;
+    'rpc-request': RPCRequest<RPCType>;
+    'rpc-response': RPCResponse<RPCType>;
+};
+export type RPCEventType = keyof RPCEventMap;
+export interface RPCEvent<T extends RPCEventType> extends Event {
+    type: T;
+    data: RPCEventMap[T];
+}
+export {};

package/lib/types/rpc.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnBjLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL3JwYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/lib/types/signatures.d.ts

@@ -0,0 +1,28 @@
+export type PrivateKey = string;
+type Awaitable<T> = T | Promise<T>;
+export type ServiceSignatureProvider = {
+    /**
+     * Returns public key in compressed (compact) format used in Reclaim RPC calls
+     * @param privateKey corresponding private key in raw o hex form
+     */
+    getPublicKey(privateKey: PrivateKey): Uint8Array;
+    /**
+     * Returns address corresponding to the provided public key
+     * @param publicKey raw o hex form, compressed or uncompressed
+     */
+    getAddress(publicKey: Uint8Array): string;
+    /**
+     * Signs data with the provided private key
+     * @param data raw data to be signed
+     * @param privateKey private key in raw or hex format
+     */
+    sign(data: Uint8Array, privateKey: PrivateKey): Awaitable<Uint8Array>;
+    /**
+     * Verifies signature against provided data and an address
+     * @param data raw data to be verified. Must be same as used in sign() call
+     * @param signature signature bytes or string
+     * @param addressBytes address corresponding to a public key
+     */
+    verify(data: Uint8Array, signature: Uint8Array | string, addressBytes: Uint8Array | string): Awaitable<boolean>;
+};
+export {};

package/lib/types/signatures.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmF0dXJlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9zaWduYXR1cmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/lib/types/tunnel.d.ts

@@ -0,0 +1,18 @@
+import type { CreateTunnelRequest } from 'src/proto/api';
+export type MakeTunnelBaseOpts<O> = O & {
+    onClose?(err?: Error): void;
+    onMessage?(data: Uint8Array): void;
+};
+export type Tunnel<E> = E & {
+    write(data: Uint8Array): void;
+    close(err?: Error): void;
+};
+export type MakeTunnelFn<O, E = {}> = (opts: MakeTunnelBaseOpts<O>) => (Tunnel<E> | Promise<Tunnel<E>>);
+export type Transcript<T> = {
+    sender: 'client' | 'server';
+    message: T;
+}[];
+export type TCPSocketProperties = {
+    transcript: Transcript<Uint8Array>;
+    createRequest: Pick<CreateTunnelRequest, 'host' | 'port' | 'geoLocation'>;
+};

package/lib/types/tunnel.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHVubmVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL3R1bm5lbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/lib/types/zk.d.ts

@@ -0,0 +1,16 @@
+import { EncryptionAlgorithm, ZKOperator } from '@reclaimprotocol/circom-symmetric-crypto';
+export type ZKOperators = {
+    [E in EncryptionAlgorithm]?: ZKOperator;
+};
+export type ZKEngine = 'snarkJS' | 'gnark';
+export type PrepareZKProofsBaseOpts = {
+    /** get ZK operator for specified algorithm */
+    zkOperators?: ZKOperators;
+    /**
+     * max number of ZK proofs to generate concurrently
+     * @default 1
+     */
+    zkProofConcurrency?: number;
+    maxZkChunks?: number;
+    zkEngine?: ZKEngine;
+};

package/lib/types/zk.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvemsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/lib/utils/benchmark.d.ts

@@ -0,0 +1 @@
+export declare function Benchmark(): Promise<string>;

package/lib/utils/benchmark.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Benchmark = Benchmark;
+const tls_1 = require("@reclaimprotocol/tls");
+const logger_1 = require("src/utils/logger");
+const zk_1 = require("src/utils/zk");
+const ZK_CIPHER_SUITES = [
+    'TLS_CHACHA20_POLY1305_SHA256',
+    'TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384',
+    'TLS_AES_128_GCM_SHA256'
+];
+async function Benchmark() {
+    let benchmarkRes = '';
+    for (const cipherSuite of ZK_CIPHER_SUITES) {
+        const now = Date.now();
+        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);
+        const { ivLength: fixedIvLength, } = tls_1.SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+        const fixedIv = Buffer.alloc(fixedIvLength, 0);
+        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'
+            }
+        ];
+        const proofGenerator = await (0, zk_1.makeZkProofGenerator)({
+            logger: logger_1.logger,
+            cipherSuite,
+        });
+        for (const { plaintext } of vectors) {
+            const plaintextArr = (0, tls_1.strToUint8Array)(plaintext);
+            const { ciphertext, iv } = await (0, tls_1.encryptWrappedRecord)(plaintextArr, {
+                key: encKey,
+                iv: fixedIv,
+                recordNumber: 0,
+                recordHeaderOpts: {
+                    type: 'WRAPPED_RECORD'
+                },
+                cipherSuite,
+                version: cipherSuite.includes('ECDHE_')
+                    ? 'TLS1_2'
+                    : 'TLS1_3',
+            });
+            const packet = {
+                type: 'ciphertext',
+                encKey,
+                iv,
+                recordNumber: 0,
+                plaintext: plaintextArr,
+                ciphertext,
+                fixedIv: new Uint8Array(0),
+                data: ciphertext
+            };
+            await proofGenerator.addPacketToProve(packet, {
+                type: 'zk',
+                redactedPlaintext: plaintextArr,
+            }, () => { });
+            await proofGenerator.generateProofs();
+        }
+        benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms \n`;
+    }
+    logger_1.logger.info(benchmarkRes);
+    return benchmarkRes;
+}
+//# sourceMappingURL=data:application/json;base64,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