feat(ANSModelPackage): take the base key the ceremony gives this build

The reader has been able to open packages for a while and has held no
key, so it refused all of them. This is the seam that hands it one.

The base private key is not in this repository and never will be. It is
written by the ceremony (ANSMINDCORE's ansmodel-keys) into a generated
header that is gitignored and produced from the key vault on the machine
that builds a release. ANSModelKeys.h uses that file when it is there
and says "no keys" when it is not, so a developer's checkout builds and
runs with no secret in it: every zip still loads, and a package is
refused with a sentence that says why.

Keys are settled once — what the build carries, plus a developer's
environment — unless a caller sets a keyring outright, which now means
exactly that rather than depending on which call ran first.

Checked with the real keys against the packages ANSMINDCORE's side
produced: a package sealed by a box that holds only the public half
opens here byte for byte, and one signed by the new release key verifies
against the built-in root. If those two products disagreed, a model that
runs in one would not run in the other, which is the failure this format
exists to avoid. 40 checks in the package test, no failures.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
2026-09-12 23:05:00 +10:00
co-authored by Claude Opus 5
parent 8e50120759
commit c82b2a67bc
3 changed files with 70 additions and 12 deletions
+42
View File
@@ -0,0 +1,42 @@
#ifndef ANSMODELKEYS_H
#define ANSMODELKEYS_H
#pragma once
// ANSModelKeys — the keys this build was given, if it was given any.
//
// The base private key is not in this file and is not in the repository. It is
// written by the key ceremony (ANSMINDCORE's tools/ansmodel_keys.cpp) into
// ANSModelKeysGenerated.h, which is ignored by git and produced on the machine
// that builds a release. This header is the seam: it uses that file when it is
// there and says "no keys" when it is not.
//
// A BUILD WITHOUT THE KEY IS A VALID BUILD. Every zip still loads, and a
// package is refused with a sentence that says why. That is what keeps the key
// out of a developer's checkout without keeping developers out of the code.
#if defined(__has_include)
#if __has_include("ANSModelKeysGenerated.h")
#include "ANSModelKeysGenerated.h"
#define ANSCORE_HAVE_BUILTIN_MODEL_KEYS 1
#endif
#endif
#include "ANSModelPackage.h"
namespace ANSCENTER {
namespace modelpkg {
// Add whatever this build ships with to a keyring. False when it ships with
// nothing, which is not an error.
inline bool AddBuiltInKeys(Keyring& ring) {
#if defined(ANSCORE_HAVE_BUILTIN_MODEL_KEYS)
return builtin::addBuiltInKeys(ring);
#else
(void)ring;
return false;
#endif
}
} // namespace modelpkg
} // namespace ANSCENTER
#endif // ANSMODELKEYS_H
+24 -12
View File
@@ -14,12 +14,13 @@
// exists. OpenModelPackage decrypts into a buffer the caller owns; the caller
// hands that buffer to a session and wipes it. Nothing here writes a file.
//
// WHERE THE KEY COMES FROM. The product sets it once at startup with
// SetProcessModelKeys(): the base PRIVATE key packages are sealed to, and the
// root PUBLIC key that vouches for a release signing key. Nothing here reads a
// key out of the package or off the disk. With no keys set, a package is
// refused with a sentence that says so, and every existing zip still loads — a
// build from before the key ceremony runs everything except packages.
// WHERE THE KEY COMES FROM. Three places, in this order: what the build ships
// with (ANSModelKeys.h, filled in by the key ceremony), what the environment
// offers a developer, and whatever a caller sets with SetProcessModelKeys().
// Nothing here reads a key out of the package or off the disk. With no keys at
// all, a package is refused with a sentence that says so, and every existing
// zip still loads — a build made without the ceremony runs everything except
// packages.
//
// The base private key must never sit in the binary as one contiguous
// constant; assembling it is the job of whatever calls SetProcessModelKeys,
@@ -38,6 +39,7 @@
#include <string>
#include <vector>
#include "ANSModelKeys.h"
#include "ANSModelPackage.h"
#include "ANSOnnxShape.h"
@@ -66,11 +68,16 @@ inline bool keyFromB64(const char* b64, Key& out) {
return true;
}
// Development only: keys from the environment, once, and said out loud.
inline void loadEnvKeysOnce(Keyring& ring) {
static bool done = false;
if (done) return;
done = true;
// True once this process's keyring is settled — either because the build's own
// keys were installed, or because a caller replaced them outright. A caller
// that sets keys means exactly that: what it set is what this process holds.
inline bool& keysSettled() {
static bool settled = false;
return settled;
}
// Development only: keys from the environment, and said out loud.
inline void loadEnvKeys(Keyring& ring) {
const char* id = std::getenv("ANSCORE_MODEL_KEY_ID");
const char* priv = std::getenv("ANSCORE_MODEL_BASE_PRIVATE");
Key k{};
@@ -97,12 +104,17 @@ inline void loadEnvKeysOnce(Keyring& ring) {
inline void SetProcessModelKeys(Keyring ring) {
std::lock_guard<std::mutex> lk(detail::keysMutex());
detail::keyringStorage() = std::move(ring);
detail::keysSettled() = true;
}
inline Keyring ProcessModelKeys() {
std::lock_guard<std::mutex> lk(detail::keysMutex());
Keyring& ring = detail::keyringStorage();
detail::loadEnvKeysOnce(ring);
if (!detail::keysSettled()) {
detail::keysSettled() = true;
AddBuiltInKeys(ring); // what this build was given at the ceremony
detail::loadEnvKeys(ring); // and what a developer's environment adds
}
return ring; // by value: the caller may open on another thread
}