From 2b795ecd718a7de504b3a8549f0b3908e345935d Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 15:04:29 +0800 Subject: [PATCH] Import packages/protocol/tests/frame-limits.test.ts --- packages/protocol/tests/frame-limits.test.ts | 358 +++++++++++++++++++ 1 file changed, 358 insertions(+) create mode 100644 packages/protocol/tests/frame-limits.test.ts diff --git a/packages/protocol/tests/frame-limits.test.ts b/packages/protocol/tests/frame-limits.test.ts new file mode 100644 index 0000000..edb11e0 --- /dev/null +++ b/packages/protocol/tests/frame-limits.test.ts @@ -0,0 +1,358 @@ +import { runScenarios } from '../../../scripts/test-scenarios.mjs' +import { describe, expect, it } from 'vitest' +import { + PROTOCOL_VERSION, + SECURE_FRAGMENT_CHUNK_BYTES, + MAX_SECURE_MESSAGE_BYTES, + HARNESS_API_TRANSFER_CHUNK_BYTES, + MAX_HARNESS_API_TRANSFER_BYTES, + CODEX_APP_TRANSFER_CHUNK_BYTES, + MAX_CODEX_APP_TRANSFER_BYTES, + SecureMessageCodec, +} from '../src/index.js' + +const MAX_IN_FLIGHT_SECURE_MESSAGES = 8 + +describe('protocol limit constants', () => { + it('preserves secure fragment and independent transfer budgets', async () => { + await runScenarios([ + { + name: 'PROTOCOL_VERSION is 1', + run: () => { + expect(PROTOCOL_VERSION).toBe(1) + }, + }, + { + name: 'SECURE_FRAGMENT_CHUNK_BYTES is 48 KiB', + run: () => { + expect(SECURE_FRAGMENT_CHUNK_BYTES).toBe(48 * 1024) + }, + }, + { + name: 'MAX_SECURE_MESSAGE_BYTES is 4 MiB', + run: () => { + expect(MAX_SECURE_MESSAGE_BYTES).toBe(4 * 1024 * 1024) + }, + }, + { + name: 'keeps image transfers bounded without raising the secure-message limit', + run: () => { + expect(HARNESS_API_TRANSFER_CHUNK_BYTES).toBe(512 * 1024) + expect(MAX_HARNESS_API_TRANSFER_BYTES).toBe(288 * 1024 * 1024) + expect(HARNESS_API_TRANSFER_CHUNK_BYTES).toBeLessThan(MAX_SECURE_MESSAGE_BYTES) + }, + }, + { + name: 'keeps Codex history transfers in an independent bounded domain', + run: () => { + expect(CODEX_APP_TRANSFER_CHUNK_BYTES).toBe(512 * 1024) + expect(MAX_CODEX_APP_TRANSFER_BYTES).toBe(288 * 1024 * 1024) + expect(CODEX_APP_TRANSFER_CHUNK_BYTES).toBeLessThan(MAX_SECURE_MESSAGE_BYTES) + }, + }, + ]) + }, 25000) + +}) + +describe('SecureMessageCodec message size limit', () => { + it('enforces the secure message size boundary', async () => { + await runScenarios([ + { + name: 'accepts message at exactly MAX_SECURE_MESSAGE_BYTES', + run: () => { + const codec = new SecureMessageCodec() + const message = new Uint8Array(MAX_SECURE_MESSAGE_BYTES) + const frames = codec.encode(message) + expect(frames.length).toBeGreaterThan(0) + }, + }, + { + name: 'rejects message exceeding MAX_SECURE_MESSAGE_BYTES', + run: () => { + const codec = new SecureMessageCodec() + const message = new Uint8Array(MAX_SECURE_MESSAGE_BYTES + 1) + expect(() => codec.encode(message)).toThrow('Secure message exceeds the reassembly limit.') + }, + }, + ]) + }, 10000) + +}) + +describe('SecureMessageCodec fragment reassembly limits', () => { + it('rejects more than MAX_IN_FLIGHT_SECURE_MESSAGES concurrent assemblies', () => { + const decoder = new SecureMessageCodec() + const encoder = new SecureMessageCodec() + + const messages = Array.from({ length: 9 }, (_, i) => + new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 2 + i)) + + const allFrames = messages.map(msg => encoder.encode(msg)) + + for (let i = 0; i < 8; i++) { + decoder.decode(allFrames[i]![0]!) + } + + expect(() => decoder.decode(allFrames[8]![0]!)).toThrow('Secure fragment sequence is invalid.') + }) + + it('rejects repeated or unordered fragments', async () => { + await runScenarios([ + { + name: 'rejects out-of-order fragments', + run: () => { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 3) + const frames = encoder.encode(message) + expect(frames).toHaveLength(3) + + decoder.decode(frames[0]!) + expect(() => decoder.decode(frames[2]!)).toThrow('Secure fragment sequence is invalid.') + }, + }, + { + name: 'rejects duplicate fragment index', + run: () => { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 2) + const frames = encoder.encode(message) + expect(frames).toHaveLength(2) + + decoder.decode(frames[0]!) + expect(() => decoder.decode(frames[0]!)).toThrow('Secure fragment sequence is invalid.') + }, + }, + ]) + }, 10000) + + it('rejects fragment with wrong chunk size', () => { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 2) + const frames = encoder.encode(message) + + const corrupted = new Uint8Array(frames[0]!.byteLength + 10) + corrupted.set(frames[0]!) + + expect(() => decoder.decode(corrupted)).toThrow('Secure fragment length is invalid.') + }) +}) + +describe('SecureMessageCodec fragment header validation', () => { + it('rejects malformed fragment metadata', async () => { + await runScenarios([ + { + name: 'rejects fragment with invalid version', + run: () => { + const codec = new SecureMessageCodec() + + const message = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES + 1) + const frames = new SecureMessageCodec().encode(message) + const corrupted = new Uint8Array(frames[0]!) + corrupted[4] = 99 + + expect(() => codec.decode(corrupted)).toThrow('Secure fragment header is invalid.') + }, + }, + { + name: 'rejects fragment with messageId = 0', + run: () => { + const codec = new SecureMessageCodec() + + const fragment = new Uint8Array(17 + 100) + fragment.set([0x44, 0x53, 0x48, 0x46]) + fragment[4] = 1 + const view = new DataView(fragment.buffer) + view.setUint32(5, 0) + view.setUint16(9, 0) + view.setUint16(11, 2) + view.setUint32(13, SECURE_FRAGMENT_CHUNK_BYTES + 100) + + expect(() => codec.decode(fragment)).toThrow('Secure fragment metadata is invalid.') + }, + }, + { + name: 'rejects fragment with total < 2', + run: () => { + const codec = new SecureMessageCodec() + + const fragment = new Uint8Array(17 + 100) + fragment.set([0x44, 0x53, 0x48, 0x46]) + fragment[4] = 1 + const view = new DataView(fragment.buffer) + view.setUint32(5, 1) + view.setUint16(9, 0) + view.setUint16(11, 1) + view.setUint32(13, SECURE_FRAGMENT_CHUNK_BYTES + 100) + + expect(() => codec.decode(fragment)).toThrow('Secure fragment metadata is invalid.') + }, + }, + { + name: 'rejects fragment with index >= total', + run: () => { + const codec = new SecureMessageCodec() + + const fragment = new Uint8Array(17 + 100) + fragment.set([0x44, 0x53, 0x48, 0x46]) + fragment[4] = 1 + const view = new DataView(fragment.buffer) + view.setUint32(5, 1) + view.setUint16(9, 2) + view.setUint16(11, 2) + view.setUint32(13, SECURE_FRAGMENT_CHUNK_BYTES + 100) + + expect(() => codec.decode(fragment)).toThrow('Secure fragment metadata is invalid.') + }, + }, + { + name: 'rejects fragment with totalBytes <= SECURE_FRAGMENT_CHUNK_BYTES', + run: () => { + const codec = new SecureMessageCodec() + + const fragment = new Uint8Array(17 + 100) + fragment.set([0x44, 0x53, 0x48, 0x46]) + fragment[4] = 1 + const view = new DataView(fragment.buffer) + view.setUint32(5, 1) + view.setUint16(9, 0) + view.setUint16(11, 2) + view.setUint32(13, SECURE_FRAGMENT_CHUNK_BYTES) + + expect(() => codec.decode(fragment)).toThrow('Secure fragment metadata is invalid.') + }, + }, + { + name: 'rejects fragment with totalBytes > MAX_SECURE_MESSAGE_BYTES', + run: () => { + const codec = new SecureMessageCodec() + + const totalBytes = MAX_SECURE_MESSAGE_BYTES + 1 + const total = Math.ceil(totalBytes / SECURE_FRAGMENT_CHUNK_BYTES) + + const fragment = new Uint8Array(17 + SECURE_FRAGMENT_CHUNK_BYTES) + fragment.set([0x44, 0x53, 0x48, 0x46]) + fragment[4] = 1 + const view = new DataView(fragment.buffer) + view.setUint32(5, 1) + view.setUint16(9, 0) + view.setUint16(11, total) + view.setUint32(13, totalBytes) + + expect(() => codec.decode(fragment)).toThrow('Secure fragment metadata is invalid.') + }, + }, + ]) + }, 30000) + + // KNOWN BUG: Same magic-prefix collision issue as above + it.fails('treats message smaller than header size as non-fragment', () => { + const codec = new SecureMessageCodec() + + const tiny = new Uint8Array([0x44, 0x53, 0x48, 0x46]) + // Messages smaller than SECURE_FRAGMENT_HEADER_BYTES (17) should not be fragments + // even if they start with DSHF magic + expect(codec.decode(tiny)).toEqual(tiny) + }) + +}) + +describe('SecureMessageCodec round-trip integrity', () => { + // KNOWN BUG: isSecureFragment() uses magic prefix detection, causing + // unfragmented messages starting with DSHF (0x44534846) to be incorrectly + // treated as fragments. This affects any message 4+ bytes starting with + // those magic bytes. + it.fails('round-trips an unfragmented message starting with fragment magic (8 bytes)', () => { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message = new Uint8Array([ + 0x44, 0x53, 0x48, 0x46, // DSHF magic + 1, 2, 3, 4, + ]) + + const frames = encoder.encode(message) + + expect(frames).toHaveLength(1) + expect(decoder.decode(frames[0]!)).toEqual(message) + }) + + it.fails('round-trips an unfragmented message starting with fragment magic (17 bytes)', () => { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message = new Uint8Array(17) + message.set([0x44, 0x53, 0x48, 0x46, 1]) + + const frames = encoder.encode(message) + + expect(frames).toHaveLength(1) + expect(decoder.decode(frames[0]!)).toEqual(message) + }) + + it('round-trips various message sizes', () => { + const sizes = [ + 1, + 100, + SECURE_FRAGMENT_CHUNK_BYTES - 1, + SECURE_FRAGMENT_CHUNK_BYTES, + SECURE_FRAGMENT_CHUNK_BYTES + 1, + SECURE_FRAGMENT_CHUNK_BYTES * 2, + SECURE_FRAGMENT_CHUNK_BYTES * 2 + 37, + ] + + for (const size of sizes) { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message = new Uint8Array(size) + for (let i = 0; i < size; i++) { + message[i] = i % 251 + } + + const frames = encoder.encode(message) + + expect(frames).toHaveLength(Math.ceil(size / SECURE_FRAGMENT_CHUNK_BYTES)) + + let result: Uint8Array | undefined + for (const frame of frames) { + result = decoder.decode(frame) + } + + expect(result).toBeDefined() + expect(result!.byteLength).toBe(size) + expect(result).toEqual(message) + } + }) + + it('resets state correctly', () => { + const encoder = new SecureMessageCodec() + const decoder = new SecureMessageCodec() + + const message1 = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 2) + const frames1 = encoder.encode(message1) + + for (const frame of frames1) { + decoder.decode(frame) + } + + decoder.reset() + + const message2 = new Uint8Array(SECURE_FRAGMENT_CHUNK_BYTES * 2 + 50) + const frames2 = encoder.encode(message2) + + let result: Uint8Array | undefined + for (const frame of frames2) { + result = decoder.decode(frame) + } + + expect(result).toBeDefined() + expect(result!.byteLength).toBe(message2.byteLength) + }) +})