Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

createCsrfMiddleware.test.ts

427 lines13.1 KB

1import { describe, expect, it, vi } from 'vitest'
2import {
3 createCsrfMiddleware,
4 csrfSymbol,
5 getCsrfRequestValidationResult,
6 isCsrfRequestAllowed,
7} from '@tanstack/start-client-core'
8import type { RequestServerOptions } from '@tanstack/start-client-core'
9import type { Register } from '@tanstack/router-core'
10​
11const requestOrigin = 'https://app.example.com'
12​
13function trackHeaders(init: Record<string, string>) {
14 const headers = new Map(
15 Object.entries(init).map(([key, value]) => [key.toLowerCase(), value]),
16 )
17 const reads: Array<string> = []
18​
19 return {
20 reads,
21 request: {
22 url: `${requestOrigin}/_serverFn/test`,
23 headers: {
24 get(name: string) {
25 reads.push(name)
26 return headers.get(name.toLowerCase()) ?? null
27 },
28 },
29 } as Request,
30 }
32​
33function createContext(init: {
34 headers?: Record<string, string>
35 handlerType?: 'serverFn' | 'router'
36 origin?: string
37}): RequestServerOptions<Register, undefined> {
38 const { request } = trackHeaders(init.headers ?? {})
39 return {
40 request,
41 pathname: new URL(request.url).pathname,
42 context: undefined,
43 next: (() => undefined) as any,
44 handlerType: init.handlerType ?? 'serverFn',
45 }
47​
48async function runMiddleware(
49 middleware: ReturnType<typeof createCsrfMiddleware>,
50 ctx: RequestServerOptions<Register, undefined>,
51) {
52 const next = vi.fn(() => ({ request: ctx.request, pathname: ctx.pathname }))
53 const result = await middleware.options.server!({
54 ...ctx,
55 next,
56 } as any)
57 return { result, next }
59​
60describe('getCsrfRequestValidationResult', () => {
61 it('allows same-origin fetch metadata without reading Origin or Referer', async () => {
62 const { request, reads } = trackHeaders({
63 'Sec-Fetch-Site': 'same-origin',
64 Origin: 'https://evil.example.com',
65 Referer: 'https://evil.example.com/path',
66 })
67​
68 await expect(
69 getCsrfRequestValidationResult({}, createContextFromRequest(request)),
70 ).resolves.toBe(true)
71 expect(reads).toEqual(['Sec-Fetch-Site'])
72 })
73​
74 it.each(['same-site', 'cross-site', 'none', 'invalid'])(
75 'rejects %s fetch metadata',
76 async (fetchSite) => {
77 const ctx = createContext({
78 headers: {
79 'Sec-Fetch-Site': fetchSite,
80 Origin: requestOrigin,
81 Referer: `${requestOrigin}/path`,
82 },
83 })
84​
85 await expect(getCsrfRequestValidationResult({}, ctx)).resolves.toBe(false)
86 },
87 )
88​
89 it('allows matching Origin without reading Referer', async () => {
90 const { request, reads } = trackHeaders({
91 Origin: requestOrigin,
92 Referer: 'https://evil.example.com/path',
93 })
94​
95 await expect(
96 getCsrfRequestValidationResult({}, createContextFromRequest(request)),
97 ).resolves.toBe(true)
98 expect(reads).toEqual(['Sec-Fetch-Site', 'Origin'])
99 })
100​
101 it('rejects mismatched Origin without reading Referer', async () => {
102 const { request, reads } = trackHeaders({
103 Origin: 'https://evil.example.com',
104 Referer: `${requestOrigin}/path`,
105 })
106​
107 await expect(
108 getCsrfRequestValidationResult({}, createContextFromRequest(request)),
109 ).resolves.toBe(false)
110 expect(reads).toEqual(['Sec-Fetch-Site', 'Origin'])
111 })
112​
113 it.each([
114 requestOrigin,
115 `${requestOrigin}/path`,
116 `${requestOrigin}?query=1`,
117 `${requestOrigin}#hash`,
118 ])('allows same-origin Referer fallback: %s', async (referer) => {
119 const ctx = createContext({ headers: { Referer: referer } })
120​
121 await expect(getCsrfRequestValidationResult({}, ctx)).resolves.toBe(true)
122 })
123​
124 it.each([
125 'https://evil.example.com/path',
126 `${requestOrigin}.evil/path`,
127 `${requestOrigin}:443/path`,
128 ])('rejects cross-origin Referer fallback: %s', async (referer) => {
129 const ctx = createContext({ headers: { Referer: referer } })
130​
131 await expect(getCsrfRequestValidationResult({}, ctx)).resolves.toBe(false)
132 })
133​
134 it('returns undefined for requests without origin check headers', async () => {
135 const ctx = createContext({})
136​
137 await expect(
138 getCsrfRequestValidationResult({}, ctx),
139 ).resolves.toBeUndefined()
140 })
141​
142 it('rejects empty Referer header as known invalid origin check', async () => {
143 const ctx = createContext({ headers: { Referer: '' } })
144​
145 await expect(getCsrfRequestValidationResult({}, ctx)).resolves.toBe(false)
146 })
147​
148 it('rejects missing origin check headers by default', async () => {
149 const ctx = createContext({})
150​
151 await expect(isCsrfRequestAllowed({}, ctx)).resolves.toBe(false)
152 })
153​
154 it('allows missing origin check headers with the opt-in', async () => {
155 const ctx = createContext({})
156​
157 await expect(
158 isCsrfRequestAllowed({ allowRequestsWithoutOriginCheck: true }, ctx),
159 ).resolves.toBe(true)
160 })
161​
162 it('does not allow invalid origin check headers with the opt-in', async () => {
163 const ctx = createContext({ headers: { 'Sec-Fetch-Site': 'cross-site' } })
164​
165 await expect(
166 isCsrfRequestAllowed({ allowRequestsWithoutOriginCheck: true }, ctx),
167 ).resolves.toBe(false)
168 })
169​
170 it('uses custom origin matchers', async () => {
171 const ctx = createContext({
172 headers: { Origin: 'https://preview.example.com' },
173 })
174​
175 await expect(
176 getCsrfRequestValidationResult(
177 { origin: ['https://app.example.com', 'https://preview.example.com'] },
178 ctx,
179 ),
180 ).resolves.toBe(true)
181 })
182​
183 it('uses custom Sec-Fetch-Site matchers', async () => {
184 const ctx = createContext({ headers: { 'Sec-Fetch-Site': 'same-site' } })
185​
186 await expect(
187 getCsrfRequestValidationResult(
188 { secFetchSite: ['same-origin', 'same-site'] },
189 ctx,
190 ),
191 ).resolves.toBe(true)
192 })
193​
194 it('reads request URL origin only when needed', async () => {
195 const getUrl = vi.fn(() => `${requestOrigin}/_serverFn/test`)
196 const sameOriginFetch = createContext({
197 headers: { 'Sec-Fetch-Site': 'same-origin' },
198 })
199 Object.defineProperty(sameOriginFetch.request, 'url', { get: getUrl })
200​
201 await expect(
202 getCsrfRequestValidationResult({}, sameOriginFetch),
203 ).resolves.toBe(true)
204 expect(getUrl).not.toHaveBeenCalled()
205​
206 const originFallback = createContext({
207 headers: { Origin: requestOrigin },
208 })
209 Object.defineProperty(originFallback.request, 'url', { get: getUrl })
210​
211 await expect(
212 getCsrfRequestValidationResult({}, originFallback),
213 ).resolves.toBe(true)
214 expect(getUrl).toHaveBeenCalledTimes(1)
215 })
216})
217​
218describe('createCsrfMiddleware', () => {
219 it('marks middleware with csrfSymbol in non-production environments', () => {
220 const middleware = createCsrfMiddleware()
221​
222 expect(csrfSymbol in middleware).toBe(true)
223 })
224​
225 it('protects router requests by default', async () => {
226 const middleware = createCsrfMiddleware()
227 const ctx = createContext({ handlerType: 'router' })
228​
229 const { result, next } = await runMiddleware(middleware, ctx)
230​
231 expect(next).not.toHaveBeenCalled()
232 expect(result).toBeInstanceOf(Response)
233 expect((result as Response).status).toBe(403)
234 })
235​
236 it('protects server function requests by default', async () => {
237 const middleware = createCsrfMiddleware()
238 const ctx = createContext({ handlerType: 'serverFn' })
239​
240 const { result, next } = await runMiddleware(middleware, ctx)
241​
242 expect(next).not.toHaveBeenCalled()
243 expect(result).toBeInstanceOf(Response)
244 expect((result as Response).status).toBe(403)
245 })
246​
247 it('filters requests', async () => {
248 const middleware = createCsrfMiddleware({ filter: () => false })
249 const ctx = createContext({ handlerType: 'serverFn' })
250​
251 const { next } = await runMiddleware(middleware, ctx)
252​
253 expect(next).toHaveBeenCalledTimes(1)
254 })
255​
256 it('can filter to server function requests', async () => {
257 const middleware = createCsrfMiddleware({
258 filter: (ctx) => ctx.handlerType === 'serverFn',
259 })
260 const ctx = createContext({ handlerType: 'router' })
261​
262 const { next } = await runMiddleware(middleware, ctx)
263​
264 expect(next).toHaveBeenCalledTimes(1)
265 })
266​
267 it.each([false, true])(
268 'waits for an async filter returning %s before validating',
269 async (shouldValidate) => {
270 let resolveFilter!: (result: boolean) => void
271 const filterResult = new Promise<boolean>((resolve) => {
272 resolveFilter = resolve
273 })
274 const matcher = vi.fn(() => false)
275 const middleware = createCsrfMiddleware({
276 filter: () => filterResult,
277 secFetchSite: matcher,
278 })
279 const ctx = createContext({
280 headers: { 'Sec-Fetch-Site': 'same-origin' },
281 })
282 const pending = runMiddleware(middleware, ctx)
283​
284 expect(matcher).not.toHaveBeenCalled()
285 resolveFilter(shouldValidate)
286 const { result, next } = await pending
287​
288 expect(matcher).toHaveBeenCalledTimes(shouldValidate ? 1 : 0)
289 expect(next).toHaveBeenCalledTimes(shouldValidate ? 0 : 1)
290 if (shouldValidate) {
291 expect((result as Response).status).toBe(403)
292 }
293 },
294 )
295​
296 it.each([
297 ['secFetchSite', 'Sec-Fetch-Site', 'same-origin'],
298 ['origin', 'Origin', requestOrigin],
299 ['referer', 'Referer', `${requestOrigin}/path`],
300 ] as const)(
301 'awaits async %s matchers before continuing or rejecting',
302 async (option, header, value) => {
303 for (const allowed of [false, true]) {
304 const matcher = vi.fn(async () => allowed)
305 const middleware = createCsrfMiddleware({ [option]: matcher })
306 const ctx = createContext({ headers: { [header]: value } })
307​
308 const { result, next } = await runMiddleware(middleware, ctx)
309​
310 expect(matcher).toHaveBeenCalledOnce()
311 expect(matcher).toHaveBeenCalledWith(
312 value,
313 expect.objectContaining({ request: ctx.request }),
314 )
315 expect(next).toHaveBeenCalledTimes(allowed ? 1 : 0)
316 if (!allowed) {
317 expect((result as Response).status).toBe(403)
318 }
319 }
320 },
321 )
322​
323 it('matches a Referer origin with an async origin matcher', async () => {
324 const matcher = vi.fn(async () => true)
325 const middleware = createCsrfMiddleware({ origin: matcher })
326 const ctx = createContext({
327 headers: { Referer: `${requestOrigin}/path` },
328 })
329​
330 const { next } = await runMiddleware(middleware, ctx)
331​
332 expect(matcher).toHaveBeenCalledWith(
333 requestOrigin,
334 expect.objectContaining({ request: ctx.request }),
335 )
336 expect(next).toHaveBeenCalledOnce()
337 })
338​
339 it.each(['filter', 'secFetchSite', 'origin', 'referer', 'failureResponse'])(
340 'rejects when a synchronous or async %s callback throws',
341 async (option) => {
342 const error = new Error('CSRF callback failed')
343 const ctx = createContext({
344 headers:
345 option === 'secFetchSite'
346 ? { 'Sec-Fetch-Site': 'same-origin' }
347 : option === 'origin'
348 ? { Origin: requestOrigin }
349 : option === 'referer'
350 ? { Referer: `${requestOrigin}/path` }
351 : {},
352 })
353​
354 for (const callback of [
355 () => {
356 throw error
357 },
358 () => Promise.reject(error),
359 ]) {
360 const middleware = createCsrfMiddleware({ [option]: callback })
361 const next = vi.fn()
362 // Synchronous callback errors must still become rejected promises.
363 const result = middleware.options.server!({ ...ctx, next } as any)
364​
365 await expect(result).rejects.toBe(error)
366 expect(next).not.toHaveBeenCalled()
367 }
368 },
369 )
370​
371 it('uses custom failure responses', async () => {
372 const middleware = createCsrfMiddleware({
373 failureResponse: new Response('CSRF failed', { status: 419 }),
374 })
375 const ctx = createContext({ handlerType: 'serverFn' })
376​
377 const { result } = await runMiddleware(middleware, ctx)
378​
379 expect((result as Response).status).toBe(419)
380 await expect((result as Response).text()).resolves.toBe('CSRF failed')
381 })
382​
383 it('awaits custom failure response callbacks', async () => {
384 const response = new Response('CSRF failed', { status: 419 })
385 const failureResponse = vi.fn(async () => response)
386 const middleware = createCsrfMiddleware({ failureResponse })
387 const ctx = createContext({})
388​
389 const { result, next } = await runMiddleware(middleware, ctx)
390​
391 expect(failureResponse).toHaveBeenCalledWith(
392 expect.objectContaining({ request: ctx.request }),
393 )
394 expect(result).toBe(response)
395 expect(next).not.toHaveBeenCalled()
396 })
397​
398 it('clones a configured failure response for every request', async () => {
399 const failureResponse = new Response('CSRF failed', { status: 419 })
400 const middleware = createCsrfMiddleware({ failureResponse })
401​
402 for (let i = 0; i < 2; i++) {
403 const { result, next } = await runMiddleware(
404 middleware,
405 createContext({}),
406 )
407​
408 expect(result).not.toBe(failureResponse)
409 expect((result as Response).status).toBe(419)
410 await expect((result as Response).text()).resolves.toBe('CSRF failed')
411 expect(next).not.toHaveBeenCalled()
412 }
413 expect(failureResponse.bodyUsed).toBe(false)
414 })
415})
416​
417function createContextFromRequest(
418 request: Request,
419): RequestServerOptions<Register, undefined> {
420 return {
421 request,
422 pathname: new URL(request.url).pathname,
423 context: undefined,
424 next: (() => undefined) as any,
425 handlerType: 'serverFn',
426 }