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>
315 lines
12 KiB
C++
315 lines
12 KiB
C++
#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
|