feat: G2 code-signing verifier (Mode-1) with legacy G1 transition

[DeepDiver1975]

Description

Reimplements the verification half of OC\IntegrityCheck\Checker for the new
"G2" code-signing PKI (ECDSA-P384 primary, RSA-4096-PSS fallback), with CRL-based
revocation and a time-boxed transition path for legacy G1 signatures. The signing
half (writeAppSignature/writeCoreSignature, occ integrity:sign-*) is left
untouched — it is superseded by the standalone ocsign tool.

Verification now accepts the new signature.json v2 format
({v, alg, hashes, signature, certificates:{leaf, chain[]}}) as well as the legacy
format, validates the certificate chain against bundled trust anchors, verifies the
manifest signature over the canonical bytes M, enforces CRL revocation
(fail-closed), checks appId/CN identity, and produces the same structured
integrity diff the admin UI already consumes.

The new logic lives in focused, independently-tested collaborators under
lib/private/IntegrityCheck/Verifier/; Checker::verify() delegates to them,
preserving the public API, cache, result-shape contract, and all callers.
Mode-2 attestation is intentionally out of scope (blocked upstream on the
undecided bind(H,T) token encoding).

Components

• CanonicalManifest — byte-exact reconstruction of the signed manifest M
  (gated by shared golden vectors copied from the ocsign repo).
• SignatureEnvelope — v2 + legacy parser; extracts the verbatim hashes byte-span
  (no re-serialization, so what is verified equals what is diffed).
• ManifestVerifier — ecdsa-p384-sha384 (ASN.1 DER), rsa-pss-sha384 (salt 48),
  and legacy rsa-pss-sha1 (MGF1-SHA512, salt 0).
• AlgorithmAllowlist (§3) — allowlist + G1-only legacy gate with a hardcoded
  LEGACY_SUNSET.
• TrustStore + ChainValidator (§4.2) — only bundled roots are trust anchors;
  an envelope-supplied intermediate is independently re-verified to a bundled root
  before it may vouch for the leaf. Enforces leaf CA:FALSE / digitalSignature /
  codeSigning.
• CrlFetcher / CrlValidator / CrlProvider (§5) — HTTPS-only, no-redirect fetch;
  fetched-valid → bundled → fail-closed (CRL_UNAVAILABLE).
• AppIdResolver (§7) — ASCII-only case-fold, strict regex, exact-byte CN compare;
  XXE-safe XML parsing.
• IntegrityDiffer (§4.6) — legacy EXTRA_FILE/FILE_MISSING/INVALID_HASH shape.
• Verifier — the §4 Mode-1 pipeline + the §8 G1 dual-trust warn-and-allow branch.

resources/codesigning/ migrated to the new roots/ intermediates/ crl/ layout;
the legacy G1 anchor + frozen CRL are relocated so legacy apps keep verifying.
The G2 root/intermediate and the production leaf CRL are populated by the CA
ceremony (documented in resources/codesigning/README.md) — G2 verification is
inert until then, which is intentional and strictly safer than shipping a
placeholder anchor.

Related Issue

• Fixes <issue_link>

Motivation and Context

The legacy integrity check trusts a single RSA-PSS-SHA1 PKI whose intermediate
expires in 2026. This introduces the G2 PKI (stronger algorithms, revocation via a
published CRL, revoke-from-time) while keeping the legacy G1 chain trusted through a
time-boxed transition (LEGACY_SUNSET). Spec: spec-core-verifier.md §1–§11.

How Has This Been Tested?

• test environment: PHP 8.3, PHPUnit (tests/phpunit-autotest.xml), phpseclib3
  (vendored).
• Unit + integration: tests/lib/IntegrityCheck/ — 180 tests / 357 assertions,
  0 failures. Includes byte-exact golden-vector parity, real ECDSA + RSA-PSS
  signature verification, a security-critical rogue-intermediate rejection test,
  CRL fail-closed + wrong-issuer rejection, §8 before/after-sunset transition,
  revoked-leaf and revoked-intermediate cases, and Checker delegation/contract tests.
• Cross-implementation conformance: the golden manifest vectors are shared
  verbatim with the Go ocsign signer.
• Adversarial review: whole-branch + offensive-security review, which found and
  fixed an AIA-URL SSRF (phpseclib URL fetch disabled), a fail-open DI defect, and
  extended revocation to the full chain. The cryptographic core was confirmed sound
  against rogue-chain, algorithm-confusion, canonical-M dual-parse, CRL-bypass, XXE,
  and §8-abuse attacks.

Types of changes

• New feature (non-breaking change which adds functionality)
• Technical debt

Checklist:

• Code changes
• Unit tests added
• Acceptance tests added
• Documentation ticket raised:
• Changelog item

Notes for reviewers

• Commits are DCO signed-off and PGP-signed.
• Follow-ups (documented, non-blocking): (1) the CA ceremony must publish the G2
  root/intermediate and the production developers.crl; (2) intermediate revocation
  is checked against the available CRL, but a dedicated root-signed intermediate.crl
  source is ceremony-pending; (3) the mimetypelist.js exclusion could use a correct
  relative-path-keyed narrowing (an incorrect anchoring attempt was reverted).

🤖 Generated with Claude Code

[update-docs]

Thanks for opening this pull request! The maintainers of this repository would appreciate it if you would create a changelog item based on your changes.

[kw-fscheuer]

Deep review of the G2 verifier. Overall this is strong, careful work: the decomposition into single-responsibility collaborators is clean, the security-critical chain logic (only bundled roots are anchors; envelope intermediates are independently re-verified to a bundled root before they may vouch for the leaf) is correct, XXE and AIA-SSRF are handled, and the fail-closed CRL posture matches spec §5. Findings verified against spec-core-verifier.md (§4/§5/§8) and the PKI design doc (§9).

Two items to fix before merge, one low-severity hardening note (inline), and one deferred implementation gap.

Blockers

1. Legacy-warn (§8 case 2) apps are blocked at install — violates "warn + allow"

lib/private/Installer.php (~line 352, not in this diff) treats any non-empty result as failure:

if ($integrityResult !== []) { /* throw, refuse install */ }

A valid, expired, pre-sunset G1 app returns ['LEGACY_ACCEPTED_WARN' => true], which is !== [], so the install is refused — the exact case §8 calls "the single warn-not-block exception." hasPassedCheck() was correctly taught about this marker (Checker.php:459-463), but the install gate was not. Fix: treat the LEGACY_ACCEPTED_WARN marker as a pass at this call site.

Lesser, same area (non-blocking): core/Command/Integrity/CheckApp.php:66 returns exit code 1 for the warn marker — arguably fine for a diagnostic command, but worth aligning for consistency; and the "warn" half of "warn + allow" is never surfaced visibly to the admin even when the app is allowed.

2. v2 parser accepts an arbitrary version number — see inline comment on SignatureEnvelope.php.

Note (not a blocker)

3. decodeHashesMap can return a non-array — see inline comment on CanonicalManifest.php.

Implementation gap (non-blocking, follow-up ticket)

4. Periodic full-instance re-verification is not implemented

Spec §6 / design §9 require periodic re-verification as "the safety net that makes revocation meaningful for already-installed apps." No TimedJob/cron invokes runInstanceVerification() — it runs only on upgrade, setup, manual rescan, and per-app install. Without it, a revoked leaf on an already-installed app keeps running until an admin upgrades or clicks Rescan. This likely pre-dates the PR (which reimplements verification, not scheduling), so a follow-up ticket rather than a blocker here.

Perf suggestion for when that job is designed: Verifier::verify() fetches the CRL once per app, so a full run is N sequential HTTPS fetches (up to ~15s each against an unreachable host). The CRL is instance-wide, not per-app — memoize the fetched-and-validated CRL per generation for the duration of a run to collapse N fetches to one.

Reviewed and explicitly NOT flagged

• CRL staleness: the signature-only CRL validation (no nextUpdate rejection) is correct per spec §5 / design §9 — a stale-but-signature-valid CRL is accepted by design so airgapped instances keep working off the bundled CRL. Fail-closed only on no valid CRL.
• Intermediate revocation being inert in production (developers.crl is signed by the intermediate and can't revoke its own issuer) traces to a spec-level §4/§2/§5 inconsistency, not this PR — tracked separately.

[kw-fscheuer]

v2 parser accepts an arbitrary version number. $version = $data['v'] ?? 2 accepts e.g. {"v": 99, "certificates": {...}} as a v2 envelope and processes it with v2 canonicalization rules. Harmless today because AlgorithmAllowlist still gates the algorithm, but a future v3 with different canonical-M construction would be silently mis-parsed as v2 (wrong signed-bytes reconstruction). Suggest rejecting unknown v values explicitly — accept only the versions this verifier understands, throw MissingSignatureException otherwise.

[kw-fscheuer]

decodeHashesMap can return a non-array. json_decode($rawM, true) returns null on malformed input, and the result flows into SignatureEnvelope's array $hashesMap constructor param — a TypeError rather than the intended MissingSignatureException. Realistic malformed input is already caught by the is_array($data['hashes']) guard in SignatureEnvelope::parse(), so this is only reachable via a defect in the brace-balanced scanner; the effect is that a clean MISSING_SIGNATURE reason code degrades into a generic EXCEPTION result. Low severity / defense-in-depth: a two-line if (!\is_array($decoded)) { throw new MissingSignatureException(...); } closes it and preserves the reason-code contract. Not attacker-reachable given the upstream guard.