The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
import { createHash } from 'node:crypto'
import { execFile } from 'node:child_process'
import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { promisify } from 'node:util'
import { readSecurityDirectory } from './sanitize-pe-signatures.mjs'
const exec = promisify(execFile)
const sha256 = bytes => createHash('sha256').update(bytes).digest('hex')
// Only checksum, security-directory entry and a trailing certificate can change.
// Keep every other byte, including overlays. Unknown layouts are not cacheable.
export function peContentHash(file) {
const entry = readSecurityDirectory(file)
if (!entry) return null
const bytes = fs.readFileSync(file)
const pe = bytes.readUInt32LE(0x3c)
const checksum = pe + 24 + 64
if (checksum + 4 > entry.offsetInFile) return null
let end = bytes.length
if (entry.certSize || entry.certOffset) {
if (!entry.certSize || entry.certOffset < entry.offsetInFile + 8 ||
entry.certOffset % 8 || entry.certOffset + entry.certSize !== bytes.length) return null
end = entry.certOffset
}
const content = Buffer.from(bytes.subarray(0, end))
content.fill(0, checksum, checksum + 4)
content.fill(0, entry.offsetInFile, entry.offsetInFile + 8)
const hash = createHash('sha256').update(content)
// Signing aligns the certificate table to eight bytes.
hash.update(Buffer.alloc((8 - content.length % 8) % 8))
return hash.digest('hex')
}
export async function verifySignedPayloads(files, publisher, signtool = '') {
if (!files.length) return new Set()
const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'verify-signatures-'))
try {
const manifest = path.join(temp, 'files.json')
fs.writeFileSync(manifest, JSON.stringify(files.map(file => ({ path: file, publisher }))))
const { stdout } = await exec('powershell.exe', [
'-NoProfile', '-NonInteractive', '-File',
path.join(import.meta.dirname, 'verify-signed-payloads.ps1'), manifest,
...(signtool ? ['-SignTool', signtool] : [])
], { windowsHide: true, timeout: 600000, maxBuffer: 4 * 1024 * 1024 })
const results = JSON.parse(stdout.replace(/^\uFEFF/, ''))
if (!Array.isArray(results) || results.length !== files.length ||
results.some((r, i) => r.path !== files[i] || typeof r.valid !== 'boolean')) {
throw new Error('Invalid Authenticode verification response')
}
return new Set(results.filter(r => r.valid).map(r => r.path))
} finally {
fs.rmSync(temp, { recursive: true, force: true })
}
}
export function createPayloadSignCache({ root, env, signtool, dlib, timestampUrl, verify = verifySignedPayloads }) {
const publisher = env.AZURE_SIGN_PUBLISHER
if (!root || !publisher) return null
const policy = sha256(JSON.stringify({
schema: 1, endpoint: env.AZURE_SIGN_ENDPOINT, account: env.AZURE_SIGN_ACCOUNT,
profile: env.AZURE_SIGN_PROFILE, publisher, timestampUrl,
digest: 'SHA256', timestampDigest: 'SHA256',
signtool: sha256(fs.readFileSync(signtool)), dlib: sha256(fs.readFileSync(dlib))
}))
const directory = path.join(root, policy)
const entryPath = key => path.join(directory, key)
return {
async prepare(files) {
const groups = new Map()
const uncached = []
for (const file of files) {
const content = peContentHash(file)
if (!content) { uncached.push(file); continue }
const key = sha256(fs.readFileSync(file))
if (groups.has(key)) groups.get(key).files.push(file)
else groups.set(key, { key, content, files: [file] })
}
const candidates = []
for (const group of groups.values()) {
const entry = entryPath(group.key)
if (!fs.existsSync(entry)) continue
try {
const receipt = JSON.parse(fs.readFileSync(path.join(entry, 'receipt.json'), 'utf8'))
const binary = path.join(entry, 'signed.exe')
if (receipt.signedHash !== sha256(fs.readFileSync(binary)) || peContentHash(binary) !== group.content) {
throw new Error('Cache content mismatch')
}
candidates.push({ group, binary })
} catch {
fs.rmSync(entry, { recursive: true, force: true })
}
}
const valid = await verify(candidates.map(c => c.binary), publisher, signtool)
let restored = 0
for (const { group, binary } of candidates) {
if (!valid.has(binary)) {
fs.rmSync(entryPath(group.key), { recursive: true, force: true })
continue
}
for (const file of group.files) fs.copyFileSync(binary, file)
restored += group.files.length
groups.delete(group.key)
}
const pending = [...groups.values()]
return {
files: [...uncached, ...pending.map(g => g.files[0])],
pending, restored,
duplicates: pending.reduce((n, g) => n + g.files.length - 1, 0)
}
},
async publish(plan) {
const files = plan.pending.map(g => g.files[0])
const valid = await verify(files, publisher, signtool)
for (const group of plan.pending) {
const file = group.files[0]
if (!valid.has(file) || peContentHash(file) !== group.content) {
throw new Error(`Signed payload failed verification: ${file}`)
}
const signed = fs.readFileSync(file)
fs.mkdirSync(directory, { recursive: true })
const temp = fs.mkdtempSync(path.join(directory, '.tmp-'))
try {
fs.writeFileSync(path.join(temp, 'signed.exe'), signed)
fs.writeFileSync(path.join(temp, 'receipt.json'), JSON.stringify({ signedHash: sha256(signed) }))
const dest = entryPath(group.key)
// A complete entry appears in one rename, never a half-written pair.
if (!fs.existsSync(dest)) fs.renameSync(temp, dest)
} finally {
fs.rmSync(temp, { recursive: true, force: true })
}
for (const duplicate of group.files.slice(1)) fs.copyFileSync(file, duplicate)
}
}
}
}