12345678910import { beforeEach, describe, expect, it } from "vitest";11import { deflate } from "pako";1213import {14 CodexError,15 CHUNK_SIZE,16 PARITY_SHARDS,17 type ChunkEnvelope,18 type CodexPayload,19} from "../../shared/codex-types";20import {21 base64UrlToBytes,22 bytesToBase64Url,23 buildChunkEnvelope,24 sha256Hex,25 verifyChunkIntegrity,26} from "./helpers";27import { encodeWithErasure, decodeWithErasure } from "./erasure";28import { _resetReedSolomonCacheForTest } from "./rs-loader";29import { ChunkBuffer, parseRawScan, reconstructAndVerify } from "./restore";3031beforeEach(() => {32 _resetReedSolomonCacheForTest();33});3435const VERIFY_CODE = "PX-TEST-1234";3637async function makeEnv(opts: {38 index: number;39 total: number;40 isParity?: boolean;41 verifyCode?: string;42 bytes?: Uint8Array;43}): Promise<ChunkEnvelope> {44 return buildChunkEnvelope(45 opts.bytes ?? new Uint8Array([1, 2, 3, 4, 5]),46 opts.index,47 opts.total,48 opts.isParity ?? false,49 opts.verifyCode ?? VERIFY_CODE50 );51}5253async function makePayload(seedLength = 12_000): Promise<CodexPayload> {54 const blobBytes = new Uint8Array(seedLength);55 let s = 0x9e3779b9;56 for (let i = 0; i < seedLength; i++) {57 s = (s ^ (s << 13)) >>> 0;58 s = (s ^ (s >>> 17)) >>> 0;59 s = (s ^ (s << 5)) >>> 0;60 blobBytes[i] = s & 0xff;61 }62 const vaultBlob = bytesToBase64Url(blobBytes);63 const vaultFingerprint = (64 await sha256Hex(new TextEncoder().encode(vaultBlob))65 )66 .slice(0, 16)67 .toUpperCase();68 return {69 version: 2,70 verifyCode: VERIFY_CODE,71 vaultBlob,72 timestamp: 1_700_000_000_000,73 entryCount: 42,74 vaultFingerprint,75 generatedAt: 1_700_000_001_000,76 };77}7879async function buildEnvelopesForPayload(80 payload: CodexPayload81): Promise<ChunkEnvelope[]> {82 const json = JSON.stringify(payload);83 const compressed = deflate(new TextEncoder().encode(json), { level: 9 });84 const { dataChunks, parityChunks, totalChunks } =85 await encodeWithErasure(compressed);86 const all = [...dataChunks, ...parityChunks];87 return Promise.all(88 all.map((bytes, i) =>89 buildChunkEnvelope(90 bytes,91 i,92 totalChunks,93 i >= dataChunks.length,94 payload.verifyCode95 )96 )97 );98}99100101102describe("parseRawScan adversarial", () => {103 const garbageInputs = [104 "",105 " ",106 "\n",107 "not json at all",108 "{not_valid_json",109 "null",110 "true",111 "42",112 '"a string"',113 "[]",114 "[1,2,3]",115 ];116 for (const raw of garbageInputs) {117 it(`returns parse_error for ${JSON.stringify(raw)}`, () => {118 const result = parseRawScan(raw);119 expect(result).toHaveProperty("error");120 });121 }122123 const wrongVersionInputs = [124 JSON.stringify({ v: 1, c: VERIFY_CODE, i: 0, t: 5 }),125 JSON.stringify({ v: 3, c: VERIFY_CODE, i: 0, t: 5 }),126 JSON.stringify({ v: 0, c: VERIFY_CODE, i: 0, t: 5 }),127 JSON.stringify({ v: "2", c: VERIFY_CODE, i: 0, t: 5 }),128 JSON.stringify({ v: -1 }),129 JSON.stringify({ v: 99 }),130 ];131 for (const raw of wrongVersionInputs) {132 it(`reports wrong_version for ${JSON.stringify(raw).slice(0, 40)}`, () => {133 const result = parseRawScan(raw);134 expect(result).toMatchObject({ error: "wrong_version" });135 });136 }137138 const missingFieldInputs = [139 JSON.stringify({ v: 2 }),140 JSON.stringify({ v: 2, c: VERIFY_CODE }),141 JSON.stringify({ v: 2, c: VERIFY_CODE, i: 0 }),142 JSON.stringify({ v: 2, c: VERIFY_CODE, i: 0, t: 5 }),143 JSON.stringify({ v: 2, c: VERIFY_CODE, i: 0, t: 5, p: false }),144 JSON.stringify({ v: 2, c: VERIFY_CODE, i: 0, t: 5, p: false, d: "x" }),145 ];146 for (const raw of missingFieldInputs) {147 it(`parse_error for missing fields: ${raw.slice(0, 60)}`, () => {148 const result = parseRawScan(raw);149 expect(result).toMatchObject({ error: "parse_error" });150 });151 }152153 it("returns envelope for a valid envelope JSON", async () => {154 const env = await makeEnv({ index: 0, total: 5 });155 const result = parseRawScan(JSON.stringify(env));156 expect(result).toMatchObject({ v: 2, c: VERIFY_CODE, i: 0, t: 5 });157 });158159 it("extra unknown fields do not break parseRawScan", async () => {160 const env = await makeEnv({ index: 0, total: 5 });161 const raw = JSON.stringify({ ...env, extra: "field", more: 42 });162 const result = parseRawScan(raw);163 expect(result).toMatchObject({ v: 2, c: VERIFY_CODE });164 });165});166167168169describe("ChunkBuffer adversarial", () => {170 it("foreign verifyCode is rejected as foreign_codex", async () => {171 const buf = new ChunkBuffer();172 await buf.add(await makeEnv({ index: 0, total: 5 }));173 const res = await buf.add(174 await makeEnv({ index: 1, total: 5, verifyCode: "PX-OTHR-XXXX" })175 );176 expect(res).toEqual({ accepted: false, reason: "foreign_codex" });177 });178179 it("tampered hash is rejected as bad_integrity", async () => {180 const buf = new ChunkBuffer();181 const env = await makeEnv({ index: 0, total: 5 });182 const tampered = { ...env, h: "00000000" };183 const res = await buf.add(tampered);184 expect(res).toEqual({ accepted: false, reason: "bad_integrity" });185 });186187 it("data tampered without rehashing is rejected", async () => {188 const buf = new ChunkBuffer();189 const env = await makeEnv({ index: 0, total: 5 });190 const tampered: ChunkEnvelope = {191 ...env,192 d: bytesToBase64Url(new Uint8Array([99, 99, 99])),193 };194 const res = await buf.add(tampered);195 expect(res).toEqual({ accepted: false, reason: "bad_integrity" });196 });197198 it("wrong envelope version is rejected as parse_error", async () => {199 const buf = new ChunkBuffer();200 const env = await makeEnv({ index: 0, total: 5 });201 const wrong = { ...env, v: 1 } as unknown as ChunkEnvelope;202 const res = await buf.add(wrong);203 expect(res).toEqual({ accepted: false, reason: "parse_error" });204 });205206 it("duplicate chunk index is dedup'd", async () => {207 const buf = new ChunkBuffer();208 const env = await makeEnv({ index: 2, total: 5 });209 expect((await buf.add(env)).accepted).toBe(true);210 const second = await buf.add(env);211 expect(second).toEqual({ accepted: false, reason: "duplicate" });212 expect(buf.size()).toBe(1);213 });214215 for (const idx of [0, 1, 2, 3, 4]) {216 it(`accepts chunk at index ${idx}`, async () => {217 const buf = new ChunkBuffer();218 const env = await makeEnv({ index: idx, total: 5 });219 const res = await buf.add(env);220 expect(res.accepted).toBe(true);221 });222 }223224 for (const total of [3, 5, 7, 10, 20]) {225 it(`context dataShards = total - PARITY_SHARDS at total=${total}`, async () => {226 const buf = new ChunkBuffer();227 await buf.add(await makeEnv({ index: 0, total }));228 const ctx = buf.getContext();229 expect(ctx?.dataShards).toBe(total - PARITY_SHARDS);230 });231 }232233 it("reconstructAndVerify on empty buffer throws CodexError", async () => {234 const buf = new ChunkBuffer();235 await expect(reconstructAndVerify(buf)).rejects.toThrow(CodexError);236 });237});238239240241describe("verifyChunkIntegrity adversarial", () => {242 it("correct envelope verifies true", async () => {243 const env = await makeEnv({ index: 0, total: 5 });244 expect(await verifyChunkIntegrity(env)).toBe(true);245 });246247 const corruptHashes = [248 "00000000",249 "FFFFFFFF",250 "ZZZZZZZZ",251 "abcdef12",252 "",253 ];254 for (const h of corruptHashes) {255 it(`tampered hash ${JSON.stringify(h)} verifies false`, async () => {256 const env = await makeEnv({ index: 0, total: 5 });257 const tampered = { ...env, h };258 expect(await verifyChunkIntegrity(tampered)).toBe(false);259 });260 }261262 for (let i = 0; i < 5; i++) {263 it(`random data tamper #${i} verifies false`, async () => {264 const env = await makeEnv({ index: 0, total: 5 });265 const bytes = new Uint8Array([266 Math.floor(Math.random() * 256),267 Math.floor(Math.random() * 256),268 Math.floor(Math.random() * 256),269 ]);270 const tampered = { ...env, d: bytesToBase64Url(bytes) };271 272 const recomputed = (await sha256Hex(bytes)).slice(0, 8);273 if (recomputed === env.h) return; 274 expect(await verifyChunkIntegrity(tampered)).toBe(false);275 });276 }277});278279280281describe("encodeWithErasure / decodeWithErasure adversarial", () => {282 it("encoding empty input still produces at least 1 data shard", async () => {283 const { dataChunks, parityChunks, totalChunks, dataShards } =284 await encodeWithErasure(new Uint8Array());285 expect(dataShards).toBeGreaterThanOrEqual(1);286 expect(totalChunks).toBe(dataShards + PARITY_SHARDS);287 expect(dataChunks.length).toBe(dataShards);288 expect(parityChunks.length).toBe(PARITY_SHARDS);289 });290291 for (const size of [1, 100, 1023, 1024, 1025, 5000, 10000]) {292 it(`encode/decode round-trips data of size ${size}`, async () => {293 const data = crypto.getRandomValues(new Uint8Array(size));294 const { dataChunks, parityChunks, dataShards, totalChunks } =295 await encodeWithErasure(data);296 const map = new Map<number, Uint8Array>();297 [...dataChunks, ...parityChunks].forEach((c, i) => map.set(i, c));298 const decoded = await decodeWithErasure(map, dataShards, totalChunks);299 expect(decoded.length).toBe(dataShards * CHUNK_SIZE);300 301 for (let i = 0; i < size; i++) {302 expect(decoded[i]).toBe(data[i]);303 }304 });305 }306307 it("decoding with empty chunk map throws CodexError", async () => {308 await expect(309 decodeWithErasure(new Map(), 5, 7)310 ).rejects.toThrow(CodexError);311 });312313 it("decoding with fewer chunks than dataShards throws CodexError", async () => {314 const data = crypto.getRandomValues(new Uint8Array(5000));315 const { dataChunks, dataShards, totalChunks } = await encodeWithErasure(316 data317 );318 319 const map = new Map<number, Uint8Array>();320 map.set(0, dataChunks[0]!);321 await expect(322 decodeWithErasure(map, dataShards, totalChunks)323 ).rejects.toThrow(CodexError);324 });325326 it("chunk index out of range throws CodexError", async () => {327 const data = crypto.getRandomValues(new Uint8Array(2048));328 const { dataChunks, dataShards, totalChunks } = await encodeWithErasure(329 data330 );331 const map = new Map<number, Uint8Array>();332 map.set(999, dataChunks[0]!);333 await expect(334 decodeWithErasure(map, dataShards, totalChunks)335 ).rejects.toThrow(CodexError);336 });337338 it("chunk with wrong size throws CodexError", async () => {339 const data = crypto.getRandomValues(new Uint8Array(2048));340 const { dataChunks, dataShards, totalChunks } = await encodeWithErasure(341 data342 );343 const map = new Map<number, Uint8Array>();344 345 map.set(0, new Uint8Array(100));346 for (let i = 1; i < dataShards; i++) map.set(i, dataChunks[i]!);347 await expect(348 decodeWithErasure(map, dataShards, totalChunks)349 ).rejects.toThrow(CodexError);350 });351352 it("dropping 1 data chunk (within parity budget) reconstructs", async () => {353 const data = crypto.getRandomValues(new Uint8Array(8000));354 const { dataChunks, parityChunks, dataShards, totalChunks } =355 await encodeWithErasure(data);356 const map = new Map<number, Uint8Array>();357 358 for (let i = 1; i < dataShards; i++) map.set(i, dataChunks[i]!);359 parityChunks.forEach((c, j) => map.set(dataShards + j, c));360 const decoded = await decodeWithErasure(map, dataShards, totalChunks);361 expect(decoded.length).toBe(dataShards * CHUNK_SIZE);362 for (let i = 0; i < data.length; i++) {363 expect(decoded[i]).toBe(data[i]);364 }365 });366367 it("dropping all data chunks (only parity present) fails when k < dataShards", async () => {368 const data = crypto.getRandomValues(new Uint8Array(8000));369 const { parityChunks, dataShards, totalChunks } = await encodeWithErasure(370 data371 );372 373 if (parityChunks.length >= dataShards) return;374 const map = new Map<number, Uint8Array>();375 parityChunks.forEach((c, j) => map.set(dataShards + j, c));376 await expect(377 decodeWithErasure(map, dataShards, totalChunks)378 ).rejects.toThrow(CodexError);379 });380381 it("dropping too many data chunks (more than parity) fails cleanly", async () => {382 const data = crypto.getRandomValues(new Uint8Array(20000));383 const { dataChunks, parityChunks, dataShards, totalChunks } =384 await encodeWithErasure(data);385 if (dataShards <= PARITY_SHARDS + 1) return; 386 const map = new Map<number, Uint8Array>();387 388 for (let i = PARITY_SHARDS + 1; i < dataShards; i++) {389 map.set(i, dataChunks[i]!);390 }391 parityChunks.forEach((c, j) => map.set(dataShards + j, c));392 await expect(393 decodeWithErasure(map, dataShards, totalChunks)394 ).rejects.toThrow(CodexError);395 });396});397398399400describe("reconstructAndVerify adversarial", () => {401 it("round-trips a payload via ChunkBuffer + reconstructAndVerify", async () => {402 const payload = await makePayload(2000);403 const envs = await buildEnvelopesForPayload(payload);404 const buf = new ChunkBuffer();405 for (const e of envs) await buf.add(e);406 const reconstructed = await reconstructAndVerify(buf);407 expect(reconstructed.vaultFingerprint).toBe(payload.vaultFingerprint);408 expect(reconstructed.entryCount).toBe(payload.entryCount);409 });410411 it("missing chunks but enough parity still reconstructs", async () => {412 const payload = await makePayload(5000);413 const envs = await buildEnvelopesForPayload(payload);414 if (envs.length <= PARITY_SHARDS + 1) return;415 const buf = new ChunkBuffer();416 417 for (let i = 1; i < envs.length; i++) await buf.add(envs[i]!);418 const reconstructed = await reconstructAndVerify(buf);419 expect(reconstructed.vaultFingerprint).toBe(payload.vaultFingerprint);420 });421422 it("tampered chunk data (after acceptance) does not round-trip", async () => {423 const payload = await makePayload(3000);424 const envs = await buildEnvelopesForPayload(payload);425 const buf = new ChunkBuffer();426 427 428 const evil = envs[0]!;429 const fakeBytes = crypto.getRandomValues(new Uint8Array(CHUNK_SIZE));430 const fakeHash = (await sha256Hex(fakeBytes)).slice(0, 8);431 const fakeEnv: ChunkEnvelope = {432 ...evil,433 d: bytesToBase64Url(fakeBytes),434 h: fakeHash,435 };436 await buf.add(fakeEnv);437 for (let i = 1; i < envs.length; i++) await buf.add(envs[i]!);438 439 await expect(reconstructAndVerify(buf)).rejects.toThrow(CodexError);440 });441});442443444445describe("parseRawScan with adversarial raw strings (no-crash)", () => {446 const inputs = [447 "{}",448 '{"a":1,"b":2}',449 '{"v":2}',450 '{"v":2,"c":""}',451 '{"v":2,"c":"' + "A".repeat(10000) + '"}',452 '{"v":2,"c":"PX-XXXX-XXXX","i":-1,"t":5,"p":false,"d":"","h":""}',453 '{"v":2,"c":"PX-XXXX-XXXX","i":99,"t":5,"p":false,"d":"","h":""}',454 '{"v":2,"c":"PX-XXXX-XXXX","i":0,"t":-5,"p":false,"d":"","h":""}',455 '{"v":2,"c":"PX-XXXX-XXXX","i":0,"t":5,"p":"yes","d":"","h":""}',456 '{"v":2,"c":"PX-XXXX-XXXX","i":0,"t":5,"p":false,"d":null,"h":null}',457 ];458 for (const raw of inputs) {459 it(`parseRawScan does not crash on ${raw.slice(0, 50)}`, () => {460 const result = parseRawScan(raw);461 expect(result).toBeDefined();462 });463 }464});465466467468describe("ChunkBuffer verify code adversarial", () => {469 const foreignCodes = [470 "PX-OTHR-1234",471 "PX-AAAA-AAAA",472 "PX-1111-1111",473 "PX-9999-9999",474 "PX-ABCD-EFGH",475 ];476 for (const code of foreignCodes) {477 it(`buffer rejects foreign code ${code}`, async () => {478 const buf = new ChunkBuffer();479 await buf.add(await makeEnv({ index: 0, total: 5 }));480 const foreign = await makeEnv({ index: 1, total: 5, verifyCode: code });481 const res = await buf.add(foreign);482 expect(res.accepted).toBe(false);483 expect(res.reason).toBe("foreign_codex");484 });485 }486});487488489490describe("erasure round-trip size sweep", () => {491 for (const size of [492 0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1023, 1024, 1025, 1500, 2048,493 3000, 4096, 5000, 7500, 10000,494 ]) {495 it(`size ${size} round-trips correctly`, async () => {496 const data = crypto.getRandomValues(new Uint8Array(size));497 const { dataChunks, parityChunks, dataShards, totalChunks } =498 await encodeWithErasure(data);499 const map = new Map<number, Uint8Array>();500 [...dataChunks, ...parityChunks].forEach((c, i) => map.set(i, c));501 const decoded = await decodeWithErasure(map, dataShards, totalChunks);502 for (let i = 0; i < size; i++) {503 expect(decoded[i]).toBe(data[i]);504 }505 });506507 it(`size ${size} drop-first-parity still decodes`, async () => {508 const data = crypto.getRandomValues(new Uint8Array(size));509 const { dataChunks, dataShards, totalChunks } = await encodeWithErasure(510 data511 );512 const map = new Map<number, Uint8Array>();513 dataChunks.forEach((c, i) => map.set(i, c));514 515 const decoded = await decodeWithErasure(map, dataShards, totalChunks);516 for (let i = 0; i < size; i++) {517 expect(decoded[i]).toBe(data[i]);518 }519 });520 }521});522523524525describe("ChunkBuffer scale", () => {526 for (const total of [3, 5, 10]) {527 it(`buffer accepts ${total - PARITY_SHARDS} data chunks and reports ready`, async () => {528 const buf = new ChunkBuffer();529 const dataShards = total - PARITY_SHARDS;530 for (let i = 0; i < dataShards; i++) {531 const res = await buf.add(await makeEnv({ index: i, total }));532 expect(res.accepted).toBe(true);533 }534 expect(buf.isReady()).toBe(true);535 });536 }537});