543 lines
38 KiB
JavaScript
543 lines
38 KiB
JavaScript
'use strict';
|
|
|
|
const assert = require('node:assert/strict');
|
|
const crypto = require('node:crypto');
|
|
const fs = require('node:fs');
|
|
const os = require('node:os');
|
|
const path = require('node:path');
|
|
const test = require('node:test');
|
|
const database = require('../../src/database');
|
|
const {
|
|
createPs5NativePackageService,
|
|
inspectPs5ContainerFile,
|
|
} = require('../../src/services/ps5-native-package-service');
|
|
const {
|
|
PINNED_PS5_BUILDER,
|
|
createPs5NativePkgBuilderProvider,
|
|
runProcess,
|
|
} = require('../../src/services/ps5-native-pkg-builder-provider');
|
|
const { registerPs5NativePackageManifest } = require('../../src/services/ps5-native-package-registration-service');
|
|
|
|
function semanticCapabilities(overrides = {}) {
|
|
return { backupToDebugFpkg: true, dataDlcToDebugFpkg: true, updateToDebugFpkg: false, backupInspection: true, packageInspection: true, packageValidation: true, launchReadiness: true, licenseFreeBuild: true, finalizedFihOutput: true, ...overrides };
|
|
}
|
|
function semanticProbe(overrides = {}) { return { available: true, ...PINNED_PS5_BUILDER, capabilities: semanticCapabilities(), ...overrides }; }
|
|
function acceptedValidation() { return { accepted: true, validator: 'ProsperoPkgValidator', launchReady: true, unresolvedModules: [] }; }
|
|
|
|
function writeBackup(root, name = 'source', overrides = {}) {
|
|
const folder = path.join(root, name);
|
|
fs.mkdirSync(path.join(folder, 'sce_sys'), { recursive: true });
|
|
fs.writeFileSync(path.join(folder, 'eboot.bin'), Buffer.concat([Buffer.from([0x7f, 0x45, 0x4c, 0x46]), Buffer.alloc(128)]));
|
|
fs.writeFileSync(path.join(folder, 'sce_sys', 'param.json'), JSON.stringify({
|
|
titleId: 'PPSA12345',
|
|
contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001',
|
|
contentVersion: '01.00',
|
|
localizedParameters: { enUS: { titleName: 'Chimera PS5 Test' }, defaultLanguage: 'en-US' },
|
|
applicationDrmType: 'standard',
|
|
...overrides,
|
|
}));
|
|
return folder;
|
|
}
|
|
|
|
function writeDlcBackup(root, name = 'dlc-source', overrides = {}) {
|
|
const folder = path.join(root, name);
|
|
fs.mkdirSync(path.join(folder, 'sce_sys'), { recursive: true });
|
|
fs.mkdirSync(path.join(folder, 'data'), { recursive: true });
|
|
fs.writeFileSync(path.join(folder, 'data', 'owned-content.bin'), 'owned dlc fixture');
|
|
fs.writeFileSync(path.join(folder, 'sce_sys', 'param.json'), JSON.stringify({
|
|
titleId: 'PPSA12345',
|
|
contentId: 'UP0001-PPSA12345_00-CHIMERADLC000001',
|
|
contentVersion: '01.01',
|
|
localizedParameters: { enUS: { titleName: 'Chimera PS5 Test DLC' }, defaultLanguage: 'en-US' },
|
|
applicationDrmType: 'free',
|
|
...overrides,
|
|
}));
|
|
return folder;
|
|
}
|
|
|
|
function writeFih(filename, contentId = 'UP0001-PPSA12345_00-CHIMERATEST00001') {
|
|
const fih = Buffer.alloc(0x10000); const pfs = Buffer.alloc(0x10000); const cnt = Buffer.alloc(0x2900);
|
|
Buffer.from([0x7f, 0x46, 0x49, 0x48]).copy(fih); fih[4] = 1; fih.writeUInt16LE(3, 6); fih.writeUInt32LE(1, 8);
|
|
fih.writeBigUInt64LE(0x10000n, 0x10); fih.writeBigUInt64LE(0x10000n, 0x18); fih.writeBigUInt64LE(0x20000n, 0x58); fih.writeUInt32LE(1, 0xfc);
|
|
const gameDigest = crypto.createHash('sha3-256').update(pfs).digest(); for (const offset of [0x30, 0x70, 0xd0]) gameDigest.copy(fih, offset);
|
|
Buffer.from([0x7f, 0x43, 0x4e, 0x54]).copy(cnt); cnt.writeUInt32BE(1, 0x10); cnt.writeUInt16BE(1, 0x14); cnt.writeUInt16BE(1, 0x16); cnt.writeUInt32BE(0x2000, 0x18); cnt.writeBigUInt64BE(0x2000n, 0x20); cnt.writeBigUInt64BE(0x900n, 0x28);
|
|
Buffer.from(contentId, 'ascii').copy(cnt, 0x40, 0, 0x30); cnt.writeUInt32BE(0x20, 0x2000); cnt.writeUInt32BE(0x2100, 0x2010); cnt.writeUInt32BE(0x800, 0x2014);
|
|
for (const [record, offset] of [0x000, 0x180, 0x300, 0x480, 0x600].entries()) crypto.createHash('sha256').update(`${contentId}:${record}`).digest().copy(cnt, 0x2100 + offset);
|
|
crypto.createHash('sha3-256').update(cnt.subarray(0, 0xfe0)).digest().copy(cnt, 0xfe0);
|
|
fs.writeFileSync(filename, Buffer.concat([fih, pfs, cnt]));
|
|
}
|
|
|
|
function fixture(t, overrides = {}) {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-pkg-'));
|
|
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const libraryRoot = path.join(root, 'library');
|
|
const outputRoot = path.join(root, 'vault');
|
|
fs.mkdirSync(libraryRoot, { recursive: true });
|
|
const registrations = [];
|
|
const builds = [];
|
|
const provider = overrides.provider || {
|
|
probe: async () => semanticProbe(),
|
|
build: async input => { builds.push(input); fs.mkdirSync(path.dirname(input.outputPath), { recursive: true }); writeFih(input.outputPath, input.contentId); return { provider: PINNED_PS5_BUILDER }; },
|
|
validatePackage: async () => acceptedValidation(),
|
|
};
|
|
const service = createPs5NativePackageService({
|
|
allowedRoots: () => [libraryRoot, outputRoot], outputRoot,
|
|
stateFile: path.join(root, 'state', 'jobs.json'), provider,
|
|
registrar: async manifest => { registrations.push(manifest); return { packageSetId: 91 }; },
|
|
idFactory: overrides.idFactory || (() => 'ps5-job-1'), now: overrides.now || (() => 1_800_000_000_000),
|
|
});
|
|
return { root, libraryRoot, outputRoot, registrations, builds, service };
|
|
}
|
|
|
|
test('validates a decrypted PS5 backup from param.json and executable evidence', async t => {
|
|
const f = fixture(t);
|
|
const source = writeBackup(f.libraryRoot);
|
|
const result = await f.service.inspectBackup({ sourcePath: source, expectedTitleId: 'PPSA12345' });
|
|
assert.equal(result.ready, true);
|
|
assert.equal(result.titleId, 'PPSA12345');
|
|
assert.equal(result.executable.format, 'raw-elf');
|
|
assert.equal(result.contentId, 'UP0001-PPSA12345_00-CHIMERATEST00001');
|
|
});
|
|
|
|
test('blocks opaque executables and identity mismatch while rejecting unsafe paths', async t => {
|
|
const f = fixture(t);
|
|
const opaque = writeBackup(f.libraryRoot, 'opaque');
|
|
fs.writeFileSync(path.join(opaque, 'eboot.bin'), 'not decrypted');
|
|
const opaqueResult = await f.service.inspectBackup({ sourcePath: opaque });
|
|
assert.equal(opaqueResult.state, 'blocked');
|
|
assert.ok(opaqueResult.issues.some(item => item.code === 'PS5_FPKG_MODULE_UNRESOLVED'));
|
|
const wrong = writeBackup(f.libraryRoot, 'wrong');
|
|
const mismatch = await f.service.inspectBackup({ sourcePath: wrong, expectedTitleId: 'PPSA99999' });
|
|
assert.equal(mismatch.state, 'blocked'); assert.ok(mismatch.issues.some(item => item.code === 'PS5_FPKG_TITLE_MISMATCH'));
|
|
const linked = writeBackup(f.libraryRoot, 'linked');
|
|
const outside = path.join(f.root, 'outside'); fs.mkdirSync(outside); fs.writeFileSync(path.join(outside, 'x'), 'x');
|
|
fs.symlinkSync(outside, path.join(linked, 'escape'), process.platform === 'win32' ? 'junction' : 'dir');
|
|
await assert.rejects(() => f.service.inspectBackup({ sourcePath: linked }), error => error.code === 'PS5_FPKG_SOURCE_UNSAFE');
|
|
await assert.rejects(() => f.service.inspectBackup({ sourcePath: outside }), error => error.code === 'PS5_BACKUP_CONTAINMENT');
|
|
});
|
|
|
|
test('accepts signed modules only when a matching decrypted raw-ELF substitute exists', async t => {
|
|
const f = fixture(t); const source = writeBackup(f.libraryRoot, 'signed-with-decrypted');
|
|
fs.writeFileSync(path.join(source, 'eboot.bin'), Buffer.concat([Buffer.from([0x54, 0x14, 0xf5, 0xee]), Buffer.alloc(128)]));
|
|
fs.mkdirSync(path.join(source, 'decrypted'), { recursive: true });
|
|
fs.writeFileSync(path.join(source, 'decrypted', 'eboot.bin'), Buffer.concat([Buffer.from([0x7f, 0x45, 0x4c, 0x46]), Buffer.alloc(128)]));
|
|
const result = await f.service.inspectBackup({ sourcePath: source });
|
|
assert.equal(result.executable.format, 'self-with-decrypted-substitutes');
|
|
assert.equal(result.executable.substitutedModuleCount, 1);
|
|
});
|
|
|
|
test('accepts data DLC without eboot but refuses update and entitlement-only package routes', async t => {
|
|
const f = fixture(t); const dlc = writeDlcBackup(f.libraryRoot);
|
|
const inspected = await f.service.inspectBackup({ sourcePath: dlc, expectedTitleId: 'PPSA12345', componentType: 'dlc' });
|
|
assert.equal(inspected.componentType, 'dlc');
|
|
assert.equal(inspected.executable.moduleCount, 0);
|
|
const update = await f.service.inspectBackup({ sourcePath: dlc, componentType: 'update' });
|
|
assert.equal(update.state, 'unsupported'); assert.equal(update.ready, false);
|
|
await assert.rejects(() => f.service.inspectBackup({ sourcePath: dlc, componentType: 'dlc-entitlement' }), error => error.code === 'PS5_FPKG_SOURCE_NOT_READY');
|
|
});
|
|
|
|
test('distinguishes genuine PS5 FIH/CNT containers from FFPKG mount images and renamed files', t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-format-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const fih = path.join(root, 'game.pkg'); writeFih(fih);
|
|
const cnt = path.join(root, 'metadata.pkg'); fs.writeFileSync(cnt, Buffer.concat([Buffer.from([0x7f, 0x43, 0x4e, 0x54]), Buffer.alloc(64)]));
|
|
const image = path.join(root, 'game.ffpkg'); fs.writeFileSync(image, Buffer.alloc(128));
|
|
const renamed = path.join(root, 'renamed.pkg'); fs.writeFileSync(renamed, Buffer.alloc(128));
|
|
const inspectedFih = inspectPs5ContainerFile(fih);
|
|
assert.deepEqual(inspectedFih.format, 'ps5-fih-debug-package');
|
|
assert.equal(inspectedFih.validation.installTrust.status, 'unproven');
|
|
assert.equal(inspectedFih.validation.installTrust.basis, 'structural-only');
|
|
assert.ok(inspectedFih.validation.warnings.some(item => item.code === 'APPINST_TRUST_UNPROVEN'));
|
|
assert.deepEqual(inspectPs5ContainerFile(cnt).format, 'ps5-cnt-container');
|
|
assert.equal(inspectPs5ContainerFile(image).format, 'ufs-mount-image');
|
|
assert.equal(inspectPs5ContainerFile(image).nativeInstallable, false);
|
|
assert.equal(inspectPs5ContainerFile(renamed).format, 'unknown-pkg');
|
|
assert.equal(inspectPs5ContainerFile(renamed).nativeInstallable, false);
|
|
});
|
|
|
|
test('accepts the upstream stock FIH image-count and opaque image-key profile without claiming launch compatibility', t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-stock-profile-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const stock = path.join(root, 'stock.pkg'); writeFih(stock, 'IV9999-FAKE00000_00-HOMEBREWLOADER01');
|
|
const bytes = fs.readFileSync(stock);
|
|
bytes.writeUInt32LE(0, 0xfc);
|
|
for (let index = 0; index < 0x800; index++) bytes[0x22100 + index] = ((index * 73 + 19) % 255) + 1;
|
|
crypto.createHash('sha3-256').update(bytes.subarray(0x20000, 0x20fe0)).digest().copy(bytes, 0x20fe0);
|
|
fs.writeFileSync(stock, bytes);
|
|
|
|
const inspected = inspectPs5ContainerFile(stock);
|
|
assert.equal(inspected.structurallyValid, true);
|
|
assert.equal(inspected.validation.validationLevel, 'fih-cnt-structural-v3');
|
|
assert.equal(inspected.validation.imageCount, 0);
|
|
assert.equal(inspected.validation.imageKey.profile, 'opaque-filled-0x800');
|
|
assert.equal(inspected.validation.routeCompatibility.status, 'unproven');
|
|
assert.ok(inspected.validation.warnings.some(item => item.code === 'FIH_IMAGE_COUNT_STOCK_PROFILE'));
|
|
assert.ok(inspected.validation.warnings.some(item => item.code === 'CNT_IMAGE_KEY_OPAQUE_PROFILE'));
|
|
});
|
|
|
|
test('fails closed when FIH geometry, CNT sealing or image-key records are corrupted', t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-structural-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const geometry = path.join(root, 'geometry.pkg'); writeFih(geometry);
|
|
const geometryFd = fs.openSync(geometry, 'r+'); fs.writeSync(geometryFd, Buffer.from([0x01]), 0, 1, 0x58); fs.closeSync(geometryFd);
|
|
let inspected = inspectPs5ContainerFile(geometry);
|
|
assert.equal(inspected.nativeInstallable, false);
|
|
assert.ok(inspected.validation.errors.some(item => item.code === 'FIH_CNT_GEOMETRY'));
|
|
|
|
const seal = path.join(root, 'seal.pkg'); writeFih(seal);
|
|
const sealFd = fs.openSync(seal, 'r+'); fs.writeSync(sealFd, Buffer.from([0xff]), 0, 1, 0x20000 + 0x100); fs.closeSync(sealFd);
|
|
inspected = inspectPs5ContainerFile(seal);
|
|
assert.ok(inspected.validation.errors.some(item => item.code === 'CNT_HEADER_SEAL'));
|
|
|
|
const key = path.join(root, 'key.pkg'); writeFih(key);
|
|
const keyFd = fs.openSync(key, 'r+'); fs.writeSync(keyFd, Buffer.alloc(0x800), 0, 0x800, 0x22100); fs.closeSync(keyFd);
|
|
inspected = inspectPs5ContainerFile(key);
|
|
assert.ok(inspected.validation.errors.some(item => item.code === 'CNT_IMAGE_KEY_PROFILE'));
|
|
|
|
const sparseKey = path.join(root, 'sparse-key.pkg'); writeFih(sparseKey);
|
|
const sparseKeyBytes = fs.readFileSync(sparseKey); sparseKeyBytes.fill(0, 0x22100, 0x22900); sparseKeyBytes[0x22100] = 1;
|
|
crypto.createHash('sha3-256').update(sparseKeyBytes.subarray(0x20000, 0x20fe0)).digest().copy(sparseKeyBytes, 0x20fe0); fs.writeFileSync(sparseKey, sparseKeyBytes);
|
|
inspected = inspectPs5ContainerFile(sparseKey);
|
|
assert.ok(inspected.validation.errors.some(item => item.code === 'CNT_IMAGE_KEY_PROFILE'));
|
|
});
|
|
|
|
test('builds, validates and hashes a real FIH package before registration', async t => {
|
|
const f = fixture(t);
|
|
const source = writeBackup(f.libraryRoot);
|
|
const created = await f.service.create({ sourcePath: source, expectedTitleId: 'PPSA12345' });
|
|
assert.equal(created.status, 'package_ready');
|
|
const complete = await f.service.run(created.id);
|
|
assert.equal(complete.status, 'artifact_registered');
|
|
assert.equal(complete.container.format, 'ps5-fih-debug-package');
|
|
assert.match(complete.sha256, /^[a-f0-9]{64}$/);
|
|
assert.equal(f.registrations.length, 1);
|
|
assert.equal(f.registrations[0].components[0].adapterHint, 'ps5-fpkg-finalized-fih');
|
|
assert.equal(f.registrations[0].components[0].sha256, crypto.createHash('sha256').update(fs.readFileSync(complete.outputPath)).digest('hex'));
|
|
});
|
|
|
|
test('builds one ordered native package set from base plus data DLC components', async t => {
|
|
const f = fixture(t); const base = writeBackup(f.libraryRoot, 'base'); const dlc = writeDlcBackup(f.libraryRoot, 'dlc');
|
|
const created = await f.service.create({ expectedTitleId: 'PPSA12345', sources: [{ sourcePath: base, componentType: 'base' }, { sourcePath: dlc, componentType: 'dlc' }] });
|
|
const complete = await f.service.run(created.id);
|
|
assert.equal(complete.status, 'artifact_registered');
|
|
assert.deepEqual(f.builds.map(item => item.componentType), ['base', 'dlc']);
|
|
assert.deepEqual(f.registrations[0].components.map(item => item.type), ['base', 'dlc']);
|
|
assert.deepEqual(f.registrations[0].recipe.installOrder.map(item => item.order), [1, 3]);
|
|
assert.deepEqual(f.registrations[0].dependencies, [{ componentId: f.registrations[0].components[1].id, requires: 'base' }]);
|
|
assert.equal(f.registrations[0].components.every(item => item.container?.format === 'ps5-fih-debug-package'), true);
|
|
});
|
|
|
|
test('a component identity change between planning and build fails closed', async t => {
|
|
const f = fixture(t); const base = writeBackup(f.libraryRoot, 'base'); const dlc = writeDlcBackup(f.libraryRoot, 'dlc');
|
|
const created = await f.service.create({ sources: [{ sourcePath: base, componentType: 'base' }, { sourcePath: dlc, componentType: 'dlc' }] });
|
|
const paramPath = path.join(dlc, 'sce_sys', 'param.json'); const param = JSON.parse(fs.readFileSync(paramPath, 'utf8')); param.contentId = 'UP0001-PPSA12345_00-CHIMERADLC000002'; fs.writeFileSync(paramPath, JSON.stringify(param));
|
|
await assert.rejects(() => f.service.run(created.id), error => error.code === 'PS5_FPKG_SOURCE_CHANGED');
|
|
assert.equal(f.registrations.length, 0);
|
|
});
|
|
|
|
test('a same-size payload mutation between planning and build fails closed', async t => {
|
|
const f = fixture(t); const base = writeBackup(f.libraryRoot, 'base'); const dlc = writeDlcBackup(f.libraryRoot, 'dlc');
|
|
const created = await f.service.create({ sources: [{ sourcePath: base, componentType: 'base' }, { sourcePath: dlc, componentType: 'dlc' }] });
|
|
const payloadPath = path.join(dlc, 'data', 'owned-content.bin'); const original = fs.readFileSync(payloadPath);
|
|
fs.writeFileSync(payloadPath, Buffer.alloc(original.length, 0x78));
|
|
await assert.rejects(() => f.service.run(created.id), error => error.code === 'PS5_FPKG_SOURCE_CHANGED');
|
|
assert.equal(f.builds.length, 0);
|
|
assert.equal(f.registrations.length, 0);
|
|
});
|
|
|
|
test('exposes only hash-bound native FIH packages through a short-lived HTTPS handoff', async t => {
|
|
const f = fixture(t); const pkg = path.join(f.outputRoot, 'verified.pkg'); writeFih(pkg); const bytes = fs.readFileSync(pkg); const sha256 = crypto.createHash('sha256').update(bytes).digest('hex');
|
|
const exposed = await f.service.expose({ filePath: pkg, sha256, size: bytes.length, origin: 'https://chimera.example.test' });
|
|
assert.match(exposed.url, /^https:\/\/chimera\.example\.test\/ps5-native-package\/[A-Za-z0-9_-]{43}\/verified\.pkg$/);
|
|
assert.equal(f.service.resolvePackageHandoff(new URL(exposed.url).pathname).filePath, fs.realpathSync(pkg));
|
|
await assert.rejects(() => f.service.expose({ filePath: pkg, sha256: '0'.repeat(64), size: bytes.length, origin: 'https://chimera.example.test' }), error => error.code === 'PS5_PACKAGE_HANDOFF_HASH');
|
|
await assert.rejects(() => f.service.expose({ filePath: pkg, sha256, size: bytes.length, origin: 'http://chimera.example.test' }), error => error.code === 'PS5_PACKAGE_ORIGIN');
|
|
});
|
|
|
|
test('active jobs become interrupted and require an explicit resume', async t => {
|
|
const f = fixture(t);
|
|
const source = writeBackup(f.libraryRoot);
|
|
const created = await f.service.create({ sourcePath: source });
|
|
const stateFile = path.join(f.root, 'state', 'jobs.json');
|
|
const stored = JSON.parse(fs.readFileSync(stateFile, 'utf8')); stored.jobs[0].status = 'building'; fs.writeFileSync(stateFile, JSON.stringify(stored));
|
|
const restarted = createPs5NativePackageService({ allowedRoots: () => [f.libraryRoot, f.outputRoot], outputRoot: f.outputRoot, stateFile, provider: f.service.__provider || { probe: async () => ({ available: true }), build: async () => ({}) }, registrar: async () => ({ packageSetId: 91 }) });
|
|
assert.equal(restarted.get(created.id).status, 'interrupted');
|
|
assert.equal(restarted.resume(created.id).status, 'package_ready');
|
|
});
|
|
|
|
test('requires a real registrar and never marks an unregistered artifact completed', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-registrar-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const libraryRoot = path.join(root, 'library'); const outputRoot = path.join(root, 'vault'); fs.mkdirSync(libraryRoot);
|
|
const provider = { probe: async () => semanticProbe(), build: async input => writeFih(input.outputPath, input.contentId), validatePackage: async () => acceptedValidation() };
|
|
assert.throws(() => createPs5NativePackageService({ allowedRoots: () => [libraryRoot, outputRoot], outputRoot, stateFile: path.join(root, 'missing.json'), provider }), /registrar/i);
|
|
let registration = {}; let builds = 0;
|
|
provider.build = async input => { builds++; fs.mkdirSync(path.dirname(input.outputPath), { recursive: true }); writeFih(input.outputPath, input.contentId); };
|
|
const service = createPs5NativePackageService({ allowedRoots: () => [libraryRoot, outputRoot], outputRoot, stateFile: path.join(root, 'jobs.json'), provider, registrar: async () => registration, idFactory: () => 'registration-job' });
|
|
const source = writeBackup(libraryRoot);
|
|
const created = await service.create({ sourcePath: source });
|
|
await assert.rejects(() => service.run(created.id), error => error.code === 'PS5_PACKAGE_REGISTRATION_INCOMPLETE');
|
|
assert.equal(service.get(created.id).status, 'registration_pending');
|
|
registration = { packageSetId: 123 };
|
|
service.resume(created.id);
|
|
const completed = await service.run(created.id);
|
|
assert.equal(completed.status, 'artifact_registered');
|
|
assert.equal(completed.registration.packageSetId, 123);
|
|
assert.equal(builds, 1);
|
|
});
|
|
|
|
test('rejects stale concurrent writers instead of clobbering job state', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-cas-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const libraryRoot = path.join(root, 'library'); const outputRoot = path.join(root, 'vault'); const stateFile = path.join(root, 'jobs.json'); fs.mkdirSync(libraryRoot);
|
|
const provider = { probe: async () => ({ available: true }), build: async () => ({}) }; const options = { allowedRoots: () => [libraryRoot, outputRoot], outputRoot, stateFile, provider, registrar: async () => ({ packageSetId: 1 }) };
|
|
const first = createPs5NativePackageService({ ...options, idFactory: () => 'first' });
|
|
const second = createPs5NativePackageService({ ...options, idFactory: () => 'second' });
|
|
const source = writeBackup(libraryRoot);
|
|
await first.create({ sourcePath: source });
|
|
await assert.rejects(() => second.create({ sourcePath: source }), error => error.code === 'PS5_PACKAGE_STATE_CONFLICT');
|
|
assert.deepEqual(JSON.parse(fs.readFileSync(stateFile, 'utf8')).jobs.map(job => job.id), ['first']);
|
|
});
|
|
|
|
test('fails closed without overwriting corrupted durable job state', t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-corrupt-state-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const outputRoot = path.join(root, 'vault'); const stateFile = path.join(root, 'jobs.json'); const original = '{broken-json'; fs.writeFileSync(stateFile, original);
|
|
const provider = { probe: async () => ({ available: true }), build: async () => ({}) };
|
|
assert.throws(() => createPs5NativePackageService({ allowedRoots: () => [root], outputRoot, stateFile, provider, registrar: async () => ({ packageSetId: 1 }) }), error => error.code === 'PS5_PACKAGE_STATE_CORRUPT');
|
|
assert.equal(fs.readFileSync(stateFile, 'utf8'), original);
|
|
});
|
|
|
|
test('resume reuses a hash-verified component checkpoint instead of rebuilding it', async t => {
|
|
const calls = []; let failDlc = true;
|
|
const provider = {
|
|
probe: async () => semanticProbe(),
|
|
build: async input => { calls.push(input.componentType); if (input.componentType === 'dlc' && failDlc) throw new Error('simulated DLC failure'); fs.mkdirSync(path.dirname(input.outputPath), { recursive: true }); writeFih(input.outputPath, input.contentId); },
|
|
validatePackage: async () => acceptedValidation(),
|
|
};
|
|
const f = fixture(t, { provider }); const base = writeBackup(f.libraryRoot, 'base'); const dlc = writeDlcBackup(f.libraryRoot, 'dlc');
|
|
const created = await f.service.create({ sources: [{ sourcePath: base, componentType: 'base' }, { sourcePath: dlc, componentType: 'dlc' }] });
|
|
await assert.rejects(() => f.service.run(created.id), /simulated DLC failure/);
|
|
failDlc = false; f.service.resume(created.id);
|
|
const complete = await f.service.run(created.id);
|
|
assert.equal(complete.status, 'artifact_registered');
|
|
assert.deepEqual(calls, ['base', 'dlc', 'dlc']);
|
|
});
|
|
|
|
test('start acknowledges immediately and runs the durable build asynchronously', async t => {
|
|
let releaseBuild; const gate = new Promise(resolve => { releaseBuild = resolve; });
|
|
const provider = {
|
|
probe: async () => semanticProbe(),
|
|
build: async input => { await gate; fs.mkdirSync(path.dirname(input.outputPath), { recursive: true }); writeFih(input.outputPath, input.contentId); },
|
|
validatePackage: async () => acceptedValidation(),
|
|
};
|
|
const f = fixture(t, { provider }); const created = await f.service.create({ sourcePath: writeBackup(f.libraryRoot) });
|
|
const accepted = f.service.start(created.id);
|
|
assert.equal(accepted.accepted, true); assert.equal(accepted.status, 'package_ready');
|
|
assert.equal(f.service.start(created.id).alreadyRunning, true);
|
|
releaseBuild();
|
|
for (let attempt = 0; attempt < 100 && f.service.get(created.id).status !== 'artifact_registered'; attempt++) await new Promise(resolve => setTimeout(resolve, 10));
|
|
assert.equal(f.service.get(created.id).status, 'artifact_registered');
|
|
});
|
|
|
|
test('service enforces the builder-advertised source ceiling before build', async t => {
|
|
let builds = 0;
|
|
const provider = {
|
|
probe: async () => semanticProbe({ capabilities: semanticCapabilities({ maxSourceBytes: 1 }) }),
|
|
build: async () => { builds++; },
|
|
validatePackage: async () => acceptedValidation(),
|
|
};
|
|
const f = fixture(t, { provider });
|
|
const created = await f.service.create({ sourcePath: writeBackup(f.libraryRoot) });
|
|
await assert.rejects(() => f.service.run(created.id), error => error.code === 'PS5_BUILDER_SOURCE_LIMIT' && error.details.maxSourceBytes === 1);
|
|
assert.equal(builds, 0);
|
|
});
|
|
|
|
test('pinned bridge uses a fixed no-shell JSON request protocol and rejects hostile paths', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-builder-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const toolRoot = path.join(root, 'tool'); const workRoot = path.join(root, 'work'); const sourceRoot = path.join(root, 'source');
|
|
fs.mkdirSync(toolRoot); fs.mkdirSync(workRoot); fs.mkdirSync(sourceRoot);
|
|
const executable = path.join(toolRoot, PINNED_PS5_BUILDER.executable); fs.writeFileSync(executable, 'bridge');
|
|
const outputPath = path.join(workRoot, 'out.pkg'); const calls = [];
|
|
const runner = async input => {
|
|
calls.push(input);
|
|
if (input.args[0] === 'probe') return { output: JSON.stringify(semanticProbe()) };
|
|
writeFih(outputPath); fs.writeFileSync(input.args[4], JSON.stringify({ ok: true, outputPath })); return { output: 'ok' };
|
|
};
|
|
const provider = createPs5NativePkgBuilderProvider({ toolRoot, allowedWorkRoots: [workRoot], allowedSourceRoots: [sourceRoot], runner });
|
|
assert.equal((await provider.probe()).available, true);
|
|
await provider.build({ sourcePath: sourceRoot, sourceSize: 0, outputPath, workPath: path.join(workRoot, 'job'), titleId: 'PPSA12345', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001' });
|
|
assert.equal(calls.at(-1).command, fs.realpathSync(executable));
|
|
assert.equal(calls.at(-1).shell, false);
|
|
assert.equal(calls.at(-1).args[0], 'build-backup');
|
|
assert.equal(calls.at(-1).args[1], '--request');
|
|
assert.equal(calls.at(-1).args[3], '--result');
|
|
assert.equal(JSON.parse(fs.readFileSync(calls.at(-1).args[2], 'utf8')).componentType, 'base');
|
|
await assert.rejects(() => provider.build({ sourcePath: sourceRoot, sourceSize: 0, outputPath, workPath: path.join(workRoot, 'update'), titleId: 'PPSA12345', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001', componentType: 'update' }), error => error.code === 'PS5_BUILDER_COMPONENT');
|
|
await assert.rejects(() => provider.build({ sourcePath: fspOutside(root), sourceSize: 0, outputPath, workPath: path.join(workRoot, 'evil'), titleId: 'PPSA12345', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001' }), error => error.code === 'PS5_BUILDER_PATH');
|
|
});
|
|
|
|
test('pinned bridge rejects a runtime that does not prove license-free base conversion', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-builder-license-free-'));
|
|
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const toolRoot = path.join(root, 'tool');
|
|
fs.mkdirSync(toolRoot);
|
|
fs.writeFileSync(path.join(toolRoot, PINNED_PS5_BUILDER.executable), 'bridge');
|
|
const runner = async () => ({ output: JSON.stringify({
|
|
...PINNED_PS5_BUILDER,
|
|
capabilities: {
|
|
...semanticCapabilities({ licenseFreeBuild: false }),
|
|
},
|
|
}) });
|
|
const provider = createPs5NativePkgBuilderProvider({ toolRoot, runner });
|
|
const probe = await provider.probe();
|
|
assert.equal(probe.available, false);
|
|
assert.equal(probe.reason, 'capability-mismatch');
|
|
});
|
|
|
|
test('pinned bridge persists bounded diagnostics when the native process fails', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-builder-failure-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const toolRoot = path.join(root, 'tool'); const workRoot = path.join(root, 'work'); const sourceRoot = path.join(root, 'source');
|
|
fs.mkdirSync(toolRoot); fs.mkdirSync(workRoot); fs.mkdirSync(sourceRoot);
|
|
fs.writeFileSync(path.join(toolRoot, PINNED_PS5_BUILDER.executable), 'bridge');
|
|
const runner = async input => {
|
|
if (input.args[0] === 'probe') return { output: JSON.stringify(semanticProbe()) };
|
|
throw Object.assign(new Error('PS5 packagebridge stopte met code 1.'), { code: 'PS5_BUILDER_FAILED', details: { code: 1, output: 'System.InvalidOperationException: exact native failure' } });
|
|
};
|
|
const provider = createPs5NativePkgBuilderProvider({ toolRoot, allowedWorkRoots: [workRoot], allowedSourceRoots: [sourceRoot], runner });
|
|
const workPath = path.join(workRoot, 'job');
|
|
await assert.rejects(() => provider.build({ sourcePath: sourceRoot, sourceSize: 0, outputPath: path.join(workRoot, 'out.pkg'), workPath, titleId: 'PPSA12345', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001' }), error => {
|
|
assert.equal(error.code, 'PS5_BUILDER_FAILED');
|
|
assert.match(error.details.output, /exact native failure/);
|
|
assert.equal(error.details.exitCode, 1);
|
|
return true;
|
|
});
|
|
const diagnostic = JSON.parse(fs.readFileSync(path.join(workPath, 'build-failure.json'), 'utf8'));
|
|
assert.equal(diagnostic.code, 'PS5_BUILDER_FAILED');
|
|
assert.equal(diagnostic.exitCode, 1);
|
|
assert.match(diagnostic.output, /exact native failure/);
|
|
});
|
|
|
|
test('native bridge process logging is capped while retaining a bounded output tail', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-builder-log-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const logPath = path.join(root, 'build.log');
|
|
const result = await runProcess({ command: process.execPath, args: ['-e', `process.stdout.write('x'.repeat(${9 * 1024 * 1024}))`], cwd: root, logPath });
|
|
assert.equal(result.code, 0);
|
|
assert.equal(result.output.length, 64_000);
|
|
assert.ok(fs.statSync(logPath).size <= 8 * 1024 * 1024);
|
|
});
|
|
|
|
test('failed package jobs retain structured provider diagnostics', async t => {
|
|
const provider = {
|
|
probe: async () => semanticProbe(),
|
|
build: async () => { throw Object.assign(new Error('bridge failed'), { code: 'PS5_BUILDER_FAILED', details: { exitCode: 1, output: 'precise failure', diagnosticPath: '/safe/work/build-failure.json' } }); },
|
|
validatePackage: async () => acceptedValidation(),
|
|
};
|
|
const f = fixture(t, { provider }); const source = writeBackup(f.libraryRoot);
|
|
const created = await f.service.create({ sourcePath: source });
|
|
await assert.rejects(() => f.service.run(created.id), /bridge failed/);
|
|
const failed = f.service.get(created.id);
|
|
assert.equal(failed.status, 'failed');
|
|
assert.deepEqual(failed.errorDetails, { code: 'PS5_BUILDER_FAILED', exitCode: 1, output: 'precise failure', diagnosticPath: '/safe/work/build-failure.json' });
|
|
});
|
|
|
|
test('bridge binds data DLC explicitly and exposes no update or entitlement-only build mode', () => {
|
|
const source = fs.readFileSync(path.join(__dirname, '../../tools/chimera-prospero-bridge/Program.cs'), 'utf8');
|
|
assert.match(source, /chimera-prospero-bridge-v4/);
|
|
assert.match(source, /ProsperoBackupConverter/);
|
|
assert.match(source, /ProsperoPkgValidator\.Validate/);
|
|
assert.match(source, /build-backup/);
|
|
assert.match(source, /build-data-dlc/);
|
|
assert.match(source, /inspect-backup/);
|
|
assert.match(source, /inspect-package/);
|
|
assert.match(source, /validate-package/);
|
|
assert.match(source, /licenseFreeBuild = true/);
|
|
assert.match(source, /backupBuildApi = "ProsperoPackageBuilder"/);
|
|
assert.match(source, /LicenseFree = true, FakeSignSelfModules = false/);
|
|
assert.match(source, /ProsperoFself\.MakeFself/);
|
|
assert.doesNotMatch(source, /patchSet/);
|
|
assert.doesNotMatch(source, /wideNapsU2cBase|stockImageKeyRsa3072|chimera-license-free-base-v16/);
|
|
assert.match(source, /ProsperoPackageMode\.AdditionalContentData/);
|
|
assert.doesNotMatch(source, /ProsperoPackageMode\.AdditionalContentNoData/);
|
|
assert.doesNotMatch(source, /ProsperoPackageMode\.(Update|Patch)/);
|
|
});
|
|
|
|
test('builder v4 request contains semantic inputs without legacy implementation tuning', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-builder-tuning-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const toolRoot = path.join(root, 'tool'); const workRoot = path.join(root, 'work'); const sourceRoot = path.join(root, 'source');
|
|
fs.mkdirSync(toolRoot); fs.mkdirSync(workRoot); fs.mkdirSync(sourceRoot);
|
|
fs.writeFileSync(path.join(toolRoot, PINNED_PS5_BUILDER.executable), 'bridge');
|
|
const outputPath = path.join(workRoot, 'out.pkg'); const calls = [];
|
|
const runner = async input => {
|
|
calls.push(input);
|
|
if (input.args[0] === 'probe') return { output: JSON.stringify(semanticProbe()) };
|
|
writeFih(outputPath);
|
|
fs.writeFileSync(input.args[4], JSON.stringify({ ok: true, outputPath }));
|
|
return { output: 'ok' };
|
|
};
|
|
const provider = createPs5NativePkgBuilderProvider({
|
|
toolRoot,
|
|
allowedWorkRoots: [workRoot],
|
|
allowedSourceRoots: [sourceRoot],
|
|
runner,
|
|
});
|
|
await provider.build({ sourcePath: sourceRoot, sourceSize: 0, outputPath, workPath: path.join(workRoot, 'job'), titleId: 'PPSA12345', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001' });
|
|
const buildCall = calls.at(-1);
|
|
const request = JSON.parse(fs.readFileSync(buildCall.args[2], 'utf8'));
|
|
assert.equal(request.operation, 'build-backup');
|
|
assert.equal(request.abi, 'chimera-prospero-bridge-v4');
|
|
assert.equal(request.tuning, undefined);
|
|
assert.equal(buildCall.env.CHIMERA_PROSPERO_COMPRESSION_WORKERS, undefined);
|
|
assert.match(buildCall.env.CHIMERA_PROSPERO_ALLOWED_SOURCE_ROOTS, /source/);
|
|
});
|
|
|
|
test('Docker builds the exact upstream revision with only the pinned streaming patch', () => {
|
|
const root = path.resolve(__dirname, '../..');
|
|
const dockerfile = fs.readFileSync(path.join(root, 'Dockerfile'), 'utf8');
|
|
assert.match(dockerfile, /9084c0e88cd8d7cd9c0b353b8b6b89f7d1cc4275/);
|
|
assert.match(dockerfile, /git .* status --porcelain/);
|
|
assert.match(dockerfile, /CHIMERA_UPSTREAM_PROVENANCE\.json/);
|
|
assert.match(dockerfile, /0001-stream-large-package-assembly\.patch/);
|
|
assert.doesNotMatch(dockerfile, /v16-patches|chimera-license-free-base-v16/);
|
|
assert.equal(fs.existsSync(path.join(root, 'tools/chimera-prospero-bridge/legacy/v16-patches/0001-parallel-fast-store.patch')), true);
|
|
});
|
|
|
|
test('builder rejects insufficient workspace before starting the bridge', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-builder-capacity-')); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
|
const toolRoot = path.join(root, 'tool'); const workRoot = path.join(root, 'work'); const sourceRoot = path.join(root, 'source');
|
|
fs.mkdirSync(toolRoot); fs.mkdirSync(workRoot); fs.mkdirSync(sourceRoot);
|
|
fs.writeFileSync(path.join(toolRoot, PINNED_PS5_BUILDER.executable), 'bridge');
|
|
let buildRuns = 0;
|
|
const runner = async input => {
|
|
if (input.args[0] === 'probe') return { output: JSON.stringify(semanticProbe()) };
|
|
buildRuns++; return { output: '' };
|
|
};
|
|
const provider = createPs5NativePkgBuilderProvider({ toolRoot, allowedWorkRoots: [workRoot], allowedSourceRoots: [sourceRoot], runner });
|
|
await assert.rejects(() => provider.build({ sourcePath: sourceRoot, sourceSize: 10_000_000_000_000, outputPath: path.join(workRoot, 'out.pkg'), workPath: path.join(workRoot, 'job'), titleId: 'PPSA12345', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001' }), error => error.code === 'PS5_BUILDER_DISK');
|
|
assert.equal(buildRuns, 0);
|
|
});
|
|
|
|
function fspOutside(root) { const outside = path.join(root, 'not-allowed'); fs.mkdirSync(outside, { recursive: true }); return outside; }
|
|
|
|
test('registers a verified native package as a local package set without console-install evidence', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-registration-'));
|
|
database.configure({ dataDir: path.join(root, 'db'), logger: { info() {}, warn() {}, error() {} } }); await database.initialize();
|
|
t.after(() => { database.close(); fs.rmSync(root, { recursive: true, force: true }); });
|
|
const outputRoot = path.join(root, 'vault'); const folder = path.join(outputRoot, 'PPSA12345', 'job'); fs.mkdirSync(folder, { recursive: true });
|
|
const pkg = path.join(folder, 'PPSA12345-base.pkg'); writeFih(pkg); const bytes = fs.readFileSync(pkg);
|
|
const manifest = { schemaVersion: 1, kind: 'chimera.ps5-native-package.v1', createdAt: 100, title: { platform: 'ps5', titleId: 'PPSA12345', name: 'PS5 Test' }, packageFormat: { container: 'FIH', debug: true, retail: false }, components: [{ id: 'base', type: 'base', version: '01.00', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001', size: bytes.length, sha256: crypto.createHash('sha256').update(bytes).digest('hex'), absolutePath: pkg, required: true, order: 1, adapterHint: 'ps5-native-debug-package', provenance: [] }], dependencies: [], recipe: { installOrder: [{ componentId: 'base', order: 1 }] } };
|
|
const result = registerPs5NativePackageManifest({ db: database, outputRoot, manifest });
|
|
assert.ok(result.packageSetId);
|
|
assert.equal(database.runQuery('SELECT COUNT(*) AS count FROM local_copies')[0].count, 1);
|
|
assert.equal(database.runQuery('SELECT COUNT(*) AS count FROM console_installs')[0].count, 0);
|
|
});
|
|
|
|
test('rolls back title and package registration atomically when a component is invalid', async t => {
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'chimera-ps5-registration-rollback-'));
|
|
database.configure({ dataDir: path.join(root, 'db'), logger: { info() {}, warn() {}, error() {} } }); await database.initialize();
|
|
t.after(() => { database.close(); fs.rmSync(root, { recursive: true, force: true }); });
|
|
const outputRoot = path.join(root, 'vault'); const folder = path.join(outputRoot, 'PPSA12345', 'job'); fs.mkdirSync(folder, { recursive: true });
|
|
const pkg = path.join(folder, 'invalid.pkg'); writeFih(pkg); const size = fs.statSync(pkg).size;
|
|
const beforeGames = database.runQuery('SELECT COUNT(*) AS count FROM games')[0].count;
|
|
const beforeTitles = database.runQuery('SELECT COUNT(*) AS count FROM titles')[0].count;
|
|
const manifest = { schemaVersion: 1, kind: 'chimera.ps5-native-package.v1', createdAt: 100, title: { platform: 'ps5', titleId: 'PPSA12345', name: 'Rollback Test' }, packageFormat: { container: 'FIH', debug: true, retail: false }, components: [{ id: 'base', type: 'base', version: '01.00', contentId: 'UP0001-PPSA12345_00-CHIMERATEST00001', size, sha256: 'not-a-hash', absolutePath: pkg, required: true, order: 1 }], dependencies: [], recipe: { installOrder: [{ componentId: 'base', order: 1 }] } };
|
|
assert.throws(() => registerPs5NativePackageManifest({ db: database, outputRoot, manifest }), error => error.code === 'PS5_PACKAGE_MANIFEST');
|
|
assert.equal(database.runQuery('SELECT COUNT(*) AS count FROM games')[0].count, beforeGames);
|
|
assert.equal(database.runQuery('SELECT COUNT(*) AS count FROM titles')[0].count, beforeTitles);
|
|
assert.equal(database.runQuery('SELECT COUNT(*) AS count FROM package_sets')[0].count, 0);
|
|
});
|