Import packages/plugin/tests/loopback.test.ts
This commit is contained in:
parent
5cb17eaeb0
commit
0d6c3362a5
|
|
@ -0,0 +1,245 @@
|
|||
import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs'
|
||||
import { afterEach, describe, expect, it, vi } from 'vitest'
|
||||
import { once } from 'node:events'
|
||||
import { createServer, request, type Server } from 'node:http'
|
||||
import { randomUUID } from 'node:crypto'
|
||||
import { WebSocket, WebSocketServer } from 'ws'
|
||||
import { LoopbackHost } from '../src/loopback-host.js'
|
||||
import { LoopbackPreview } from '../src/loopback-preview.js'
|
||||
import type { RemoteClientCore } from '@dsh-remote/client-core'
|
||||
import type { LoopbackRead } from '@dsh-remote/protocol'
|
||||
|
||||
const cleanup: Array<() => void | Promise<void>> = []
|
||||
const cleanupScenario1 = async () => {
|
||||
for (const close of cleanup.splice(0).reverse()) await close()
|
||||
}
|
||||
afterEach(cleanupScenario1)
|
||||
async function listen(server: Server): Promise<number> {
|
||||
await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve))
|
||||
cleanup.push(() => new Promise<void>(resolve => { server.closeAllConnections(); server.close(() => resolve()) }))
|
||||
return (server.address() as { port: number }).port
|
||||
}
|
||||
function host(ports: number[]) { const h = new LoopbackHost(() => ports); cleanup.push(() => h.closeAll()); return h }
|
||||
function rpc(host: LoopbackHost): RemoteClientCore {
|
||||
return { rpc: async (_method: string, params: unknown) => host.call(params) } as RemoteClientCore
|
||||
}
|
||||
function get(url: string, headers: Record<string, string> = {}): Promise<{ status: number; body: Buffer }> {
|
||||
const u = new URL(url)
|
||||
return new Promise((resolve, reject) => {
|
||||
const req = request({ hostname: '127.0.0.1', port: u.port, path: u.pathname + u.search, headers: { Host: u.host, ...headers } }, res => {
|
||||
const chunks: Buffer[] = []; res.on('data', data => chunks.push(data)); res.on('error', reject)
|
||||
res.on('end', () => resolve({ status: res.statusCode!, body: Buffer.concat(chunks) }))
|
||||
}); req.on('error', reject); req.end()
|
||||
})
|
||||
}
|
||||
|
||||
describe('restricted loopback HTTP / WebSocket preview', () => {
|
||||
it('denies unlisted ports, arbitrary hosts, absolute URLs and cross-peer handles', async () => {
|
||||
const h = host([])
|
||||
const base = { op: 'http.open', id: randomUUID(), port: 5173, path: '/', method: 'GET', headers: [] }
|
||||
await expect(h.call(base)).rejects.toMatchObject({ code: 'LOOPBACK_PORT_DENIED' })
|
||||
await expect(h.call({ ...base, host: '169.254.169.254' })).rejects.toThrow()
|
||||
for (const path of ['//other/', 'http://other/', '/\r\nheader', '/\\other']) await expect(h.call({ ...base, path })).rejects.toThrow()
|
||||
await expect(h.call({ op: 'http.read', id: randomUUID() })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' })
|
||||
})
|
||||
it('streams large responses in bounded chunks without following redirects', async () => {
|
||||
const data = Buffer.alloc(3 * 1024 * 1024 + 7, 91)
|
||||
const port = await listen(createServer((req, res) => {
|
||||
if (req.url === '/redirect') { res.writeHead(302, { Location: 'http://169.254.169.254/' }); res.end(); return }
|
||||
res.end(data)
|
||||
}))
|
||||
const h = host([port]); const id = randomUUID()
|
||||
expect(await h.call({ op: 'http.open', id, port, path: '/', method: 'GET', headers: [] })).toMatchObject({ status: 200 })
|
||||
const chunks: Buffer[] = []
|
||||
while (true) {
|
||||
const value = await h.call({ op: 'http.read', id }) as LoopbackRead
|
||||
const bytes = Buffer.from(value.data, 'base64'); expect(bytes.length).toBeLessThanOrEqual(65536); chunks.push(bytes)
|
||||
if (value.done) break
|
||||
}
|
||||
expect(Buffer.concat(chunks).equals(data)).toBe(true)
|
||||
expect(await h.call({ op: 'http.open', id: randomUUID(), port, path: '/redirect', method: 'GET', headers: [] })).toMatchObject({ status: 302 })
|
||||
})
|
||||
it('revokes HTTP handles and pending reads while keeping allowed ports usable', async () => {
|
||||
const revoked = createServer((_req, res) => { res.writeHead(200); res.flushHeaders() })
|
||||
const sockets = new Set<import('node:net').Socket>()
|
||||
revoked.on('connection', socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)) })
|
||||
const revokedPort = await listen(revoked)
|
||||
const keptPort = await listen(createServer((_req, res) => res.end('still allowed')))
|
||||
const h = host([revokedPort, keptPort])
|
||||
const id = randomUUID(); const keptId = randomUUID()
|
||||
const open = { op: 'http.open', id, port: revokedPort, path: '/', method: 'GET', headers: [] }
|
||||
await h.call(open)
|
||||
await h.call({ ...open, id: keptId, port: keptPort })
|
||||
let outcome: unknown
|
||||
void h.call({ op: 'http.read', id }).then(value => { outcome = value }, error => { outcome = error })
|
||||
h.setPorts([keptPort])
|
||||
await vi.waitFor(() => {
|
||||
expect(sockets.size).toBe(0)
|
||||
expect(outcome).toMatchObject({ code: 'LOOPBACK_READ_FAILED' })
|
||||
})
|
||||
await expect(h.call({ op: 'http.read', id })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' })
|
||||
await expect(h.call({ ...open, id: randomUUID() })).rejects.toMatchObject({ code: 'LOOPBACK_PORT_DENIED' })
|
||||
expect(Buffer.from((await h.call({ op: 'http.read', id: keptId }) as LoopbackRead).data, 'base64').toString()).toBe('still allowed')
|
||||
h.setPorts([])
|
||||
await expect(h.call({ op: 'http.read', id: keptId })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' })
|
||||
h.setPorts([revokedPort])
|
||||
await expect(h.call({ op: 'http.read', id })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' })
|
||||
await expect(h.call({ ...open, id: randomUUID() })).resolves.toMatchObject({ status: 200 })
|
||||
})
|
||||
it('terminates revoked WebSockets and wakes pending reads without waiting for their timeout', async () => {
|
||||
const server = createServer()
|
||||
const upstream = new WebSocketServer({ server })
|
||||
const port = await listen(server)
|
||||
cleanup.push(() => { for (const socket of upstream.clients) socket.terminate(); upstream.close() })
|
||||
const h = host([port]); const id = randomUUID()
|
||||
const open = { op: 'ws.open', id, port, path: '/', headers: [], protocols: [] }
|
||||
await h.call(open)
|
||||
let outcome: unknown
|
||||
void h.call({ op: 'ws.read', id }).then(value => { outcome = value }, error => { outcome = error })
|
||||
h.setPorts([])
|
||||
await vi.waitFor(() => {
|
||||
expect(upstream.clients.size).toBe(0)
|
||||
expect(outcome).toEqual({ messages: [], closed: true })
|
||||
})
|
||||
await expect(h.call({ op: 'ws.send', id, data: Buffer.from('denied').toString('base64'), binary: false }))
|
||||
.rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' })
|
||||
h.setPorts([port])
|
||||
await expect(h.call({ op: 'ws.read', id })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' })
|
||||
await h.call({ ...open, id: randomUUID() })
|
||||
expect(upstream.clients.size).toBe(1)
|
||||
})
|
||||
it('cancels pending HTTP and WebSocket opens when their ports are revoked', async () => {
|
||||
const rows = ['http', 'ws'] as const
|
||||
await runScenarios(
|
||||
rows.map((row, index) => {
|
||||
const kind = row
|
||||
return {
|
||||
name: scenarioName('cancels a pending %s open when its port is revoked', row, index),
|
||||
run: async () => {
|
||||
const server = createServer()
|
||||
const sockets = new Set<import('node:net').Socket>()
|
||||
server.on('connection', (socket) => {
|
||||
sockets.add(socket)
|
||||
socket.on('close', () => sockets.delete(socket))
|
||||
})
|
||||
const port = await listen(server)
|
||||
server.on('upgrade', (_req, socket) => {
|
||||
socket.on('end', () => socket.destroy())
|
||||
socket.resume()
|
||||
})
|
||||
cleanup.push(() => {
|
||||
for (const socket of sockets) socket.destroy()
|
||||
})
|
||||
const h = host([port])
|
||||
const id = randomUUID()
|
||||
const arrived = once(server, kind === 'http' ? 'request' : 'upgrade')
|
||||
let outcome: unknown
|
||||
void h
|
||||
.call(
|
||||
kind === 'http'
|
||||
? { op: 'http.open', id, port, path: '/', method: 'GET', headers: [] }
|
||||
: { op: 'ws.open', id, port, path: '/', headers: [], protocols: [] },
|
||||
)
|
||||
.then(
|
||||
(value) => {
|
||||
outcome = value
|
||||
},
|
||||
(error) => {
|
||||
outcome = error
|
||||
},
|
||||
)
|
||||
await arrived
|
||||
h.setPorts([])
|
||||
await vi.waitFor(() => {
|
||||
expect(outcome).toMatchObject({ code: 'LOOPBACK_UNAVAILABLE' })
|
||||
expect(sockets.size).toBe(0)
|
||||
})
|
||||
await expect(h.call({ op: kind === 'http' ? 'http.read' : 'ws.read', id })).rejects.toMatchObject({
|
||||
code: 'LOOPBACK_CLOSED',
|
||||
})
|
||||
},
|
||||
}
|
||||
}),
|
||||
async () => {
|
||||
await cleanupScenario1()
|
||||
},
|
||||
)
|
||||
})
|
||||
it('protects reused HTTP and WebSocket handles from late revoked reads', async () => {
|
||||
const rows = ['http', 'ws'] as const
|
||||
await runScenarios(
|
||||
rows.map((row, index) => {
|
||||
const kind = row
|
||||
return {
|
||||
name: scenarioName('does not close a reused %s id when a revoked read settles', row, index),
|
||||
run: async () => {
|
||||
const server = createServer((req, res) => {
|
||||
res.writeHead(200)
|
||||
if (req.url === '/replacement') res.end('replacement')
|
||||
else res.flushHeaders()
|
||||
})
|
||||
const upstream = new WebSocketServer({ server })
|
||||
const port = await listen(server)
|
||||
cleanup.push(() => {
|
||||
for (const socket of upstream.clients) socket.terminate()
|
||||
upstream.close()
|
||||
})
|
||||
const h = host([port])
|
||||
const id = randomUUID()
|
||||
const open =
|
||||
kind === 'http'
|
||||
? { op: 'http.open', id, port, path: '/', method: 'GET', headers: [] }
|
||||
: { op: 'ws.open', id, port, path: '/', headers: [], protocols: [] }
|
||||
await h.call(open)
|
||||
const oldRead = h
|
||||
.call({ op: kind === 'http' ? 'http.read' : 'ws.read', id })
|
||||
.catch((error) => error)
|
||||
h.setPorts([])
|
||||
h.setPorts([port])
|
||||
await h.call({ ...open, path: '/replacement' })
|
||||
await oldRead
|
||||
if (kind === 'http') {
|
||||
expect(
|
||||
Buffer.from(
|
||||
((await h.call({ op: 'http.read', id })) as LoopbackRead).data,
|
||||
'base64',
|
||||
).toString(),
|
||||
).toBe('replacement')
|
||||
} else {
|
||||
await expect(h.call({ op: 'ws.send', id, data: '', binary: false })).resolves.toEqual({
|
||||
sent: true,
|
||||
})
|
||||
}
|
||||
},
|
||||
}
|
||||
}),
|
||||
async () => {
|
||||
await cleanupScenario1()
|
||||
},
|
||||
)
|
||||
})
|
||||
it('isolates local preview origins and carries HTTP plus bidirectional HMR WebSocket', async () => {
|
||||
const server = createServer((req, res) => res.end(`page:${req.url}`))
|
||||
const upstream = new WebSocketServer({ server, handleProtocols: protocols => protocols.has('vite-hmr') ? 'vite-hmr' : false })
|
||||
upstream.on('connection', socket => socket.on('message', (data, binary) => socket.send(data, { binary })))
|
||||
const port = await listen(server)
|
||||
cleanup.push(() => { for (const socket of upstream.clients) socket.terminate(); upstream.close() })
|
||||
const h = host([port]); const preview = new LoopbackPreview(rpc(h)); cleanup.push(() => preview.close())
|
||||
const { url } = await preview.open(port)
|
||||
expect(new URL(url).hostname).toMatch(/^dsh-[a-f0-9]{48}\.localhost$/)
|
||||
expect((await get(url + 'src/main.ts')).body.toString()).toBe('page:/src/main.ts')
|
||||
expect((await get(url, { Host: 'evil.example' })).status).toBe(403)
|
||||
expect((await get(url, { Origin: 'https://evil.example' })).status).toBe(403)
|
||||
expect((await get(url, { 'Service-Worker': 'script' })).status).toBe(403)
|
||||
const parsed = new URL(url)
|
||||
const socket = new WebSocket(`ws://127.0.0.1:${parsed.port}/hmr?token=dev`, ['vite-hmr'], { headers: { Host: parsed.host, Origin: parsed.origin } })
|
||||
cleanup.push(() => socket.terminate())
|
||||
await new Promise<void>((resolve, reject) => { socket.once('open', resolve); socket.once('error', reject) })
|
||||
expect(socket.protocol).toBe('vite-hmr')
|
||||
const received = new Promise<string>(resolve => socket.once('message', bytes => resolve(bytes.toString())))
|
||||
socket.send('{"type":"update"}')
|
||||
expect(await received).toBe('{"type":"update"}')
|
||||
await preview.close()
|
||||
await expect(get(url)).rejects.toThrow()
|
||||
})
|
||||
})
|
||||
Loading…
Reference in New Issue