Skip to content

3 листопада Next.js закрив сім вразливостей, і три з них про те, як use cache міг показати дані одного клієнта іншому. Розбираю механіку на коді, який можна запустити, даю скрипти перевірки й план оновлення для multi-tenant застосунків.

Опубліковано
Читання
15 хв
Автор
Yaroslav Tsarenko
–переглядів
Темний рельєф із рядом світлих комірок, у сусідню з яких просочується чужий бузковий потік

Найстрашніша вразливість у вебзастосунку не обов'язково та, де хакер запускає свій код на сервері. Іноді все тихіше: клієнт A відкриває дашборд і бачить рахунки клієнта B. Без зламу, без підозрілих запитів у логах. Просто кеш вирішив, що це «той самий запит».

Саме про такі сценарії три з семи вразливостей, які Next.js закрив 3 листопада у версіях 16.4.5 і 15.5.29. Якщо у вас SaaS із кількома компаніями-клієнтами, мовними версіями чи сайтами на одному коді, і ви вже перейшли на Cache Components з use cache — ця стаття для вас.

Нижче: що саме зламалось, чому кеш узагалі здатен віддати чужі дані (з кодом, який можна запустити), як за п'ять хвилин перевірити свій проєкт і як оновитись так, щоб отруєні записи не пережили патч. Усі виводи справжні: macOS, Node.js 25.7.

Що вийшло 3 листопада і кого це стосується

27 жовтня команда Next.js попередила про плановий реліз безпеки, а 3 листопада опублікувала його: 16.4.5 для активної LTS-гілки і 15.5.29 для гілки підтримки. 9 листопада вийшла 16.4.6, вона теж містить усі виправлення.

У блозі Next.js першу вразливість позначено як High, решту як Medium. В advisory на GitHub кожна має CVSS v4 від 6.0 до 6.9, тобто Moderate. Різниця в ярликах не повинна заспокоювати: для multi-tenant продукту «помірний» витік даних між клієнтами — це інцидент, про який доведеться повідомляти.

Вразливість Кого стосується Версії
use cache через unstable_cache (CVE-2026-119790) Cache Components, функція читає root param 16.3.0–16.4.4
Вкладені use cache і root params (CVE-2026-119351) Cache Components, вкладені кешовані функції 16.2.0–16.4.4
Бінарні аргументи use cache (CVE-2026-119349) Uint8Array, Blob як аргументи 16.0.0–16.4.4
Отруєння спільної оболонки next start, Partial Prefetching вимкнено або не задано self-hosted
Стиснуті відповіді за проксі (CVE-2026-119348) повертаєте чужий Response як є, HTTP/1.1-проксі 16.0.0–16.4.4, до 15.5.28
Куки в Edge-маршрутах (CVE-2026-119346) NextResponse.cookies.set() в Edge 15.0.0–15.5.28, 16.0.0–16.4.4
SVG в Image Optimization (CVE-2026-119347) нативний бекенд, що декодує SVG 15.0.0–15.5.28, 16.0.0–16.4.4

Cache Components (лише 16.x)

  • use cache + unstable_cache16.3.0–16.4.4, CVSS 6.3
  • Вкладені use cache і root params16.2.0–16.4.4, CVSS 6.3
  • Бінарні аргументи16.0.0–16.4.4, CVSS 6.3

Self-hosted

  • Отруєння спільної оболонкиnext start, Partial Prefetching вимкнено
  • Стиснуті відповіді за проксі15.x і 16.x, CVSS 6.3

Усі конфігурації

  • HttpOnly-куки в Edge-маршрутах15.x і 16.x, CVSS 6.0
  • SVG в Image Optimization15.x і 16.x, CVSS 6.9
Сім вразливостей листопадового релізу: кого стосуються

Помітили закономірність? Усе, що пов'язане з use cache, існує лише в гілці 16: там Cache Components стали стабільними. Тому 15.5.29 закриває чотири інші проблеми, а три витоки між тенантами — суто історія 16.x.

Чому кеш узагалі може віддати чужі дані

Почнімо з фундаменту, бо без нього решта виглядає магією. За документацією, ключ запису use cache складається з Build ID, ідентифікатора функції, серіалізованих аргументів і змінних із замикання. Плюс root params — але лише ті, які функція справді прочитала.

Із чого складається ключ use cacheза документацією Next.jsBuild IDновий деплой+Function IDхеш функції+Аргументисеріалізовані+Замиканнязмінні ззовні+Root paramsлише прочитаніВідстеження спрацювалоВідстеження пропущенеключ…|acme → дані acmeключ…|globex → дані globexключ… без тенанта → дані acmeкожен тенант має свій записglobex отримує дані acme

Останній пункт і є суть. Root params — це динамічні сегменти над кореневим layout, як-от app/[tenant]/layout.tsx. З 16.3 їх можна читати будь-де через import { tenant } from "next/root-params", без передавання пропсами. Зручно, але тепер тенант потрапляє в ключ не явно, а через відстеження: Next.js має помітити, що функція його прочитала. Пропустить цей момент — запис стане спільним для всіх.

Ось іграшкова модель цього класу помилок. Це не код Next.js, а 40 рядків, які показують ту саму механіку: функція читає тенанта з контексту запиту, а ключ кешу будується лише з аргументів.

ts
import { AsyncLocalStorage } from "node:async_hooks";

const request = new AsyncLocalStorage<{ tenant: string }>();
const tenant = () => request.getStore()!.tenant;

const db: Record<string, string[]> = {
  acme: ["Invoice #1 ACME", "Invoice #2 ACME"],
  globex: ["Invoice #7 GLOBEX"],
};

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

function memo<A extends unknown[], R>(fn: (...args: A) => Promise<R>, keyOf: (...args: A) => string) {
  const store = new Map<string, Promise<R>>();
  return (...args: A) => {
    const key = keyOf(...args);
    if (!store.has(key)) store.set(key, fn(...args));
    return store.get(key)!;
  };
}

async function loadInvoices(limit: number) {
  const t = tenant();
  await sleep(50);
  return db[t].slice(0, limit);
}

const unsafe = memo(loadInvoices, (limit) => `invoices:${limit}`);
const safe = memo(
  async (t: string, limit: number) => {
    await sleep(50);
    return db[t].slice(0, limit);
  },
  (t, limit) => `invoices:${t}:${limit}`,
);

async function run(label: string, get: (t: string) => Promise<string[]>) {
  const [a, b] = await Promise.all(
    ["acme", "globex"].map((t) => request.run({ tenant: t }, async () => `${t} sees ${JSON.stringify(await get(t))}`)),
  );
  console.log(`${label}\n  ${a}\n  ${b}`);
}

await run("unsafe key (args only):", () => unsafe(10));
await run("safe key (tenant is an argument):", (t) => safe(t, 10));
text
$ node memo-leak.ts
unsafe key (args only):
  acme sees ["Invoice #1 ACME","Invoice #2 ACME"]
  globex sees ["Invoice #1 ACME","Invoice #2 ACME"]
safe key (tenant is an argument):
  acme sees ["Invoice #1 ACME","Invoice #2 ACME"]
  globex sees ["Invoice #7 GLOBEX"]

Globex бачить рахунки ACME. Жодного зламу, лише ключ без одного виміру. У Next.js відстеження root params зазвичай працює правильно. Листопадові вразливості — це три ситуації, де воно не встигало або де ключ збігався для різних даних.

Три витоки через use cache

Тепер по черзі: де саме відстеження не встигало і що з цим робити у вашому коді.

Витік 1: use cache всередині unstable_cache

Сценарій: у вас є кешована функція, яка читає tenant із root params. Частина коду викликає її напряму, а старіший модуль досі загортає її в unstable_cache. Next.js і так кидає помилку на таке вкладення, але advisory описує вікно гонки: після старту процесу, поки перше заповнення ще триває, виклик через unstable_cache може отримати чужий результат без перевірки root params.

Запит тенанта acmeЗапит тенантаglobexuse cache-функціяКеш unstable_cache1прямий виклик, кеш холодний2той самий виклик через un…3отримує результат acme бе…4зберігає під ключем без тенанта5наступні запити globex бачать дані acme
Гонка на холодному кеші: як unstable_cache отримує чужий результат

Далі гірше: цей результат зберігається в unstable_cache під ключем без тенанта і віддається наступним запитам, доки запис не ревалідують чи не витіснять. Тобто один невдалий холодний старт отруює кеш надовго.

Обхідний шлях у цьому випадку офіційний і повний: не викликайте use cache-функцію через unstable_cache. Advisory прямо каже, що уникнути такого вкладення — повноцінне рішення. Що це означає на практиці:

ts
import { cacheLife, cacheTag } from "next/cache";
import { tenant } from "next/root-params";

export async function getInvoices(limit: number) {
  "use cache";
  cacheLife("minutes");
  const t = await tenant();
  cacheTag(`invoices:${t}`);
  return db.invoices.findMany({ where: { tenantId: t }, take: limit });
}

Одна функція, одна модель кешування, тег із тенантом для точкової інвалідизації. Ніяких обгорток зі старого API.

Витік 2: вкладені use cache і root params

Друга вразливість (CVE-2026-119351) тонша. Зовнішня кешована функція викликає внутрішню, а внутрішня читає root param і повертає об'єкт, де частина значень готова одразу, а частина — ще проміс. Зовнішня функція бере готову частину, завершується і зберігається раніше, ніж внутрішня встигла записати свою залежність від root param.

Результат: запис зовнішньої функції без тенанта в ключі, спільний для всіх. За даними advisory, такі записи ще й ігнорують теги й час життя вкладених кешів. Зловмисник не контролює, що саме витече, все залежить від того, чий запит записав кеш першим. Але для мовних версій сайту це означає «англійський текст на українській сторінці», а для SaaS — дані чужої компанії.

Звідси практичне правило, корисне і після патча: якщо функція залежить від тенанта, передавайте тенанта аргументом, а не покладайтесь на те, що його помітять глибоко у вкладеному виклику. Документація Next.js сама радить для cookies і headers «читати поза кешем і передавати аргументом». Для тенанта це той самий принцип.

ts
export async function getDashboard(tenantId: string) {
  "use cache";
  cacheLife("minutes");
  cacheTag(`dashboard:${tenantId}`);
  const [invoices, stats] = await Promise.all([getInvoicesFor(tenantId, 10), getStatsFor(tenantId)]);
  return { invoices, stats };
}

Ключ тепер містить tenantId явно, на будь-якому рівні вкладеності. Нудно? Так. Безпечно? Теж так.

Витік 3: бінарні аргументи з однаковим ключем

Третій advisory коротко каже: різні бінарні аргументи, як-от Uint8Array чи Blob, могли давати однаковий ключ кешу. Якщо за цими байтами ви розрізняєте користувачів (підписаний токен, хеш сесії, файл), один користувач отримує результат іншого або підкладає свій.

Деталей механіки advisory не розкриває, тож ось ілюстрація самого класу проблеми на наївному серіалізаторі ключа:

Різні байти, однаковий ключілюстрація класу помилки на наївному серіалізаторіНаївний ключBlob «alice»Blob «bob»[{}]один запис для обохХеш рядкомBlob «alice»Blob «bob»55d7bb25…536ac816…два окремі записи
ts
import { createHash } from "node:crypto";

const naiveKey = (...args: unknown[]) => JSON.stringify(args);

const alice = new Blob(["session-of-alice"]);
const bob = new Blob(["session-of-bob"]);
console.log("naive:", naiveKey(alice), naiveKey(bob), naiveKey(alice) === naiveKey(bob));

const digest = async (b: Blob) => createHash("sha256").update(Buffer.from(await b.arrayBuffer())).digest("hex").slice(0, 16);
const [ka, kb] = [await digest(alice), await digest(bob)];
console.log("hashed:", ka, kb, ka === kb);
text
$ node binary-key.ts
naive: [{}] [{}] true
hashed: 55d7bb25fc8d8b53 536ac816b5bc8150 false

Два різні Blob перетворились на однаковий [{}]. Висновок незалежно від версії: не передавайте в кешовані функції бінарні дані, якщо від них залежить, чиї це дані. Порахуйте хеш поза кешем і передайте рядок, а ще краще — ідентифікатор користувача, який ви вже перевірили.

Self-hosted: спільна оболонка і стиснуті відповіді

Дві вразливості стосуються тих, хто запускає Next.js сам: Docker, VPS, Kubernetes.

Отруєння спільної оболонки. При next start з Cache Components і вимкненим (або просто не заданим) Partial Prefetching неавтентифікований запит із підібраним URL міг записати в спільну статичну оболонку значення конкретного запиту. Наслідок — неправильний контент або стійкі 404 на інших URL. Умови вузькі: динамічний параметр зі значенням, якого не було на білді, ще два глибших параметри без пререндеру і layout, що читає один із них у Suspense. За даними команди, з увімкненим Partial Prefetching у тестах проблеми не було. До речі, у гайді з App Router я радив задавати partialPrefetching: true явно, і тут це теж допомагає.

Стиснуті відповіді за проксі (CVE-2026-119348). Знайомий патерн «простий проксі»: route handler робить fetch і повертає Response як є. fetch розпаковує тіло, а заголовки content-encoding і content-length залишаються від стиснутого оригіналу. За HTTP/1.1-проксі, який ставить запити в чергу на одному з'єднанні з бекендом, ця розбіжність зсуває межі відповідей. І частина чужої відповіді дістається іншому клієнту.

Чому старі заголовки стиснення зсувають відповідіілюстрація; числа умовніЗаголовки: content-encoding: gzip, content-length: 312Тіло після fetch: 1 024 байти, вже розпаковане312712Проксі відрізає 312 байтКлієнт 1: обрізана відповідьРешта 712 байтдістаються клієнту 2 в тому ж з'єднанніРішення: свій Response без чужих content-encoding і content-length

Патч це виправляє, але сам патерн варто прибрати. Не повертайте чужий Response без змін:

ts
const ALLOWED = new Set(["api.partner.example"]);

export async function GET(req: Request) {
  const raw = new URL(req.url).searchParams.get("u");
  const target = raw && URL.canParse(raw) ? new URL(raw) : null;
  if (!target || target.protocol !== "https:" || !ALLOWED.has(target.hostname)) {
    return new Response("Forbidden", { status: 403 });
  }

  const upstream = await fetch(target, { headers: { accept: "application/json" } });
  const headers = new Headers({ "content-type": upstream.headers.get("content-type") ?? "application/octet-stream" });
  return new Response(upstream.body, { status: upstream.status, headers });
}

Білий список хостів, власні заголовки замість скопійованих, жодних content-encoding і content-length від чужого сервера. Бонусом ви закриваєте SSRF, якщо його раніше не було закрито.

Edge-куки і SVG: дві вразливості для всіх

HttpOnly, який перестав бути HttpOnly (CVE-2026-119346). Edge Route Handlers і Edge API routes у Pages Router, які ставлять куку через NextResponse.cookies.set(), дублювали її у внутрішньому заголовку x-middleware-set-cookie. А цей заголовок, на відміну від Set-Cookie, може прочитати JavaScript з того самого origin. Сам по собі це не XSS: потрібен чужий скрипт на вашому домені. Але HttpOnly існує саме для того, щоб XSS не перетворювався на крадіжку сесії. Маршрути на Node.js і cookies().set() не зачепило.

SVG в обхід заборони (CVE-2026-119347). Зображення з дозволеного джерела могло видавати себе за AVIF і проходити повз images.dangerouslyAllowSVG: false, а потім декодуватися як SVG. Білий список джерел працює, XSS чи виконання коду в advisory не продемонстровано. Ризик — навантаження на SVG-парсер і його власні вразливості. Якщо ви дозволяєте зображення з доменів, куди користувачі завантажують файли, це ваш випадок.

Чи зачепило вас: дерево рішень і два скрипти

Чи зачепило ваш проєктперевіряйте згори вниз; перше «так» — ваша відповідьcacheComponents і кілька тенантів чи мов?такНайвищий ризик: патч і аудитSelf-hosted: next start чи свій проксі?такПатч + partialPrefetchingEdge-маршрути ставлять куки, є SVG?такПатч, куки через Node.jsВерсія нижча за патч, решта — нітакПросто оновіться до 16.4.6

Перший скрипт — версія. Він читає встановлений next з node_modules (а не діапазон із package.json, який може брехати) і повертає код 1, якщо версія вразлива. Зручно для CI.

ts
import { readFileSync } from "node:fs";
import { join } from "node:path";

const PATCHED: Record<string, string> = { "15": "15.5.29", "16": "16.4.5" };

const parse = (v: string) => v.split("-")[0].split(".").map(Number);
const lt = (a: string, b: string) => {
  const [x, y] = [parse(a), parse(b)];
  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] < y[i];
  return false;
};

const root = process.argv[2] ?? process.cwd();
const { version } = JSON.parse(readFileSync(join(root, "node_modules/next/package.json"), "utf8"));
const major = version.split(".")[0];
const fixed = PATCHED[major];

if (!fixed) console.log(`next ${version}: no patch line in this release, upgrade to 16.4.5+`);
else if (lt(version, fixed)) {
  console.log(`next ${version}: VULNERABLE, upgrade to ${fixed} or newer`);
  process.exitCode = 1;
} else console.log(`next ${version}: patched (>= ${fixed})`);
text
$ node check-next.ts ./app-a
next 16.4.4: VULNERABLE, upgrade to 16.4.5 or newer
$ node check-next.ts ./app-b
next 15.5.29: patched (>= 15.5.29)
$ node check-next.ts ./app-c
next 16.4.6: patched (>= 16.4.5)

Другий скрипт шукає в коді патерни з advisory. Це не сканер вразливостей, а список місць, які варто переглянути очима, навіть після оновлення:

ts
import { readFileSync, readdirSync, statSync } from "node:fs";
import { join, relative } from "node:path";

type Rule = { id: string; why: string; test: (src: string) => boolean };

const rules: Rule[] = [
  { id: "use-cache+unstable_cache", why: "use cache function wrapped by unstable_cache (CVE-2026-119790)",
    test: (s) => /["']use cache/.test(s) && /unstable_cache\(/.test(s) },
  { id: "use-cache+root-params", why: "cached code reads root params: check nesting (CVE-2026-119351)",
    test: (s) => /["']use cache/.test(s) && /from ["']next\/root-params["']/.test(s) },
  { id: "use-cache+binary-arg", why: "binary argument in a cached function (CVE-2026-119349)",
    test: (s) => /["']use cache/.test(s) && /:\s*(Uint8Array|ArrayBuffer|Blob|Buffer)\b/.test(s) },
  { id: "edge+cookies.set", why: "NextResponse cookies set in an Edge route (CVE-2026-119346)",
    test: (s) => /runtime\s*=\s*["']edge["']/.test(s) && /\.cookies\.set\(/.test(s) },
  { id: "fetch-passthrough", why: "fetched Response returned as is (CVE-2026-119348, self-hosted)",
    test: (s) => /return\s+(await\s+)?fetch\(/.test(s) },
  { id: "svg-allowed", why: "dangerouslyAllowSVG enabled",
    test: (s) => /dangerouslyAllowSVG\s*:\s*true/.test(s) },
];

const root = process.argv[2] ?? ".";
const skip = new Set(["node_modules", ".next", ".git"]);

function* walk(dir: string): Generator<string> {
  for (const name of readdirSync(dir)) {
    if (skip.has(name)) continue;
    const path = join(dir, name);
    if (statSync(path).isDirectory()) yield* walk(path);
    else if (/\.(t|j)sx?$|\.mjs$/.test(name)) yield path;
  }
}

let hits = 0;
for (const file of walk(root)) {
  const src = readFileSync(file, "utf8");
  for (const r of rules) {
    if (!r.test(src)) continue;
    hits++;
    console.log(`${relative(root, file)}  [${r.id}]  ${r.why}`);
  }
}
console.log(hits ? `\n${hits} place(s) to review` : "nothing suspicious found");
process.exitCode = hits ? 1 : 0;

На тестовому проєкті з трьома навмисно поганими файлами:

text
$ node audit-use-cache.ts ./fixture
app/api/login/route.ts  [edge+cookies.set]  NextResponse cookies set in an Edge route (CVE-2026-119346)
app/api/proxy/route.ts  [fetch-passthrough]  fetched Response returned as is (CVE-2026-119348, self-hosted)
lib/reports.ts  [use-cache+unstable_cache]  use cache function wrapped by unstable_cache (CVE-2026-119790)
lib/reports.ts  [use-cache+root-params]  cached code reads root params: check nesting (CVE-2026-119351)
lib/reports.ts  [use-cache+binary-arg]  binary argument in a cached function (CVE-2026-119349)

5 place(s) to review

Регулярні вирази грубі, тож хибні спрацювання будуть. Це нормально: краще п'ять зайвих рядків, ніж один пропущений unstable_cache.

Як оновитись без сюрпризів

Оновлення саме по собі — одна команда. Сюрпризи починаються навколо неї.

  1. Поставте актуальну патч-версію. npm install next@16.4.6 (або next@15.5.29 для гілки 15). Потім npm ls next: якщо в монорепозиторії є другий застосунок чи пакет із власною копією next, він залишиться вразливим.
  2. Перевірте lockfile у CI. Діапазон ^16.4.0 у package.json нічого не гарантує, якщо lockfile закріпив 16.4.3. Запускайте check-next.ts після npm ci.
  3. Подумайте про отруєні записи. Записи use cache містять Build ID, тож новий деплой їх скидає. А от unstable_cache і fetch-кеш, за документацією, переживають деплої. Звідси висновок: якщо ви мали вкладення з першого витоку, отруєний запис у unstable_cache може лишитись і після патча. Викличте revalidateTag для відповідних тегів або очистіть сховище кастомного cache handler.
  4. Перевірте Edge-маршрути з куками. Якщо там ставиться сесійна кука, після оновлення ротуйте сесії тих користувачів, у кого є підстави підозрювати XSS. Без ознак XSS кука не витікала.
  5. Проженіть тест на тенантів на staging одразу після next start, поки кеш холодний.

Ось той самий тест. Він паралельно відкриває дашборди двох тенантів і шукає в HTML маркер чужого:

ts
const base = process.env.BASE_URL ?? "http://localhost:3000";
const tenants = ["acme", "globex"];
const parallel = 5;
const rounds = 20;
const marker = (t: string) => `data-tenant="${t}"`;

let leaks = 0;
for (let i = 0; i < rounds; i++) {
  const results = await Promise.all(
    tenants.flatMap((t) =>
      Array.from({ length: parallel }, async () => {
        const res = await fetch(`${base}/${t}/dashboard`, { headers: { "x-test-round": String(i) } });
        const html = await res.text();
        const foreign = tenants.filter((o) => o !== t && html.includes(marker(o)));
        return foreign.length ? `${t} received ${foreign.join(", ")}` : null;
      }),
    ),
  );
  for (const r of results) if (r) { leaks++; console.log(`round ${i}: ${r}`); }
}

const total = rounds * tenants.length * parallel;
console.log(leaks ? `${leaks} of ${total} responses contain another tenant` : `${total} responses, no foreign tenant markers`);
process.exitCode = leaks ? 1 : 0;

Перевірив його на двох локальних серверах-заглушках: чесному і навмисно «дірявому», який запам'ятовує першого тенанта.

text
$ BASE_URL=http://localhost:3999 node tenant-race.ts
200 responses, no foreign tenant markers

$ BASE_URL=http://localhost:3999 node tenant-race.ts
round 0: globex received acme
round 0: globex received acme
round 0: globex received acme
...
100 of 200 responses contain another tenant

Додайте у свій layout атрибут data-tenant (він нічого не розкриває, тенант і так є в URL), і тест стане частиною CI. Якщо сторінки за логіном, передайте сесійні куки тестових акаунтів у headers.

Якщо витік уже міг статися

Неприємне питання, яке рідко ставлять у технічних статтях: а що, якщо ваш продукт кілька місяців стояв на вразливій версії і всі умови збігались? Логи тут допоможуть слабо: з погляду сервера кожен запит був легітимним, а відповідь просто взялась із кешу.

Що можна зробити чесно:

  • Звузьте коло. Чи були ввімкнені Cache Components? Чи є в коді вкладення з першого витоку або бінарні аргументи? Якщо аудит-скрипт нічого не знайшов, а cacheComponents вимкнено, ризик витоку між тенантами практично нульовий.
  • Пошукайте сигнали від людей. Звернення в підтримку на кшталт «бачу чужі замовлення» або «сторінка показує не ту мову» тепер мають пояснення. Перечитайте тікети за останні місяці.
  • Зафіксуйте рішення письмово. Що перевірили, що знайшли, коли оновились. Якщо продукт обробляє персональні дані громадян ЄС, стаття 33 GDPR вимагає повідомити наглядовий орган не пізніше ніж за 72 години після того, як ви дізнались про витік (якщо він створює ризик для людей). Якщо ж ви обробляєте дані за дорученням клієнта, повідомити треба його, і без зволікань.

Я не юрист, і рішення про повідомлення ухвалює власник продукту. Але технічна частина — «чи могло це статися саме у нас» — це день роботи інженера, а не тиждень паніки.

Правила multi-tenant кешу, які переживуть наступний патч

Патч закриває конкретні баги. Але наступного разу баг буде інший, а клас помилки той самий: ключ кешу, у якому бракує виміру «чиє це». Ось правила, яких я тримаюсь у продуктах із кількома ролями й клієнтами:

  • Тенант і користувач — явні аргументи. Root params зручні для мови сайту. Для даних, які належать компанії, передавайте ідентифікатор явно, щоб він гарантовано був у ключі.
  • Один API кешування. Не змішуйте use cache і unstable_cache для тих самих даних. Мігрували — мігруйте до кінця.
  • Теги з тенантом. cacheTag(`invoices:${tenantId}`) дає точкову інвалідизацію і зрозумілий слід у логах.
  • Ніяких бінарних аргументів, що визначають власника. Хеш або перевірений ідентифікатор, рядком.
  • Перевірка доступу поза кешем. Кеш відповідає на «які дані», а не на «чи можна їх бачити». Авторизацію робіть до виклику кешованої функції, на кожен запит.
  • Тест холодного старту в CI. Описаний вище скрипт ловить цілий клас помилок, а не одну CVE.

Останній пункт для мене не теорія. У AllShip AI на одному коді живуть вантажовідправники, перевізники, водії й адміністратори, і я перевірив 109 точок входу на права доступу. Найнеприємніші знахідки в таких аудитах — це не «дірка в логіні», а місця, де дані правильного типу віддаються не тому власнику.

Окремо про ШІ-асистентів у коді. Агент охоче загорне стару функцію в unstable_cache «для швидкості» або передасть Buffer у кешовану функцію, бо це компілюється. Про те, де саме такі агенти спотикаються на реальних задачах, я писав у розборі дослідження про AI-агентів. Мораль та сама: довіряй, але перевіряй автоматично.

Що зробити цього тижня

Чекліст

  • next у lockfile щонайменше 16.4.5 або 15.5.29, у кожному пакеті монорепозиторію
  • Жодна use cache-функція не викликається через unstable_cache
  • Функції, що залежать від тенанта, отримують його аргументом
  • У кешованих функціях немає Uint8Array, Blob чи Buffer, що визначають власника даних
  • Після оновлення ревалідовано теги unstable_cache, якщо було вкладення
  • Self-hosted: partialPrefetching: true задано явно, проксі-маршрути не повертають чужий Response як є
  • Сесійні куки ставляться через cookies().set() або в Node.js-маршрутах
  • dangerouslyAllowSVG вимкнено, джерела зображень — лише ваші
  • Тест на тенантів запускається в CI після кожного деплою на staging

З чого почати

Запустіть обидва скрипти на своєму репозиторії. Версія свіжа й аудит порожній? Чудово, додайте тест на тенантів у CI і забудьте до наступного релізу безпеки. Знайшлись unstable_cache поруч із use cache або бінарні аргументи? Виправте ці місця до оновлення, а після деплою ревалідуйте кеш.

Якщо у вас Next.js-продукт із кількома клієнтами чи ролями, де кешування додавали поступово й ніхто вже не пам'ятає, що з чим вкладено, — з таким я працюю регулярно. Як я веду такі проєкти, описано на сторінці розробки на Next.js.

Було корисно?

– вподобань · – переглядів

LinkedInXTelegramFacebook
Потрібно таке для вашого продукту?Розробка на Next.js і Node.js — від бази даних до інтерфейсуДетальніше →

Часті запитання

Яку версію Next.js ставити після листопадового оновлення безпеки?

Для гілки 16 щонайменше 16.4.5, а краще актуальну 16.4.6 (9 листопада). Для гілки 15 — 15.5.29. Три вразливості Cache Components існують лише в 16.x, тому на 15.5.29 закриваються інші чотири: Edge-куки, стиснуті відповіді, SVG і самохостинг.

Чи стосуються вразливості use cache мого проєкту, якщо я не вмикав cacheComponents?

Ні, три витоки між тенантами і отруєння оболонки потребують увімкнених Cache Components. Але решта три вразливості (куки в Edge-маршрутах, стиснуті відповіді за проксі, SVG в оптимізації зображень) від цього не залежать, тож оновлюватись треба все одно.

Чи треба чистити кеш після оновлення Next.js?

Записи use cache прив'язані до Build ID, тому новий деплой їх скидає. А записи unstable_cache і fetch-кешу переживають деплої. Якщо ви обгортали use cache-функцію в unstable_cache, після оновлення варто викликати revalidateTag для відповідних тегів або очистити сховище кешу.

Чи зачепило застосунки на Vercel?

Частина вразливостей описана для self-hosted конфігурацій: отруєння спільної оболонки при next start і змішування відповідей за HTTP/1.1-проксі. Витоки через use cache і Edge-куки залежать від коду застосунку, а не від хостингу, тож оновлення потрібне всім.