359 lines
12 KiB
TypeScript
359 lines
12 KiB
TypeScript
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)
|
|
})
|
|
})
|