import { fetchOutboundHttpWithRedirects } from "~/utils/outboundHttp.server"; export const INVOICE_DOWNLOAD_MAX_BYTES = 25 * 1024 * 1024; export const INVOICE_DOWNLOAD_TIMEOUT_MS = 10_000; export const INVOICE_DOWNLOAD_TRUSTED_REDIRECT_LIMIT = 3; const INVOICE_DOWNLOAD_ACCEPT = "application/pdf,application/octet-stream;q=0.9"; type InvoiceDownloadFetchDeps = { fetchImpl?: typeof fetch; outboundFetch?: typeof fetchOutboundHttpWithRedirects; }; /** * Fetch an invoice file. URLs on the trusted provider origin (Lago) are fetched * directly — Lago answers Active-Storage blob URLs with a redirect (same-origin * hop for local disk storage, presigned object-storage URL for S3), so trusted * hops are followed manually and any off-origin hop is handed to the SSRF-safe * outbound client, which validates the target as a public host. */ export async function fetchInvoiceDownloadFile( fileUrl: string, options: { trustedProviderOrigin?: string | null } = {}, deps: InvoiceDownloadFetchDeps = {}, ): Promise { const trustedOrigin = normalizeOrigin(options.trustedProviderOrigin); let url = new URL(fileUrl); for (let hop = 0; hop <= INVOICE_DOWNLOAD_TRUSTED_REDIRECT_LIMIT; hop += 1) { if (!trustedOrigin || url.origin !== trustedOrigin) { return await (deps.outboundFetch ?? fetchOutboundHttpWithRedirects)( url.toString(), { headers: { accept: INVOICE_DOWNLOAD_ACCEPT } }, { timeoutMs: INVOICE_DOWNLOAD_TIMEOUT_MS }, ); } const response = await (deps.fetchImpl ?? fetch)(url, { headers: { accept: INVOICE_DOWNLOAD_ACCEPT }, redirect: "manual", signal: AbortSignal.timeout(INVOICE_DOWNLOAD_TIMEOUT_MS), }); const location = response.status >= 300 && response.status < 400 ? response.headers.get("location") : null; if (!location) { return response; } void response.body?.cancel().catch(() => undefined); url = new URL(location, url); } throw new Error("Invoice download exceeded the redirect limit."); } export function createBoundedInvoiceDownloadBody( response: Response, maxBytes = INVOICE_DOWNLOAD_MAX_BYTES, ): ReadableStream | null { if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) { throw new TypeError("Invoice download limit must be a positive safe integer."); } const contentLength = response.headers.get("content-length"); if (contentLength && /^\d+$/u.test(contentLength) && Number(contentLength) > maxBytes) { void response.body?.cancel().catch(() => undefined); throw new Error("Invoice download exceeds the configured size limit."); } if (!response.body) return null; const reader = response.body.getReader(); let bytesRead = 0; return new ReadableStream({ async pull(controller) { try { const chunk = await reader.read(); if (chunk.done) { controller.close(); return; } bytesRead += chunk.value.byteLength; if (bytesRead > maxBytes) { await reader.cancel().catch(() => undefined); controller.error(new Error("Invoice download exceeds the configured size limit.")); return; } controller.enqueue(chunk.value); } catch (error) { controller.error(error); } }, async cancel(reason) { await reader.cancel(reason).catch(() => undefined); }, }); } function normalizeOrigin(value: string | null | undefined): string | null { if (!value) return null; try { return new URL(value).origin; } catch { return null; } }