Implement CERTVERIFY -- real DER cert verification, tested against OpenSSL

Phase B of the identity pipeline (FABRIC-3.md §F.7/§F.17):

- x509_ed25519.c/.h: two new DER walkers alongside the existing pubkey
  extractor -- x509_verify_signature() (verifies a cert's outer Ed25519
  signature over the raw, exactly-as-encoded tbsCertificate bytes, real
  signature verification against issuer_pubkey, rejects non-Ed25519
  signatureAlgorithm) and x509_extract_serial() (extracts the
  serialNumber INTEGER, stripping a DER padding byte if present, for the
  drive_uuid binding decided in §F.7).

- vm_identity.c: vm_identity_from_cert(), ties the three DER primitives
  together into the actual CERTVERIFY check -- signature verifies against
  issuer_pubkey, serialNumber matches this drive's own drive_uuid,
  subject pubkey extracts cleanly -- and populates a VMIdentity on
  success. acl_caps is caller-supplied, not read from the cert (nothing
  in the decided cert fields encodes capabilities); deciding what a
  verified identity is allowed to do is policy for the caller (WIREBIND,
  not yet built), not this function's job.

Verified two ways: a standalone host-side test harness (not part of the
kernel build) links the real source files against a real openssl-
generated Ed25519 X.509 cert -- extracted pubkey, extracted serial, and
signature verification all match ground truth, plus two negative tests
(wrong issuer pubkey, corrupted signature) both correctly rejected. Then
the actual kernel build verified live on all three architectures: clean
compile, clean boot to ok>, Hermes/Artemis both live with no KILL. Same
pre-existing, unrelated Zuse fence-write anomaly observed on all three
(not caused by this change, not chased here).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019ZGkimpfyh63EZyRkNbkPD

include/starkernel/vm_identity.h

@@ -49,6 +49,7 @@
 #ifdef __STARKERNEL__
 
 #include <stdint.h>
+#include <stddef.h>
 
 typedef struct {
     uint8_t  owner_pubkey[32]; /**< Ed25519 public key of this VM's owning
@@ -85,6 +86,40 @@ typedef struct {
  */
 int vm_identity_has_cap(const VMIdentity *id, uint32_t cap);
 
+/**
+ * vm_identity_from_cert - CERTVERIFY (FABRIC-3.md §F.7/§F.17): verify a
+ * DER-encoded, Zuse-signed X.509 cert and populate a VMIdentity from it.
+ *
+ * Three checks, all must pass: the cert's own signature verifies against
+ * issuer_pubkey (Zuse's own on-device key -- a separate trust root from
+ * the capsule-PKI chain, no chain walk needed); the cert's serialNumber
+ * equals drive_uuid byte-for-byte (binds this cert to one physical drive,
+ * §F.7 decision 2 -- a copied cert on different media will not verify);
+ * the subject's Ed25519 public key extracts cleanly.
+ *
+ * acl_caps is *not* read from the cert -- nothing in the decided cert
+ * fields encodes capabilities (§F.16). It's supplied by the caller, whose
+ * job it is to decide what this verified identity is allowed to do (e.g.
+ * comparing the extracted pubkey against Zuse's own system-resident
+ * pubkey to decide VM_IDENTITY_CAP_ALL vs. a lesser default) -- that
+ * policy decision doesn't belong inside a pure verification function.
+ *
+ * @param out          Populated on success; left untouched on failure.
+ * @param der          DER-encoded certificate bytes.
+ * @param der_len      Their length.
+ * @param issuer_pubkey Zuse's own Ed25519 public key.
+ * @param drive_uuid   This physical drive's own 16-byte drive_uuid
+ *                      (homeblocks_sig_t), compared against the cert's
+ *                      serialNumber.
+ * @param acl_caps     Capability bitmask to install, caller-decided.
+ * @return 0 on success, -1 if any check fails (malformed DER, wrong
+ *         signature algorithm, signature doesn't verify, serial mismatch,
+ *         or the extracted key isn't a valid Ed25519 point).
+ */
+int vm_identity_from_cert(VMIdentity *out, const uint8_t *der, size_t der_len,
+                           const uint8_t issuer_pubkey[32],
+                           const uint8_t drive_uuid[16], uint32_t acl_caps);
+
 #endif /* __STARKERNEL__ */
 
 #endif /* STARKERNEL_VM_IDENTITY_H */