@fastify/express 4.0.9 → 4.0.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +15 -3
- package/index.js +372 -49
- package/package.json +4 -2
- package/test/absolute-form-url.test.js +52 -4
- package/test/enhance-request.test.js +57 -6
- package/test/form-data.test.js +3 -3
- package/test/middleware.test.js +1099 -35
- package/test/path-normalization.test.js +158 -0
- package/test/url-encoding.test.js +144 -0
|
@@ -96,3 +96,161 @@ test('useSemicolonDelimiter does not bypass path-scoped middleware', async t =>
|
|
|
96
96
|
|
|
97
97
|
t.assert.deepStrictEqual(middlewareCalls, 4)
|
|
98
98
|
})
|
|
99
|
+
|
|
100
|
+
test('case-insensitive routing does not bypass path-scoped middleware', async t => {
|
|
101
|
+
const instance = fastify({ routerOptions: { caseSensitive: false } })
|
|
102
|
+
t.after(() => instance.close())
|
|
103
|
+
|
|
104
|
+
await instance.register(expressPlugin)
|
|
105
|
+
|
|
106
|
+
let middlewareCalls = 0
|
|
107
|
+
let handlerCalls = 0
|
|
108
|
+
function requireToken (req, res, next) {
|
|
109
|
+
middlewareCalls++
|
|
110
|
+
if (req.headers.authorization === 'Bearer admin-secret-token') return next()
|
|
111
|
+
res.statusCode = 401
|
|
112
|
+
res.end('blocked')
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
let middlewareUrl
|
|
116
|
+
instance.use('/api/keys', (req, res, next) => {
|
|
117
|
+
middlewareUrl = req.baseUrl
|
|
118
|
+
requireToken(req, res, next)
|
|
119
|
+
})
|
|
120
|
+
instance.get('/api/keys', async req => {
|
|
121
|
+
handlerCalls++
|
|
122
|
+
return { url: req.url, rawUrl: req.raw.url, originalUrl: req.raw.originalUrl }
|
|
123
|
+
})
|
|
124
|
+
instance.use('/kiosk', requireToken)
|
|
125
|
+
instance.get('/kiosk/config', async () => {
|
|
126
|
+
handlerCalls++
|
|
127
|
+
return { secret: 'classified' }
|
|
128
|
+
})
|
|
129
|
+
|
|
130
|
+
const address = await instance.listen({ port: 0 })
|
|
131
|
+
for (const path of [
|
|
132
|
+
'/api/keys',
|
|
133
|
+
'/API/KEYS',
|
|
134
|
+
'/api/%E2%84%AAeys',
|
|
135
|
+
'/api/%E2%84%AAeys?Key=%E2%84%AA',
|
|
136
|
+
'/kiosk/config',
|
|
137
|
+
'/%E2%84%AAiosk/config'
|
|
138
|
+
]) {
|
|
139
|
+
const response = await fetch(address + path)
|
|
140
|
+
t.assert.strictEqual(response.status, 401, path)
|
|
141
|
+
t.assert.strictEqual(await response.text(), 'blocked', path)
|
|
142
|
+
}
|
|
143
|
+
t.assert.strictEqual(middlewareCalls, 6)
|
|
144
|
+
t.assert.strictEqual(handlerCalls, 0)
|
|
145
|
+
|
|
146
|
+
const response = await fetch(address + '/api/%E2%84%AAeys?Key=%E2%84%AA', {
|
|
147
|
+
headers: { authorization: 'Bearer admin-secret-token' }
|
|
148
|
+
})
|
|
149
|
+
t.assert.strictEqual(response.status, 200)
|
|
150
|
+
// Middleware matched on the folded path; the handler sees the original spelling.
|
|
151
|
+
t.assert.strictEqual(middlewareUrl, '/api/keys')
|
|
152
|
+
t.assert.deepStrictEqual(await response.json(), {
|
|
153
|
+
url: '/api/Keys?Key=%E2%84%AA',
|
|
154
|
+
rawUrl: '/api/Keys?Key=%E2%84%AA',
|
|
155
|
+
originalUrl: '/api/%E2%84%AAeys?Key=%E2%84%AA'
|
|
156
|
+
})
|
|
157
|
+
t.assert.strictEqual(middlewareCalls, 7)
|
|
158
|
+
t.assert.strictEqual(handlerCalls, 1)
|
|
159
|
+
})
|
|
160
|
+
|
|
161
|
+
test('case-sensitive routing does not fold the Kelvin sign', async t => {
|
|
162
|
+
const instance = fastify({ routerOptions: { caseSensitive: true } })
|
|
163
|
+
t.after(() => instance.close())
|
|
164
|
+
|
|
165
|
+
await instance.register(expressPlugin)
|
|
166
|
+
|
|
167
|
+
let middlewareCalls = 0
|
|
168
|
+
instance.use('/api/keys', (req, res) => {
|
|
169
|
+
middlewareCalls++
|
|
170
|
+
res.statusCode = 401
|
|
171
|
+
res.end('blocked')
|
|
172
|
+
})
|
|
173
|
+
instance.get('/api/keys', async () => ({ secret: 'classified' }))
|
|
174
|
+
|
|
175
|
+
const address = await instance.listen({ port: 0 })
|
|
176
|
+
const normal = await fetch(address + '/api/keys')
|
|
177
|
+
t.assert.strictEqual(normal.status, 401)
|
|
178
|
+
|
|
179
|
+
const kelvin = await fetch(address + '/api/%E2%84%AAeys')
|
|
180
|
+
t.assert.strictEqual(kelvin.status, 404)
|
|
181
|
+
t.assert.strictEqual(middlewareCalls, 1)
|
|
182
|
+
})
|
|
183
|
+
|
|
184
|
+
test('case-insensitive routing does not bypass RegExp middleware with uppercase prefixes or patterns', async t => {
|
|
185
|
+
const instance = fastify({ routerOptions: { caseSensitive: false } })
|
|
186
|
+
t.after(() => instance.close())
|
|
187
|
+
|
|
188
|
+
await instance.register(expressPlugin)
|
|
189
|
+
|
|
190
|
+
let middlewareCalls = 0
|
|
191
|
+
function block (_req, res) {
|
|
192
|
+
middlewareCalls++
|
|
193
|
+
res.statusCode = 401
|
|
194
|
+
res.end('blocked')
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
// Already case-insensitive patterns are kept as they are.
|
|
198
|
+
instance.use(/^\/root/i, block)
|
|
199
|
+
instance.get('/root', async () => ({ secret: 'classified' }))
|
|
200
|
+
|
|
201
|
+
await instance.register(async function (admin) {
|
|
202
|
+
admin.use(/^\/secret/, block)
|
|
203
|
+
admin.use([/^\/Keys/], block)
|
|
204
|
+
admin.get('/secret', async () => ({ secret: 'classified' }))
|
|
205
|
+
admin.get('/keys', async () => ({ secret: 'classified' }))
|
|
206
|
+
admin.get('/public', async () => ({ ok: true }))
|
|
207
|
+
}, { prefix: '/Admin' })
|
|
208
|
+
|
|
209
|
+
for (const path of ['/ROOT', '/admin/secret', '/ADMIN/SECRET', '/Admin/Secret', '/admin/keys', '/admin/%E2%84%AAeys']) {
|
|
210
|
+
middlewareCalls = 0
|
|
211
|
+
const response = await instance.inject(path)
|
|
212
|
+
t.assert.strictEqual(response.statusCode, 401, path)
|
|
213
|
+
t.assert.strictEqual(middlewareCalls, 1, path)
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
middlewareCalls = 0
|
|
217
|
+
const open = await instance.inject('/ADMIN/PUBLIC')
|
|
218
|
+
t.assert.strictEqual(open.statusCode, 200)
|
|
219
|
+
t.assert.strictEqual(middlewareCalls, 0)
|
|
220
|
+
})
|
|
221
|
+
|
|
222
|
+
test('case-insensitive routing keeps the original URL spelling for route handlers', async t => {
|
|
223
|
+
const instance = fastify({ routerOptions: { caseSensitive: false } })
|
|
224
|
+
t.after(() => instance.close())
|
|
225
|
+
|
|
226
|
+
await instance.register(expressPlugin)
|
|
227
|
+
|
|
228
|
+
let middlewareSeen
|
|
229
|
+
instance.use('/files', (req, _res, next) => {
|
|
230
|
+
middlewareSeen = { url: req.url, originalUrl: req.originalUrl }
|
|
231
|
+
next()
|
|
232
|
+
})
|
|
233
|
+
instance.get('/files/:name', async req => ({ url: req.url, rawUrl: req.raw.url, params: req.params }))
|
|
234
|
+
|
|
235
|
+
const address = await instance.listen({ port: 0 })
|
|
236
|
+
const response = await fetch(address + '/Files/ReadMe.TXT?Sig=AbC')
|
|
237
|
+
t.assert.strictEqual(response.status, 200)
|
|
238
|
+
t.assert.deepStrictEqual(await response.json(), {
|
|
239
|
+
url: '/Files/ReadMe.TXT?Sig=AbC',
|
|
240
|
+
rawUrl: '/Files/ReadMe.TXT?Sig=AbC',
|
|
241
|
+
params: { name: 'ReadMe.TXT' }
|
|
242
|
+
})
|
|
243
|
+
t.assert.deepStrictEqual(middlewareSeen, { url: '/readme.txt?Sig=AbC', originalUrl: '/Files/ReadMe.TXT?Sig=AbC' })
|
|
244
|
+
})
|
|
245
|
+
|
|
246
|
+
test('case-insensitive routing keeps the original URL spelling without any middleware', async t => {
|
|
247
|
+
const instance = fastify({ routerOptions: { caseSensitive: false } })
|
|
248
|
+
t.after(() => instance.close())
|
|
249
|
+
|
|
250
|
+
await instance.register(expressPlugin)
|
|
251
|
+
// Without any middleware Express does not run, and the URL must be restored all the same.
|
|
252
|
+
instance.get('/Other/:name', async req => ({ url: req.url, params: req.params }))
|
|
253
|
+
|
|
254
|
+
const response = await instance.inject('/OTHER/Name?Q=A')
|
|
255
|
+
t.assert.deepStrictEqual(response.json(), { url: '/OTHER/Name?Q=A', params: { name: 'Name' } })
|
|
256
|
+
})
|
|
@@ -0,0 +1,144 @@
|
|
|
1
|
+
'use strict'
|
|
2
|
+
|
|
3
|
+
const net = require('node:net')
|
|
4
|
+
const { test } = require('node:test')
|
|
5
|
+
const Fastify = require('fastify')
|
|
6
|
+
const express = require('express')
|
|
7
|
+
|
|
8
|
+
const expressPlugin = require('../index')
|
|
9
|
+
|
|
10
|
+
// Send the request target exactly as written: fetch() and http.request()
|
|
11
|
+
// would normalize backslashes or drop the fragment.
|
|
12
|
+
function requestTarget (address, target) {
|
|
13
|
+
const { hostname, port } = new URL(address)
|
|
14
|
+
|
|
15
|
+
return new Promise((resolve, reject) => {
|
|
16
|
+
const socket = net.createConnection({ host: hostname, port }, () => {
|
|
17
|
+
// Do not half-close the connection: Node.js aborts a request still in
|
|
18
|
+
// flight when the client ends its side, so its response would be lost.
|
|
19
|
+
// The server closes the connection after responding (Connection: close).
|
|
20
|
+
socket.write(`GET ${target} HTTP/1.1\r\nHost: ${hostname}:${port}\r\nConnection: close\r\n\r\n`)
|
|
21
|
+
})
|
|
22
|
+
|
|
23
|
+
let response = ''
|
|
24
|
+
socket.setEncoding('utf8')
|
|
25
|
+
socket.on('data', chunk => { response += chunk })
|
|
26
|
+
socket.on('end', () => {
|
|
27
|
+
resolve({
|
|
28
|
+
statusCode: Number(/^HTTP\/1\.1 (\d{3})/.exec(response)[1]),
|
|
29
|
+
payload: response.slice(response.indexOf('\r\n\r\n') + 4)
|
|
30
|
+
})
|
|
31
|
+
})
|
|
32
|
+
socket.on('error', reject)
|
|
33
|
+
})
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
function deny (req, res) {
|
|
37
|
+
res.statusCode = 401
|
|
38
|
+
res.end('auth required')
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
test('a backslash with whitespace or a fragment does not bypass mounts on dynamic segments', async t => {
|
|
42
|
+
const instance = Fastify({ routerOptions: { useSemicolonDelimiter: true } })
|
|
43
|
+
t.after(() => instance.close())
|
|
44
|
+
|
|
45
|
+
await instance.register(expressPlugin)
|
|
46
|
+
|
|
47
|
+
instance.use('/tenant/:id/admin', deny)
|
|
48
|
+
instance.get('/tenant/:id/admin', async () => ({ secret: true }))
|
|
49
|
+
|
|
50
|
+
instance.use(/^\/regexp\/[^/]+\/admin/, deny)
|
|
51
|
+
instance.get('/regexp/:id/admin', async () => ({ secret: true }))
|
|
52
|
+
|
|
53
|
+
const router = express.Router()
|
|
54
|
+
router.use('/router/:id/admin', deny)
|
|
55
|
+
instance.use(router)
|
|
56
|
+
instance.get('/router/:id/admin', async () => ({ secret: true }))
|
|
57
|
+
|
|
58
|
+
instance.register(async function (scoped) {
|
|
59
|
+
scoped.use('/admin', deny)
|
|
60
|
+
scoped.get('/admin', async () => ({ secret: true }))
|
|
61
|
+
}, { prefix: '/scoped/:id' })
|
|
62
|
+
|
|
63
|
+
const address = await instance.listen({ port: 0, host: '127.0.0.1' })
|
|
64
|
+
|
|
65
|
+
for (const base of ['/tenant', '/regexp', '/router', '/scoped']) {
|
|
66
|
+
for (const rest of [
|
|
67
|
+
'/x/admin',
|
|
68
|
+
'/x%5C%20/admin',
|
|
69
|
+
'/x%5C%09/admin',
|
|
70
|
+
'/x%5C%0A/admin',
|
|
71
|
+
'/x%5C%0C/admin',
|
|
72
|
+
'/x%5C%0D/admin',
|
|
73
|
+
'/x%5C%C2%A0/admin',
|
|
74
|
+
'/x%5C%EF%BB%BF/admin',
|
|
75
|
+
'/x%5C/admin?a=%20',
|
|
76
|
+
'/x%5C/admin;a=%20',
|
|
77
|
+
'/x%5C/admin?a=1#b',
|
|
78
|
+
'/x%5C/admin#',
|
|
79
|
+
'/x\\%20/admin',
|
|
80
|
+
'/x\\/admin#fragment'
|
|
81
|
+
]) {
|
|
82
|
+
const response = await requestTarget(address, base + rest)
|
|
83
|
+
t.assert.strictEqual(response.statusCode, 401, base + rest)
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
})
|
|
87
|
+
|
|
88
|
+
test('middleware and route handlers decode parameters and the query string once', async t => {
|
|
89
|
+
const instance = Fastify()
|
|
90
|
+
t.after(() => instance.close())
|
|
91
|
+
|
|
92
|
+
await instance.register(expressPlugin)
|
|
93
|
+
|
|
94
|
+
let seen
|
|
95
|
+
instance.use('/account/:id', (req, res, next) => {
|
|
96
|
+
seen = { id: req.params.id, query: { ...req.query } }
|
|
97
|
+
next()
|
|
98
|
+
})
|
|
99
|
+
instance.get('/account/:id', async request => ({ id: request.params.id, query: request.query }))
|
|
100
|
+
|
|
101
|
+
const address = await instance.listen({ port: 0, host: '127.0.0.1' })
|
|
102
|
+
|
|
103
|
+
for (const [target, id, query] of [
|
|
104
|
+
['/account/alice', 'alice', {}],
|
|
105
|
+
['/account/%2561lice', '%61lice', {}],
|
|
106
|
+
['/account/%252F', '%2F', {}],
|
|
107
|
+
['/account/a%2Fb', 'a/b', {}],
|
|
108
|
+
['/account/a%20b%5C', 'a b\\', {}],
|
|
109
|
+
['/account/alice?next=%2525&name=a%20b', 'alice', { next: '%25', name: 'a b' }],
|
|
110
|
+
['/account/alice?q=1#2', 'alice', { q: '1#2' }]
|
|
111
|
+
]) {
|
|
112
|
+
seen = undefined
|
|
113
|
+
const response = await requestTarget(address, target)
|
|
114
|
+
t.assert.strictEqual(response.statusCode, 200, target)
|
|
115
|
+
t.assert.deepStrictEqual(JSON.parse(response.payload), { id, query }, target)
|
|
116
|
+
t.assert.deepStrictEqual(seen, { id, query }, target)
|
|
117
|
+
}
|
|
118
|
+
})
|
|
119
|
+
|
|
120
|
+
test('mount paths are spelled like Fastify routes', async t => {
|
|
121
|
+
const instance = Fastify()
|
|
122
|
+
t.after(() => instance.close())
|
|
123
|
+
|
|
124
|
+
await instance.register(expressPlugin)
|
|
125
|
+
|
|
126
|
+
instance.use('/team docs', deny)
|
|
127
|
+
instance.get('/team docs', async () => ({ secret: true }))
|
|
128
|
+
|
|
129
|
+
instance.use(['/100%', '/a\u00a0b'], deny)
|
|
130
|
+
instance.get('/100%', async () => ({ secret: true }))
|
|
131
|
+
instance.get('/a\u00a0b', async () => ({ secret: true }))
|
|
132
|
+
|
|
133
|
+
instance.register(async function (scoped) {
|
|
134
|
+
scoped.use('/admin', deny)
|
|
135
|
+
scoped.get('/admin', async () => ({ secret: true }))
|
|
136
|
+
}, { prefix: '/shared files' })
|
|
137
|
+
|
|
138
|
+
const address = await instance.listen({ port: 0, host: '127.0.0.1' })
|
|
139
|
+
|
|
140
|
+
for (const target of ['/team%20docs', '/100%25', '/a%C2%A0b', '/shared%20files/admin']) {
|
|
141
|
+
const response = await requestTarget(address, target)
|
|
142
|
+
t.assert.strictEqual(response.statusCode, 401, target)
|
|
143
|
+
}
|
|
144
|
+
})
|