@reclaimprotocol/attestor-core 5.0.1-beta.21 → 5.0.1-beta.22

package/lib/utils/bgp-listener.js

@@ -0,0 +1,119 @@
+import CIDR from 'ip-cidr';
+import { BGP_WS_URL } from "../config/index.js";
+import { makeWebSocket } from "./ws.js";
+const ANNOUNCEMENT_OVERLAP = 'announcement-overlap';
+class BGPAnnouncementOverlapEvent extends Event {
+    data;
+    constructor(data) {
+        super(ANNOUNCEMENT_OVERLAP);
+        this.data = data;
+    }
+}
+/**
+ * Listens for BGP announcements and emits events whenever
+ * an announcement overlaps with a target IP.
+ */
+export function createBgpListener(logger) {
+    let ws;
+    let closed = false;
+    const targetIps = new Set();
+    const eventTarget = new EventTarget();
+    openWs();
+    return {
+        onOverlap(ips, callback) {
+            for (const ip of ips) {
+                targetIps.add(ip);
+            }
+            eventTarget.addEventListener(ANNOUNCEMENT_OVERLAP, _callback);
+            return () => {
+                for (const ip of ips) {
+                    targetIps.delete(ip);
+                }
+                eventTarget.removeEventListener(ANNOUNCEMENT_OVERLAP, _callback);
+            };
+            function _callback(event) {
+                callback(event.data);
+            }
+        },
+        close() {
+            ws.onclose = null;
+            ws.onerror = null;
+            ws.close();
+            closed = true;
+        }
+    };
+    function openWs() {
+        logger.debug('connecting to BGP websocket');
+        ws = makeWebSocket(BGP_WS_URL);
+        ws.onopen = onOpen;
+        ws.onerror = (ev) => onClose(ev);
+        ws.onclose = () => onClose(new Error('Unexpected close'));
+        ws.onmessage = ({ data }) => {
+            const str = typeof data === 'string' ? data : data.toString();
+            try {
+                onMessage(str);
+            }
+            catch (err) {
+                logger.error({ data, err }, 'error processing BGP message');
+            }
+        };
+    }
+    function onOpen() {
+        const subscriptionMessage = {
+            type: 'ris_subscribe',
+            data: {
+                type: 'UPDATE',
+            },
+        };
+        ws.send(JSON.stringify(subscriptionMessage));
+        logger.info('connected to BGP websocket');
+    }
+    function onClose(err) {
+        if (closed) {
+            return;
+        }
+        logger.info({ err }, 'BGP websocket closed');
+        if (!err) {
+            return;
+        }
+        logger.info('reconnecting to BGP websocket');
+        openWs();
+    }
+    function onMessage(message) {
+        const data = JSON.parse(message);
+        const announcements = data?.data?.announcements;
+        logger.trace({ data }, 'got BGP update');
+        if (!Array.isArray(announcements)) {
+            return;
+        }
+        const asPath = data?.data?.path;
+        for (const announcement of announcements) {
+            const prefixes = announcement?.prefixes;
+            const nextHop = announcement?.['next_hop'];
+            const hasPrefixes = prefixes?.length && (nextHop || asPath);
+            if (!hasPrefixes) {
+                return;
+            }
+            for (const prefix of prefixes) {
+                if (!overlapsTargetIps(prefix)) {
+                    continue;
+                }
+                // emit event
+                eventTarget.dispatchEvent(new BGPAnnouncementOverlapEvent({ prefix }));
+            }
+        }
+    }
+    function overlapsTargetIps(prefix) {
+        // ignore all prefixes that end with /0
+        if (prefix.endsWith('/0')) {
+            return false;
+        }
+        const cidr = new CIDR(prefix);
+        for (const ip of targetIps) {
+            if (cidr.contains(ip)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/lib/utils/claims.js

@@ -0,0 +1,98 @@
+import canonicalize from 'canonicalize';
+import { keccak256 } from 'ethers';
+import { DEFAULT_METADATA } from "../config/index.js";
+import { ClaimTunnelResponse } from "../proto/api.js";
+import { SIGNATURES, strToUint8Array } from "../..";
+/**
+ * Creates the standard string to sign for a claim.
+ * This data is what the attestor will sign when it successfully
+ * verifies a claim.
+ */
+export function createSignDataForClaim(data) {
+    const lines = [
+        getIdentifierFromClaimInfo(data),
+        // we lowercase the owner to ensure that the
+        // ETH addresses always serialize the same way
+        data.owner.toLowerCase(),
+        data.timestampS.toString(),
+        data.epoch.toString(),
+    ];
+    return lines.join('\n');
+}
+/**
+ * Verify the claim tunnel response from a attestor.
+ *
+ * If you'd only like to verify the claim signature, you can
+ * optionally only pass "claim" & "signatures.claimSignature"
+ * to this function.
+ *
+ * The successful run of this function means that the claim
+ * is valid, and the attestor that signed the claim is valid.
+ */
+export async function assertValidClaimSignatures({ signatures, ...res }, metadata = DEFAULT_METADATA) {
+    if (!signatures) {
+        throw new Error('No signatures provided');
+    }
+    const { resultSignature, claimSignature, attestorAddress } = signatures;
+    const { verify } = SIGNATURES[metadata.signatureType];
+    if (signatures?.resultSignature) {
+        const resBytes = ClaimTunnelResponse
+            .encode(ClaimTunnelResponse.create(res)).finish();
+        const verified = await verify(resBytes, resultSignature, attestorAddress);
+        if (!verified) {
+            throw new Error('Invalid result signature');
+        }
+    }
+    // claim wasn't generated -- i.e. the transcript
+    // did not contain the necessary data
+    if (!res.claim) {
+        return;
+    }
+    const signData = createSignDataForClaim(res.claim);
+    const verifiedClaim = await verify(strToUint8Array(signData), claimSignature, attestorAddress);
+    if (!verifiedClaim) {
+        throw new Error('Invalid claim signature');
+    }
+}
+/**
+ * Generates a unique identifier for given claim info
+ * @param info
+ * @returns
+ */
+export function getIdentifierFromClaimInfo(info) {
+    //re-canonicalize context if it's not empty
+    if (info.context?.length > 0) {
+        try {
+            const ctx = JSON.parse(info.context);
+            info.context = canonicalStringify(ctx);
+        }
+        catch {
+            throw new Error('unable to parse non-empty context. Must be JSON');
+        }
+    }
+    const str = `${info.provider}\n${info.parameters}\n${info.context || ''}`;
+    //console.log('Identifier: ' + btoa(str))
+    return keccak256(strToUint8Array(str)).toLowerCase();
+}
+/**
+ * Canonically stringifies an object, so that the same object will always
+ * produce the same string despite the order of keys
+ */
+export function canonicalStringify(params) {
+    if (!params) {
+        return '';
+    }
+    // have to cast as ESM isn't correctly typing this
+    return canonicalize(params) || '';
+}
+export function hashProviderParams(params) {
+    const filteredParams = {
+        url: params.url,
+        method: params.method,
+        body: params.body,
+        responseMatches: params.responseMatches,
+        responseRedactions: params.responseRedactions
+    };
+    const serializedParams = canonicalStringify(filteredParams);
+    return keccak256(strToUint8Array(serializedParams)).toLowerCase();
+}

package/lib/utils/env.js

@@ -0,0 +1,15 @@
+export function detectEnvironment() {
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        return 'react-native';
+    }
+    if (typeof window !== 'undefined') {
+        return 'browser';
+    }
+    return 'node';
+}
+export function getEnvVariable(name) {
+    if (typeof process === 'undefined') {
+        return undefined;
+    }
+    return process?.env[name];
+}

package/lib/utils/error.js

@@ -0,0 +1,50 @@
+import { ErrorCode, ErrorData } from "../proto/api.js";
+const PROTO_ERROR = ErrorData.fromJSON({});
+/**
+ * Represents an error that can be thrown by the Attestor Core
+ * or server. Provides a code, and optional data
+ * to pass along with the error.
+ */
+export class AttestorError extends Error {
+    name = 'AttestorError';
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    /**
+     * Encodes the error as a ErrorData
+     * protobuf message
+     */
+    toProto() {
+        return ErrorData.create({
+            code: ErrorCode[this.code],
+            message: this.message,
+            data: JSON.stringify(this.data)
+        });
+    }
+    static fromProto(data = PROTO_ERROR) {
+        return new AttestorError(typeof data.code === 'number'
+            ? getKeyForValue(ErrorCode, data.code) || 'UNRECOGNIZED'
+            : data.code, data.message, data.data ? JSON.parse(data.data) : undefined);
+    }
+    static fromError(err, code = 'ERROR_INTERNAL') {
+        if (err instanceof AttestorError) {
+            return err;
+        }
+        return new AttestorError(code, err.message);
+    }
+    static badRequest(message, data) {
+        return new AttestorError('ERROR_BAD_REQUEST', message, data);
+    }
+}
+function getKeyForValue(obj, value) {
+    for (const key in obj) {
+        if (obj[key] === value) {
+            return key;
+        }
+    }
+    return undefined;
+}

package/lib/utils/generics.js

@@ -0,0 +1,317 @@
+import { areUint8ArraysEqual, CONTENT_TYPE_MAP, crypto, decryptWrappedRecord, PACKET_TYPE, SUPPORTED_CIPHER_SUITE_MAP, uint8ArrayToBinaryStr, uint8ArrayToDataView } from '@reclaimprotocol/tls';
+import { REDACTION_CHAR_CODE } from '@reclaimprotocol/zk-symmetric-crypto';
+import { RPCMessage, RPCMessages } from "../proto/api.js";
+const DEFAULT_REDACTION_DATA = new Uint8Array(4)
+    .fill(REDACTION_CHAR_CODE);
+export { uint8ArrayToBinaryStr };
+/**
+ * Decodes a Uint8Array to a UTF-8 string.
+ */
+export function uint8ArrayToStr(arr) {
+    return new TextDecoder().decode(arr);
+}
+/**
+ * Encodes a UTF-8 string to a Uint8Array.
+ */
+export function strToUint8Array(str) {
+    return new TextEncoder().encode(str);
+}
+export function getTranscriptString(receipt) {
+    const applMsgs = extractApplicationDataFromTranscript(receipt);
+    const strList = [];
+    for (const { message, sender } of applMsgs) {
+        const content = uint8ArrayToStr(message);
+        if (strList[strList.length - 1]?.startsWith(sender)) {
+            strList[strList.length - 1] += content;
+        }
+        else {
+            strList.push(`${sender}: ${content}`);
+        }
+    }
+    return strList.join('\n');
+}
+export const unixTimestampSeconds = () => Math.floor(Date.now() / 1000);
+/**
+ * Find index of needle in haystack
+ */
+export function findIndexInUint8Array(haystack, needle) {
+    for (let i = 0; i < haystack.length; i++) {
+        if (areUint8ArraysEqual(haystack.slice(i, i + needle.length), needle)) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Fetch the ZK algorithm for the specified cipher suite
+ */
+export 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
+ */
+export 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, } = 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
+ */
+export function getRecordIV(content, cipherSuite) {
+    // assert that the cipher suite is supported
+    getZkAlgorithmForCipherSuite(cipherSuite);
+    const { ivLength: fixedIvLength, } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+    // 12 => total IV length
+    const recordIvLength = 12 - fixedIvLength;
+    return content.slice(0, recordIvLength);
+}
+export function getProviderValue(params, fn, secretParams) {
+    return typeof fn === 'function'
+        // @ts-ignore
+        ? fn(params, secretParams)
+        : fn;
+}
+export function generateRpcMessageId() {
+    return uint8ArrayToDataView(crypto.randomBytes(4)).getUint32(0);
+}
+/**
+ * Random session ID for a WebSocket client.
+ */
+export function generateSessionId() {
+    return generateRpcMessageId();
+}
+/**
+ * Random ID for a tunnel.
+ */
+export function generateTunnelId() {
+    return generateRpcMessageId();
+}
+export 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' }
+ */
+export 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"
+ */
+export function getRpcResponseType(type) {
+    return `${type}Response`;
+}
+/**
+ * Get the RPC request type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelRequest"
+ */
+export function getRpcRequestType(type) {
+    return `${type}Request`;
+}
+export function isApplicationData(packet, tlsVersion) {
+    return packet.type === 'ciphertext'
+        && (packet.contentType === 'APPLICATION_DATA'
+            || (packet.data[0] === PACKET_TYPE.WRAPPED_RECORD
+                && tlsVersion === 'TLS1_2'));
+}
+/**
+ * Convert the received data from a WS to a Uint8Array
+ */
+export async function extractArrayBufferFromWsData(data) {
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    // uint8array/Buffer
+    if (data instanceof Uint8Array
+        || (typeof data === 'object' && data && 'buffer' in data)) {
+        return data;
+    }
+    if (typeof data === 'string') {
+        return strToUint8Array(data);
+    }
+    if (typeof Blob !== 'undefined' && 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.
+ */
+export 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
+ */
+export 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(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 !== CONTENT_TYPE_MAP['APPLICATION_DATA']) {
+                continue;
+            }
+            message = m.message.slice(0, -1);
+        }
+        else if (m.recordHeader[0] === PACKET_TYPE.WRAPPED_RECORD) {
+            message = m.message;
+        }
+        else {
+            continue;
+        }
+        msgs.push({ message, sender: m.sender });
+    }
+    return msgs;
+}
+export 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] === PACKET_TYPE.HELLO) {
+            message = m.message;
+        }
+        else if (m.recordHeader[0] === PACKET_TYPE.WRAPPED_RECORD) {
+            if (tlsVersion === 'TLS1_3') {
+                const contentType = m.message[m.message.length - 1];
+                if (contentType !== 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;
+}
+export async function decryptDirect(directReveal, cipherSuite, recordHeader, serverTlsVersion, content) {
+    const { key, iv, recordNumber } = directReveal;
+    const { cipher } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+    const importedKey = await crypto.importKey(cipher, key);
+    return await decryptWrappedRecord(content, {
+        iv,
+        key: importedKey,
+        recordHeader,
+        recordNumber,
+        version: serverTlsVersion,
+        cipherSuite,
+    });
+}
+export function packRpcMessages(...msgs) {
+    return RPCMessages.create({
+        messages: msgs.map(msg => (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.
+ */
+export 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;
+}
+export function isTls13Suite(suite) {
+    return suite === 'TLS_AES_128_GCM_SHA256'
+        || suite === 'TLS_AES_256_GCM_SHA384'
+        || suite === 'TLS_CHACHA20_POLY1305_SHA256';
+}