From 09a9ca1fdd022501fe6c77bc73fc34c92b968b99 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Thu, 20 Aug 2026 17:54:33 +0900 Subject: [PATCH 1/6] fix: preserve oidc deep links across callback storage --- .../adr/0103-oidc-deep-link-state-recovery.md | 32 +++++++++++++++++++ frontend/src/oidcReturnUrl.test.ts | 13 +++++++- frontend/src/oidcReturnUrl.ts | 19 +++++++++-- 3 files changed, 60 insertions(+), 4 deletions(-) create mode 100644 docs/adr/0103-oidc-deep-link-state-recovery.md diff --git a/docs/adr/0103-oidc-deep-link-state-recovery.md b/docs/adr/0103-oidc-deep-link-state-recovery.md new file mode 100644 index 000000000..d4422a2af --- /dev/null +++ b/docs/adr/0103-oidc-deep-link-state-recovery.md @@ -0,0 +1,32 @@ +# ADR 0103: Recover authenticated deep links across OIDC callback contexts + +- Status: Accepted +- Date: 2026-08-20 +- Depends on: [0069](0069-member-locale-preference.md), [0028](0028-keyverse-oidc-provider.md) + +## Context + +The Buyer can be opened directly at `/?post=`. The OIDC provider callback +may omit application state or complete in a browser context where the original +tab's `sessionStorage` is not available. Falling back to `/` loses the post +deep link and presents the unauthenticated language/login surface again, even +when the member's OIDC session is otherwise valid. + +## Decision + +- Keep the OIDC `state.returnUrl` as the first recovery source. +- Persist the same validated same-origin path in both `sessionStorage` and + `localStorage` before redirecting to OIDC. `localStorage` is only a bounded + recovery fallback, not an authentication or authorization store. +- On callback, remove the key from both stores and use session storage before + local storage. Reject external and protocol-relative URLs. +- Keep member language preference account-scoped in + `user_account.preferred_locale`; this ADR does not move locale state into the + post URL, browser storage, or a `user_account + post_id` key. + +## Consequences + +Opening a shared post link survives a missing OIDC state payload or a changed +storage context without losing the post. A stale internal return path is +removed at callback, and authorization still comes only from the authenticated +OIDC token and backend ABAC checks. diff --git a/frontend/src/oidcReturnUrl.test.ts b/frontend/src/oidcReturnUrl.test.ts index 5c234d835..aa51637a3 100644 --- a/frontend/src/oidcReturnUrl.test.ts +++ b/frontend/src/oidcReturnUrl.test.ts @@ -6,7 +6,10 @@ import { } from "./oidcReturnUrl"; describe("OIDC return URL handling", () => { - beforeEach(() => window.sessionStorage.clear()); + beforeEach(() => { + window.sessionStorage.clear(); + window.localStorage.clear(); + }); it("keeps a post deep link and rejects external destinations", () => { expect(returnUrlFromLocation({ pathname: "/", search: "?post=abc", hash: "" })).toBe( @@ -22,5 +25,13 @@ describe("OIDC return URL handling", () => { rememberOidcReturnUrl("/?post=stored-again"); expect(restoreOidcReturnUrl('{"returnUrl":"/?post=from-json"}')).toBe("/?post=from-json"); expect(window.sessionStorage.getItem("lineageweave.oidc.returnUrl")).toBeNull(); + expect(window.localStorage.getItem("lineageweave.oidc.returnUrl")).toBeNull(); + }); + + it("restores a deep link from local storage when session storage is empty", () => { + window.localStorage.setItem("lineageweave.oidc.returnUrl", "/?post=from-local-storage"); + + expect(restoreOidcReturnUrl(undefined)).toBe("/?post=from-local-storage"); + expect(window.localStorage.getItem("lineageweave.oidc.returnUrl")).toBeNull(); }); }); diff --git a/frontend/src/oidcReturnUrl.ts b/frontend/src/oidcReturnUrl.ts index 60962e011..98a0a0498 100644 --- a/frontend/src/oidcReturnUrl.ts +++ b/frontend/src/oidcReturnUrl.ts @@ -18,6 +18,11 @@ export function rememberOidcReturnUrl(value: string): void { } catch { // OIDC state remains the fallback when session storage is unavailable. } + try { + window.localStorage.setItem(OIDC_RETURN_URL_STORAGE_KEY, value); + } catch { + // The OIDC state and session storage remain the fallbacks. + } } function stateReturnUrl(state: unknown): string { @@ -35,15 +40,23 @@ function stateReturnUrl(state: unknown): string { export function restoreOidcReturnUrl(state: unknown): string { const fromState = stateReturnUrl(state); - let stored = ""; + let sessionStored = ""; + let localStored = ""; try { - stored = window.sessionStorage.getItem(OIDC_RETURN_URL_STORAGE_KEY) ?? ""; + sessionStored = window.sessionStorage.getItem(OIDC_RETURN_URL_STORAGE_KEY) ?? ""; window.sessionStorage.removeItem(OIDC_RETURN_URL_STORAGE_KEY); + } catch { + // Fall through to local storage or the current path. + } + try { + localStored = window.localStorage.getItem(OIDC_RETURN_URL_STORAGE_KEY) ?? ""; + window.localStorage.removeItem(OIDC_RETURN_URL_STORAGE_KEY); } catch { // Fall through to the current path. } if (fromState) return fromState; - if (isSafeReturnUrl(stored)) return stored; + if (isSafeReturnUrl(sessionStored)) return sessionStored; + if (isSafeReturnUrl(localStored)) return localStored; return new URLSearchParams(window.location.search).has("post") ? returnUrlFromLocation() : window.location.pathname; From f7d11e397d852e698edd0a974a33c3bcc3a6bef8 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Thu, 20 Aug 2026 18:01:06 +0900 Subject: [PATCH 2/6] docs: avoid oidc adr number collision --- ...nk-state-recovery.md => 0109-oidc-deep-link-state-recovery.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/adr/{0103-oidc-deep-link-state-recovery.md => 0109-oidc-deep-link-state-recovery.md} (100%) diff --git a/docs/adr/0103-oidc-deep-link-state-recovery.md b/docs/adr/0109-oidc-deep-link-state-recovery.md similarity index 100% rename from docs/adr/0103-oidc-deep-link-state-recovery.md rename to docs/adr/0109-oidc-deep-link-state-recovery.md From e0dbc3860278e13d74b6dadd5be4fd75e9c107b1 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Thu, 20 Aug 2026 18:30:10 +0900 Subject: [PATCH 3/6] docs: align OIDC ADR heading --- docs/adr/0109-oidc-deep-link-state-recovery.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/adr/0109-oidc-deep-link-state-recovery.md b/docs/adr/0109-oidc-deep-link-state-recovery.md index d4422a2af..6742194f7 100644 --- a/docs/adr/0109-oidc-deep-link-state-recovery.md +++ b/docs/adr/0109-oidc-deep-link-state-recovery.md @@ -1,4 +1,4 @@ -# ADR 0103: Recover authenticated deep links across OIDC callback contexts +# ADR 0109: Recover authenticated deep links across OIDC callback contexts - Status: Accepted - Date: 2026-08-20 From 2d7f899de28703aeb6fc6f503a6519bb9cfb1a40 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Fri, 21 Aug 2026 08:05:44 +0900 Subject: [PATCH 4/6] fix: bound OIDC return state parsing --- CHANGELOG.d/2.12.6-oidc-deep-link-safety.md | 7 ++++ .../adr/0109-oidc-deep-link-state-recovery.md | 3 ++ frontend/src/oidcReturnUrl.test.ts | 32 +++++++++++++++++++ frontend/src/oidcReturnUrl.ts | 22 +++++++++---- 4 files changed, 58 insertions(+), 6 deletions(-) create mode 100644 CHANGELOG.d/2.12.6-oidc-deep-link-safety.md diff --git a/CHANGELOG.d/2.12.6-oidc-deep-link-safety.md b/CHANGELOG.d/2.12.6-oidc-deep-link-safety.md new file mode 100644 index 000000000..48599f982 --- /dev/null +++ b/CHANGELOG.d/2.12.6-oidc-deep-link-safety.md @@ -0,0 +1,7 @@ +# 2.12.6 — Bound OIDC deep-link state parsing + +## Fixed + +- OIDC callback state is parsed at most once and length-bounded before JSON + handling, preventing recursive encoded state from exhausting the browser + stack while preserving safe same-origin post deep links. diff --git a/docs/adr/0109-oidc-deep-link-state-recovery.md b/docs/adr/0109-oidc-deep-link-state-recovery.md index 6742194f7..808f12aff 100644 --- a/docs/adr/0109-oidc-deep-link-state-recovery.md +++ b/docs/adr/0109-oidc-deep-link-state-recovery.md @@ -15,6 +15,9 @@ when the member's OIDC session is otherwise valid. ## Decision - Keep the OIDC `state.returnUrl` as the first recovery source. +- Accept only a direct same-origin path, one bounded serialized object, or one + object value. Never recursively parse JSON-encoded strings; reject serialized + state and return paths longer than 4,096 characters before further handling. - Persist the same validated same-origin path in both `sessionStorage` and `localStorage` before redirecting to OIDC. `localStorage` is only a bounded recovery fallback, not an authentication or authorization store. diff --git a/frontend/src/oidcReturnUrl.test.ts b/frontend/src/oidcReturnUrl.test.ts index aa51637a3..de6e95502 100644 --- a/frontend/src/oidcReturnUrl.test.ts +++ b/frontend/src/oidcReturnUrl.test.ts @@ -19,6 +19,11 @@ describe("OIDC return URL handling", () => { }); it("restores an object or serialized OIDC state before storage fallback", () => { + rememberOidcReturnUrl("/?post=stored-before-direct"); + expect(restoreOidcReturnUrl("/?post=from-direct-state")).toBe( + "/?post=from-direct-state", + ); + rememberOidcReturnUrl("/?post=stored"); expect(restoreOidcReturnUrl({ returnUrl: "/?post=from-object" })).toBe("/?post=from-object"); @@ -28,6 +33,33 @@ describe("OIDC return URL handling", () => { expect(window.localStorage.getItem("lineageweave.oidc.returnUrl")).toBeNull(); }); + it("rejects oversized and recursively encoded state without exhausting the stack", () => { + rememberOidcReturnUrl("/?post=stored-fallback"); + const oversizedNestedState = `${"[".repeat(5000)}0${"]".repeat(5000)}`; + + expect(restoreOidcReturnUrl(oversizedNestedState)).toBe("/?post=stored-fallback"); + + rememberOidcReturnUrl("/?post=stored-after-encoded-state"); + const recursivelyEncoded = JSON.stringify(JSON.stringify({ returnUrl: "/?post=nested" })); + expect(restoreOidcReturnUrl(recursivelyEncoded)).toBe( + "/?post=stored-after-encoded-state", + ); + + rememberOidcReturnUrl("/?post=stored-after-invalid-json"); + expect(restoreOidcReturnUrl("not-json-state")).toBe( + "/?post=stored-after-invalid-json", + ); + }); + + it("rejects oversized direct paths before storing or restoring them", () => { + const oversizedPath = `/?post=${"a".repeat(4096)}`; + + rememberOidcReturnUrl(oversizedPath); + + expect(window.sessionStorage.getItem("lineageweave.oidc.returnUrl")).toBeNull(); + expect(restoreOidcReturnUrl({ returnUrl: oversizedPath })).toBe("/"); + }); + it("restores a deep link from local storage when session storage is empty", () => { window.localStorage.setItem("lineageweave.oidc.returnUrl", "/?post=from-local-storage"); diff --git a/frontend/src/oidcReturnUrl.ts b/frontend/src/oidcReturnUrl.ts index 98a0a0498..027d2f55b 100644 --- a/frontend/src/oidcReturnUrl.ts +++ b/frontend/src/oidcReturnUrl.ts @@ -1,9 +1,14 @@ export const OIDC_RETURN_URL_STORAGE_KEY = "lineageweave.oidc.returnUrl"; +const MAX_OIDC_RETURN_URL_LENGTH = 4096; type UrlLike = Pick; function isSafeReturnUrl(value: string): boolean { - return value.startsWith("/") && !value.startsWith("//"); + return ( + value.length <= MAX_OIDC_RETURN_URL_LENGTH && + value.startsWith("/") && + !value.startsWith("//") + ); } export function returnUrlFromLocation(location: UrlLike = window.location): string { @@ -26,15 +31,20 @@ export function rememberOidcReturnUrl(value: string): void { } function stateReturnUrl(state: unknown): string { - if (typeof state === "string") { + let candidate = state; + if (typeof candidate === "string") { + if (isSafeReturnUrl(candidate)) return candidate; + if (candidate.length > MAX_OIDC_RETURN_URL_LENGTH) return ""; try { - return stateReturnUrl(JSON.parse(state)); + candidate = JSON.parse(candidate); } catch { - return isSafeReturnUrl(state) ? state : ""; + return ""; } } - if (typeof state !== "object" || state === null || !("returnUrl" in state)) return ""; - const value = (state as { returnUrl?: unknown }).returnUrl; + if (typeof candidate !== "object" || candidate === null || !("returnUrl" in candidate)) { + return ""; + } + const value = (candidate as { returnUrl?: unknown }).returnUrl; return typeof value === "string" && isSafeReturnUrl(value) ? value : ""; } From dab3994ee49f299e86c4543a8c33845fe8d92eb8 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Fri, 21 Aug 2026 10:09:18 +0900 Subject: [PATCH 5/6] fix: reject unsafe OIDC return paths --- frontend/src/oidcReturnUrl.test.ts | 5 +++++ frontend/src/oidcReturnUrl.ts | 8 +++++++- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/frontend/src/oidcReturnUrl.test.ts b/frontend/src/oidcReturnUrl.test.ts index de6e95502..8582445ec 100644 --- a/frontend/src/oidcReturnUrl.test.ts +++ b/frontend/src/oidcReturnUrl.test.ts @@ -18,6 +18,11 @@ describe("OIDC return URL handling", () => { expect(returnUrlFromLocation({ pathname: "//evil.example", search: "", hash: "" })).toBe("/"); }); + it("rejects backslash and control-character paths that can change URL parsing", () => { + expect(restoreOidcReturnUrl({ returnUrl: "/\\evil.example" })).toBe("/"); + expect(restoreOidcReturnUrl({ returnUrl: "/\u0000post=abc" })).toBe("/"); + }); + it("restores an object or serialized OIDC state before storage fallback", () => { rememberOidcReturnUrl("/?post=stored-before-direct"); expect(restoreOidcReturnUrl("/?post=from-direct-state")).toBe( diff --git a/frontend/src/oidcReturnUrl.ts b/frontend/src/oidcReturnUrl.ts index 027d2f55b..45bef5dd4 100644 --- a/frontend/src/oidcReturnUrl.ts +++ b/frontend/src/oidcReturnUrl.ts @@ -4,10 +4,16 @@ const MAX_OIDC_RETURN_URL_LENGTH = 4096; type UrlLike = Pick; function isSafeReturnUrl(value: string): boolean { + const hasControlCharacter = [...value].some((character) => { + const code = character.charCodeAt(0); + return code <= 0x1f || code === 0x7f; + }); return ( value.length <= MAX_OIDC_RETURN_URL_LENGTH && value.startsWith("/") && - !value.startsWith("//") + !value.startsWith("//") && + !value.includes("\\") && + !hasControlCharacter ); } From dd9c3a80f44a7046f90edda51dbb22de69f0c0ae Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Fri, 21 Aug 2026 01:56:57 -0700 Subject: [PATCH 6/6] fix: render buyer-facing image evidence (#307) * fix: render buyer-facing image evidence * fix: label unavailable image evidence * docs: avoid buyer image adr number collision * docs: align image evidence ADR heading * test(image): cover source placement and OCR rendering * fix: validate buyer image sources at render boundary * fix: close remaining browser provider error leaks * docs: record browser provider error boundary * fix: avoid inventing image table headers --- CHANGELOG.d/2.12.6-provider-error-boundary.md | 1 + docs/adr/0123-provider-error-boundary.md | 6 +-- frontend/src/PostBody.test.tsx | 38 +++++++++++++++++++ frontend/src/PostBody.tsx | 29 +++++++++++--- 4 files changed, 66 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.d/2.12.6-provider-error-boundary.md b/CHANGELOG.d/2.12.6-provider-error-boundary.md index 99a2fbd4d..927fad08e 100644 --- a/CHANGELOG.d/2.12.6-provider-error-boundary.md +++ b/CHANGELOG.d/2.12.6-provider-error-boundary.md @@ -1,4 +1,5 @@ ## Fixed - Keep contextual-orchestrator, OIDC, RankWeave, TEPP, and durable-ingestion diagnostics behind stable product error boundaries while retaining the original exception for server-side chaining. +- Route browser transport and tenant-settings failures through the same boundary so 5xx provider details never reach buyer-facing error text. - Keep browser 5xx and transport failures behind the same stable client error boundary. diff --git a/docs/adr/0123-provider-error-boundary.md b/docs/adr/0123-provider-error-boundary.md index 48610ebeb..5cc6289d1 100644 --- a/docs/adr/0123-provider-error-boundary.md +++ b/docs/adr/0123-provider-error-boundary.md @@ -24,9 +24,9 @@ cannot escape as raw ``KeyError`` or type-error payloads from a library boundary. The browser API client is a second trust boundary: HTTP 5xx details are -discarded, and transport failures become a stable status-0 client error -before any UI handler can render them. Client-error details remain available -only for actionable validation or authorization responses. +discarded, and transport failures become a stable status-0 client error before +any UI handler can render them. Client-error details remain available only for +actionable validation or authorization responses. Missing or malformed evidence remains unavailable; it is never converted into a fabricated negative result. Existing input-validation errors outside a diff --git a/frontend/src/PostBody.test.tsx b/frontend/src/PostBody.test.tsx index 1a9b00c4a..86beb01c5 100644 --- a/frontend/src/PostBody.test.tsx +++ b/frontend/src/PostBody.test.tsx @@ -295,6 +295,44 @@ describe("PostBody", () => { expect(screen.getByText("Panel")).toBeInTheDocument(); }); + it("keeps escaped pipes and does not invent headers for unmarked region OCR", () => { + render( + '} + imageContent={[ + { + unit_index: 0, + mime_type: "image/png", + status_code: "described", + extracted_text: "| Item | State |\n| --- | --- |\n| Review \\| approve | Ready |", + caption: "A table image", + tags: [], + regions: [ + { + region_index: 0, + x_ratio: 0, + y_ratio: 0, + width_ratio: 1, + height_ratio: 1, + status_code: "described", + extracted_text: "| 1 | Panel |\n| 2 | Ready |", + caption: "An OCR region without a Markdown header marker.", + tags: [], + }, + ], + }, + ]} + />, + ); + + expect(screen.getByText("Review | approve")).toBeInTheDocument(); + expect(screen.getByRole("columnheader", { name: "Item" })).toBeInTheDocument(); + expect(screen.queryByRole("columnheader", { name: "1" })).not.toBeInTheDocument(); + expect(document.querySelector(".post-image-region-text p")?.textContent).toBe( + "| 1 | Panel |\n| 2 | Ready |", + ); + }); + it("keeps source-image placement while showing persisted OCR and caption evidence", () => { render( { - const cells = row.split("|").map((cell) => cell.trim()); + const cells = row.split(/(? cell.trim().replace(/\\\|/g, "|")); if (cells[0] === "") cells.shift(); if (cells[cells.length - 1] === "") cells.pop(); return cells; - }) + }); + if (!parsedRows.some((row) => row.every((cell) => /^:?-{3,}:?$/.test(cell)))) return null; + const rows = parsedRows .filter((row) => !row.every((cell) => /^:?-{3,}:?$/.test(cell))) .filter((row) => row.length > 1 && row.some(Boolean)); if (rows.length < 2 || rows.some((row) => row.length !== rows[0].length)) return null; @@ -22,10 +24,20 @@ function parsePipeDelimitedTable(text: string): string[][] | null { function renderImageText(text: string) { const rows = parsePipeDelimitedTable(text); if (!rows) return

{text}

; + const [header, ...bodyRows] = rows; return ( + + + {header.map((cell, cellIndex) => ( + + ))} + + - {rows.map((row, rowIndex) => ( + {bodyRows.map((row, rowIndex) => ( {row.map((cell, cellIndex) => ( @@ -72,7 +84,14 @@ function renderImageEvidence(
    {imageContent.regions.map((region) => (
  1. - {region.caption || region.extracted_text || t("Unknown")} + {region.caption ?

    {region.caption}

    : null} + {region.extracted_text ? ( +
    + {renderImageText(region.extracted_text)} +
    + ) : region.caption ? null : ( + t("Unknown") + )} {region.tags.length ? ( {t("Image tags")}: {region.tags.join(", ")}
+ {cell} +
{cell}