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

package/lib/providers/http/utils.js

@@ -0,0 +1,324 @@
+// noinspection ExceptionCaughtLocallyJS
+import "./patch-parse5-tree.js";
+import { concatenateUint8Arrays } from '@reclaimprotocol/tls';
+import { ArrayExpression, ExpressionStatement, ObjectExpression, parseScript, Property, Syntax } from 'esprima-next';
+import { JSONPath } from 'jsonpath-plus';
+import { parse } from 'parse5';
+import { adapter as htmlAdapter, } from 'parse5-htmlparser2-tree-adapter';
+import RE2 from 're2';
+import xpath from 'xpath';
+import { getHttpRequestDataFromTranscript, isApplicationData, makeHttpResponseParser, REDACTION_CHAR_CODE } from "../../utils/index.js";
+/**
+ * Returns only first extracted element
+ * @param html
+ * @param xpathExpression
+ * @param contentsOnly
+ */
+export function extractHTMLElement(html, xpathExpression, contentsOnly) {
+    const { start, end } = extractHTMLElementIndex(html, xpathExpression, contentsOnly);
+    return html.slice(start, end);
+}
+/**
+ * Returns all extracted elements
+ * @param html
+ * @param xpathExpression
+ * @param contentsOnly
+ */
+export function extractHTMLElements(html, xpathExpression, contentsOnly) {
+    const indexes = extractHTMLElementsIndexes(html, xpathExpression, contentsOnly);
+    const res = [];
+    for (const { start, end } of indexes) {
+        res.push(html.slice(start, end));
+    }
+    return res;
+}
+/**
+ * returns a single index of extracted element
+ * @param html
+ * @param xpathExpression
+ * @param contentsOnly
+ */
+export function extractHTMLElementIndex(html, xpathExpression, contentsOnly) {
+    return extractHTMLElementsIndexes(html, xpathExpression, contentsOnly)[0];
+}
+/**
+ * Returns indexes of all extracted elements
+ * @param html
+ * @param xpathExpression
+ * @param contentsOnly indices of the start and end of the element's contents only,
+ * 	not the whole tag
+ */
+export function extractHTMLElementsIndexes(html, xpathExpression, contentsOnly) {
+    return extractHTMLElementIndexesParse5(html, xpathExpression, contentsOnly);
+}
+function extractHTMLElementIndexesParse5(html, xpathExpression, contentsOnly) {
+    const domLight = parse(html, { treeAdapter: htmlAdapter, sourceCodeLocationInfo: true });
+    // lets xpath identify this as a node
+    domLight['name'] = 'root';
+    const parsedPath = xpath.parse(xpathExpression);
+    const nodes = parsedPath.select({
+        node: domLight,
+        allowAnyNamespaceForNoPrefix: true,
+    });
+    if (!nodes.length) {
+        throw new Error(`Failed to find XPath: "${xpathExpression}"`);
+    }
+    return nodes.map(node => getNodeRange(node, contentsOnly));
+}
+function getNodeRange(node, contentsOnly) {
+    if (!contentsOnly) {
+        return { start: node.startIndex, end: node.endIndex };
+    }
+    if (!('firstChild' in node) || !node.firstChild) {
+        throw new Error(`Node "${node['name']}" has no children`);
+    }
+    return {
+        start: node.firstChild.startIndex,
+        end: node.lastChild.endIndex
+    };
+}
+export function extractJSONValueIndex(json, jsonPath) {
+    return extractJSONValueIndexes(json, jsonPath)[0];
+}
+export function extractJSONValueIndexes(json, jsonPath) {
+    const pointers = JSONPath({
+        path: jsonPath,
+        json: JSON.parse(json),
+        wrap: false,
+        resultType: 'pointer',
+        eval: 'safe',
+        // @ts-ignore
+        ignoreEvalErrors: true
+    });
+    if (!pointers) {
+        throw new Error('jsonPath not found');
+    }
+    //wrap in parentheses for esprima to parse
+    const tree = parseScript('(' + json + ')', { range: true });
+    if (tree.body[0] instanceof ExpressionStatement
+        && (tree.body[0].expression instanceof ObjectExpression || tree.body[0].expression instanceof ArrayExpression)) {
+        const traversePointers = Array.isArray(pointers) ? pointers : [pointers];
+        const res = [];
+        for (const pointer of traversePointers) {
+            const index = traverse(tree.body[0].expression, '', [pointer]);
+            if (index) {
+                res.push({
+                    start: index.start - 1, //account for '('
+                    end: index.end - 1,
+                });
+            }
+        }
+        return res;
+    }
+    throw new Error('jsonPath not found');
+}
+/**
+ * recursively go through AST tree and build a JSON path while it's not equal to the one we search for
+ * @param o - esprima expression for root object
+ * @param path - path that is being built
+ * @param pointers - JSON pointers to compare to
+ */
+function traverse(o, path, pointers) {
+    if (o instanceof ObjectExpression) {
+        for (const p of o.properties) {
+            if (!(p instanceof Property)) {
+                continue;
+            }
+            const localPath = p.key.type === Syntax.Literal
+                ? path + '/' + p.key.value
+                : path;
+            if (pointers.includes(localPath) && 'range' in p && Array.isArray(p.range)) {
+                return {
+                    start: p.range[0],
+                    end: p.range[1],
+                };
+            }
+            if (p.value instanceof ObjectExpression
+                || p.value instanceof ArrayExpression) {
+                const res = traverse(p.value, localPath, pointers);
+                if (res) {
+                    return res;
+                }
+            }
+        }
+    }
+    if (o instanceof ArrayExpression) {
+        for (let i = 0; i < o.elements.length; i++) {
+            const element = o.elements[i];
+            if (!element) {
+                continue;
+            }
+            const localPath = path + '/' + i;
+            if (pointers.includes(localPath) &&
+                'range' in element &&
+                Array.isArray(element.range)) {
+                return {
+                    start: element.range[0],
+                    end: element.range[1],
+                };
+            }
+            if (element instanceof ObjectExpression) {
+                const res = traverse(element, localPath, pointers);
+                if (res) {
+                    return res;
+                }
+            }
+            if (element instanceof ArrayExpression) {
+                const res = traverse(element, localPath, pointers);
+                if (res) {
+                    return res;
+                }
+            }
+        }
+    }
+    return null;
+}
+export function buildHeaders(input) {
+    const headers = [];
+    for (const [key, value] of Object.entries(input || {})) {
+        headers.push(`${key}: ${value}`);
+    }
+    return headers;
+}
+/**
+ * Converts position in HTTP response body to an absolute position in TLS transcript considering chunked encoding
+ * @param pos
+ * @param bodyStartIdx
+ * @param chunks
+ */
+export function convertResponsePosToAbsolutePos(pos, bodyStartIdx, chunks) {
+    if (chunks?.length) {
+        let chunkBodyStart = 0;
+        for (const chunk of chunks) {
+            const chunkSize = chunk.toIndex - chunk.fromIndex;
+            if (pos >= chunkBodyStart && pos <= (chunkBodyStart + chunkSize)) {
+                return pos - chunkBodyStart + chunk.fromIndex;
+            }
+            chunkBodyStart += chunkSize;
+        }
+        throw new Error('position out of range');
+    }
+    return bodyStartIdx + pos;
+}
+/**
+ * If this reveal spans the boundary of two chunks, we'll
+ *
+ */
+export function getRedactionsForChunkHeaders(from, to, chunks) {
+    const res = [];
+    if (!chunks?.length) {
+        return res;
+    }
+    for (let i = 1; i < chunks?.length; i++) {
+        const chunk = chunks[i];
+        if (chunk.fromIndex > from && chunk.fromIndex < to) {
+            res.push({
+                fromIndex: chunks[i - 1].toIndex,
+                toIndex: chunk.fromIndex,
+            });
+        }
+    }
+    return res;
+}
+export function parseHttpResponse(buff) {
+    const parser = makeHttpResponseParser();
+    parser.onChunk(buff);
+    parser.streamEnded();
+    return parser.res;
+}
+export function makeRegex(str) {
+    return RE2(str, 'sgiu');
+}
+const TEMPLATE_START_CHARCODE = '{'.charCodeAt(0);
+const TEMPLATE_END_CHARCODE = '}'.charCodeAt(0);
+/**
+ * Try to match strings that contain templates like {{param}}
+ * against redacted string that has *** instead of that param
+ */
+export function matchRedactedStrings(templateString, redactedString) {
+    if (templateString.length === 0 && redactedString?.length === 0) {
+        return true;
+    }
+    if (!redactedString) {
+        return false;
+    }
+    let ts = -1;
+    let rs = -1;
+    while (ts < templateString.length && rs < redactedString.length) {
+        let ct = getTChar();
+        let cr = getRChar();
+        if (ct !== cr) {
+            // only valid if param contains "{" & redacted contains "*"
+            if (ct === TEMPLATE_START_CHARCODE && cr === REDACTION_CHAR_CODE) {
+                //check that the char after first "{" is also "{"
+                if (getTChar() !== TEMPLATE_START_CHARCODE) {
+                    return false;
+                }
+                //look for first closing bracket
+                while (((ct = getTChar()) !== TEMPLATE_END_CHARCODE) && ct !== -1) {
+                }
+                //look for second closing bracket
+                while (((ct = getTChar()) !== TEMPLATE_END_CHARCODE) && ct !== -1) {
+                }
+                if (ct === -1) {
+                    return false;
+                }
+                //find the end of redaction
+                while (((cr = getRChar()) === REDACTION_CHAR_CODE) && cr !== -1) {
+                }
+                if (cr === -1) {
+                    //if there's nothing after template too then both ended at the end of strings
+                    return getTChar() === -1;
+                }
+                //rewind redacted string position back 1 char because we read one extra
+                rs--;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    function getTChar() {
+        ts++;
+        if (ts < templateString.length) {
+            return templateString[ts];
+        }
+        else {
+            return -1;
+        }
+    }
+    function getRChar() {
+        if (!redactedString) {
+            return -1;
+        }
+        rs++;
+        if (rs < redactedString.length) {
+            return redactedString[rs];
+        }
+        else {
+            return -1;
+        }
+    }
+    return ts === templateString.length && rs === redactedString.length;
+}
+export function generateRequstAndResponseFromTranscript(transcript, tlsVersion) {
+    const allPackets = transcript;
+    const packets = [];
+    for (const b of allPackets) {
+        if (b.message.type !== 'ciphertext'
+            || !isApplicationData(b.message, tlsVersion)) {
+            continue;
+        }
+        const plaintext = tlsVersion === 'TLS1_3'
+            ? b.message.plaintext.slice(0, -1)
+            : b.message.plaintext;
+        packets.push({
+            message: plaintext,
+            sender: b.sender
+        });
+    }
+    const req = getHttpRequestDataFromTranscript(packets);
+    const responsePackets = concatenateUint8Arrays(packets.filter(p => p.sender === 'server').map(p => p.message).filter(b => !b.every(b => b === REDACTION_CHAR_CODE)));
+    const res = parseHttpResponse(responsePackets);
+    return { req, res };
+}

package/lib/providers/index.js

@@ -0,0 +1,4 @@
+import http from "./http/index.js";
+export const providers = {
+    http,
+};

package/lib/server/create-server.js

@@ -0,0 +1,103 @@
+import { createServer as createHttpServer } from 'http';
+import serveStatic from 'serve-static';
+import { WebSocketServer } from 'ws';
+import { API_SERVER_PORT, ATTESTOR_ADDRESS_PATHNAME, BROWSER_RPC_PATHNAME, WS_PATHNAME } from "../config/index.js";
+import { AttestorServerSocket } from "./socket.js";
+import { getAttestorAddress } from "./utils/generics.js";
+import { addKeepAlive } from "./utils/keep-alive.js";
+import { createBgpListener } from "../utils/bgp-listener.js";
+import { getEnvVariable } from "../utils/env.js";
+import { logger as LOGGER } from "../utils/index.js";
+import { SelectedServiceSignatureType } from "../utils/signatures/index.js";
+import { promisifySend } from "../utils/ws.js";
+const PORT = +(getEnvVariable('PORT') || API_SERVER_PORT);
+const DISABLE_BGP_CHECKS = getEnvVariable('DISABLE_BGP_CHECKS') === '1';
+const ATTESTOR_ADDRESS_JSON_RES = JSON.stringify({
+    address: getAttestorAddress(SelectedServiceSignatureType),
+    signatureType: SelectedServiceSignatureType
+});
+/**
+ * Creates the WebSocket API server,
+ * creates a fileserver to serve the browser RPC client,
+ * and listens on the given port.
+ */
+export async function createServer(port = PORT) {
+    const http = createHttpServer();
+    const serveBrowserRpc = serveStatic('browser', {
+        index: ['index.html'],
+        setHeaders(res) {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+        },
+    });
+    const bgpListener = !DISABLE_BGP_CHECKS
+        ? createBgpListener(LOGGER.child({ service: 'bgp-listener' }))
+        : undefined;
+    const wss = new WebSocketServer({ noServer: true });
+    http.on('upgrade', handleUpgrade.bind(wss));
+    http.on('request', (req, res) => {
+        const url = URL.parse(req.url || '', 'http://localhost');
+        if (!url) {
+            res.statusCode = 422;
+            res.end('Invalid URL');
+            return;
+        }
+        if (url.pathname === ATTESTOR_ADDRESS_PATHNAME) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(ATTESTOR_ADDRESS_JSON_RES);
+            return;
+        }
+        // simple way to serve files at the browser RPC path
+        if (!url.pathname?.startsWith(BROWSER_RPC_PATHNAME)) {
+            res.statusCode = 404;
+            res.end('Not found');
+            return;
+        }
+        req.url = req.url.slice(BROWSER_RPC_PATHNAME.length) || '/';
+        serveBrowserRpc(req, res, (err) => {
+            if (err) {
+                LOGGER.error({ err, url: req.url }, 'Failed to serve file');
+            }
+            res.statusCode = err?.statusCode ?? 404;
+            res.end(err?.message ?? 'Not found');
+        });
+    });
+    // wait for us to start listening
+    http.listen(port);
+    await new Promise((resolve, reject) => {
+        http.once('listening', () => resolve());
+        http.once('error', reject);
+    });
+    wss.on('connection', (ws, req) => handleNewClient(ws, req, bgpListener));
+    LOGGER.info({
+        port,
+        apiPath: WS_PATHNAME,
+        browserRpcPath: BROWSER_RPC_PATHNAME,
+        signerAddress: getAttestorAddress(SelectedServiceSignatureType)
+    }, 'WS server listening');
+    const wssClose = wss.close.bind(wss);
+    wss.close = (cb) => {
+        wssClose(() => http.close(cb));
+        bgpListener?.close();
+    };
+    return wss;
+}
+async function handleNewClient(ws, req, bgpListener) {
+    promisifySend(ws);
+    const client = await AttestorServerSocket.acceptConnection(ws, { req, bgpListener, logger: LOGGER });
+    // if initialisation fails, don't store the client
+    if (!client) {
+        return;
+    }
+    ws.serverSocket = client;
+    addKeepAlive(ws, LOGGER.child({ sessionId: client.sessionId }));
+}
+function handleUpgrade(request, socket, head) {
+    const { pathname } = new URL(request.url, 'wss://base.url');
+    if (pathname === WS_PATHNAME) {
+        this.handleUpgrade(request, socket, head, (ws) => {
+            this.emit('connection', ws, request);
+        });
+        return;
+    }
+    socket.destroy();
+}

package/lib/server/handlers/claimTeeBundle.js

@@ -0,0 +1,252 @@
+/**
+ * TEE Bundle Claim Handler
+ * Handles ClaimTeeBundleRequest by verifying TEE attestations and reconstructing TLS transcript
+ */
+import { ClaimTeeBundleResponse } from "../../proto/api.js";
+import { VerificationBundle } from "../../proto/tee-bundle.js";
+import { substituteParamValues } from "../../providers/http/index.js";
+import { assertValidProviderTranscript } from "../utils/assert-valid-claim-request.js";
+import { getAttestorAddress, niceParseJsonObject, signAsAttestor } from "../utils/generics.js";
+import { verifyOprfMpcOutputs } from "../utils/tee-oprf-mpc-verification.js";
+import { verifyOprfProofs } from "../utils/tee-oprf-verification.js";
+import { reconstructTlsTranscript } from "../utils/tee-transcript-reconstruction.js";
+import { verifyTeeBundle } from "../utils/tee-verification.js";
+import { AttestorError } from "../../utils/error.js";
+import { createSignDataForClaim, getIdentifierFromClaimInfo } from "../../utils/index.js";
+export const claimTeeBundle = async (teeBundleRequest, { logger, client }) => {
+    const { verificationBundle, data } = teeBundleRequest;
+    // Initialize response
+    const res = ClaimTeeBundleResponse.create({ request: teeBundleRequest });
+    // 1. Verify TEE bundle (attestations + signatures) - this includes timestamp validation
+    logger.info('Starting TEE bundle verification');
+    const teeData = await verifyTeeBundle(verificationBundle, logger);
+    // 2. Extract timestampS from TEE_K bundle for claim signing
+    const timestampS = Math.floor(teeData.kOutputPayload.timestampMs / 1000);
+    // 3. Verify OPRF proofs first (before transcript reconstruction)
+    logger.info('Verifying OPRF proofs');
+    // Parse the verification bundle to get OPRF verifications
+    const bundle = VerificationBundle.decode(verificationBundle);
+    const zkOprfResults = await verifyOprfProofs({ ...teeData, oprfVerifications: bundle.oprfVerifications }, logger);
+    // 4. Verify OPRF MPC outputs (TEE-to-TEE computed OPRF)
+    logger.info('Verifying OPRF MPC outputs');
+    const oprfMpcResults = verifyOprfMpcOutputs(teeData.kOutputPayload, teeData.tOutputPayload, logger);
+    // 5. Combine ZK and OPRF MPC results for transcript reconstruction
+    const allOprfResults = validateAndCombineOprfResults(zkOprfResults, oprfMpcResults, logger);
+    // 6. Reconstruct TLS transcript with all OPRF replacements applied
+    logger.info('Starting TLS transcript reconstruction with OPRF replacements');
+    const transcriptData = await reconstructTlsTranscript(teeData, logger, allOprfResults);
+    // 7. Create plaintext transcript for provider validation (OPRF already applied)
+    logger.info('Creating plaintext transcript from TEE data');
+    const plaintextTranscript = createPlaintextTranscriptFromTeeData(transcriptData, logger);
+    // 8. Direct provider validation
+    logger.info('Running direct provider validation on TEE reconstructed data');
+    if (!data) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', 'No claim data provided in TEE bundle request');
+    }
+    const validatedClaim = await validateTeeProviderReceipt(plaintextTranscript, data, logger, { version: client.metadata.clientVersion }, transcriptData.certificateInfo);
+    const ctx = niceParseJsonObject(validatedClaim.context, 'context');
+    // eslint-disable-next-line camelcase
+    ctx.pcr0_k = teeData.teekPcr0;
+    // eslint-disable-next-line camelcase
+    ctx.pcr0_t = teeData.teetPcr0;
+    // eslint-disable-next-line camelcase
+    ctx.tee_session_id = teeData.teeSessionId;
+    validatedClaim.context = JSON.stringify(ctx);
+    res.claim = {
+        ...validatedClaim,
+        identifier: getIdentifierFromClaimInfo(validatedClaim),
+        // Use timestampS from TEE_K bundle for claim signing
+        timestampS,
+        // hardcode for compatibility with V1 claims
+        epoch: 1
+    };
+    logger.info({ claim: res.claim }, 'TEE bundle claim validation successful');
+    // 9. Sign the response
+    res.signatures = {
+        attestorAddress: getAttestorAddress(client.metadata.signatureType),
+        claimSignature: res.claim
+            ? await signAsAttestor(createSignDataForClaim(res.claim), client.metadata.signatureType)
+            : new Uint8Array(),
+        resultSignature: await signAsAttestor(ClaimTeeBundleResponse.encode(res).finish(), client.metadata.signatureType)
+    };
+    logger.info('TEE bundle claim processing completed');
+    return res;
+};
+/**
+ * Creates a plaintext transcript from TEE reconstructed data
+ * This converts the TEE transcript data into the format expected by provider validation
+ * NEW: Uses consolidated response instead of individual packets for simplicity
+ */
+function createPlaintextTranscriptFromTeeData(transcriptData, logger) {
+    const transcript = [];
+    // Add reconstructed request (client -> server)
+    if (transcriptData.revealedRequest && transcriptData.revealedRequest.length > 0) {
+        transcript.push({
+            sender: 'client',
+            message: transcriptData.revealedRequest
+        });
+        logger.debug('Added TEE revealed request to plaintext transcript', {
+            length: transcriptData.revealedRequest.length
+        });
+    }
+    // Add consolidated reconstructed response (server -> client)
+    if (transcriptData.reconstructedResponse && transcriptData.reconstructedResponse.length > 0) {
+        transcript.push({
+            sender: 'server',
+            message: transcriptData.reconstructedResponse
+        });
+        logger.debug('Added TEE consolidated response to plaintext transcript', {
+            length: transcriptData.reconstructedResponse.length
+        });
+    }
+    // Log certificate validation info if available
+    if (transcriptData.certificateInfo) {
+        logger.info('Certificate information available for validation', {
+            commonName: transcriptData.certificateInfo.commonName,
+            issuerCommonName: transcriptData.certificateInfo.issuerCommonName,
+            dnsNames: transcriptData.certificateInfo.dnsNames,
+            notBefore: new Date(transcriptData.certificateInfo.notBeforeUnix * 1000).toISOString(),
+            notAfter: new Date(transcriptData.certificateInfo.notAfterUnix * 1000).toISOString()
+        });
+    }
+    logger.info('Created plaintext transcript from TEE data', {
+        totalMessages: transcript.length,
+        hasRequest: !!transcriptData.revealedRequest?.length,
+        hasResponse: !!transcriptData.reconstructedResponse?.length,
+        hasCertificateInfo: !!transcriptData.certificateInfo
+    });
+    return transcript;
+}
+/**
+ * Validates TEE provider receipt directly without signature validation
+ * This is essentially assertValidProviderTranscript but for TEE data
+ * NEW: Includes certificate validation for domain authentication
+ */
+async function validateTeeProviderReceipt(plaintextTranscript, claimInfo, logger, providerCtx, certificateInfo) {
+    logger.info('Starting direct TEE provider validation', {
+        provider: claimInfo.provider,
+        transcriptMessages: plaintextTranscript.length,
+        hasCertificateInfo: !!certificateInfo
+    });
+    // Validate certificate if available
+    if (certificateInfo) {
+        validateTlsCertificate(claimInfo, certificateInfo, logger);
+    }
+    // Use the existing provider validation logic directly
+    const validatedClaim = await assertValidProviderTranscript(plaintextTranscript, claimInfo, logger, providerCtx);
+    logger.info('TEE provider validation completed successfully', {
+        provider: validatedClaim.provider,
+        owner: validatedClaim.owner || 'unknown'
+    });
+    return validatedClaim;
+}
+/**
+ * Checks if a hostname matches a certificate name (with wildcard support)
+ * @param hostname - The hostname to check
+ * @param certName - The certificate name
+ * @returns true if the hostname is valid for this certificate name
+ */
+function isHostnameValidForCertificate(hostname, certName) {
+    // Exact match
+    if (hostname === certName) {
+        return true;
+    }
+    // Wildcard match
+    if (certName.startsWith('*.')) {
+        // Extract the domain from wildcard
+        const wildcardDomain = certName.slice(2);
+        // Check if hostname ends with the wildcard domain
+        if (hostname.endsWith(wildcardDomain)) {
+            // Ensure we're matching a subdomain, not partial domain
+            const subdomainPart = hostname.slice(0, -(wildcardDomain.length));
+            // Valid if:
+            // 1. The subdomain part ends with a dot (proper subdomain boundary)
+            // 2. The subdomain part doesn't contain additional dots (single-level wildcard)
+            if (subdomainPart.endsWith('.')) {
+                const subdomain = subdomainPart.slice(0, -1);
+                // Wildcard only matches single level, not multiple subdomains
+                return !subdomain.includes('.');
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Validates that the TLS certificate is valid for the domain being claimed
+ */
+function validateTlsCertificate(claimInfo, certificateInfo, logger) {
+    // Extract hostname from the claim (this varies by provider)
+    let claimedHostname;
+    const paramsWithTemplates = niceParseJsonObject(claimInfo.parameters, 'params');
+    const params = substituteParamValues(paramsWithTemplates, undefined, true).newParams;
+    // Different providers store hostname in different places
+    if ('url' in params && typeof params.url === 'string') {
+        claimedHostname = new URL(params.url).hostname;
+    }
+    if (!claimedHostname) {
+        logger.warn('Could not extract hostname from claim for certificate validation', {
+            provider: claimInfo.provider
+        });
+        throw new AttestorError('ERROR_INVALID_CLAIM', 'Certificate validation failed: hostname not found');
+    }
+    logger.info('Validating TLS certificate for claimed hostname', {
+        claimedHostname,
+        certificateCommonName: certificateInfo.commonName,
+        certificateDnsNames: certificateInfo.dnsNames
+    });
+    // Check if claimed hostname matches certificate (including wildcard support)
+    const isValidForHostname = isHostnameValidForCertificate(claimedHostname, certificateInfo.commonName) ||
+        certificateInfo.dnsNames.some(name => isHostnameValidForCertificate(claimedHostname, name));
+    if (!isValidForHostname) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', `Certificate validation failed: hostname '${claimedHostname}' not valid for certificate (CN: ${certificateInfo.commonName}, SANs: ${certificateInfo.dnsNames.join(', ')})`);
+    }
+    // Check certificate validity period
+    const now = Date.now() / 1000; // Current time in Unix seconds
+    if (now < certificateInfo.notBeforeUnix || now > certificateInfo.notAfterUnix) {
+        throw new AttestorError('ERROR_INVALID_CLAIM', `Certificate validation failed: certificate not valid at current time (valid from ${new Date(certificateInfo.notBeforeUnix * 1000).toISOString()} to ${new Date(certificateInfo.notAfterUnix * 1000).toISOString()})`);
+    }
+    logger.info('TLS certificate validation passed', {
+        claimedHostname,
+        validatedAgainst: isHostnameValidForCertificate(claimedHostname, certificateInfo.commonName) ?
+            `CommonName: ${certificateInfo.commonName}` :
+            `SAN: ${certificateInfo.dnsNames.find(name => isHostnameValidForCertificate(claimedHostname, name))}`
+    });
+}
+/**
+ * Validates OPRF results have no overlapping ranges and combines them
+ * SECURITY: Prevents position collisions between ZK and OPRF MPC results
+ */
+function validateAndCombineOprfResults(zkOprfResults, oprfMpcResults, logger) {
+    const allOprfResults = [...zkOprfResults, ...oprfMpcResults];
+    if (allOprfResults.length === 0) {
+        return allOprfResults;
+    }
+    logger.info(`Combined ${zkOprfResults.length} ZK OPRF + ${oprfMpcResults.length} OPRF MPC results`);
+    // Check for overlapping ranges (position collision detection)
+    const seen = {};
+    for (const result of zkOprfResults) {
+        seen[result.position] = { length: result.length, source: 'zk' };
+    }
+    for (const result of oprfMpcResults) {
+        const existing = seen[result.position];
+        if (existing) {
+            // Exact duplicate at same position - verify they match
+            if (existing.length !== result.length) {
+                throw new AttestorError('ERROR_INVALID_CLAIM', `OPRF range conflict at position ${result.position}: ZK length ${existing.length} vs MPC length ${result.length}`);
+            }
+            logger.warn(`Duplicate OPRF range at position ${result.position} from both ZK and MPC - using MPC result`);
+        }
+        // Check for overlapping (but not identical) ranges
+        for (const [pos, data] of Object.entries(seen)) {
+            const position = Number(pos);
+            const existingEnd = position + data.length;
+            const newEnd = result.position + result.length;
+            const overlaps = (result.position < existingEnd && newEnd > position) && result.position !== position;
+            if (overlaps) {
+                throw new AttestorError('ERROR_INVALID_CLAIM', `Overlapping OPRF ranges: [${position}:${existingEnd}] (${data.source}) and [${result.position}:${newEnd}] (mpc)`);
+            }
+        }
+        seen[result.position] = { length: result.length, source: 'mpc' };
+    }
+    return allOprfResults;
+}