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

createCsrfMiddleware.ts

197 lines5.6 KB

1import { createIsomorphicFn } from '@tanstack/start-fn-stubs'
2import { createMiddleware } from './createMiddleware'
3import type {
4 RequestMiddlewareAfterServer,
5 RequestServerOptions,
6} from './createMiddleware'
7import type { Register } from '@tanstack/router-core'
8​
9export const csrfSymbol = Symbol.for('tanstack-start:csrf-middleware')
10​
11export type CsrfSecFetchSite =
12 | 'same-origin'
13 | 'same-site'
14 | 'cross-site'
15 | 'none'
16​
17export type CsrfMatcher<TValue, TRegister = Register, TMiddlewares = unknown> =
18 | TValue
19 | Array<TValue>
20 | ((
21 value: TValue | (string & {}),
22 ctx: RequestServerOptions<TRegister, TMiddlewares>,
23 ) => boolean | Promise<boolean>)
24​
25export interface CsrfMiddlewareOptions<
26 TRegister = Register,
27 TMiddlewares = unknown,
28> {
29 /**
30 * Return `true` to validate this request, or `false` to skip validation.
31 *
32 * @default undefined, which validates every request handled by this middleware.
33 */
34 filter?: (
35 ctx: RequestServerOptions<TRegister, TMiddlewares>,
36 ) => boolean | Promise<boolean>
37 /**
38 * Allowed Origin values. Defaults to the trusted request origin.
39 */
40 origin?: CsrfMatcher<string, TRegister, TMiddlewares>
41 /**
42 * Allowed Sec-Fetch-Site values.
43 *
44 * @default 'same-origin'
45 */
46 secFetchSite?: CsrfMatcher<CsrfSecFetchSite, TRegister, TMiddlewares>
47 /**
48 * Whether to use Referer as a fallback when Sec-Fetch-Site and Origin are absent.
49 *
50 * @default true
51 */
52 referer?:
53 | boolean
54 | ((
55 referer: string,
56 ctx: RequestServerOptions<TRegister, TMiddlewares>,
57 ) => boolean | Promise<boolean>)
58 /**
59 * Allow requests when Sec-Fetch-Site, Origin, and Referer are all missing.
60 *
61 * @default false
62 */
63 allowRequestsWithoutOriginCheck?: boolean
64 /**
65 * Optional response returned when CSRF validation fails.
66 *
67 * @default new Response('Forbidden', { status: 403 })
68 */
69 failureResponse?:
70 | Response
71 | ((
72 ctx: RequestServerOptions<TRegister, TMiddlewares>,
73 ) => Response | Promise<Response>)
75​
76type CreateCsrfMiddleware = <TRegister, TMiddlewares>(
77 opts?: CsrfMiddlewareOptions<TRegister, TMiddlewares>,
78) => RequestMiddlewareAfterServer<{}, undefined, undefined>
79​
80const innerCreateCsrfMiddleware: CreateCsrfMiddleware = (opts = {}) => {
81 const middleware = createMiddleware().server(async (ctx) => {
82 const csrfCtx = ctx as RequestServerOptions<any, any>
83​
84 if (opts.filter && !(await opts.filter(csrfCtx))) {
85 return ctx.next()
86 }
87​
88 if (await isCsrfRequestAllowed(opts, csrfCtx)) {
89 return ctx.next()
90 }
91​
92 return getFailureResponse(opts, csrfCtx)
93 })
94​
95 if (process.env.NODE_ENV !== 'production') {
96 Object.defineProperty(middleware, csrfSymbol, { value: true })
97 }
98​
99 return middleware
101​
102export const createCsrfMiddleware: CreateCsrfMiddleware =
103 createIsomorphicFn().server(innerCreateCsrfMiddleware) as CreateCsrfMiddleware
104​
105export async function isCsrfRequestAllowed<TRegister, TMiddlewares>(
106 opts: CsrfMiddlewareOptions<TRegister, TMiddlewares>,
107 ctx: RequestServerOptions<TRegister, TMiddlewares>,
108): Promise<boolean> {
109 const result = await getCsrfRequestValidationResult(opts, ctx)
110 return (
111 result === true ||
112 (result === undefined && opts.allowRequestsWithoutOriginCheck === true)
113 )
115​
116export async function getCsrfRequestValidationResult<TRegister, TMiddlewares>(
117 opts: CsrfMiddlewareOptions<TRegister, TMiddlewares>,
118 ctx: RequestServerOptions<TRegister, TMiddlewares>,
119): Promise<boolean | undefined> {
120 const fetchSite = ctx.request.headers.get('Sec-Fetch-Site')
121 if (fetchSite !== null) {
122 return matchValue(opts.secFetchSite ?? 'same-origin', fetchSite, ctx)
123 }
124​
125 const origin = ctx.request.headers.get('Origin')
126 if (origin !== null) {
127 if (opts.origin) {
128 return matchValue(opts.origin, origin, ctx)
129 }
130​
131 return origin === new URL(ctx.request.url).origin
132 }
133​
134 const referer = ctx.request.headers.get('Referer')
135 if (referer === null || opts.referer === false) {
136 return undefined
137 }
138​
139 if (typeof opts.referer === 'function') {
140 return opts.referer(referer, ctx)
141 }
142​
143 if (opts.origin) {
144 const refererOrigin = getOriginFromUrl(referer)
145 return (
146 refererOrigin !== undefined && matchValue(opts.origin, refererOrigin, ctx)
147 )
148 }
149​
150 return isRefererSameOrigin(referer, new URL(ctx.request.url).origin)
152​
153async function matchValue<TValue extends string, TRegister, TMiddlewares>(
154 matcher: CsrfMatcher<TValue, TRegister, TMiddlewares>,
155 value: string,
156 ctx: RequestServerOptions<TRegister, TMiddlewares>,
157): Promise<boolean> {
158 if (typeof matcher === 'function') {
159 return matcher(value, ctx)
160 }
161​
162 if (Array.isArray(matcher)) {
163 // typescript is dumb for array.includes()
164 return matcher.includes(value as TValue)
165 }
166​
167 return value === matcher
169​
170function getOriginFromUrl(url: string): string | undefined {
171 try {
172 return new URL(url).origin
173 } catch {
174 return undefined
175 }
177​
178function isRefererSameOrigin(referer: string, requestOrigin: string): boolean {
179 if (referer === requestOrigin) return true
180 if (!referer.startsWith(requestOrigin)) return false
181 if (referer.length === requestOrigin.length) return true
182 const code = referer.charCodeAt(requestOrigin.length)
183 return code === 47 /* '/' */ || code === 63 /* '?' */ || code === 35 /* '#' */
185​
186async function getFailureResponse<TRegister, TMiddlewares>(
187 opts: CsrfMiddlewareOptions<TRegister, TMiddlewares>,
188 ctx: RequestServerOptions<TRegister, TMiddlewares>,
189): Promise<Response> {
190 if (typeof opts.failureResponse === 'function') {
191 return opts.failureResponse(ctx)
192 }
193​
194 return (
195 opts.failureResponse?.clone() ?? new Response('Forbidden', { status: 403 })
196 )