#ifndef ANSMODELOPEN_H #define ANSMODELOPEN_H #pragma once // ANSModelOpen — the one place that knows how a model package reaches an engine. // // An engine's "model" has always been a path: a password-protected zip that // ANSODBase inflates into a folder, after which the engine picks out // train_last.onnx, classes.names and model_config.json. A .ansmodel package // replaces all four with one sealed file, and this header is what turns it // back into the things the engines already understand — the model's bytes, the // class list, the task and the input size. // // THE PLAINTEXT NEVER REACHES THE DISK. That is the whole reason the format // 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. // // The base private key must never sit in the binary as one contiguous // constant; assembling it is the job of whatever calls SetProcessModelKeys, // not of this header, which is why this header has no key material in it. // // The development fallback (ANSCORE_MODEL_KEY_ID / ANSCORE_MODEL_BASE_PRIVATE // / ANSCORE_MODEL_ROOT_ID / ANSCORE_MODEL_ROOT_PUBLIC, all base64) exists so // the path can be exercised before that ceremony exists. It is read once and // announced, because a key that came from the environment is not the key a // shipped product should be using. #include #include #include #include #include #include #include "ANSModelPackage.h" namespace ANSCENTER { namespace modelpkg { // ── the keys this process opens packages with ───────────────────────────── namespace detail { inline std::mutex& keysMutex() { static std::mutex m; return m; } inline Keyring& keyringStorage() { static Keyring ring; return ring; } inline bool keyFromB64(const char* b64, Key& out) { if (!b64 || !*b64) return false; std::vector raw; if (!bits::base64Decode(b64, raw) || raw.size() != out.size()) return false; std::memcpy(out.data(), raw.data(), out.size()); 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; const char* id = std::getenv("ANSCORE_MODEL_KEY_ID"); const char* priv = std::getenv("ANSCORE_MODEL_BASE_PRIVATE"); Key k{}; if (id && *id && keyFromB64(priv, k)) { ring.addX25519(id, k); std::fprintf(stderr, "[modelpkg] base key %s taken from the environment - for " "development, not for a shipped build\n", id); } const char* rootId = std::getenv("ANSCORE_MODEL_ROOT_ID"); const char* rootPub = std::getenv("ANSCORE_MODEL_ROOT_PUBLIC"); Key r{}; if (rootId && *rootId && keyFromB64(rootPub, r)) { ring.addRoot(rootId, r); std::fprintf(stderr, "[modelpkg] root key %s taken from the environment\n", rootId); } } } // namespace detail inline void SetProcessModelKeys(Keyring ring) { std::lock_guard lk(detail::keysMutex()); detail::keyringStorage() = std::move(ring); } inline Keyring ProcessModelKeys() { std::lock_guard lk(detail::keysMutex()); Keyring& ring = detail::keyringStorage(); detail::loadEnvKeysOnce(ring); return ring; // by value: the caller may open on another thread } // True once this build can open anything at all. A product that has not had // keys installed should say "this build cannot open model packages" rather // than let every load fail one at a time. inline bool HaveProcessModelKeys() { const Keyring ring = ProcessModelKeys(); return !ring.x25519.empty() || !ring.keys.empty(); } // ── recognising one ─────────────────────────────────────────────────────── inline bool IsPackagePath(const std::string& path) { return path.size() > 9 && path.compare(path.size() - 9, 9, ".ansmodel") == 0; } // ── what an engine needs out of one ─────────────────────────────────────── // Everything the inflated folder used to carry, in the shape the engines read // it: the model itself, the classes in order, and the geometry that // model_config.json held. struct OpenedModel { std::vector model; // decrypted; wipe it once loaded std::vector classes; std::string task; // detection | classification | segmentation | obb | pose std::string family; // yolo | yolo10 | rfdetr std::string runtime; // onnx | openvino-ir std::string legacyMarker; // what the zip would have carried std::string name; // what to call this model in a log int inputWidth = 0; // 0 when the package does not say int inputHeight = 0; std::string warning; // show it; the model still loaded void wipe() { if (!model.empty()) std::memset(model.data(), 0, model.size()); model.clear(); model.shrink_to_fit(); } }; // Read what a package says about itself without decrypting the model. Cheap // enough to call on a folder full of packages. inline bool DescribeModelPackage(const std::string& path, OpenedModel& out, std::string& err) { Package pkg; if (!open(path, ProcessModelKeys(), pkg, err)) return false; const Json& m = pkg.manifest; out.task = m.value("task", std::string("detection")); out.family = m.value("family", std::string()); out.runtime = m.value("runtime", std::string("onnx")); out.legacyMarker = m.value("legacy", Json::object()).value("marker", std::string()); out.warning = pkg.warning; out.classes.clear(); for (const auto& c : m.value("classes", Json::array())) out.classes.push_back(c.value("name", std::string())); const Json in = m.value("input", Json::object()); out.inputWidth = in.value("width", 0); out.inputHeight = in.value("height", 0); out.name = m.value("project", std::string()); if (out.name.empty()) out.name = path; return true; } // Open one all the way: the description above, plus the model's bytes. // // The caller owns those bytes and should wipe them (OpenedModel::wipe) the // moment the session has copied what it needs. inline bool OpenModelPackage(const std::string& path, OpenedModel& out, std::string& err) { if (!HaveProcessModelKeys()) { err = "this build has no model-package key, so it cannot open " + path; return false; } Package pkg; if (!open(path, ProcessModelKeys(), pkg, err)) return false; const std::string entry = pkg.entryPayloadId(); if (entry.empty()) { err = "the package names no model to run"; return false; } if (!readPayload(pkg, entry, out.model, err)) return false; const Json& m = pkg.manifest; out.task = m.value("task", std::string("detection")); out.family = m.value("family", std::string()); out.runtime = m.value("runtime", std::string("onnx")); out.legacyMarker = m.value("legacy", Json::object()).value("marker", std::string()); out.warning = pkg.warning; out.classes.clear(); for (const auto& c : m.value("classes", Json::array())) out.classes.push_back(c.value("name", std::string())); const Json in = m.value("input", Json::object()); out.inputWidth = in.value("width", 0); out.inputHeight = in.value("height", 0); out.name = m.value("project", std::string()); if (out.name.empty()) out.name = path; return true; } } // namespace modelpkg } // namespace ANSCENTER #endif // ANSMODELOPEN_H