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

createCsrfMiddleware.test.ts

290 lines8.6 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('uses custom failure responses', async () => {
268 const middleware = createCsrfMiddleware({
269 failureResponse: new Response('CSRF failed', { status: 419 }),
270 })
271 const ctx = createContext({ handlerType: 'serverFn' })
272​
273 const { result } = await runMiddleware(middleware, ctx)
274​
275 expect((result as Response).status).toBe(419)
276 await expect((result as Response).text()).resolves.toBe('CSRF failed')
277 })
278})
279​
280function createContextFromRequest(
281 request: Request,
282): RequestServerOptions<Register, undefined> {
283 return {
284 request,
285 pathname: new URL(request.url).pathname,
286 context: undefined,
287 next: (() => undefined) as any,
288 handlerType: 'serverFn',
289 }