@saulwade/swl-ses 2.6.0 → 2.8.0

package/scripts/lib/runtime-artifact-verifier.js

@@ -0,0 +1,426 @@
+'use strict';
+
+/** Verificación fail-closed de artefactos y locators runtime C10/W3. */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const util = require('node:util');
+
+const MAX_ARTIFACTS = 256;
+const MAX_ARTIFACT_BYTES = 16 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const MAX_RELATIVE_PATH = 512;
+const MAX_PATH_SEGMENT = 128;
+const SHA256 = /^[a-f0-9]{64}$/u;
+const SAFE_RELATIVE_PATH = /^[A-Za-z0-9._/-]+$/u;
+const WINDOWS_RESERVED = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu;
+const OPEN_FLAGS = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0);
+const VERIFIED_SETS = new WeakMap();
+
+function crearError(code, mensaje) {
+  const error = new Error(`${code}: ${mensaje}`);
+  error.code = code;
+  error.esErrorArtefactoSWL = true;
+  return error;
+}
+
+function esObjetoPlano(valor) {
+  if (valor === null || typeof valor !== 'object' || Array.isArray(valor)
+      || util.types.isProxy(valor)) return false;
+  const prototipo = Object.getPrototypeOf(valor);
+  return prototipo === Object.prototype || prototipo === null;
+}
+
+function esMaterialDatos(valor) {
+  if (Object.getOwnPropertySymbols(valor).length > 0) return false;
+  return Object.values(Object.getOwnPropertyDescriptors(valor))
+    .every((descriptor) => descriptor.enumerable && 'value' in descriptor);
+}
+
+function esArrayDatos(valor) {
+  if (!Array.isArray(valor) || util.types.isProxy(valor)
+      || Object.getOwnPropertySymbols(valor).length > 0) return false;
+  const descriptores = Object.getOwnPropertyDescriptors(valor);
+  const indices = Object.entries(descriptores).filter(([clave]) => clave !== 'length');
+  return indices.length === valor.length && indices.every(([clave, descriptor]) => (
+    /^(?:0|[1-9]\d*)$/u.test(clave) && descriptor.enumerable && 'value' in descriptor
+  ));
+}
+
+function assertShape(valor, campos, nombre) {
+  if (!esObjetoPlano(valor)) throw crearError('LOCATOR_INVALID', `${nombre} no es objeto plano`);
+  if (!esMaterialDatos(valor)) {
+    throw crearError('LOCATOR_INVALID', `${nombre} contiene material hostil`);
+  }
+  const faltante = campos.find((campo) => !Object.hasOwn(valor, campo));
+  if (faltante) throw crearError('LOCATOR_INVALID', `${nombre} omite ${faltante}`);
+  const extra = Object.keys(valor).find((campo) => !campos.includes(campo));
+  if (extra) throw crearError('LOCATOR_INVALID', `${nombre} contiene campo ${extra}`);
+}
+
+function rutasIguales(izquierda, derecha) {
+  return path.relative(izquierda, derecha) === '';
+}
+
+function mismaIdentidad(izquierda, derecha) {
+  return izquierda.dev === derecha.dev && izquierda.ino === derecha.ino;
+}
+
+function validarDirectorio(stats, code, nombre) {
+  if (stats.isSymbolicLink() || !stats.isDirectory()) {
+    throw crearError(code, `${nombre} debe ser directorio real`);
+  }
+}
+
+function cerrarDescriptores(descriptores) {
+  const unicos = [...new Set(descriptores.filter(Number.isInteger))];
+  const errores = [];
+  for (const descriptor of unicos) {
+    try { fs.closeSync(descriptor); } catch (error) { errores.push(error); }
+  }
+  return errores;
+}
+
+function cerrarRecursos(descriptores, errorOperacion) {
+  const erroresCierre = cerrarDescriptores(descriptores);
+  if (erroresCierre.length > 0) {
+    const error = crearError('CLOSE_FAILED', 'no se pudieron cerrar todos los descriptores');
+    error.cause = errorOperacion || erroresCierre[0];
+    throw error;
+  }
+  if (errorOperacion) throw errorOperacion;
+}
+
+function resolverRaiz(bundleRoot) {
+  if (typeof bundleRoot !== 'string' || !path.isAbsolute(bundleRoot)) {
+    throw crearError('ROOT_INVALID', 'la raíz absoluta es requerida');
+  }
+  const ruta = path.resolve(bundleRoot);
+  try {
+    const stats = fs.lstatSync(ruta, { bigint: true });
+    validarDirectorio(stats, 'ROOT_INVALID', 'la raíz');
+    if (!rutasIguales(ruta, fs.realpathSync(ruta))) {
+      throw crearError('ROOT_INVALID', 'la raíz contiene resolución por link');
+    }
+    return { ruta, stats };
+  } catch (error) {
+    if (error.code === 'ROOT_INVALID') throw error;
+    throw crearError('ROOT_INVALID', 'la raíz no existe o no es accesible');
+  }
+}
+
+function abrirRaiz(bundleRoot) {
+  const { ruta, stats: antes } = resolverRaiz(bundleRoot);
+  let descriptor;
+  try {
+    descriptor = fs.openSync(ruta, OPEN_FLAGS);
+    const handle = fs.fstatSync(descriptor, { bigint: true });
+    const despues = fs.lstatSync(ruta, { bigint: true });
+    validarDirectorio(handle, 'ROOT_CHANGED', 'la raíz abierta');
+    validarDirectorio(despues, 'ROOT_CHANGED', 'la raíz actual');
+    if (!mismaIdentidad(antes, handle) || !mismaIdentidad(handle, despues)) {
+      throw crearError('ROOT_CHANGED', 'la raíz cambió entre lstat y open');
+    }
+    return { ruta, descriptor, dev: handle.dev, ino: handle.ino, code: 'ROOT_CHANGED' };
+  } catch (error) {
+    const fallo = error.code === 'ROOT_CHANGED'
+      ? error
+      : crearError('OPEN_FAILED', 'no se pudo fijar la raíz');
+    cerrarRecursos([descriptor], fallo);
+  }
+}
+
+function validarDirectorioActual(handle) {
+  try {
+    const abierto = fs.fstatSync(handle.descriptor, { bigint: true });
+    const actual = fs.lstatSync(handle.ruta, { bigint: true });
+    validarDirectorio(abierto, handle.code, 'directorio abierto');
+    validarDirectorio(actual, handle.code, 'directorio actual');
+    if (!mismaIdentidad(handle, abierto) || !mismaIdentidad(handle, actual)) {
+      throw crearError(handle.code, 'directorio cambió de identidad');
+    }
+  } catch (error) {
+    if (error.code === handle.code) throw error;
+    throw crearError(handle.code, 'directorio desapareció o dejó de ser verificable');
+  }
+}
+
+function validarDirectorios(handles) {
+  handles.forEach(validarDirectorioActual);
+}
+
+function abrirDirectorio(ruta, padres) {
+  let descriptor;
+  let antes;
+  try {
+    antes = fs.lstatSync(ruta, { bigint: true });
+  } catch {
+    throw crearError('PATH_INVALID', 'ancestro ausente');
+  }
+  if (antes.isSymbolicLink()) throw crearError('LINK_REJECTED', 'symlink en path');
+  if (!antes.isDirectory()) throw crearError('PATH_INVALID', 'ancestro no es directorio');
+  try {
+    validarDirectorios(padres);
+    descriptor = fs.openSync(ruta, OPEN_FLAGS);
+    const abierto = fs.fstatSync(descriptor, { bigint: true });
+    const despues = fs.lstatSync(ruta, { bigint: true });
+    validarDirectorio(abierto, 'DIRECTORY_CHANGED', 'ancestro abierto');
+    validarDirectorio(despues, 'DIRECTORY_CHANGED', 'ancestro actual');
+    if (!mismaIdentidad(antes, abierto) || !mismaIdentidad(abierto, despues)) {
+      throw crearError('DIRECTORY_CHANGED', 'ancestro cambió entre lstat y open');
+    }
+    return { ruta, descriptor, dev: abierto.dev, ino: abierto.ino, code: 'DIRECTORY_CHANGED' };
+  } catch (error) {
+    const fallo = error.code === 'DIRECTORY_CHANGED'
+      ? error
+      : crearError('OPEN_FAILED', 'no se pudo fijar un ancestro');
+    cerrarRecursos([descriptor], fallo);
+  }
+}
+
+function validarSegmentoPortable(segmento) {
+  if (segmento.length > MAX_PATH_SEGMENT || /[. ]$/u.test(segmento)) {
+    throw crearError('PATH_INVALID', 'segmento excede longitud o termina en punto/espacio');
+  }
+  if (WINDOWS_RESERVED.test(segmento)) {
+    throw crearError('PATH_INVALID', 'nombre reservado no portable');
+  }
+}
+
+function validarPathRelativo(relativo) {
+  if (typeof relativo !== 'string' || relativo.length > MAX_RELATIVE_PATH
+      || !SAFE_RELATIVE_PATH.test(relativo)) {
+    throw crearError('PATH_INVALID', 'path relativo no canónico o excede longitud');
+  }
+  const partes = relativo.split('/');
+  if (path.posix.isAbsolute(relativo) || relativo.includes(':') || relativo.includes('\\')
+      || partes.some((parte) => parte === '' || parte === '.' || parte === '..')) {
+    throw crearError('PATH_INVALID', 'path absoluto, traversal, ADS o segmento inválido');
+  }
+  partes.forEach(validarSegmentoPortable);
+  return partes;
+}
+
+function validarListaRutas(rutas) {
+  if (!esArrayDatos(rutas) || rutas.length === 0) {
+    throw crearError('PATH_INVALID', 'la lista de paths debe ser datos no vacíos');
+  }
+  if (rutas.length > MAX_ARTIFACTS) throw crearError('LIMIT_EXCEEDED', 'cantidad de artefactos');
+  rutas.forEach(validarPathRelativo);
+  const ordenadas = [...rutas].sort();
+  const caseFold = rutas.map((ruta) => ruta.toLowerCase());
+  if (new Set(rutas).size !== rutas.length || new Set(caseFold).size !== rutas.length
+      || JSON.stringify(rutas) !== JSON.stringify(ordenadas)) {
+    throw crearError('PATH_INVALID', 'paths duplicados, con colisión case-fold o fuera de orden');
+  }
+}
+
+function abrirAncestros(raiz, partes) {
+  const handles = [raiz];
+  let actual = raiz.ruta;
+  try {
+    for (const parte of partes.slice(0, -1)) {
+      actual = path.join(actual, parte);
+      handles.push(abrirDirectorio(actual, handles));
+    }
+    return handles;
+  } catch (error) {
+    const abiertos = handles.slice(1).reverse().map(({ descriptor }) => descriptor);
+    cerrarRecursos(abiertos, error);
+  }
+}
+
+function identidadArchivo(stats) {
+  return [stats.dev, stats.ino, stats.size, stats.mtimeNs, stats.ctimeNs]
+    .map((valor) => String(valor)).join(':');
+}
+
+function validarStatsArchivo(stats) {
+  if (!stats.isFile()) throw crearError('TYPE_REJECTED', 'artefacto no es archivo regular');
+  if (stats.nlink !== 1n) throw crearError('LINK_REJECTED', 'hardlink detectado');
+  if (stats.size > BigInt(MAX_ARTIFACT_BYTES)) {
+    throw crearError('LIMIT_EXCEEDED', 'artefacto demasiado grande');
+  }
+}
+
+function leerBytes(descriptor, longitud) {
+  const bytes = Buffer.alloc(longitud);
+  let offset = 0;
+  while (offset < longitud) {
+    const leidos = fs.readSync(descriptor, bytes, offset, longitud - offset, offset);
+    if (leidos === 0) throw crearError('ARTIFACT_CHANGED', 'EOF antes del tamaño verificado');
+    offset += leidos;
+  }
+  return bytes;
+}
+
+function estaConfinado(raiz, destino) {
+  const relativo = path.relative(raiz, destino);
+  const primerSegmento = relativo.split(path.sep)[0];
+  return relativo !== '' && primerSegmento !== '..' && !path.isAbsolute(relativo);
+}
+
+function validarPathFinal(raiz, destino, statsHandle) {
+  try {
+    const real = fs.realpathSync(destino);
+    const statsPath = fs.lstatSync(destino, { bigint: true });
+    if (!estaConfinado(raiz, real) || statsPath.isSymbolicLink()) {
+      throw crearError('PATH_ESCAPE', 'path final fuera de la raíz o symlink');
+    }
+    if (!mismaIdentidad(statsPath, statsHandle)) {
+      throw crearError('ARTIFACT_CHANGED', 'path cambió de identidad durante lectura');
+    }
+  } catch (error) {
+    if (['PATH_ESCAPE', 'ARTIFACT_CHANGED'].includes(error.code)) throw error;
+    throw crearError('ARTIFACT_CHANGED', 'path desapareció durante lectura');
+  }
+}
+
+function abrirArchivo(ruta) {
+  try {
+    return fs.openSync(ruta, OPEN_FLAGS);
+  } catch {
+    throw crearError('OPEN_FAILED', 'no se pudo abrir el artefacto');
+  }
+}
+
+function leerArchivoEstable(raiz, relativo) {
+  const partes = validarPathRelativo(relativo);
+  const handles = abrirAncestros(raiz, partes);
+  const destino = path.join(raiz.ruta, ...partes);
+  let descriptor;
+  let bytes;
+  let errorOperacion;
+  try {
+    validarDirectorios(handles);
+    descriptor = abrirArchivo(destino);
+    const antes = fs.fstatSync(descriptor, { bigint: true });
+    validarStatsArchivo(antes);
+    validarDirectorios(handles);
+    bytes = leerBytes(descriptor, Number(antes.size));
+    const despues = fs.fstatSync(descriptor, { bigint: true });
+    validarDirectorios(handles);
+    if (identidadArchivo(antes) !== identidadArchivo(despues)
+        || antes.nlink !== despues.nlink) {
+      throw crearError('ARTIFACT_CHANGED', 'archivo cambió durante lectura');
+    }
+    validarStatsArchivo(despues);
+    validarPathFinal(raiz.ruta, destino, despues);
+    validarDirectorios(handles);
+  } catch (error) {
+    errorOperacion = error.esErrorArtefactoSWL
+      ? error
+      : crearError('OPEN_FAILED', 'falló la lectura por descriptor');
+  }
+  const ancestros = handles.slice(1).reverse().map((handle) => handle.descriptor);
+  cerrarRecursos([descriptor, ...ancestros], errorOperacion);
+  return bytes;
+}
+
+function metadataDe(ruta, bytes) {
+  return Object.freeze({
+    path: ruta,
+    bytes: bytes.length,
+    sha256: crypto.createHash('sha256').update(bytes).digest('hex'),
+  });
+}
+
+function registrarConjunto(entradas) {
+  const metadata = Object.freeze(entradas.map(({ path: ruta, bytes }) => metadataDe(ruta, bytes)));
+  const token = Object.freeze({ kind: 'verified-runtime-artifacts', entries: metadata });
+  const bytesPorRuta = entradas.map(({ path: ruta, bytes }) => [ruta, Buffer.from(bytes)]);
+  VERIFIED_SETS.set(token, new Map(bytesPorRuta));
+  return token;
+}
+
+function cargarArtefactosVerificados(bundleRoot, rutas) {
+  validarListaRutas(rutas);
+  const raiz = abrirRaiz(bundleRoot);
+  let total = 0;
+  let conjunto;
+  let errorOperacion;
+  try {
+    const entradas = rutas.map((ruta) => {
+      const bytes = leerArchivoEstable(raiz, ruta);
+      total += bytes.length;
+      if (total > MAX_TOTAL_BYTES) throw crearError('LIMIT_EXCEEDED', 'tamaño total excedido');
+      return { path: ruta, bytes };
+    });
+    validarDirectorioActual(raiz);
+    conjunto = registrarConjunto(entradas);
+  } catch (error) {
+    errorOperacion = error;
+  }
+  cerrarRecursos([raiz.descriptor], errorOperacion);
+  return conjunto;
+}
+
+function exigirConjunto(conjunto) {
+  const interno = VERIFIED_SETS.get(conjunto);
+  if (!interno) throw crearError('UNVERIFIED_SET', 'se requiere conjunto verificado');
+  return interno;
+}
+
+function esConjuntoArtefactosVerificado(valor) {
+  return VERIFIED_SETS.has(valor);
+}
+
+function crearLocator(conjunto) {
+  exigirConjunto(conjunto);
+  const entries = Object.freeze(conjunto.entries.map((entry) => Object.freeze({ ...entry })));
+  return Object.freeze({ schemaVersion: '1.0.0', kind: 'swl-runtime-locator', entries });
+}
+
+function validarEntradaLocator(entry, indice) {
+  assertShape(entry, ['path', 'bytes', 'sha256'], `locator entry ${indice}`);
+  validarPathRelativo(entry.path);
+  if (!Number.isSafeInteger(entry.bytes) || entry.bytes < 0 || entry.bytes > MAX_ARTIFACT_BYTES) {
+    throw crearError('LOCATOR_INVALID', 'bytes de locator inválidos');
+  }
+  if (typeof entry.sha256 !== 'string' || !SHA256.test(entry.sha256)) {
+    throw crearError('LOCATOR_INVALID', 'digest de locator inválido');
+  }
+}
+
+function validarLocator(locator) {
+  assertShape(locator, ['schemaVersion', 'kind', 'entries'], 'locator');
+  if (locator.schemaVersion !== '1.0.0' || locator.kind !== 'swl-runtime-locator') {
+    throw crearError('LOCATOR_INVALID', 'versión o kind de locator inválido');
+  }
+  if (!esArrayDatos(locator.entries) || locator.entries.length === 0) {
+    throw crearError('LOCATOR_INVALID', 'locator sin entradas de datos');
+  }
+  if (locator.entries.length > MAX_ARTIFACTS) {
+    throw crearError('LIMIT_EXCEEDED', 'cantidad de entradas del locator');
+  }
+  locator.entries.forEach(validarEntradaLocator);
+  validarListaRutas(locator.entries.map(({ path: ruta }) => ruta));
+}
+
+function verificarLocator(bundleRoot, locator) {
+  validarLocator(locator);
+  const conjunto = cargarArtefactosVerificados(
+    bundleRoot, locator.entries.map(({ path: ruta }) => ruta)
+  );
+  if (JSON.stringify(conjunto.entries) !== JSON.stringify(locator.entries)) {
+    throw crearError('ARTIFACT_MISMATCH', 'bytes o digest no coinciden con locator');
+  }
+  return conjunto;
+}
+
+function leerArtefactoVerificado(conjunto, relativo) {
+  const interno = exigirConjunto(conjunto);
+  const bytes = interno.get(relativo);
+  if (!bytes) throw crearError('PATH_INVALID', 'artefacto no pertenece al conjunto');
+  return Buffer.from(bytes);
+}
+
+module.exports = {
+  cargarArtefactosVerificados,
+  crearLocator,
+  esConjuntoArtefactosVerificado,
+  leerArtefactoVerificado,
+  validarListaRutasPortables: validarListaRutas,
+  verificarLocator,
+};

package/scripts/lib/runtime-build-attestation.js

@@ -0,0 +1,127 @@
+'use strict';
+
+/** Registra una construcción Core-3 sin producir autoridad conductual. */
+
+const util = require('node:util');
+
+const { isKernelDependencies } = require('./policy-contract');
+const { validarListaRutasPortables } = require('./runtime-artifact-verifier');
+const { parsearIJson, validarTimestampIso } = require('./signed-envelope');
+
+const MAX_RAW_BYTES = 256 * 1024;
+const SHA256 = /^[a-f0-9]{64}$/u;
+const PAYLOAD_KEYS = Object.freeze([
+  'schemaVersion', 'kind', 'purpose', 'runtimeId', 'installerTarget', 'adapterId',
+  'adapterSchemaVersion', 'contractVersion', 'manifestDigest', 'locatorDigest',
+  'outputs', 'builtAt', 'effectiveMode',
+]);
+const RUNTIMES = Object.freeze({
+  'claude-code': 'claude',
+  'codex-cli': 'codex',
+  'gemini-cli': 'gemini',
+});
+
+function fail(codigo, mensaje) {
+  const error = new TypeError(mensaje);
+  error.codigo = codigo;
+  throw error;
+}
+
+function exactKeys(value, keys) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    && JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
+}
+
+function validateRawBytes(rawBytes) {
+  if (!rawBytes || typeof rawBytes !== 'object' || util.types.isProxy(rawBytes)) {
+    fail('BUILD_ATTESTATION_INVALID', 'bytes de atestación inválidos');
+  }
+  const prototype = Object.getPrototypeOf(rawBytes);
+  const validPrototype = prototype === Buffer.prototype || prototype === Uint8Array.prototype;
+  const intrusive = ['buffer', 'byteOffset', 'byteLength'].some(
+    (property) => Object.hasOwn(rawBytes, property)
+  );
+  if (!validPrototype || intrusive
+      || rawBytes.byteLength === 0 || rawBytes.byteLength > MAX_RAW_BYTES) {
+    fail('BUILD_ATTESTATION_INVALID', 'bytes de atestación inválidos');
+  }
+}
+
+function parsePayload(rawBytes) {
+  validateRawBytes(rawBytes);
+  try {
+    return parsearIJson(rawBytes);
+  } catch {
+    fail('BUILD_ATTESTATION_INVALID', 'atestación no es I-JSON canónico');
+  }
+}
+
+function validateOutputs(outputs) {
+  if (!Array.isArray(outputs) || !outputs.every((output) => (
+    exactKeys(output, ['path', 'sha256'])
+      && typeof output.path === 'string' && output.path.startsWith('outputs/')
+      && typeof output.sha256 === 'string' && SHA256.test(output.sha256)
+  ))) return false;
+  try {
+    validarListaRutasPortables(outputs.map((output) => output.path));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function validateBindings(payload) {
+  if (!Object.hasOwn(RUNTIMES, payload.runtimeId)) return false;
+  return payload.installerTarget === RUNTIMES[payload.runtimeId]
+    && payload.adapterId === `runtime-adapter:${payload.runtimeId}`;
+}
+
+function validateConstants(payload) {
+  return payload.schemaVersion === '1.0.0'
+    && payload.kind === 'swl-runtime-build-attestation'
+    && payload.purpose === 'runtime-build'
+    && payload.adapterSchemaVersion === '1.0.0'
+    && payload.contractVersion === '1.0.0'
+    && payload.effectiveMode === 'proposal_only';
+}
+
+function validatePayload(payload) {
+  try {
+    validarTimestampIso(payload.builtAt, 'build timestamp');
+  } catch {
+    return false;
+  }
+  return exactKeys(payload, PAYLOAD_KEYS)
+    && validateConstants(payload)
+    && validateBindings(payload)
+    && SHA256.test(payload.manifestDigest)
+    && SHA256.test(payload.locatorDigest)
+    && validateOutputs(payload.outputs);
+}
+
+function validateCas(expectedSequence, expectedHeadHash) {
+  if (!Number.isSafeInteger(expectedSequence) || expectedSequence < 0
+      || Object.is(expectedSequence, -0) || typeof expectedHeadHash !== 'string'
+      || !SHA256.test(expectedHeadHash)) {
+    fail('BUILD_CAS_INVALID', 'precondición CAS inválida');
+  }
+}
+
+function registrarBuildAttestation(rawBytes, expectedSequence, expectedHeadHash, dependencies) {
+  if (arguments.length !== 4 || !isKernelDependencies(dependencies)) {
+    fail('BUILD_AUTHORITY_INVALID', 'dependencias W2 no verificadas');
+  }
+  validateCas(expectedSequence, expectedHeadHash);
+  const payload = parsePayload(rawBytes);
+  if (!validatePayload(payload)) {
+    fail('BUILD_ATTESTATION_INVALID', 'contrato de atestación inválido');
+  }
+  return dependencies.integrityLedger.append({
+    expectedSequence,
+    expectedHeadHash,
+    eventType: 'runtime-build',
+    payload,
+  });
+}
+
+module.exports = { registrarBuildAttestation };