verify-layer: cloud exports (AWS ECS/EC2/Lambda, Azure VMs/Container Instances/Container Apps/Web Apps, GCP Compute Engine/Cloud Run) read from the operator's own CLI export, never from an account; fixtures derived from the vendors' documented examples; a real account is unmeasured and the README says so

This commit is contained in:
Aere Network committed 2026-10-18 14:12:00 +03:00
1 parent ea695dcf32
commit ac14880703
49 files changed
+10080 -17

No files matched your search

+245 -4
View File
@@ -18,6 +18,9 @@
// sidecar record --kind proof --proof-file f.json (leaga orice plic AIP-23 gata facut, dupa ce ii verifica forma si integritatea)
// sidecar scan --source docker|kubernetes --input export.json (fiecare container care RULEAZA; NUMAI numele variabilelor de mediu,
// linia de comanda ca hash; exportul il face operatorul)
// sidecar scan --source aws-ecs|aws-ec2|aws-lambda|azure-vm|azure-container|azure-containerapp|azure-webapp|gcp-compute|gcp-run
// --input export.json [--task-definitions f] (B15, 2026-10-18: exportul CLI-ului furnizorului, facut de operator; aceeasi
// forma: numai ce RULEAZA, numai NUMELE variabilelor, nicio acreditare si niciun apel la API)
// sidecar verify-log --log p [--attested cap.json [--signer head.pub.pem]] -> 0 intreg (si continua capul atestat), 1 rupt sau necontinuat
// sidecar attest-head --log p [--out f] [--sign-key head.key.pem] -> capul lantului ca plic AIP-23 aere-audit-head, semnat ML-DSA-65
// sidecar keygen --out <dosar> -> cheia ML-DSA-65 cu care operatorul semneaza capetele (head.key.pem 0600, head.pub.pem)
@@ -184,6 +187,243 @@ export function descrieKubernetes(lista) {
return out;
}
// ---- adaptoarele pe furnizori de cloud (B15, 2026-10-18): ACEEASI forma, onesta ------------------------------------------------
// Exportul il face operatorul cu CLI-ul furnizorului, cu acreditarile LUI, pe masina lui; sidecar-ul citeste fisierul si atat: nicio
// acreditare in sidecar, niciun apel la un API. Fiecare adaptor: (1) refuza pe nume un fisier care nu e iesirea CLI-ului numit;
// (2) ia numai incarcaturile pe care exportul le declara ca RULEAZA; (3) scrie identitatea (imagine + digest cand exportul il are,
// altfel id-ul masinii/serviciului + imaginea declarata, `imageIdentity: 'declared'`), regiunea/zona, NUMAI numele variabilelor de
// mediu (si ale etichetelor, setarilor, cheilor de metadata), NICIO valoare de userData/customData/metadata (nu se copiaza deloc).
// Descriptorul e canonic (chei sortate la toate nivelurile) si devine un plic 'data' prin acelasi constructor ca Docker/Kubernetes.
// Masurate pe iesirile DOCUMENTATE ale CLI-urilor (fixturi-cloud/), nu pe un cont real: nu avem conturi la AWS/Azure/GCP.
const canonicAdanc = (v) => (Array.isArray(v) ? '[' + v.map((x) => canonicAdanc(x === undefined ? null : x)).join(',') + ']'
: v && typeof v === 'object' ? '{' + Object.keys(v).filter((k) => v[k] !== undefined).sort().map((k) => JSON.stringify(k) + ':' + canonicAdanc(v[k])).join(',') + '}'
: JSON.stringify(v === undefined ? null : v));
const numeDin = (lista, cheie = 'name') => [...new Set((Array.isArray(lista) ? lista : []).map((e) => (e && typeof e === 'object' ? e[cheie] : e)).filter((n) => typeof n === 'string' && n))].sort();
const ultimul = (url) => (typeof url === 'string' && url ? url.split('/').filter(Boolean).pop() || null : null);
const grupulDin = (id) => { const m = /\/resourceGroups\/([^/]+)\//i.exec(String(id || '')); return m ? m[1] : null; };
const digestDinImagine = (img) => { const m = /@(sha256:[0-9a-fA-F]{64})$/.exec(String(img || '')); return m ? m[1].toLowerCase() : null; };
// az CLI scrie resursele ARM cu `properties` aplatizat; `az rest` si extensia containerapp le lasa imbricate: se citesc amandoua formele
const aplatizat = (o) => (o && typeof o === 'object' && o.properties && typeof o.properties === 'object' ? { ...o.properties, ...o } : o);
const intrare = (nume, version, d) => ({ name: nume, version: version || '?', content: Buffer.from(canonicAdanc(d), 'utf8') });
/** `aws ecs describe-tasks` (+ optional `aws ecs describe-task-definition`, una sau o lista, pentru numele variabilelor si comanda) */
export function descrieAwsEcs(j, definitii = null) {
if (!(!!j && !Array.isArray(j) && Array.isArray(j.tasks) /*FORMA:aws-ecs*/)) throw new Error('aws-ecs: the input is not the output of `aws ecs describe-tasks` (an object with tasks[])');
const defs = new Map();
for (const d of definitii == null ? [] : Array.isArray(definitii) ? definitii : [definitii]) {
const td = d && d.taskDefinition;
if (!(!!td && typeof td.taskDefinitionArn === 'string' && Array.isArray(td.containerDefinitions) /*FORMA:aws-ecs-definitii*/)) throw new Error('aws-ecs: --task-definitions is not the output of `aws ecs describe-task-definition` (taskDefinition.containerDefinitions[])');
defs.set(td.taskDefinitionArn, td);
}
const out = [];
for (const t of j.tasks) {
if (!(!!t && t.lastStatus === 'RUNNING' /*RULEAZA:aws-ecs*/)) continue;
const td = defs.get(t.taskDefinitionArn) || null;
const region = String(t.taskArn || '').split(':')[3] || null;
for (const c of t.containers || []) {
// si containerul trebuie sa ruleze: un task RUNNING poate avea un container neesential deja oprit
if (!(!!c && c.lastStatus === 'RUNNING' /*RULEAZA:aws-ecs-container*/)) continue;
const cd = td ? td.containerDefinitions.find((x) => x && x.name === c.name) || null : null;
const over = (t.overrides?.containerOverrides || []).find((x) => x && x.name === c.name) || null;
const d = {
runtime: 'aws-ecs', region, clusterArn: t.clusterArn || null, taskArn: t.taskArn || null, taskDefinitionArn: t.taskDefinitionArn || null,
container: c.name, image: c.image || cd?.image || null, imageDigest: c.imageDigest || null, imageIdentity: c.imageDigest ? 'digest' : 'declared',
runtimeId: c.runtimeId || null, launchType: t.launchType || null, availabilityZone: t.availabilityZone || null, startedAt: t.startedAt || null,
group: t.group || null, taskVersion: t.version ?? null,
commandSha256: cd ? sha256(Buffer.from(JSON.stringify([...(cd.entryPoint || []), ...(over?.command || cd.command || [])]), 'utf8')) : null,
// numele din definitie (environment + secrets, al caror valueFrom e un ARN, nu o valoare) si din overrides; valorile nu intra
envNames: numeDin([...(cd?.environment || []), ...(cd?.secrets || []), ...(over?.environment || [])] /*NUME:aws-ecs*/),
envSource: td ? (over?.environment ? 'task-definition+overrides' : 'task-definition') : over?.environment ? 'overrides-only' : 'not-in-export',
mounts: (cd?.mountPoints || []).map((m) => m && m.containerPath).filter(Boolean).sort(),
};
out.push(intrare(`ecs:${ultimul(t.clusterArn)}/${ultimul(t.taskArn)}/${c.name}`, c.imageDigest || c.image, d));
}
}
return out;
}
/** `aws ec2 describe-instances` */
export function descrieAwsEc2(j) {
if (!(!!j && !Array.isArray(j) && Array.isArray(j.Reservations) /*FORMA:aws-ec2*/)) throw new Error('aws-ec2: the input is not the output of `aws ec2 describe-instances` (an object with Reservations[])');
const out = [];
for (const r of j.Reservations) for (const i of r?.Instances || []) {
if (!(!!i && i.State?.Name === 'running' /*RULEAZA:aws-ec2*/)) continue;
const zona = i.Placement?.AvailabilityZone || null; const region = zona ? zona.replace(/[a-z]$/, '') : null;
// userData nu e in describe-instances si nu se cere; valorile etichetelor nu intra (o eticheta poate purta orice)
const d = {
runtime: 'aws-ec2', region, availabilityZone: zona, instanceId: i.InstanceId || null, imageId: i.ImageId || null, imageIdentity: 'declared',
instanceType: i.InstanceType || null, architecture: i.Architecture || null, platformDetails: i.PlatformDetails || null, virtualizationType: i.VirtualizationType || null,
bootMode: i.BootMode || null, launchTime: i.LaunchTime || null, iamInstanceProfileArn: i.IamInstanceProfile?.Arn || null, rootDeviceType: i.RootDeviceType || null,
imdsV2Required: i.MetadataOptions ? i.MetadataOptions.HttpTokens === 'required' : null, tagKeys: numeDin(i.Tags, 'Key' /*NUME:aws-ec2*/),
};
out.push(intrare(`ec2:${region}/${i.InstanceId}`, i.ImageId, d));
}
return out;
}
/** `aws lambda list-functions`: list-functions nu intoarce State (nota din documentatia lui); o functie e inregistrata ca desfasurata,
* cu `state: 'not-in-export'`; daca exportul poarta State (get-function-configuration), numai `Active` intra */
export function descrieAwsLambda(j) {
if (!(!!j && !Array.isArray(j) && Array.isArray(j.Functions) /*FORMA:aws-lambda*/)) throw new Error('aws-lambda: the input is not the output of `aws lambda list-functions` (an object with Functions[])');
const out = [];
for (const f of j.Functions) {
if (!(!!f && (f.State === undefined || f.State === 'Active') /*RULEAZA:aws-lambda*/)) continue;
const region = String(f.FunctionArn || '').split(':')[3] || null;
const d = {
runtime: 'aws-lambda', region, functionArn: f.FunctionArn || null, functionName: f.FunctionName || null, packageType: f.PackageType || 'Zip',
functionRuntime: f.Runtime || null, handler: f.Handler || null, codeSha256: f.CodeSha256 || null, imageIdentity: f.CodeSha256 ? 'codeSha256' : 'declared',
codeSize: f.CodeSize ?? null, lastModified: f.LastModified || null, functionVersion: f.Version || null, revisionId: f.RevisionId || null,
architectures: [...(f.Architectures || [])].sort(), layers: numeDin(f.Layers, 'Arn'), state: f.State ?? 'not-in-export',
envNames: Object.keys(f.Environment?.Variables || {}).sort() /*NUME:aws-lambda*/,
};
out.push(intrare(`lambda:${region}/${f.FunctionName}`, f.CodeSha256, d));
}
return out;
}
/** `az vm list -d` (--show-details adauga powerState; fara el exportul nu spune daca masina merge, si e refuzat) */
export function descrieAzureVm(j) {
if (!(Array.isArray(j) && j.every((v) => v && typeof v.id === 'string' && /\/providers\/Microsoft\.Compute\/virtualMachines\//i.test(v.id)) /*FORMA:azure-vm*/)) throw new Error('azure-vm: the input is not the output of `az vm list -d` (an array of Microsoft.Compute/virtualMachines resources)');
const vms = j.map(aplatizat);
if (!(vms.length === 0 || vms.some((v) => typeof v.powerState === 'string') /*FORMA:azure-vm-d*/)) throw new Error('azure-vm: the export has no powerState: run `az vm list -d` (--show-details), which adds the power state of each machine');
const out = [];
for (const v of vms) {
if (!(v.powerState === 'VM running' /*RULEAZA:azure-vm*/)) continue;
const ir = v.storageProfile?.imageReference || {}; const rg = v.resourceGroup || grupulDin(v.id);
// customData, userData, adminUsername, cheile ssh, adresele: nu se copiaza; etichetele intra numai cu numele
const d = {
runtime: 'azure-vm', id: v.id, name: v.name || null, resourceGroup: rg, location: v.location || null, zones: [...(v.zones || [])].sort(), vmId: v.vmId || null,
vmSize: v.hardwareProfile?.vmSize || null,
imageReference: Object.fromEntries(['publisher', 'offer', 'sku', 'version', 'exactVersion', 'id', 'sharedGalleryImageId', 'communityGalleryImageId'].filter((k) => ir[k] != null).map((k) => [k, ir[k]])),
imageIdentity: 'declared', osType: v.storageProfile?.osDisk?.osType || null, computerName: v.osProfile?.computerName || null,
provisioningState: v.provisioningState || null, powerState: v.powerState, timeCreated: v.timeCreated || null, tagKeys: Object.keys(v.tags || {}).sort() /*NUME:azure-vm*/,
};
out.push(intrare(`azvm:${rg}/${v.name}`, ir.exactVersion || ir.version || ir.id, d));
}
return out;
}
/** `az container list` / `az container show` (Azure Container Instances): starea fiecarui container e in instanceView.currentState */
export function descrieAzureContainer(j) {
if (!(Array.isArray(j) && j.every((g) => g && typeof g.id === 'string' && /\/providers\/Microsoft\.ContainerInstance\/containerGroups\//i.test(g.id)) /*FORMA:azure-container*/)) throw new Error('azure-container: the input is not the output of `az container list` or `az container show` (an array of Microsoft.ContainerInstance/containerGroups resources)');
const out = []; let cuStare = 0;
for (const g0 of j) {
const g = aplatizat(g0); const rg = g.resourceGroup || grupulDin(g.id);
for (const c0 of g.containers || []) {
const c = aplatizat(c0); const st = c.instanceView?.currentState || null; if (st) cuStare++;
if (!(!!st && st.state === 'Running' /*RULEAZA:azure-container*/)) continue;
// environmentVariables intra cu numele (value si secureValue nu), imageRegistryCredentials nu intra deloc
const d = {
runtime: 'azure-container', groupId: g.id, group: g.name || null, resourceGroup: rg, location: g.location || null, zones: [...(g.zones || [])].sort(), osType: g.osType || null,
provisioningState: g.provisioningState || null, container: c.name || null, image: c.image || null, imageDigest: digestDinImagine(c.image), imageIdentity: digestDinImagine(c.image) ? 'digest' : 'declared',
commandSha256: sha256(Buffer.from(JSON.stringify(c.command || []), 'utf8')), envNames: numeDin(c.environmentVariables /*NUME:azure-container*/),
mounts: (c.volumeMounts || []).map((m) => m && m.mountPath).filter(Boolean).sort(), startedAt: st.startTime || null, restartCount: c.instanceView?.restartCount ?? null,
};
out.push(intrare(`aci:${rg}/${g.name}/${c.name}`, digestDinImagine(c.image) || c.image, d));
}
}
if (j.length && cuStare === 0) throw new Error('azure-container: no container in the export carries instanceView.currentState (`az container list` may omit it): collect `az container show -g <group> -n <name> -o json` outputs into a JSON array');
return out;
}
/** `az containerapp list` (Azure Container Apps): runningStatus e al aplicatiei; numai `Running` intra (Progressing, Stopped, Suspended
* si `Ready`, pe care specificatia il enumera fara sa il defineasca, nu); initContainers nu intra (nu ruleaza continuu) */
export function descrieAzureContainerApp(j) {
if (!(Array.isArray(j) && j.every((a) => a && typeof a.id === 'string' && /\/providers\/Microsoft\.App\/containerApps\//i.test(a.id)) /*FORMA:azure-containerapp*/)) throw new Error('azure-containerapp: the input is not the output of `az containerapp list` (an array of Microsoft.App/containerApps resources)');
const out = [];
for (const a0 of j) {
const a = aplatizat(a0);
if (!(a.runningStatus === 'Running' /*RULEAZA:azure-containerapp*/)) continue;
const rg = a.resourceGroup || grupulDin(a.id);
for (const c of a.template?.containers || []) {
if (!c) continue;
// env intra cu numele; secretRef e numele unui secret, nu valoarea lui; configuration.secrets nu se citeste deloc
const d = {
runtime: 'azure-containerapp', appId: a.id, app: a.name || null, resourceGroup: rg, location: a.location || null, environmentId: a.environmentId || a.managedEnvironmentId || null,
provisioningState: a.provisioningState || null, runningStatus: a.runningStatus, latestReadyRevisionName: a.latestReadyRevisionName || null, latestRevisionName: a.latestRevisionName || null,
workloadProfileName: a.workloadProfileName || null, container: c.name || null, image: c.image || null, imageDigest: digestDinImagine(c.image), imageIdentity: digestDinImagine(c.image) ? 'digest' : 'declared',
commandSha256: sha256(Buffer.from(JSON.stringify([...(c.command || []), ...(c.args || [])]), 'utf8')), envNames: numeDin(c.env /*NUME:azure-containerapp*/), envSecretRefs: numeDin(c.env, 'secretRef'),
mounts: (c.volumeMounts || []).map((m) => m && m.mountPath).filter(Boolean).sort(),
};
out.push(intrare(`aca:${rg}/${a.name}/${c.name}`, digestDinImagine(c.image) || c.image, d));
}
}
return out;
}
/** `az webapp list --show-details` (App Service): state e al sitului; runtime-ul e linuxFxVersion/windowsFxVersion (DOCKER|imagine
* pentru un container); appSettings si connectionStrings intra numai cu numele (API-ul le ascunde oricum la citirile obisnuite) */
export function descrieAzureWebapp(j) {
if (!(Array.isArray(j) && j.every((s) => s && typeof s.id === 'string' && /\/providers\/Microsoft\.Web\/sites\//i.test(s.id)) /*FORMA:azure-webapp*/)) throw new Error('azure-webapp: the input is not the output of `az webapp list --show-details` (an array of Microsoft.Web/sites resources)');
const out = [];
for (const s0 of j) {
const s = aplatizat(s0);
if (!(s.state === 'Running' /*RULEAZA:azure-webapp*/)) continue;
const rg = s.resourceGroup || grupulDin(s.id); const sc = s.siteConfig && typeof s.siteConfig === 'object' ? s.siteConfig : null;
const fx = sc?.linuxFxVersion || sc?.windowsFxVersion || null; const m = /^DOCKER\|(.+)$/i.exec(fx || ''); const image = m ? m[1] : null;
const d = {
runtime: 'azure-webapp', id: s.id, name: s.name || null, resourceGroup: rg, location: s.location || null, kind: s.kind || null, state: s.state, defaultHostName: s.defaultHostName || null,
fxVersion: fx, image, imageDigest: digestDinImagine(image), imageIdentity: digestDinImagine(image) ? 'digest' : fx ? 'declared' : 'not-in-export',
lastModifiedTimeUtc: s.lastModifiedTimeUtc || null, httpsOnly: s.httpsOnly ?? null, minTlsVersion: sc?.minTlsVersion || null, siteConfigInExport: !!sc,
appSettingNames: numeDin(sc?.appSettings /*NUME:azure-webapp*/), connectionStringNames: numeDin(sc?.connectionStrings),
};
out.push(intrare(`azwebapp:${rg}/${s.name}`, digestDinImagine(image) || image || fx, d));
}
return out;
}
/** `gcloud compute instances list --format=json`: metadata.items intra numai cu cheile (startup-script, user-data, ssh-keys stau acolo) */
export function descrieGcpCompute(j) {
if (!(Array.isArray(j) && j.every((i) => i && i.kind === 'compute#instance') /*FORMA:gcp-compute*/)) throw new Error('gcp-compute: the input is not the output of `gcloud compute instances list --format=json` (an array of compute#instance resources)');
const out = [];
for (const i of j) {
if (!(i.status === 'RUNNING' /*RULEAZA:gcp-compute*/)) continue;
const boot = (i.disks || []).find((d) => d && d.boot) || null; const zona = ultimul(i.zone);
const d = {
runtime: 'gcp-compute', id: i.id != null ? String(i.id) : null, name: i.name || null, zone: zona, machineType: ultimul(i.machineType), status: i.status, cpuPlatform: i.cpuPlatform || null,
creationTimestamp: i.creationTimestamp || null, lastStartTimestamp: i.lastStartTimestamp || null,
bootDisk: boot ? { source: ultimul(boot.source), licenses: (boot.licenses || []).map(ultimul).filter(Boolean).sort(), architecture: boot.architecture || null, diskSizeGb: boot.diskSizeGb ?? null } : null,
imageIdentity: 'declared', serviceAccounts: numeDin(i.serviceAccounts, 'email'), labelKeys: Object.keys(i.labels || {}).sort(), metadataKeys: numeDin(i.metadata?.items, 'key' /*NUME:gcp-compute*/),
selfLink: i.selfLink || null,
};
out.push(intrare(`gce:${zona}/${i.name}`, i.id != null ? String(i.id) : null, d));
}
return out;
}
/** `gcloud run services list --format=json` (Knative Service, Cloud Run Admin API v1): ruleaza = conditia Ready e True */
export function descrieGcpRun(j) {
if (!(Array.isArray(j) && j.every((s) => s && s.apiVersion === 'serving.knative.dev/v1' && s.kind === 'Service') /*FORMA:gcp-run*/)) throw new Error('gcp-run: the input is not the output of `gcloud run services list --format=json` (an array of serving.knative.dev/v1 Service resources)');
const out = [];
for (const s of j) {
const ready = (s.status?.conditions || []).find((c) => c && c.type === 'Ready') || null;
if (!(!!ready && ready.status === 'True' /*RULEAZA:gcp-run*/)) continue;
const md = s.metadata || {}; const region = md.labels?.['cloud.googleapis.com/location'] || null; const spec = s.spec?.template?.spec || {};
(spec.containers || []).forEach((c, idx) => {
if (!c) return;
const nume = c.name || `container-${idx}`;
// env intra cu numele; value si valueFrom (referinta la Secret Manager) nu
const d = {
runtime: 'gcp-run', service: md.name || null, namespace: md.namespace || null, region, uid: md.uid || null, generation: md.generation ?? null, observedGeneration: s.status?.observedGeneration ?? null,
latestReadyRevisionName: s.status?.latestReadyRevisionName || null, latestCreatedRevisionName: s.status?.latestCreatedRevisionName || null, url: s.status?.url || null,
serviceAccountName: spec.serviceAccountName || null, container: nume, image: c.image || null, imageDigest: digestDinImagine(c.image), imageIdentity: digestDinImagine(c.image) ? 'digest' : 'declared',
commandSha256: sha256(Buffer.from(JSON.stringify([...(c.command || []), ...(c.args || [])]), 'utf8')), envNames: numeDin(c.env /*NUME:gcp-run*/),
mounts: (c.volumeMounts || []).map((m) => m && m.mountPath).filter(Boolean).sort(), readySince: ready.lastTransitionTime || null,
};
out.push(intrare(`run:${region}/${md.name}/${nume}`, digestDinImagine(c.image) || s.status?.latestReadyRevisionName || c.image, d));
});
}
return out;
}
/** sursa -> adaptor; `aws-ecs` primeste si definitiile de task (optional) */
export const ADAPTOARE = {
docker: descrieDocker, kubernetes: descrieKubernetes,
'aws-ecs': descrieAwsEcs, 'aws-ec2': descrieAwsEc2, 'aws-lambda': descrieAwsLambda,
'azure-vm': descrieAzureVm, 'azure-container': descrieAzureContainer, 'azure-containerapp': descrieAzureContainerApp, 'azure-webapp': descrieAzureWebapp,
'gcp-compute': descrieGcpCompute, 'gcp-run': descrieGcpRun,
};
// ---- scrierea: un singur scriitor odata ----------------------------------------------------------------------------------------
// Doi scriitori fara lacat citeau aceeasi lungime si scriau acelasi seq: lantul se rupea, si de atunci ORICE adaugare era refuzata
// (revizuirea adversariala 2026-09-29, masurat: doi scriitori concurenti rup lantul). Lacatul e un fisier creat exclusiv langa
@@ -277,13 +517,14 @@ async function main() {
}
case 'scan': {
const src = get('--source'); const f = get('--input');
if (!['docker', 'kubernetes'].includes(src) || !f) { console.error('scan --source docker|kubernetes --input <export.json>'); return 2; }
if (!ADAPTOARE[src] || !f) { console.error(`scan --source ${Object.keys(ADAPTOARE).join('|')} --input <export.json> [--task-definitions <describe-task-definition.json>]`); return 2; }
let desc;
try {
const j = JSON.parse(fs.readFileSync(f, 'utf8'));
desc = src === 'docker' ? descrieDocker(j) : descrieKubernetes(j);
const td = get('--task-definitions');
desc = src === 'aws-ecs' ? descrieAwsEcs(j, td ? JSON.parse(fs.readFileSync(td, 'utf8')) : null) : ADAPTOARE[src](j);
} catch (e) { console.error('scan: ' + e.message); return 2; }
if (desc.length === 0) { console.error('scan: no running container in the export; a zero is not recorded'); return 2; }
if (desc.length === 0) { console.error('scan: no running workload (container, task, instance, function or service) in the export; a zero is not recorded'); return 2; }
// plicul 'data' poarta numai digestul descriptorului; descriptorul insusi (fara valori de mediu, prin constructie) sta
// alaturi, ca un auditor sa il poata re-hasha si compara cu plicul din lant; scris sub acelasi lacat
const desFile = get('--descriptors', log + '.descriptori.jsonl');
@@ -293,7 +534,7 @@ async function main() {
fs.appendFileSync(desFile, JSON.stringify({ seq: r.seq, name: d.name, sha256: sha256(d.content), descriptor: JSON.parse(d.content.toString('utf8')) }) + '\n');
console.log(`recorded seq=${r.seq} ${d.name} ${String(d.version || '?').slice(0, 19)}`);
});
console.log(`scan ${src}: ${desc.length} running containers, ${desc.length} envelopes in ${log}, descriptors in ${desFile}`);
console.log(`scan ${src}: ${desc.length} running ${['docker', 'kubernetes'].includes(src) ? 'containers' : 'workloads'}, ${desc.length} envelopes in ${log}, descriptors in ${desFile}`);
return 0;
}
case 'verify-log': {