@dozimple/abap-adt 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -4,6 +4,55 @@ Formato basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/). V
 
 ## [Unreleased]
 
+## [1.0.1] - 2026-09-22
+
+Versión de mantenimiento: seguimiento de la auditoría de seguridad, procedimiento de commit y pruebas por propiedades.
+
+### Añadido
+- **Pruebas por propiedades de la entrada hostil** (`test/property.test.ts`, fast-check): 15 invariantes sobre el
+  filtro de `table_contents`, el saneado de errores, el HTML de documentación y feeds, los nombres que acaban en una
+  ruta ADT, `SAP_USER_RE` y la huella de los tokens de confirmación. En vez de comprobar casos conocidos, cada prueba
+  afirma lo que la función garantiza para **cualquier** entrada y el generador busca el contraejemplo (miles por
+  ejecución; `FC_RUNS=5000 npm test` para una pasada profunda). Validadas rompiendo el código a propósito: cada
+  propiedad detecta la regresión que le toca.
+
+### Cambiado
+- La release de GitHub adjunta el bundle de la atestación también como `<paquete>.intoto.jsonl`, además de
+  `.sigstore.json`. Es el mismo bundle in-toto con los dos nombres: uno es el que verifica `gh attestation verify` y el
+  otro el que las herramientas de cadena de suministro reconocen como procedencia (OpenSSF Scorecard entre ellas).
+
+### Seguridad
+- El veto de datos sensibles incluye `ICF_PASSWD` (contraseña del usuario de inicio de sesión fijo de un servicio ICF)
+  y las columnas genéricas `PASSWD` / `PASSWORD`, en cualquier tabla, también cuando llegan por un `SELECT *` (se
+  comprueban las columnas del resultado y, si aparece una, no se muestra nada). Detectado al revisar la configuración
+  ICF de un servicio.
+- Seguimiento de la auditoría (prioridades 1 y 2 del auditor y DZ-30): **permisos de `systems.json` en Windows**
+  comprobados por ACL y SID (antes no se comprobaba nada en esa plataforma), fail-closed si no se pueden leer;
+  **registro de auditoría firmado con HMAC-SHA256** con clave en el llavero del SO (quitar firmas se detecta), y
+  `audit:verify` comprueba cadena y firmas; el escáner falla si `package.json` declara scripts de instalación.
+- **Auditoría de seguridad del 21-09-2026** (30 hallazgos, ninguno alto ni crítico): corregidos todos los accionables.
+  Los más relevantes: la escritura ya no aplica un diff aprobado sobre un objeto que cambió en SAP después de la vista
+  previa (huella comprobada bajo el bloqueo); filtro de `table_contents` por lista blanca; usuarios SAP validados en
+  filtros de feeds; nombres validados en rutas ADT; `allowSelfSigned` solo en DEV y avisado al arrancar; sin
+  redirecciones en el servicio de riesgo; errores saneados antes de llegar al modelo; contraseñas en memoria con
+  caducidad; toda tool `exec` decide expresamente si pide confirmación; tope de filas también en `jobs` y
+  `application_log`; columnas personales propias por cliente (`piiColumns`); registro de auditoría con bloqueo entre
+  procesos y lectura de la cola; marcado neutralizado tras decodificar HTML; ids online de `docs_fetch` validados ya
+  decodificados. Documentado lo que cada control garantiza y lo que no (token frente a elicitación, cadena de
+  auditoría sin secreto, aviso de «dato» probabilístico). Tests de regresión en `test/audit-2026-09.test.ts`.
+- **Procedimiento de seguridad en cada commit** ([docs/COMMIT_SECURITY.md](docs/COMMIT_SECURITY.md)): el `pre-commit`
+  revisa el código completo y el contenido exacto preparado; un `pre-push` nuevo y el CI revisan todo el historial de
+  todas las ramas. El escáner detecta además direcciones (IPs reales, hosts con puertos de SAP, dominios internos),
+  más tipos de credenciales (Google, JWT, tokens de GitHub de grano fino, GitLab, cadenas de conexión, secretos
+  asignados, URLs con contraseña, webhooks) y archivos peligrosos por su nombre (`.env`, certificados, claves SSH, el
+  `systems.json` real). 21 tests adversariales.
+
+### Corregido
+- Workflow de release: la comprobación de `latest` fallaba porque npm tarda unos segundos en propagar la etiqueta
+  (la 1.0.0 se publicó bien, pero la release de GitHub no se creó y se completó a mano con los artefactos firmados del
+  mismo run). Ahora reintenta durante 2 minutos, no republica una versión existente y actualiza la release si ya
+  existe: reintentar un run es seguro.
+
 ## [1.0.0] - 2026-09-21
 
 Primera versión estable, publicada en npm como `@dozimple/abap-adt` con procedencia.

package/README.es.md

@@ -291,7 +291,7 @@ Modelo de amenazas con STRIDE y OWASP Top 10 para aplicaciones LLM: **[docs/THRE
 Con la versión exacta y sin scripts de instalación, igual que las dependencias del propio proyecto:
 
 ```sh
-npm install -g --ignore-scripts @dozimple/abap-adt@1.0.0
+npm install -g --ignore-scripts @dozimple/abap-adt@1.0.1
 PKG="$(npm root -g)/@dozimple/abap-adt"
 mkdir -p ~/.config/abap-adt-dozimple && chmod 700 ~/.config/abap-adt-dozimple
 cp "$PKG/config/systems.example.json" ~/.config/abap-adt-dozimple/systems.json   # sistemas, roles y permisos
@@ -307,8 +307,9 @@ Registro en el cliente MCP:
 ```
 
 Cada versión se publica desde el CI con [procedencia de npm](https://docs.npmjs.com/generating-provenance-statements):
-`npm view @dozimple/abap-adt@1.0.0 dist.attestations` muestra la atestación, y la release de GitHub incluye el
-paquete, su bundle de Sigstore y el SBOM.
+`npm view @dozimple/abap-adt@1.0.1 dist.attestations` muestra la atestación, y la release de GitHub incluye el
+paquete, su bundle de Sigstore (`.sigstore.json`), el mismo bundle como procedencia in-toto (`.intoto.jsonl`)
+y el SBOM. Para comprobarlo: `gh attestation verify dozimple-abap-adt-1.0.1.tgz --repo <owner>/abap-adt-dozimple`.
 
 ### Desde el código fuente
 

package/README.md

@@ -291,7 +291,7 @@ Designed to pass a Security and Basis review without exceptions. Details: **[SEC
 Pinned to an exact version, without install scripts, like the project's own dependencies:
 
 ```sh
-npm install -g --ignore-scripts @dozimple/abap-adt@1.0.0
+npm install -g --ignore-scripts @dozimple/abap-adt@1.0.1
 PKG="$(npm root -g)/@dozimple/abap-adt"
 mkdir -p ~/.config/abap-adt-dozimple && chmod 700 ~/.config/abap-adt-dozimple
 cp "$PKG/config/systems.example.json" ~/.config/abap-adt-dozimple/systems.json   # systems, roles and permissions
@@ -307,8 +307,9 @@ MCP client registration:
 ```
 
 Every release is published from CI with [npm provenance](https://docs.npmjs.com/generating-provenance-statements):
-`npm view @dozimple/abap-adt@1.0.0 dist.attestations` shows the attestation, and the GitHub release carries the
-tarball, its Sigstore bundle and the SBOM.
+`npm view @dozimple/abap-adt@1.0.1 dist.attestations` shows the attestation, and the GitHub release carries the
+tarball, its Sigstore bundle (`.sigstore.json`), the same bundle as in-toto provenance (`.intoto.jsonl`) and the
+SBOM. To check it: `gh attestation verify dozimple-abap-adt-1.0.1.tgz --repo <owner>/abap-adt-dozimple`.
 
 ### From source
 

package/SECURITY.md

@@ -8,26 +8,26 @@ aplicaciones LLM, riesgos residuales): **[docs/THREAT_MODEL.md](docs/THREAT_MODE
 
 | Activo | Amenaza | Control |
 |---|---|---|
-| Credenciales SAP | Filtrado en archivos, logs, respuestas o procesos hijo | Llavero de macOS o Secret Service en Linux (`execFile` sin shell); opción `--strict` para que el llavero pregunte en cada lectura; la configuración no admite contraseñas; nunca en logs ni respuestas; los procesos hijo reciben un entorno explícito mínimo (`PATH`, `HOME`, `TMPDIR`, idioma y terminal) |
+| Credenciales SAP | Filtrado en archivos, logs, respuestas o procesos hijo | Llavero de macOS o Secret Service en Linux (`execFile` sin shell); opción `--strict` para que el llavero pregunte en cada lectura; en memoria, caducan a los 15 min y se borran al cerrar; la configuración no admite contraseñas; nunca en logs ni respuestas; los procesos hijo reciben un entorno explícito mínimo (`PATH`, `HOME`, `TMPDIR`, idioma y terminal) |
 | Sistemas SAP | Cambios no deseados por un agente | `read` / `exec` / `write` por tool; `write` solo en DEV con `allowWrite`; QAS y PRD nunca; tools de escritura ocultas si ningún sistema la permite; sin liberar, importar ni borrar |
-| Escrituras | El agente escribe sin que la persona vea qué | **Confirmación obligatoria**: por elicitación MCP si el cliente la soporta; si no, en dos fases con vista previa (sintaxis de SAP + diff real) y token de un solo uso atado a tool, sistema y argumentos exactos (10 min). Anotación `destructiveHint` para que el cliente también pida permiso |
-| Trazabilidad | Una escritura sin rastro, o un rastro retocado | **Registro de auditoría** local encadenado por hash (`audit.jsonl`): intención, resultado y denegaciones de toda escritura y ejecución, con usuario SAP, sistema, forma de confirmación y huella sha256 del contenido (nunca el contenido). Sin registro no se escribe. `npm run audit:verify` detecta alteraciones |
+| Escrituras | El agente escribe sin que la persona vea qué | **Confirmación obligatoria** con vista previa (sintaxis de SAP + diff real + avisos de la orden). Dos niveles de garantía, y no son equivalentes: **elicitación MCP** (fuerte: la pregunta la responde una persona en el cliente) si el cliente la soporta; si no, **token** de un solo uso atado a tool, sistema y argumentos exactos (10 min), que es una garantía **de aviso**: el servidor no puede distinguir si una persona vio la vista previa, por eso el cliente no debe autoaprobar estas tools (`destructiveHint`). `npm run audit:verify` cuenta cuántas escrituras se confirmaron de cada forma. Además, la huella de lo mostrado viaja con la confirmación y se comprueba **bajo el bloqueo** antes de escribir: si el objeto cambió en SAP tras la vista previa, no se escribe |
+| Trazabilidad | Una escritura sin rastro, o un rastro retocado | **Registro de auditoría** local encadenado por hash y **firmado con HMAC-SHA256** (`audit.jsonl`): intención, resultado y denegaciones de toda escritura y ejecución, con usuario SAP, sistema, forma de confirmación y huella sha256 del contenido (nunca el contenido). La clave se genera al primer uso y vive en el llavero del SO (se guarda por stdin, nunca como argumento de un proceso); la fecha de creación va con ella, así que quitar firmas se detecta. Sin registro no se escribe; escrituras de varios servidores a la vez, serializadas con bloqueo. `npm run audit:verify` comprueba cadena y firmas. **Límite:** quien pueda leer tu llavero (tu propia sesión sin `--strict`) podría recalcularlo todo; para evidencia fuera de tu control, anota fuera del equipo el «último hash» que imprime `audit:verify`. Sin almacén de secretos (Windows), la cadena queda sin firma y se avisa |
 | ABAP Unit | Un test con efectos (BD, llamadas externas) | Solo tests `RISK LEVEL HARMLESS` y `DURATION SHORT`, pedido explícitamente; solo en DEV |
 | Orden de transporte | El cambio cae en una orden ajena | `decideTransport`: orden explícita; si hay bloqueo CTS de otra orden, se para sin escribir |
 | Material de seguridad en SAP | Lectura de hashes, almacén seguro, PSE, secretos OAuth o dumps | Veto de USR02/USH02/USRPWDHISTORY, RSECTAB/RSECACTB, SSF_PSE_*, USRACL, SNAP, OA2C_* y columnas de hash, **también a través de vistas (DD26S) y CDS (DDLDEPENDENCY + fuente DDL), hasta 3 niveles** |
 | Datos de personal | Infotipos y nómina | PA\*, PB\*, PCL1-5 y HRPY_\* vetados, también vía vistas y CDS |
-| Datos personales de negocio | Exposición masiva a un proveedor LLM | Clase de datos por sistema (`test` / `masked` / `prod`; por defecto DEV = test, QAS/PRD = prod). En masked/prod: **columnas personales enmascaradas** (nombres, direcciones, teléfonos, correos, identificadores fiscales, cuentas bancarias, fechas de nacimiento), prohibido usarlas en WHERE, alias o expresiones, y **tope de filas** por sistema (200 en prod, configurable) |
+| Datos personales de negocio | Exposición masiva a un proveedor LLM | Clase de datos por sistema (`test` / `masked` / `prod`; por defecto DEV = test, QAS/PRD = prod). En masked/prod: **columnas personales enmascaradas** (nombres, direcciones, teléfonos, correos, identificadores fiscales, cuentas bancarias, fechas de nacimiento, y las columnas propias de cada cliente declaradas en `piiColumns`), prohibido usarlas en WHERE, alias o expresiones, y **tope de filas** por sistema (200 en prod, configurable), también en `jobs` y `application_log`. El enmascarado es por nombre de columna: un campo Z no declarado sale en claro |
 | Parámetros de las tools | Un parámetro mal escrito o inventado que se ignora en silencio (p. ej. la orden de transporte) | Esquemas estrictos: un parámetro no declarado es error y la tool no se ejecuta; el esquema publicado declara `additionalProperties: false` |
-| SQL | Escritura, varias sentencias o inyección en filtros | Solo `SELECT`/`WITH`, sin `;`; vista previa de ADT de solo lectura; literales escapados; en `table_contents` el filtro no admite subconsultas, UNION, comentarios ni comillas sin cerrar |
-| Configuración | Alguien redirige el servidor o habilita la escritura | `systems.json` se rechaza si lo pueden modificar grupo u otros usuarios, o si es de otro usuario; el sistema por defecto por variable de entorno se identifica como tal en cada respuesta, y si no existe es error |
+| SQL | Escritura, varias sentencias o inyección en filtros | Solo `SELECT`/`WITH`, sin `;`; vista previa de ADT de solo lectura; literales escapados; en `table_contents` el filtro se valida por **lista blanca** (columnas, operadores, literales, AND/OR/NOT, LIKE, IN, BETWEEN, IS NULL/INITIAL, paréntesis equilibrados); usuarios SAP en filtros de feeds validados por formato; nombres en rutas ADT validados (sin `..`) |
+| Configuración | Alguien redirige el servidor, habilita la escritura o cambia el comando de un componente | `systems.json` se rechaza si lo pueden modificar otros: en macOS/Linux por permisos y propietario; **en Windows por sus ACL**, leídas por SID (independiente del idioma): solo tu usuario, SYSTEM, Administradores y TrustedInstaller pueden escribirlo. Si la comprobación no puede hacerse, no se arranca (salvo `ABAP_DZ_SKIP_ACL_CHECK=1`, avisado en cada arranque). El sistema por defecto por variable de entorno se identifica en cada respuesta, y si no existe es error |
 | Red | Exposición de un puerto | Solo stdio; no se abre ningún puerto |
-| TLS | Intercepción (MitM) | Verificación por defecto; `caFile` para certificados propios; `allowSelfSigned` marcado con ⚠ |
+| TLS | Intercepción (MitM) | Verificación por defecto; `caFile` para certificados propios; `allowSelfSigned` **solo en DEV** (rechazado en QAS/PRD), marcado con ⚠ y avisado en cada arranque. El servicio de riesgo no sigue redirecciones: las credenciales Basic no viajan a otra URL |
 | Datos de clientes | Salida a internet vía documentación | Online apagado por defecto; si se habilita, `assertPublicQuery` bloquea objetos Z/Y, namespaces, órdenes, sistemas, SID, usuarios, dominios y términos configurados; `docs_fetch` solo acepta ids con forma de documento, y los online pasan el mismo filtro |
-| Inyección de instrucciones | Fuente, textos o datos de SAP o de la web que intentan dirigir al agente | Toda respuesta de SAP y de documentación se marca como dato, nunca instrucciones; ninguna escritura sin confirmación humana con vista previa |
-| Dependencias | Vulnerabilidades o código malicioso | 4 dependencias de producción con versión exacta y lockfile; `ignore-scripts` (sin scripts de instalación); `npm audit` y `npm audit signatures` (firmas y procedencia) en CI; SBOM CycloneDX como artefacto de cada build; acciones de CI fijadas por commit; Dependabot |
+| Inyección de instrucciones | Fuente, textos o datos de SAP o de la web que intentan dirigir al agente | Toda respuesta de SAP y de documentación se marca como dato, nunca instrucciones (control **probabilístico**: reduce, no elimina, que el modelo obedezca contenido hostil); el marcado que revive al decodificar HTML se neutraliza; la barrera efectiva es que ninguna escritura ocurre sin confirmación humana con vista previa. Los errores que llegan al modelo se sanean (sin credenciales en URLs, sin cabeceras, sin marcado, con longitud acotada) |
+| Dependencias | Vulnerabilidades o código malicioso | 4 dependencias de producción con versión exacta y lockfile; `ignore-scripts` (sin scripts de instalación) en el desarrollo, y el paquete publicado **no declara ningún script de instalación** (el escáner falla si aparece uno: el `.npmrc` no protege a quien instala el paquete); `npm audit` y `npm audit signatures` (firmas y procedencia) en CI; SBOM CycloneDX como artefacto de cada build; acciones de CI fijadas por commit; Dependabot |
 | Terceros | Un MCP externo con acceso a credenciales | Solo como proceso hijo aislado, tras revisión, con entorno mínimo; sus tools pasan por la política de este servidor |
 | Estado local | Lectura por otros usuarios del equipo | Carpetas `700`, archivos `600`; el registro de uso no guarda argumentos |
-| Repositorio | Credenciales o datos de clientes en el historial | `scripts/scan-sensitive.mjs` en `pre-commit` y en CI; los términos prohibidos se leen de la configuración local, nunca se listan en el repo; secret scanning con push protection |
+| Repositorio | Credenciales, direcciones (IPs, hosts internos o de SAP) o datos de clientes en el código o en el historial | [Procedimiento en cada commit](docs/COMMIT_SECURITY.md): `pre-commit` revisa el código completo más lo preparado; `pre-push` y CI revisan todo el historial; `main` exige el CI; secret scanning con push protection. Los términos de clientes se leen de la configuración local, nunca se listan en el repo |
 
 ## Recomendaciones de despliegue
 
@@ -46,7 +46,8 @@ aplicaciones LLM, riesgos residuales): **[docs/THREAT_MODEL.md](docs/THREAT_MODE
 
 ```sh
 npm run security      # npm audit + firmas del registro + escáner de credenciales y datos de clientes
-npm test              # incluye los tests de política y de seguridad (test/security.test.ts)
+npm test              # incluye los tests de política y de seguridad (test/security.test.ts) y las
+                      # pruebas por propiedades de la entrada hostil (test/property.test.ts, fast-check)
 npm run audit:verify  # integridad del registro de auditoría local
 npm run sbom          # SBOM CycloneDX de las dependencias de producción
 ```

package/dist/core/atc.js

@@ -31,7 +31,8 @@ export async function defaultVariant(c) {
     const v = cust.properties.find((p) => p.name === "systemCheckVariant")?.value;
     return typeof v === "string" && v ? v : "DEFAULT";
 }
-const xmlEsc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+/** Escapado XML completo (texto y atributos con comillas simples o dobles). */
+const xmlEsc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 /**
  * Ejecución ATC sobre varios objetos a la vez. La librería solo admite una
  * URI; en NW 7.50 una orden no sirve como conjunto («No URI-Mapping defined

package/dist/core/audit.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { auditKey, macOf } from "./auditkey.js";
 import { stateDir } from "./telemetry.js";
 /**
  * Registro de auditoría de todo lo que modifica o ejecuta en SAP. Solo
@@ -15,7 +16,7 @@ export const AUDIT_FILE = "audit.jsonl";
 const GENESIS = "0".repeat(64);
 const INLINE_MAX = 120;
 /** E/S del registro, sustituible en tests para simular disco lleno o permisos. */
-export const auditIo = { appendFileSync, existsSync, mkdirSync, readFileSync };
+export const auditIo = { appendFileSync, existsSync, mkdirSync, readFileSync, openSync, closeSync, fstatSync, readSync, statSync, rmSync };
 const sha256 = (s) => createHash("sha256").update(s).digest("hex");
 /** Argumentos aptos para el registro: valores cortos tal cual, el resto como huella. */
 export function auditArgs(args) {
@@ -39,14 +40,63 @@ export function auditArgs(args) {
 function entryHash(e) {
     return sha256(JSON.stringify(e));
 }
+/** Última entrada leyendo solo la cola del archivo (el registro no se relee entero en cada escritura). */
 function lastEntry(path) {
     if (!auditIo.existsSync(path))
         return { seq: 0, hash: GENESIS };
-    const lines = auditIo.readFileSync(path, "utf8").trimEnd().split("\n").filter(Boolean);
-    if (!lines.length)
-        return { seq: 0, hash: GENESIS };
-    const last = JSON.parse(lines[lines.length - 1]);
-    return { seq: last.seq, hash: last.hash };
+    const fd = auditIo.openSync(path, "r");
+    try {
+        const size = auditIo.fstatSync(fd).size;
+        if (!size)
+            return { seq: 0, hash: GENESIS };
+        for (let window = 16 * 1024;; window *= 4) {
+            const start = Math.max(0, size - window);
+            const buf = Buffer.alloc(size - start);
+            auditIo.readSync(fd, buf, 0, buf.length, start);
+            const lines = buf.toString("utf8").trimEnd().split("\n");
+            // Si la ventana empieza a mitad de una línea, la primera está cortada: vale la última si hay al menos dos.
+            if (lines.length >= 2 || start === 0) {
+                const last = JSON.parse(lines[lines.length - 1]);
+                return { seq: last.seq, hash: last.hash };
+            }
+        }
+    }
+    finally {
+        auditIo.closeSync(fd);
+    }
+}
+/**
+ * Bloqueo entre procesos (dos clientes MCP pueden tener cada uno su servidor): sin él, dos escrituras simultáneas
+ * leerían el mismo «prev» y romperían la cadena, que sería indistinguible de una manipulación.
+ */
+function withLock(dir, fn) {
+    const lock = join(dir, AUDIT_FILE + ".lock");
+    const deadline = Date.now() + 5_000;
+    for (;;) {
+        try {
+            auditIo.closeSync(auditIo.openSync(lock, "wx", 0o600));
+            break;
+        }
+        catch (e) {
+            if (e.code !== "EEXIST")
+                throw e;
+            // Un bloqueo de más de 30 s es de un proceso que murió a mitad: se recupera.
+            try {
+                if (Date.now() - auditIo.statSync(lock).mtimeMs > 30_000)
+                    auditIo.rmSync(lock, { force: true });
+            }
+            catch { }
+            if (Date.now() > deadline)
+                throw new Error("registro de auditoría bloqueado por otro proceso");
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        auditIo.rmSync(lock, { force: true });
+    }
 }
 /**
  * Añade una entrada. Lanza si no puede escribir: quien llama decide no
@@ -55,6 +105,12 @@ function lastEntry(path) {
 export function appendAudit(input, dir = stateDir()) {
     auditIo.mkdirSync(dir, { recursive: true, mode: 0o700 });
     const path = join(dir, AUDIT_FILE);
+    return withLock(dir, () => appendLocked(path, input));
+}
+function appendLocked(path, input) {
+    // La clave se obtiene (o se crea) ANTES de fechar la entrada: así la primera firmada nunca queda con una fecha
+    // anterior a la de la clave, y quitarle la firma no la hace pasar por una entrada antigua.
+    const key = auditKey(true);
     const prev = lastEntry(path);
     const base = {
         seq: prev.seq + 1,
@@ -63,14 +119,19 @@ export function appendAudit(input, dir = stateDir()) {
         args: auditArgs(input.args),
         prev: prev.hash,
     };
-    const entry = { ...base, hash: entryHash(base) };
+    const hash = entryHash(base);
+    const entry = key ? { ...base, hash, mac: macOf(key.key, hash) } : { ...base, hash };
     auditIo.appendFileSync(path, JSON.stringify(entry) + "\n", { mode: 0o600 });
     return entry;
 }
-/** Recorre la cadena completa: secuencia, enlace con la anterior y hash propio. */
-export function verifyAudit(text) {
+/**
+ * Recorre la cadena completa: secuencia, enlace con la anterior y hash propio. Con la clave, además, la firma de cada
+ * entrada; y toda entrada posterior a la creación de la clave TIENE que estar firmada (quitar firmas no sirve).
+ */
+export function verifyAudit(text, key) {
     const lines = text.split("\n").filter(Boolean);
     let prev = GENESIS;
+    let signed = 0;
     for (let i = 0; i < lines.length; i++) {
         let e;
         try {
@@ -79,15 +140,23 @@ export function verifyAudit(text) {
         catch {
             return { ok: false, entries: lines.length, brokenAt: i + 1, reason: "línea que no es JSON" };
         }
-        const { hash, ...rest } = e;
+        const { hash, mac, ...rest } = e;
         if (e.seq !== i + 1)
             return { ok: false, entries: lines.length, brokenAt: i + 1, reason: `secuencia ${e.seq}, se esperaba ${i + 1}` };
         if (e.prev !== prev)
             return { ok: false, entries: lines.length, brokenAt: i + 1, reason: "no enlaza con la entrada anterior" };
         if (entryHash(rest) !== hash)
             return { ok: false, entries: lines.length, brokenAt: i + 1, reason: "contenido alterado" };
+        if (key) {
+            if (mac !== undefined && mac !== macOf(key.key, hash))
+                return { ok: false, entries: lines.length, brokenAt: i + 1, reason: "firma HMAC inválida (cadena recalculada sin la clave)" };
+            if (mac === undefined && e.ts >= key.created)
+                return { ok: false, entries: lines.length, brokenAt: i + 1, reason: "entrada sin firma posterior a la creación de la clave (firma quitada)" };
+            if (mac !== undefined)
+                signed++;
+        }
         prev = hash;
     }
-    return { ok: true, entries: lines.length };
+    return key ? { ok: true, entries: lines.length, signed } : { ok: true, entries: lines.length };
 }
 //# sourceMappingURL=audit.js.map

package/dist/core/auditkey.js

@@ -0,0 +1,85 @@
+import { execFileSync } from "node:child_process";
+import { createHmac, randomBytes } from "node:crypto";
+/**
+ * Clave HMAC del registro de auditoría, guardada en el almacén de secretos del sistema operativo (llavero de macOS
+ * o Secret Service en Linux). Con ella, reescribir el registro exige además poder leer el llavero del usuario: un
+ * proceso sin acceso al llavero (u otro usuario del equipo) ya no puede recalcular la cadena y que pase por buena.
+ *
+ * Formato guardado: «v1:<fecha ISO de creación>:<64 hex>». La fecha permite detectar que se QUITARON firmas:
+ * toda entrada posterior a ella tiene que llevarla.
+ *
+ * ABAP_DZ_AUDIT_KEYSTORE: «os» (por defecto), «memory» (tests) o «none» (sin firma, se avisa).
+ */
+const SERVICE = "abap-adt-dozimple-audit";
+const ACCOUNT = "hmac";
+let cached;
+let memory;
+let warned = false;
+const parse = (v) => {
+    const m = /^v1:([^:]+(?::[^:]+)*?):([0-9a-f]{64})$/.exec((v ?? "").trim());
+    return m ? { created: m[1], key: Buffer.from(m[2], "hex") } : null;
+};
+function readOs() {
+    try {
+        if (process.platform === "darwin") {
+            return execFileSync("security", ["find-generic-password", "-s", SERVICE, "-a", ACCOUNT, "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        }
+        if (process.platform === "linux") {
+            return execFileSync("secret-tool", ["lookup", "service", SERVICE, "account", ACCOUNT], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        }
+    }
+    catch {
+        /* no existe todavía, o no hay almacén */
+    }
+    return undefined;
+}
+/** Guarda el valor sin pasarlo nunca como argumento de un proceso (visible en `ps`): siempre por stdin. */
+function writeOs(value) {
+    try {
+        if (process.platform === "darwin") {
+            execFileSync("security", ["-i"], { input: `add-generic-password -U -s ${SERVICE} -a ${ACCOUNT} -w ${value}\n`, stdio: ["pipe", "ignore", "ignore"] });
+            return parse(readOs())?.key.toString("hex") === value.split(":").pop();
+        }
+        if (process.platform === "linux") {
+            execFileSync("secret-tool", ["store", `--label=${SERVICE}`, "service", SERVICE, "account", ACCOUNT], { input: value, stdio: ["pipe", "ignore", "ignore"] });
+            return !!parse(readOs());
+        }
+    }
+    catch {
+        /* sin almacén disponible */
+    }
+    return false;
+}
+/**
+ * La clave, creándola la primera vez si `create`. null = no hay almacén de secretos: el registro sigue encadenado
+ * pero sin firma (y se avisa una vez por stderr).
+ */
+export function auditKey(create = true) {
+    if (cached !== undefined && (cached || !create))
+        return cached;
+    const mode = process.env.ABAP_DZ_AUDIT_KEYSTORE ?? "os";
+    if (mode === "none")
+        return (cached = null);
+    const read = () => (mode === "memory" ? memory : readOs());
+    let k = parse(read());
+    if (!k && create) {
+        const value = `v1:${new Date().toISOString()}:${randomBytes(32).toString("hex")}`;
+        if (mode === "memory")
+            memory = value;
+        else if (!writeOs(value)) {
+            if (!warned)
+                console.error("[abap-adt-doZimple] ⚠ Sin almacén de secretos: el registro de auditoría queda encadenado pero sin firma HMAC.");
+            warned = true;
+            return (cached = null);
+        }
+        k = parse(read());
+    }
+    return (cached = k);
+}
+/** Solo tests: olvida la clave en memoria (como si fuera otro equipo o se hubiera borrado). */
+export function resetAuditKeyForTests() {
+    cached = undefined;
+    memory = undefined;
+}
+export const macOf = (key, hash) => createHmac("sha256", key).update(hash).digest("hex");
+//# sourceMappingURL=auditkey.js.map

package/dist/core/config.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
@@ -34,6 +35,11 @@ const SystemSchema = z.object({
     dataClass: z.enum(["test", "masked", "prod"]).optional(),
     /** Tope de filas por consulta; por defecto test 5000, masked 1000, prod 200. */
     maxRows: z.number().int().min(1).max(5000).optional(),
+    /**
+     * Columnas personales propias de este cliente (campos Z o alias de CDS) que se enmascaran igual que las estándar
+     * en sistemas masked/prod. El enmascarado es por nombre: lo que no esté aquí ni en la lista estándar sale en claro.
+     */
+    piiColumns: z.array(z.string().regex(/^[A-Za-z0-9_/]+$/)).default([]),
     password: z
         .string()
         .regex(/^(keychain|env:[A-Z0-9_]+)$/, 'password: "keychain" o "env:NOMBRE_VARIABLE"')
@@ -70,6 +76,12 @@ export function parseConfig(raw) {
             throw new Error(`Sistema duplicado en la configuración: ${s.id}`);
         ids.add(key);
     }
+    for (const s of cfg.systems) {
+        // Sin verificar TLS, quien intercepte la red recibe usuario y contraseña (Basic): nunca en calidad ni productivo.
+        if (s.allowSelfSigned && s.role !== "DEV") {
+            throw new Error(`${s.id}: allowSelfSigned solo se admite en sistemas DEV. Para ${s.role} usa caFile con el certificado de su CA.`);
+        }
+    }
     if (cfg.defaultSystem && !ids.has(cfg.defaultSystem.toUpperCase())) {
         throw new Error(`defaultSystem "${cfg.defaultSystem}" no está en systems[]`);
     }
@@ -88,8 +100,9 @@ export function loadConfig(path = configPath()) {
  * servidor y si puede escribir en él: tiene que ser solo del usuario.
  */
 export function assertPrivateFile(path, st = statSync(path)) {
+    // En Windows no hay bits de modo ni uid: se leen las ACL (assertPrivateFileWindows).
     if (process.platform === "win32")
-        return;
+        return assertPrivateFileWindows(path);
     if (st.mode & 0o022) {
         throw new Error(`${path} lo pueden modificar otros usuarios (permisos ${(st.mode & 0o777).toString(8)}). Corrígelo con: chmod 600 "${path}"`);
     }
@@ -98,6 +111,69 @@ export function assertPrivateFile(path, st = statSync(path)) {
         throw new Error(`${path} pertenece a otro usuario (uid ${st.uid}). Debe ser tuyo y con permisos 600.`);
     }
 }
+// ── Windows: ACL del archivo ────────────────────────────────────────────────
+/** Quién puede escribir legítimamente, además del propio usuario: SYSTEM, Administradores, TrustedInstaller. */
+const TRUSTED_SIDS = new Set(["S-1-5-18", "S-1-5-32-544", "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464"]);
+/** Derechos que permiten cambiar el contenido, los permisos o el propietario (nombres de .NET y genéricos numéricos). */
+const WRITE_RIGHTS = /FullControl|Modify|Write|AppendData|CreateFiles|ChangePermissions|TakeOwnership|^(268435456|1073741824)$/;
+/** Entradas que dan escritura a alguien que no es el usuario ni una identidad del sistema. */
+export function aclViolations(entries, userSid) {
+    return entries.filter((e) => /allow/i.test(e.type) && e.sid !== userSid && !TRUSTED_SIDS.has(e.sid) && WRITE_RIGHTS.test(e.rights));
+}
+/** Salida del script de PowerShell: «USER|<sid>», «OWNER|<sid>» y «ACE|<sid>|<derechos>|<tipo>». */
+export function parseAclOutput(out) {
+    let user = "";
+    let owner = "";
+    const entries = [];
+    for (const line of out.split(/\r?\n/)) {
+        const [kind, sid, rights, type] = line.trim().split("|");
+        if (kind === "USER")
+            user = sid;
+        else if (kind === "OWNER")
+            owner = sid;
+        else if (kind === "ACE" && sid)
+            entries.push({ sid, rights: rights ?? "", type: type ?? "" });
+    }
+    return { user, owner, entries };
+}
+// La ruta llega por variable de entorno, nunca dentro del comando: sin inyección posible.
+const ACL_SCRIPT = [
+    "$ErrorActionPreference='Stop'",
+    "$a=Get-Acl -LiteralPath $env:ABAPDZ_ACL_PATH",
+    "'USER|'+[Security.Principal.WindowsIdentity]::GetCurrent().User.Value",
+    "'OWNER|'+(New-Object Security.Principal.NTAccount($a.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value",
+    "foreach($r in $a.Access){ $s=try{$r.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value}catch{$r.IdentityReference.Value}; 'ACE|'+$s+'|'+$r.FileSystemRights+'|'+$r.AccessControlType }",
+].join("; ");
+/**
+ * systems.json define qué proceso lanza cada componente (sidecars.command): quien pueda escribirlo ejecuta código
+ * con tu identidad. En Windows se exige que solo tu usuario (y el sistema) pueda modificarlo. Si la comprobación no
+ * se puede hacer, no se arranca (fail-closed), salvo ABAP_DZ_SKIP_ACL_CHECK=1, que queda avisado al arrancar.
+ */
+export function assertPrivateFileWindows(path, run = () => execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ACL_SCRIPT], {
+    encoding: "utf8",
+    timeout: 15_000,
+    env: { ...process.env, ABAPDZ_ACL_PATH: path },
+})) {
+    if (process.env.ABAP_DZ_SKIP_ACL_CHECK === "1")
+        return;
+    let acl;
+    try {
+        acl = parseAclOutput(run());
+    }
+    catch (e) {
+        throw new Error(`No se pudieron leer los permisos de ${path} (${e.message.split("\n")[0]}). Sin esa comprobación no se arranca; si lo asumes, define ABAP_DZ_SKIP_ACL_CHECK=1.`);
+    }
+    if (!acl.user)
+        throw new Error(`No se pudo determinar el usuario actual para comprobar ${path}.`);
+    if (acl.owner && acl.owner !== acl.user && !TRUSTED_SIDS.has(acl.owner)) {
+        throw new Error(`${path} pertenece a otra identidad (${acl.owner}). Debe ser tuyo.`);
+    }
+    const bad = aclViolations(acl.entries, acl.user);
+    if (bad.length) {
+        throw new Error(`${path} lo pueden modificar otras identidades (${bad.map((b) => `${b.sid}: ${b.rights}`).join("; ")}). ` +
+            `Déjalo solo para tu usuario: icacls "${path}" /inheritance:r /grant:r "%USERNAME%":F`);
+    }
+}
 /** Escritura efectiva: hace falta allowWrite y ser un sistema de desarrollo. */
 export function canWrite(s) {
     return s.allowWrite && s.role === "DEV";
@@ -133,4 +209,16 @@ export function resolveSystem(cfg, requested) {
         return { system: cfg.systems[0], source: "único configurado" };
     throw new Error(`Hay varios sistemas y ninguno por defecto: indica "system" (${cfg.systems.map((x) => x.id).join(", ")})`);
 }
+/** Avisos que se escriben por stderr en cada arranque: lo que la configuración deja más débil de lo normal. */
+export function startupWarnings(cfg, platform = process.platform) {
+    const out = [];
+    for (const s of cfg.systems) {
+        if (s.allowSelfSigned && !s.caFile)
+            out.push(`${s.id}: TLS SIN VERIFICAR (allowSelfSigned). Configura caFile con el certificado de su CA.`);
+    }
+    if (platform === "win32" && process.env.ABAP_DZ_SKIP_ACL_CHECK === "1") {
+        out.push("Windows: ABAP_DZ_SKIP_ACL_CHECK=1 desactiva la comprobación de permisos de systems.json (que define los procesos que se lanzan). Quítala en cuanto puedas.");
+    }
+    return out;
+}
 //# sourceMappingURL=config.js.map

package/dist/core/confirm.js

@@ -22,22 +22,34 @@ function canonical(v) {
 export function argsDigest(tool, system, args) {
     return createHash("sha256").update(JSON.stringify([tool, system.toUpperCase(), canonical(args)])).digest("hex");
 }
-export function issueToken(tool, system, args, now = Date.now()) {
+/**
+ * `state` es la huella de lo que el usuario vio en la vista previa (p. ej. el sha256 de la fuente actual en SAP):
+ * la tool la compara al escribir para no aplicar un diff sobre algo que cambió entretanto.
+ */
+export function issueToken(tool, system, args, now = Date.now(), state) {
     for (const [t, p] of pending)
         if (p.exp <= now)
             pending.delete(t);
     const token = randomBytes(16).toString("hex");
-    pending.set(token, { digest: argsDigest(tool, system, args), exp: now + CONFIRM_TTL_MS });
+    pending.set(token, { digest: argsDigest(tool, system, args), exp: now + CONFIRM_TTL_MS, state });
     return token;
 }
-/** Consume el token: vale una sola vez, también cuando no coincide. */
-export function consumeToken(token, tool, system, args, now = Date.now()) {
+/** Como consumeToken, y además devuelve la huella del estado que se vio en la vista previa. */
+export function consumeTokenWithState(token, tool, system, args, now = Date.now()) {
     const p = pending.get(token);
     if (!p)
-        return "unknown";
+        return { check: "unknown" };
     pending.delete(token);
     if (p.exp <= now)
-        return "expired";
-    return p.digest === argsDigest(tool, system, args) ? "ok" : "mismatch";
+        return { check: "expired" };
+    return p.digest === argsDigest(tool, system, args) ? { check: "ok", state: p.state } : { check: "mismatch" };
+}
+/** Consume el token: vale una sola vez, también cuando no coincide. */
+export function consumeToken(token, tool, system, args, now = Date.now()) {
+    return consumeTokenWithState(token, tool, system, args, now).check;
+}
+/** Huella de un contenido tal como se mostró: sha256 con saltos de línea normalizados. */
+export function stateOf(content) {
+    return createHash("sha256").update(content.replace(/\r\n?/g, "\n")).digest("hex");
 }
 //# sourceMappingURL=confirm.js.map

package/dist/core/connection.js

@@ -88,7 +88,11 @@ export class SapConnection {
         if (!this.basisRelease) {
             this.basisRelease = this.query("SELECT release FROM cvers WHERE component = 'SAP_BASIS'", 1)
                 .then((r) => r.values[0]?.RELEASE?.trim())
-                .catch(() => undefined);
+                .catch(() => {
+                // Un fallo pasajero (VPN caída un instante) no deja el dato en blanco para siempre: se reintenta después.
+                this.basisRelease = undefined;
+                return undefined;
+            });
         }
         return this.basisRelease;
     }

package/dist/core/credentials.js

@@ -4,6 +4,8 @@ import { ToolError } from "./errors.js";
 const run = promisify(execFile);
 /** Servicio del llavero de macOS bajo el que se guardan las contraseñas. */
 export const KEYCHAIN_SERVICE = "abap-adt-dozimple";
+/** Contraseñas en memoria con caducidad: sin caché el llavero se leería en cada petición; sin límite, vivirían siempre. */
+const CACHE_TTL_MS = 15 * 60_000;
 const cache = new Map();
 /**
  * Devuelve la contraseña del sistema. Nunca se escribe en logs ni en la
@@ -11,8 +13,9 @@ const cache = new Map();
  */
 export async function getPassword(s) {
     const hit = cache.get(s.id);
-    if (hit)
-        return hit;
+    if (hit && hit.exp > Date.now())
+        return hit.pwd;
+    cache.delete(s.id);
     let pwd;
     if (s.password.startsWith("env:")) {
         pwd = process.env[s.password.slice(4)];
@@ -34,11 +37,15 @@ export async function getPassword(s) {
             throw new ToolError("AUTH", `No hay contraseña para ${s.id} en el llavero. Guárdala con: scripts/set-password.sh ${s.id}`);
         }
     }
-    cache.set(s.id, pwd);
+    cache.set(s.id, { pwd, exp: Date.now() + CACHE_TTL_MS });
     return pwd;
 }
 /** Tras un 401 conviene olvidar la contraseña cacheada por si se cambió. */
 export function forgetPassword(id) {
     cache.delete(id);
 }
+/** Al cerrar el servidor: ninguna contraseña queda en memoria más de lo necesario. */
+export function clearPasswords() {
+    cache.clear();
+}
 //# sourceMappingURL=credentials.js.map