From 6c164c3d0f0a2ffa3027b0106651022eae104726 Mon Sep 17 00:00:00 2001 From: Tuan Nghia Nguyen Date: Sat, 12 Sep 2026 21:24:53 +1000 Subject: [PATCH] feat(ANSModelPackage): read the ANS model package here too MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 --- 3rdparty/monocypher/LICENCE.md | 167 + 3rdparty/monocypher/README.anscore.md | 13 + 3rdparty/monocypher/monocypher-ed25519.c | 500 +++ 3rdparty/monocypher/monocypher-ed25519.h | 140 + 3rdparty/monocypher/monocypher.c | 2956 +++++++++++++++++ 3rdparty/monocypher/monocypher.h | 321 ++ CMakeLists.txt | 1 + core/ANSModelPackage/ANSAead.h | 314 ++ core/ANSModelPackage/ANSModelPackage.h | 768 +++++ core/ANSModelPackage/ANSPackageBits.h | 326 ++ core/ANSModelPackage/CMakeLists.txt | 31 + .../ANSModelPackage-UnitTest.cpp | 263 ++ tests/ANSModelPackage-UnitTest/CMakeLists.txt | 9 + tests/ANSModelPackage-UnitTest/data/README.md | 23 + .../data/interop.ansmodel | Bin 0 -> 13242 bytes tests/CMakeLists.txt | 1 + 16 files changed, 5833 insertions(+) create mode 100644 3rdparty/monocypher/LICENCE.md create mode 100644 3rdparty/monocypher/README.anscore.md create mode 100644 3rdparty/monocypher/monocypher-ed25519.c create mode 100644 3rdparty/monocypher/monocypher-ed25519.h create mode 100644 3rdparty/monocypher/monocypher.c create mode 100644 3rdparty/monocypher/monocypher.h create mode 100644 core/ANSModelPackage/ANSAead.h create mode 100644 core/ANSModelPackage/ANSModelPackage.h create mode 100644 core/ANSModelPackage/ANSPackageBits.h create mode 100644 core/ANSModelPackage/CMakeLists.txt create mode 100644 tests/ANSModelPackage-UnitTest/ANSModelPackage-UnitTest.cpp create mode 100644 tests/ANSModelPackage-UnitTest/CMakeLists.txt create mode 100644 tests/ANSModelPackage-UnitTest/data/README.md create mode 100644 tests/ANSModelPackage-UnitTest/data/interop.ansmodel diff --git a/3rdparty/monocypher/LICENCE.md b/3rdparty/monocypher/LICENCE.md new file mode 100644 index 0000000..9c3fae9 --- /dev/null +++ b/3rdparty/monocypher/LICENCE.md @@ -0,0 +1,167 @@ +Monocypher as a whole is dual-licensed. Choose whichever licence you +want from the two licences listed below. + +The first licence is a regular 2-clause BSD licence. The second licence +is the CC-0 from Creative Commons. It is intended to release Monocypher +to the public domain. The BSD licence serves as a fallback option. + +See the individual files for specific information about who contributed +to what file during which years. See below for special notes. + +Licence 1 (2-clause BSD) +------------------------ + +Copyright (c) 2017-2023, Loup Vaillant +Copyright (c) 2017-2019, Michael Savage +Copyright (c) 2017-2023, Fabio Scotoni +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the + distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Licence 2 (CC-0) +---------------- + +> CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE +> LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN +> ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS +> INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES +> REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS +> PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM +> THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED +> HEREUNDER. + +### Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer +exclusive Copyright and Related Rights (defined below) upon the creator +and subsequent owner(s) (each and all, an "owner") of an original work +of authorship and/or a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for +the purpose of contributing to a commons of creative, cultural and +scientific works ("Commons") that the public can reliably and without +fear of later claims of infringement build upon, modify, incorporate in +other works, reuse and redistribute as freely as possible in any form +whatsoever and for any purposes, including without limitation commercial +purposes. These owners may contribute to the Commons to promote the +ideal of a free culture and the further production of creative, cultural +and scientific works, or to gain reputation or greater distribution for +their Work in part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any +expectation of additional consideration or compensation, the person +associating CC0 with a Work (the "Affirmer"), to the extent that he or +she is an owner of Copyright and Related Rights in the Work, voluntarily +elects to apply CC0 to the Work and publicly distribute the Work under +its terms, with knowledge of his or her Copyright and Related Rights in +the Work and the meaning and intended legal effect of CC0 on those +rights. + +1. **Copyright and Related Rights.** A Work made available under CC0 may + be protected by copyright and related or neighboring rights + ("Copyright and Related Rights"). Copyright and Related Rights + include, but are not limited to, the following: + + - the right to reproduce, adapt, distribute, perform, display, + communicate, and translate a Work; + - moral rights retained by the original author(s) and/or + performer(s); publicity and privacy rights pertaining to a person's + image or likeness depicted in a Work; + - rights protecting against unfair competition in regards to a Work, + subject to the limitations in paragraph 4(a), below; + - rights protecting the extraction, dissemination, use and reuse of + data in a Work; + - database rights (such as those arising under Directive 96/9/EC of + the European Parliament and of the Council of 11 March 1996 on the + legal protection of databases, and under any national + implementation thereof, including any amended or successor version + of such directive); and + - other similar, equivalent or corresponding rights throughout the + world based on applicable law or treaty, and any national + implementations thereof. + +2. **Waiver.** To the greatest extent permitted by, but not in + contravention of, applicable law, Affirmer hereby overtly, fully, + permanently, irrevocably and unconditionally waives, abandons, and + surrenders all of Affirmer's Copyright and Related Rights and + associated claims and causes of action, whether now known or unknown + (including existing as well as future claims and causes of action), + in the Work (i) in all territories worldwide, (ii) for the maximum + duration provided by applicable law or treaty (including future time + extensions), (iii) in any current or future medium and for any number + of copies, and (iv) for any purpose whatsoever, including without + limitation commercial, advertising or promotional purposes (the + "Waiver"). Affirmer makes the Waiver for the benefit of each member + of the public at large and to the detriment of Affirmer's heirs and + successors, fully intending that such Waiver shall not be subject to + revocation, rescission, cancellation, termination, or any other legal + or equitable action to disrupt the quiet enjoyment of the Work by the + public as contemplated by Affirmer's express Statement of Purpose. + +3. **Public License Fallback.** Should any part of the Waiver for any + reason be judged legally invalid or ineffective under applicable law, + then the Waiver shall be preserved to the maximum extent permitted + taking into account Affirmer's express Statement of Purpose. In + addition, to the extent the Waiver is so judged Affirmer hereby + grants to each affected person a royalty-free, non transferable, non + sublicensable, non exclusive, irrevocable and unconditional license + to exercise Affirmer's Copyright and Related Rights in the Work (i) + in all territories worldwide, (ii) for the maximum duration provided + by applicable law or treaty (including future time extensions), (iii) + in any current or future medium and for any number of copies, and + (iv) for any purpose whatsoever, including without limitation + commercial, advertising or promotional purposes (the "License"). The + License shall be deemed effective as of the date CC0 was applied by + Affirmer to the Work. Should any part of the License for any reason + be judged legally invalid or ineffective under applicable law, such + partial invalidity or ineffectiveness shall not invalidate the + remainder of the License, and in such case Affirmer hereby affirms + that he or she will not (i) exercise any of his or her remaining + Copyright and Related Rights in the Work or (ii) assert any + associated claims and causes of action with respect to the Work, in + either case contrary to Affirmer's express Statement of Purpose. + +4. **Limitations and Disclaimers.** + + - No trademark or patent rights held by Affirmer are waived, + abandoned, surrendered, licensed or otherwise affected by this + document. + - Affirmer offers the Work as-is and makes no representations or + warranties of any kind concerning the Work, express, implied, + statutory or otherwise, including without limitation warranties of + title, merchantability, fitness for a particular purpose, non + infringement, or the absence of latent or other defects, accuracy, + or the present or absence of errors, whether or not discoverable, + all to the greatest extent permissible under applicable law. + - Affirmer disclaims responsibility for clearing rights of other + persons that may apply to the Work or any use thereof, including + without limitation any person's Copyright and Related Rights in the + Work. Further, Affirmer disclaims responsibility for obtaining any + necessary consents, permissions or other rights required for any + use of the Work. + - Affirmer understands and acknowledges that Creative Commons is not + a party to this document and has no duty or obligation with respect + to this CC0 or use of the Work. diff --git a/3rdparty/monocypher/README.anscore.md b/3rdparty/monocypher/README.anscore.md new file mode 100644 index 0000000..4e71bc2 --- /dev/null +++ b/3rdparty/monocypher/README.anscore.md @@ -0,0 +1,13 @@ +# Monocypher 4.0.2 — vendored + +Source: https://monocypher.org/download/monocypher-4.0.2.tar.gz +Files: `monocypher.c/.h`, `monocypher-ed25519.c/.h`, `LICENCE.md`. Unmodified. +Licence: dual 2-clause BSD / CC-0. + +Here for the model package format (`core/ANSModelPackage`): X25519 to unwrap a +package's content key, and RFC 8032 Ed25519 to prove where the package came +from. The `-ed25519` pair is not optional — Monocypher's own EdDSA signs with +BLAKE2b, which would not interoperate with a package signed anywhere else. + +ANSMINDCORE vendors the same release for the same reason. The two readers must +stay byte-compatible, so update them together and run both suites. diff --git a/3rdparty/monocypher/monocypher-ed25519.c b/3rdparty/monocypher/monocypher-ed25519.c new file mode 100644 index 0000000..1dbcfbb --- /dev/null +++ b/3rdparty/monocypher/monocypher-ed25519.c @@ -0,0 +1,500 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#include "monocypher-ed25519.h" + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#endif + +///////////////// +/// Utilities /// +///////////////// +#define FOR(i, min, max) for (size_t i = min; i < max; i++) +#define COPY(dst, src, size) FOR(_i_, 0, size) (dst)[_i_] = (src)[_i_] +#define ZERO(buf, size) FOR(_i_, 0, size) (buf)[_i_] = 0 +#define WIPE_CTX(ctx) crypto_wipe(ctx , sizeof(*(ctx))) +#define WIPE_BUFFER(buffer) crypto_wipe(buffer, sizeof(buffer)) +#define MIN(a, b) ((a) <= (b) ? (a) : (b)) +typedef uint8_t u8; +typedef uint64_t u64; + +// Returns the smallest positive integer y such that +// (x + y) % pow_2 == 0 +// Basically, it's how many bytes we need to add to "align" x. +// Only works when pow_2 is a power of 2. +// Note: we use ~x+1 instead of -x to avoid compiler warnings +static size_t align(size_t x, size_t pow_2) +{ + return (~x + 1) & (pow_2 - 1); +} + +static u64 load64_be(const u8 s[8]) +{ + return((u64)s[0] << 56) + | ((u64)s[1] << 48) + | ((u64)s[2] << 40) + | ((u64)s[3] << 32) + | ((u64)s[4] << 24) + | ((u64)s[5] << 16) + | ((u64)s[6] << 8) + | (u64)s[7]; +} + +static void store64_be(u8 out[8], u64 in) +{ + out[0] = (in >> 56) & 0xff; + out[1] = (in >> 48) & 0xff; + out[2] = (in >> 40) & 0xff; + out[3] = (in >> 32) & 0xff; + out[4] = (in >> 24) & 0xff; + out[5] = (in >> 16) & 0xff; + out[6] = (in >> 8) & 0xff; + out[7] = in & 0xff; +} + +static void load64_be_buf (u64 *dst, const u8 *src, size_t size) { + FOR(i, 0, size) { dst[i] = load64_be(src + i*8); } +} + +/////////////// +/// SHA 512 /// +/////////////// +static u64 rot(u64 x, int c ) { return (x >> c) | (x << (64 - c)); } +static u64 ch (u64 x, u64 y, u64 z) { return (x & y) ^ (~x & z); } +static u64 maj(u64 x, u64 y, u64 z) { return (x & y) ^ ( x & z) ^ (y & z); } +static u64 big_sigma0(u64 x) { return rot(x, 28) ^ rot(x, 34) ^ rot(x, 39); } +static u64 big_sigma1(u64 x) { return rot(x, 14) ^ rot(x, 18) ^ rot(x, 41); } +static u64 lit_sigma0(u64 x) { return rot(x, 1) ^ rot(x, 8) ^ (x >> 7); } +static u64 lit_sigma1(u64 x) { return rot(x, 19) ^ rot(x, 61) ^ (x >> 6); } + +static const u64 K[80] = { + 0x428a2f98d728ae22,0x7137449123ef65cd,0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc, + 0x3956c25bf348b538,0x59f111f1b605d019,0x923f82a4af194f9b,0xab1c5ed5da6d8118, + 0xd807aa98a3030242,0x12835b0145706fbe,0x243185be4ee4b28c,0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f,0x80deb1fe3b1696b1,0x9bdc06a725c71235,0xc19bf174cf692694, + 0xe49b69c19ef14ad2,0xefbe4786384f25e3,0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65, + 0x2de92c6f592b0275,0x4a7484aa6ea6e483,0x5cb0a9dcbd41fbd4,0x76f988da831153b5, + 0x983e5152ee66dfab,0xa831c66d2db43210,0xb00327c898fb213f,0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2,0xd5a79147930aa725,0x06ca6351e003826f,0x142929670a0e6e70, + 0x27b70a8546d22ffc,0x2e1b21385c26c926,0x4d2c6dfc5ac42aed,0x53380d139d95b3df, + 0x650a73548baf63de,0x766a0abb3c77b2a8,0x81c2c92e47edaee6,0x92722c851482353b, + 0xa2bfe8a14cf10364,0xa81a664bbc423001,0xc24b8b70d0f89791,0xc76c51a30654be30, + 0xd192e819d6ef5218,0xd69906245565a910,0xf40e35855771202a,0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8,0x1e376c085141ab53,0x2748774cdf8eeb99,0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb,0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc,0x78a5636f43172f60,0x84c87814a1f0ab72,0x8cc702081a6439ec, + 0x90befffa23631e28,0xa4506cebde82bde9,0xbef9a3f7b2c67915,0xc67178f2e372532b, + 0xca273eceea26619c,0xd186b8c721c0c207,0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178, + 0x06f067aa72176fba,0x0a637dc5a2c898a6,0x113f9804bef90dae,0x1b710b35131c471b, + 0x28db77f523047d84,0x32caab7b40c72493,0x3c9ebe0a15c9bebc,0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6,0x597f299cfc657e2a,0x5fcb6fab3ad6faec,0x6c44198c4a475817 +}; + +static void sha512_compress(crypto_sha512_ctx *ctx) +{ + u64 a = ctx->hash[0]; u64 b = ctx->hash[1]; + u64 c = ctx->hash[2]; u64 d = ctx->hash[3]; + u64 e = ctx->hash[4]; u64 f = ctx->hash[5]; + u64 g = ctx->hash[6]; u64 h = ctx->hash[7]; + + FOR (j, 0, 16) { + u64 in = K[j] + ctx->input[j]; + u64 t1 = big_sigma1(e) + ch (e, f, g) + h + in; + u64 t2 = big_sigma0(a) + maj(a, b, c); + h = g; g = f; f = e; e = d + t1; + d = c; c = b; b = a; a = t1 + t2; + } + size_t i16 = 0; + FOR(i, 1, 5) { + i16 += 16; + FOR (j, 0, 16) { + ctx->input[j] += lit_sigma1(ctx->input[(j- 2) & 15]); + ctx->input[j] += lit_sigma0(ctx->input[(j-15) & 15]); + ctx->input[j] += ctx->input[(j- 7) & 15]; + u64 in = K[i16 + j] + ctx->input[j]; + u64 t1 = big_sigma1(e) + ch (e, f, g) + h + in; + u64 t2 = big_sigma0(a) + maj(a, b, c); + h = g; g = f; f = e; e = d + t1; + d = c; c = b; b = a; a = t1 + t2; + } + } + + ctx->hash[0] += a; ctx->hash[1] += b; + ctx->hash[2] += c; ctx->hash[3] += d; + ctx->hash[4] += e; ctx->hash[5] += f; + ctx->hash[6] += g; ctx->hash[7] += h; +} + +// Write 1 input byte +static void sha512_set_input(crypto_sha512_ctx *ctx, u8 input) +{ + size_t word = ctx->input_idx >> 3; + size_t byte = ctx->input_idx & 7; + ctx->input[word] |= (u64)input << (8 * (7 - byte)); +} + +// Increment a 128-bit "word". +static void sha512_incr(u64 x[2], u64 y) +{ + x[1] += y; + if (x[1] < y) { + x[0]++; + } +} + +void crypto_sha512_init(crypto_sha512_ctx *ctx) +{ + ctx->hash[0] = 0x6a09e667f3bcc908; + ctx->hash[1] = 0xbb67ae8584caa73b; + ctx->hash[2] = 0x3c6ef372fe94f82b; + ctx->hash[3] = 0xa54ff53a5f1d36f1; + ctx->hash[4] = 0x510e527fade682d1; + ctx->hash[5] = 0x9b05688c2b3e6c1f; + ctx->hash[6] = 0x1f83d9abfb41bd6b; + ctx->hash[7] = 0x5be0cd19137e2179; + ctx->input_size[0] = 0; + ctx->input_size[1] = 0; + ctx->input_idx = 0; + ZERO(ctx->input, 16); +} + +void crypto_sha512_update(crypto_sha512_ctx *ctx, + const u8 *message, size_t message_size) +{ + // Avoid undefined NULL pointer increments with empty messages + if (message_size == 0) { + return; + } + + // Align ourselves with word boundaries + if ((ctx->input_idx & 7) != 0) { + size_t nb_bytes = MIN(align(ctx->input_idx, 8), message_size); + FOR (i, 0, nb_bytes) { + sha512_set_input(ctx, message[i]); + ctx->input_idx++; + } + message += nb_bytes; + message_size -= nb_bytes; + } + + // Align ourselves with block boundaries + if ((ctx->input_idx & 127) != 0) { + size_t nb_words = MIN(align(ctx->input_idx, 128), message_size) >> 3; + load64_be_buf(ctx->input + (ctx->input_idx >> 3), message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + } + + // Compress block if needed + if (ctx->input_idx == 128) { + sha512_incr(ctx->input_size, 1024); // size is in bits + sha512_compress(ctx); + ctx->input_idx = 0; + ZERO(ctx->input, 16); + } + + // Process the message block by block + FOR (i, 0, message_size >> 7) { // number of blocks + load64_be_buf(ctx->input, message, 16); + sha512_incr(ctx->input_size, 1024); // size is in bits + sha512_compress(ctx); + ctx->input_idx = 0; + ZERO(ctx->input, 16); + message += 128; + } + message_size &= 127; + + if (message_size != 0) { + // Remaining words + size_t nb_words = message_size >> 3; + load64_be_buf(ctx->input, message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + + // Remaining bytes + FOR (i, 0, message_size) { + sha512_set_input(ctx, message[i]); + ctx->input_idx++; + } + } +} + +void crypto_sha512_final(crypto_sha512_ctx *ctx, u8 hash[64]) +{ + // Add padding bit + if (ctx->input_idx == 0) { + ZERO(ctx->input, 16); + } + sha512_set_input(ctx, 128); + + // Update size + sha512_incr(ctx->input_size, ctx->input_idx * 8); + + // Compress penultimate block (if any) + if (ctx->input_idx > 111) { + sha512_compress(ctx); + ZERO(ctx->input, 14); + } + // Compress last block + ctx->input[14] = ctx->input_size[0]; + ctx->input[15] = ctx->input_size[1]; + sha512_compress(ctx); + + // Copy hash to output (big endian) + FOR (i, 0, 8) { + store64_be(hash + i*8, ctx->hash[i]); + } + + WIPE_CTX(ctx); +} + +void crypto_sha512(u8 hash[64], const u8 *message, size_t message_size) +{ + crypto_sha512_ctx ctx; + crypto_sha512_init (&ctx); + crypto_sha512_update(&ctx, message, message_size); + crypto_sha512_final (&ctx, hash); +} + +//////////////////// +/// HMAC SHA 512 /// +//////////////////// +void crypto_sha512_hmac_init(crypto_sha512_hmac_ctx *ctx, + const u8 *key, size_t key_size) +{ + // hash key if it is too long + if (key_size > 128) { + crypto_sha512(ctx->key, key, key_size); + key = ctx->key; + key_size = 64; + } + // Compute inner key: padded key XOR 0x36 + FOR (i, 0, key_size) { ctx->key[i] = key[i] ^ 0x36; } + FOR (i, key_size, 128) { ctx->key[i] = 0x36; } + // Start computing inner hash + crypto_sha512_init (&ctx->ctx); + crypto_sha512_update(&ctx->ctx, ctx->key, 128); +} + +void crypto_sha512_hmac_update(crypto_sha512_hmac_ctx *ctx, + const u8 *message, size_t message_size) +{ + crypto_sha512_update(&ctx->ctx, message, message_size); +} + +void crypto_sha512_hmac_final(crypto_sha512_hmac_ctx *ctx, u8 hmac[64]) +{ + // Finish computing inner hash + crypto_sha512_final(&ctx->ctx, hmac); + // Compute outer key: padded key XOR 0x5c + FOR (i, 0, 128) { + ctx->key[i] ^= 0x36 ^ 0x5c; + } + // Compute outer hash + crypto_sha512_init (&ctx->ctx); + crypto_sha512_update(&ctx->ctx, ctx->key , 128); + crypto_sha512_update(&ctx->ctx, hmac, 64); + crypto_sha512_final (&ctx->ctx, hmac); // outer hash + WIPE_CTX(ctx); +} + +void crypto_sha512_hmac(u8 hmac[64], const u8 *key, size_t key_size, + const u8 *message, size_t message_size) +{ + crypto_sha512_hmac_ctx ctx; + crypto_sha512_hmac_init (&ctx, key, key_size); + crypto_sha512_hmac_update(&ctx, message, message_size); + crypto_sha512_hmac_final (&ctx, hmac); +} + +//////////////////// +/// HKDF SHA 512 /// +//////////////////// +void crypto_sha512_hkdf_expand(u8 *okm, size_t okm_size, + const u8 *prk, size_t prk_size, + const u8 *info, size_t info_size) +{ + int not_first = 0; + u8 ctr = 1; + u8 blk[64]; + + while (okm_size > 0) { + size_t out_size = MIN(okm_size, sizeof(blk)); + + crypto_sha512_hmac_ctx ctx; + crypto_sha512_hmac_init(&ctx, prk , prk_size); + if (not_first) { + // For some reason HKDF uses some kind of CBC mode. + // For some reason CTR mode alone wasn't enough. + // Like what, they didn't trust HMAC in 2010? Really?? + crypto_sha512_hmac_update(&ctx, blk , sizeof(blk)); + } + crypto_sha512_hmac_update(&ctx, info, info_size); + crypto_sha512_hmac_update(&ctx, &ctr, 1); + crypto_sha512_hmac_final(&ctx, blk); + + COPY(okm, blk, out_size); + + not_first = 1; + okm += out_size; + okm_size -= out_size; + ctr++; + } +} + +void crypto_sha512_hkdf(u8 *okm , size_t okm_size, + const u8 *ikm , size_t ikm_size, + const u8 *salt, size_t salt_size, + const u8 *info, size_t info_size) +{ + // Extract + u8 prk[64]; + crypto_sha512_hmac(prk, salt, salt_size, ikm, ikm_size); + + // Expand + crypto_sha512_hkdf_expand(okm, okm_size, prk, sizeof(prk), info, info_size); +} + +/////////////// +/// Ed25519 /// +/////////////// +void crypto_ed25519_key_pair(u8 secret_key[64], u8 public_key[32], u8 seed[32]) +{ + u8 a[64]; + COPY(a, seed, 32); // a[ 0..31] = seed + crypto_wipe(seed, 32); + COPY(secret_key, a, 32); // secret key = seed + crypto_sha512(a, a, 32); // a[ 0..31] = scalar + crypto_eddsa_trim_scalar(a, a); // a[ 0..31] = trimmed scalar + crypto_eddsa_scalarbase(public_key, a); // public key = [trimmed scalar]B + COPY(secret_key + 32, public_key, 32); // secret key includes public half + WIPE_BUFFER(a); +} + +static void hash_reduce(u8 h[32], + const u8 *a, size_t a_size, + const u8 *b, size_t b_size, + const u8 *c, size_t c_size, + const u8 *d, size_t d_size) +{ + u8 hash[64]; + crypto_sha512_ctx ctx; + crypto_sha512_init (&ctx); + crypto_sha512_update(&ctx, a, a_size); + crypto_sha512_update(&ctx, b, b_size); + crypto_sha512_update(&ctx, c, c_size); + crypto_sha512_update(&ctx, d, d_size); + crypto_sha512_final (&ctx, hash); + crypto_eddsa_reduce(h, hash); +} + +static void ed25519_dom_sign(u8 signature [64], const u8 secret_key[32], + const u8 *dom, size_t dom_size, + const u8 *message, size_t message_size) +{ + u8 a[64]; // secret scalar and prefix + u8 r[32]; // secret deterministic "random" nonce + u8 h[32]; // publically verifiable hash of the message (not wiped) + u8 R[32]; // first half of the signature (allows overlapping inputs) + const u8 *pk = secret_key + 32; + + crypto_sha512(a, secret_key, 32); + crypto_eddsa_trim_scalar(a, a); + hash_reduce(r, dom, dom_size, a + 32, 32, message, message_size, 0, 0); + crypto_eddsa_scalarbase(R, r); + hash_reduce(h, dom, dom_size, R, 32, pk, 32, message, message_size); + COPY(signature, R, 32); + crypto_eddsa_mul_add(signature + 32, h, a, r); + + WIPE_BUFFER(a); + WIPE_BUFFER(r); +} + +void crypto_ed25519_sign(u8 signature [64], const u8 secret_key[64], + const u8 *message, size_t message_size) +{ + ed25519_dom_sign(signature, secret_key, 0, 0, message, message_size); +} + +int crypto_ed25519_check(const u8 signature[64], const u8 public_key[32], + const u8 *msg, size_t msg_size) +{ + u8 h_ram[32]; + hash_reduce(h_ram, signature, 32, public_key, 32, msg, msg_size, 0, 0); + return crypto_eddsa_check_equation(signature, public_key, h_ram); +} + +static const u8 domain[34] = "SigEd25519 no Ed25519 collisions\1"; + +void crypto_ed25519_ph_sign(uint8_t signature[64], const uint8_t secret_key[64], + const uint8_t message_hash[64]) +{ + ed25519_dom_sign(signature, secret_key, domain, sizeof(domain), + message_hash, 64); +} + +int crypto_ed25519_ph_check(const uint8_t sig[64], const uint8_t pk[32], + const uint8_t msg_hash[64]) +{ + u8 h_ram[32]; + hash_reduce(h_ram, domain, sizeof(domain), sig, 32, pk, 32, msg_hash, 64); + return crypto_eddsa_check_equation(sig, pk, h_ram); +} + + +#ifdef MONOCYPHER_CPP_NAMESPACE +} +#endif diff --git a/3rdparty/monocypher/monocypher-ed25519.h b/3rdparty/monocypher/monocypher-ed25519.h new file mode 100644 index 0000000..1e6d705 --- /dev/null +++ b/3rdparty/monocypher/monocypher-ed25519.h @@ -0,0 +1,140 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#ifndef ED25519_H +#define ED25519_H + +#include "monocypher.h" + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#elif defined(__cplusplus) +extern "C" { +#endif + +//////////////////////// +/// Type definitions /// +//////////////////////// + +// Do not rely on the size or content on any of those types, +// they may change without notice. +typedef struct { + uint64_t hash[8]; + uint64_t input[16]; + uint64_t input_size[2]; + size_t input_idx; +} crypto_sha512_ctx; + +typedef struct { + uint8_t key[128]; + crypto_sha512_ctx ctx; +} crypto_sha512_hmac_ctx; + + +// SHA 512 +// ------- +void crypto_sha512_init (crypto_sha512_ctx *ctx); +void crypto_sha512_update(crypto_sha512_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_sha512_final (crypto_sha512_ctx *ctx, uint8_t hash[64]); +void crypto_sha512(uint8_t hash[64], + const uint8_t *message, size_t message_size); + +// SHA 512 HMAC +// ------------ +void crypto_sha512_hmac_init(crypto_sha512_hmac_ctx *ctx, + const uint8_t *key, size_t key_size); +void crypto_sha512_hmac_update(crypto_sha512_hmac_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_sha512_hmac_final(crypto_sha512_hmac_ctx *ctx, uint8_t hmac[64]); +void crypto_sha512_hmac(uint8_t hmac[64], + const uint8_t *key , size_t key_size, + const uint8_t *message, size_t message_size); + +// SHA 512 HKDF +// ------------ +void crypto_sha512_hkdf_expand(uint8_t *okm, size_t okm_size, + const uint8_t *prk, size_t prk_size, + const uint8_t *info, size_t info_size); +void crypto_sha512_hkdf(uint8_t *okm , size_t okm_size, + const uint8_t *ikm , size_t ikm_size, + const uint8_t *salt, size_t salt_size, + const uint8_t *info, size_t info_size); + +// Ed25519 +// ------- +// Signatures (EdDSA with curve25519 + SHA-512) +// -------------------------------------------- +void crypto_ed25519_key_pair(uint8_t secret_key[64], + uint8_t public_key[32], + uint8_t seed[32]); +void crypto_ed25519_sign(uint8_t signature [64], + const uint8_t secret_key[64], + const uint8_t *message, size_t message_size); +int crypto_ed25519_check(const uint8_t signature [64], + const uint8_t public_key[32], + const uint8_t *message, size_t message_size); + +// Pre-hash variants +void crypto_ed25519_ph_sign(uint8_t signature [64], + const uint8_t secret_key [64], + const uint8_t message_hash[64]); +int crypto_ed25519_ph_check(const uint8_t signature [64], + const uint8_t public_key [32], + const uint8_t message_hash[64]); + +#ifdef __cplusplus +} +#endif + +#endif // ED25519_H diff --git a/3rdparty/monocypher/monocypher.c b/3rdparty/monocypher/monocypher.c new file mode 100644 index 0000000..d3930fb --- /dev/null +++ b/3rdparty/monocypher/monocypher.c @@ -0,0 +1,2956 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2020, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2020 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#include "monocypher.h" + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#endif + +///////////////// +/// Utilities /// +///////////////// +#define FOR_T(type, i, start, end) for (type i = (start); i < (end); i++) +#define FOR(i, start, end) FOR_T(size_t, i, start, end) +#define COPY(dst, src, size) FOR(_i_, 0, size) (dst)[_i_] = (src)[_i_] +#define ZERO(buf, size) FOR(_i_, 0, size) (buf)[_i_] = 0 +#define WIPE_CTX(ctx) crypto_wipe(ctx , sizeof(*(ctx))) +#define WIPE_BUFFER(buffer) crypto_wipe(buffer, sizeof(buffer)) +#define MIN(a, b) ((a) <= (b) ? (a) : (b)) +#define MAX(a, b) ((a) >= (b) ? (a) : (b)) + +typedef int8_t i8; +typedef uint8_t u8; +typedef int16_t i16; +typedef uint32_t u32; +typedef int32_t i32; +typedef int64_t i64; +typedef uint64_t u64; + +static const u8 zero[128] = {0}; + +// returns the smallest positive integer y such that +// (x + y) % pow_2 == 0 +// Basically, y is the "gap" missing to align x. +// Only works when pow_2 is a power of 2. +// Note: we use ~x+1 instead of -x to avoid compiler warnings +static size_t gap(size_t x, size_t pow_2) +{ + return (~x + 1) & (pow_2 - 1); +} + +static u32 load24_le(const u8 s[3]) +{ + return + ((u32)s[0] << 0) | + ((u32)s[1] << 8) | + ((u32)s[2] << 16); +} + +static u32 load32_le(const u8 s[4]) +{ + return + ((u32)s[0] << 0) | + ((u32)s[1] << 8) | + ((u32)s[2] << 16) | + ((u32)s[3] << 24); +} + +static u64 load64_le(const u8 s[8]) +{ + return load32_le(s) | ((u64)load32_le(s+4) << 32); +} + +static void store32_le(u8 out[4], u32 in) +{ + out[0] = in & 0xff; + out[1] = (in >> 8) & 0xff; + out[2] = (in >> 16) & 0xff; + out[3] = (in >> 24) & 0xff; +} + +static void store64_le(u8 out[8], u64 in) +{ + store32_le(out , (u32)in ); + store32_le(out + 4, in >> 32); +} + +static void load32_le_buf (u32 *dst, const u8 *src, size_t size) { + FOR(i, 0, size) { dst[i] = load32_le(src + i*4); } +} +static void load64_le_buf (u64 *dst, const u8 *src, size_t size) { + FOR(i, 0, size) { dst[i] = load64_le(src + i*8); } +} +static void store32_le_buf(u8 *dst, const u32 *src, size_t size) { + FOR(i, 0, size) { store32_le(dst + i*4, src[i]); } +} +static void store64_le_buf(u8 *dst, const u64 *src, size_t size) { + FOR(i, 0, size) { store64_le(dst + i*8, src[i]); } +} + +static u64 rotr64(u64 x, u64 n) { return (x >> n) ^ (x << (64 - n)); } +static u32 rotl32(u32 x, u32 n) { return (x << n) ^ (x >> (32 - n)); } + +static int neq0(u64 diff) +{ + // constant time comparison to zero + // return diff != 0 ? -1 : 0 + u64 half = (diff >> 32) | ((u32)diff); + return (1 & ((half - 1) >> 32)) - 1; +} + +static u64 x16(const u8 a[16], const u8 b[16]) +{ + return (load64_le(a + 0) ^ load64_le(b + 0)) + | (load64_le(a + 8) ^ load64_le(b + 8)); +} +static u64 x32(const u8 a[32],const u8 b[32]){return x16(a,b)| x16(a+16, b+16);} +static u64 x64(const u8 a[64],const u8 b[64]){return x32(a,b)| x32(a+32, b+32);} +int crypto_verify16(const u8 a[16], const u8 b[16]){ return neq0(x16(a, b)); } +int crypto_verify32(const u8 a[32], const u8 b[32]){ return neq0(x32(a, b)); } +int crypto_verify64(const u8 a[64], const u8 b[64]){ return neq0(x64(a, b)); } + +void crypto_wipe(void *secret, size_t size) +{ + volatile u8 *v_secret = (u8*)secret; + ZERO(v_secret, size); +} + +///////////////// +/// Chacha 20 /// +///////////////// +#define QUARTERROUND(a, b, c, d) \ + a += b; d = rotl32(d ^ a, 16); \ + c += d; b = rotl32(b ^ c, 12); \ + a += b; d = rotl32(d ^ a, 8); \ + c += d; b = rotl32(b ^ c, 7) + +static void chacha20_rounds(u32 out[16], const u32 in[16]) +{ + // The temporary variables make Chacha20 10% faster. + u32 t0 = in[ 0]; u32 t1 = in[ 1]; u32 t2 = in[ 2]; u32 t3 = in[ 3]; + u32 t4 = in[ 4]; u32 t5 = in[ 5]; u32 t6 = in[ 6]; u32 t7 = in[ 7]; + u32 t8 = in[ 8]; u32 t9 = in[ 9]; u32 t10 = in[10]; u32 t11 = in[11]; + u32 t12 = in[12]; u32 t13 = in[13]; u32 t14 = in[14]; u32 t15 = in[15]; + + FOR (i, 0, 10) { // 20 rounds, 2 rounds per loop. + QUARTERROUND(t0, t4, t8 , t12); // column 0 + QUARTERROUND(t1, t5, t9 , t13); // column 1 + QUARTERROUND(t2, t6, t10, t14); // column 2 + QUARTERROUND(t3, t7, t11, t15); // column 3 + QUARTERROUND(t0, t5, t10, t15); // diagonal 0 + QUARTERROUND(t1, t6, t11, t12); // diagonal 1 + QUARTERROUND(t2, t7, t8 , t13); // diagonal 2 + QUARTERROUND(t3, t4, t9 , t14); // diagonal 3 + } + out[ 0] = t0; out[ 1] = t1; out[ 2] = t2; out[ 3] = t3; + out[ 4] = t4; out[ 5] = t5; out[ 6] = t6; out[ 7] = t7; + out[ 8] = t8; out[ 9] = t9; out[10] = t10; out[11] = t11; + out[12] = t12; out[13] = t13; out[14] = t14; out[15] = t15; +} + +static const u8 *chacha20_constant = (const u8*)"expand 32-byte k"; // 16 bytes + +void crypto_chacha20_h(u8 out[32], const u8 key[32], const u8 in [16]) +{ + u32 block[16]; + load32_le_buf(block , chacha20_constant, 4); + load32_le_buf(block + 4, key , 8); + load32_le_buf(block + 12, in , 4); + + chacha20_rounds(block, block); + + // prevent reversal of the rounds by revealing only half of the buffer. + store32_le_buf(out , block , 4); // constant + store32_le_buf(out+16, block+12, 4); // counter and nonce + WIPE_BUFFER(block); +} + +u64 crypto_chacha20_djb(u8 *cipher_text, const u8 *plain_text, + size_t text_size, const u8 key[32], const u8 nonce[8], + u64 ctr) +{ + u32 input[16]; + load32_le_buf(input , chacha20_constant, 4); + load32_le_buf(input + 4, key , 8); + load32_le_buf(input + 14, nonce , 2); + input[12] = (u32) ctr; + input[13] = (u32)(ctr >> 32); + + // Whole blocks + u32 pool[16]; + size_t nb_blocks = text_size >> 6; + FOR (i, 0, nb_blocks) { + chacha20_rounds(pool, input); + if (plain_text != 0) { + FOR (j, 0, 16) { + u32 p = pool[j] + input[j]; + store32_le(cipher_text, p ^ load32_le(plain_text)); + cipher_text += 4; + plain_text += 4; + } + } else { + FOR (j, 0, 16) { + u32 p = pool[j] + input[j]; + store32_le(cipher_text, p); + cipher_text += 4; + } + } + input[12]++; + if (input[12] == 0) { + input[13]++; + } + } + text_size &= 63; + + // Last (incomplete) block + if (text_size > 0) { + if (plain_text == 0) { + plain_text = zero; + } + chacha20_rounds(pool, input); + u8 tmp[64]; + FOR (i, 0, 16) { + store32_le(tmp + i*4, pool[i] + input[i]); + } + FOR (i, 0, text_size) { + cipher_text[i] = tmp[i] ^ plain_text[i]; + } + WIPE_BUFFER(tmp); + } + ctr = input[12] + ((u64)input[13] << 32) + (text_size > 0); + + WIPE_BUFFER(pool); + WIPE_BUFFER(input); + return ctr; +} + +u32 crypto_chacha20_ietf(u8 *cipher_text, const u8 *plain_text, + size_t text_size, + const u8 key[32], const u8 nonce[12], u32 ctr) +{ + u64 big_ctr = ctr + ((u64)load32_le(nonce) << 32); + return (u32)crypto_chacha20_djb(cipher_text, plain_text, text_size, + key, nonce + 4, big_ctr); +} + +u64 crypto_chacha20_x(u8 *cipher_text, const u8 *plain_text, + size_t text_size, + const u8 key[32], const u8 nonce[24], u64 ctr) +{ + u8 sub_key[32]; + crypto_chacha20_h(sub_key, key, nonce); + ctr = crypto_chacha20_djb(cipher_text, plain_text, text_size, + sub_key, nonce + 16, ctr); + WIPE_BUFFER(sub_key); + return ctr; +} + +///////////////// +/// Poly 1305 /// +///////////////// + +// h = (h + c) * r +// preconditions: +// ctx->h <= 4_ffffffff_ffffffff_ffffffff_ffffffff +// ctx->r <= 0ffffffc_0ffffffc_0ffffffc_0fffffff +// end <= 1 +// Postcondition: +// ctx->h <= 4_ffffffff_ffffffff_ffffffff_ffffffff +static void poly_blocks(crypto_poly1305_ctx *ctx, const u8 *in, + size_t nb_blocks, unsigned end) +{ + // Local all the things! + const u32 r0 = ctx->r[0]; + const u32 r1 = ctx->r[1]; + const u32 r2 = ctx->r[2]; + const u32 r3 = ctx->r[3]; + const u32 rr0 = (r0 >> 2) * 5; // lose 2 bits... + const u32 rr1 = (r1 >> 2) + r1; // rr1 == (r1 >> 2) * 5 + const u32 rr2 = (r2 >> 2) + r2; // rr1 == (r2 >> 2) * 5 + const u32 rr3 = (r3 >> 2) + r3; // rr1 == (r3 >> 2) * 5 + const u32 rr4 = r0 & 3; // ...recover 2 bits + u32 h0 = ctx->h[0]; + u32 h1 = ctx->h[1]; + u32 h2 = ctx->h[2]; + u32 h3 = ctx->h[3]; + u32 h4 = ctx->h[4]; + + FOR (i, 0, nb_blocks) { + // h + c, without carry propagation + const u64 s0 = (u64)h0 + load32_le(in); in += 4; + const u64 s1 = (u64)h1 + load32_le(in); in += 4; + const u64 s2 = (u64)h2 + load32_le(in); in += 4; + const u64 s3 = (u64)h3 + load32_le(in); in += 4; + const u32 s4 = h4 + end; + + // (h + c) * r, without carry propagation + const u64 x0 = s0*r0+ s1*rr3+ s2*rr2+ s3*rr1+ s4*rr0; + const u64 x1 = s0*r1+ s1*r0 + s2*rr3+ s3*rr2+ s4*rr1; + const u64 x2 = s0*r2+ s1*r1 + s2*r0 + s3*rr3+ s4*rr2; + const u64 x3 = s0*r3+ s1*r2 + s2*r1 + s3*r0 + s4*rr3; + const u32 x4 = s4*rr4; + + // partial reduction modulo 2^130 - 5 + const u32 u5 = x4 + (x3 >> 32); // u5 <= 7ffffff5 + const u64 u0 = (u5 >> 2) * 5 + (x0 & 0xffffffff); + const u64 u1 = (u0 >> 32) + (x1 & 0xffffffff) + (x0 >> 32); + const u64 u2 = (u1 >> 32) + (x2 & 0xffffffff) + (x1 >> 32); + const u64 u3 = (u2 >> 32) + (x3 & 0xffffffff) + (x2 >> 32); + const u32 u4 = (u3 >> 32) + (u5 & 3); // u4 <= 4 + + // Update the hash + h0 = u0 & 0xffffffff; + h1 = u1 & 0xffffffff; + h2 = u2 & 0xffffffff; + h3 = u3 & 0xffffffff; + h4 = u4; + } + ctx->h[0] = h0; + ctx->h[1] = h1; + ctx->h[2] = h2; + ctx->h[3] = h3; + ctx->h[4] = h4; +} + +void crypto_poly1305_init(crypto_poly1305_ctx *ctx, const u8 key[32]) +{ + ZERO(ctx->h, 5); // Initial hash is zero + ctx->c_idx = 0; + // load r and pad (r has some of its bits cleared) + load32_le_buf(ctx->r , key , 4); + load32_le_buf(ctx->pad, key+16, 4); + FOR (i, 0, 1) { ctx->r[i] &= 0x0fffffff; } + FOR (i, 1, 4) { ctx->r[i] &= 0x0ffffffc; } +} + +void crypto_poly1305_update(crypto_poly1305_ctx *ctx, + const u8 *message, size_t message_size) +{ + // Avoid undefined NULL pointer increments with empty messages + if (message_size == 0) { + return; + } + + // Align ourselves with block boundaries + size_t aligned = MIN(gap(ctx->c_idx, 16), message_size); + FOR (i, 0, aligned) { + ctx->c[ctx->c_idx] = *message; + ctx->c_idx++; + message++; + message_size--; + } + + // If block is complete, process it + if (ctx->c_idx == 16) { + poly_blocks(ctx, ctx->c, 1, 1); + ctx->c_idx = 0; + } + + // Process the message block by block + size_t nb_blocks = message_size >> 4; + poly_blocks(ctx, message, nb_blocks, 1); + message += nb_blocks << 4; + message_size &= 15; + + // remaining bytes (we never complete a block here) + FOR (i, 0, message_size) { + ctx->c[ctx->c_idx] = message[i]; + ctx->c_idx++; + } +} + +void crypto_poly1305_final(crypto_poly1305_ctx *ctx, u8 mac[16]) +{ + // Process the last block (if any) + // We move the final 1 according to remaining input length + // (this will add less than 2^130 to the last input block) + if (ctx->c_idx != 0) { + ZERO(ctx->c + ctx->c_idx, 16 - ctx->c_idx); + ctx->c[ctx->c_idx] = 1; + poly_blocks(ctx, ctx->c, 1, 0); + } + + // check if we should subtract 2^130-5 by performing the + // corresponding carry propagation. + u64 c = 5; + FOR (i, 0, 4) { + c += ctx->h[i]; + c >>= 32; + } + c += ctx->h[4]; + c = (c >> 2) * 5; // shift the carry back to the beginning + // c now indicates how many times we should subtract 2^130-5 (0 or 1) + FOR (i, 0, 4) { + c += (u64)ctx->h[i] + ctx->pad[i]; + store32_le(mac + i*4, (u32)c); + c = c >> 32; + } + WIPE_CTX(ctx); +} + +void crypto_poly1305(u8 mac[16], const u8 *message, + size_t message_size, const u8 key[32]) +{ + crypto_poly1305_ctx ctx; + crypto_poly1305_init (&ctx, key); + crypto_poly1305_update(&ctx, message, message_size); + crypto_poly1305_final (&ctx, mac); +} + +//////////////// +/// BLAKE2 b /// +//////////////// +static const u64 iv[8] = { + 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, + 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, + 0x510e527fade682d1, 0x9b05688c2b3e6c1f, + 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179, +}; + +static void blake2b_compress(crypto_blake2b_ctx *ctx, int is_last_block) +{ + static const u8 sigma[12][16] = { + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, + { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }, + { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 }, + { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 }, + { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 }, + { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }, + { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 }, + { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 }, + { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 }, + { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, + { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }, + }; + + // increment input offset + u64 *x = ctx->input_offset; + size_t y = ctx->input_idx; + x[0] += y; + if (x[0] < y) { + x[1]++; + } + + // init work vector + u64 v0 = ctx->hash[0]; u64 v8 = iv[0]; + u64 v1 = ctx->hash[1]; u64 v9 = iv[1]; + u64 v2 = ctx->hash[2]; u64 v10 = iv[2]; + u64 v3 = ctx->hash[3]; u64 v11 = iv[3]; + u64 v4 = ctx->hash[4]; u64 v12 = iv[4] ^ ctx->input_offset[0]; + u64 v5 = ctx->hash[5]; u64 v13 = iv[5] ^ ctx->input_offset[1]; + u64 v6 = ctx->hash[6]; u64 v14 = iv[6] ^ (u64)~(is_last_block - 1); + u64 v7 = ctx->hash[7]; u64 v15 = iv[7]; + + // mangle work vector + u64 *input = ctx->input; +#define BLAKE2_G(a, b, c, d, x, y) \ + a += b + x; d = rotr64(d ^ a, 32); \ + c += d; b = rotr64(b ^ c, 24); \ + a += b + y; d = rotr64(d ^ a, 16); \ + c += d; b = rotr64(b ^ c, 63) +#define BLAKE2_ROUND(i) \ + BLAKE2_G(v0, v4, v8 , v12, input[sigma[i][ 0]], input[sigma[i][ 1]]); \ + BLAKE2_G(v1, v5, v9 , v13, input[sigma[i][ 2]], input[sigma[i][ 3]]); \ + BLAKE2_G(v2, v6, v10, v14, input[sigma[i][ 4]], input[sigma[i][ 5]]); \ + BLAKE2_G(v3, v7, v11, v15, input[sigma[i][ 6]], input[sigma[i][ 7]]); \ + BLAKE2_G(v0, v5, v10, v15, input[sigma[i][ 8]], input[sigma[i][ 9]]); \ + BLAKE2_G(v1, v6, v11, v12, input[sigma[i][10]], input[sigma[i][11]]); \ + BLAKE2_G(v2, v7, v8 , v13, input[sigma[i][12]], input[sigma[i][13]]); \ + BLAKE2_G(v3, v4, v9 , v14, input[sigma[i][14]], input[sigma[i][15]]) + +#ifdef BLAKE2_NO_UNROLLING + FOR (i, 0, 12) { + BLAKE2_ROUND(i); + } +#else + BLAKE2_ROUND(0); BLAKE2_ROUND(1); BLAKE2_ROUND(2); BLAKE2_ROUND(3); + BLAKE2_ROUND(4); BLAKE2_ROUND(5); BLAKE2_ROUND(6); BLAKE2_ROUND(7); + BLAKE2_ROUND(8); BLAKE2_ROUND(9); BLAKE2_ROUND(10); BLAKE2_ROUND(11); +#endif + + // update hash + ctx->hash[0] ^= v0 ^ v8; ctx->hash[1] ^= v1 ^ v9; + ctx->hash[2] ^= v2 ^ v10; ctx->hash[3] ^= v3 ^ v11; + ctx->hash[4] ^= v4 ^ v12; ctx->hash[5] ^= v5 ^ v13; + ctx->hash[6] ^= v6 ^ v14; ctx->hash[7] ^= v7 ^ v15; +} + +void crypto_blake2b_keyed_init(crypto_blake2b_ctx *ctx, size_t hash_size, + const u8 *key, size_t key_size) +{ + // initial hash + COPY(ctx->hash, iv, 8); + ctx->hash[0] ^= 0x01010000 ^ (key_size << 8) ^ hash_size; + + ctx->input_offset[0] = 0; // beginning of the input, no offset + ctx->input_offset[1] = 0; // beginning of the input, no offset + ctx->hash_size = hash_size; + ctx->input_idx = 0; + ZERO(ctx->input, 16); + + // if there is a key, the first block is that key (padded with zeroes) + if (key_size > 0) { + u8 key_block[128] = {0}; + COPY(key_block, key, key_size); + // same as calling crypto_blake2b_update(ctx, key_block , 128) + load64_le_buf(ctx->input, key_block, 16); + ctx->input_idx = 128; + } +} + +void crypto_blake2b_init(crypto_blake2b_ctx *ctx, size_t hash_size) +{ + crypto_blake2b_keyed_init(ctx, hash_size, 0, 0); +} + +void crypto_blake2b_update(crypto_blake2b_ctx *ctx, + const u8 *message, size_t message_size) +{ + // Avoid undefined NULL pointer increments with empty messages + if (message_size == 0) { + return; + } + + // Align with word boundaries + if ((ctx->input_idx & 7) != 0) { + size_t nb_bytes = MIN(gap(ctx->input_idx, 8), message_size); + size_t word = ctx->input_idx >> 3; + size_t byte = ctx->input_idx & 7; + FOR (i, 0, nb_bytes) { + ctx->input[word] |= (u64)message[i] << ((byte + i) << 3); + } + ctx->input_idx += nb_bytes; + message += nb_bytes; + message_size -= nb_bytes; + } + + // Align with block boundaries (faster than byte by byte) + if ((ctx->input_idx & 127) != 0) { + size_t nb_words = MIN(gap(ctx->input_idx, 128), message_size) >> 3; + load64_le_buf(ctx->input + (ctx->input_idx >> 3), message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + } + + // Process block by block + size_t nb_blocks = message_size >> 7; + FOR (i, 0, nb_blocks) { + if (ctx->input_idx == 128) { + blake2b_compress(ctx, 0); + } + load64_le_buf(ctx->input, message, 16); + message += 128; + ctx->input_idx = 128; + } + message_size &= 127; + + if (message_size != 0) { + // Compress block & flush input buffer as needed + if (ctx->input_idx == 128) { + blake2b_compress(ctx, 0); + ctx->input_idx = 0; + } + if (ctx->input_idx == 0) { + ZERO(ctx->input, 16); + } + // Fill remaining words (faster than byte by byte) + size_t nb_words = message_size >> 3; + load64_le_buf(ctx->input, message, nb_words); + ctx->input_idx += nb_words << 3; + message += nb_words << 3; + message_size -= nb_words << 3; + + // Fill remaining bytes + FOR (i, 0, message_size) { + size_t word = ctx->input_idx >> 3; + size_t byte = ctx->input_idx & 7; + ctx->input[word] |= (u64)message[i] << (byte << 3); + ctx->input_idx++; + } + } +} + +void crypto_blake2b_final(crypto_blake2b_ctx *ctx, u8 *hash) +{ + blake2b_compress(ctx, 1); // compress the last block + size_t hash_size = MIN(ctx->hash_size, 64); + size_t nb_words = hash_size >> 3; + store64_le_buf(hash, ctx->hash, nb_words); + FOR (i, nb_words << 3, hash_size) { + hash[i] = (ctx->hash[i >> 3] >> (8 * (i & 7))) & 0xff; + } + WIPE_CTX(ctx); +} + +void crypto_blake2b_keyed(u8 *hash, size_t hash_size, + const u8 *key, size_t key_size, + const u8 *message, size_t message_size) +{ + crypto_blake2b_ctx ctx; + crypto_blake2b_keyed_init(&ctx, hash_size, key, key_size); + crypto_blake2b_update (&ctx, message, message_size); + crypto_blake2b_final (&ctx, hash); +} + +void crypto_blake2b(u8 *hash, size_t hash_size, const u8 *msg, size_t msg_size) +{ + crypto_blake2b_keyed(hash, hash_size, 0, 0, msg, msg_size); +} + +////////////// +/// Argon2 /// +////////////// +// references to R, Z, Q etc. come from the spec + +// Argon2 operates on 1024 byte blocks. +typedef struct { u64 a[128]; } blk; + +// updates a BLAKE2 hash with a 32 bit word, little endian. +static void blake_update_32(crypto_blake2b_ctx *ctx, u32 input) +{ + u8 buf[4]; + store32_le(buf, input); + crypto_blake2b_update(ctx, buf, 4); + WIPE_BUFFER(buf); +} + +static void blake_update_32_buf(crypto_blake2b_ctx *ctx, + const u8 *buf, u32 size) +{ + blake_update_32(ctx, size); + crypto_blake2b_update(ctx, buf, size); +} + + +static void copy_block(blk *o,const blk*in){FOR(i, 0, 128) o->a[i] = in->a[i];} +static void xor_block(blk *o,const blk*in){FOR(i, 0, 128) o->a[i] ^= in->a[i];} + +// Hash with a virtually unlimited digest size. +// Doesn't extract more entropy than the base hash function. +// Mainly used for filling a whole kilobyte block with pseudo-random bytes. +// (One could use a stream cipher with a seed hash as the key, but +// this would introduce another dependency —and point of failure.) +static void extended_hash(u8 *digest, u32 digest_size, + const u8 *input , u32 input_size) +{ + crypto_blake2b_ctx ctx; + crypto_blake2b_init (&ctx, MIN(digest_size, 64)); + blake_update_32 (&ctx, digest_size); + crypto_blake2b_update(&ctx, input, input_size); + crypto_blake2b_final (&ctx, digest); + + if (digest_size > 64) { + // the conversion to u64 avoids integer overflow on + // ludicrously big hash sizes. + u32 r = (u32)(((u64)digest_size + 31) >> 5) - 2; + u32 i = 1; + u32 in = 0; + u32 out = 32; + while (i < r) { + // Input and output overlap. This is intentional + crypto_blake2b(digest + out, 64, digest + in, 64); + i += 1; + in += 32; + out += 32; + } + crypto_blake2b(digest + out, digest_size - (32 * r), digest + in , 64); + } +} + +#define LSB(x) ((u64)(u32)x) +#define G(a, b, c, d) \ + a += b + ((LSB(a) * LSB(b)) << 1); d ^= a; d = rotr64(d, 32); \ + c += d + ((LSB(c) * LSB(d)) << 1); b ^= c; b = rotr64(b, 24); \ + a += b + ((LSB(a) * LSB(b)) << 1); d ^= a; d = rotr64(d, 16); \ + c += d + ((LSB(c) * LSB(d)) << 1); b ^= c; b = rotr64(b, 63) +#define ROUND(v0, v1, v2, v3, v4, v5, v6, v7, \ + v8, v9, v10, v11, v12, v13, v14, v15) \ + G(v0, v4, v8, v12); G(v1, v5, v9, v13); \ + G(v2, v6, v10, v14); G(v3, v7, v11, v15); \ + G(v0, v5, v10, v15); G(v1, v6, v11, v12); \ + G(v2, v7, v8, v13); G(v3, v4, v9, v14) + +// Core of the compression function G. Computes Z from R in place. +static void g_rounds(blk *b) +{ + // column rounds (work_block = Q) + for (int i = 0; i < 128; i += 16) { + ROUND(b->a[i ], b->a[i+ 1], b->a[i+ 2], b->a[i+ 3], + b->a[i+ 4], b->a[i+ 5], b->a[i+ 6], b->a[i+ 7], + b->a[i+ 8], b->a[i+ 9], b->a[i+10], b->a[i+11], + b->a[i+12], b->a[i+13], b->a[i+14], b->a[i+15]); + } + // row rounds (b = Z) + for (int i = 0; i < 16; i += 2) { + ROUND(b->a[i ], b->a[i+ 1], b->a[i+ 16], b->a[i+ 17], + b->a[i+32], b->a[i+33], b->a[i+ 48], b->a[i+ 49], + b->a[i+64], b->a[i+65], b->a[i+ 80], b->a[i+ 81], + b->a[i+96], b->a[i+97], b->a[i+112], b->a[i+113]); + } +} + +const crypto_argon2_extras crypto_argon2_no_extras = { 0, 0, 0, 0 }; + +void crypto_argon2(u8 *hash, u32 hash_size, void *work_area, + crypto_argon2_config config, + crypto_argon2_inputs inputs, + crypto_argon2_extras extras) +{ + const u32 segment_size = config.nb_blocks / config.nb_lanes / 4; + const u32 lane_size = segment_size * 4; + const u32 nb_blocks = lane_size * config.nb_lanes; // rounding down + + // work area seen as blocks (must be suitably aligned) + blk *blocks = (blk*)work_area; + { + u8 initial_hash[72]; // 64 bytes plus 2 words for future hashes + crypto_blake2b_ctx ctx; + crypto_blake2b_init (&ctx, 64); + blake_update_32 (&ctx, config.nb_lanes ); // p: number of "threads" + blake_update_32 (&ctx, hash_size); + blake_update_32 (&ctx, config.nb_blocks); + blake_update_32 (&ctx, config.nb_passes); + blake_update_32 (&ctx, 0x13); // v: version number + blake_update_32 (&ctx, config.algorithm); // y: Argon2i, Argon2d... + blake_update_32_buf (&ctx, inputs.pass, inputs.pass_size); + blake_update_32_buf (&ctx, inputs.salt, inputs.salt_size); + blake_update_32_buf (&ctx, extras.key, extras.key_size); + blake_update_32_buf (&ctx, extras.ad, extras.ad_size); + crypto_blake2b_final(&ctx, initial_hash); // fill 64 first bytes only + + // fill first 2 blocks of each lane + u8 hash_area[1024]; + FOR_T(u32, l, 0, config.nb_lanes) { + FOR_T(u32, i, 0, 2) { + store32_le(initial_hash + 64, i); // first additional word + store32_le(initial_hash + 68, l); // second additional word + extended_hash(hash_area, 1024, initial_hash, 72); + load64_le_buf(blocks[l * lane_size + i].a, hash_area, 128); + } + } + + WIPE_BUFFER(initial_hash); + WIPE_BUFFER(hash_area); + } + + // Argon2i and Argon2id start with constant time indexing + int constant_time = config.algorithm != CRYPTO_ARGON2_D; + + // Fill (and re-fill) the rest of the blocks + // + // Note: even though each segment within the same slice can be + // computed in parallel, (one thread per lane), we are computing + // them sequentially, because Monocypher doesn't support threads. + // + // Yet optimal performance (and therefore security) requires one + // thread per lane. The only reason Monocypher supports multiple + // lanes is compatibility. + blk tmp; + FOR_T(u32, pass, 0, config.nb_passes) { + FOR_T(u32, slice, 0, 4) { + // On the first slice of the first pass, + // blocks 0 and 1 are already filled, hence pass_offset. + u32 pass_offset = pass == 0 && slice == 0 ? 2 : 0; + u32 slice_offset = slice * segment_size; + + // Argon2id switches back to non-constant time indexing + // after the first two slices of the first pass + if (slice == 2 && config.algorithm == CRYPTO_ARGON2_ID) { + constant_time = 0; + } + + // Each iteration of the following loop may be performed in + // a separate thread. All segments must be fully completed + // before we start filling the next slice. + FOR_T(u32, segment, 0, config.nb_lanes) { + blk index_block; + u32 index_ctr = 1; + FOR_T (u32, block, pass_offset, segment_size) { + // Current and previous blocks + u32 lane_offset = segment * lane_size; + blk *segment_start = blocks + lane_offset + slice_offset; + blk *current = segment_start + block; + blk *previous = + block == 0 && slice_offset == 0 + ? segment_start + lane_size - 1 + : segment_start + block - 1; + + u64 index_seed; + if (constant_time) { + if (block == pass_offset || (block % 128) == 0) { + // Fill or refresh deterministic indices block + + // seed the beginning of the block... + ZERO(index_block.a, 128); + index_block.a[0] = pass; + index_block.a[1] = segment; + index_block.a[2] = slice; + index_block.a[3] = nb_blocks; + index_block.a[4] = config.nb_passes; + index_block.a[5] = config.algorithm; + index_block.a[6] = index_ctr; + index_ctr++; + + // ... then shuffle it + copy_block(&tmp, &index_block); + g_rounds (&index_block); + xor_block (&index_block, &tmp); + copy_block(&tmp, &index_block); + g_rounds (&index_block); + xor_block (&index_block, &tmp); + } + index_seed = index_block.a[block % 128]; + } else { + index_seed = previous->a[0]; + } + + // Establish the reference set. *Approximately* comprises: + // - The last 3 slices (if they exist yet) + // - The already constructed blocks in the current segment + u32 next_slice = ((slice + 1) % 4) * segment_size; + u32 window_start = pass == 0 ? 0 : next_slice; + u32 nb_segments = pass == 0 ? slice : 3; + u64 lane = + pass == 0 && slice == 0 + ? segment + : (index_seed >> 32) % config.nb_lanes; + u32 window_size = + nb_segments * segment_size + + (lane == segment ? block-1 : + block == 0 ? (u32)-1 : 0); + + // Find reference block + u64 j1 = index_seed & 0xffffffff; // block selector + u64 x = (j1 * j1) >> 32; + u64 y = (window_size * x) >> 32; + u64 z = (window_size - 1) - y; + u64 ref = (window_start + z) % lane_size; + u32 index = lane * lane_size + (u32)ref; + blk *reference = blocks + index; + + // Shuffle the previous & reference block + // into the current block + copy_block(&tmp, previous); + xor_block (&tmp, reference); + if (pass == 0) { copy_block(current, &tmp); } + else { xor_block (current, &tmp); } + g_rounds (&tmp); + xor_block (current, &tmp); + } + } + } + } + + // Wipe temporary block + volatile u64* p = tmp.a; + ZERO(p, 128); + + // XOR last blocks of each lane + blk *last_block = blocks + lane_size - 1; + FOR_T (u32, lane, 1, config.nb_lanes) { + blk *next_block = last_block + lane_size; + xor_block(next_block, last_block); + last_block = next_block; + } + + // Serialize last block + u8 final_block[1024]; + store64_le_buf(final_block, last_block->a, 128); + + // Wipe work area + p = (u64*)work_area; + ZERO(p, 128 * nb_blocks); + + // Hash the very last block with H' into the output hash + extended_hash(hash, hash_size, final_block, 1024); + WIPE_BUFFER(final_block); +} + +//////////////////////////////////// +/// Arithmetic modulo 2^255 - 19 /// +//////////////////////////////////// +// Originally taken from SUPERCOP's ref10 implementation. +// A bit bigger than TweetNaCl, over 4 times faster. + +// field element +typedef i32 fe[10]; + +// field constants +// +// fe_one : 1 +// sqrtm1 : sqrt(-1) +// d : -121665 / 121666 +// D2 : 2 * -121665 / 121666 +// lop_x, lop_y: low order point in Edwards coordinates +// ufactor : -sqrt(-1) * 2 +// A2 : 486662^2 (A squared) +static const fe fe_one = {1}; +static const fe sqrtm1 = { + -32595792, -7943725, 9377950, 3500415, 12389472, + -272473, -25146209, -2005654, 326686, 11406482, +}; +static const fe d = { + -10913610, 13857413, -15372611, 6949391, 114729, + -8787816, -6275908, -3247719, -18696448, -12055116, +}; +static const fe D2 = { + -21827239, -5839606, -30745221, 13898782, 229458, + 15978800, -12551817, -6495438, 29715968, 9444199, +}; +static const fe lop_x = { + 21352778, 5345713, 4660180, -8347857, 24143090, + 14568123, 30185756, -12247770, -33528939, 8345319, +}; +static const fe lop_y = { + -6952922, -1265500, 6862341, -7057498, -4037696, + -5447722, 31680899, -15325402, -19365852, 1569102, +}; +static const fe ufactor = { + -1917299, 15887451, -18755900, -7000830, -24778944, + 544946, -16816446, 4011309, -653372, 10741468, +}; +static const fe A2 = { + 12721188, 3529, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static void fe_0(fe h) { ZERO(h , 10); } +static void fe_1(fe h) { h[0] = 1; ZERO(h+1, 9); } + +static void fe_copy(fe h,const fe f ){FOR(i,0,10) h[i] = f[i]; } +static void fe_neg (fe h,const fe f ){FOR(i,0,10) h[i] = -f[i]; } +static void fe_add (fe h,const fe f,const fe g){FOR(i,0,10) h[i] = f[i] + g[i];} +static void fe_sub (fe h,const fe f,const fe g){FOR(i,0,10) h[i] = f[i] - g[i];} + +static void fe_cswap(fe f, fe g, int b) +{ + i32 mask = -b; // -1 = 0xffffffff + FOR (i, 0, 10) { + i32 x = (f[i] ^ g[i]) & mask; + f[i] = f[i] ^ x; + g[i] = g[i] ^ x; + } +} + +static void fe_ccopy(fe f, const fe g, int b) +{ + i32 mask = -b; // -1 = 0xffffffff + FOR (i, 0, 10) { + i32 x = (f[i] ^ g[i]) & mask; + f[i] = f[i] ^ x; + } +} + + +// Signed carry propagation +// ------------------------ +// +// Let t be a number. It can be uniquely decomposed thus: +// +// t = h*2^26 + l +// such that -2^25 <= l < 2^25 +// +// Let c = (t + 2^25) / 2^26 (rounded down) +// c = (h*2^26 + l + 2^25) / 2^26 (rounded down) +// c = h + (l + 2^25) / 2^26 (rounded down) +// c = h (exactly) +// Because 0 <= l + 2^25 < 2^26 +// +// Let u = t - c*2^26 +// u = h*2^26 + l - h*2^26 +// u = l +// Therefore, -2^25 <= u < 2^25 +// +// Additionally, if |t| < x, then |h| < x/2^26 (rounded down) +// +// Notations: +// - In C, 1<<25 means 2^25. +// - In C, x>>25 means floor(x / (2^25)). +// - All of the above applies with 25 & 24 as well as 26 & 25. +// +// +// Note on negative right shifts +// ----------------------------- +// +// In C, x >> n, where x is a negative integer, is implementation +// defined. In practice, all platforms do arithmetic shift, which is +// equivalent to division by 2^26, rounded down. Some compilers, like +// GCC, even guarantee it. +// +// If we ever stumble upon a platform that does not propagate the sign +// bit (we won't), visible failures will show at the slightest test, and +// the signed shifts can be replaced by the following: +// +// typedef struct { i64 x:39; } s25; +// typedef struct { i64 x:38; } s26; +// i64 shift25(i64 x) { s25 s; s.x = ((u64)x)>>25; return s.x; } +// i64 shift26(i64 x) { s26 s; s.x = ((u64)x)>>26; return s.x; } +// +// Current compilers cannot optimise this, causing a 30% drop in +// performance. Fairly expensive for something that never happens. +// +// +// Precondition +// ------------ +// +// |t0| < 2^63 +// |t1|..|t9| < 2^62 +// +// Algorithm +// --------- +// c = t0 + 2^25 / 2^26 -- |c| <= 2^36 +// t0 -= c * 2^26 -- |t0| <= 2^25 +// t1 += c -- |t1| <= 2^63 +// +// c = t4 + 2^25 / 2^26 -- |c| <= 2^36 +// t4 -= c * 2^26 -- |t4| <= 2^25 +// t5 += c -- |t5| <= 2^63 +// +// c = t1 + 2^24 / 2^25 -- |c| <= 2^38 +// t1 -= c * 2^25 -- |t1| <= 2^24 +// t2 += c -- |t2| <= 2^63 +// +// c = t5 + 2^24 / 2^25 -- |c| <= 2^38 +// t5 -= c * 2^25 -- |t5| <= 2^24 +// t6 += c -- |t6| <= 2^63 +// +// c = t2 + 2^25 / 2^26 -- |c| <= 2^37 +// t2 -= c * 2^26 -- |t2| <= 2^25 < 1.1 * 2^25 (final t2) +// t3 += c -- |t3| <= 2^63 +// +// c = t6 + 2^25 / 2^26 -- |c| <= 2^37 +// t6 -= c * 2^26 -- |t6| <= 2^25 < 1.1 * 2^25 (final t6) +// t7 += c -- |t7| <= 2^63 +// +// c = t3 + 2^24 / 2^25 -- |c| <= 2^38 +// t3 -= c * 2^25 -- |t3| <= 2^24 < 1.1 * 2^24 (final t3) +// t4 += c -- |t4| <= 2^25 + 2^38 < 2^39 +// +// c = t7 + 2^24 / 2^25 -- |c| <= 2^38 +// t7 -= c * 2^25 -- |t7| <= 2^24 < 1.1 * 2^24 (final t7) +// t8 += c -- |t8| <= 2^63 +// +// c = t4 + 2^25 / 2^26 -- |c| <= 2^13 +// t4 -= c * 2^26 -- |t4| <= 2^25 < 1.1 * 2^25 (final t4) +// t5 += c -- |t5| <= 2^24 + 2^13 < 1.1 * 2^24 (final t5) +// +// c = t8 + 2^25 / 2^26 -- |c| <= 2^37 +// t8 -= c * 2^26 -- |t8| <= 2^25 < 1.1 * 2^25 (final t8) +// t9 += c -- |t9| <= 2^63 +// +// c = t9 + 2^24 / 2^25 -- |c| <= 2^38 +// t9 -= c * 2^25 -- |t9| <= 2^24 < 1.1 * 2^24 (final t9) +// t0 += c * 19 -- |t0| <= 2^25 + 2^38*19 < 2^44 +// +// c = t0 + 2^25 / 2^26 -- |c| <= 2^18 +// t0 -= c * 2^26 -- |t0| <= 2^25 < 1.1 * 2^25 (final t0) +// t1 += c -- |t1| <= 2^24 + 2^18 < 1.1 * 2^24 (final t1) +// +// Postcondition +// ------------- +// |t0|, |t2|, |t4|, |t6|, |t8| < 1.1 * 2^25 +// |t1|, |t3|, |t5|, |t7|, |t9| < 1.1 * 2^24 +#define FE_CARRY \ + i64 c; \ + c = (t0 + ((i64)1<<25)) >> 26; t0 -= c * ((i64)1 << 26); t1 += c; \ + c = (t4 + ((i64)1<<25)) >> 26; t4 -= c * ((i64)1 << 26); t5 += c; \ + c = (t1 + ((i64)1<<24)) >> 25; t1 -= c * ((i64)1 << 25); t2 += c; \ + c = (t5 + ((i64)1<<24)) >> 25; t5 -= c * ((i64)1 << 25); t6 += c; \ + c = (t2 + ((i64)1<<25)) >> 26; t2 -= c * ((i64)1 << 26); t3 += c; \ + c = (t6 + ((i64)1<<25)) >> 26; t6 -= c * ((i64)1 << 26); t7 += c; \ + c = (t3 + ((i64)1<<24)) >> 25; t3 -= c * ((i64)1 << 25); t4 += c; \ + c = (t7 + ((i64)1<<24)) >> 25; t7 -= c * ((i64)1 << 25); t8 += c; \ + c = (t4 + ((i64)1<<25)) >> 26; t4 -= c * ((i64)1 << 26); t5 += c; \ + c = (t8 + ((i64)1<<25)) >> 26; t8 -= c * ((i64)1 << 26); t9 += c; \ + c = (t9 + ((i64)1<<24)) >> 25; t9 -= c * ((i64)1 << 25); t0 += c * 19; \ + c = (t0 + ((i64)1<<25)) >> 26; t0 -= c * ((i64)1 << 26); t1 += c; \ + h[0]=(i32)t0; h[1]=(i32)t1; h[2]=(i32)t2; h[3]=(i32)t3; h[4]=(i32)t4; \ + h[5]=(i32)t5; h[6]=(i32)t6; h[7]=(i32)t7; h[8]=(i32)t8; h[9]=(i32)t9 + +// Decodes a field element from a byte buffer. +// mask specifies how many bits we ignore. +// Traditionally we ignore 1. It's useful for EdDSA, +// which uses that bit to denote the sign of x. +// Elligator however uses positive representatives, +// which means ignoring 2 bits instead. +static void fe_frombytes_mask(fe h, const u8 s[32], unsigned nb_mask) +{ + u32 mask = 0xffffff >> nb_mask; + i64 t0 = load32_le(s); // t0 < 2^32 + i64 t1 = load24_le(s + 4) << 6; // t1 < 2^30 + i64 t2 = load24_le(s + 7) << 5; // t2 < 2^29 + i64 t3 = load24_le(s + 10) << 3; // t3 < 2^27 + i64 t4 = load24_le(s + 13) << 2; // t4 < 2^26 + i64 t5 = load32_le(s + 16); // t5 < 2^32 + i64 t6 = load24_le(s + 20) << 7; // t6 < 2^31 + i64 t7 = load24_le(s + 23) << 5; // t7 < 2^29 + i64 t8 = load24_le(s + 26) << 4; // t8 < 2^28 + i64 t9 = (load24_le(s + 29) & mask) << 2; // t9 < 2^25 + FE_CARRY; // Carry precondition OK +} + +static void fe_frombytes(fe h, const u8 s[32]) +{ + fe_frombytes_mask(h, s, 1); +} + + +// Precondition +// |h[0]|, |h[2]|, |h[4]|, |h[6]|, |h[8]| < 1.1 * 2^25 +// |h[1]|, |h[3]|, |h[5]|, |h[7]|, |h[9]| < 1.1 * 2^24 +// +// Therefore, |h| < 2^255-19 +// There are two possibilities: +// +// - If h is positive, all we need to do is reduce its individual +// limbs down to their tight positive range. +// - If h is negative, we also need to add 2^255-19 to it. +// Or just remove 19 and chop off any excess bit. +static void fe_tobytes(u8 s[32], const fe h) +{ + i32 t[10]; + COPY(t, h, 10); + i32 q = (19 * t[9] + (((i32) 1) << 24)) >> 25; + // |t9| < 1.1 * 2^24 + // -1.1 * 2^24 < t9 < 1.1 * 2^24 + // -21 * 2^24 < 19 * t9 < 21 * 2^24 + // -2^29 < 19 * t9 + 2^24 < 2^29 + // -2^29 / 2^25 < (19 * t9 + 2^24) / 2^25 < 2^29 / 2^25 + // -16 < (19 * t9 + 2^24) / 2^25 < 16 + FOR (i, 0, 5) { + q += t[2*i ]; q >>= 26; // q = 0 or -1 + q += t[2*i+1]; q >>= 25; // q = 0 or -1 + } + // q = 0 iff h >= 0 + // q = -1 iff h < 0 + // Adding q * 19 to h reduces h to its proper range. + q *= 19; // Shift carry back to the beginning + FOR (i, 0, 5) { + t[i*2 ] += q; q = t[i*2 ] >> 26; t[i*2 ] -= q * ((i32)1 << 26); + t[i*2+1] += q; q = t[i*2+1] >> 25; t[i*2+1] -= q * ((i32)1 << 25); + } + // h is now fully reduced, and q represents the excess bit. + + store32_le(s + 0, ((u32)t[0] >> 0) | ((u32)t[1] << 26)); + store32_le(s + 4, ((u32)t[1] >> 6) | ((u32)t[2] << 19)); + store32_le(s + 8, ((u32)t[2] >> 13) | ((u32)t[3] << 13)); + store32_le(s + 12, ((u32)t[3] >> 19) | ((u32)t[4] << 6)); + store32_le(s + 16, ((u32)t[5] >> 0) | ((u32)t[6] << 25)); + store32_le(s + 20, ((u32)t[6] >> 7) | ((u32)t[7] << 19)); + store32_le(s + 24, ((u32)t[7] >> 13) | ((u32)t[8] << 12)); + store32_le(s + 28, ((u32)t[8] >> 20) | ((u32)t[9] << 6)); + + WIPE_BUFFER(t); +} + +// Precondition +// ------------- +// |f0|, |f2|, |f4|, |f6|, |f8| < 1.65 * 2^26 +// |f1|, |f3|, |f5|, |f7|, |f9| < 1.65 * 2^25 +// +// |g0|, |g2|, |g4|, |g6|, |g8| < 1.65 * 2^26 +// |g1|, |g3|, |g5|, |g7|, |g9| < 1.65 * 2^25 +static void fe_mul_small(fe h, const fe f, i32 g) +{ + i64 t0 = f[0] * (i64) g; i64 t1 = f[1] * (i64) g; + i64 t2 = f[2] * (i64) g; i64 t3 = f[3] * (i64) g; + i64 t4 = f[4] * (i64) g; i64 t5 = f[5] * (i64) g; + i64 t6 = f[6] * (i64) g; i64 t7 = f[7] * (i64) g; + i64 t8 = f[8] * (i64) g; i64 t9 = f[9] * (i64) g; + // |t0|, |t2|, |t4|, |t6|, |t8| < 1.65 * 2^26 * 2^31 < 2^58 + // |t1|, |t3|, |t5|, |t7|, |t9| < 1.65 * 2^25 * 2^31 < 2^57 + + FE_CARRY; // Carry precondition OK +} + +// Precondition +// ------------- +// |f0|, |f2|, |f4|, |f6|, |f8| < 1.65 * 2^26 +// |f1|, |f3|, |f5|, |f7|, |f9| < 1.65 * 2^25 +// +// |g0|, |g2|, |g4|, |g6|, |g8| < 1.65 * 2^26 +// |g1|, |g3|, |g5|, |g7|, |g9| < 1.65 * 2^25 +static void fe_mul(fe h, const fe f, const fe g) +{ + // Everything is unrolled and put in temporary variables. + // We could roll the loop, but that would make curve25519 twice as slow. + i32 f0 = f[0]; i32 f1 = f[1]; i32 f2 = f[2]; i32 f3 = f[3]; i32 f4 = f[4]; + i32 f5 = f[5]; i32 f6 = f[6]; i32 f7 = f[7]; i32 f8 = f[8]; i32 f9 = f[9]; + i32 g0 = g[0]; i32 g1 = g[1]; i32 g2 = g[2]; i32 g3 = g[3]; i32 g4 = g[4]; + i32 g5 = g[5]; i32 g6 = g[6]; i32 g7 = g[7]; i32 g8 = g[8]; i32 g9 = g[9]; + i32 F1 = f1*2; i32 F3 = f3*2; i32 F5 = f5*2; i32 F7 = f7*2; i32 F9 = f9*2; + i32 G1 = g1*19; i32 G2 = g2*19; i32 G3 = g3*19; + i32 G4 = g4*19; i32 G5 = g5*19; i32 G6 = g6*19; + i32 G7 = g7*19; i32 G8 = g8*19; i32 G9 = g9*19; + // |F1|, |F3|, |F5|, |F7|, |F9| < 1.65 * 2^26 + // |G0|, |G2|, |G4|, |G6|, |G8| < 2^31 + // |G1|, |G3|, |G5|, |G7|, |G9| < 2^30 + + i64 t0 = f0*(i64)g0 + F1*(i64)G9 + f2*(i64)G8 + F3*(i64)G7 + f4*(i64)G6 + + F5*(i64)G5 + f6*(i64)G4 + F7*(i64)G3 + f8*(i64)G2 + F9*(i64)G1; + i64 t1 = f0*(i64)g1 + f1*(i64)g0 + f2*(i64)G9 + f3*(i64)G8 + f4*(i64)G7 + + f5*(i64)G6 + f6*(i64)G5 + f7*(i64)G4 + f8*(i64)G3 + f9*(i64)G2; + i64 t2 = f0*(i64)g2 + F1*(i64)g1 + f2*(i64)g0 + F3*(i64)G9 + f4*(i64)G8 + + F5*(i64)G7 + f6*(i64)G6 + F7*(i64)G5 + f8*(i64)G4 + F9*(i64)G3; + i64 t3 = f0*(i64)g3 + f1*(i64)g2 + f2*(i64)g1 + f3*(i64)g0 + f4*(i64)G9 + + f5*(i64)G8 + f6*(i64)G7 + f7*(i64)G6 + f8*(i64)G5 + f9*(i64)G4; + i64 t4 = f0*(i64)g4 + F1*(i64)g3 + f2*(i64)g2 + F3*(i64)g1 + f4*(i64)g0 + + F5*(i64)G9 + f6*(i64)G8 + F7*(i64)G7 + f8*(i64)G6 + F9*(i64)G5; + i64 t5 = f0*(i64)g5 + f1*(i64)g4 + f2*(i64)g3 + f3*(i64)g2 + f4*(i64)g1 + + f5*(i64)g0 + f6*(i64)G9 + f7*(i64)G8 + f8*(i64)G7 + f9*(i64)G6; + i64 t6 = f0*(i64)g6 + F1*(i64)g5 + f2*(i64)g4 + F3*(i64)g3 + f4*(i64)g2 + + F5*(i64)g1 + f6*(i64)g0 + F7*(i64)G9 + f8*(i64)G8 + F9*(i64)G7; + i64 t7 = f0*(i64)g7 + f1*(i64)g6 + f2*(i64)g5 + f3*(i64)g4 + f4*(i64)g3 + + f5*(i64)g2 + f6*(i64)g1 + f7*(i64)g0 + f8*(i64)G9 + f9*(i64)G8; + i64 t8 = f0*(i64)g8 + F1*(i64)g7 + f2*(i64)g6 + F3*(i64)g5 + f4*(i64)g4 + + F5*(i64)g3 + f6*(i64)g2 + F7*(i64)g1 + f8*(i64)g0 + F9*(i64)G9; + i64 t9 = f0*(i64)g9 + f1*(i64)g8 + f2*(i64)g7 + f3*(i64)g6 + f4*(i64)g5 + + f5*(i64)g4 + f6*(i64)g3 + f7*(i64)g2 + f8*(i64)g1 + f9*(i64)g0; + // t0 < 0.67 * 2^61 + // t1 < 0.41 * 2^61 + // t2 < 0.52 * 2^61 + // t3 < 0.32 * 2^61 + // t4 < 0.38 * 2^61 + // t5 < 0.22 * 2^61 + // t6 < 0.23 * 2^61 + // t7 < 0.13 * 2^61 + // t8 < 0.09 * 2^61 + // t9 < 0.03 * 2^61 + + FE_CARRY; // Everything below 2^62, Carry precondition OK +} + +// Precondition +// ------------- +// |f0|, |f2|, |f4|, |f6|, |f8| < 1.65 * 2^26 +// |f1|, |f3|, |f5|, |f7|, |f9| < 1.65 * 2^25 +// +// Note: we could use fe_mul() for this, but this is significantly faster +static void fe_sq(fe h, const fe f) +{ + i32 f0 = f[0]; i32 f1 = f[1]; i32 f2 = f[2]; i32 f3 = f[3]; i32 f4 = f[4]; + i32 f5 = f[5]; i32 f6 = f[6]; i32 f7 = f[7]; i32 f8 = f[8]; i32 f9 = f[9]; + i32 f0_2 = f0*2; i32 f1_2 = f1*2; i32 f2_2 = f2*2; i32 f3_2 = f3*2; + i32 f4_2 = f4*2; i32 f5_2 = f5*2; i32 f6_2 = f6*2; i32 f7_2 = f7*2; + i32 f5_38 = f5*38; i32 f6_19 = f6*19; i32 f7_38 = f7*38; + i32 f8_19 = f8*19; i32 f9_38 = f9*38; + // |f0_2| , |f2_2| , |f4_2| , |f6_2| , |f8_2| < 1.65 * 2^27 + // |f1_2| , |f3_2| , |f5_2| , |f7_2| , |f9_2| < 1.65 * 2^26 + // |f5_38|, |f6_19|, |f7_38|, |f8_19|, |f9_38| < 2^31 + + i64 t0 = f0 *(i64)f0 + f1_2*(i64)f9_38 + f2_2*(i64)f8_19 + + f3_2*(i64)f7_38 + f4_2*(i64)f6_19 + f5 *(i64)f5_38; + i64 t1 = f0_2*(i64)f1 + f2 *(i64)f9_38 + f3_2*(i64)f8_19 + + f4 *(i64)f7_38 + f5_2*(i64)f6_19; + i64 t2 = f0_2*(i64)f2 + f1_2*(i64)f1 + f3_2*(i64)f9_38 + + f4_2*(i64)f8_19 + f5_2*(i64)f7_38 + f6 *(i64)f6_19; + i64 t3 = f0_2*(i64)f3 + f1_2*(i64)f2 + f4 *(i64)f9_38 + + f5_2*(i64)f8_19 + f6 *(i64)f7_38; + i64 t4 = f0_2*(i64)f4 + f1_2*(i64)f3_2 + f2 *(i64)f2 + + f5_2*(i64)f9_38 + f6_2*(i64)f8_19 + f7 *(i64)f7_38; + i64 t5 = f0_2*(i64)f5 + f1_2*(i64)f4 + f2_2*(i64)f3 + + f6 *(i64)f9_38 + f7_2*(i64)f8_19; + i64 t6 = f0_2*(i64)f6 + f1_2*(i64)f5_2 + f2_2*(i64)f4 + + f3_2*(i64)f3 + f7_2*(i64)f9_38 + f8 *(i64)f8_19; + i64 t7 = f0_2*(i64)f7 + f1_2*(i64)f6 + f2_2*(i64)f5 + + f3_2*(i64)f4 + f8 *(i64)f9_38; + i64 t8 = f0_2*(i64)f8 + f1_2*(i64)f7_2 + f2_2*(i64)f6 + + f3_2*(i64)f5_2 + f4 *(i64)f4 + f9 *(i64)f9_38; + i64 t9 = f0_2*(i64)f9 + f1_2*(i64)f8 + f2_2*(i64)f7 + + f3_2*(i64)f6 + f4 *(i64)f5_2; + // t0 < 0.67 * 2^61 + // t1 < 0.41 * 2^61 + // t2 < 0.52 * 2^61 + // t3 < 0.32 * 2^61 + // t4 < 0.38 * 2^61 + // t5 < 0.22 * 2^61 + // t6 < 0.23 * 2^61 + // t7 < 0.13 * 2^61 + // t8 < 0.09 * 2^61 + // t9 < 0.03 * 2^61 + + FE_CARRY; +} + +// Parity check. Returns 0 if even, 1 if odd +static int fe_isodd(const fe f) +{ + u8 s[32]; + fe_tobytes(s, f); + u8 isodd = s[0] & 1; + WIPE_BUFFER(s); + return isodd; +} + +// Returns 1 if equal, 0 if not equal +static int fe_isequal(const fe f, const fe g) +{ + u8 fs[32]; + u8 gs[32]; + fe_tobytes(fs, f); + fe_tobytes(gs, g); + int isdifferent = crypto_verify32(fs, gs); + WIPE_BUFFER(fs); + WIPE_BUFFER(gs); + return 1 + isdifferent; +} + +// Inverse square root. +// Returns true if x is a square, false otherwise. +// After the call: +// isr = sqrt(1/x) if x is a non-zero square. +// isr = sqrt(sqrt(-1)/x) if x is not a square. +// isr = 0 if x is zero. +// We do not guarantee the sign of the square root. +// +// Notes: +// Let quartic = x^((p-1)/4) +// +// x^((p-1)/2) = chi(x) +// quartic^2 = chi(x) +// quartic = sqrt(chi(x)) +// quartic = 1 or -1 or sqrt(-1) or -sqrt(-1) +// +// Note that x is a square if quartic is 1 or -1 +// There are 4 cases to consider: +// +// if quartic = 1 (x is a square) +// then x^((p-1)/4) = 1 +// x^((p-5)/4) * x = 1 +// x^((p-5)/4) = 1/x +// x^((p-5)/8) = sqrt(1/x) or -sqrt(1/x) +// +// if quartic = -1 (x is a square) +// then x^((p-1)/4) = -1 +// x^((p-5)/4) * x = -1 +// x^((p-5)/4) = -1/x +// x^((p-5)/8) = sqrt(-1) / sqrt(x) +// x^((p-5)/8) * sqrt(-1) = sqrt(-1)^2 / sqrt(x) +// x^((p-5)/8) * sqrt(-1) = -1/sqrt(x) +// x^((p-5)/8) * sqrt(-1) = -sqrt(1/x) or sqrt(1/x) +// +// if quartic = sqrt(-1) (x is not a square) +// then x^((p-1)/4) = sqrt(-1) +// x^((p-5)/4) * x = sqrt(-1) +// x^((p-5)/4) = sqrt(-1)/x +// x^((p-5)/8) = sqrt(sqrt(-1)/x) or -sqrt(sqrt(-1)/x) +// +// Note that the product of two non-squares is always a square: +// For any non-squares a and b, chi(a) = -1 and chi(b) = -1. +// Since chi(x) = x^((p-1)/2), chi(a)*chi(b) = chi(a*b) = 1. +// Therefore a*b is a square. +// +// Since sqrt(-1) and x are both non-squares, their product is a +// square, and we can compute their square root. +// +// if quartic = -sqrt(-1) (x is not a square) +// then x^((p-1)/4) = -sqrt(-1) +// x^((p-5)/4) * x = -sqrt(-1) +// x^((p-5)/4) = -sqrt(-1)/x +// x^((p-5)/8) = sqrt(-sqrt(-1)/x) +// x^((p-5)/8) = sqrt( sqrt(-1)/x) * sqrt(-1) +// x^((p-5)/8) * sqrt(-1) = sqrt( sqrt(-1)/x) * sqrt(-1)^2 +// x^((p-5)/8) * sqrt(-1) = sqrt( sqrt(-1)/x) * -1 +// x^((p-5)/8) * sqrt(-1) = -sqrt(sqrt(-1)/x) or sqrt(sqrt(-1)/x) +static int invsqrt(fe isr, const fe x) +{ + fe t0, t1, t2; + + // t0 = x^((p-5)/8) + // Can be achieved with a simple double & add ladder, + // but it would be slower. + fe_sq(t0, x); + fe_sq(t1,t0); fe_sq(t1, t1); fe_mul(t1, x, t1); + fe_mul(t0, t0, t1); + fe_sq(t0, t0); fe_mul(t0, t1, t0); + fe_sq(t1, t0); FOR (i, 1, 5) { fe_sq(t1, t1); } fe_mul(t0, t1, t0); + fe_sq(t1, t0); FOR (i, 1, 10) { fe_sq(t1, t1); } fe_mul(t1, t1, t0); + fe_sq(t2, t1); FOR (i, 1, 20) { fe_sq(t2, t2); } fe_mul(t1, t2, t1); + fe_sq(t1, t1); FOR (i, 1, 10) { fe_sq(t1, t1); } fe_mul(t0, t1, t0); + fe_sq(t1, t0); FOR (i, 1, 50) { fe_sq(t1, t1); } fe_mul(t1, t1, t0); + fe_sq(t2, t1); FOR (i, 1, 100) { fe_sq(t2, t2); } fe_mul(t1, t2, t1); + fe_sq(t1, t1); FOR (i, 1, 50) { fe_sq(t1, t1); } fe_mul(t0, t1, t0); + fe_sq(t0, t0); FOR (i, 1, 2) { fe_sq(t0, t0); } fe_mul(t0, t0, x); + + // quartic = x^((p-1)/4) + i32 *quartic = t1; + fe_sq (quartic, t0); + fe_mul(quartic, quartic, x); + + i32 *check = t2; + fe_0 (check); int z0 = fe_isequal(x , check); + fe_1 (check); int p1 = fe_isequal(quartic, check); + fe_neg(check, check ); int m1 = fe_isequal(quartic, check); + fe_neg(check, sqrtm1); int ms = fe_isequal(quartic, check); + + // if quartic == -1 or sqrt(-1) + // then isr = x^((p-1)/4) * sqrt(-1) + // else isr = x^((p-1)/4) + fe_mul(isr, t0, sqrtm1); + fe_ccopy(isr, t0, 1 - (m1 | ms)); + + WIPE_BUFFER(t0); + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); + return p1 | m1 | z0; +} + +// Inverse in terms of inverse square root. +// Requires two additional squarings to get rid of the sign. +// +// 1/x = x * (+invsqrt(x^2))^2 +// = x * (-invsqrt(x^2))^2 +// +// A fully optimised exponentiation by p-1 would save 6 field +// multiplications, but it would require more code. +static void fe_invert(fe out, const fe x) +{ + fe tmp; + fe_sq(tmp, x); + invsqrt(tmp, tmp); + fe_sq(tmp, tmp); + fe_mul(out, tmp, x); + WIPE_BUFFER(tmp); +} + +// trim a scalar for scalar multiplication +void crypto_eddsa_trim_scalar(u8 out[32], const u8 in[32]) +{ + COPY(out, in, 32); + out[ 0] &= 248; + out[31] &= 127; + out[31] |= 64; +} + +// get bit from scalar at position i +static int scalar_bit(const u8 s[32], int i) +{ + if (i < 0) { return 0; } // handle -1 for sliding windows + return (s[i>>3] >> (i&7)) & 1; +} + +/////////////// +/// X-25519 /// Taken from SUPERCOP's ref10 implementation. +/////////////// +static void scalarmult(u8 q[32], const u8 scalar[32], const u8 p[32], + int nb_bits) +{ + // computes the scalar product + fe x1; + fe_frombytes(x1, p); + + // computes the actual scalar product (the result is in x2 and z2) + fe x2, z2, x3, z3, t0, t1; + // Montgomery ladder + // In projective coordinates, to avoid divisions: x = X / Z + // We don't care about the y coordinate, it's only 1 bit of information + fe_1(x2); fe_0(z2); // "zero" point + fe_copy(x3, x1); fe_1(z3); // "one" point + int swap = 0; + for (int pos = nb_bits-1; pos >= 0; --pos) { + // constant time conditional swap before ladder step + int b = scalar_bit(scalar, pos); + swap ^= b; // xor trick avoids swapping at the end of the loop + fe_cswap(x2, x3, swap); + fe_cswap(z2, z3, swap); + swap = b; // anticipates one last swap after the loop + + // Montgomery ladder step: replaces (P2, P3) by (P2*2, P2+P3) + // with differential addition + fe_sub(t0, x3, z3); + fe_sub(t1, x2, z2); + fe_add(x2, x2, z2); + fe_add(z2, x3, z3); + fe_mul(z3, t0, x2); + fe_mul(z2, z2, t1); + fe_sq (t0, t1 ); + fe_sq (t1, x2 ); + fe_add(x3, z3, z2); + fe_sub(z2, z3, z2); + fe_mul(x2, t1, t0); + fe_sub(t1, t1, t0); + fe_sq (z2, z2 ); + fe_mul_small(z3, t1, 121666); + fe_sq (x3, x3 ); + fe_add(t0, t0, z3); + fe_mul(z3, x1, z2); + fe_mul(z2, t1, t0); + } + // last swap is necessary to compensate for the xor trick + // Note: after this swap, P3 == P2 + P1. + fe_cswap(x2, x3, swap); + fe_cswap(z2, z3, swap); + + // normalises the coordinates: x == X / Z + fe_invert(z2, z2); + fe_mul(x2, x2, z2); + fe_tobytes(q, x2); + + WIPE_BUFFER(x1); + WIPE_BUFFER(x2); WIPE_BUFFER(z2); WIPE_BUFFER(t0); + WIPE_BUFFER(x3); WIPE_BUFFER(z3); WIPE_BUFFER(t1); +} + +void crypto_x25519(u8 raw_shared_secret[32], + const u8 your_secret_key [32], + const u8 their_public_key [32]) +{ + // restrict the possible scalar values + u8 e[32]; + crypto_eddsa_trim_scalar(e, your_secret_key); + scalarmult(raw_shared_secret, e, their_public_key, 255); + WIPE_BUFFER(e); +} + +void crypto_x25519_public_key(u8 public_key[32], + const u8 secret_key[32]) +{ + static const u8 base_point[32] = {9}; + crypto_x25519(public_key, secret_key, base_point); +} + +/////////////////////////// +/// Arithmetic modulo L /// +/////////////////////////// +static const u32 L[8] = { + 0x5cf5d3ed, 0x5812631a, 0xa2f79cd6, 0x14def9de, + 0x00000000, 0x00000000, 0x00000000, 0x10000000, +}; + +// p = a*b + p +static void multiply(u32 p[16], const u32 a[8], const u32 b[8]) +{ + FOR (i, 0, 8) { + u64 carry = 0; + FOR (j, 0, 8) { + carry += p[i+j] + (u64)a[i] * b[j]; + p[i+j] = (u32)carry; + carry >>= 32; + } + p[i+8] = (u32)carry; + } +} + +static int is_above_l(const u32 x[8]) +{ + // We work with L directly, in a 2's complement encoding + // (-L == ~L + 1) + u64 carry = 1; + FOR (i, 0, 8) { + carry += (u64)x[i] + (~L[i] & 0xffffffff); + carry >>= 32; + } + return (int)carry; // carry is either 0 or 1 +} + +// Final reduction modulo L, by conditionally removing L. +// if x < l , then r = x +// if l <= x 2*l, then r = x-l +// otherwise the result will be wrong +static void remove_l(u32 r[8], const u32 x[8]) +{ + u64 carry = (u64)is_above_l(x); + u32 mask = ~(u32)carry + 1; // carry == 0 or 1 + FOR (i, 0, 8) { + carry += (u64)x[i] + (~L[i] & mask); + r[i] = (u32)carry; + carry >>= 32; + } +} + +// Full reduction modulo L (Barrett reduction) +static void mod_l(u8 reduced[32], const u32 x[16]) +{ + static const u32 r[9] = { + 0x0a2c131b,0xed9ce5a3,0x086329a7,0x2106215d, + 0xffffffeb,0xffffffff,0xffffffff,0xffffffff,0xf, + }; + // xr = x * r + u32 xr[25] = {0}; + FOR (i, 0, 9) { + u64 carry = 0; + FOR (j, 0, 16) { + carry += xr[i+j] + (u64)r[i] * x[j]; + xr[i+j] = (u32)carry; + carry >>= 32; + } + xr[i+16] = (u32)carry; + } + // xr = floor(xr / 2^512) * L + // Since the result is guaranteed to be below 2*L, + // it is enough to only compute the first 256 bits. + // The division is performed by saying xr[i+16]. (16 * 32 = 512) + ZERO(xr, 8); + FOR (i, 0, 8) { + u64 carry = 0; + FOR (j, 0, 8-i) { + carry += xr[i+j] + (u64)xr[i+16] * L[j]; + xr[i+j] = (u32)carry; + carry >>= 32; + } + } + // xr = x - xr + u64 carry = 1; + FOR (i, 0, 8) { + carry += (u64)x[i] + (~xr[i] & 0xffffffff); + xr[i] = (u32)carry; + carry >>= 32; + } + // Final reduction modulo L (conditional subtraction) + remove_l(xr, xr); + store32_le_buf(reduced, xr, 8); + + WIPE_BUFFER(xr); +} + +void crypto_eddsa_reduce(u8 reduced[32], const u8 expanded[64]) +{ + u32 x[16]; + load32_le_buf(x, expanded, 16); + mod_l(reduced, x); + WIPE_BUFFER(x); +} + +// r = (a * b) + c +void crypto_eddsa_mul_add(u8 r[32], + const u8 a[32], const u8 b[32], const u8 c[32]) +{ + u32 A[8]; load32_le_buf(A, a, 8); + u32 B[8]; load32_le_buf(B, b, 8); + u32 p[16]; load32_le_buf(p, c, 8); ZERO(p + 8, 8); + multiply(p, A, B); + mod_l(r, p); + WIPE_BUFFER(p); + WIPE_BUFFER(A); + WIPE_BUFFER(B); +} + +/////////////// +/// Ed25519 /// +/////////////// + +// Point (group element, ge) in a twisted Edwards curve, +// in extended projective coordinates. +// ge : x = X/Z, y = Y/Z, T = XY/Z +// ge_cached : Yp = X+Y, Ym = X-Y, T2 = T*D2 +// ge_precomp: Z = 1 +typedef struct { fe X; fe Y; fe Z; fe T; } ge; +typedef struct { fe Yp; fe Ym; fe Z; fe T2; } ge_cached; +typedef struct { fe Yp; fe Ym; fe T2; } ge_precomp; + +static void ge_zero(ge *p) +{ + fe_0(p->X); + fe_1(p->Y); + fe_1(p->Z); + fe_0(p->T); +} + +static void ge_tobytes(u8 s[32], const ge *h) +{ + fe recip, x, y; + fe_invert(recip, h->Z); + fe_mul(x, h->X, recip); + fe_mul(y, h->Y, recip); + fe_tobytes(s, y); + s[31] ^= fe_isodd(x) << 7; + + WIPE_BUFFER(recip); + WIPE_BUFFER(x); + WIPE_BUFFER(y); +} + +// h = -s, where s is a point encoded in 32 bytes +// +// Variable time! Inputs must not be secret! +// => Use only to *check* signatures. +// +// From the specifications: +// The encoding of s contains y and the sign of x +// x = sqrt((y^2 - 1) / (d*y^2 + 1)) +// In extended coordinates: +// X = x, Y = y, Z = 1, T = x*y +// +// Note that num * den is a square iff num / den is a square +// If num * den is not a square, the point was not on the curve. +// From the above: +// Let num = y^2 - 1 +// Let den = d*y^2 + 1 +// x = sqrt((y^2 - 1) / (d*y^2 + 1)) +// x = sqrt(num / den) +// x = sqrt(num^2 / (num * den)) +// x = num * sqrt(1 / (num * den)) +// +// Therefore, we can just compute: +// num = y^2 - 1 +// den = d*y^2 + 1 +// isr = invsqrt(num * den) // abort if not square +// x = num * isr +// Finally, negate x if its sign is not as specified. +static int ge_frombytes_neg_vartime(ge *h, const u8 s[32]) +{ + fe_frombytes(h->Y, s); + fe_1(h->Z); + fe_sq (h->T, h->Y); // t = y^2 + fe_mul(h->X, h->T, d ); // x = d*y^2 + fe_sub(h->T, h->T, h->Z); // t = y^2 - 1 + fe_add(h->X, h->X, h->Z); // x = d*y^2 + 1 + fe_mul(h->X, h->T, h->X); // x = (y^2 - 1) * (d*y^2 + 1) + int is_square = invsqrt(h->X, h->X); + if (!is_square) { + return -1; // Not on the curve, abort + } + fe_mul(h->X, h->T, h->X); // x = sqrt((y^2 - 1) / (d*y^2 + 1)) + if (fe_isodd(h->X) == (s[31] >> 7)) { + fe_neg(h->X, h->X); + } + fe_mul(h->T, h->X, h->Y); + return 0; +} + +static void ge_cache(ge_cached *c, const ge *p) +{ + fe_add (c->Yp, p->Y, p->X); + fe_sub (c->Ym, p->Y, p->X); + fe_copy(c->Z , p->Z ); + fe_mul (c->T2, p->T, D2 ); +} + +// Internal buffers are not wiped! Inputs must not be secret! +// => Use only to *check* signatures. +static void ge_add(ge *s, const ge *p, const ge_cached *q) +{ + fe a, b; + fe_add(a , p->Y, p->X ); + fe_sub(b , p->Y, p->X ); + fe_mul(a , a , q->Yp); + fe_mul(b , b , q->Ym); + fe_add(s->Y, a , b ); + fe_sub(s->X, a , b ); + + fe_add(s->Z, p->Z, p->Z ); + fe_mul(s->Z, s->Z, q->Z ); + fe_mul(s->T, p->T, q->T2); + fe_add(a , s->Z, s->T ); + fe_sub(b , s->Z, s->T ); + + fe_mul(s->T, s->X, s->Y); + fe_mul(s->X, s->X, b ); + fe_mul(s->Y, s->Y, a ); + fe_mul(s->Z, a , b ); +} + +// Internal buffers are not wiped! Inputs must not be secret! +// => Use only to *check* signatures. +static void ge_sub(ge *s, const ge *p, const ge_cached *q) +{ + ge_cached neg; + fe_copy(neg.Ym, q->Yp); + fe_copy(neg.Yp, q->Ym); + fe_copy(neg.Z , q->Z ); + fe_neg (neg.T2, q->T2); + ge_add(s, p, &neg); +} + +static void ge_madd(ge *s, const ge *p, const ge_precomp *q, fe a, fe b) +{ + fe_add(a , p->Y, p->X ); + fe_sub(b , p->Y, p->X ); + fe_mul(a , a , q->Yp); + fe_mul(b , b , q->Ym); + fe_add(s->Y, a , b ); + fe_sub(s->X, a , b ); + + fe_add(s->Z, p->Z, p->Z ); + fe_mul(s->T, p->T, q->T2); + fe_add(a , s->Z, s->T ); + fe_sub(b , s->Z, s->T ); + + fe_mul(s->T, s->X, s->Y); + fe_mul(s->X, s->X, b ); + fe_mul(s->Y, s->Y, a ); + fe_mul(s->Z, a , b ); +} + +// Internal buffers are not wiped! Inputs must not be secret! +// => Use only to *check* signatures. +static void ge_msub(ge *s, const ge *p, const ge_precomp *q, fe a, fe b) +{ + ge_precomp neg; + fe_copy(neg.Ym, q->Yp); + fe_copy(neg.Yp, q->Ym); + fe_neg (neg.T2, q->T2); + ge_madd(s, p, &neg, a, b); +} + +static void ge_double(ge *s, const ge *p, ge *q) +{ + fe_sq (q->X, p->X); + fe_sq (q->Y, p->Y); + fe_sq (q->Z, p->Z); // qZ = pZ^2 + fe_mul_small(q->Z, q->Z, 2); // qZ = pZ^2 * 2 + fe_add(q->T, p->X, p->Y); + fe_sq (s->T, q->T); + fe_add(q->T, q->Y, q->X); + fe_sub(q->Y, q->Y, q->X); + fe_sub(q->X, s->T, q->T); + fe_sub(q->Z, q->Z, q->Y); + + fe_mul(s->X, q->X , q->Z); + fe_mul(s->Y, q->T , q->Y); + fe_mul(s->Z, q->Y , q->Z); + fe_mul(s->T, q->X , q->T); +} + +// 5-bit signed window in cached format (Niels coordinates, Z=1) +static const ge_precomp b_window[8] = { + {{25967493,-14356035,29566456,3660896,-12694345, + 4014787,27544626,-11754271,-6079156,2047605,}, + {-12545711,934262,-2722910,3049990,-727428, + 9406986,12720692,5043384,19500929,-15469378,}, + {-8738181,4489570,9688441,-14785194,10184609, + -12363380,29287919,11864899,-24514362,-4438546,},}, + {{15636291,-9688557,24204773,-7912398,616977, + -16685262,27787600,-14772189,28944400,-1550024,}, + {16568933,4717097,-11556148,-1102322,15682896, + -11807043,16354577,-11775962,7689662,11199574,}, + {30464156,-5976125,-11779434,-15670865,23220365, + 15915852,7512774,10017326,-17749093,-9920357,},}, + {{10861363,11473154,27284546,1981175,-30064349, + 12577861,32867885,14515107,-15438304,10819380,}, + {4708026,6336745,20377586,9066809,-11272109, + 6594696,-25653668,12483688,-12668491,5581306,}, + {19563160,16186464,-29386857,4097519,10237984, + -4348115,28542350,13850243,-23678021,-15815942,},}, + {{5153746,9909285,1723747,-2777874,30523605, + 5516873,19480852,5230134,-23952439,-15175766,}, + {-30269007,-3463509,7665486,10083793,28475525, + 1649722,20654025,16520125,30598449,7715701,}, + {28881845,14381568,9657904,3680757,-20181635, + 7843316,-31400660,1370708,29794553,-1409300,},}, + {{-22518993,-6692182,14201702,-8745502,-23510406, + 8844726,18474211,-1361450,-13062696,13821877,}, + {-6455177,-7839871,3374702,-4740862,-27098617, + -10571707,31655028,-7212327,18853322,-14220951,}, + {4566830,-12963868,-28974889,-12240689,-7602672, + -2830569,-8514358,-10431137,2207753,-3209784,},}, + {{-25154831,-4185821,29681144,7868801,-6854661, + -9423865,-12437364,-663000,-31111463,-16132436,}, + {25576264,-2703214,7349804,-11814844,16472782, + 9300885,3844789,15725684,171356,6466918,}, + {23103977,13316479,9739013,-16149481,817875, + -15038942,8965339,-14088058,-30714912,16193877,},}, + {{-33521811,3180713,-2394130,14003687,-16903474, + -16270840,17238398,4729455,-18074513,9256800,}, + {-25182317,-4174131,32336398,5036987,-21236817, + 11360617,22616405,9761698,-19827198,630305,}, + {-13720693,2639453,-24237460,-7406481,9494427, + -5774029,-6554551,-15960994,-2449256,-14291300,},}, + {{-3151181,-5046075,9282714,6866145,-31907062, + -863023,-18940575,15033784,25105118,-7894876,}, + {-24326370,15950226,-31801215,-14592823,-11662737, + -5090925,1573892,-2625887,2198790,-15804619,}, + {-3099351,10324967,-2241613,7453183,-5446979, + -2735503,-13812022,-16236442,-32461234,-12290683,},}, +}; + +// Incremental sliding windows (left to right) +// Based on Roberto Maria Avanzi[2005] +typedef struct { + i16 next_index; // position of the next signed digit + i8 next_digit; // next signed digit (odd number below 2^window_width) + u8 next_check; // point at which we must check for a new window +} slide_ctx; + +static void slide_init(slide_ctx *ctx, const u8 scalar[32]) +{ + // scalar is guaranteed to be below L, either because we checked (s), + // or because we reduced it modulo L (h_ram). L is under 2^253, so + // so bits 253 to 255 are guaranteed to be zero. No need to test them. + // + // Note however that L is very close to 2^252, so bit 252 is almost + // always zero. If we were to start at bit 251, the tests wouldn't + // catch the off-by-one error (constructing one that does would be + // prohibitively expensive). + // + // We should still check bit 252, though. + int i = 252; + while (i > 0 && scalar_bit(scalar, i) == 0) { + i--; + } + ctx->next_check = (u8)(i + 1); + ctx->next_index = -1; + ctx->next_digit = -1; +} + +static int slide_step(slide_ctx *ctx, int width, int i, const u8 scalar[32]) +{ + if (i == ctx->next_check) { + if (scalar_bit(scalar, i) == scalar_bit(scalar, i - 1)) { + ctx->next_check--; + } else { + // compute digit of next window + int w = MIN(width, i + 1); + int v = -(scalar_bit(scalar, i) << (w-1)); + FOR_T (int, j, 0, w-1) { + v += scalar_bit(scalar, i-(w-1)+j) << j; + } + v += scalar_bit(scalar, i-w); + int lsb = v & (~v + 1); // smallest bit of v + int s = // log2(lsb) + (((lsb & 0xAA) != 0) << 0) | + (((lsb & 0xCC) != 0) << 1) | + (((lsb & 0xF0) != 0) << 2); + ctx->next_index = (i16)(i-(w-1)+s); + ctx->next_digit = (i8) (v >> s ); + ctx->next_check -= (u8) w; + } + } + return i == ctx->next_index ? ctx->next_digit: 0; +} + +#define P_W_WIDTH 3 // Affects the size of the stack +#define B_W_WIDTH 5 // Affects the size of the binary +#define P_W_SIZE (1<<(P_W_WIDTH-2)) + +int crypto_eddsa_check_equation(const u8 signature[64], const u8 public_key[32], + const u8 h[32]) +{ + ge minus_A; // -public_key + ge minus_R; // -first_half_of_signature + const u8 *s = signature + 32; + + // Check that A and R are on the curve + // Check that 0 <= S < L (prevents malleability) + // *Allow* non-cannonical encoding for A and R + { + u32 s32[8]; + load32_le_buf(s32, s, 8); + if (ge_frombytes_neg_vartime(&minus_A, public_key) || + ge_frombytes_neg_vartime(&minus_R, signature) || + is_above_l(s32)) { + return -1; + } + } + + // look-up table for minus_A + ge_cached lutA[P_W_SIZE]; + { + ge minus_A2, tmp; + ge_double(&minus_A2, &minus_A, &tmp); + ge_cache(&lutA[0], &minus_A); + FOR (i, 1, P_W_SIZE) { + ge_add(&tmp, &minus_A2, &lutA[i-1]); + ge_cache(&lutA[i], &tmp); + } + } + + // sum = [s]B - [h]A + // Merged double and add ladder, fused with sliding + slide_ctx h_slide; slide_init(&h_slide, h); + slide_ctx s_slide; slide_init(&s_slide, s); + int i = MAX(h_slide.next_check, s_slide.next_check); + ge *sum = &minus_A; // reuse minus_A for the sum + ge_zero(sum); + while (i >= 0) { + ge tmp; + ge_double(sum, sum, &tmp); + int h_digit = slide_step(&h_slide, P_W_WIDTH, i, h); + int s_digit = slide_step(&s_slide, B_W_WIDTH, i, s); + if (h_digit > 0) { ge_add(sum, sum, &lutA[ h_digit / 2]); } + if (h_digit < 0) { ge_sub(sum, sum, &lutA[-h_digit / 2]); } + fe t1, t2; + if (s_digit > 0) { ge_madd(sum, sum, b_window + s_digit/2, t1, t2); } + if (s_digit < 0) { ge_msub(sum, sum, b_window + -s_digit/2, t1, t2); } + i--; + } + + // Compare [8](sum-R) and the zero point + // The multiplication by 8 eliminates any low-order component + // and ensures consistency with batched verification. + ge_cached cached; + u8 check[32]; + static const u8 zero_point[32] = {1}; // Point of order 1 + ge_cache(&cached, &minus_R); + ge_add(sum, sum, &cached); + ge_double(sum, sum, &minus_R); // reuse minus_R as temporary + ge_double(sum, sum, &minus_R); // reuse minus_R as temporary + ge_double(sum, sum, &minus_R); // reuse minus_R as temporary + ge_tobytes(check, sum); + return crypto_verify32(check, zero_point); +} + +// 5-bit signed comb in cached format (Niels coordinates, Z=1) +static const ge_precomp b_comb_low[8] = { + {{-6816601,-2324159,-22559413,124364,18015490, + 8373481,19993724,1979872,-18549925,9085059,}, + {10306321,403248,14839893,9633706,8463310, + -8354981,-14305673,14668847,26301366,2818560,}, + {-22701500,-3210264,-13831292,-2927732,-16326337, + -14016360,12940910,177905,12165515,-2397893,},}, + {{-12282262,-7022066,9920413,-3064358,-32147467, + 2927790,22392436,-14852487,2719975,16402117,}, + {-7236961,-4729776,2685954,-6525055,-24242706, + -15940211,-6238521,14082855,10047669,12228189,}, + {-30495588,-12893761,-11161261,3539405,-11502464, + 16491580,-27286798,-15030530,-7272871,-15934455,},}, + {{17650926,582297,-860412,-187745,-12072900, + -10683391,-20352381,15557840,-31072141,-5019061,}, + {-6283632,-2259834,-4674247,-4598977,-4089240, + 12435688,-31278303,1060251,6256175,10480726,}, + {-13871026,2026300,-21928428,-2741605,-2406664, + -8034988,7355518,15733500,-23379862,7489131,},}, + {{6883359,695140,23196907,9644202,-33430614, + 11354760,-20134606,6388313,-8263585,-8491918,}, + {-7716174,-13605463,-13646110,14757414,-19430591, + -14967316,10359532,-11059670,-21935259,12082603,}, + {-11253345,-15943946,10046784,5414629,24840771, + 8086951,-6694742,9868723,15842692,-16224787,},}, + {{9639399,11810955,-24007778,-9320054,3912937, + -9856959,996125,-8727907,-8919186,-14097242,}, + {7248867,14468564,25228636,-8795035,14346339, + 8224790,6388427,-7181107,6468218,-8720783,}, + {15513115,15439095,7342322,-10157390,18005294, + -7265713,2186239,4884640,10826567,7135781,},}, + {{-14204238,5297536,-5862318,-6004934,28095835, + 4236101,-14203318,1958636,-16816875,3837147,}, + {-5511166,-13176782,-29588215,12339465,15325758, + -15945770,-8813185,11075932,-19608050,-3776283,}, + {11728032,9603156,-4637821,-5304487,-7827751, + 2724948,31236191,-16760175,-7268616,14799772,},}, + {{-28842672,4840636,-12047946,-9101456,-1445464, + 381905,-30977094,-16523389,1290540,12798615,}, + {27246947,-10320914,14792098,-14518944,5302070, + -8746152,-3403974,-4149637,-27061213,10749585,}, + {25572375,-6270368,-15353037,16037944,1146292, + 32198,23487090,9585613,24714571,-1418265,},}, + {{19844825,282124,-17583147,11004019,-32004269, + -2716035,6105106,-1711007,-21010044,14338445,}, + {8027505,8191102,-18504907,-12335737,25173494, + -5923905,15446145,7483684,-30440441,10009108,}, + {-14134701,-4174411,10246585,-14677495,33553567, + -14012935,23366126,15080531,-7969992,7663473,},}, +}; + +static const ge_precomp b_comb_high[8] = { + {{33055887,-4431773,-521787,6654165,951411, + -6266464,-5158124,6995613,-5397442,-6985227,}, + {4014062,6967095,-11977872,3960002,8001989, + 5130302,-2154812,-1899602,-31954493,-16173976,}, + {16271757,-9212948,23792794,731486,-25808309, + -3546396,6964344,-4767590,10976593,10050757,},}, + {{2533007,-4288439,-24467768,-12387405,-13450051, + 14542280,12876301,13893535,15067764,8594792,}, + {20073501,-11623621,3165391,-13119866,13188608, + -11540496,-10751437,-13482671,29588810,2197295,}, + {-1084082,11831693,6031797,14062724,14748428, + -8159962,-20721760,11742548,31368706,13161200,},}, + {{2050412,-6457589,15321215,5273360,25484180, + 124590,-18187548,-7097255,-6691621,-14604792,}, + {9938196,2162889,-6158074,-1711248,4278932, + -2598531,-22865792,-7168500,-24323168,11746309,}, + {-22691768,-14268164,5965485,9383325,20443693, + 5854192,28250679,-1381811,-10837134,13717818,},}, + {{-8495530,16382250,9548884,-4971523,-4491811, + -3902147,6182256,-12832479,26628081,10395408,}, + {27329048,-15853735,7715764,8717446,-9215518, + -14633480,28982250,-5668414,4227628,242148,}, + {-13279943,-7986904,-7100016,8764468,-27276630, + 3096719,29678419,-9141299,3906709,11265498,},}, + {{11918285,15686328,-17757323,-11217300,-27548967, + 4853165,-27168827,6807359,6871949,-1075745,}, + {-29002610,13984323,-27111812,-2713442,28107359, + -13266203,6155126,15104658,3538727,-7513788,}, + {14103158,11233913,-33165269,9279850,31014152, + 4335090,-1827936,4590951,13960841,12787712,},}, + {{1469134,-16738009,33411928,13942824,8092558, + -8778224,-11165065,1437842,22521552,-2792954,}, + {31352705,-4807352,-25327300,3962447,12541566, + -9399651,-27425693,7964818,-23829869,5541287,}, + {-25732021,-6864887,23848984,3039395,-9147354, + 6022816,-27421653,10590137,25309915,-1584678,},}, + {{-22951376,5048948,31139401,-190316,-19542447, + -626310,-17486305,-16511925,-18851313,-12985140,}, + {-9684890,14681754,30487568,7717771,-10829709, + 9630497,30290549,-10531496,-27798994,-13812825,}, + {5827835,16097107,-24501327,12094619,7413972, + 11447087,28057551,-1793987,-14056981,4359312,},}, + {{26323183,2342588,-21887793,-1623758,-6062284, + 2107090,-28724907,9036464,-19618351,-13055189,}, + {-29697200,14829398,-4596333,14220089,-30022969, + 2955645,12094100,-13693652,-5941445,7047569,}, + {-3201977,14413268,-12058324,-16417589,-9035655, + -7224648,9258160,1399236,30397584,-5684634,},}, +}; + +static void lookup_add(ge *p, ge_precomp *tmp_c, fe tmp_a, fe tmp_b, + const ge_precomp comb[8], const u8 scalar[32], int i) +{ + u8 teeth = (u8)((scalar_bit(scalar, i) ) + + (scalar_bit(scalar, i + 32) << 1) + + (scalar_bit(scalar, i + 64) << 2) + + (scalar_bit(scalar, i + 96) << 3)); + u8 high = teeth >> 3; + u8 index = (teeth ^ (high - 1)) & 7; + FOR (j, 0, 8) { + i32 select = 1 & (((j ^ index) - 1) >> 8); + fe_ccopy(tmp_c->Yp, comb[j].Yp, select); + fe_ccopy(tmp_c->Ym, comb[j].Ym, select); + fe_ccopy(tmp_c->T2, comb[j].T2, select); + } + fe_neg(tmp_a, tmp_c->T2); + fe_cswap(tmp_c->T2, tmp_a , high ^ 1); + fe_cswap(tmp_c->Yp, tmp_c->Ym, high ^ 1); + ge_madd(p, p, tmp_c, tmp_a, tmp_b); +} + +// p = [scalar]B, where B is the base point +static void ge_scalarmult_base(ge *p, const u8 scalar[32]) +{ + // twin 4-bits signed combs, from Mike Hamburg's + // Fast and compact elliptic-curve cryptography (2012) + // 1 / 2 modulo L + static const u8 half_mod_L[32] = { + 247,233,122,46,141,49,9,44,107,206,123,81,239,124,111,10, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8, + }; + // (2^256 - 1) / 2 modulo L + static const u8 half_ones[32] = { + 142,74,204,70,186,24,118,107,184,231,190,57,250,173,119,99, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7, + }; + + // All bits set form: 1 means 1, 0 means -1 + u8 s_scalar[32]; + crypto_eddsa_mul_add(s_scalar, scalar, half_mod_L, half_ones); + + // Double and add ladder + fe tmp_a, tmp_b; // temporaries for addition + ge_precomp tmp_c; // temporary for comb lookup + ge tmp_d; // temporary for doubling + fe_1(tmp_c.Yp); + fe_1(tmp_c.Ym); + fe_0(tmp_c.T2); + + // Save a double on the first iteration + ge_zero(p); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_low , s_scalar, 31); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_high, s_scalar, 31+128); + // Regular double & add for the rest + for (int i = 30; i >= 0; i--) { + ge_double(p, p, &tmp_d); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_low , s_scalar, i); + lookup_add(p, &tmp_c, tmp_a, tmp_b, b_comb_high, s_scalar, i+128); + } + // Note: we could save one addition at the end if we assumed the + // scalar fit in 252 bits. Which it does in practice if it is + // selected at random. However, non-random, non-hashed scalars + // *can* overflow 252 bits in practice. Better account for that + // than leaving that kind of subtle corner case. + + WIPE_BUFFER(tmp_a); WIPE_CTX(&tmp_d); + WIPE_BUFFER(tmp_b); WIPE_CTX(&tmp_c); + WIPE_BUFFER(s_scalar); +} + +void crypto_eddsa_scalarbase(u8 point[32], const u8 scalar[32]) +{ + ge P; + ge_scalarmult_base(&P, scalar); + ge_tobytes(point, &P); + WIPE_CTX(&P); +} + +void crypto_eddsa_key_pair(u8 secret_key[64], u8 public_key[32], u8 seed[32]) +{ + // To allow overlaps, observable writes happen in this order: + // 1. seed + // 2. secret_key + // 3. public_key + u8 a[64]; + COPY(a, seed, 32); + crypto_wipe(seed, 32); + COPY(secret_key, a, 32); + crypto_blake2b(a, 64, a, 32); + crypto_eddsa_trim_scalar(a, a); + crypto_eddsa_scalarbase(secret_key + 32, a); + COPY(public_key, secret_key + 32, 32); + WIPE_BUFFER(a); +} + +static void hash_reduce(u8 h[32], + const u8 *a, size_t a_size, + const u8 *b, size_t b_size, + const u8 *c, size_t c_size) +{ + u8 hash[64]; + crypto_blake2b_ctx ctx; + crypto_blake2b_init (&ctx, 64); + crypto_blake2b_update(&ctx, a, a_size); + crypto_blake2b_update(&ctx, b, b_size); + crypto_blake2b_update(&ctx, c, c_size); + crypto_blake2b_final (&ctx, hash); + crypto_eddsa_reduce(h, hash); +} + +// Digital signature of a message with from a secret key. +// +// The secret key comprises two parts: +// - The seed that generates the key (secret_key[ 0..31]) +// - The public key (secret_key[32..63]) +// +// The seed and the public key are bundled together to make sure users +// don't use mismatched seeds and public keys, which would instantly +// leak the secret scalar and allow forgeries (allowing this to happen +// has resulted in critical vulnerabilities in the wild). +// +// The seed is hashed to derive the secret scalar and a secret prefix. +// The sole purpose of the prefix is to generate a secret random nonce. +// The properties of that nonce must be as follows: +// - Unique: we need a different one for each message. +// - Secret: third parties must not be able to predict it. +// - Random: any detectable bias would break all security. +// +// There are two ways to achieve these properties. The obvious one is +// to simply generate a random number. Here that would be a parameter +// (Monocypher doesn't have an RNG). It works, but then users may reuse +// the nonce by accident, which _also_ leaks the secret scalar and +// allows forgeries. This has happened in the wild too. +// +// This is no good, so instead we generate that nonce deterministically +// by reducing modulo L a hash of the secret prefix and the message. +// The secret prefix makes the nonce unpredictable, the message makes it +// unique, and the hash/reduce removes all bias. +// +// The cost of that safety is hashing the message twice. If that cost +// is unacceptable, there are two alternatives: +// +// - Signing a hash of the message instead of the message itself. This +// is fine as long as the hash is collision resistant. It is not +// compatible with existing "pure" signatures, but at least it's safe. +// +// - Using a random nonce. Please exercise **EXTREME CAUTION** if you +// ever do that. It is absolutely **critical** that the nonce is +// really an unbiased random number between 0 and L-1, never reused, +// and wiped immediately. +// +// To lower the likelihood of complete catastrophe if the RNG is +// either flawed or misused, you can hash the RNG output together with +// the secret prefix and the beginning of the message, and use the +// reduction of that hash instead of the RNG output itself. It's not +// foolproof (you'd need to hash the whole message) but it helps. +// +// Signing a message involves the following operations: +// +// scalar, prefix = HASH(secret_key) +// r = HASH(prefix || message) % L +// R = [r]B +// h = HASH(R || public_key || message) % L +// S = ((h * a) + r) % L +// signature = R || S +void crypto_eddsa_sign(u8 signature [64], const u8 secret_key[64], + const u8 *message, size_t message_size) +{ + u8 a[64]; // secret scalar and prefix + u8 r[32]; // secret deterministic "random" nonce + u8 h[32]; // publically verifiable hash of the message (not wiped) + u8 R[32]; // first half of the signature (allows overlapping inputs) + + crypto_blake2b(a, 64, secret_key, 32); + crypto_eddsa_trim_scalar(a, a); + hash_reduce(r, a + 32, 32, message, message_size, 0, 0); + crypto_eddsa_scalarbase(R, r); + hash_reduce(h, R, 32, secret_key + 32, 32, message, message_size); + COPY(signature, R, 32); + crypto_eddsa_mul_add(signature + 32, h, a, r); + + WIPE_BUFFER(a); + WIPE_BUFFER(r); +} + +// To check the signature R, S of the message M with the public key A, +// there are 3 steps: +// +// compute h = HASH(R || A || message) % L +// check that A is on the curve. +// check that R == [s]B - [h]A +// +// The last two steps are done in crypto_eddsa_check_equation() +int crypto_eddsa_check(const u8 signature[64], const u8 public_key[32], + const u8 *message, size_t message_size) +{ + u8 h[32]; + hash_reduce(h, signature, 32, public_key, 32, message, message_size); + return crypto_eddsa_check_equation(signature, public_key, h); +} + +///////////////////////// +/// EdDSA <--> X25519 /// +///////////////////////// +void crypto_eddsa_to_x25519(u8 x25519[32], const u8 eddsa[32]) +{ + // (u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x) + // Only converting y to u, the sign of x is ignored. + fe t1, t2; + fe_frombytes(t2, eddsa); + fe_add(t1, fe_one, t2); + fe_sub(t2, fe_one, t2); + fe_invert(t2, t2); + fe_mul(t1, t1, t2); + fe_tobytes(x25519, t1); + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); +} + +void crypto_x25519_to_eddsa(u8 eddsa[32], const u8 x25519[32]) +{ + // (x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1)) + // Only converting u to y, x is assumed positive. + fe t1, t2; + fe_frombytes(t2, x25519); + fe_sub(t1, t2, fe_one); + fe_add(t2, t2, fe_one); + fe_invert(t2, t2); + fe_mul(t1, t1, t2); + fe_tobytes(eddsa, t1); + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); +} + +///////////////////////////////////////////// +/// Dirty ephemeral public key generation /// +///////////////////////////////////////////// + +// Those functions generates a public key, *without* clearing the +// cofactor. Sending that key over the network leaks 3 bits of the +// private key. Use only to generate ephemeral keys that will be hidden +// with crypto_curve_to_hidden(). +// +// The public key is otherwise compatible with crypto_x25519(), which +// properly clears the cofactor. +// +// Note that the distribution of the resulting public keys is almost +// uniform. Flipping the sign of the v coordinate (not provided by this +// function), covers the entire key space almost perfectly, where +// "almost" means a 2^-128 bias (undetectable). This uniformity is +// needed to ensure the proper randomness of the resulting +// representatives (once we apply crypto_curve_to_hidden()). +// +// Recall that Curve25519 has order C = 2^255 + e, with e < 2^128 (not +// to be confused with the prime order of the main subgroup, L, which is +// 8 times less than that). +// +// Generating all points would require us to multiply a point of order C +// (the base point plus any point of order 8) by all scalars from 0 to +// C-1. Clamping limits us to scalars between 2^254 and 2^255 - 1. But +// by negating the resulting point at random, we also cover scalars from +// -2^255 + 1 to -2^254 (which modulo C is congruent to e+1 to 2^254 + e). +// +// In practice: +// - Scalars from 0 to e + 1 are never generated +// - Scalars from 2^255 to 2^255 + e are never generated +// - Scalars from 2^254 + 1 to 2^254 + e are generated twice +// +// Since e < 2^128, detecting this bias requires observing over 2^100 +// representatives from a given source (this will never happen), *and* +// recovering enough of the private key to determine that they do, or do +// not, belong to the biased set (this practically requires solving +// discrete logarithm, which is conjecturally intractable). +// +// In practice, this means the bias is impossible to detect. + +// s + (x*L) % 8*L +// Guaranteed to fit in 256 bits iff s fits in 255 bits. +// L < 2^253 +// x%8 < 2^3 +// L * (x%8) < 2^255 +// s < 2^255 +// s + L * (x%8) < 2^256 +static void add_xl(u8 s[32], u8 x) +{ + u64 mod8 = x & 7; + u64 carry = 0; + FOR (i , 0, 8) { + carry = carry + load32_le(s + 4*i) + L[i] * mod8; + store32_le(s + 4*i, (u32)carry); + carry >>= 32; + } +} + +// "Small" dirty ephemeral key. +// Use if you need to shrink the size of the binary, and can afford to +// slow down by a factor of two (compared to the fast version) +// +// This version works by decoupling the cofactor from the main factor. +// +// - The trimmed scalar determines the main factor +// - The clamped bits of the scalar determine the cofactor. +// +// Cofactor and main factor are combined into a single scalar, which is +// then multiplied by a point of order 8*L (unlike the base point, which +// has prime order). That "dirty" base point is the addition of the +// regular base point (9), and a point of order 8. +void crypto_x25519_dirty_small(u8 public_key[32], const u8 secret_key[32]) +{ + // Base point of order 8*L + // Raw scalar multiplication with it does not clear the cofactor, + // and the resulting public key will reveal 3 bits of the scalar. + // + // The low order component of this base point has been chosen + // to yield the same results as crypto_x25519_dirty_fast(). + static const u8 dirty_base_point[32] = { + 0xd8, 0x86, 0x1a, 0xa2, 0x78, 0x7a, 0xd9, 0x26, + 0x8b, 0x74, 0x74, 0xb6, 0x82, 0xe3, 0xbe, 0xc3, + 0xce, 0x36, 0x9a, 0x1e, 0x5e, 0x31, 0x47, 0xa2, + 0x6d, 0x37, 0x7c, 0xfd, 0x20, 0xb5, 0xdf, 0x75, + }; + // separate the main factor & the cofactor of the scalar + u8 scalar[32]; + crypto_eddsa_trim_scalar(scalar, secret_key); + + // Separate the main factor and the cofactor + // + // The scalar is trimmed, so its cofactor is cleared. The three + // least significant bits however still have a main factor. We must + // remove it for X25519 compatibility. + // + // cofactor = lsb * L (modulo 8*L) + // combined = scalar + cofactor (modulo 8*L) + add_xl(scalar, secret_key[0]); + scalarmult(public_key, scalar, dirty_base_point, 256); + WIPE_BUFFER(scalar); +} + +// Select low order point +// We're computing the [cofactor]lop scalar multiplication, where: +// +// cofactor = tweak & 7. +// lop = (lop_x, lop_y) +// lop_x = sqrt((sqrt(d + 1) + 1) / d) +// lop_y = -lop_x * sqrtm1 +// +// The low order point has order 8. There are 4 such points. We've +// chosen the one whose both coordinates are positive (below p/2). +// The 8 low order points are as follows: +// +// [0]lop = ( 0 , 1 ) +// [1]lop = ( lop_x , lop_y) +// [2]lop = ( sqrt(-1), -0 ) +// [3]lop = ( lop_x , -lop_y) +// [4]lop = (-0 , -1 ) +// [5]lop = (-lop_x , -lop_y) +// [6]lop = (-sqrt(-1), 0 ) +// [7]lop = (-lop_x , lop_y) +// +// The x coordinate is either 0, sqrt(-1), lop_x, or their opposite. +// The y coordinate is either 0, -1 , lop_y, or their opposite. +// The pattern for both is the same, except for a rotation of 2 (modulo 8) +// +// This helper function captures the pattern, and we can use it thus: +// +// select_lop(x, lop_x, sqrtm1, cofactor); +// select_lop(y, lop_y, fe_one, cofactor + 2); +// +// This is faster than an actual scalar multiplication, +// and requires less code than naive constant time look up. +static void select_lop(fe out, const fe x, const fe k, u8 cofactor) +{ + fe tmp; + fe_0(out); + fe_ccopy(out, k , (cofactor >> 1) & 1); // bit 1 + fe_ccopy(out, x , (cofactor >> 0) & 1); // bit 0 + fe_neg (tmp, out); + fe_ccopy(out, tmp, (cofactor >> 2) & 1); // bit 2 + WIPE_BUFFER(tmp); +} + +// "Fast" dirty ephemeral key +// We use this one by default. +// +// This version works by performing a regular scalar multiplication, +// then add a low order point. The scalar multiplication is done in +// Edwards space for more speed (*2 compared to the "small" version). +// The cost is a bigger binary for programs that don't also sign messages. +void crypto_x25519_dirty_fast(u8 public_key[32], const u8 secret_key[32]) +{ + // Compute clean scalar multiplication + u8 scalar[32]; + ge pk; + crypto_eddsa_trim_scalar(scalar, secret_key); + ge_scalarmult_base(&pk, scalar); + + // Compute low order point + fe t1, t2; + select_lop(t1, lop_x, sqrtm1, secret_key[0]); + select_lop(t2, lop_y, fe_one, secret_key[0] + 2); + ge_precomp low_order_point; + fe_add(low_order_point.Yp, t2, t1); + fe_sub(low_order_point.Ym, t2, t1); + fe_mul(low_order_point.T2, t2, t1); + fe_mul(low_order_point.T2, low_order_point.T2, D2); + + // Add low order point to the public key + ge_madd(&pk, &pk, &low_order_point, t1, t2); + + // Convert to Montgomery u coordinate (we ignore the sign) + fe_add(t1, pk.Z, pk.Y); + fe_sub(t2, pk.Z, pk.Y); + fe_invert(t2, t2); + fe_mul(t1, t1, t2); + + fe_tobytes(public_key, t1); + + WIPE_BUFFER(t1); WIPE_CTX(&pk); + WIPE_BUFFER(t2); WIPE_CTX(&low_order_point); + WIPE_BUFFER(scalar); +} + +/////////////////// +/// Elligator 2 /// +/////////////////// +static const fe A = {486662}; + +// Elligator direct map +// +// Computes the point corresponding to a representative, encoded in 32 +// bytes (little Endian). Since positive representatives fits in 254 +// bits, The two most significant bits are ignored. +// +// From the paper: +// w = -A / (fe(1) + non_square * r^2) +// e = chi(w^3 + A*w^2 + w) +// u = e*w - (fe(1)-e)*(A//2) +// v = -e * sqrt(u^3 + A*u^2 + u) +// +// We ignore v because we don't need it for X25519 (the Montgomery +// ladder only uses u). +// +// Note that e is either 0, 1 or -1 +// if e = 0 u = 0 and v = 0 +// if e = 1 u = w +// if e = -1 u = -w - A = w * non_square * r^2 +// +// Let r1 = non_square * r^2 +// Let r2 = 1 + r1 +// Note that r2 cannot be zero, -1/non_square is not a square. +// We can (tediously) verify that: +// w^3 + A*w^2 + w = (A^2*r1 - r2^2) * A / r2^3 +// Therefore: +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3)) +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3)) * 1 +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3)) * chi(r2^6) +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * (A / r2^3) * r2^6) +// chi(w^3 + A*w^2 + w) = chi((A^2*r1 - r2^2) * A * r2^3) +// Corollary: +// e = 1 if (A^2*r1 - r2^2) * A * r2^3) is a non-zero square +// e = -1 if (A^2*r1 - r2^2) * A * r2^3) is not a square +// Note that w^3 + A*w^2 + w (and therefore e) can never be zero: +// w^3 + A*w^2 + w = w * (w^2 + A*w + 1) +// w^3 + A*w^2 + w = w * (w^2 + A*w + A^2/4 - A^2/4 + 1) +// w^3 + A*w^2 + w = w * (w + A/2)^2 - A^2/4 + 1) +// which is zero only if: +// w = 0 (impossible) +// (w + A/2)^2 = A^2/4 - 1 (impossible, because A^2/4-1 is not a square) +// +// Let isr = invsqrt((A^2*r1 - r2^2) * A * r2^3) +// isr = sqrt(1 / ((A^2*r1 - r2^2) * A * r2^3)) if e = 1 +// isr = sqrt(sqrt(-1) / ((A^2*r1 - r2^2) * A * r2^3)) if e = -1 +// +// if e = 1 +// let u1 = -A * (A^2*r1 - r2^2) * A * r2^2 * isr^2 +// u1 = w +// u1 = u +// +// if e = -1 +// let ufactor = -non_square * sqrt(-1) * r^2 +// let vfactor = sqrt(ufactor) +// let u2 = -A * (A^2*r1 - r2^2) * A * r2^2 * isr^2 * ufactor +// u2 = w * -1 * -non_square * r^2 +// u2 = w * non_square * r^2 +// u2 = u +void crypto_elligator_map(u8 curve[32], const u8 hidden[32]) +{ + fe r, u, t1, t2, t3; + fe_frombytes_mask(r, hidden, 2); // r is encoded in 254 bits. + fe_sq(r, r); + fe_add(t1, r, r); + fe_add(u, t1, fe_one); + fe_sq (t2, u); + fe_mul(t3, A2, t1); + fe_sub(t3, t3, t2); + fe_mul(t3, t3, A); + fe_mul(t1, t2, u); + fe_mul(t1, t3, t1); + int is_square = invsqrt(t1, t1); + fe_mul(u, r, ufactor); + fe_ccopy(u, fe_one, is_square); + fe_sq (t1, t1); + fe_mul(u, u, A); + fe_mul(u, u, t3); + fe_mul(u, u, t2); + fe_mul(u, u, t1); + fe_neg(u, u); + fe_tobytes(curve, u); + + WIPE_BUFFER(t1); WIPE_BUFFER(r); + WIPE_BUFFER(t2); WIPE_BUFFER(u); + WIPE_BUFFER(t3); +} + +// Elligator inverse map +// +// Computes the representative of a point, if possible. If not, it does +// nothing and returns -1. Note that the success of the operation +// depends only on the point (more precisely its u coordinate). The +// tweak parameter is used only upon success +// +// The tweak should be a random byte. Beyond that, its contents are an +// implementation detail. Currently, the tweak comprises: +// - Bit 1 : sign of the v coordinate (0 if positive, 1 if negative) +// - Bit 2-5: not used +// - Bits 6-7: random padding +// +// From the paper: +// Let sq = -non_square * u * (u+A) +// if sq is not a square, or u = -A, there is no mapping +// Assuming there is a mapping: +// if v is positive: r = sqrt(-u / (non_square * (u+A))) +// if v is negative: r = sqrt(-(u+A) / (non_square * u )) +// +// We compute isr = invsqrt(-non_square * u * (u+A)) +// if it wasn't a square, abort. +// else, isr = sqrt(-1 / (non_square * u * (u+A)) +// +// If v is positive, we return isr * u: +// isr * u = sqrt(-1 / (non_square * u * (u+A)) * u +// isr * u = sqrt(-u / (non_square * (u+A)) +// +// If v is negative, we return isr * (u+A): +// isr * (u+A) = sqrt(-1 / (non_square * u * (u+A)) * (u+A) +// isr * (u+A) = sqrt(-(u+A) / (non_square * u) +int crypto_elligator_rev(u8 hidden[32], const u8 public_key[32], u8 tweak) +{ + fe t1, t2, t3; + fe_frombytes(t1, public_key); // t1 = u + + fe_add(t2, t1, A); // t2 = u + A + fe_mul(t3, t1, t2); + fe_mul_small(t3, t3, -2); + int is_square = invsqrt(t3, t3); // t3 = sqrt(-1 / non_square * u * (u+A)) + if (is_square) { + // The only variable time bit. This ultimately reveals how many + // tries it took us to find a representable key. + // This does not affect security as long as we try keys at random. + + fe_ccopy (t1, t2, tweak & 1); // multiply by u if v is positive, + fe_mul (t3, t1, t3); // multiply by u+A otherwise + fe_mul_small(t1, t3, 2); + fe_neg (t2, t3); + fe_ccopy (t3, t2, fe_isodd(t1)); + fe_tobytes(hidden, t3); + + // Pad with two random bits + hidden[31] |= tweak & 0xc0; + } + + WIPE_BUFFER(t1); + WIPE_BUFFER(t2); + WIPE_BUFFER(t3); + return is_square - 1; +} + +void crypto_elligator_key_pair(u8 hidden[32], u8 secret_key[32], u8 seed[32]) +{ + u8 pk [32]; // public key + u8 buf[64]; // seed + representative + COPY(buf + 32, seed, 32); + do { + crypto_chacha20_djb(buf, 0, 64, buf+32, zero, 0); + crypto_x25519_dirty_fast(pk, buf); // or the "small" version + } while(crypto_elligator_rev(buf+32, pk, buf[32])); + // Note that the return value of crypto_elligator_rev() is + // independent from its tweak parameter. + // Therefore, buf[32] is not actually reused. Either we loop one + // more time and buf[32] is used for the new seed, or we succeeded, + // and buf[32] becomes the tweak parameter. + + crypto_wipe(seed, 32); + COPY(hidden , buf + 32, 32); + COPY(secret_key, buf , 32); + WIPE_BUFFER(buf); + WIPE_BUFFER(pk); +} + +/////////////////////// +/// Scalar division /// +/////////////////////// + +// Montgomery reduction. +// Divides x by (2^256), and reduces the result modulo L +// +// Precondition: +// x < L * 2^256 +// Constants: +// r = 2^256 (makes division by r trivial) +// k = (r * (1/r) - 1) // L (1/r is computed modulo L ) +// Algorithm: +// s = (x * k) % r +// t = x + s*L (t is always a multiple of r) +// u = (t/r) % L (u is always below 2*L, conditional subtraction is enough) +static void redc(u32 u[8], u32 x[16]) +{ + static const u32 k[8] = { + 0x12547e1b, 0xd2b51da3, 0xfdba84ff, 0xb1a206f2, + 0xffa36bea, 0x14e75438, 0x6fe91836, 0x9db6c6f2, + }; + + // s = x * k (modulo 2^256) + // This is cheaper than the full multiplication. + u32 s[8] = {0}; + FOR (i, 0, 8) { + u64 carry = 0; + FOR (j, 0, 8-i) { + carry += s[i+j] + (u64)x[i] * k[j]; + s[i+j] = (u32)carry; + carry >>= 32; + } + } + u32 t[16] = {0}; + multiply(t, s, L); + + // t = t + x + u64 carry = 0; + FOR (i, 0, 16) { + carry += (u64)t[i] + x[i]; + t[i] = (u32)carry; + carry >>= 32; + } + + // u = (t / 2^256) % L + // Note that t / 2^256 is always below 2*L, + // So a constant time conditional subtraction is enough + remove_l(u, t+8); + + WIPE_BUFFER(s); + WIPE_BUFFER(t); +} + +void crypto_x25519_inverse(u8 blind_salt [32], const u8 private_key[32], + const u8 curve_point[32]) +{ + static const u8 Lm2[32] = { // L - 2 + 0xeb, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, + 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + }; + // 1 in Montgomery form + u32 m_inv [8] = { + 0x8d98951d, 0xd6ec3174, 0x737dcf70, 0xc6ef5bf4, + 0xfffffffe, 0xffffffff, 0xffffffff, 0x0fffffff, + }; + + u8 scalar[32]; + crypto_eddsa_trim_scalar(scalar, private_key); + + // Convert the scalar in Montgomery form + // m_scl = scalar * 2^256 (modulo L) + u32 m_scl[8]; + { + u32 tmp[16]; + ZERO(tmp, 8); + load32_le_buf(tmp+8, scalar, 8); + mod_l(scalar, tmp); + load32_le_buf(m_scl, scalar, 8); + WIPE_BUFFER(tmp); // Wipe ASAP to save stack space + } + + // Compute the inverse + u32 product[16]; + for (int i = 252; i >= 0; i--) { + ZERO(product, 16); + multiply(product, m_inv, m_inv); + redc(m_inv, product); + if (scalar_bit(Lm2, i)) { + ZERO(product, 16); + multiply(product, m_inv, m_scl); + redc(m_inv, product); + } + } + // Convert the inverse *out* of Montgomery form + // scalar = m_inv / 2^256 (modulo L) + COPY(product, m_inv, 8); + ZERO(product + 8, 8); + redc(m_inv, product); + store32_le_buf(scalar, m_inv, 8); // the *inverse* of the scalar + + // Clear the cofactor of scalar: + // cleared = scalar * (3*L + 1) (modulo 8*L) + // cleared = scalar + scalar * 3 * L (modulo 8*L) + // Note that (scalar * 3) is reduced modulo 8, so we only need the + // first byte. + add_xl(scalar, scalar[0] * 3); + + // Recall that 8*L < 2^256. However it is also very close to + // 2^255. If we spanned the ladder over 255 bits, random tests + // wouldn't catch the off-by-one error. + scalarmult(blind_salt, scalar, curve_point, 256); + + WIPE_BUFFER(scalar); WIPE_BUFFER(m_scl); + WIPE_BUFFER(product); WIPE_BUFFER(m_inv); +} + +//////////////////////////////// +/// Authenticated encryption /// +//////////////////////////////// +static void lock_auth(u8 mac[16], const u8 auth_key[32], + const u8 *ad , size_t ad_size, + const u8 *cipher_text, size_t text_size) +{ + u8 sizes[16]; // Not secret, not wiped + store64_le(sizes + 0, ad_size); + store64_le(sizes + 8, text_size); + crypto_poly1305_ctx poly_ctx; // auto wiped... + crypto_poly1305_init (&poly_ctx, auth_key); + crypto_poly1305_update(&poly_ctx, ad , ad_size); + crypto_poly1305_update(&poly_ctx, zero , gap(ad_size, 16)); + crypto_poly1305_update(&poly_ctx, cipher_text, text_size); + crypto_poly1305_update(&poly_ctx, zero , gap(text_size, 16)); + crypto_poly1305_update(&poly_ctx, sizes , 16); + crypto_poly1305_final (&poly_ctx, mac); // ...here +} + +void crypto_aead_init_x(crypto_aead_ctx *ctx, + u8 const key[32], const u8 nonce[24]) +{ + crypto_chacha20_h(ctx->key, key, nonce); + COPY(ctx->nonce, nonce + 16, 8); + ctx->counter = 0; +} + +void crypto_aead_init_djb(crypto_aead_ctx *ctx, + const u8 key[32], const u8 nonce[8]) +{ + COPY(ctx->key , key , 32); + COPY(ctx->nonce, nonce, 8); + ctx->counter = 0; +} + +void crypto_aead_init_ietf(crypto_aead_ctx *ctx, + const u8 key[32], const u8 nonce[12]) +{ + COPY(ctx->key , key , 32); + COPY(ctx->nonce, nonce + 4, 8); + ctx->counter = (u64)load32_le(nonce) << 32; +} + +void crypto_aead_write(crypto_aead_ctx *ctx, u8 *cipher_text, u8 mac[16], + const u8 *ad, size_t ad_size, + const u8 *plain_text, size_t text_size) +{ + u8 auth_key[64]; // the last 32 bytes are used for rekeying. + crypto_chacha20_djb(auth_key, 0, 64, ctx->key, ctx->nonce, ctx->counter); + crypto_chacha20_djb(cipher_text, plain_text, text_size, + ctx->key, ctx->nonce, ctx->counter + 1); + lock_auth(mac, auth_key, ad, ad_size, cipher_text, text_size); + COPY(ctx->key, auth_key + 32, 32); + WIPE_BUFFER(auth_key); +} + +int crypto_aead_read(crypto_aead_ctx *ctx, u8 *plain_text, const u8 mac[16], + const u8 *ad, size_t ad_size, + const u8 *cipher_text, size_t text_size) +{ + u8 auth_key[64]; // the last 32 bytes are used for rekeying. + u8 real_mac[16]; + crypto_chacha20_djb(auth_key, 0, 64, ctx->key, ctx->nonce, ctx->counter); + lock_auth(real_mac, auth_key, ad, ad_size, cipher_text, text_size); + int mismatch = crypto_verify16(mac, real_mac); + if (!mismatch) { + crypto_chacha20_djb(plain_text, cipher_text, text_size, + ctx->key, ctx->nonce, ctx->counter + 1); + COPY(ctx->key, auth_key + 32, 32); + } + WIPE_BUFFER(auth_key); + WIPE_BUFFER(real_mac); + return mismatch; +} + +void crypto_aead_lock(u8 *cipher_text, u8 mac[16], const u8 key[32], + const u8 nonce[24], const u8 *ad, size_t ad_size, + const u8 *plain_text, size_t text_size) +{ + crypto_aead_ctx ctx; + crypto_aead_init_x(&ctx, key, nonce); + crypto_aead_write(&ctx, cipher_text, mac, ad, ad_size, + plain_text, text_size); + crypto_wipe(&ctx, sizeof(ctx)); +} + +int crypto_aead_unlock(u8 *plain_text, const u8 mac[16], const u8 key[32], + const u8 nonce[24], const u8 *ad, size_t ad_size, + const u8 *cipher_text, size_t text_size) +{ + crypto_aead_ctx ctx; + crypto_aead_init_x(&ctx, key, nonce); + int mismatch = crypto_aead_read(&ctx, plain_text, mac, ad, ad_size, + cipher_text, text_size); + crypto_wipe(&ctx, sizeof(ctx)); + return mismatch; +} + +#ifdef MONOCYPHER_CPP_NAMESPACE +} +#endif diff --git a/3rdparty/monocypher/monocypher.h b/3rdparty/monocypher/monocypher.h new file mode 100644 index 0000000..765a07f --- /dev/null +++ b/3rdparty/monocypher/monocypher.h @@ -0,0 +1,321 @@ +// Monocypher version 4.0.2 +// +// This file is dual-licensed. Choose whichever licence you want from +// the two licences listed below. +// +// The first licence is a regular 2-clause BSD licence. The second licence +// is the CC-0 from Creative Commons. It is intended to release Monocypher +// to the public domain. The BSD licence serves as a fallback option. +// +// SPDX-License-Identifier: BSD-2-Clause OR CC0-1.0 +// +// ------------------------------------------------------------------------ +// +// Copyright (c) 2017-2019, Loup Vaillant +// All rights reserved. +// +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// ------------------------------------------------------------------------ +// +// Written in 2017-2019 by Loup Vaillant +// +// To the extent possible under law, the author(s) have dedicated all copyright +// and related neighboring rights to this software to the public domain +// worldwide. This software is distributed without any warranty. +// +// You should have received a copy of the CC0 Public Domain Dedication along +// with this software. If not, see +// + +#ifndef MONOCYPHER_H +#define MONOCYPHER_H + +#include +#include + +#ifdef MONOCYPHER_CPP_NAMESPACE +namespace MONOCYPHER_CPP_NAMESPACE { +#elif defined(__cplusplus) +extern "C" { +#endif + +// Constant time comparisons +// ------------------------- + +// Return 0 if a and b are equal, -1 otherwise +int crypto_verify16(const uint8_t a[16], const uint8_t b[16]); +int crypto_verify32(const uint8_t a[32], const uint8_t b[32]); +int crypto_verify64(const uint8_t a[64], const uint8_t b[64]); + + +// Erase sensitive data +// -------------------- +void crypto_wipe(void *secret, size_t size); + + +// Authenticated encryption +// ------------------------ +void crypto_aead_lock(uint8_t *cipher_text, + uint8_t mac [16], + const uint8_t key [32], + const uint8_t nonce[24], + const uint8_t *ad, size_t ad_size, + const uint8_t *plain_text, size_t text_size); +int crypto_aead_unlock(uint8_t *plain_text, + const uint8_t mac [16], + const uint8_t key [32], + const uint8_t nonce[24], + const uint8_t *ad, size_t ad_size, + const uint8_t *cipher_text, size_t text_size); + +// Authenticated stream +// -------------------- +typedef struct { + uint64_t counter; + uint8_t key[32]; + uint8_t nonce[8]; +} crypto_aead_ctx; + +void crypto_aead_init_x(crypto_aead_ctx *ctx, + const uint8_t key[32], const uint8_t nonce[24]); +void crypto_aead_init_djb(crypto_aead_ctx *ctx, + const uint8_t key[32], const uint8_t nonce[8]); +void crypto_aead_init_ietf(crypto_aead_ctx *ctx, + const uint8_t key[32], const uint8_t nonce[12]); + +void crypto_aead_write(crypto_aead_ctx *ctx, + uint8_t *cipher_text, + uint8_t mac[16], + const uint8_t *ad , size_t ad_size, + const uint8_t *plain_text, size_t text_size); +int crypto_aead_read(crypto_aead_ctx *ctx, + uint8_t *plain_text, + const uint8_t mac[16], + const uint8_t *ad , size_t ad_size, + const uint8_t *cipher_text, size_t text_size); + + +// General purpose hash (BLAKE2b) +// ------------------------------ + +// Direct interface +void crypto_blake2b(uint8_t *hash, size_t hash_size, + const uint8_t *message, size_t message_size); + +void crypto_blake2b_keyed(uint8_t *hash, size_t hash_size, + const uint8_t *key, size_t key_size, + const uint8_t *message, size_t message_size); + +// Incremental interface +typedef struct { + // Do not rely on the size or contents of this type, + // for they may change without notice. + uint64_t hash[8]; + uint64_t input_offset[2]; + uint64_t input[16]; + size_t input_idx; + size_t hash_size; +} crypto_blake2b_ctx; + +void crypto_blake2b_init(crypto_blake2b_ctx *ctx, size_t hash_size); +void crypto_blake2b_keyed_init(crypto_blake2b_ctx *ctx, size_t hash_size, + const uint8_t *key, size_t key_size); +void crypto_blake2b_update(crypto_blake2b_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_blake2b_final(crypto_blake2b_ctx *ctx, uint8_t *hash); + + +// Password key derivation (Argon2) +// -------------------------------- +#define CRYPTO_ARGON2_D 0 +#define CRYPTO_ARGON2_I 1 +#define CRYPTO_ARGON2_ID 2 + +typedef struct { + uint32_t algorithm; // Argon2d, Argon2i, Argon2id + uint32_t nb_blocks; // memory hardness, >= 8 * nb_lanes + uint32_t nb_passes; // CPU hardness, >= 1 (>= 3 recommended for Argon2i) + uint32_t nb_lanes; // parallelism level (single threaded anyway) +} crypto_argon2_config; + +typedef struct { + const uint8_t *pass; + const uint8_t *salt; + uint32_t pass_size; + uint32_t salt_size; // 16 bytes recommended +} crypto_argon2_inputs; + +typedef struct { + const uint8_t *key; // may be NULL if no key + const uint8_t *ad; // may be NULL if no additional data + uint32_t key_size; // 0 if no key (32 bytes recommended otherwise) + uint32_t ad_size; // 0 if no additional data +} crypto_argon2_extras; + +extern const crypto_argon2_extras crypto_argon2_no_extras; + +void crypto_argon2(uint8_t *hash, uint32_t hash_size, void *work_area, + crypto_argon2_config config, + crypto_argon2_inputs inputs, + crypto_argon2_extras extras); + + +// Key exchange (X-25519) +// ---------------------- + +// Shared secrets are not quite random. +// Hash them to derive an actual shared key. +void crypto_x25519_public_key(uint8_t public_key[32], + const uint8_t secret_key[32]); +void crypto_x25519(uint8_t raw_shared_secret[32], + const uint8_t your_secret_key [32], + const uint8_t their_public_key [32]); + +// Conversion to EdDSA +void crypto_x25519_to_eddsa(uint8_t eddsa[32], const uint8_t x25519[32]); + +// scalar "division" +// Used for OPRF. Be aware that exponential blinding is less secure +// than Diffie-Hellman key exchange. +void crypto_x25519_inverse(uint8_t blind_salt [32], + const uint8_t private_key[32], + const uint8_t curve_point[32]); + +// "Dirty" versions of x25519_public_key(). +// Use with crypto_elligator_rev(). +// Leaks 3 bits of the private key. +void crypto_x25519_dirty_small(uint8_t pk[32], const uint8_t sk[32]); +void crypto_x25519_dirty_fast (uint8_t pk[32], const uint8_t sk[32]); + + +// Signatures +// ---------- + +// EdDSA with curve25519 + BLAKE2b +void crypto_eddsa_key_pair(uint8_t secret_key[64], + uint8_t public_key[32], + uint8_t seed[32]); +void crypto_eddsa_sign(uint8_t signature [64], + const uint8_t secret_key[64], + const uint8_t *message, size_t message_size); +int crypto_eddsa_check(const uint8_t signature [64], + const uint8_t public_key[32], + const uint8_t *message, size_t message_size); + +// Conversion to X25519 +void crypto_eddsa_to_x25519(uint8_t x25519[32], const uint8_t eddsa[32]); + +// EdDSA building blocks +void crypto_eddsa_trim_scalar(uint8_t out[32], const uint8_t in[32]); +void crypto_eddsa_reduce(uint8_t reduced[32], const uint8_t expanded[64]); +void crypto_eddsa_mul_add(uint8_t r[32], + const uint8_t a[32], + const uint8_t b[32], + const uint8_t c[32]); +void crypto_eddsa_scalarbase(uint8_t point[32], const uint8_t scalar[32]); +int crypto_eddsa_check_equation(const uint8_t signature[64], + const uint8_t public_key[32], + const uint8_t h_ram[32]); + + +// Chacha20 +// -------- + +// Specialised hash. +// Used to hash X25519 shared secrets. +void crypto_chacha20_h(uint8_t out[32], + const uint8_t key[32], + const uint8_t in [16]); + +// Unauthenticated stream cipher. +// Don't forget to add authentication. +uint64_t crypto_chacha20_djb(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[8], + uint64_t ctr); +uint32_t crypto_chacha20_ietf(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[12], + uint32_t ctr); +uint64_t crypto_chacha20_x(uint8_t *cipher_text, + const uint8_t *plain_text, + size_t text_size, + const uint8_t key[32], + const uint8_t nonce[24], + uint64_t ctr); + + +// Poly 1305 +// --------- + +// This is a *one time* authenticator. +// Disclosing the mac reveals the key. +// See crypto_lock() on how to use it properly. + +// Direct interface +void crypto_poly1305(uint8_t mac[16], + const uint8_t *message, size_t message_size, + const uint8_t key[32]); + +// Incremental interface +typedef struct { + // Do not rely on the size or contents of this type, + // for they may change without notice. + uint8_t c[16]; // chunk of the message + size_t c_idx; // How many bytes are there in the chunk. + uint32_t r [4]; // constant multiplier (from the secret key) + uint32_t pad[4]; // random number added at the end (from the secret key) + uint32_t h [5]; // accumulated hash +} crypto_poly1305_ctx; + +void crypto_poly1305_init (crypto_poly1305_ctx *ctx, const uint8_t key[32]); +void crypto_poly1305_update(crypto_poly1305_ctx *ctx, + const uint8_t *message, size_t message_size); +void crypto_poly1305_final (crypto_poly1305_ctx *ctx, uint8_t mac[16]); + + +// Elligator 2 +// ----------- + +// Elligator mappings proper +void crypto_elligator_map(uint8_t curve [32], const uint8_t hidden[32]); +int crypto_elligator_rev(uint8_t hidden[32], const uint8_t curve [32], + uint8_t tweak); + +// Easy to use key pair generation +void crypto_elligator_key_pair(uint8_t hidden[32], uint8_t secret_key[32], + uint8_t seed[32]); + +#ifdef __cplusplus +} +#endif + +#endif // MONOCYPHER_H diff --git a/CMakeLists.txt b/CMakeLists.txt index 57c4207..b0038ba 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -155,6 +155,7 @@ include(cmake/Dependencies.cmake) add_subdirectory(core/anslicensing) add_subdirectory(core/ANSLicensingSystem) add_subdirectory(core/ANSLibsLoader) +add_subdirectory(core/ANSModelPackage) # Modules — feature DLLs (cross-platform) add_subdirectory(modules/ANSMOT) diff --git a/core/ANSModelPackage/ANSAead.h b/core/ANSModelPackage/ANSAead.h new file mode 100644 index 0000000..67bdd39 --- /dev/null +++ b/core/ANSModelPackage/ANSAead.h @@ -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 +#include +#include +#include +#include + +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(kSigma)); + s[1] = load32(reinterpret_cast(kSigma) + 4); + s[2] = load32(reinterpret_cast(kSigma) + 8); + s[3] = load32(reinterpret_cast(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 seal(const std::array& key, + const std::array& nonce, + const std::string& aad, + const std::vector& plain) { + std::vector out(plain.size() + kTagBytes); + aeadSeal(key.data(), nonce.data(), + reinterpret_cast(aad.data()), aad.size(), + plain.data(), plain.size(), out.data(), out.data() + plain.size()); + return out; +} + +inline bool open(const std::array& key, + const std::array& nonce, + const std::string& aad, const std::vector& sealed, + std::vector& 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(aad.data()), aad.size(), + sealed.data(), n, sealed.data() + n, plain.data()); +} + +} // namespace aead +} // namespace ANSCENTER + +#endif // ANSAEAD_H diff --git a/core/ANSModelPackage/ANSModelPackage.h b/core/ANSModelPackage/ANSModelPackage.h new file mode 100644 index 0000000..4435451 --- /dev/null +++ b/core/ANSModelPackage/ANSModelPackage.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/., 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#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; + +// 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 keys; // symmetric base keys (legacy wrap) + std::map x25519; // base PRIVATE keys, by id + std::map roots; // root PUBLIC keys, by id + std::vector 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 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 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& v) { + return bits::base64Encode(std::string(v.begin(), v.end())); +} +inline std::vector unb64(const std::string& s) { + std::vector 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 chunkNonce( + const std::array& base, uint64_t index) { + std::array 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(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::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(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(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(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 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 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 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 sealed(static_cast(mlen), 0); + f.seekg(std::streamoff(moff)); + f.read(reinterpret_cast(sealed.data()), std::streamsize(mlen)); + if (f.gcount() != std::streamsize(mlen)) { + err = "truncated: the manifest is not all there"; + return false; + } + std::array mbase{}; + std::memcpy(mbase.data(), mnb.data(), 4); + std::vector 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& 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 sealed; + std::vector 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(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 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 signerSecret; // 64 bytes, RFC 8032 + std::vector signerPublic; // 32 bytes + std::string rootKeyId; + std::vector rootSig; // 64 bytes over the certificate + std::string notAfter; // ISO-8601, may be empty + Json manifest; + Json card; // optional, counts only + std::vector 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& plain, + const std::string& payloadId, + const std::array& 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(req.chunk, plain.size() - from); + std::vector 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(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 manifestBytes(manifestText.begin(), + manifestText.end()); + std::array 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(sealed.data()), + sealed.size()); + } + + std::vector blobs; + std::vector> bases; + for (size_t i = 0; i < req.models.size(); ++i) { + std::array 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 wrapNonce{}; + for (size_t i = 0; i < wrapNonce.size(); ++i) + wrapNonce[i] = uint8_t(req.nonceSeed + 100 + i); + const std::vector keyPlain(contentKey.begin(), contentKey.end()); + + Key wrapKey = req.key; + std::vector 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(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( + 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(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 value(64, 0); + crypto_ed25519_sign(value.data(), req.signerSecret.data(), + reinterpret_cast(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 diff --git a/core/ANSModelPackage/ANSPackageBits.h b/core/ANSModelPackage/ANSPackageBits.h new file mode 100644 index 0000000..e5211e1 --- /dev/null +++ b/core/ANSModelPackage/ANSPackageBits.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 +#include +#include +#include +#include + +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 +#include +#include +#include + +// ── 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(s.data()), s.size()); +} +template +inline std::string base64Encode(const std::array& 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& 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 +#include +#include +#include + +// ── 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(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; + +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(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(key.data()), key.size(), + reinterpret_cast(msg.data()), msg.size()); +} +inline Digest256 hmacSha256(const Digest256& key, const std::string& msg) { + return hmacSha256(key.data(), key.size(), + reinterpret_cast(msg.data()), msg.size()); +} + + + +} // namespace bits +} // namespace ANSCENTER + +#endif // ANSPACKAGEBITS_H diff --git a/core/ANSModelPackage/CMakeLists.txt b/core/ANSModelPackage/CMakeLists.txt new file mode 100644 index 0000000..7ee0c6a --- /dev/null +++ b/core/ANSModelPackage/CMakeLists.txt @@ -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) diff --git a/tests/ANSModelPackage-UnitTest/ANSModelPackage-UnitTest.cpp b/tests/ANSModelPackage-UnitTest/ANSModelPackage-UnitTest.cpp new file mode 100644 index 0000000..0a1580f --- /dev/null +++ b/tests/ANSModelPackage-UnitTest/ANSModelPackage-UnitTest.cpp @@ -0,0 +1,263 @@ +// ANSModelPackage-UnitTest — the model package format, and its agreement with +// the other implementation. +// +// Usage: ANSModelPackage-UnitTest [data-dir] +// +// The interop fixture in data/ was written by ANSMINDCORE's packer. Opening it +// here is what makes "the two products read the same format" a fact rather +// than an intention: a change to either implementation that alters the wire +// shows up as this test failing. + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ANSModelPackage.h" + +extern "C" { +#include "monocypher-ed25519.h" +#include "monocypher.h" +} + +namespace fs = std::filesystem; +using namespace ANSCENTER; +using modelpkg::Json; + +static int gChecks = 0, gFailures = 0; +static void CHECK(bool ok, const char* what) { + ++gChecks; + if (!ok) { + ++gFailures; + std::printf("FAIL %s\n", what); + } +} + +// The fixture's keys, by the rules its generator recorded (see data/README). +struct Identity { + modelpkg::Key basePriv{}, basePub{}; + std::vector rootSk = std::vector(64); + std::vector rootPk = std::vector(32); + std::vector signerSk = std::vector(64); + std::vector signerPk = std::vector(32); +}; + +static Identity fixtureIdentity() { + Identity id; + std::vector seedRoot(32), seedSigner(32); + for (size_t i = 0; i < 32; ++i) { + id.basePriv[i] = uint8_t(i * 3 + 9); + seedRoot[i] = uint8_t(i * 7 + 1); + seedSigner[i] = uint8_t(i * 11 + 5); + } + crypto_x25519_public_key(id.basePub.data(), id.basePriv.data()); + crypto_ed25519_key_pair(id.rootSk.data(), id.rootPk.data(), seedRoot.data()); + crypto_ed25519_key_pair(id.signerSk.data(), id.signerPk.data(), seedSigner.data()); + return id; +} + +static modelpkg::Keyring fixtureKeyring(const Identity& id) { + modelpkg::Keyring ring; + ring.addX25519("ansk-v1-base", id.basePriv); + modelpkg::Key rootPub{}; + std::memcpy(rootPub.data(), id.rootPk.data(), rootPub.size()); + ring.addRoot("ansroot-v1", rootPub); + ring.nowSec = 1788000000; // a fixed "now", so the fixture does not age + return ring; +} + +// ── the primitives, against their own published numbers ─────────────────── +static void testVectors() { + auto hex = [](const std::string& h) { + std::vector v; + for (size_t i = 0; i + 1 < h.size(); i += 2) + v.push_back(uint8_t(std::stoi(h.substr(i, 2), nullptr, 16))); + return v; + }; + const std::string text = + "Ladies and Gentlemen of the class of '99: If I could offer you only one " + "tip for the future, sunscreen would be it."; + const auto key = hex("808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f"); + const auto aad = hex("50515253c0c1c2c3c4c5c6c7"); + const auto nonce = hex("070000004041424344454647"); + const std::vector plain(text.begin(), text.end()); + std::vector ct(plain.size()); + uint8_t tag[16]; + aead::aeadSeal(key.data(), nonce.data(), aad.data(), aad.size(), plain.data(), + plain.size(), ct.data(), tag); + CHECK(std::memcmp(tag, hex("1ae10b594f09e26a7e902ecbd0600691").data(), 16) == 0, + "RFC 8439 §2.8.2: the AEAD tag is the published one"); + + const auto aSec = hex("77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a"); + const auto bSec = hex("5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb"); + std::vector aPub(32), bPub(32), s1(32), s2(32); + crypto_x25519_public_key(aPub.data(), aSec.data()); + crypto_x25519_public_key(bPub.data(), bSec.data()); + crypto_x25519(s1.data(), aSec.data(), bPub.data()); + crypto_x25519(s2.data(), bSec.data(), aPub.data()); + CHECK(s1 == hex("4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742") && + s1 == s2, + "RFC 7748: X25519 reaches the published shared secret"); + + auto seed = hex("4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb"); + const auto msg = hex("72"); + std::vector sk(64), pk(32), sig(64); + crypto_ed25519_key_pair(sk.data(), pk.data(), seed.data()); + crypto_ed25519_sign(sig.data(), sk.data(), msg.data(), msg.size()); + CHECK(sig == hex("92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da" + "085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00"), + "RFC 8032 test 2: the signature is the published one, so this is " + "SHA-512 Ed25519 rather than Monocypher's BLAKE2b EdDSA"); +} + +// ── the package ANSMINDCORE wrote ───────────────────────────────────────── +static void testInterop(const fs::path& dataDir) { + const std::string path = (dataDir / "interop.ansmodel").string(); + if (!fs::exists(path)) { + std::printf("SKIP interop: %s is not here\n", path.c_str()); + return; + } + const Identity id = fixtureIdentity(); + const modelpkg::Keyring ring = fixtureKeyring(id); + + modelpkg::Package pkg; + std::string err; + CHECK(modelpkg::open(path, ring, pkg, err), + ("a package written by ANSMINDCORE opens here: " + err).c_str()); + if (!err.empty()) return; + CHECK(pkg.signerId == "anssig-2026-09", "signed by the release key it names"); + CHECK(!pkg.certExpired, "with a certificate still in date"); + CHECK(pkg.manifest.value("project", std::string()) == "Interop", + "the manifest decrypts to what was packed"); + CHECK(pkg.manifest.value("family", std::string()) == "yolo", "including the family"); + CHECK(pkg.manifest.value("classes", Json::array()).size() == 2, "and its classes"); + CHECK(pkg.entryPayloadId() == "p0", "and names the model to run"); + + std::vector got; + CHECK(modelpkg::readPayload(pkg, "p0", got, err), ("read: " + err).c_str()); + std::vector want(12000); + for (size_t i = 0; i < want.size(); ++i) want[i] = uint8_t((i * 31 + 21) & 0xff); + CHECK(got == want, "and the model comes back byte for byte, across chunks"); +} + +// ── this implementation on its own ──────────────────────────────────────── +static std::vector fakeModel(size_t n, uint8_t seed) { + std::vector v(n); + for (size_t i = 0; i < n; ++i) v[i] = uint8_t((i * 31 + seed) & 0xff); + return v; +} + +static void testRoundTripAndRefusals(const fs::path& dir) { + const Identity id = fixtureIdentity(); + const modelpkg::Keyring ring = fixtureKeyring(id); + + modelpkg::PackRequest req; + req.keyId = "ansk-v1-base"; + req.useX25519 = true; + req.basePublic = id.basePub; + req.chunk = 2048; + req.nonceSeed = 9; + req.signerId = "anssig-2026-09"; + req.signerSecret = id.signerSk; + req.signerPublic = id.signerPk; + req.rootKeyId = "ansroot-v1"; + req.notAfter = "2030-01-01T00:00:00Z"; + { + Json cert{{"keyId", req.signerId}, + {"pub", bits::base64Encode( + std::string(id.signerPk.begin(), id.signerPk.end()))}, + {"notAfter", req.notAfter}}; + const std::string cb = modelpkg::detail::certBytes(cert); + req.rootSig.assign(64, 0); + crypto_ed25519_sign(req.rootSig.data(), id.rootSk.data(), + reinterpret_cast(cb.data()), cb.size()); + } + req.manifest = Json{{"task", "segmentation"}, + {"family", "rfdetr"}, + {"runtime", "onnx"}, + {"classes", Json::array({Json{{"id", 1}, {"name", "Road"}}})}, + {"models", Json::array({Json{{"id", "m0"}, + {"payload", "p0"}, + {"entry", true}}})}}; + const auto model = fakeModel(7000, 3); + req.models.push_back({"p0", model}); + + const std::string path = (dir / "core.ansmodel").string(); + std::string err; + CHECK(modelpkg::pack(path, req, err), ("pack: " + err).c_str()); + + modelpkg::Package pkg; + CHECK(modelpkg::open(path, ring, pkg, err), ("open: " + err).c_str()); + std::vector got; + CHECK(modelpkg::readPayload(pkg, "p0", got, err) && got == model, + "what this implementation writes, it reads back"); + + auto bytes = [&](const std::string& p) { + std::ifstream f(p, std::ios::binary); + return std::string((std::istreambuf_iterator(f)), + std::istreambuf_iterator()); + }; + auto write = [&](const std::string& p, const std::string& b) { + std::ofstream f(p, std::ios::binary | std::ios::trunc); + f.write(b.data(), std::streamsize(b.size())); + }; + const std::string good = bytes(path); + + { // a flipped bit in the model body + std::string bad = good; + bad[bad.size() - 30] = char(bad[bad.size() - 30] ^ 0x01); + const std::string p = (dir / "flipped.ansmodel").string(); + write(p, bad); + modelpkg::Package t; + std::vector out; + CHECK(modelpkg::open(p, ring, t, err) && + !modelpkg::readPayload(t, "p0", out, err) && out.empty(), + "a flipped bit fails its chunk and yields no partial model"); + } + { // an unknown root + modelpkg::Keyring stranger; + stranger.addX25519("ansk-v1-base", id.basePriv); + stranger.addRoot("ansroot-other", modelpkg::Key{}); + modelpkg::Package t; + CHECK(!modelpkg::open(path, stranger, t, err) && + err.find("unknown root") != std::string::npos, + "an unknown root is refused"); + } + { // a revoked signer + modelpkg::Keyring revoking = ring; + revoking.revokedSigners.push_back("anssig-2026-09"); + modelpkg::Package t; + CHECK(!modelpkg::open(path, revoking, t, err) && + err.find("revoked") != std::string::npos, + "a revoked signing key is refused"); + } + { // not a package + const std::string p = (dir / "rubbish.bin").string(); + write(p, "nothing to see here"); + modelpkg::Package t; + CHECK(!modelpkg::open(p, ring, t, err) && + err.find("not a model package") != std::string::npos, + "something else entirely is refused by its magic"); + } +} + +int main(int argc, char** argv) { + const fs::path dataDir = argc > 1 ? fs::path(argv[1]) : fs::path("data"); + const auto stamp = std::chrono::steady_clock::now().time_since_epoch().count(); + const fs::path tmp = + fs::temp_directory_path() / ("anscore-modelpkg-" + std::to_string(stamp)); + std::error_code ec; + fs::create_directories(tmp, ec); + + testVectors(); + testInterop(dataDir); + testRoundTripAndRefusals(tmp); + + fs::remove_all(tmp, ec); + std::printf("%d checks, %d failures\n", gChecks, gFailures); + return gFailures == 0 ? 0 : 1; +} diff --git a/tests/ANSModelPackage-UnitTest/CMakeLists.txt b/tests/ANSModelPackage-UnitTest/CMakeLists.txt new file mode 100644 index 0000000..fad563c --- /dev/null +++ b/tests/ANSModelPackage-UnitTest/CMakeLists.txt @@ -0,0 +1,9 @@ +# The model package format: its primitives against published vectors, a +# package written by ANSMINDCORE, and this implementation's own round trip. +add_executable(ANSModelPackage-UnitTest ANSModelPackage-UnitTest.cpp) + +target_link_libraries(ANSModelPackage-UnitTest PRIVATE ANSModelPackage) + +add_test(NAME ANSModelPackage + COMMAND ANSModelPackage-UnitTest + ${CMAKE_CURRENT_SOURCE_DIR}/data) diff --git a/tests/ANSModelPackage-UnitTest/data/README.md b/tests/ANSModelPackage-UnitTest/data/README.md new file mode 100644 index 0000000..67fbdbe --- /dev/null +++ b/tests/ANSModelPackage-UnitTest/data/README.md @@ -0,0 +1,23 @@ +# interop.ansmodel + +Written by **ANSMINDCORE's** packer (`src/model/ansmodel.hpp`), opened by +**this** implementation in the unit test. That is the point of it: the two +products must read the same bytes, and a fixture one of them produced is the +only way to prove it. + +Keys, so any implementation can reconstruct them: + +| Material | Rule | +|---|---| +| base X25519 private key | byte *i* = `i*3 + 9` | +| root Ed25519 seed | byte *i* = `i*7 + 1` | +| release Ed25519 seed | byte *i* = `i*11 + 5` | +| model payload, 12000 bytes | byte *i* = `(i*31 + 21) & 0xff` | + +Ids: base key `ansk-v1-base`, root `ansroot-v1`, signer `anssig-2026-09`, +certificate valid until 2030-01-01. Chunk size 4096, so the payload really is +chunked. + +To regenerate after a deliberate format change, pack the same manifest from +ANSMINDCORE with those keys and replace this file — and expect both suites to +fail until they agree again, which is the alarm working. diff --git a/tests/ANSModelPackage-UnitTest/data/interop.ansmodel b/tests/ANSModelPackage-UnitTest/data/interop.ansmodel new file mode 100644 index 0000000000000000000000000000000000000000..c0e2c008c8a9300e4c74f308d4de98600b7af91a GIT binary patch literal 13242 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 literal 0 HcmV?d00001 diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 7fe9cac..fdf0f47 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -8,5 +8,6 @@ add_subdirectory(ANSUtilities-UnitTest) add_subdirectory(ANSRabbitMQ-UnitTest) add_subdirectory(ANSIO-UnitTest) add_subdirectory(ANSLS-UnitTest) +add_subdirectory(ANSModelPackage-UnitTest) add_subdirectory(ANSONVIF-UnitTest) add_subdirectory(ANSODTRE-UnitTest)