feat(ANSModelPackage): read the ANS model package here too
The second reader. A package is one encrypted file — cleartext header, sealed manifest, model bytes sealed in chunks — and this opens it: the content key unwrapped with X25519 against the base key, the header verified as Ed25519 signed by a release key the root vouches for, the model decrypted into memory and handed to ANSModelSource, which the engines already take. It is a new library rather than code inside the engine layer, and deliberately free of the heavy dependencies around it: no CUDA, no OpenCV, no LabVIEW. That is what lets it build and be tested on every platform, including the ones where the engine layer does not build. THE TWO IMPLEMENTATIONS MUST AGREE, so this does not merely claim to: tests/ANSModelPackage-UnitTest/data/interop.ansmodel was written by ANSMINDCORE's packer, and the test opens it here — manifest, classes and a chunked payload, byte for byte. A change to either wire format shows up as this failing. The fixture's keys are derived by published rules, recorded beside it, so anyone can rebuild it. The AEAD and the small primitives are copies of ANSMINDCORE's, not reimplementations, for the same reason. Monocypher 4.0.2 is vendored here as it is there, including the RFC 8032 pair — its default EdDSA signs with BLAKE2b and would not interoperate. Verified by compiling and running the test directly: 19 checks, RFC 8439, RFC 7748 and RFC 8032 vectors, the interop fixture, a round trip, a flipped bit, an unknown root, a revoked signer, and rubbish bytes. ANSCORE's own CMake configure fails on this machine for reasons that predate this change — eight errors with or without it, all missing dependencies — so the new CMake targets still need a real build box. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,314 @@
|
||||
#ifndef ANSAEAD_H
|
||||
#define ANSAEAD_H
|
||||
#pragma once
|
||||
// ANSAead — the AEAD the model package format is sealed with (RFC 8439).
|
||||
//
|
||||
// KEPT IN STEP WITH ANSMINDCORE's src/core/chacha20poly1305.hpp — the same
|
||||
// algorithm, byte for byte, because a package written by one product must open
|
||||
// in the other. Change them together or not at all.
|
||||
//
|
||||
// WHY IN-TREE, and why this cipher. A versioned crypto dependency on every
|
||||
// platform we ship, for a primitive with published test vectors, is a worse
|
||||
// trade than the algorithm itself. ChaCha20-Poly1305 is the one modern AEAD
|
||||
// that is a few
|
||||
// hundred lines of 32-bit arithmetic with no tables, no S-boxes and no
|
||||
// timing-sensitive lookups — AES-GCM needs either hardware instructions or a
|
||||
// GHASH that is easy to get subtly wrong. The suite checks this against the
|
||||
// RFC's own vectors, so it is verified rather than merely present.
|
||||
//
|
||||
// NOT a general crypto library. It seals and opens model packages. The nonce
|
||||
// rule is the caller's to keep: a key and nonce pair must never encrypt twice,
|
||||
// which the package format satisfies by deriving the nonce from a random
|
||||
// per-payload base and the chunk index.
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace ANSCENTER {
|
||||
namespace aead {
|
||||
|
||||
// ── ChaCha20 (RFC 8439 §2.4) ──────────────────────────────────────────────
|
||||
namespace detail {
|
||||
|
||||
inline uint32_t rotl32(uint32_t v, int n) { return (v << n) | (v >> (32 - n)); }
|
||||
|
||||
inline uint32_t load32(const uint8_t* p) {
|
||||
return uint32_t(p[0]) | (uint32_t(p[1]) << 8) | (uint32_t(p[2]) << 16) |
|
||||
(uint32_t(p[3]) << 24);
|
||||
}
|
||||
|
||||
inline void store32(uint8_t* p, uint32_t v) {
|
||||
p[0] = uint8_t(v);
|
||||
p[1] = uint8_t(v >> 8);
|
||||
p[2] = uint8_t(v >> 16);
|
||||
p[3] = uint8_t(v >> 24);
|
||||
}
|
||||
|
||||
inline void chachaBlock(const uint8_t key[32], uint32_t counter,
|
||||
const uint8_t nonce[12], uint8_t out[64]) {
|
||||
static const char kSigma[] = "expand 32-byte k";
|
||||
uint32_t s[16];
|
||||
s[0] = load32(reinterpret_cast<const uint8_t*>(kSigma));
|
||||
s[1] = load32(reinterpret_cast<const uint8_t*>(kSigma) + 4);
|
||||
s[2] = load32(reinterpret_cast<const uint8_t*>(kSigma) + 8);
|
||||
s[3] = load32(reinterpret_cast<const uint8_t*>(kSigma) + 12);
|
||||
for (int i = 0; i < 8; ++i) s[4 + i] = load32(key + 4 * i);
|
||||
s[12] = counter;
|
||||
for (int i = 0; i < 3; ++i) s[13 + i] = load32(nonce + 4 * i);
|
||||
|
||||
uint32_t x[16];
|
||||
std::memcpy(x, s, sizeof(x));
|
||||
auto qr = [&x](int a, int b, int c, int d) {
|
||||
x[a] += x[b]; x[d] = rotl32(x[d] ^ x[a], 16);
|
||||
x[c] += x[d]; x[b] = rotl32(x[b] ^ x[c], 12);
|
||||
x[a] += x[b]; x[d] = rotl32(x[d] ^ x[a], 8);
|
||||
x[c] += x[d]; x[b] = rotl32(x[b] ^ x[c], 7);
|
||||
};
|
||||
for (int i = 0; i < 10; ++i) { // 20 rounds = 10 double rounds
|
||||
qr(0, 4, 8, 12); qr(1, 5, 9, 13); qr(2, 6, 10, 14); qr(3, 7, 11, 15);
|
||||
qr(0, 5, 10, 15); qr(1, 6, 11, 12); qr(2, 7, 8, 13); qr(3, 4, 9, 14);
|
||||
}
|
||||
for (int i = 0; i < 16; ++i) store32(out + 4 * i, x[i] + s[i]);
|
||||
}
|
||||
|
||||
// XOR a buffer with the keystream, starting at `counter`.
|
||||
inline void chacha20Xor(const uint8_t key[32], uint32_t counter,
|
||||
const uint8_t nonce[12], const uint8_t* in, size_t n,
|
||||
uint8_t* out) {
|
||||
uint8_t block[64];
|
||||
size_t done = 0;
|
||||
while (done < n) {
|
||||
chachaBlock(key, counter++, nonce, block);
|
||||
const size_t take = (n - done < 64) ? (n - done) : 64;
|
||||
for (size_t i = 0; i < take; ++i) out[done + i] = in[done + i] ^ block[i];
|
||||
done += take;
|
||||
}
|
||||
}
|
||||
|
||||
// ── Poly1305 (RFC 8439 §2.5), 130-bit accumulator in 26-bit limbs ─────────
|
||||
class Poly1305 {
|
||||
public:
|
||||
explicit Poly1305(const uint8_t key[32]) {
|
||||
r_[0] = (load32(key) ) & 0x3ffffff;
|
||||
r_[1] = (load32(key + 3) >> 2) & 0x3ffff03;
|
||||
r_[2] = (load32(key + 6) >> 4) & 0x3ffc0ff;
|
||||
r_[3] = (load32(key + 9) >> 6) & 0x3f03fff;
|
||||
r_[4] = (load32(key + 12) >> 8) & 0x00fffff;
|
||||
for (int i = 0; i < 4; ++i) pad_[i] = load32(key + 16 + 4 * i);
|
||||
}
|
||||
|
||||
void update(const uint8_t* m, size_t n) {
|
||||
while (n > 0) {
|
||||
const size_t take = (16 - bufLen_ < n) ? (16 - bufLen_) : n;
|
||||
std::memcpy(buf_ + bufLen_, m, take);
|
||||
bufLen_ += take;
|
||||
m += take;
|
||||
n -= take;
|
||||
if (bufLen_ == 16) {
|
||||
block(buf_, false);
|
||||
bufLen_ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void finish(uint8_t tag[16]) {
|
||||
if (bufLen_ > 0) {
|
||||
buf_[bufLen_++] = 1;
|
||||
while (bufLen_ < 16) buf_[bufLen_++] = 0;
|
||||
block(buf_, true);
|
||||
}
|
||||
// Carry propagation, then the conditional subtraction of p = 2^130-5.
|
||||
uint32_t c;
|
||||
c = h_[1] >> 26; h_[1] &= 0x3ffffff; h_[2] += c;
|
||||
c = h_[2] >> 26; h_[2] &= 0x3ffffff; h_[3] += c;
|
||||
c = h_[3] >> 26; h_[3] &= 0x3ffffff; h_[4] += c;
|
||||
c = h_[4] >> 26; h_[4] &= 0x3ffffff; h_[0] += c * 5;
|
||||
c = h_[0] >> 26; h_[0] &= 0x3ffffff; h_[1] += c;
|
||||
|
||||
uint32_t g[5];
|
||||
g[0] = h_[0] + 5; c = g[0] >> 26; g[0] &= 0x3ffffff;
|
||||
g[1] = h_[1] + c; c = g[1] >> 26; g[1] &= 0x3ffffff;
|
||||
g[2] = h_[2] + c; c = g[2] >> 26; g[2] &= 0x3ffffff;
|
||||
g[3] = h_[3] + c; c = g[3] >> 26; g[3] &= 0x3ffffff;
|
||||
g[4] = h_[4] + c - (uint32_t(1) << 26);
|
||||
|
||||
uint32_t mask = (g[4] >> 31) - 1; // all ones when g >= p
|
||||
for (int i = 0; i < 5; ++i) g[i] &= mask;
|
||||
mask = ~mask;
|
||||
for (int i = 0; i < 5; ++i) h_[i] = (h_[i] & mask) | g[i];
|
||||
|
||||
// h modulo 2^128, as four 32-bit words. The narrowing is deliberate: each
|
||||
// word takes the low 32 bits of two limbs, and the only carry between
|
||||
// words is the one the pad addition produces. Keeping the spilled limb
|
||||
// bits in a 64-bit accumulator instead counts them twice — which is a
|
||||
// tag that verifies against itself and against nothing else.
|
||||
const uint32_t w0 = uint32_t((h_[0]) | (h_[1] << 26));
|
||||
const uint32_t w1 = uint32_t((h_[1] >> 6) | (h_[2] << 20));
|
||||
const uint32_t w2 = uint32_t((h_[2] >> 12) | (h_[3] << 14));
|
||||
const uint32_t w3 = uint32_t((h_[3] >> 18) | (h_[4] << 8));
|
||||
|
||||
uint64_t f = uint64_t(w0) + pad_[0];
|
||||
store32(tag, uint32_t(f));
|
||||
f = uint64_t(w1) + pad_[1] + (f >> 32);
|
||||
store32(tag + 4, uint32_t(f));
|
||||
f = uint64_t(w2) + pad_[2] + (f >> 32);
|
||||
store32(tag + 8, uint32_t(f));
|
||||
f = uint64_t(w3) + pad_[3] + (f >> 32);
|
||||
store32(tag + 12, uint32_t(f));
|
||||
}
|
||||
|
||||
private:
|
||||
void block(const uint8_t m[16], bool last) {
|
||||
const uint32_t hibit = last ? 0 : (uint32_t(1) << 24);
|
||||
h_[0] += (load32(m) ) & 0x3ffffff;
|
||||
h_[1] += (load32(m + 3) >> 2) & 0x3ffffff;
|
||||
h_[2] += (load32(m + 6) >> 4) & 0x3ffffff;
|
||||
h_[3] += (load32(m + 9) >> 6) & 0x3ffffff;
|
||||
h_[4] += (load32(m + 12) >> 8) | hibit;
|
||||
|
||||
const uint32_t s1 = r_[1] * 5, s2 = r_[2] * 5, s3 = r_[3] * 5, s4 = r_[4] * 5;
|
||||
uint64_t d0 = uint64_t(h_[0]) * r_[0] + uint64_t(h_[1]) * s4 +
|
||||
uint64_t(h_[2]) * s3 + uint64_t(h_[3]) * s2 +
|
||||
uint64_t(h_[4]) * s1;
|
||||
uint64_t d1 = uint64_t(h_[0]) * r_[1] + uint64_t(h_[1]) * r_[0] +
|
||||
uint64_t(h_[2]) * s4 + uint64_t(h_[3]) * s3 +
|
||||
uint64_t(h_[4]) * s2;
|
||||
uint64_t d2 = uint64_t(h_[0]) * r_[2] + uint64_t(h_[1]) * r_[1] +
|
||||
uint64_t(h_[2]) * r_[0] + uint64_t(h_[3]) * s4 +
|
||||
uint64_t(h_[4]) * s3;
|
||||
uint64_t d3 = uint64_t(h_[0]) * r_[3] + uint64_t(h_[1]) * r_[2] +
|
||||
uint64_t(h_[2]) * r_[1] + uint64_t(h_[3]) * r_[0] +
|
||||
uint64_t(h_[4]) * s4;
|
||||
uint64_t d4 = uint64_t(h_[0]) * r_[4] + uint64_t(h_[1]) * r_[3] +
|
||||
uint64_t(h_[2]) * r_[2] + uint64_t(h_[3]) * r_[1] +
|
||||
uint64_t(h_[4]) * r_[0];
|
||||
|
||||
uint32_t c = uint32_t(d0 >> 26); h_[0] = uint32_t(d0) & 0x3ffffff;
|
||||
d1 += c; c = uint32_t(d1 >> 26); h_[1] = uint32_t(d1) & 0x3ffffff;
|
||||
d2 += c; c = uint32_t(d2 >> 26); h_[2] = uint32_t(d2) & 0x3ffffff;
|
||||
d3 += c; c = uint32_t(d3 >> 26); h_[3] = uint32_t(d3) & 0x3ffffff;
|
||||
d4 += c; c = uint32_t(d4 >> 26); h_[4] = uint32_t(d4) & 0x3ffffff;
|
||||
h_[0] += c * 5; c = h_[0] >> 26; h_[0] &= 0x3ffffff;
|
||||
h_[1] += c;
|
||||
}
|
||||
|
||||
uint32_t r_[5]{};
|
||||
uint32_t h_[5]{};
|
||||
uint32_t pad_[4]{};
|
||||
uint8_t buf_[16]{};
|
||||
size_t bufLen_ = 0;
|
||||
};
|
||||
|
||||
inline void poly1305Pad16(Poly1305& p, size_t n) {
|
||||
static const uint8_t zeros[16] = {0};
|
||||
const size_t rem = n % 16;
|
||||
if (rem) p.update(zeros, 16 - rem);
|
||||
}
|
||||
|
||||
inline void lenLE64(uint64_t v, uint8_t out[8]) {
|
||||
for (int i = 0; i < 8; ++i) out[i] = uint8_t(v >> (8 * i));
|
||||
}
|
||||
|
||||
// Equal in constant time, so a wrong tag leaks nothing through timing.
|
||||
inline bool equalCT(const uint8_t* a, const uint8_t* b, size_t n) {
|
||||
uint8_t diff = 0;
|
||||
for (size_t i = 0; i < n; ++i) diff = uint8_t(diff | (a[i] ^ b[i]));
|
||||
return diff == 0;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// ── AEAD (RFC 8439 §2.8) ──────────────────────────────────────────────────
|
||||
|
||||
inline constexpr size_t kKeyBytes = 32;
|
||||
inline constexpr size_t kNonceBytes = 12;
|
||||
inline constexpr size_t kTagBytes = 16;
|
||||
|
||||
// Seals `plain` in place-independent fashion: `out` receives the ciphertext,
|
||||
// `tag` the authenticator over ciphertext and associated data.
|
||||
inline void aeadSeal(const uint8_t key[kKeyBytes], const uint8_t nonce[kNonceBytes],
|
||||
const uint8_t* aad, size_t aadLen, const uint8_t* plain,
|
||||
size_t plainLen, uint8_t* out, uint8_t tag[kTagBytes]) {
|
||||
uint8_t polyKey[64];
|
||||
const uint8_t zeroIn[64] = {0};
|
||||
detail::chacha20Xor(key, 0, nonce, zeroIn, 64, polyKey); // block 0
|
||||
if (plainLen) detail::chacha20Xor(key, 1, nonce, plain, plainLen, out);
|
||||
|
||||
detail::Poly1305 mac(polyKey);
|
||||
if (aadLen) {
|
||||
mac.update(aad, aadLen);
|
||||
detail::poly1305Pad16(mac, aadLen);
|
||||
}
|
||||
if (plainLen) {
|
||||
mac.update(out, plainLen);
|
||||
detail::poly1305Pad16(mac, plainLen);
|
||||
}
|
||||
uint8_t lens[16];
|
||||
detail::lenLE64(aadLen, lens);
|
||||
detail::lenLE64(plainLen, lens + 8);
|
||||
mac.update(lens, 16);
|
||||
mac.finish(tag);
|
||||
}
|
||||
|
||||
// Opens what aeadSeal produced. Returns false — without writing plaintext the
|
||||
// caller can trust — when the tag does not verify.
|
||||
inline bool aeadOpen(const uint8_t key[kKeyBytes], const uint8_t nonce[kNonceBytes],
|
||||
const uint8_t* aad, size_t aadLen, const uint8_t* cipher,
|
||||
size_t cipherLen, const uint8_t tag[kTagBytes],
|
||||
uint8_t* out) {
|
||||
uint8_t polyKey[64];
|
||||
const uint8_t zeroIn[64] = {0};
|
||||
detail::chacha20Xor(key, 0, nonce, zeroIn, 64, polyKey);
|
||||
|
||||
detail::Poly1305 mac(polyKey);
|
||||
if (aadLen) {
|
||||
mac.update(aad, aadLen);
|
||||
detail::poly1305Pad16(mac, aadLen);
|
||||
}
|
||||
if (cipherLen) {
|
||||
mac.update(cipher, cipherLen);
|
||||
detail::poly1305Pad16(mac, cipherLen);
|
||||
}
|
||||
uint8_t lens[16];
|
||||
detail::lenLE64(aadLen, lens);
|
||||
detail::lenLE64(cipherLen, lens + 8);
|
||||
mac.update(lens, 16);
|
||||
uint8_t want[kTagBytes];
|
||||
mac.finish(want);
|
||||
if (!detail::equalCT(want, tag, kTagBytes)) return false;
|
||||
|
||||
if (cipherLen) detail::chacha20Xor(key, 1, nonce, cipher, cipherLen, out);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Convenience over vectors: ciphertext with the 16-byte tag appended.
|
||||
inline std::vector<uint8_t> seal(const std::array<uint8_t, kKeyBytes>& key,
|
||||
const std::array<uint8_t, kNonceBytes>& nonce,
|
||||
const std::string& aad,
|
||||
const std::vector<uint8_t>& plain) {
|
||||
std::vector<uint8_t> out(plain.size() + kTagBytes);
|
||||
aeadSeal(key.data(), nonce.data(),
|
||||
reinterpret_cast<const uint8_t*>(aad.data()), aad.size(),
|
||||
plain.data(), plain.size(), out.data(), out.data() + plain.size());
|
||||
return out;
|
||||
}
|
||||
|
||||
inline bool open(const std::array<uint8_t, kKeyBytes>& key,
|
||||
const std::array<uint8_t, kNonceBytes>& nonce,
|
||||
const std::string& aad, const std::vector<uint8_t>& sealed,
|
||||
std::vector<uint8_t>& plain) {
|
||||
if (sealed.size() < kTagBytes) return false;
|
||||
const size_t n = sealed.size() - kTagBytes;
|
||||
plain.assign(n, 0);
|
||||
return aeadOpen(key.data(), nonce.data(),
|
||||
reinterpret_cast<const uint8_t*>(aad.data()), aad.size(),
|
||||
sealed.data(), n, sealed.data() + n, plain.data());
|
||||
}
|
||||
|
||||
} // namespace aead
|
||||
} // namespace ANSCENTER
|
||||
|
||||
#endif // ANSAEAD_H
|
||||
@@ -0,0 +1,768 @@
|
||||
#ifndef ANSMODELPACKAGE_H
|
||||
#define ANSMODELPACKAGE_H
|
||||
#pragma once
|
||||
// ANSModelPackage — reading (and, for tools and tests, writing) an ANS model
|
||||
// package: one encrypted file carrying a model, its classes and how to run it.
|
||||
//
|
||||
// KEPT IN STEP WITH ANSMINDCORE's src/model/ansmodel.hpp. The two are the same
|
||||
// format and must stay byte-compatible: the unit test here opens a package
|
||||
// written by THAT implementation, which is what makes "compatible" a fact
|
||||
// rather than an intention. Change them together.
|
||||
//
|
||||
// WHAT THIS REPLACES. A model shipped as a zip under a password every copy of
|
||||
// the software knew — a password that has since been recovered — holding
|
||||
// Categories/<name>.<id>, classes.names, a zero-length backend marker and
|
||||
// train_last.onnx. Opening one meant inflating it to a directory, so the
|
||||
// unprotected model sat on disk, was optimised, and was zipped back into a
|
||||
// cache. This format keeps every fact that bundle carried and changes how it
|
||||
// is carried: the manifest names the classes and the model family, and the
|
||||
// bytes go straight from decryption into the runtime (engine/ibackend's
|
||||
// ModelSource) without touching the filesystem.
|
||||
//
|
||||
// LAYOUT (all integers little-endian, offsets absolute):
|
||||
//
|
||||
// 0 8 magic "ANSMDL\0\0"
|
||||
// 8 2 format version (1)
|
||||
// 10 2 flags, bit 0 = more than one model
|
||||
// 12 4 header length
|
||||
// 16 n cleartext header, UTF-8 JSON — readable without any key
|
||||
// … manifest, sealed — classes, task, family, models
|
||||
// … payloads, sealed in chunks — the model bytes
|
||||
//
|
||||
// WHAT IS IN THE CLEAR, and why so little. The header carries only what a
|
||||
// reader needs before it can decrypt — which key opens the file, where the
|
||||
// sealed parts are — plus an optional card of counts for a store listing.
|
||||
// Class names, metrics and the model's shape are in the manifest, sealed.
|
||||
//
|
||||
// SEALING. ChaCha20-Poly1305 (core/chacha20poly1305) with a content key that
|
||||
// is random per package. Each chunk's nonce is a random per-payload base
|
||||
// followed by the chunk index, and the associated data binds the key id, the
|
||||
// payload id and that index — so a chunk cannot be moved between payloads or
|
||||
// between packages, and a reordered file fails on the first chunk.
|
||||
//
|
||||
// WRAPPING. The content key is sealed to the base key with X25519: an
|
||||
// ephemeral key pair per package, a shared secret against the base public key,
|
||||
// and a key derived from it with HMAC-SHA256. Packaging tools therefore hold
|
||||
// only the PUBLIC half and cannot open what they produce — which is the point
|
||||
// of doing it asymmetrically when a symmetric key would have been simpler. A
|
||||
// package may carry several wraps; a reader takes the first one it holds a key
|
||||
// for. The older symmetric wrap is still read, so packages written before this
|
||||
// keep opening.
|
||||
//
|
||||
// SIGNING. Ed25519 (RFC 8032, via the vendored monocypher-ed25519) over the
|
||||
// header with its own `sig` removed. The signature is made by a RELEASE key
|
||||
// whose public half travels in the package inside a certificate the ROOT key
|
||||
// signed — so an engine that has never seen that release still verifies it,
|
||||
// from the one root key it was built with. That is what lets signing keys
|
||||
// rotate without stranding an engine that cannot be updated.
|
||||
//
|
||||
// EXPIRY AND REVOCATION. An expired certificate WARNS and loads: the date says
|
||||
// when a key was in service, not whether the package is genuine, and an
|
||||
// air-gapped box's clock drifts. A revoked key refuses outright. Strict mode
|
||||
// turns expiry into a refusal for sites that keep accurate time.
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <ctime>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include "ANSAead.h"
|
||||
#include "ANSPackageBits.h"
|
||||
|
||||
extern "C" {
|
||||
#include "monocypher-ed25519.h"
|
||||
#include "monocypher.h"
|
||||
}
|
||||
|
||||
namespace ANSCENTER {
|
||||
namespace modelpkg {
|
||||
|
||||
using Json = nlohmann::json;
|
||||
|
||||
inline constexpr char kMagic[8] = {'A', 'N', 'S', 'M', 'D', 'L', '\0', '\0'};
|
||||
inline constexpr uint16_t kVersion = 1;
|
||||
inline constexpr uint16_t kFlagMultiModel = 1u << 0;
|
||||
inline constexpr const char* kWrapSymmetric = "chacha20poly1305-key";
|
||||
inline constexpr const char* kWrapX25519 = "x25519-hkdf-sha256-chacha20poly1305";
|
||||
inline constexpr const char* kSigEd25519 = "ed25519";
|
||||
inline constexpr uint32_t kDefaultChunk = 4u * 1024 * 1024;
|
||||
|
||||
using Key = std::array<uint8_t, aead::kKeyBytes>;
|
||||
|
||||
// What this build can open and what it trusts.
|
||||
//
|
||||
// A reader holds every base key it has ever shipped, because the base key does
|
||||
// not rotate: a package names the key it was sealed to, and the answer to an
|
||||
// unknown id is "this package needs a newer engine", not a decryption failure.
|
||||
// It holds root public keys, which is how a release signing key it has never
|
||||
// seen is still verified. And it holds the list of signing keys that have been
|
||||
// burned, which is the only thing that refuses a validly signed package.
|
||||
struct Keyring {
|
||||
std::map<std::string, Key> keys; // symmetric base keys (legacy wrap)
|
||||
std::map<std::string, Key> x25519; // base PRIVATE keys, by id
|
||||
std::map<std::string, Key> roots; // root PUBLIC keys, by id
|
||||
std::vector<std::string> revokedSigners;
|
||||
bool strictExpiry = false; // off: an expired cert warns and loads
|
||||
int64_t nowSec = 0; // 0 = ask the clock
|
||||
|
||||
void add(std::string id, const Key& k) { keys[std::move(id)] = k; }
|
||||
void addX25519(std::string id, const Key& priv) { x25519[std::move(id)] = priv; }
|
||||
void addRoot(std::string id, const Key& pub) { roots[std::move(id)] = pub; }
|
||||
bool revoked(const std::string& signerId) const {
|
||||
for (const auto& r : revokedSigners)
|
||||
if (r == signerId) return true;
|
||||
return false;
|
||||
}
|
||||
const Key* find(const std::string& id) const {
|
||||
const auto it = keys.find(id);
|
||||
return it == keys.end() ? nullptr : &it->second;
|
||||
}
|
||||
};
|
||||
|
||||
// One model inside a package: where its bytes are and how they are sealed.
|
||||
struct PayloadRef {
|
||||
std::string id;
|
||||
uint64_t off = 0;
|
||||
uint64_t len = 0; // sealed length, tags included
|
||||
uint32_t chunk = kDefaultChunk;
|
||||
std::array<uint8_t, 4> nonceBase{};
|
||||
};
|
||||
|
||||
// An opened package: everything but the model bytes, which are read on demand
|
||||
// so a two-gigabyte model is never decrypted to answer "what is this?".
|
||||
struct Package {
|
||||
std::string path;
|
||||
uint16_t version = 0;
|
||||
uint16_t flags = 0;
|
||||
std::string keyId;
|
||||
Json header; // the cleartext header, as read
|
||||
Json manifest; // decrypted
|
||||
std::vector<PayloadRef> payloads;
|
||||
Key contentKey{};
|
||||
std::string signerId; // the release key that signed it
|
||||
bool certExpired = false; // loaded anyway; see the header comment
|
||||
std::string warning; // what a caller should show, if anything
|
||||
|
||||
bool multiModel() const { return (flags & kFlagMultiModel) != 0; }
|
||||
// The model a reader should run when it is given no choice: the manifest's
|
||||
// entry model, or the first one.
|
||||
std::string entryPayloadId() const {
|
||||
const auto models = manifest.value("models", Json::array());
|
||||
for (const auto& m : models)
|
||||
if (m.value("entry", false)) return m.value("payload", std::string());
|
||||
if (!models.empty()) return models[0].value("payload", std::string());
|
||||
return payloads.empty() ? std::string() : payloads.front().id;
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
inline uint16_t rd16(const uint8_t* p) { return uint16_t(p[0] | (p[1] << 8)); }
|
||||
inline uint32_t rd32(const uint8_t* p) {
|
||||
return uint32_t(p[0]) | (uint32_t(p[1]) << 8) | (uint32_t(p[2]) << 16) |
|
||||
(uint32_t(p[3]) << 24);
|
||||
}
|
||||
inline void wr16(std::string& out, uint16_t v) {
|
||||
out.push_back(char(v & 0xff));
|
||||
out.push_back(char(v >> 8));
|
||||
}
|
||||
inline void wr32(std::string& out, uint32_t v) {
|
||||
for (int i = 0; i < 4; ++i) out.push_back(char((v >> (8 * i)) & 0xff));
|
||||
}
|
||||
|
||||
inline std::string b64(const std::vector<uint8_t>& v) {
|
||||
return bits::base64Encode(std::string(v.begin(), v.end()));
|
||||
}
|
||||
inline std::vector<uint8_t> unb64(const std::string& s) {
|
||||
std::vector<uint8_t> out;
|
||||
if (!bits::base64Decode(s, out)) out.clear();
|
||||
return out;
|
||||
}
|
||||
|
||||
// The nonce for one chunk: a random per-payload base, then the index. Unique
|
||||
// per (payload, chunk) under a content key that is unique per package.
|
||||
inline std::array<uint8_t, aead::kNonceBytes> chunkNonce(
|
||||
const std::array<uint8_t, 4>& base, uint64_t index) {
|
||||
std::array<uint8_t, aead::kNonceBytes> n{};
|
||||
std::memcpy(n.data(), base.data(), 4);
|
||||
for (int i = 0; i < 8; ++i) n[4 + i] = uint8_t(index >> (8 * i));
|
||||
return n;
|
||||
}
|
||||
|
||||
// What each chunk is bound to. Moving a chunk to another payload, another
|
||||
// index or another package changes this, and the tag then fails.
|
||||
inline std::string chunkAad(const std::string& keyId, const std::string& payloadId,
|
||||
uint64_t index, uint64_t chunkCount) {
|
||||
return "ansmodel/v1|" + keyId + "|" + payloadId + "|" + std::to_string(index) +
|
||||
"|" + std::to_string(chunkCount);
|
||||
}
|
||||
|
||||
// The wrapping key from an X25519 shared secret. HMAC-SHA256 over the secret
|
||||
// with a fixed label, which is HKDF-Extract: the raw secret is not uniform and
|
||||
// must never be used as a key directly.
|
||||
inline Key deriveWrapKey(const uint8_t shared[32], const std::string& keyId) {
|
||||
const std::string salt = "ansmodel/v1|wrap|" + keyId;
|
||||
const auto mac = bits::hmacSha256(
|
||||
reinterpret_cast<const uint8_t*>(salt.data()), salt.size(), shared, 32);
|
||||
Key k{};
|
||||
std::memcpy(k.data(), mac.data(), k.size());
|
||||
return k;
|
||||
}
|
||||
|
||||
// The bytes a signature covers: the header with its own `sig` taken out, as
|
||||
// canonical JSON. nlohmann orders object keys, so a reader that removes the
|
||||
// same field and re-serialises reproduces exactly what the packer signed.
|
||||
inline std::string signedBytes(Json header) {
|
||||
header.erase("sig");
|
||||
return header.dump();
|
||||
}
|
||||
|
||||
// What the root vouches for: this release key, this id, until this date.
|
||||
inline std::string certBytes(const Json& cert) {
|
||||
return "ansmodel/v1|cert|" + cert.value("keyId", std::string()) + "|" +
|
||||
cert.value("pub", std::string()) + "|" +
|
||||
cert.value("notAfter", std::string());
|
||||
}
|
||||
|
||||
inline int64_t nowSeconds() {
|
||||
return int64_t(std::chrono::duration_cast<std::chrono::seconds>(
|
||||
std::chrono::system_clock::now().time_since_epoch())
|
||||
.count());
|
||||
}
|
||||
|
||||
// "2027-09-01T00:00:00Z" → seconds. Returns 0 when it cannot be read, which
|
||||
// is treated as "no expiry stated" rather than "expired".
|
||||
inline int64_t parseIso8601(const std::string& t) {
|
||||
std::tm tm{};
|
||||
if (t.size() < 19) return 0;
|
||||
tm.tm_year = std::atoi(t.substr(0, 4).c_str()) - 1900;
|
||||
tm.tm_mon = std::atoi(t.substr(5, 2).c_str()) - 1;
|
||||
tm.tm_mday = std::atoi(t.substr(8, 2).c_str());
|
||||
tm.tm_hour = std::atoi(t.substr(11, 2).c_str());
|
||||
tm.tm_min = std::atoi(t.substr(14, 2).c_str());
|
||||
tm.tm_sec = std::atoi(t.substr(17, 2).c_str());
|
||||
if (tm.tm_year <= 0 || tm.tm_mon < 0 || tm.tm_mon > 11) return 0;
|
||||
#if defined(_WIN32)
|
||||
return int64_t(_mkgmtime(&tm));
|
||||
#else
|
||||
return int64_t(timegm(&tm));
|
||||
#endif
|
||||
}
|
||||
|
||||
inline uint64_t chunkCountFor(uint64_t sealedLen, uint32_t chunk) {
|
||||
const uint64_t perChunk = chunk + aead::kTagBytes;
|
||||
return (sealedLen + perChunk - 1) / perChunk;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// ── reading ───────────────────────────────────────────────────────────────
|
||||
|
||||
// Open the header and manifest. Does not read a single model byte.
|
||||
inline bool open(const std::string& path, const Keyring& ring, Package& out,
|
||||
std::string& err) {
|
||||
out = Package{};
|
||||
out.path = path;
|
||||
std::ifstream f(path, std::ios::binary);
|
||||
if (!f) {
|
||||
err = "cannot open " + path;
|
||||
return false;
|
||||
}
|
||||
uint8_t fixed[16];
|
||||
f.read(reinterpret_cast<char*>(fixed), sizeof(fixed));
|
||||
if (f.gcount() != std::streamsize(sizeof(fixed))) {
|
||||
err = "not a model package: file is too short";
|
||||
return false;
|
||||
}
|
||||
if (std::memcmp(fixed, kMagic, sizeof(kMagic)) != 0) {
|
||||
err = "not a model package: wrong magic";
|
||||
return false;
|
||||
}
|
||||
out.version = detail::rd16(fixed + 8);
|
||||
out.flags = detail::rd16(fixed + 10);
|
||||
if (out.version > kVersion) {
|
||||
err = "this package is format version " + std::to_string(out.version) +
|
||||
", which needs a newer ANS engine";
|
||||
return false;
|
||||
}
|
||||
const uint32_t headerLen = detail::rd32(fixed + 12);
|
||||
if (headerLen == 0 || headerLen > 8u * 1024 * 1024) {
|
||||
err = "header length is not plausible";
|
||||
return false;
|
||||
}
|
||||
std::string headerText(headerLen, '\0');
|
||||
f.read(headerText.data(), headerLen);
|
||||
if (f.gcount() != std::streamsize(headerLen)) {
|
||||
err = "truncated: the header is not all there";
|
||||
return false;
|
||||
}
|
||||
out.header = Json::parse(headerText, nullptr, false);
|
||||
if (out.header.is_discarded()) {
|
||||
err = "the header is not readable JSON";
|
||||
return false;
|
||||
}
|
||||
|
||||
// ── the signature, before anything is decrypted ────────────────────────
|
||||
const Json sig = out.header.value("sig", Json::object());
|
||||
if (sig.is_null() || sig.empty()) {
|
||||
err = "the package is not signed";
|
||||
return false;
|
||||
}
|
||||
const std::string sigAlg = sig.value("alg", std::string());
|
||||
if (sigAlg == kSigEd25519) {
|
||||
const Json cert = sig.value("cert", Json::object());
|
||||
const std::string signerId = cert.value("keyId", std::string());
|
||||
const std::string rootId = cert.value("rootKeyId", std::string());
|
||||
const auto signerPub = detail::unb64(cert.value("pub", std::string()));
|
||||
const auto rootSig = detail::unb64(cert.value("rootSig", std::string()));
|
||||
const auto headerSig = detail::unb64(sig.value("value", std::string()));
|
||||
if (signerPub.size() != 32 || rootSig.size() != 64 || headerSig.size() != 64) {
|
||||
err = "the signature block is malformed";
|
||||
return false;
|
||||
}
|
||||
if (ring.revoked(signerId)) {
|
||||
err = "this package was signed with a key that has been revoked (" +
|
||||
signerId + ")";
|
||||
return false;
|
||||
}
|
||||
const auto rootIt = ring.roots.find(rootId);
|
||||
if (rootIt == ring.roots.end()) {
|
||||
err = "the package is vouched for by an unknown root (" + rootId + ")";
|
||||
return false;
|
||||
}
|
||||
// The root vouches for the release key; the release key signs the header.
|
||||
const std::string cb = detail::certBytes(cert);
|
||||
if (crypto_ed25519_check(rootSig.data(), rootIt->second.data(),
|
||||
reinterpret_cast<const uint8_t*>(cb.data()),
|
||||
cb.size()) != 0) {
|
||||
err = "the signing key is not vouched for by the root it names";
|
||||
return false;
|
||||
}
|
||||
const std::string sb = detail::signedBytes(out.header);
|
||||
if (crypto_ed25519_check(headerSig.data(), signerPub.data(),
|
||||
reinterpret_cast<const uint8_t*>(sb.data()),
|
||||
sb.size()) != 0) {
|
||||
err = "the package signature does not verify — it has been altered";
|
||||
return false;
|
||||
}
|
||||
out.signerId = signerId;
|
||||
// Expiry is a fact about the key's service, not about this package's
|
||||
// authenticity, and an air-gapped clock drifts. Warn and load; strict
|
||||
// mode is for sites that would rather fail closed.
|
||||
const int64_t notAfter = detail::parseIso8601(cert.value("notAfter", std::string()));
|
||||
const int64_t now = ring.nowSec > 0 ? ring.nowSec : detail::nowSeconds();
|
||||
if (notAfter > 0 && now > notAfter) {
|
||||
out.certExpired = true;
|
||||
out.warning = "signed with a certificate that expired on " +
|
||||
cert.value("notAfter", std::string()) + " (key " + signerId + ")";
|
||||
if (ring.strictExpiry) {
|
||||
err = out.warning + " — refused because strict expiry is on";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else if (sigAlg != "none") {
|
||||
err = "the package is signed in a way this build does not know (" + sigAlg + ")";
|
||||
return false;
|
||||
}
|
||||
|
||||
// Which key opens it. Every wrap is tried, so a package sealed to several
|
||||
// keys opens on any engine holding one of them.
|
||||
const auto wraps = out.header.value("wraps", Json::array());
|
||||
if (wraps.empty()) {
|
||||
err = "the package names no key";
|
||||
return false;
|
||||
}
|
||||
std::vector<std::string> unknown;
|
||||
bool unwrapped = false;
|
||||
for (const auto& w : wraps) {
|
||||
const std::string keyId = w.value("keyId", std::string());
|
||||
const std::string alg = w.value("alg", std::string());
|
||||
const auto nonceBytes = detail::unb64(w.value("nonce", std::string()));
|
||||
const auto ct = detail::unb64(w.value("ct", std::string()));
|
||||
if (nonceBytes.size() != aead::kNonceBytes ||
|
||||
ct.size() != aead::kKeyBytes + aead::kTagBytes) {
|
||||
err = "the wrapped key is malformed";
|
||||
return false;
|
||||
}
|
||||
std::array<uint8_t, aead::kNonceBytes> nonce{};
|
||||
std::memcpy(nonce.data(), nonceBytes.data(), nonce.size());
|
||||
|
||||
// The key that opens THIS wrap: either an X25519 shared secret against the
|
||||
// ephemeral public key the packer left here, or — for packages written
|
||||
// before the curve was vendored — the symmetric base key.
|
||||
Key unwrapKey{};
|
||||
if (alg == kWrapX25519) {
|
||||
const auto it = ring.x25519.find(keyId);
|
||||
if (it == ring.x25519.end()) {
|
||||
unknown.push_back(keyId);
|
||||
continue;
|
||||
}
|
||||
const auto epk = detail::unb64(w.value("epk", std::string()));
|
||||
if (epk.size() != 32) {
|
||||
err = "the wrap carries no usable ephemeral key";
|
||||
return false;
|
||||
}
|
||||
uint8_t shared[32];
|
||||
crypto_x25519(shared, it->second.data(), epk.data());
|
||||
unwrapKey = detail::deriveWrapKey(shared, keyId);
|
||||
crypto_wipe(shared, sizeof(shared));
|
||||
} else if (alg == kWrapSymmetric) {
|
||||
const Key* k = ring.find(keyId);
|
||||
if (!k) {
|
||||
unknown.push_back(keyId);
|
||||
continue;
|
||||
}
|
||||
unwrapKey = *k;
|
||||
} else {
|
||||
err = "the package uses an unsupported wrap (" + alg + ")";
|
||||
return false;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> plain;
|
||||
if (!aead::open(unwrapKey, nonce, "ansmodel/v1|wrap|" + keyId, ct, plain)) {
|
||||
err = "the wrapped key does not open with " + keyId +
|
||||
" — the file is damaged or was sealed to a different key";
|
||||
return false;
|
||||
}
|
||||
std::memcpy(out.contentKey.data(), plain.data(), out.contentKey.size());
|
||||
out.keyId = keyId;
|
||||
unwrapped = true;
|
||||
break;
|
||||
}
|
||||
if (!unwrapped) {
|
||||
err = "this package needs a newer ANS engine: it is sealed to key " +
|
||||
(unknown.empty() ? std::string("(unnamed)") : unknown.front());
|
||||
return false;
|
||||
}
|
||||
|
||||
// Where the sealed parts are.
|
||||
for (const auto& p : out.header.value("payloads", Json::array())) {
|
||||
PayloadRef r;
|
||||
r.id = p.value("id", std::string());
|
||||
r.off = p.value("off", uint64_t(0));
|
||||
r.len = p.value("len", uint64_t(0));
|
||||
r.chunk = p.value("chunk", kDefaultChunk);
|
||||
const auto nb = detail::unb64(p.value("nonceBase", std::string()));
|
||||
if (r.id.empty() || r.len == 0 || r.chunk == 0 || nb.size() != 4) {
|
||||
err = "a payload entry is malformed";
|
||||
return false;
|
||||
}
|
||||
std::memcpy(r.nonceBase.data(), nb.data(), 4);
|
||||
out.payloads.push_back(r);
|
||||
}
|
||||
if (out.payloads.empty()) {
|
||||
err = "the package carries no model";
|
||||
return false;
|
||||
}
|
||||
|
||||
// The manifest, sealed as a single chunk under the payload id "manifest".
|
||||
const Json m = out.header.value("manifest", Json::object());
|
||||
const uint64_t moff = m.value("off", uint64_t(0));
|
||||
const uint64_t mlen = m.value("len", uint64_t(0));
|
||||
const auto mnb = detail::unb64(m.value("nonceBase", std::string()));
|
||||
if (mlen == 0 || mnb.size() != 4) {
|
||||
err = "the manifest entry is malformed";
|
||||
return false;
|
||||
}
|
||||
std::vector<uint8_t> sealed(static_cast<size_t>(mlen), 0);
|
||||
f.seekg(std::streamoff(moff));
|
||||
f.read(reinterpret_cast<char*>(sealed.data()), std::streamsize(mlen));
|
||||
if (f.gcount() != std::streamsize(mlen)) {
|
||||
err = "truncated: the manifest is not all there";
|
||||
return false;
|
||||
}
|
||||
std::array<uint8_t, 4> mbase{};
|
||||
std::memcpy(mbase.data(), mnb.data(), 4);
|
||||
std::vector<uint8_t> manifestText;
|
||||
if (!aead::open(out.contentKey, detail::chunkNonce(mbase, 0),
|
||||
detail::chunkAad(out.keyId, "manifest", 0, 1), sealed,
|
||||
manifestText)) {
|
||||
err = "the manifest does not verify — the package has been altered";
|
||||
return false;
|
||||
}
|
||||
out.manifest =
|
||||
Json::parse(std::string(manifestText.begin(), manifestText.end()), nullptr,
|
||||
false);
|
||||
if (out.manifest.is_discarded()) {
|
||||
err = "the manifest is not readable JSON";
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Decrypt one model into memory. Chunk by chunk, each verified as it is read,
|
||||
// so a damaged file fails on the chunk that is wrong rather than after the
|
||||
// whole thing has been decrypted.
|
||||
inline bool readPayload(const Package& pkg, const std::string& payloadId,
|
||||
std::vector<uint8_t>& out, std::string& err) {
|
||||
const PayloadRef* ref = nullptr;
|
||||
for (const auto& p : pkg.payloads)
|
||||
if (p.id == payloadId) ref = &p;
|
||||
if (!ref) {
|
||||
err = "no model called " + payloadId + " in this package";
|
||||
return false;
|
||||
}
|
||||
std::ifstream f(pkg.path, std::ios::binary);
|
||||
if (!f) {
|
||||
err = "cannot reopen " + pkg.path;
|
||||
return false;
|
||||
}
|
||||
f.seekg(std::streamoff(ref->off));
|
||||
const uint64_t chunks = detail::chunkCountFor(ref->len, ref->chunk);
|
||||
out.clear();
|
||||
out.reserve(size_t(ref->len));
|
||||
std::vector<uint8_t> sealed;
|
||||
std::vector<uint8_t> plain;
|
||||
uint64_t remaining = ref->len;
|
||||
for (uint64_t i = 0; i < chunks; ++i) {
|
||||
const uint64_t take =
|
||||
remaining < uint64_t(ref->chunk) + aead::kTagBytes
|
||||
? remaining
|
||||
: uint64_t(ref->chunk) + aead::kTagBytes;
|
||||
sealed.assign(size_t(take), 0);
|
||||
f.read(reinterpret_cast<char*>(sealed.data()), std::streamsize(take));
|
||||
if (f.gcount() != std::streamsize(take)) {
|
||||
err = "truncated: model " + payloadId + " stops at chunk " +
|
||||
std::to_string(i);
|
||||
return false;
|
||||
}
|
||||
if (!aead::open(pkg.contentKey, detail::chunkNonce(ref->nonceBase, i),
|
||||
detail::chunkAad(pkg.keyId, ref->id, i, chunks), sealed,
|
||||
plain)) {
|
||||
err = "chunk " + std::to_string(i) + " of " + payloadId +
|
||||
" does not verify — the package has been altered";
|
||||
out.clear();
|
||||
return false;
|
||||
}
|
||||
out.insert(out.end(), plain.begin(), plain.end());
|
||||
remaining -= take;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// ── writing (tools and tests) ─────────────────────────────────────────────
|
||||
//
|
||||
// The product's packages are written by the training box. This exists so the
|
||||
// reader can be tested against files built by something other than itself,
|
||||
// and so a converter can turn today's zip bundles into packages.
|
||||
|
||||
struct PackModel {
|
||||
std::string id; // payload id, e.g. "p0"
|
||||
std::vector<uint8_t> bytes;
|
||||
};
|
||||
|
||||
struct PackRequest {
|
||||
std::string keyId;
|
||||
Key key{}; // symmetric base key (legacy wrap)
|
||||
// Wrap to a base PUBLIC key instead, which is what a real packer does: it
|
||||
// can then produce packages it cannot itself open.
|
||||
bool useX25519 = false;
|
||||
Key basePublic{};
|
||||
// Sign as a release key the root vouches for. Empty signerSecret writes an
|
||||
// unsigned package, which only tests should ever want.
|
||||
std::string signerId;
|
||||
std::vector<uint8_t> signerSecret; // 64 bytes, RFC 8032
|
||||
std::vector<uint8_t> signerPublic; // 32 bytes
|
||||
std::string rootKeyId;
|
||||
std::vector<uint8_t> rootSig; // 64 bytes over the certificate
|
||||
std::string notAfter; // ISO-8601, may be empty
|
||||
Json manifest;
|
||||
Json card; // optional, counts only
|
||||
std::vector<PackModel> models;
|
||||
uint32_t chunk = kDefaultChunk; // smaller in tests, to exercise chunking
|
||||
// Deterministic nonces are for TESTS ONLY: a real package draws them from
|
||||
// the platform CSPRNG, because a repeated (key, nonce) pair is fatal.
|
||||
uint8_t nonceSeed = 0;
|
||||
};
|
||||
|
||||
inline bool pack(const std::string& path, const PackRequest& req,
|
||||
std::string& err) {
|
||||
if (req.models.empty()) {
|
||||
err = "a package with no model describes nothing";
|
||||
return false;
|
||||
}
|
||||
// A content key per package. Tests pass a seed; a real packer must use the
|
||||
// platform CSPRNG here.
|
||||
Key contentKey{};
|
||||
for (size_t i = 0; i < contentKey.size(); ++i)
|
||||
contentKey[i] = uint8_t(req.nonceSeed * 31 + i * 7 + 11);
|
||||
|
||||
auto sealChunked = [&](const std::vector<uint8_t>& plain,
|
||||
const std::string& payloadId,
|
||||
const std::array<uint8_t, 4>& base,
|
||||
std::string& blob) {
|
||||
const uint64_t chunks =
|
||||
plain.empty() ? 1 : (plain.size() + req.chunk - 1) / req.chunk;
|
||||
for (uint64_t i = 0; i < chunks; ++i) {
|
||||
const size_t from = size_t(i * req.chunk);
|
||||
const size_t take = std::min<size_t>(req.chunk, plain.size() - from);
|
||||
std::vector<uint8_t> part(plain.begin() + from, plain.begin() + from + take);
|
||||
const auto sealed =
|
||||
aead::seal(contentKey, detail::chunkNonce(base, i),
|
||||
detail::chunkAad(req.keyId, payloadId, i, chunks), part);
|
||||
blob.append(reinterpret_cast<const char*>(sealed.data()), sealed.size());
|
||||
}
|
||||
};
|
||||
|
||||
// The manifest first, then each model, so the header can name their offsets.
|
||||
const std::string manifestText = req.manifest.dump();
|
||||
const std::vector<uint8_t> manifestBytes(manifestText.begin(),
|
||||
manifestText.end());
|
||||
std::array<uint8_t, 4> manifestBase{uint8_t(req.nonceSeed + 1), 2, 3, 4};
|
||||
std::string manifestBlob;
|
||||
{
|
||||
const auto sealed =
|
||||
aead::seal(contentKey, detail::chunkNonce(manifestBase, 0),
|
||||
detail::chunkAad(req.keyId, "manifest", 0, 1),
|
||||
manifestBytes);
|
||||
manifestBlob.assign(reinterpret_cast<const char*>(sealed.data()),
|
||||
sealed.size());
|
||||
}
|
||||
|
||||
std::vector<std::string> blobs;
|
||||
std::vector<std::array<uint8_t, 4>> bases;
|
||||
for (size_t i = 0; i < req.models.size(); ++i) {
|
||||
std::array<uint8_t, 4> base{uint8_t(req.nonceSeed + 10 + i), 5, 6, 7};
|
||||
std::string blob;
|
||||
sealChunked(req.models[i].bytes, req.models[i].id, base, blob);
|
||||
blobs.push_back(std::move(blob));
|
||||
bases.push_back(base);
|
||||
}
|
||||
|
||||
// Wrap the content key to the base key. One wrap here; the header's shape
|
||||
// takes several, which is how a package opens on more than one key.
|
||||
std::array<uint8_t, aead::kNonceBytes> wrapNonce{};
|
||||
for (size_t i = 0; i < wrapNonce.size(); ++i)
|
||||
wrapNonce[i] = uint8_t(req.nonceSeed + 100 + i);
|
||||
const std::vector<uint8_t> keyPlain(contentKey.begin(), contentKey.end());
|
||||
|
||||
Key wrapKey = req.key;
|
||||
std::vector<uint8_t> epk;
|
||||
if (req.useX25519) {
|
||||
// An ephemeral key pair per package: its public half travels in the
|
||||
// header, its private half dies here, and the packer never holds anything
|
||||
// that opens the result.
|
||||
Key esk{};
|
||||
for (size_t i = 0; i < esk.size(); ++i)
|
||||
esk[i] = uint8_t(req.nonceSeed * 13 + i * 5 + 3);
|
||||
epk.assign(32, 0);
|
||||
crypto_x25519_public_key(epk.data(), esk.data());
|
||||
uint8_t shared[32];
|
||||
crypto_x25519(shared, esk.data(), req.basePublic.data());
|
||||
wrapKey = detail::deriveWrapKey(shared, req.keyId);
|
||||
crypto_wipe(shared, sizeof(shared));
|
||||
crypto_wipe(esk.data(), esk.size());
|
||||
}
|
||||
const auto wrapped = aead::seal(wrapKey, wrapNonce,
|
||||
"ansmodel/v1|wrap|" + req.keyId, keyPlain);
|
||||
|
||||
// Header offsets are known once the sizes are: the header is written first,
|
||||
// so its own length has to be settled before the offsets inside it. Build it
|
||||
// with placeholder offsets, measure, then fill them in — the size cannot
|
||||
// change, because the numbers are written with a fixed width.
|
||||
auto buildHeader = [&](uint64_t headerLen) {
|
||||
Json h;
|
||||
h["format"] = "ansmodel";
|
||||
h["version"] = int(kVersion);
|
||||
Json wrap{{"keyId", req.keyId},
|
||||
{"alg", req.useX25519 ? kWrapX25519 : kWrapSymmetric},
|
||||
{"nonce", detail::b64(std::vector<uint8_t>(wrapNonce.begin(),
|
||||
wrapNonce.end()))},
|
||||
{"ct", detail::b64(wrapped)}};
|
||||
if (req.useX25519) wrap["epk"] = detail::b64(epk);
|
||||
h["wraps"] = Json::array({wrap});
|
||||
uint64_t at = 16 + headerLen;
|
||||
h["manifest"] = Json{{"off", at},
|
||||
{"len", uint64_t(manifestBlob.size())},
|
||||
{"nonceBase", detail::b64(std::vector<uint8_t>(
|
||||
manifestBase.begin(), manifestBase.end()))}};
|
||||
at += manifestBlob.size();
|
||||
Json payloads = Json::array();
|
||||
for (size_t i = 0; i < blobs.size(); ++i) {
|
||||
payloads.push_back(Json{
|
||||
{"id", req.models[i].id},
|
||||
{"off", at},
|
||||
{"len", uint64_t(blobs[i].size())},
|
||||
{"chunk", req.chunk},
|
||||
{"nonceBase", detail::b64(std::vector<uint8_t>(bases[i].begin(),
|
||||
bases[i].end()))},
|
||||
{"sha256", bits::sha256Hex(std::string(blobs[i].begin(), blobs[i].end()))}});
|
||||
at += blobs[i].size();
|
||||
}
|
||||
h["payloads"] = payloads;
|
||||
if (!req.card.is_null()) h["card"] = req.card;
|
||||
// The signature is written last, over everything above: `sig` is added
|
||||
// with a placeholder of the exact length the real one takes, so signing
|
||||
// cannot change the header's size and the offsets stay true.
|
||||
if (req.signerSecret.size() == 64 && req.signerPublic.size() == 32) {
|
||||
h["sig"] = Json{{"alg", kSigEd25519},
|
||||
{"value", std::string(88, 'A')},
|
||||
{"cert", Json{{"keyId", req.signerId},
|
||||
{"pub", detail::b64(req.signerPublic)},
|
||||
{"notAfter", req.notAfter},
|
||||
{"rootKeyId", req.rootKeyId},
|
||||
{"rootSig", detail::b64(req.rootSig)}}}};
|
||||
} else {
|
||||
h["sig"] = Json{{"alg", "none"}, {"value", ""}};
|
||||
}
|
||||
return h;
|
||||
};
|
||||
|
||||
// Two passes: the first measures, the second is written. Offsets are plain
|
||||
// JSON numbers, so a longer offset could lengthen the header — hence the
|
||||
// loop, which settles in one extra step.
|
||||
std::string headerText = buildHeader(0).dump();
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
const std::string next = buildHeader(headerText.size()).dump();
|
||||
if (next.size() == headerText.size()) {
|
||||
headerText = next;
|
||||
break;
|
||||
}
|
||||
headerText = next;
|
||||
}
|
||||
Json header = buildHeader(headerText.size());
|
||||
if (req.signerSecret.size() == 64) {
|
||||
// Sign the header as the reader will read it: without `sig`, canonically
|
||||
// serialised. The placeholder above keeps the length identical, so putting
|
||||
// the real signature in changes no offset.
|
||||
const std::string sb = detail::signedBytes(header);
|
||||
std::vector<uint8_t> value(64, 0);
|
||||
crypto_ed25519_sign(value.data(), req.signerSecret.data(),
|
||||
reinterpret_cast<const uint8_t*>(sb.data()), sb.size());
|
||||
header["sig"]["value"] = detail::b64(value);
|
||||
}
|
||||
headerText = header.dump();
|
||||
|
||||
std::string file(kMagic, sizeof(kMagic));
|
||||
detail::wr16(file, kVersion);
|
||||
detail::wr16(file, req.models.size() > 1 ? kFlagMultiModel : uint16_t(0));
|
||||
detail::wr32(file, uint32_t(headerText.size()));
|
||||
file += headerText;
|
||||
file += manifestBlob;
|
||||
for (const auto& b : blobs) file += b;
|
||||
|
||||
std::ofstream o(path, std::ios::binary | std::ios::trunc);
|
||||
if (!o) {
|
||||
err = "cannot write " + path;
|
||||
return false;
|
||||
}
|
||||
o.write(file.data(), std::streamsize(file.size()));
|
||||
if (!o) {
|
||||
err = "failed while writing " + path;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace modelpkg
|
||||
} // namespace ANSCENTER
|
||||
|
||||
#endif // ANSMODELPACKAGE_H
|
||||
@@ -0,0 +1,326 @@
|
||||
#ifndef ANSPACKAGEBITS_H
|
||||
#define ANSPACKAGEBITS_H
|
||||
#pragma once
|
||||
// ANSPackageBits — base64, SHA-256 and HMAC-SHA256 for the model package.
|
||||
//
|
||||
// TAKEN FROM ANSMINDCORE (src/core/base64.hpp, src/core/sha256.hpp) unchanged,
|
||||
// for the same reason the AEAD is: a package written by one product must open
|
||||
// in the other, and two implementations of the same transform are two chances
|
||||
// to disagree. The suite checks these against the published vectors.
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace ANSCENTER {
|
||||
namespace bits {
|
||||
|
||||
// core/base64 — RFC 4648 base64, encode and decode.
|
||||
//
|
||||
// Needed by ONVIF's WS-Security UsernameToken (the nonce and the password
|
||||
// digest both travel base64-encoded) and useful anywhere bytes must cross a
|
||||
// text channel. Decode is strict about alphabet and padding: this parses
|
||||
// values that arrive from a camera on the network, and quietly accepting
|
||||
// malformed input is how a length assumption downstream turns into a bug.
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
// ── base64 ───────────────────────────────────────────────────────────────
|
||||
|
||||
inline std::string base64Encode(const uint8_t* p, size_t n) {
|
||||
static const char* kAlpha =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
std::string out;
|
||||
out.reserve(((n + 2) / 3) * 4);
|
||||
size_t i = 0;
|
||||
for (; i + 2 < n; i += 3) {
|
||||
const uint32_t v = uint32_t(p[i]) << 16 | uint32_t(p[i + 1]) << 8 | p[i + 2];
|
||||
out += kAlpha[(v >> 18) & 0x3F];
|
||||
out += kAlpha[(v >> 12) & 0x3F];
|
||||
out += kAlpha[(v >> 6) & 0x3F];
|
||||
out += kAlpha[v & 0x3F];
|
||||
}
|
||||
if (i + 1 == n) {
|
||||
const uint32_t v = uint32_t(p[i]) << 16;
|
||||
out += kAlpha[(v >> 18) & 0x3F];
|
||||
out += kAlpha[(v >> 12) & 0x3F];
|
||||
out += "==";
|
||||
} else if (i + 2 == n) {
|
||||
const uint32_t v = uint32_t(p[i]) << 16 | uint32_t(p[i + 1]) << 8;
|
||||
out += kAlpha[(v >> 18) & 0x3F];
|
||||
out += kAlpha[(v >> 12) & 0x3F];
|
||||
out += kAlpha[(v >> 6) & 0x3F];
|
||||
out += '=';
|
||||
}
|
||||
return out;
|
||||
}
|
||||
inline std::string base64Encode(const std::string& s) {
|
||||
return base64Encode(reinterpret_cast<const uint8_t*>(s.data()), s.size());
|
||||
}
|
||||
template <size_t N>
|
||||
inline std::string base64Encode(const std::array<uint8_t, N>& a) {
|
||||
return base64Encode(a.data(), a.size());
|
||||
}
|
||||
|
||||
// Returns false on any character outside the alphabet, bad padding, or a
|
||||
// length that is not a multiple of 4. Whitespace is skipped: XML puts
|
||||
// newlines inside base64 elements.
|
||||
inline bool base64Decode(const std::string& in, std::vector<uint8_t>& out) {
|
||||
auto val = [](char c) -> int {
|
||||
if (c >= 'A' && c <= 'Z') return c - 'A';
|
||||
if (c >= 'a' && c <= 'z') return c - 'a' + 26;
|
||||
if (c >= '0' && c <= '9') return c - '0' + 52;
|
||||
if (c == '+') return 62;
|
||||
if (c == '/') return 63;
|
||||
return -1;
|
||||
};
|
||||
constexpr int kPad = -2;
|
||||
out.clear();
|
||||
int quad[4] = {0, 0, 0, 0};
|
||||
int have = 0;
|
||||
bool padded = false; // once padding starts, only more padding may follow
|
||||
for (char c : in) {
|
||||
if (c == ' ' || c == '\t' || c == '\n' || c == '\r') continue;
|
||||
int v;
|
||||
if (c == '=') {
|
||||
v = kPad;
|
||||
padded = true;
|
||||
} else {
|
||||
if (padded) return false; // data after padding
|
||||
v = val(c);
|
||||
if (v < 0) return false;
|
||||
}
|
||||
quad[have++] = v;
|
||||
if (have < 4) continue;
|
||||
|
||||
// Padding is only legal in the last one or two positions.
|
||||
if (quad[0] == kPad || quad[1] == kPad) return false;
|
||||
if (quad[2] == kPad && quad[3] != kPad) return false;
|
||||
const int pad = (quad[2] == kPad ? 2 : 0) + (quad[2] != kPad &&
|
||||
quad[3] == kPad ? 1 : 0);
|
||||
const uint32_t acc = uint32_t(quad[0]) << 18 | uint32_t(quad[1]) << 12 |
|
||||
uint32_t(pad >= 2 ? 0 : quad[2]) << 6 |
|
||||
uint32_t(pad >= 1 ? 0 : quad[3]);
|
||||
out.push_back(uint8_t(acc >> 16));
|
||||
if (pad < 2) out.push_back(uint8_t(acc >> 8));
|
||||
if (pad < 1) out.push_back(uint8_t(acc));
|
||||
have = 0;
|
||||
}
|
||||
return have == 0; // a trailing partial group is malformed
|
||||
}
|
||||
|
||||
|
||||
|
||||
// core/sha256 — SHA-256 and HMAC-SHA256, in-tree.
|
||||
//
|
||||
// WHY IN-TREE. The only consumer is AWS Signature Version 4 request signing
|
||||
// for the S3 evidence store. Linking OpenSSL for two hash functions would put
|
||||
// a versioned crypto dependency into the worker's Depends on every platform
|
||||
// we ship — the same trap the bundled ONNX Runtime exists to avoid — in
|
||||
// exchange for ~150 lines of algorithm that has fixed, published test
|
||||
// vectors. The suite checks this against the FIPS 180-4 and RFC 4231 vectors,
|
||||
// so it is verified rather than merely present.
|
||||
//
|
||||
// NOT a general crypto library. It exists to sign requests: there is no
|
||||
// constant-time comparison here, and nothing in this file should ever be
|
||||
// used for password hashing or key derivation from a low-entropy secret.
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
// ── SHA-256 and HMAC-SHA256 ──────────────────────────────────────────────
|
||||
|
||||
class Sha256 {
|
||||
public:
|
||||
static constexpr size_t kDigestLen = 32;
|
||||
|
||||
Sha256() { reset(); }
|
||||
|
||||
void reset() {
|
||||
len_ = 0;
|
||||
bufLen_ = 0;
|
||||
static const uint32_t kInit[8] = {0x6a09e667u, 0xbb67ae85u, 0x3c6ef372u,
|
||||
0xa54ff53au, 0x510e527fu, 0x9b05688cu,
|
||||
0x1f83d9abu, 0x5be0cd19u};
|
||||
std::memcpy(h_, kInit, sizeof h_);
|
||||
}
|
||||
|
||||
void update(const uint8_t* p, size_t n) {
|
||||
len_ += n;
|
||||
while (n) {
|
||||
const size_t take = (n < 64 - bufLen_) ? n : (64 - bufLen_);
|
||||
std::memcpy(buf_ + bufLen_, p, take);
|
||||
bufLen_ += take;
|
||||
p += take;
|
||||
n -= take;
|
||||
if (bufLen_ == 64) {
|
||||
block(buf_);
|
||||
bufLen_ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
void update(const std::string& s) {
|
||||
update(reinterpret_cast<const uint8_t*>(s.data()), s.size());
|
||||
}
|
||||
|
||||
// Consumes the state; call reset() to reuse.
|
||||
void finish(uint8_t out[kDigestLen]) {
|
||||
const uint64_t bits = uint64_t(len_) * 8; // captured BEFORE padding
|
||||
uint8_t b = 0x80;
|
||||
update(&b, 1);
|
||||
b = 0;
|
||||
while (bufLen_ != 56) update(&b, 1);
|
||||
uint8_t lenBe[8];
|
||||
for (int i = 0; i < 8; ++i) lenBe[i] = uint8_t(bits >> (56 - 8 * i));
|
||||
update(lenBe, 8);
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
out[i * 4 + 0] = uint8_t(h_[i] >> 24);
|
||||
out[i * 4 + 1] = uint8_t(h_[i] >> 16);
|
||||
out[i * 4 + 2] = uint8_t(h_[i] >> 8);
|
||||
out[i * 4 + 3] = uint8_t(h_[i]);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
static uint32_t rotr(uint32_t x, int n) {
|
||||
return (x >> n) | (x << (32 - n));
|
||||
}
|
||||
|
||||
void block(const uint8_t* p) {
|
||||
// First 32 bits of the fractional parts of the cube roots of the first
|
||||
// 64 primes (FIPS 180-4 §4.2.2).
|
||||
static const uint32_t k[64] = {
|
||||
0x428a2f98u, 0x71374491u, 0xb5c0fbcfu, 0xe9b5dba5u, 0x3956c25bu,
|
||||
0x59f111f1u, 0x923f82a4u, 0xab1c5ed5u, 0xd807aa98u, 0x12835b01u,
|
||||
0x243185beu, 0x550c7dc3u, 0x72be5d74u, 0x80deb1feu, 0x9bdc06a7u,
|
||||
0xc19bf174u, 0xe49b69c1u, 0xefbe4786u, 0x0fc19dc6u, 0x240ca1ccu,
|
||||
0x2de92c6fu, 0x4a7484aau, 0x5cb0a9dcu, 0x76f988dau, 0x983e5152u,
|
||||
0xa831c66du, 0xb00327c8u, 0xbf597fc7u, 0xc6e00bf3u, 0xd5a79147u,
|
||||
0x06ca6351u, 0x14292967u, 0x27b70a85u, 0x2e1b2138u, 0x4d2c6dfcu,
|
||||
0x53380d13u, 0x650a7354u, 0x766a0abbu, 0x81c2c92eu, 0x92722c85u,
|
||||
0xa2bfe8a1u, 0xa81a664bu, 0xc24b8b70u, 0xc76c51a3u, 0xd192e819u,
|
||||
0xd6990624u, 0xf40e3585u, 0x106aa070u, 0x19a4c116u, 0x1e376c08u,
|
||||
0x2748774cu, 0x34b0bcb5u, 0x391c0cb3u, 0x4ed8aa4au, 0x5b9cca4fu,
|
||||
0x682e6ff3u, 0x748f82eeu, 0x78a5636fu, 0x84c87814u, 0x8cc70208u,
|
||||
0x90befffau, 0xa4506cebu, 0xbef9a3f7u, 0xc67178f2u};
|
||||
uint32_t w[64];
|
||||
for (int i = 0; i < 16; ++i)
|
||||
w[i] = uint32_t(p[i * 4]) << 24 | uint32_t(p[i * 4 + 1]) << 16 |
|
||||
uint32_t(p[i * 4 + 2]) << 8 | uint32_t(p[i * 4 + 3]);
|
||||
for (int i = 16; i < 64; ++i) {
|
||||
const uint32_t s0 =
|
||||
rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >> 3);
|
||||
const uint32_t s1 =
|
||||
rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >> 10);
|
||||
w[i] = w[i - 16] + s0 + w[i - 7] + s1;
|
||||
}
|
||||
uint32_t a = h_[0], b = h_[1], c = h_[2], d = h_[3];
|
||||
uint32_t e = h_[4], f = h_[5], g = h_[6], hh = h_[7];
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
const uint32_t S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
|
||||
const uint32_t ch = (e & f) ^ (~e & g);
|
||||
const uint32_t t1 = hh + S1 + ch + k[i] + w[i];
|
||||
const uint32_t S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
|
||||
const uint32_t maj = (a & b) ^ (a & c) ^ (b & c);
|
||||
const uint32_t t2 = S0 + maj;
|
||||
hh = g; g = f; f = e; e = d + t1;
|
||||
d = c; c = b; b = a; a = t1 + t2;
|
||||
}
|
||||
h_[0] += a; h_[1] += b; h_[2] += c; h_[3] += d;
|
||||
h_[4] += e; h_[5] += f; h_[6] += g; h_[7] += hh;
|
||||
}
|
||||
|
||||
uint32_t h_[8];
|
||||
uint8_t buf_[64];
|
||||
size_t bufLen_ = 0;
|
||||
uint64_t len_ = 0;
|
||||
};
|
||||
|
||||
using Digest256 = std::array<uint8_t, 32>;
|
||||
|
||||
inline Digest256 sha256(const uint8_t* p, size_t n) {
|
||||
Sha256 s;
|
||||
s.update(p, n);
|
||||
Digest256 out{};
|
||||
s.finish(out.data());
|
||||
return out;
|
||||
}
|
||||
inline Digest256 sha256(const std::string& s) {
|
||||
return sha256(reinterpret_cast<const uint8_t*>(s.data()), s.size());
|
||||
}
|
||||
|
||||
inline std::string toHex(const uint8_t* p, size_t n) {
|
||||
static const char* kHex = "0123456789abcdef";
|
||||
std::string out;
|
||||
out.reserve(n * 2);
|
||||
for (size_t i = 0; i < n; ++i) {
|
||||
out += kHex[p[i] >> 4];
|
||||
out += kHex[p[i] & 0xF];
|
||||
}
|
||||
return out;
|
||||
}
|
||||
inline std::string toHex(const Digest256& d) {
|
||||
return toHex(d.data(), d.size());
|
||||
}
|
||||
|
||||
inline std::string sha256Hex(const uint8_t* p, size_t n) {
|
||||
return toHex(sha256(p, n));
|
||||
}
|
||||
inline std::string sha256Hex(const std::string& s) {
|
||||
return toHex(sha256(s));
|
||||
}
|
||||
|
||||
// RFC 2104 HMAC with SHA-256.
|
||||
inline Digest256 hmacSha256(const uint8_t* key, size_t keyLen,
|
||||
const uint8_t* msg, size_t msgLen) {
|
||||
uint8_t k[64] = {0};
|
||||
if (keyLen > 64) {
|
||||
Sha256 s;
|
||||
s.update(key, keyLen);
|
||||
s.finish(k); // remaining 32 bytes stay zero-padded
|
||||
} else {
|
||||
std::memcpy(k, key, keyLen);
|
||||
}
|
||||
uint8_t ipad[64], opad[64];
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
ipad[i] = uint8_t(k[i] ^ 0x36);
|
||||
opad[i] = uint8_t(k[i] ^ 0x5c);
|
||||
}
|
||||
uint8_t inner[32];
|
||||
{
|
||||
Sha256 s;
|
||||
s.update(ipad, 64);
|
||||
s.update(msg, msgLen);
|
||||
s.finish(inner);
|
||||
}
|
||||
Digest256 out{};
|
||||
{
|
||||
Sha256 s;
|
||||
s.update(opad, 64);
|
||||
s.update(inner, 32);
|
||||
s.finish(out.data());
|
||||
}
|
||||
return out;
|
||||
}
|
||||
inline Digest256 hmacSha256(const std::string& key, const std::string& msg) {
|
||||
return hmacSha256(reinterpret_cast<const uint8_t*>(key.data()), key.size(),
|
||||
reinterpret_cast<const uint8_t*>(msg.data()), msg.size());
|
||||
}
|
||||
inline Digest256 hmacSha256(const Digest256& key, const std::string& msg) {
|
||||
return hmacSha256(key.data(), key.size(),
|
||||
reinterpret_cast<const uint8_t*>(msg.data()), msg.size());
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // namespace bits
|
||||
} // namespace ANSCENTER
|
||||
|
||||
#endif // ANSPACKAGEBITS_H
|
||||
@@ -0,0 +1,31 @@
|
||||
# ANSModelPackage — reading an ANS model package (.ansmodel).
|
||||
#
|
||||
# Header-only apart from the vendored curves, and deliberately free of the
|
||||
# heavy dependencies around it: no CUDA, no OpenCV, no LabVIEW. That is what
|
||||
# lets it build — and be tested — on every platform, including the ones where
|
||||
# the engine layer does not build at all.
|
||||
add_library(ANSModelPackage STATIC
|
||||
${CMAKE_SOURCE_DIR}/3rdparty/monocypher/monocypher.c
|
||||
${CMAKE_SOURCE_DIR}/3rdparty/monocypher/monocypher-ed25519.c
|
||||
)
|
||||
|
||||
target_include_directories(ANSModelPackage PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${CMAKE_SOURCE_DIR}/3rdparty/monocypher
|
||||
)
|
||||
|
||||
# nlohmann/json comes from vcpkg on Windows and the system elsewhere, the same
|
||||
# way ANSFR already takes it.
|
||||
if(WIN32)
|
||||
target_include_directories(ANSModelPackage PUBLIC ${VCPKG_INCLUDE_DIR})
|
||||
else()
|
||||
find_path(ANSCORE_NLOHMANN_INCLUDE nlohmann/json.hpp
|
||||
HINTS /opt/homebrew/include /usr/local/include /usr/include)
|
||||
if(ANSCORE_NLOHMANN_INCLUDE)
|
||||
target_include_directories(ANSModelPackage PUBLIC ${ANSCORE_NLOHMANN_INCLUDE})
|
||||
else()
|
||||
message(WARNING "nlohmann/json.hpp not found — ANSModelPackage will not build")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
set_target_properties(ANSModelPackage PROPERTIES POSITION_INDEPENDENT_CODE ON)
|
||||
Reference in New Issue
Block a user