@rightkit/release 0.2.74 → 0.2.75

package/direct-bootstrap.mjs

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
-import { RIGHTRELEASE_MANIFEST_SIGNER, signReleaseManifestWithAzure } from "./sign-release-manifest.mjs";
+import { RIGHTRELEASE_MANIFEST_SIGNER, signReleaseManifestCatalogWithAzure } from "./sign-release-manifest.mjs";
 import { validateCycloneDxSbom, validateInTotoSlsaProvenance } from "./supply-chain-evidence.mjs";
 
 const SHA256 = /^[a-f0-9]{64}$/;
@@ -145,8 +145,6 @@ export function buildReleaseManifest({
     minimumBootstrapVersion,
     signingKeyId: RIGHTRELEASE_MANIFEST_SIGNER.id,
     signatureAlgorithm: RIGHTRELEASE_MANIFEST_SIGNER.algorithm,
-    signatureProvider: RIGHTRELEASE_MANIFEST_SIGNER.provider,
-    signatureProviderVersion: RIGHTRELEASE_MANIFEST_SIGNER.providerVersion,
     checksumsSha256: checksumsDigest,
     assets: normalizedAssets,
   };
@@ -164,14 +162,14 @@ export function materializeDirectRelease({ outputDir, manifestInput }) {
   });
   const manifestText = `${canonicalJson(manifest)}\n`;
   const manifestPath = join(outputDir, "release-manifest.json");
-  const signaturePath = join(outputDir, "release-manifest.cat");
+  const catalogPath = join(outputDir, "release-manifest.cat");
   writeFileSync(manifestPath, manifestText);
-  const signing = signReleaseManifestWithAzure({ manifestPath, signaturePath });
-  if (!statSync(signaturePath).isFile() || statSync(signaturePath).size < 1) throw new Error("detached release manifest signature is missing");
+  const signing = signReleaseManifestCatalogWithAzure({ manifestPath, catalogPath });
+  if (!statSync(catalogPath).isFile() || statSync(catalogPath).size < 1) throw new Error("release manifest catalog is missing");
   if (signing?.signer?.id !== RIGHTRELEASE_MANIFEST_SIGNER.id || signing.signer.subject !== RIGHTRELEASE_MANIFEST_SIGNER.subject || !/^[a-f0-9]{64}$/.test(signing.signer.certificateSha256 ?? "")) {
-    throw new Error("detached release manifest signer is not RightRelease Azure authority");
+    throw new Error("release manifest catalog signer is not RightRelease Azure authority");
   }
-  return { manifest, manifestPath, signaturePath, signing, checksums };
+  return { manifest, manifestPath, catalogPath, signaturePath: catalogPath, signing, checksums };
 }
 
 function psQuote(value) {
@@ -239,8 +237,7 @@ export function renderPowerShellBootstrap({
   };
   // Bind generated contract metadata so a caller cannot pass a marker plus an
   // arbitrary base64 payload and have it treated as a RightRelease bootstrap.
-  // This is not a replacement for manifest catalog signing; it is a structural
-  // integrity fence for the executable bootstrap source itself.
+  // This is a structural integrity fence for the executable bootstrap source itself.
   contract.contractSha256 = createHash("sha256").update(canonicalJson(contract)).digest("hex");
   const contractB64 = Buffer.from(JSON.stringify(contract)).toString("base64");
   const lines = [
@@ -269,18 +266,18 @@ export function renderPowerShellBootstrap({
     "$ReleaseBase = " + psQuote("https://github.com/" + repository + "/releases/download/v") + " + $Version",
     "$Work = Join-Path ([IO.Path]::GetTempPath()) (" + psQuote(product + "-install-") + " + [guid]::NewGuid())",
     "New-Item -ItemType Directory -Force -Path $Work | Out-Null",
-    "$ManifestPath = Join-Path $Work 'release-manifest.json'; $SignaturePath = Join-Path $Work 'release-manifest.cat'; $ChecksumsPath = Join-Path $Work 'checksums.json'",
+    "$ManifestPath = Join-Path $Work 'release-manifest.json'; $CatalogPath = Join-Path $Work 'release-manifest.cat'; $ChecksumsPath = Join-Path $Work 'checksums.json'",
     "Invoke-WebRequest ($ReleaseBase + '/release-manifest.json') -OutFile $ManifestPath",
-    "Invoke-WebRequest ($ReleaseBase + '/release-manifest.cat') -OutFile $SignaturePath",
-    "$ManifestBytes = [IO.File]::ReadAllBytes($ManifestPath); Import-Module Microsoft.PowerShell.Security -ErrorAction Stop",
-    "$Catalog = Test-FileCatalog -CatalogFilePath $SignaturePath -Path $ManifestPath -Detailed; if ([string]$Catalog.Status -ne 'Valid') { throw 'Release manifest catalog binding is invalid' }",
-    "$CatalogSignature = Get-AuthenticodeSignature -FilePath $SignaturePath; if ([string]$CatalogSignature.Status -ne 'Valid' -or -not $CatalogSignature.SignerCertificate) { throw 'Release manifest signature is invalid' }; $SignerCertificate = $CatalogSignature.SignerCertificate",
-    "$SignerSubject = 'CN=' + $SignerCertificate.GetNameInfo([Security.Cryptography.X509Certificates.X509NameType]::SimpleName, $false)",
+    "Invoke-WebRequest ($ReleaseBase + '/release-manifest.cat') -OutFile $CatalogPath",
+    "$ManifestBytes = [IO.File]::ReadAllBytes($ManifestPath)",
+    "$CatalogSignature = Get-AuthenticodeSignature -FilePath $CatalogPath; if ($CatalogSignature.Status -ne 'Valid' -or $null -eq $CatalogSignature.SignerCertificate) { throw 'Release manifest catalog signature is invalid' }; $SignerCertificate = $CatalogSignature.SignerCertificate",
+    "$ManifestCatalogRoot = Join-Path $Work 'manifest-catalog'; New-Item -ItemType Directory -Force -Path $ManifestCatalogRoot | Out-Null; Copy-Item -LiteralPath $ManifestPath -Destination (Join-Path $ManifestCatalogRoot 'release-manifest.json')",
+    "$CatalogValidation = Test-FileCatalog -Path $ManifestCatalogRoot -CatalogFilePath $CatalogPath; if ([string]$CatalogValidation -ne 'Valid') { throw 'Release manifest catalog does not bind exact bytes' }",
     "$Sha256 = [Security.Cryptography.SHA256]::Create(); try { $SignerFingerprint = ([BitConverter]::ToString($Sha256.ComputeHash($SignerCertificate.RawData))).Replace('-','').ToLowerInvariant() } finally { $Sha256.Dispose() }",
-    "$VerifiedKeyId = $null; foreach ($KeyId in $AcceptedSigners.Keys) { $Accepted = $AcceptedSigners[$KeyId]; if ($SignerSubject -eq [string]$Accepted.subject -and $SignerFingerprint -eq [string]$Accepted.certificateSha256) { $VerifiedKeyId = $KeyId; break } }",
+    "$VerifiedKeyId = $null; foreach ($KeyId in $AcceptedSigners.Keys) { $Accepted = $AcceptedSigners[$KeyId]; if ($SignerCertificate.Subject -eq [string]$Accepted.subject -and $SignerFingerprint -eq [string]$Accepted.certificateSha256) { $VerifiedKeyId = $KeyId; break } }",
     "if (-not $VerifiedKeyId) { throw 'Release manifest signer is not accepted' }",
     "$Manifest = [Text.Encoding]::UTF8.GetString($ManifestBytes) | ConvertFrom-Json",
-    "if ($Manifest.signingKeyId -ne $VerifiedKeyId -or $Manifest.signatureAlgorithm -ne 'authenticode-catalog-sha256' -or $Manifest.signatureProvider -ne 'windows-authenticode-catalog' -or $Manifest.signatureProviderVersion -ne 1) { throw 'Release manifest signer identity mismatch' }",
+    "if ($Manifest.signingKeyId -ne $VerifiedKeyId -or $Manifest.signatureAlgorithm -ne 'authenticode-catalog-sha256') { throw 'Release manifest signer identity mismatch' }",
     "if ($Manifest.product -ne " + psQuote(product) + " -or $Manifest.version -ne $Version -or $Manifest.tag -ne ('v' + $Version)) { throw 'Release identity mismatch' }",
     "if ([version]$Contract.bootstrapVersion -lt [version]$Manifest.minimumBootstrapVersion) { throw 'Bootstrap update required' }",
     "$Machine = [Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString(); $Target = if ($Machine -eq 'Arm64') { 'windows-arm64' } elseif ($Machine -eq 'X64') { 'windows-x86_64' } else { throw ('Unsupported architecture: ' + $Machine) }",
@@ -337,10 +334,9 @@ export function renderPowerShellBootstrap({
 export function validatePowerShellBootstrap(script, expected = {}) {
   const required = [
     "# rightkit-direct-bootstrap:v1",
-    "Release manifest signature is invalid",
+    "Release manifest catalog signature is invalid",
     "certificateSha256",
     "Test-FileCatalog",
-    "Get-AuthenticodeSignature",
     "checksums.json is not manifest-bound",
     "Provenance checksum mismatch",
     "SBOM checksum mismatch",

package/github-release.mjs

@@ -6,7 +6,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { verifySealedRelease } from "./release-state.mjs";
 import { addonManifestSha256, validateAddonConfig, validateAddonManifest } from "./addon-contract.mjs";
-import { RIGHTRELEASE_MANIFEST_SIGNER, verifyManifestCatalogSignature } from "./sign-release-manifest.mjs";
+import { RIGHTRELEASE_MANIFEST_SIGNER, verifyReleaseManifestCatalog } from "./sign-release-manifest.mjs";
 
 const REPO_RE = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
 const RELEASE_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,159}$/;
@@ -68,13 +68,9 @@ export function prepareGitHubDirectRelease({
   signing,
   signingResult,
   signer,
-  signatureCommandRunner,
-  signaturePlatform,
-  cmsCommandRunner,
-  cmsPlatform,
+  catalogCommandRunner = spawnSync,
+  catalogPlatform = process.platform,
 }) {
-  const effectiveSignatureRunner = signatureCommandRunner ?? cmsCommandRunner ?? spawnSync;
-  const effectiveSignaturePlatform = signaturePlatform ?? cmsPlatform ?? process.platform;
   if (!REPO_RE.test(repo)) throw new Error(`invalid GitHub repository: ${repo}`);
   const root = path.resolve(repoRoot ?? process.cwd());
   const manifestFile = path.resolve(root, manifestPath);
@@ -88,7 +84,7 @@ export function prepareGitHubDirectRelease({
   if (product && manifest.product !== product) throw new Error("direct release product mismatch");
   if (version && manifest.version !== version) throw new Error("direct release version mismatch");
   if (!STABLE_SEMVER_RE.test(manifest.version) || manifest.tag !== `v${manifest.version}`) throw new Error("direct release manifest tag is invalid stable SemVer");
-  if (manifest.signingKeyId !== RIGHTRELEASE_MANIFEST_SIGNER.id || manifest.signatureAlgorithm !== RIGHTRELEASE_MANIFEST_SIGNER.algorithm || manifest.signatureProvider !== RIGHTRELEASE_MANIFEST_SIGNER.provider || manifest.signatureProviderVersion !== RIGHTRELEASE_MANIFEST_SIGNER.providerVersion) throw new Error("direct release manifest signer contract is invalid");
+  if (manifest.signingKeyId !== RIGHTRELEASE_MANIFEST_SIGNER.id || manifest.signatureAlgorithm !== RIGHTRELEASE_MANIFEST_SIGNER.algorithm) throw new Error("direct release manifest signer contract is invalid");
   const declared = new Set((manifest.assets ?? []).map((asset) => asset.name));
   if (!declared.size) throw new Error("direct release manifest has no archive assets");
   if ([...declared].some((name) => /(?:installer|setup)\.(?:exe|dmg|pkg|msi)$/i.test(name))) throw new Error("direct release must not contain installer assets");
@@ -128,10 +124,10 @@ export function prepareGitHubDirectRelease({
     notesFile,
     manifestUrl: `https://github.com/${repo}/releases/download/${manifest.tag}/${path.basename(manifestFile)}`,
     signer: expectedSigner,
-    signaturePlatform: effectiveSignaturePlatform,
+    catalogPlatform,
   };
-  Object.defineProperty(plan, "signatureCommandRunner", { value: effectiveSignatureRunner, enumerable: false });
-  validateGitHubDirectReleasePlan(plan, { commandRunner: effectiveSignatureRunner, platform: effectiveSignaturePlatform });
+  Object.defineProperty(plan, "catalogCommandRunner", { value: catalogCommandRunner, enumerable: false });
+  validateGitHubDirectReleasePlan(plan, { commandRunner: catalogCommandRunner, platform: catalogPlatform });
   return plan;
 }
 
@@ -143,7 +139,7 @@ export const prepareGitHubManifestRelease = prepareGitHubDirectRelease;
  * signed manifest remains authority; checksums.json is only a digest-bound
  * convenience index for archives and attached provenance/SBOM evidence.
  */
-export function validateGitHubDirectReleasePlan(plan, { commandRunner = plan?.signatureCommandRunner ?? plan?.cmsCommandRunner ?? spawnSync, platform = plan?.signaturePlatform ?? plan?.cmsPlatform ?? process.platform } = {}) {
+export function validateGitHubDirectReleasePlan(plan, { commandRunner = plan?.catalogCommandRunner ?? spawnSync, platform = plan?.catalogPlatform ?? process.platform } = {}) {
   if (!plan || plan.kind !== "direct-release") throw new Error("invalid direct GitHub release plan");
   if (!plan.manifestPath || !plan.signaturePath || !plan.checksumsPath || !Array.isArray(plan.assets)) throw new Error("direct GitHub release plan is incomplete");
   const manifestFile = path.resolve(plan.manifestPath);
@@ -152,14 +148,14 @@ export function validateGitHubDirectReleasePlan(plan, { commandRunner = plan?.si
   for (const file of [manifestFile, signatureFile, checksumsFile]) {
     if (!existsSync(file) || !statSync(file).isFile()) throw new Error(`direct release payload missing: ${file}`);
   }
-  if (statSync(signatureFile).size < 1) throw new Error("detached release manifest signature is missing");
+  if (statSync(signatureFile).size < 1) throw new Error("release manifest catalog is missing");
   const manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
   if (manifest.schemaVersion !== 1 || manifest.kind !== "rightkit-direct-release-manifest" || !STABLE_SEMVER_RE.test(manifest.version ?? "") || manifest.tag !== `v${manifest.version}`) {
     throw new Error("invalid direct release manifest");
   }
   if (plan.tag !== manifest.tag) throw new Error("direct GitHub release tag does not match manifest");
-  if (manifest.signingKeyId !== RIGHTRELEASE_MANIFEST_SIGNER.id || manifest.signatureAlgorithm !== RIGHTRELEASE_MANIFEST_SIGNER.algorithm || manifest.signatureProvider !== RIGHTRELEASE_MANIFEST_SIGNER.provider || manifest.signatureProviderVersion !== RIGHTRELEASE_MANIFEST_SIGNER.providerVersion) throw new Error("direct release manifest signer contract is invalid");
-  verifyManifestCatalogSignature({ manifestPath: manifestFile, signaturePath: signatureFile, expectedSigner: plan.signer, commandRunner, platform });
+  if (manifest.signingKeyId !== RIGHTRELEASE_MANIFEST_SIGNER.id || manifest.signatureAlgorithm !== RIGHTRELEASE_MANIFEST_SIGNER.algorithm) throw new Error("direct release manifest signer contract is invalid");
+  verifyReleaseManifestCatalog({ manifestPath: manifestFile, catalogPath: signatureFile, expectedSigner: plan.signer, commandRunner, platform });
   if (!SHA256.test(manifest.checksumsSha256 ?? "")) throw new Error("direct release checksums digest is missing");
   if (sha256(checksumsFile) !== manifest.checksumsSha256) throw new Error("checksums.json is not manifest-bound");
   const checksums = JSON.parse(readFileSync(checksumsFile, "utf8"));
@@ -236,8 +232,8 @@ export function prepareGitHubAddonRelease({ repoRoot, config, configRoot = repoR
   };
 }
 
-export function publishGitHubRelease(plan, { repo, dryRun = false, run = runCommand, signatureCommandRunner = plan?.signatureCommandRunner ?? plan?.cmsCommandRunner, signaturePlatform = plan?.signaturePlatform ?? plan?.cmsPlatform ?? process.platform } = {}) {
-  if (plan.kind === "direct-release") validateGitHubDirectReleasePlan(plan, { commandRunner: signatureCommandRunner ?? spawnSync, platform: signaturePlatform });
+export function publishGitHubRelease(plan, { repo, dryRun = false, run = runCommand, catalogCommandRunner = plan?.catalogCommandRunner, catalogPlatform = plan?.catalogPlatform ?? process.platform } = {}) {
+  if (plan.kind === "direct-release") validateGitHubDirectReleasePlan(plan, { commandRunner: catalogCommandRunner ?? spawnSync, platform: catalogPlatform });
   const visibility = JSON.parse(run("gh", ["repo", "view", repo, "--json", "visibility"]));
   if (visibility.visibility !== "PUBLIC" && !(plan.kind !== "addon" && visibility.visibility === "PRIVATE")) {
     throw new Error(`GitHub releases require a public or private repository: ${repo}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rightkit/release",
-  "version": "0.2.74",
+  "version": "0.2.75",
   "description": "Portable Right Suite release CLI/SDK: signed native archives, direct bootstrap transactions, immutable GitHub Release upload, R2 bootstrap publication, and add-on adoption.",
   "license": "MIT OR Apache-2.0",
   "type": "module",
@@ -29,7 +29,6 @@
   "scripts": {
     "test": "node --test --test-concurrency=1 --test-force-exit *.test.mjs",
     "test:registry-parity": "node registry-parity.mjs --allow-unpublished",
-    "test:signer:windows": "node sign-release-manifest.integration.mjs",
     "doctor:all": "node --test right-suite-contract.test.mjs",
     "verify:standalone": "node standalone-clone-verify.mjs"
   }

package/rightkit-versions.json

@@ -22,7 +22,7 @@
     "@rightkit/logs": "0.1.4",
     "@rightkit/platform-ui": "0.1.1",
     "@rightkit/qa": "0.2.1",
-    "@rightkit/release": "0.2.74",
+    "@rightkit/release": "0.2.75",
     "@rightkit/tauri": "0.1.1",
     "@rightkit/updates": "0.2.4"
   },
@@ -72,7 +72,8 @@
       "0.2.70",
       "0.2.71",
       "0.2.72",
-      "0.2.73"
+      "0.2.73",
+      "0.2.74"
     ],
     "@rightkit/qa": [
       "0.1.0",

package/sign-release-manifest.mjs

@@ -2,10 +2,11 @@ import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync,
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 
 export const RIGHTRELEASE_MANIFEST_SIGNER = Object.freeze({
   id: "azure-artifact-signing-damned-ventures-v1",
-  subject: "CN=Damned Ventures LLC",
+  subject: "CN=Damned Ventures LLC, O=Damned Ventures LLC, L=new york, S=New York, C=US",
   algorithm: "authenticode-catalog-sha256",
   provider: "windows-authenticode-catalog",
   providerVersion: 1,
@@ -21,47 +22,52 @@ const EXCLUDE_CREDENTIALS = [
   "AzureDeveloperCliCredential",
   "InteractiveBrowserCredential",
 ];
+
 const CERTIFICATE_SHA256 = /^[a-f0-9]{64}$/i;
 
-/** Verify Azure-signed catalog binding exact release-manifest bytes. */
-export function verifyManifestCatalogSignature({
+export function verifyReleaseManifestCatalog({
   manifestPath,
-  signaturePath,
+  catalogPath,
   expectedSigner,
   commandRunner = spawnSync,
   platform = process.platform,
-  powershellPath = "pwsh",
+  powershellPath = "powershell",
 }) {
   const manifest = resolve(manifestPath);
-  const signature = resolve(signaturePath);
-  if (!existsSync(manifest) || !statSync(manifest).isFile()) throw new Error("manifest bytes are missing");
-  if (!existsSync(signature) || !statSync(signature).isFile() || statSync(signature).size < 1) throw new Error("detached manifest catalog signature is missing");
-  if (!expectedSigner || expectedSigner.id !== RIGHTRELEASE_MANIFEST_SIGNER.id || expectedSigner.subject !== RIGHTRELEASE_MANIFEST_SIGNER.subject || expectedSigner.algorithm !== RIGHTRELEASE_MANIFEST_SIGNER.algorithm || expectedSigner.provider !== RIGHTRELEASE_MANIFEST_SIGNER.provider || expectedSigner.providerVersion !== RIGHTRELEASE_MANIFEST_SIGNER.providerVersion || !CERTIFICATE_SHA256.test(expectedSigner.certificateSha256 ?? "")) {
+  const catalog = resolve(catalogPath);
+  if (platform !== "win32") throw new Error("Authenticode catalog verification requires Windows");
+  if (!existsSync(manifest) || !statSync(manifest).isFile()) throw new Error("catalog manifest bytes are missing");
+  if (!existsSync(catalog) || !statSync(catalog).isFile() || statSync(catalog).size < 1) throw new Error("release manifest catalog is missing");
+  if (!expectedSigner || expectedSigner.id !== RIGHTRELEASE_MANIFEST_SIGNER.id || expectedSigner.subject !== RIGHTRELEASE_MANIFEST_SIGNER.subject || expectedSigner.algorithm !== RIGHTRELEASE_MANIFEST_SIGNER.algorithm || !CERTIFICATE_SHA256.test(expectedSigner.certificateSha256 ?? "")) {
     throw new Error("catalog verification requires exact Azure signer identity");
   }
-  if (platform !== "win32" && commandRunner === spawnSync) throw new Error("RightRelease catalog verification must run on Windows");
-  const inspection = inspectCatalog({ manifestPath: manifest, signaturePath: signature, commandRunner, powershellPath });
-  if (inspection.verified !== true || inspection.catalogStatus !== "Valid" || inspection.signatureStatus !== "Valid") throw new Error("manifest catalog signature is invalid");
+  const inspection = verifyCatalogWithPowerShell({ manifestPath: manifest, catalogPath: catalog, commandRunner, powershellPath });
+  if (!inspection.verified) throw new Error("release manifest catalog is invalid");
   if (normalizeSubject(inspection.subject) !== normalizeSubject(expectedSigner.subject)) throw new Error("catalog signer subject mismatch");
   const certificateSha256 = String(inspection.certificateSha256 ?? "").replaceAll(":", "").toLowerCase();
   if (!CERTIFICATE_SHA256.test(certificateSha256) || certificateSha256 !== String(expectedSigner.certificateSha256).toLowerCase()) throw new Error("catalog signer certificate fingerprint mismatch");
-  return { verified: true, manifestPath: manifest, signaturePath: signature, signer: { ...expectedSigner, certificateSha256 } };
+  return { verified: true, manifestPath: manifest, catalogPath: catalog, signer: { ...expectedSigner, certificateSha256 } };
 }
 
-export function signReleaseManifestWithAzure({
+export function signReleaseManifestCatalogWithAzure({
   manifestPath,
-  signaturePath,
+  catalogPath,
   commandRunner = spawnSync,
   environment = process.env,
   signtoolPath,
   dlibPath,
   metadataPath,
-  powershellPath = "pwsh",
 }) {
-  if (process.platform !== "win32" && commandRunner === spawnSync) throw new Error("RightRelease manifest signing must run on protected Windows release host");
+  if (process.platform !== "win32" && commandRunner === spawnSync) {
+    throw new Error("RightRelease manifest signing must run on protected Windows release host");
+  }
   const userEnv = (name) => readUserEnvironment(name, commandRunner);
   const env = (name) => environment[name] || userEnv(name);
-  const signtool = signtoolPath || firstExisting([env("AZURE_SIGNTOOL_PATH"), env("SIGNTOOL_PATH"), ...signtoolCandidates(env)]);
+  const signtool = signtoolPath || firstExisting([
+    env("AZURE_SIGNTOOL_PATH"),
+    env("SIGNTOOL_PATH"),
+    ...signtoolCandidates(env),
+  ]);
   if (!signtool) throw new Error("RightRelease manifest signer could not find signtool.exe");
   const dlib = dlibPath || firstExisting([
     env("AZURE_CODESIGN_DLIB_PATH"),
@@ -72,70 +78,85 @@ export function signReleaseManifestWithAzure({
   ]);
   if (!dlib) throw new Error("RightRelease manifest signer could not find Azure Artifact Signing dlib");
 
-  const temp = mkdtempSync(join(tmpdir(), "rightrelease-manifest-sign-"));
+  const temp = mkdtempSync(join(tmpdir(), "rightrelease-manifest-catalog-"));
+  const powershellEnvironment = windowsPowerShellEnvironment(environment);
   const metadata = metadataPath || materializeMetadata(temp, env);
-  const catalogDir = join(temp, "catalog");
-  mkdirSync(catalogDir, { recursive: true });
-  const catalog = join(catalogDir, "catalog.cat");
-  const generator = join(temp, "create-catalog.ps1");
-  writeFileSync(generator, [
-    "param([string]$ManifestPath, [string]$CatalogDirectory)",
-    "$ErrorActionPreference = 'Stop'",
-    "Import-Module Microsoft.PowerShell.Security -ErrorAction Stop",
-    "New-FileCatalog -Path $ManifestPath -CatalogFilePath $CatalogDirectory -CatalogVersion 2.0 | Out-Null",
-  ].join("\r\n") + "\r\n");
+  const catalogSource = join(temp, "catalog-source");
+  const unsignedCatalog = join(temp, "release-manifest.cat");
+  mkdirSync(catalogSource, { recursive: true });
+  copyFileSync(resolve(manifestPath), join(catalogSource, "release-manifest.json"));
   try {
-    const generation = commandRunner(powershellPath, ["-NoProfile", "-File", generator, resolve(manifestPath), catalogDir], { encoding: "utf8", windowsHide: true, env: environment });
-    if (generation?.status !== 0) throw new Error(`RightRelease manifest catalog generation failed: ${String(generation?.stderr ?? "").trim()}`);
-    if (!existsSync(catalog) || !statSync(catalog).isFile()) throw new Error("RightRelease manifest catalog was not produced");
+    const materializer = join(temp, "new-catalog.ps1");
+    writeFileSync(materializer, [
+      "param([string]$SourcePath, [string]$CatalogPath)",
+      "Import-Module Microsoft.PowerShell.Security -ErrorAction Stop",
+      "$Result = New-FileCatalog -Path $SourcePath -CatalogFilePath $CatalogPath -CatalogVersion 2.0",
+      "if (-not (Test-Path $Result)) { throw 'Manifest catalog was not created' }",
+    ].join("\r\n") + "\r\n");
+    const created = commandRunner("powershell", ["-NoProfile", "-File", materializer, catalogSource, unsignedCatalog], { encoding: "utf8", windowsHide: true, env: powershellEnvironment });
+    if (created?.status !== 0 || !existsSync(unsignedCatalog)) throw new Error(`RightRelease manifest catalog creation failed: ${String(created?.stderr ?? "").trim()}`);
     const result = commandRunner(signtool, [
       "sign", "/v", "/fd", "SHA256", "/tr", "http://timestamp.acs.microsoft.com", "/td", "SHA256",
-      "/dlib", dlib, "/dmdf", metadata, catalog,
+      "/dlib", dlib, "/dmdf", metadata,
+      unsignedCatalog,
     ], { encoding: "utf8", windowsHide: true, env: environment });
-    if (result?.status !== 0) throw new Error(`RightRelease manifest signing failed: ${String(result?.stderr ?? "").trim()}`);
-    const inspection = inspectCatalog({ manifestPath: resolve(manifestPath), signaturePath: catalog, commandRunner, powershellPath, environment });
-    if (inspection.verified !== true || inspection.catalogStatus !== "Valid" || inspection.signatureStatus !== "Valid") throw new Error("RightRelease manifest catalog verification failed");
-    if (normalizeSubject(inspection.subject) !== normalizeSubject(RIGHTRELEASE_MANIFEST_SIGNER.subject) || !CERTIFICATE_SHA256.test(inspection.certificateSha256 ?? "")) throw new Error("RightRelease manifest signer identity does not match protected Azure profile");
-    mkdirSync(dirname(signaturePath), { recursive: true });
-    copyFileSync(catalog, signaturePath);
-    return { signaturePath: resolve(signaturePath), signer: { ...RIGHTRELEASE_MANIFEST_SIGNER, certificateSha256: inspection.certificateSha256.toLowerCase() } };
+    if (result?.status !== 0) throw new Error(`RightRelease manifest catalog signing failed: ${String(result?.stderr ?? "").trim()}`);
+    const inspection = verifyCatalogWithPowerShell({ manifestPath: resolve(manifestPath), catalogPath: unsignedCatalog, commandRunner, powershellPath: "powershell", environment: powershellEnvironment });
+    if (normalizeSubject(inspection.subject) !== normalizeSubject(RIGHTRELEASE_MANIFEST_SIGNER.subject) || !CERTIFICATE_SHA256.test(inspection.certificateSha256 ?? "")) throw new Error(`RightRelease catalog signer identity does not match protected Azure profile: ${inspection.subject}`);
+    mkdirSync(dirname(catalogPath), { recursive: true });
+    copyFileSync(unsignedCatalog, catalogPath);
+    return { catalogPath: resolve(catalogPath), signer: { ...RIGHTRELEASE_MANIFEST_SIGNER, certificateSha256: inspection.certificateSha256.toLowerCase() } };
   } finally {
     rmSync(temp, { recursive: true, force: true });
   }
 }
 
-function inspectCatalog({ manifestPath, signaturePath, commandRunner, powershellPath, environment = process.env }) {
+function verifyCatalogWithPowerShell({ manifestPath, catalogPath, commandRunner, powershellPath, environment = process.env }) {
   const temp = mkdtempSync(join(tmpdir(), "rightrelease-catalog-verify-"));
+  const source = join(temp, "catalog-source");
+  mkdirSync(source, { recursive: true });
+  copyFileSync(manifestPath, join(source, "release-manifest.json"));
   const verifier = join(temp, "verify-catalog.ps1");
   writeFileSync(verifier, [
-    "param([string]$ManifestPath, [string]$SignaturePath)",
-    "$ErrorActionPreference = 'Stop'",
+    "param([string]$SourcePath, [string]$CatalogPath)",
     "Import-Module Microsoft.PowerShell.Security -ErrorAction Stop",
-    "$Catalog = Test-FileCatalog -CatalogFilePath $SignaturePath -Path $ManifestPath -Detailed",
-    "$Signature = Get-AuthenticodeSignature -FilePath $SignaturePath",
+    "$Signature = Get-AuthenticodeSignature -FilePath $CatalogPath",
+    "if ($Signature.Status -ne 'Valid' -or $null -eq $Signature.SignerCertificate) { throw 'Catalog Authenticode signature is invalid' }",
+    "$Validation = Test-FileCatalog -Path $SourcePath -CatalogFilePath $CatalogPath",
+    "if ([string]$Validation -ne 'Valid') { throw 'Catalog does not bind exact manifest bytes' }",
     "$Certificate = $Signature.SignerCertificate",
-    "if (-not $Certificate) { throw 'Catalog signer certificate is missing' }",
-    "$SimpleName = $Certificate.GetNameInfo([Security.Cryptography.X509Certificates.X509NameType]::SimpleName, $false)",
     "$Sha256 = [Security.Cryptography.SHA256]::Create()",
     "try { $Fingerprint = ([BitConverter]::ToString($Sha256.ComputeHash($Certificate.RawData))).Replace('-','').ToLowerInvariant() } finally { $Sha256.Dispose() }",
-    "@{ verified=([string]$Catalog.Status -eq 'Valid' -and [string]$Signature.Status -eq 'Valid'); catalogStatus=[string]$Catalog.Status; signatureStatus=[string]$Signature.Status; subject=('CN=' + $SimpleName); certificateSha256=$Fingerprint } | ConvertTo-Json -Compress",
+    "@{ verified=$true; subject=$Certificate.Subject; certificateSha256=$Fingerprint } | ConvertTo-Json -Compress",
   ].join("\r\n") + "\r\n");
   try {
-    const result = commandRunner(powershellPath, ["-NoProfile", "-File", verifier, manifestPath, signaturePath], { encoding: "utf8", windowsHide: true, env: environment });
-    if (result?.status !== 0) throw new Error(`manifest catalog verification failed: ${String(result?.stderr ?? "").trim()}`);
-    let inspection;
-    try { inspection = JSON.parse(String(result?.stdout ?? "").trim()); } catch { throw new Error("catalog verifier returned invalid JSON"); }
-    if (typeof inspection.subject !== "string" || typeof inspection.certificateSha256 !== "string") throw new Error("catalog verifier returned incomplete identity");
-    return inspection;
+    const result = commandRunner(powershellPath, ["-NoProfile", "-File", verifier, source, catalogPath], { encoding: "utf8", windowsHide: true, env: windowsPowerShellEnvironment(environment) });
+    if (result?.status !== 0) throw new Error(`catalog verification failed: ${String(result?.stderr ?? "").trim()}`);
+    return parseCatalogInspection(result?.stdout);
   } finally {
     rmSync(temp, { recursive: true, force: true });
   }
 }
 
+function parseCatalogInspection(output) {
+  let inspection;
+  try { inspection = JSON.parse(String(output ?? "").trim()); } catch { throw new Error("catalog verifier returned invalid JSON"); }
+  if (inspection.verified !== true || typeof inspection.subject !== "string" || typeof inspection.certificateSha256 !== "string") throw new Error("catalog verifier returned incomplete identity");
+  return inspection;
+}
+
 function normalizeSubject(subject) {
   return String(subject).trim().replace(/\s*=\s*/g, "=").replace(/\s*,\s*/g, ",");
 }
 
+function windowsPowerShellEnvironment(environment) {
+  const sanitized = { ...environment };
+  for (const key of Object.keys(sanitized)) {
+    if (key.toLowerCase() === "psmodulepath") delete sanitized[key];
+  }
+  return sanitized;
+}
+
 function materializeMetadata(dir, env) {
   const existing = env("AZURE_ARTIFACT_SIGNING_METADATA") || env("AZURE_SIGNING_METADATA");
   if (existing) {
@@ -145,7 +166,9 @@ function materializeMetadata(dir, env) {
   const Endpoint = env("AZURE_ARTIFACT_SIGNING_ENDPOINT") || env("AZURE_SIGNING_ENDPOINT") || env("AZURE_ENDPOINT");
   const CodeSigningAccountName = env("AZURE_ARTIFACT_SIGNING_ACCOUNT") || env("AZURE_SIGNING_ACCOUNT_NAME") || env("AZURE_ACCOUNT");
   const CertificateProfileName = env("AZURE_ARTIFACT_SIGNING_PROFILE") || env("AZURE_CERTIFICATE_PROFILE_NAME") || env("AZURE_PROFILE");
-  if (!Endpoint || !CodeSigningAccountName || !CertificateProfileName) throw new Error("RightRelease manifest signer requires existing Azure Artifact Signing configuration");
+  if (!Endpoint || !CodeSigningAccountName || !CertificateProfileName) {
+    throw new Error("RightRelease manifest signer requires existing Azure Artifact Signing configuration");
+  }
   const path = join(dir, "metadata.json");
   writeFileSync(path, `${JSON.stringify({ Endpoint, CodeSigningAccountName, CertificateProfileName, ExcludeCredentials: EXCLUDE_CREDENTIALS }, null, 2)}\n`);
   return path;
@@ -166,6 +189,9 @@ function firstExisting(candidates) {
 }
 
 function readUserEnvironment(name, commandRunner) {
-  const result = commandRunner("powershell", ["-NoProfile", "-Command", `[Environment]::GetEnvironmentVariable('${name.replaceAll("'", "''")}','User')`], { encoding: "utf8", windowsHide: true });
+  const result = commandRunner("powershell", ["-NoProfile", "-Command", `[Environment]::GetEnvironmentVariable('${name.replaceAll("'", "''")}','User')`], {
+    encoding: "utf8",
+    windowsHide: true,
+  });
   return result?.status === 0 ? String(result.stdout ?? "").trim() : "";
 }

package/sign-release-manifest.integration.mjs

@@ -1,27 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { RIGHTRELEASE_MANIFEST_SIGNER, signReleaseManifestWithAzure, verifyManifestCatalogSignature } from "./sign-release-manifest.mjs";
-
-if (process.platform !== "win32") throw new Error("protected manifest signer integration must run on Windows");
-
-const root = mkdtempSync(join(tmpdir(), "rightrelease-live-signer-"));
-const manifestPath = join(root, "release-manifest.json");
-const signaturePath = join(root, "release-manifest.cat");
-try {
-  writeFileSync(manifestPath, '{"kind":"rightrelease-live-signer-probe","schemaVersion":1}\n');
-  const signing = signReleaseManifestWithAzure({ manifestPath, signaturePath });
-  const verification = verifyManifestCatalogSignature({ manifestPath, signaturePath, expectedSigner: signing.signer });
-  assert.equal(verification.verified, true);
-  assert.equal(verification.signer.id, RIGHTRELEASE_MANIFEST_SIGNER.id);
-
-  writeFileSync(manifestPath, `${readFileSync(manifestPath, "utf8")}tampered\n`);
-  assert.throws(
-    () => verifyManifestCatalogSignature({ manifestPath, signaturePath, expectedSigner: signing.signer }),
-    /manifest catalog signature is invalid/,
-  );
-  process.stdout.write(`${JSON.stringify({ status: "PASS", provider: signing.signer.provider, providerVersion: signing.signer.providerVersion, algorithm: signing.signer.algorithm, subject: signing.signer.subject, certificateSha256: signing.signer.certificateSha256 })}\n`);
-} finally {
-  rmSync(root, { recursive: true, force: true });
-}