From e08f7e38576ba1be67574c1d2b42378895eebabf Mon Sep 17 00:00:00 2001 From: QQ Date: Tue, 17 Nov 2026 08:47:39 +0800 Subject: [PATCH] Import packages/plugin/src/lan-upload.ts --- packages/plugin/src/lan-upload.ts | 182 ++++++++++++++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 packages/plugin/src/lan-upload.ts diff --git a/packages/plugin/src/lan-upload.ts b/packages/plugin/src/lan-upload.ts new file mode 100644 index 0000000..facf985 --- /dev/null +++ b/packages/plugin/src/lan-upload.ts @@ -0,0 +1,182 @@ +import { randomBytes } from 'node:crypto' +import { createServer, type Server } from 'node:http' +import { networkInterfaces } from 'node:os' +import { WebSocket, WebSocketServer } from 'ws' +import { NoiseIkSession } from '@dsh-remote/crypto' +import { + LAN_UPLOAD_TICKET_MS, BINARY_UPLOAD_CHUNK_BYTES, SecureMessageCodec, + createLanUploadPrologue, createRpcError, createRpcResponse, decodeMessage, encodeMessage, + isLanUploadAddress, lanUploadRequestSchema, type LanUploadOffer, +} from '@dsh-remote/protocol' +import type { HostIdentity } from './identity-store.js' +import type { WorkspaceUploadHost } from './workspace-upload.js' +import { RpcError, safeErrorCode } from './safe-error.js' + +interface Entry { + server: Server + wss: WebSocketServer + socket?: WebSocket + timer?: ReturnType + handshakeTimer?: ReturnType + noise?: NoiseIkSession + sessionId: string + uploadId: string + used: boolean + opened: boolean + committed: boolean + disposed: boolean + rejectBinding?: () => void + queuedBytes: number + requests: number +} +export interface LanUploadOwner { + connectionId: string + peerIdentityKey: string + identity: () => HostIdentity + mode: () => string | undefined +} + +/** One authenticated control connection owns every listener, ticket and upload below. */ +export class LanUploadHost { + private closed = false + private entries = new Set() + + constructor( + private readonly upload: WorkspaceUploadHost, + private readonly owner: LanUploadOwner, + private readonly localAddresses: () => readonly string[] = () => Object.values(networkInterfaces()).flatMap(list => list ?? []).filter(a => a.family === 'IPv4' && !a.internal).map(a => a.address), + ) {} + + async open(input: unknown): Promise { + const p = lanUploadRequestSchema.parse(input) + if (!this.live() || !isLanUploadAddress(p.address) || !this.localAddresses().includes(p.address) + || this.entries.size >= 2) throw unavailable() + if ([...this.entries].some(e => e.uploadId === p.uploadId)) throw unavailable() + const server = createServer((_request, response) => { response.writeHead(404).end() }) + server.maxConnections = 4 + server.headersTimeout = 5_000 + server.requestTimeout = 5_000 + server.keepAliveTimeout = 1_000 + // Neither HTTP nor WebSocket compression is used. Only small Noise ciphertexts cross this socket. + const wss = new WebSocketServer({ noServer: true, maxPayload: 65535, perMessageDeflate: false }) + const entry: Entry = { server, wss, sessionId: p.sessionId, uploadId: p.uploadId, used:false, opened:false, committed:false, disposed:false, queuedBytes:0, requests:0 } + this.entries.add(entry) + try { + await new Promise((resolve, reject) => { + entry.rejectBinding = () => reject(unavailable()) + server.once('error', reject) + server.listen(0, p.address, () => { server.off('error', reject); entry.rejectBinding=undefined; if(entry.disposed){server.close();reject(unavailable())}else resolve() }) + }) + if (!this.live() || entry.disposed) throw unavailable() + const address = server.address() + if (!address || typeof address === 'string') throw unavailable() + const token = randomBytes(32).toString('base64url') + const path = `/ds-harness-remote/upload/${token}` + const offer: LanUploadOffer = { sessionId:p.sessionId, uploadId:p.uploadId, connectionId:this.owner.connectionId, + url:`ws://${p.address}:${address.port}${path}`, expiresInMs:LAN_UPLOAD_TICKET_MS } + entry.timer = setTimeout(() => { void this.dispose(entry) }, LAN_UPLOAD_TICKET_MS) + entry.timer.unref() + server.on('error', () => { void this.dispose(entry) }) + server.on('upgrade', (request, socket, head) => { + if (!this.live() || entry.disposed || entry.used || request.url !== path) { socket.destroy(); return } + entry.used = true + clearTimeout(entry.timer) + // Consume once at upgrade. A stolen ticket cannot authenticate as the bound peer. + try { wss.handleUpgrade(request, socket, head, ws => this.attach(entry, offer, ws)) } + catch { socket.destroy(); void this.dispose(entry) } + }) + return offer + } catch (error) { + await this.dispose(entry) + throw error instanceof RpcError ? error : unavailable() + } + } + + async closeAll(): Promise { + this.closed = true + await Promise.all([...this.entries].map(entry => this.dispose(entry))) + } + + private live() { return !this.closed && this.owner.mode() === 'LAN' } + + private attach(entry: Entry, offer: LanUploadOffer, socket: WebSocket) { + if (!this.live() || entry.disposed) { socket.terminate(); return } + entry.socket = socket + socket.on('error', () => { void this.dispose(entry) }) + socket.on('close', () => { void this.dispose(entry) }) + const identity = this.owner.identity() + const noise = new NoiseIkSession({ role:'responder', localPrivateKey:identity.privateKey, localPublicKey:identity.publicKey, + remotePublicKey:this.owner.peerIdentityKey, prologue:createLanUploadPrologue(offer) }) + entry.noise = noise + const incoming = new SecureMessageCodec(), outgoing = new SecureMessageCodec() + let tail = Promise.resolve() + const send = async (message: ReturnType | ReturnType) => { + for (const frame of outgoing.encode(encodeMessage(message))) { + if (!this.live() || entry.disposed || socket.readyState !== WebSocket.OPEN) throw unavailable() + await new Promise((resolve, reject) => socket.send(noise.encrypt(frame), {binary:true}, error => error ? reject(error) : resolve())) + } + } + const touch = () => { + clearTimeout(entry.timer) + entry.timer = setTimeout(() => { void this.dispose(entry) }, 120_000) + entry.timer.unref() + } + entry.handshakeTimer = setTimeout(() => { void this.dispose(entry) }, 5_000) + entry.handshakeTimer.unref() + socket.on('message', (raw, binary) => { + try { + if (!binary || !this.live() || entry.disposed) throw unavailable() + const bytes = raw instanceof Buffer ? raw : Buffer.from(raw as ArrayBuffer) + if (!noise.complete) { + noise.readHandshake(bytes) + socket.send(noise.writeHandshake(), {binary:true}) + clearTimeout(entry.handshakeTimer) + touch() + return + } + const data = incoming.decode(noise.decrypt(bytes)) + if (!data) return + if (data.byteLength > BINARY_UPLOAD_CHUNK_BYTES + 8192 || entry.queuedBytes + data.byteLength > 2*1024*1024 || entry.requests >= 8) throw unavailable() + const message = decodeMessage(data) + const payload = message.payload as {method?:unknown;params?:unknown} + const params = payload?.params as Record | undefined + if (message.type !== 'rpc.request' || !params || params.sessionId !== entry.sessionId || params.uploadId !== entry.uploadId + || !['workspace.upload.open','workspace.upload.chunk.binary','workspace.upload.commit','workspace.upload.abort'].includes(String(payload.method))) throw unavailable() + entry.queuedBytes += data.byteLength; entry.requests++ + touch() + tail = tail.then(async () => { + if (!this.live() || entry.disposed) return + const method = payload.method as string + try { + if (entry.committed || (method === 'workspace.upload.open' ? entry.opened || params.encoding !== 'binary-v1' : !entry.opened)) throw unavailable() + // Mark before awaiting: disconnect must clean an open whose reply never arrived. + if (method === 'workspace.upload.open') entry.opened = true + const result = await this.upload.call(method, params) + if (method === 'workspace.upload.commit') entry.committed = true + await send(createRpcResponse(message.id, result)) + } catch (error) { + await send(createRpcError(message.id, safeErrorCode(error), 'The LAN upload could not be completed.')).catch(() => undefined) + await this.dispose(entry) + } finally { entry.queuedBytes -= data.byteLength; entry.requests-- } + }).catch(() => { void this.dispose(entry) }) + } catch { void this.dispose(entry) } + }) + } + + private async dispose(entry: Entry) { + if (entry.disposed) return + entry.disposed = true + entry.rejectBinding?.(); entry.rejectBinding=undefined + this.entries.delete(entry) + clearTimeout(entry.timer); clearTimeout(entry.handshakeTimer) + entry.socket?.terminate() + entry.noise?.destroy() + for (const socket of entry.wss.clients) socket.terminate() + entry.wss.close() + entry.server.closeAllConnections() + entry.server.close() + // Publication is final even if the commit acknowledgement was lost. + if (entry.opened && !entry.committed) await this.upload.call('workspace.upload.abort', {sessionId:entry.sessionId,uploadId:entry.uploadId}).catch(() => undefined) + } +} +function unavailable() { return new RpcError('FEATURE_NOT_SUPPORTED', 'LAN upload is unavailable on this connection.') }