@reclaimprotocol/attestor-core 3.0.1

package/lib/utils/generics.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unixTimestampSeconds = void 0;
+exports.uint8ArrayToStr = uint8ArrayToStr;
+exports.getTranscriptString = getTranscriptString;
+exports.findIndexInUint8Array = findIndexInUint8Array;
+exports.uint8ArrayToBinaryStr = uint8ArrayToBinaryStr;
+exports.gunzipSync = gunzipSync;
+exports.getZkAlgorithmForCipherSuite = getZkAlgorithmForCipherSuite;
+exports.getPureCiphertext = getPureCiphertext;
+exports.getRecordIV = getRecordIV;
+exports.getProviderValue = getProviderValue;
+exports.generateRpcMessageId = generateRpcMessageId;
+exports.generateSessionId = generateSessionId;
+exports.generateTunnelId = generateTunnelId;
+exports.makeRpcEvent = makeRpcEvent;
+exports.getRpcTypeFromKey = getRpcTypeFromKey;
+exports.getRpcResponseType = getRpcResponseType;
+exports.getRpcRequestType = getRpcRequestType;
+exports.isApplicationData = isApplicationData;
+exports.extractArrayBufferFromWsData = extractArrayBufferFromWsData;
+exports.getRpcRequest = getRpcRequest;
+exports.extractApplicationDataFromTranscript = extractApplicationDataFromTranscript;
+exports.extractHandshakeFromTranscript = extractHandshakeFromTranscript;
+exports.decryptDirect = decryptDirect;
+exports.packRpcMessages = packRpcMessages;
+exports.ethersStructToPlainObject = ethersStructToPlainObject;
+const circom_symmetric_crypto_1 = require("@reclaimprotocol/circom-symmetric-crypto");
+const tls_1 = require("@reclaimprotocol/tls");
+const api_1 = require("src/proto/api");
+const DEFAULT_REDACTION_DATA = new Uint8Array(4)
+    .fill(circom_symmetric_crypto_1.REDACTION_CHAR_CODE);
+function uint8ArrayToStr(arr) {
+    return new TextDecoder().decode(arr);
+}
+function getTranscriptString(receipt) {
+    var _a;
+    const applMsgs = extractApplicationDataFromTranscript(receipt);
+    const strList = [];
+    for (const { message, sender } of applMsgs) {
+        const content = uint8ArrayToStr(message);
+        if ((_a = strList[strList.length - 1]) === null || _a === void 0 ? void 0 : _a.startsWith(sender)) {
+            strList[strList.length - 1] += content;
+        }
+        else {
+            strList.push(`${sender}: ${content}`);
+        }
+    }
+    return strList.join('\n');
+}
+const unixTimestampSeconds = () => Math.floor(Date.now() / 1000);
+exports.unixTimestampSeconds = unixTimestampSeconds;
+/**
+ * Find index of needle in haystack
+ */
+function findIndexInUint8Array(haystack, needle) {
+    for (let i = 0; i < haystack.length; i++) {
+        if ((0, tls_1.areUint8ArraysEqual)(haystack.slice(i, i + needle.length), needle)) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * convert a Uint8Array to a binary encoded str
+ * from: https://github.com/feross/buffer/blob/795bbb5bda1b39f1370ebd784bea6107b087e3a7/index.js#L1063
+ * @param buf
+ * @returns
+ */
+function uint8ArrayToBinaryStr(buf) {
+    let ret = '';
+    for (const v of buf) {
+        (ret += String.fromCharCode(v));
+    }
+    return ret;
+}
+function gunzipSync(buf) {
+    const { gunzipSync } = require('zlib');
+    return gunzipSync(buf);
+}
+/**
+ * Fetch the ZK algorithm for the specified cipher suite
+ */
+function getZkAlgorithmForCipherSuite(cipherSuite) {
+    if (cipherSuite.includes('CHACHA20')) {
+        return 'chacha20';
+    }
+    if (cipherSuite.includes('AES_256_GCM')) {
+        return 'aes-256-ctr';
+    }
+    if (cipherSuite.includes('AES_128_GCM')) {
+        return 'aes-128-ctr';
+    }
+    throw new Error(`${cipherSuite} not supported for ZK ops`);
+}
+/**
+ * Get the pure ciphertext without any MAC,
+ * or authentication tag,
+ * @param content content w/o header
+ * @param cipherSuite
+ */
+function getPureCiphertext(content, cipherSuite) {
+    // assert that the cipher suite is supported
+    getZkAlgorithmForCipherSuite(cipherSuite);
+    // 16 => auth tag length
+    content = content.slice(0, -16);
+    const { ivLength: fixedIvLength, } = tls_1.SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+    // 12 => total IV length
+    const recordIvLength = 12 - fixedIvLength;
+    // record IV is prefixed to the ciphertext
+    content = content.slice(recordIvLength);
+    return content;
+}
+/**
+ * Get the 8 byte IV part that's stored in the record for some cipher suites
+ * @param content content w/o header
+ * @param cipherSuite
+ */
+function getRecordIV(content, cipherSuite) {
+    // assert that the cipher suite is supported
+    getZkAlgorithmForCipherSuite(cipherSuite);
+    const { ivLength: fixedIvLength, } = tls_1.SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+    // 12 => total IV length
+    const recordIvLength = 12 - fixedIvLength;
+    return content.slice(0, recordIvLength);
+}
+function getProviderValue(params, fn) {
+    return typeof fn === 'function'
+        // @ts-ignore
+        ? fn(params)
+        : fn;
+}
+function generateRpcMessageId() {
+    return (0, tls_1.uint8ArrayToDataView)(tls_1.crypto.randomBytes(8)).getUint32(0);
+}
+/**
+ * Random session ID for a WebSocket client.
+ */
+function generateSessionId() {
+    return generateRpcMessageId();
+}
+/**
+ * Random ID for a tunnel.
+ */
+function generateTunnelId() {
+    return generateRpcMessageId();
+}
+function makeRpcEvent(type, data) {
+    const ev = new Event(type);
+    ev.data = data;
+    return ev;
+}
+/**
+ * Get the RPC type from the key.
+ * For eg. "claimTunnelRequest" ->
+ *    { type: 'claimTunnel', direction: 'request' }
+ */
+function getRpcTypeFromKey(key) {
+    if (key.endsWith('Request')) {
+        return {
+            type: key.slice(0, -7),
+            direction: 'request'
+        };
+    }
+    if (key.endsWith('Response')) {
+        return {
+            type: key.slice(0, -8),
+            direction: 'response'
+        };
+    }
+}
+/**
+ * Get the RPC response type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelResponse"
+ */
+function getRpcResponseType(type) {
+    return `${type}Response`;
+}
+/**
+ * Get the RPC request type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelRequest"
+ */
+function getRpcRequestType(type) {
+    return `${type}Request`;
+}
+function isApplicationData(packet, tlsVersion) {
+    return packet.type === 'ciphertext'
+        && (packet.contentType === 'APPLICATION_DATA'
+            || (packet.data[0] === tls_1.PACKET_TYPE.WRAPPED_RECORD
+                && tlsVersion === 'TLS1_2'));
+}
+/**
+ * Convert the received data from a WS to a Uint8Array
+ */
+async function extractArrayBufferFromWsData(data) {
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    // uint8array/Buffer
+    if (typeof data === 'object' && data && 'buffer' in data) {
+        return data;
+    }
+    if (typeof data === 'string') {
+        return (0, tls_1.strToUint8Array)(data);
+    }
+    if (data instanceof Blob) {
+        return new Uint8Array(await data.arrayBuffer());
+    }
+    throw new Error('unsupported data: ' + String(data));
+}
+/**
+ * Check if the RPC message is a request or a response.
+ */
+function getRpcRequest(msg) {
+    if (msg.requestError) {
+        return {
+            direction: 'response',
+            type: 'error'
+        };
+    }
+    for (const key in msg) {
+        if (!msg[key]) {
+            continue;
+        }
+        const rpcType = getRpcTypeFromKey(key);
+        if (!rpcType) {
+            continue;
+        }
+        return rpcType;
+    }
+}
+/**
+ * Finds all application data messages in a transcript
+ * and returns them. Removes the "contentType" suffix from the message.
+ * in TLS 1.3
+ */
+function extractApplicationDataFromTranscript({ transcript, tlsVersion }) {
+    const msgs = [];
+    for (const m of transcript) {
+        let message;
+        // redacted msgs but with a valid packet header
+        // can be considered application data messages
+        if (m.redacted) {
+            if (!m.plaintextLength) {
+                message = DEFAULT_REDACTION_DATA;
+            }
+            else {
+                const len = tlsVersion === 'TLS1_3'
+                    // remove content type suffix
+                    ? m.plaintextLength - 1
+                    : m.plaintextLength;
+                message = new Uint8Array(len)
+                    .fill(circom_symmetric_crypto_1.REDACTION_CHAR_CODE);
+            }
+            // otherwise, we need to check the content type
+        }
+        else if (tlsVersion === 'TLS1_3') {
+            const contentType = m.message[m.message.length - 1];
+            if (contentType !== tls_1.CONTENT_TYPE_MAP['APPLICATION_DATA']) {
+                continue;
+            }
+            message = m.message.slice(0, -1);
+        }
+        else if (m.recordHeader[0] === tls_1.PACKET_TYPE.WRAPPED_RECORD) {
+            message = m.message;
+        }
+        else {
+            continue;
+        }
+        msgs.push({ message, sender: m.sender });
+    }
+    return msgs;
+}
+function extractHandshakeFromTranscript({ transcript, tlsVersion }) {
+    const msgs = [];
+    for (const [i, m] of transcript.entries()) {
+        if (m.redacted) {
+            break; // stop at first encrypted message
+        }
+        let message;
+        if (m.recordHeader[0] === tls_1.PACKET_TYPE.HELLO) {
+            message = m.message;
+        }
+        else if (m.recordHeader[0] === tls_1.PACKET_TYPE.WRAPPED_RECORD) {
+            if (tlsVersion === 'TLS1_3') {
+                const contentType = m.message[m.message.length - 1];
+                if (contentType !== tls_1.CONTENT_TYPE_MAP['HANDSHAKE']) {
+                    break;
+                }
+                message = m.message.slice(0, -1);
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            continue;
+        }
+        if (!message.length) {
+            throw new Error('unsupported handshake message');
+        }
+        msgs.push({ message, sender: m.sender, index: i });
+    }
+    return msgs;
+}
+async function decryptDirect(directReveal, cipherSuite, recordHeader, serverTlsVersion, content) {
+    const { key, iv, recordNumber } = directReveal;
+    const { cipher } = tls_1.SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+    const importedKey = await tls_1.crypto.importKey(cipher, key);
+    return await (0, tls_1.decryptWrappedRecord)(content, {
+        iv,
+        key: importedKey,
+        recordHeader,
+        recordNumber,
+        version: serverTlsVersion,
+        cipherSuite,
+    });
+}
+function packRpcMessages(...msgs) {
+    return api_1.RPCMessages.create({
+        messages: msgs.map(msg => (api_1.RPCMessage.create({
+            ...msg,
+            id: msg.id || generateRpcMessageId()
+        })))
+    });
+}
+/**
+ * Converts an Ethers struct (an array w named keys) to
+ * a plain object. Recursively converts all structs inside.
+ * Required to correctly JSON.stringify the struct.
+ */
+function ethersStructToPlainObject(struct) {
+    if (!Array.isArray(struct)) {
+        return struct;
+    }
+    const namedKeys = Object.keys(struct)
+        .filter(key => isNaN(Number(key)));
+    // seems to be an actual array
+    if (!namedKeys.length) {
+        return struct.map(ethersStructToPlainObject);
+    }
+    const obj = {};
+    for (const key of namedKeys) {
+        obj[key] = ethersStructToPlainObject(struct[key]);
+    }
+    return obj;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generics.js","sourceRoot":"","sources":["../../src/utils/generics.ts"],"names":[],"mappings":"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"}

package/lib/utils/http-parser.d.ts

@@ -0,0 +1,55 @@
+import type { IncomingHttpHeaders } from 'http';
+import type { ArraySlice, Transcript } from 'src/types';
+export type HttpRequest = {
+    method: string;
+    url: string;
+    protocol: string;
+    headers: IncomingHttpHeaders;
+    body?: Uint8Array;
+};
+export type HttpResponse = {
+    statusCode: number;
+    statusMessage: string;
+    headers: IncomingHttpHeaders;
+    body: Uint8Array;
+    headersComplete: boolean;
+    complete: boolean;
+    /**
+     * Index of the first byte of the status line
+     */
+    statusLineEndIndex?: number;
+    /**
+     * Index of the first byte of the body
+     * in the complete response
+     */
+    bodyStartIndex?: number;
+    /**
+     * If using chunked transfer encoding,
+     * this will be set & contain indices of each
+     * chunk in the complete response
+     */
+    chunks?: ArraySlice[];
+    headerIndices: Map<string, ArraySlice>;
+};
+/**
+ * parses http/1.1 responses
+ */
+export declare function makeHttpResponseParser(): {
+    res: HttpResponse;
+    /**
+     * Parse the next chunk of data
+     * @param data the data to parse
+     */
+    onChunk(data: Uint8Array): void;
+    /**
+     * Call to prevent further parsing; indicating the end of the request
+     * Checks that the response is valid & complete, otherwise throws an error
+     */
+    streamEnded(): void;
+};
+/**
+ * Read the HTTP request from a TLS receipt transcript.
+ * @param receipt the transcript to read from or application messages if they were extracted beforehand
+ * @returns the parsed HTTP request
+ */
+export declare function getHttpRequestDataFromTranscript(receipt: Transcript<Uint8Array>): HttpRequest;

package/lib/utils/http-parser.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHttpResponseParser = makeHttpResponseParser;
+exports.getHttpRequestDataFromTranscript = getHttpRequestDataFromTranscript;
+const tls_1 = require("@reclaimprotocol/tls");
+const generics_1 = require("src/utils/generics");
+const redactions_1 = require("src/utils/redactions");
+const HTTP_HEADER_LINE_END = (0, tls_1.strToUint8Array)('\r\n');
+/**
+ * parses http/1.1 responses
+ */
+function makeHttpResponseParser() {
+    /** the HTTP response data */
+    const res = {
+        statusCode: 0,
+        statusMessage: '',
+        headers: {},
+        body: new Uint8Array(),
+        complete: false,
+        headersComplete: false,
+        headerIndices: new Map()
+    };
+    let remainingBodyBytes = 0;
+    let isChunked = false;
+    let remaining = new Uint8Array();
+    let currentByteIdx = 0;
+    return {
+        res,
+        /**
+         * Parse the next chunk of data
+         * @param data the data to parse
+         */
+        onChunk(data) {
+            var _a, _b;
+            // concatenate the remaining data from the last chunk
+            remaining = (0, tls_1.concatenateUint8Arrays)([remaining, data]);
+            // if we don't have the headers yet, keep reading lines
+            // as each header is in a line
+            if (!res.headersComplete) {
+                for (let line = getLine(); typeof line !== 'undefined'; line = getLine()) {
+                    // first line is the HTTP version, status code & message
+                    if (!res.statusCode) {
+                        const [, statusCode, statusMessage] = line.match(/HTTP\/\d\.\d (\d+) (.*)/) || [];
+                        res.statusCode = Number(statusCode);
+                        res.statusMessage = statusMessage;
+                        res.statusLineEndIndex = currentByteIdx - HTTP_HEADER_LINE_END.length;
+                    }
+                    else if (line === '') { // empty line signifies end of headers
+                        res.headersComplete = true;
+                        // if the response is chunked, we need to process the body differently
+                        if ((_a = res.headers['transfer-encoding']) === null || _a === void 0 ? void 0 : _a.includes('chunked')) {
+                            isChunked = true;
+                            res.chunks = [];
+                            break;
+                            // if the response has a content-length, we know how many bytes to read
+                        }
+                        else if (res.headers['content-length']) {
+                            remainingBodyBytes = Number(res.headers['content-length']);
+                            break;
+                        }
+                        else {
+                            remainingBodyBytes = -1;
+                            // otherwise,
+                            // no content-length, no chunked transfer encoding
+                            // means wait till the stream ends
+                            // https://stackoverflow.com/a/11376887
+                        }
+                    }
+                    else if (!res.complete) { // parse the header
+                        const [key, value] = line.split(': ');
+                        res.headers[key.toLowerCase()] = value;
+                        res.headerIndices[key.toLowerCase()] = {
+                            fromIndex: currentByteIdx - line.length - HTTP_HEADER_LINE_END.length,
+                            toIndex: currentByteIdx - HTTP_HEADER_LINE_END.length
+                        };
+                    }
+                    else {
+                        throw new Error('got more data after response was complete');
+                    }
+                }
+            }
+            if (res.headersComplete) {
+                if (remainingBodyBytes) {
+                    readBody();
+                    // if no more body bytes to read,
+                    // and the response was not chunked we're done
+                    if (!remainingBodyBytes && !isChunked) {
+                        res.complete = true;
+                    }
+                }
+                if (res.headers['content-length'] === '0') {
+                    res.complete = true;
+                }
+                if (isChunked) {
+                    for (let line = getLine(); typeof line !== 'undefined'; line = getLine()) {
+                        if (line === '') {
+                            continue;
+                        }
+                        const chunkSize = Number.parseInt(line, 16);
+                        // if chunk size is 0, we're done
+                        if (!chunkSize) {
+                            res.complete = true;
+                            continue;
+                        }
+                        (_b = res.chunks) === null || _b === void 0 ? void 0 : _b.push({
+                            fromIndex: currentByteIdx,
+                            toIndex: currentByteIdx + chunkSize,
+                        });
+                        // otherwise read the chunk
+                        remainingBodyBytes = chunkSize;
+                        readBody();
+                        // if we read all the data we had,
+                        // but there's still data left,
+                        // break the loop and wait for the next chunk
+                        if (remainingBodyBytes) {
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+        /**
+         * Call to prevent further parsing; indicating the end of the request
+         * Checks that the response is valid & complete, otherwise throws an error
+         */
+        streamEnded() {
+            if (!res.headersComplete) {
+                throw new Error('stream ended before headers were complete');
+            }
+            if (remaining.length) {
+                throw new Error('stream ended with remaining data');
+            }
+            if (remainingBodyBytes > 0) {
+                throw new Error('stream ended before all body bytes were received');
+            }
+            res.complete = true;
+        }
+    };
+    function readBody() {
+        if (res.complete) {
+            throw new Error('got more data after response was complete');
+        }
+        if (!res.bodyStartIndex) {
+            res.bodyStartIndex = currentByteIdx;
+        }
+        let bytesToCopy;
+        if (remainingBodyBytes === -1) {
+            // all bytes are body bytes
+            bytesToCopy = remaining.length;
+        }
+        else {
+            // take the number of bytes we need to read, or the number of bytes remaining
+            // and append to the bytes of the body
+            bytesToCopy = Math.min(remainingBodyBytes, remaining.length);
+            remainingBodyBytes -= bytesToCopy;
+        }
+        res.body = (0, tls_1.concatenateUint8Arrays)([
+            res.body,
+            remaining.slice(0, bytesToCopy)
+        ]);
+        remaining = remaining.slice(bytesToCopy);
+        currentByteIdx += bytesToCopy;
+    }
+    function getLine() {
+        // find end of line, if it exists
+        // otherwise return undefined
+        const idx = (0, generics_1.findIndexInUint8Array)(remaining, HTTP_HEADER_LINE_END);
+        if (idx === -1) {
+            return undefined;
+        }
+        const line = (0, generics_1.uint8ArrayToStr)(remaining.slice(0, idx));
+        remaining = remaining.slice(idx + HTTP_HEADER_LINE_END.length);
+        currentByteIdx += idx + HTTP_HEADER_LINE_END.length;
+        return line;
+    }
+}
+/**
+ * Read the HTTP request from a TLS receipt transcript.
+ * @param receipt the transcript to read from or application messages if they were extracted beforehand
+ * @returns the parsed HTTP request
+ */
+function getHttpRequestDataFromTranscript(receipt) {
+    const clientMsgs = receipt
+        .filter(s => s.sender === 'client');
+    // if the first message is redacted, we can't parse it
+    // as we don't know what the request was
+    if (clientMsgs[0].message[0] === redactions_1.REDACTION_CHAR_CODE) {
+        throw new Error('First client message request is redacted. Cannot parse');
+    }
+    const request = {
+        method: '',
+        url: '',
+        protocol: '',
+        headers: {}
+    };
+    let requestBuffer = (0, tls_1.concatenateUint8Arrays)(clientMsgs.map(m => m.message));
+    // keep reading lines until we get to the end of the headers
+    for (let line = getLine(); typeof line !== 'undefined'; line = getLine()) {
+        if (line === '') {
+            break;
+        }
+        if (!request.method) {
+            const [, method, url, protocol] = line.match(/(\w+) (.*) (.*)/) || [];
+            request.method = method.toLowerCase();
+            request.url = url;
+            request.protocol = protocol;
+        }
+        else {
+            let keyIdx = line.indexOf(':');
+            if (keyIdx === -1) {
+                keyIdx = line.length - 1;
+            }
+            const key = line.slice(0, keyIdx)
+                .toLowerCase()
+                .trim();
+            const value = line.slice(keyIdx + 1)
+                .trim();
+            const oldValue = request.headers[key];
+            if (typeof oldValue === 'string') {
+                request.headers[key] = [oldValue, value];
+            }
+            else if (Array.isArray(oldValue)) {
+                oldValue.push(value);
+            }
+            else {
+                request.headers[key] = value;
+            }
+        }
+    }
+    //the rest is request body
+    if (requestBuffer.length) {
+        request.body = requestBuffer;
+    }
+    if (!request.method) {
+        throw new Error('Client request is incomplete');
+    }
+    return request;
+    function getLine() {
+        const idx = (0, generics_1.findIndexInUint8Array)(requestBuffer, HTTP_HEADER_LINE_END);
+        if (idx === -1) {
+            return undefined;
+        }
+        const line = (0, generics_1.uint8ArrayToStr)(requestBuffer.slice(0, idx));
+        requestBuffer = requestBuffer
+            .slice(idx + HTTP_HEADER_LINE_END.length);
+        return line;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-parser.js","sourceRoot":"","sources":["../../src/utils/http-parser.ts"],"names":[],"mappings":"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"}