sfinx

sphincs+ inspired signing utility
git clone git://git.finwo.net/app/sfinx
Log | Files | Refs | README | LICENSE

commit ab624023d522b689e233f881aae97b52a832e181
parent 6a542c743eea11968d653194bde7808eb633e455
Author: finwo <finwo@pm.me>
Date:   Tue, 13 Oct 2026 23:45:10 +0200

Bind the key, chain and step position into every WOTS chain hash

Diffstat:
MMakefile | 2+-
MREADME.md | 8+++++++-
Adocs/bench.md | 110+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mdocs/idea.md | 11+++++++++--
Mdocs/scheme.md | 56++++++++++++++++++++++++++++++++++++++++++++------------
Msrc/sfinx.c | 145++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
Atarget/linux-aarch64/.gitkeep | 0
Mtest/02-wots.c | 62++++++++++++++++++++++++++++++++++++++++++--------------------
Mtest/04-subtree.c | 6+++---
Mtest/11-reuse.c | 34+++++++++++++++++++++++-----------
Atest/12-tweak.c | 112+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mtest/Makefile | 10+++++++++-
Atest/bench-chain.c | 194+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mtest/ref/sfinx_ref.c | 69++++++++++++++++++++++++++++++++++++++++++++++++++++-----------------
Mtest/vectors/sig-L28-N0.hex | 2+-
Mtest/vectors/sig-L28-N1.hex | 2+-
Mtest/vectors/sig-L32-N0.hex | 2+-
Mtest/vectors/sig-L32-N1.hex | 2+-
Mtest/vectors/sig-L32-N2.hex | 2+-
Mtest/vectors/sig-L48-N0.hex | 2+-
Mtest/vectors/sig-L48-N1.hex | 2+-
Mtest/vectors/sig-L64-N0.hex | 2+-
Mtest/vectors/sig-L64-N1.hex | 2+-
23 files changed, 721 insertions(+), 116 deletions(-)

diff --git a/Makefile b/Makefile @@ -2,7 +2,7 @@ TARGET:=$(shell uname -s | tr '[:upper:]' '[:lower:]')-$(shell uname -m) BIN:=sfinx -SFINX_VERSION?=0.2.0 +SFINX_VERSION?=0.3.0 export SFINX_VERSION FIND:=$(shell command -v gfind find) diff --git a/README.md b/README.md @@ -110,12 +110,17 @@ Benchmark ```sh make bench make bench BENCH_ARGS='-L 512 -p 8 -n 5' +make --directory test bench-chain ``` This builds `test/bench.c` both threaded and sequential, then times key derivation, signing and verification for both the tree and the single key. `-L` sets the hash size (default 256), `-p` the path length in bytes (default 32) and -`-n` the repetitions, of which the best is reported (default 3). +`-n` the repetitions, of which the best is reported (default 3). `bench-chain` +times the WOTS chains alone, per backend. + +Measured numbers across a few machines are in +[docs/bench.md](docs/bench.md). Testing ------- @@ -130,6 +135,7 @@ Docs - [docs/scheme.md](docs/scheme.md): the precise scheme, formulas and pseudocode - [docs/cli.md](docs/cli.md): the command reference and the file formats - [docs/api.md](docs/api.md): the C API, generated from `src/sfinx.h` +- [docs/bench.md](docs/bench.md): measured throughput per machine and backend License ------- diff --git a/docs/bench.md b/docs/bench.md @@ -0,0 +1,110 @@ +Benchmarks +========== + +Operations per second, higher is better. Tree mode at path length 32, so one +signature covers 32 subtrees. + +| host | cores | backend | +| ------------------------- | ----- | -------- | +| AMD Ryzen 7 9800X3D | 8/16 | avx512 | +| Intel Xeon D-1541 | 8/16 | avx2 | +| Cortex-A520 + A720 | 12 | arm-sha3 | + +gcc 14.2.1, `-Wall -Wextra -O2`, best of 5 on the Ryzen, 3 on the Xeon, 2 on +the ARM. The Xeon shares its host with other services, so treat it as a floor. + +Only keygen and signing use the worker pool. Verifying and single mode run on +one core either way, so they are listed once. + +## SHA3-256, the default + +| host | keygen/s | sign/s | verify/s | +| ------------- | -------- | ------ | -------- | +| 9800X3D | 18 | 0.56 | 40 | +| 9800X3D x16 | 186 | 4.72 | 40 | +| D-1541 | 2.0 | 0.063 | 12 | +| D-1541 x16 | 15 | 0.49 | 12 | +| A520/A720 | 1.1 | 0.034 | 8.0 | +| A520/A720 x12 | 7.0 | 0.21 | 8.0 | + +## Every hash size + +Single core, then the same host threaded. + +| host | hash | keygen/s | sign/s | verify/s | +| ------------- | -------- | -------- | ------ | -------- | +| 9800X3D | SHA3-224 | 20 | 0.63 | 43 | +| 9800X3D | SHA3-256 | 18 | 0.56 | 40 | +| 9800X3D | SHA3-384 | 12 | 0.38 | 26 | +| 9800X3D | SHA3-512 | 9.4 | 0.29 | 20 | +| 9800X3D x16 | SHA3-224 | 208 | 5.38 | 43 | +| 9800X3D x16 | SHA3-256 | 186 | 4.72 | 40 | +| 9800X3D x16 | SHA3-384 | 125 | 3.14 | 25 | +| 9800X3D x16 | SHA3-512 | 96 | 2.30 | 20 | +| D-1541 | SHA3-224 | 2.3 | 0.071 | 13 | +| D-1541 | SHA3-256 | 2.0 | 0.063 | 12 | +| D-1541 | SHA3-384 | 1.4 | 0.043 | 7.8 | +| D-1541 | SHA3-512 | 1.0 | 0.032 | 6.2 | +| D-1541 x16 | SHA3-224 | 17 | 0.57 | 13 | +| D-1541 x16 | SHA3-256 | 15 | 0.49 | 12 | +| D-1541 x16 | SHA3-384 | 10 | 0.34 | 8.0 | +| D-1541 x16 | SHA3-512 | 7.2 | 0.25 | 6.2 | +| A520/A720 | SHA3-224 | 1.2 | 0.038 | 8.8 | +| A520/A720 | SHA3-256 | 1.1 | 0.034 | 8.0 | +| A520/A720 | SHA3-384 | 0.49 | 0.015 | 3.5 | +| A520/A720 | SHA3-512 | 0.55 | 0.017 | 4.1 | +| A520/A720 x12 | SHA3-224 | 7.7 | 0.23 | 8.8 | +| A520/A720 x12 | SHA3-256 | 7.0 | 0.21 | 8.0 | +| A520/A720 x12 | SHA3-384 | 4.9 | 0.14 | 5.2 | +| A520/A720 x12 | SHA3-512 | 3.8 | 0.11 | 4.1 | + +## Single mode + +One WOTS key, no tree, no path. Signs and verifies on one core. + +| host | SHA3-224 | SHA3-256 | SHA3-384 | SHA3-512 | +| --------- | -------- | -------- | -------- | -------- | +| 9800X3D | 1395 | 1303 | 1055 | 626 | +| D-1541 | 453 | 424 | 315 | 197 | +| A520/A720 | 283 | 262 | 142 | 126 | + +## Chains + +`make --directory test bench-chain`, one subtree of chains advanced 256 steps, +in millions of hashes per second on the 9800X3D. Higher is better. + +- `plain`: an untweaked chain over the batch API +- `glue`: the tweak over the batch API, rebuilding records each step +- `fused`: the chain kernel + +| hash | backend | plain | glue | fused | +| -------- | --------- | ----- | ----- | ----- | +| SHA3-224 | scalar | 5.94 | 5.73 | 5.11 | +| SHA3-224 | avx2 x4 | 11.92 | 10.54 | 13.51 | +| SHA3-224 | avx512 x8 | 24.44 | 20.36 | 40.10 | +| SHA3-256 | scalar | 5.92 | 5.67 | 5.12 | +| SHA3-256 | avx2 x4 | 11.60 | 10.22 | 13.53 | +| SHA3-256 | avx512 x8 | 24.05 | 19.73 | 40.44 | +| SHA3-384 | scalar | 5.83 | 5.45 | 5.12 | +| SHA3-384 | avx2 x4 | 10.93 | 9.57 | 13.54 | +| SHA3-384 | avx512 x8 | 21.63 | 17.13 | 40.24 | +| SHA3-512 | scalar | 5.70 | 5.59 | 5.12 | +| SHA3-512 | avx2 x4 | 10.50 | 10.03 | 13.59 | +| SHA3-512 | avx512 x8 | 20.24 | 18.76 | 40.91 | + +A chain step is one permutation at every hash size, so the fused kernel holds +about 40 Mh/s on avx512 from SHA3-224 to SHA3-512 where an untweaked chain +falls from 24.4 to 20.2. Reaching the chain through the batch API instead costs +a transpose and a scalar absorb per step, which is the `glue` column. + +Scalar has no lanes to fill, so it does not recover the larger block and sits +about 14% below an untweaked chain. + +## Notes + +Signing scales with path length: at path 32 each signature builds 32 subtrees, +and a shorter path is proportionally faster. Verifying does not, since it only +walks the path it is given. + +Zen 5 has a full-width AVX-512 datapath. Intel parts that double-pump 512-bit +operations will sit closer to the avx2 numbers. diff --git a/docs/idea.md b/docs/idea.md @@ -55,9 +55,16 @@ keys. Each key is a Winternitz one-time signature over an `L`-byte value. - Pre-image: `SHAKE256(seed | E4M4(N) | path[0..k-1])` for a layer-`k` key, `c * L` bytes, split into `c = L + 2` chains of `L` bytes. -- Chain `i` signs digit `i` by hashing its pre-image `digit[i]` times. +- A step is `H(x | kid | i | j)`, where `kid = H(E4M4(N) | path[0..k-1])` truncated, `i` is the chain and `j` the position. +- Chain `i` signs digit `i` by stepping its pre-image `digit[i]` times. - The first `L` digits are the signed value. The last `len2 = 2` digits are the checksum `C = sum(255 - digit[i])`. -- The pubkey is `H(chain_end[0] | ... | chain_end[c-1])`, where a chain end is the pre-image hashed `w = 256` times. +- The pubkey is `H(chain_end[0] | ... | chain_end[c-1])`, where a chain end is the pre-image stepped `w = 256` times. + +Binding the key, chain and position into every step keeps published chain +values apart. A plain `H(x)` chain puts every value from every key in one pool, +where a single precomputation targets all of them at once. The `kid` is public, +so a verifier recomputes it; it is truncated to keep a step inside one Keccak +block, which at SHA3-512 leaves only 5 bytes. The checksum is what stops a chain from being reversed. Increasing any digit decreases `C`, and an attacker can only hash forward, so a checksum chain would diff --git a/docs/scheme.md b/docs/scheme.md @@ -82,21 +82,46 @@ d[L+1] = C & 0xff `C` max is `L * 255`, which fits in two bytes for every supported `L` (7,140 at `L = 28`, 16,320 at `L = 64`), so `len2 = 2`. +Key id, once per WOTS key, over public data only so the verifier can recompute +it: + +``` +kid = H(E4M4(N) | path[0..k-1])[0 .. K-1] +K = min(L, rate - 1 - L - 2) rate = 200 - 2L +``` + +| hash | rate | L | K | block | +| -------- | ---- | -- | -- | ----- | +| SHA3-224 | 144 | 28 | 28 | 58 | +| SHA3-256 | 136 | 32 | 32 | 66 | +| SHA3-384 | 104 | 48 | 48 | 98 | +| SHA3-512 | 72 | 64 | 5 | 71 | + +`K` is cut so a chain step stays one permutation. SHA3-512 is the tight case: +rate 72 leaves 5 bytes, so its key ids separate only 40 bits, and two keys +colliding there share a chain pool again. Single mode has an empty suffix, so +`kid = H("")`. + Chain and keys: ``` -chain_i(x, 0) = x -chain_i(x, k) = H(chain_i(x, k-1)) +chain_i(x, j, 0) = x +chain_i(x, j, n) = chain_i(H(x | kid | i | j), j+1, n-1) -proof[i] = chain_i(pre[i], d[i]) sign -end[i] = chain_i(pre[i], w) pubkey build +proof[i] = chain_i(pre[i], 0, d[i]) sign +end[i] = chain_i(pre[i], 0, w) pubkey build pubkey = H(end[0] | end[1] | ... | end[c-1]) ``` +Every step is bound to its key, its chain and its position: `i` is `0..c-1` and +`j` is `0..w-1`, both one byte. Without that binding every published chain +value across every key sits in one pool, and one precomputation targets all of +them at once. + Verify a proof against a value: recompute the digits from the value, then -`end[i] = chain_i(proof[i], w - d[i])`, then the pubkey hash. An attacker can -only hash forward, so raising any `d[i]` lowers `C`, which forces a checksum -chain backward, which needs a preimage. +`end[i] = chain_i(proof[i], d[i], w - d[i])`, then the pubkey hash. An attacker +can only hash forward, so raising any `d[i]` lowers `C`, which forces a +checksum chain backward, which needs a preimage. ## Merkle subtree @@ -203,14 +228,20 @@ parent(bitlen, mask, prefix, left, right) = H(bitlen | mask | prefix | left | right) // WOTS +chain(x, kid, i, from, steps): + for j = from to from + steps - 1: + x = H(x | kid | i | j) + return x + single_sign(seed, prefix, value): pre = pre_image(seed, prefix) + kid = H(prefix)[0..K-1] d = digits(value) - return [ pre[i] hashed d[i] times, for i in 0..c-1 ] + return [ chain(pre[i], kid, i, 0, d[i]), for i in 0..c-1 ] -single_pubkey(proof, value): +single_pubkey(proof, kid, value): d = digits(value) - ends = [ proof[i] hashed (w - d[i]) times, for i in 0..c-1 ] + ends = [ chain(proof[i], kid, i, d[i], w - d[i]), for i in 0..c-1 ] return H(ends[0] | ... | ends[c-1]) ``` @@ -244,12 +275,13 @@ verify(pubkey, message, sig): L = E4M4_decode(sig) if N == 0: - return single_pubkey(read_proof(), H(message)) == pubkey + return single_pubkey(read_proof(), H(""), H(message)) == pubkey value = H(path | message) for k = N down to 1: - pub = single_pubkey(read_proof(), value) // proof for layer k + kid = H(E4M4(N) | path[0..k-1])[0..K-1] + pub = single_pubkey(read_proof(), kid, value) // proof for layer k if k == 1: return hash_up(pub, read_auth()) == pubkey // root of subtree 0 value = hash_up(pub, read_auth()) // root of subtree k-1 diff --git a/src/sfinx.c b/src/sfinx.c @@ -101,6 +101,37 @@ static inline sfinx_hash _sfinx_hash_from_len(size_t len) { } return 0; } + +#define SFINX_KID_ROOM(L) (197 - 3 * (L)) +#define SFINX_KID_LEN(L) ((L) < SFINX_KID_ROOM(L) ? (L) : SFINX_KID_ROOM(L)) +#define SFINX_CHAIN_FIT(L) ((L) + SFINX_KID_LEN(L) + 2 <= (200 - 2 * (L)) - 1) + +_Static_assert(SFINX_CHAIN_FIT(28), "SHA3-224 chain step is not one permutation"); +_Static_assert(SFINX_CHAIN_FIT(32), "SHA3-256 chain step is not one permutation"); +_Static_assert(SFINX_CHAIN_FIT(48), "SHA3-384 chain step is not one permutation"); +_Static_assert(SFINX_CHAIN_FIT(64), "SHA3-512 chain step is not one permutation"); + +static inline size_t _sfinx_kid_len(sfinx_hash hash) { + size_t len = sfinx_hash_len(hash); + return SFINX_KID_LEN(len); +} + +static inline void _sfinx_kid(sfinx_hash hash, const uint8_t *suffix, size_t suffix_len, uint8_t *out) { + uint8_t full[SFINX_HASH_LEN_MAX]; + _sfinx_hash(hash, suffix, suffix_len, full); + memcpy(out, full, _sfinx_kid_len(hash)); +} + +static inline void _sfinx_chain_batch(sfinx_hash hash, size_t count, uint8_t *x, const uint8_t *tail, size_t tail_len, + uint8_t from, uint32_t steps) { + size_t len = sfinx_hash_len(hash); + switch (hash) { + case SFINX_HASH_224: kf_sha3_224_chain(count, x, len, tail, tail_len, 1, from, steps); break; + case SFINX_HASH_256: kf_sha3_256_chain(count, x, len, tail, tail_len, 1, from, steps); break; + case SFINX_HASH_384: kf_sha3_384_chain(count, x, len, tail, tail_len, 1, from, steps); break; + case SFINX_HASH_512: kf_sha3_512_chain(count, x, len, tail, tail_len, 1, from, steps); break; + } +} // }}} // WOTS {{{ @@ -115,6 +146,7 @@ static inline sfinx_hash _sfinx_hash_from_len(size_t len) { #define SFINX_WOTS_BYTES_MAX ((SFINX_HASH_LEN_MAX + 2) * SFINX_HASH_LEN_MAX) #define SFINX_WOTS_DIGITS_MAX (SFINX_HASH_LEN_MAX + 2) +#define SFINX_WOTS_TAIL_MAX ((SFINX_HASH_LEN_MAX + 2) * (SFINX_HASH_LEN_MAX + 1)) // Cap on the seed-sized key staging buffer, so a large seed cannot force 256 copies at once #ifndef SFINX_BATCH_KEY_BUDGET @@ -137,42 +169,57 @@ static inline void _sfinx_wots_digits(sfinx_hash hash, const uint8_t *value, uin out[len + 1] = (uint8_t)checksum; } -static inline void _sfinx_wots_chain(sfinx_hash hash, uint8_t *node, uint32_t steps) { - uint8_t next[SFINX_HASH_LEN_MAX]; - size_t len = sfinx_hash_len(hash); - for (uint32_t i = 0; i < steps; i++) { - _sfinx_hash(hash, node, len, next); - memcpy(node, next, len); +static inline void _sfinx_wots_tails(sfinx_hash hash, const uint8_t *kid, uint8_t *out) { + size_t len = sfinx_hash_len(hash); + size_t k = _sfinx_kid_len(hash); + for (size_t i = 0; i < len + 2; i++) { + memcpy(out + i * (k + 1), kid, k); + out[i * (k + 1) + k] = (uint8_t)i; } } -static inline void _sfinx_wots_pubkey(sfinx_hash hash, const uint8_t *key, size_t key_len, uint8_t *pubkey_out) { +static inline void _sfinx_wots_chain(sfinx_hash hash, uint8_t *node, const uint8_t *kid, uint8_t index, uint8_t from, + uint32_t steps) { + uint8_t tail[SFINX_HASH_LEN_MAX + 1]; + size_t k = _sfinx_kid_len(hash); + memcpy(tail, kid, k); + tail[k] = index; + _sfinx_chain_batch(hash, 1, node, tail, k + 1, from, steps); +} + +static inline void _sfinx_wots_pubkey(sfinx_hash hash, const uint8_t *key, size_t key_len, size_t seed_len, + uint8_t *pubkey_out) { size_t len = sfinx_hash_len(hash); size_t count = len + 2; + size_t k = _sfinx_kid_len(hash); uint8_t ends[SFINX_WOTS_BYTES_MAX]; + uint8_t kid[SFINX_HASH_LEN_MAX]; + uint8_t tails[SFINX_WOTS_TAIL_MAX]; _sfinx_wots_preimage(hash, key, key_len, ends); - for (uint32_t step = 0; step < 256u; step++) { - _sfinx_hash_batch(hash, count, ends, len, ends, len); - } + _sfinx_kid(hash, key + seed_len, key_len - seed_len, kid); + _sfinx_wots_tails(hash, kid, tails); + _sfinx_chain_batch(hash, count, ends, tails, k + 1, 0, 256); _sfinx_hash(hash, ends, count * len, pubkey_out); } -static inline sfinx_status _sfinx_wots_sign(sfinx_hash hash, const uint8_t *key, size_t key_len, const uint8_t *value, - size_t value_len, uint8_t *proof_out) { +static inline sfinx_status _sfinx_wots_sign(sfinx_hash hash, const uint8_t *key, size_t key_len, size_t seed_len, + const uint8_t *value, size_t value_len, uint8_t *proof_out) { size_t len = sfinx_hash_len(hash); uint8_t digits[SFINX_WOTS_DIGITS_MAX]; + uint8_t kid[SFINX_HASH_LEN_MAX]; if (len == 0 || value_len != len) { return SFINX_ERR_ARGS; } _sfinx_wots_preimage(hash, key, key_len, proof_out); _sfinx_wots_digits(hash, value, digits); + _sfinx_kid(hash, key + seed_len, key_len - seed_len, kid); for (size_t i = 0; i < len + 2; i++) { - _sfinx_wots_chain(hash, proof_out + i * len, digits[i]); + _sfinx_wots_chain(hash, proof_out + i * len, kid, (uint8_t)i, 0, digits[i]); } return SFINX_OK; } -static inline void _sfinx_wots_rebuild(sfinx_hash hash, const uint8_t *value, const uint8_t *proof, +static inline void _sfinx_wots_rebuild(sfinx_hash hash, const uint8_t *value, const uint8_t *proof, const uint8_t *kid, uint8_t *pubkey_out) { size_t len = sfinx_hash_len(hash); uint8_t digits[SFINX_WOTS_DIGITS_MAX]; @@ -181,16 +228,16 @@ static inline void _sfinx_wots_rebuild(sfinx_hash hash, const uint8_t *value, co _sfinx_wots_digits(hash, value, digits); for (size_t i = 0; i < len + 2; i++) { memcpy(node, proof + i * len, len); - _sfinx_wots_chain(hash, node, 256 - digits[i]); + _sfinx_wots_chain(hash, node, kid, (uint8_t)i, digits[i], 256 - digits[i]); memcpy(ends + i * len, node, len); } _sfinx_hash(hash, ends, (len + 2) * len, pubkey_out); } -static inline int _sfinx_wots_verify(sfinx_hash hash, const uint8_t *pubkey, const uint8_t *value, - const uint8_t *proof) { +static inline int _sfinx_wots_verify(sfinx_hash hash, const uint8_t *pubkey, const uint8_t *value, const uint8_t *proof, + const uint8_t *kid) { uint8_t want[SFINX_HASH_LEN_MAX]; - _sfinx_wots_rebuild(hash, value, proof, want); + _sfinx_wots_rebuild(hash, value, proof, kid, want); return memcmp(want, pubkey, sfinx_hash_len(hash)) == 0; } // }}} @@ -448,12 +495,14 @@ static inline void _sfinx_merkle_parent(sfinx_hash hash, uint8_t bitlen, uint8_t static inline void _sfinx_subtree_leaves(sfinx_hash hash, const uint8_t *seed, size_t seed_len, const uint8_t *prefix, size_t prefix_len, size_t begin, size_t end, uint8_t *ends, uint8_t *nodes, - uint8_t *keybuf) { - size_t len = sfinx_hash_len(hash); - size_t c = len + 2; - size_t key_len = seed_len + prefix_len + 1; - size_t chunk = SFINX_BATCH_KEY_BUDGET / key_len; - size_t n = end - begin; + uint8_t *tails, uint8_t *keybuf) { + size_t len = sfinx_hash_len(hash); + size_t c = len + 2; + size_t k = _sfinx_kid_len(hash); + size_t key_len = seed_len + prefix_len + 1; + size_t tail_len = k + 1; + size_t chunk = SFINX_BATCH_KEY_BUDGET / key_len; + size_t n = end - begin; if (chunk == 0) { chunk = 1; @@ -472,10 +521,14 @@ static inline void _sfinx_subtree_leaves(sfinx_hash hash, const uint8_t *seed, s key[key_len - 1] = (uint8_t)(begin + base + i); } _sfinx_shake256_batch(m, keybuf, key_len, ends + (begin + base) * c * len, c * len); + for (size_t i = 0; i < m; i++) { + uint8_t kid[SFINX_HASH_LEN_MAX]; + uint8_t *key = keybuf + i * key_len; + _sfinx_kid(hash, key + seed_len, prefix_len + 1, kid); + _sfinx_wots_tails(hash, kid, tails + (begin + base + i) * c * tail_len); + } } - for (uint32_t step = 0; step < 256u; step++) { - _sfinx_hash_batch(hash, n * c, ends + begin * c * len, len, ends + begin * c * len, len); - } + _sfinx_chain_batch(hash, n * c, ends + begin * c * len, tails + begin * c * tail_len, tail_len, 0, 256); _sfinx_hash_batch(hash, n, ends + begin * c * len, c * len, nodes + begin * len, len); } @@ -489,6 +542,7 @@ typedef struct { size_t count; uint8_t *ends; uint8_t *nodes; + uint8_t *tails; } _sfinx_subtree_ctx; static void _sfinx_subtree_job(void *vctx, size_t index, void *scratch) { @@ -500,24 +554,31 @@ static void _sfinx_subtree_job(void *vctx, size_t index, void *scratch) { end = ctx->count; } _sfinx_subtree_leaves(ctx->hash, ctx->seed, ctx->seed_len, ctx->prefix, ctx->prefix_len, begin, end, ctx->ends, - ctx->nodes, scratch); + ctx->nodes, ctx->tails, scratch); } static inline int _sfinx_subtree_build(_sfinx_pool *pool, sfinx_hash hash, const uint8_t *seed, size_t seed_len, const uint8_t *prefix, size_t prefix_len, uint8_t leaf_index, uint8_t *root_out, uint8_t *auth_out) { - size_t len = sfinx_hash_len(hash); - size_t c = len + 2; - size_t key_len = seed_len + prefix_len + 1; - size_t count = 256; - size_t pos = leaf_index; + size_t len = sfinx_hash_len(hash); + size_t c = len + 2; + size_t key_len = seed_len + prefix_len + 1; + size_t tail_len = _sfinx_kid_len(hash) + 1; + size_t count = 256; + size_t pos = leaf_index; uint8_t nodes[256 * SFINX_HASH_LEN_MAX]; uint8_t *ends; + uint8_t *tails; ends = malloc(count * c * len); if (!ends) { return 0; } + tails = malloc(count * c * tail_len); + if (!tails) { + free(ends); + return 0; + } if (pool) { _sfinx_subtree_ctx ctx = { .hash = hash, @@ -529,6 +590,7 @@ static inline int _sfinx_subtree_build(_sfinx_pool *pool, sfinx_hash hash, const .count = count, .ends = ends, .nodes = nodes, + .tails = tails, }; size_t jobs; if (ctx.chunk == 0) { @@ -547,10 +609,11 @@ static inline int _sfinx_subtree_build(_sfinx_pool *pool, sfinx_hash hash, const } keybuf = malloc(chunk * key_len); if (!keybuf) { + free(tails); free(ends); return 0; } - _sfinx_subtree_leaves(hash, seed, seed_len, prefix, prefix_len, 0, count, ends, nodes, keybuf); + _sfinx_subtree_leaves(hash, seed, seed_len, prefix, prefix_len, 0, count, ends, nodes, tails, keybuf); free(keybuf); } for (size_t bitlen = 8; bitlen-- > 0;) { @@ -565,6 +628,7 @@ static inline int _sfinx_subtree_build(_sfinx_pool *pool, sfinx_hash hash, const pos >>= 1; } memcpy(root_out, nodes, len); + free(tails); free(ends); return 1; } @@ -606,7 +670,7 @@ sfinx_status sfinx_single_public_key(sfinx_hash hash, const uint8_t *seed, size_ if (!pubkey_out || pubkey_cap < len) { return SFINX_ERR_NOSPACE; } - _sfinx_wots_pubkey(hash, seed, seed_len, pubkey_out); + _sfinx_wots_pubkey(hash, seed, seed_len, seed_len, pubkey_out); if (pubkey_len_out) { *pubkey_len_out = len; } @@ -627,7 +691,7 @@ sfinx_status sfinx_single_sign(sfinx_hash hash, const uint8_t *seed, size_t seed _sfinx_hash(hash, msg, msg_len, org); _sfinx_e4m4_encode(0, sig); _sfinx_e4m4_encode((uint32_t)len, sig + 1); - if (_sfinx_wots_sign(hash, seed, seed_len, org, len, sig + 2) != SFINX_OK) { + if (_sfinx_wots_sign(hash, seed, seed_len, seed_len, org, len, sig + 2) != SFINX_OK) { return SFINX_ERR_ARGS; } if (sig_len_out) { @@ -718,7 +782,7 @@ sfinx_status sfinx_tree_sign(sfinx_hash hash, const uint8_t *seed, size_t seed_l free(key); return SFINX_ERR_NOSPACE; } - if (_sfinx_wots_sign(hash, key, seed_len + k + 1, value, len, sig + at) != SFINX_OK) { + if (_sfinx_wots_sign(hash, key, seed_len + k + 1, seed_len, value, len, sig + at) != SFINX_OK) { _sfinx_pool_destroy(pool); free(key); return SFINX_ERR_ARGS; @@ -756,6 +820,7 @@ sfinx_status sfinx_verify(const uint8_t *pubkey, size_t pubkey_len, const uint8_ uint8_t value[SFINX_HASH_LEN_MAX]; uint8_t leaf[SFINX_HASH_LEN_MAX]; uint8_t root[SFINX_HASH_LEN_MAX]; + uint8_t kid[SFINX_HASH_LEN_MAX]; const uint8_t *path; uint8_t *joined; @@ -777,7 +842,8 @@ sfinx_status sfinx_verify(const uint8_t *pubkey, size_t pubkey_len, const uint8_ c = len + 2; if (path_len == 0) { _sfinx_hash(hash, msg, msg_len, org); - return _sfinx_wots_verify(hash, pubkey, org, sig + at) ? SFINX_OK : SFINX_ERR_VERIFY; + _sfinx_kid(hash, NULL, 0, kid); + return _sfinx_wots_verify(hash, pubkey, org, sig + at, kid) ? SFINX_OK : SFINX_ERR_VERIFY; } joined = malloc(path_len + msg_len); if (!joined) { @@ -789,7 +855,8 @@ sfinx_status sfinx_verify(const uint8_t *pubkey, size_t pubkey_len, const uint8_ free(joined); memcpy(value, org, len); for (size_t k = path_len; k >= 1; k--) { - _sfinx_wots_rebuild(hash, value, sig + at, leaf); + _sfinx_kid(hash, sig, k + 1, kid); + _sfinx_wots_rebuild(hash, value, sig + at, kid, leaf); at += c * len; _sfinx_subtree_verify(hash, sig, k, leaf, sig[k], sig + at, root); at += 8 * len; diff --git a/target/linux-aarch64/.gitkeep b/target/linux-aarch64/.gitkeep diff --git a/test/02-wots.c b/test/02-wots.c @@ -7,12 +7,17 @@ static void check_size(size_t got, size_t want, const char *what) { tap(got == want, what, "got %zu, want %zu", got, want); } -static void chain_manual(sfinx_hash hash, uint8_t *node, uint32_t steps) { - uint8_t next[SFINX_HASH_LEN_MAX]; +static void chain_manual(sfinx_hash hash, uint8_t *node, const uint8_t *kid, uint8_t index, uint8_t from, + uint32_t steps) { + uint8_t blk[SFINX_HASH_LEN_MAX * 2 + 2]; size_t len = sfinx_hash_len(hash); + size_t k = _sfinx_kid_len(hash); for (uint32_t i = 0; i < steps; i++) { - _sfinx_hash(hash, node, len, next); - memcpy(node, next, len); + memcpy(blk, node, len); + memcpy(blk + len, kid, k); + blk[len + k] = index; + blk[len + k + 1] = (uint8_t)(from + i); + _sfinx_hash(hash, blk, len + k + 2, node); } } @@ -30,6 +35,7 @@ int main(void) { uint8_t proof[SFINX_WOTS_BYTES_MAX]; uint8_t node[SFINX_HASH_LEN_MAX]; uint8_t manual[SFINX_HASH_LEN_MAX]; + uint8_t kid[SFINX_HASH_LEN_MAX]; tap_begin("sfinx WOTS"); @@ -51,46 +57,62 @@ int main(void) { _sfinx_wots_digits(SFINX_HASH_256, value, digits); tap(memcmp(digits, value, 32) == 0, "digits copy the value", "digits differ"); + _sfinx_kid(SFINX_HASH_256, NULL, 0, kid); + for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1); memcpy(manual, node, 32); - chain_manual(SFINX_HASH_256, manual, 5); - _sfinx_wots_chain(SFINX_HASH_256, node, 5); + chain_manual(SFINX_HASH_256, manual, kid, 7, 0, 5); + _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 0, 5); tap(memcmp(node, manual, 32) == 0, "chain of 5 matches manual", "chain differs"); for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1); memcpy(manual, node, 32); - _sfinx_wots_chain(SFINX_HASH_256, node, 0); + chain_manual(SFINX_HASH_256, manual, kid, 7, 3, 4); + _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 3, 4); + tap(memcmp(node, manual, 32) == 0, "chain from 3 matches manual", "chain differs"); + + for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1); + memcpy(manual, node, 32); + _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 0, 0); tap(memcmp(node, manual, 32) == 0, "chain of 0 is identity", "chain changed"); - _sfinx_wots_pubkey(SFINX_HASH_256, seed, seed_len, pubkey); - _sfinx_wots_pubkey(SFINX_HASH_256, seed, seed_len, other); + for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1); + memcpy(manual, node, 32); + _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 0, 1); + _sfinx_wots_chain(SFINX_HASH_256, manual, kid, 8, 0, 1); + tap(memcmp(node, manual, 32) != 0, "chain index changes the step", "steps match"); + + _sfinx_wots_pubkey(SFINX_HASH_256, seed, seed_len, seed_len, pubkey); + _sfinx_wots_pubkey(SFINX_HASH_256, seed, seed_len, seed_len, other); tap(memcmp(pubkey, other, 32) == 0, "pubkey is deterministic", "pubkeys differ"); - _sfinx_wots_pubkey(SFINX_HASH_256, (const uint8_t *)"other wots seed", 15, other); + _sfinx_wots_pubkey(SFINX_HASH_256, (const uint8_t *)"other wots seed", 15, 15, other); tap(memcmp(pubkey, other, 32) != 0, "different seed gives a different pubkey", "pubkeys match"); _sfinx_hash(SFINX_HASH_256, (const uint8_t *)"hello", 5, value); - _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof); - tap(_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof), "proof verifies", "verify failed"); + _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof); + tap(_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof, kid), "proof verifies", "verify failed"); proof[17] ^= 0x40; - tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof), "tampered proof fails", "verify passed"); + tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof, kid), "tampered proof fails", "verify passed"); - _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof); + _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof); value[3] ^= 0x01; - tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof), "tampered value fails", "verify passed"); + tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof, kid), "tampered value fails", "verify passed"); _sfinx_hash(SFINX_HASH_256, (const uint8_t *)"hello", 5, value); - _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof); + _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof); memcpy(other, pubkey, 32); other[0] ^= 0x01; - tap(!_sfinx_wots_verify(SFINX_HASH_256, other, value, proof), "wrong pubkey fails", "verify passed"); + tap(!_sfinx_wots_verify(SFINX_HASH_256, other, value, proof, kid), "wrong pubkey fails", "verify passed"); for (size_t h = 0; h < 4; h++) { + uint8_t hkid[SFINX_HASH_LEN_MAX]; + _sfinx_kid(hashes[h], NULL, 0, hkid); _sfinx_hash(hashes[h], (const uint8_t *)"message", 7, value); - _sfinx_wots_pubkey(hashes[h], seed, seed_len, pubkey); - _sfinx_wots_sign(hashes[h], seed, seed_len, value, sfinx_hash_len(hashes[h]), proof); - tap(_sfinx_wots_verify(hashes[h], pubkey, value, proof), labels[h], "verify failed"); + _sfinx_wots_pubkey(hashes[h], seed, seed_len, seed_len, pubkey); + _sfinx_wots_sign(hashes[h], seed, seed_len, seed_len, value, sfinx_hash_len(hashes[h]), proof); + tap(_sfinx_wots_verify(hashes[h], pubkey, value, proof, hkid), labels[h], "verify failed"); } return tap_plan(); diff --git a/test/04-subtree.c b/test/04-subtree.c @@ -28,7 +28,7 @@ int main(void) { memcpy(key, seed, seed_len); memcpy(key + seed_len, prefix, 3); key[seed_len + 3] = idx; - _sfinx_wots_pubkey(SFINX_HASH_256, key, seed_len + 4, leaf); + _sfinx_wots_pubkey(SFINX_HASH_256, key, seed_len + 4, seed_len, leaf); _sfinx_subtree_verify(SFINX_HASH_256, prefix, 3, leaf, idx, auth, built); tap(memcmp(built, root, len) == 0, "auth path rebuilds the subtree root", "root differs"); @@ -50,7 +50,7 @@ int main(void) { memcpy(key, seed, seed_len); memcpy(key + seed_len, prefix, 3); key[seed_len + 3] = (uint8_t)i; - _sfinx_wots_pubkey(SFINX_HASH_256, key, seed_len + 4, nodes + i * len); + _sfinx_wots_pubkey(SFINX_HASH_256, key, seed_len + 4, seed_len, nodes + i * len); } count = 256; for (size_t bitlen = 8; bitlen-- > 0;) { @@ -79,7 +79,7 @@ int main(void) { memcpy(mkey, seed, seed_len); memcpy(mkey + seed_len, prefix, 3); mkey[seed_len + 3] = (uint8_t)i; - _sfinx_wots_pubkey(h, mkey, seed_len + 4, mnodes + i * l); + _sfinx_wots_pubkey(h, mkey, seed_len + 4, seed_len, mnodes + i * l); } for (size_t bitlen = 8; bitlen-- > 0;) { cnt /= 2; diff --git a/test/11-reuse.c b/test/11-reuse.c @@ -6,24 +6,29 @@ #define MSG "sfinx reuse regression" #define MSG_LEN (sizeof(MSG) - 1) -// Two WOTS signatures from one key sit on the same chains, so one walks forward onto the other -static size_t chains_linked(sfinx_hash hash, const uint8_t *a, const uint8_t *b, size_t len, size_t count) { +// A proof element sits at an unknown chain position, so every start is tried +static size_t chains_linked(sfinx_hash hash, const uint8_t *kid_a, const uint8_t *a, const uint8_t *kid_b, + const uint8_t *b, size_t len, size_t count) { uint8_t walk[SFINX_HASH_LEN_MAX]; size_t linked = 0; for (size_t i = 0; i < count; i++) { - for (int dir = 0; dir < 2; dir++) { + int hit = 0; + for (int dir = 0; dir < 2 && !hit; dir++) { const uint8_t *from = dir ? b : a; const uint8_t *to = dir ? a : b; - memcpy(walk, from + i * len, len); - for (size_t step = 0; step < 256; step++) { - if (memcmp(walk, to + i * len, len) == 0) { - linked++; - dir = 2; - break; + const uint8_t *kid = dir ? kid_b : kid_a; + for (size_t j0 = 0; j0 < 256 && !hit; j0++) { + memcpy(walk, from + i * len, len); + for (size_t step = j0; step < 256; step++) { + if (memcmp(walk, to + i * len, len) == 0) { + hit = 1; + break; + } + _sfinx_wots_chain(hash, walk, kid, (uint8_t)i, (uint8_t)step, 1); } - _sfinx_hash(hash, walk, len, walk); } } + linked += (size_t)hit; } return linked; } @@ -39,6 +44,8 @@ int main(void) { size_t n1 = sfinx_signature_len(SFINX_HASH_256, 1); size_t n2 = sfinx_signature_len(SFINX_HASH_256, 2); size_t linked; + uint8_t kid1[SFINX_HASH_LEN_MAX]; + uint8_t kid2[SFINX_HASH_LEN_MAX]; tap_begin("sfinx cross-length key reuse"); @@ -52,7 +59,12 @@ int main(void) { tap(memcmp(sig1 + n1 - 8 * len, sig2 + n2 - 8 * len, 8 * len) != 0, "layer-1 auth paths differ across path lengths", "auth paths are identical"); - linked = chains_linked(SFINX_HASH_256, sig1 + 3, sig2 + n2 - (len + 10) * len, len, len + 2); + _sfinx_kid(SFINX_HASH_256, sig1, 2, kid1); + _sfinx_kid(SFINX_HASH_256, sig2, 2, kid2); + tap(memcmp(kid1, kid2, _sfinx_kid_len(SFINX_HASH_256)) != 0, "layer-1 key ids differ across path lengths", + "key ids are identical"); + + linked = chains_linked(SFINX_HASH_256, kid1, sig1 + 3, kid2, sig2 + n2 - (len + 10) * len, len, len + 2); tap(linked == 0, "layer-1 proofs do not chain onto each other", "%zu of %zu chains link", linked, len + 2); return tap_plan(); diff --git a/test/12-tweak.c b/test/12-tweak.c @@ -0,0 +1,112 @@ +#include <string.h> + +#include "_tap.c" +#include "src/sfinx.c" + +#define MSG "sfinx tweak vector" +#define MSG_LEN (sizeof(MSG) - 1) + +static void step(sfinx_hash hash, const uint8_t *kid, uint8_t index, uint8_t from, uint8_t *out) { + uint8_t node[SFINX_HASH_LEN_MAX]; + for (size_t i = 0; i < sfinx_hash_len(hash); i++) { + node[i] = (uint8_t)(i + 1); + } + _sfinx_wots_chain(hash, node, kid, index, from, 1); + memcpy(out, node, sfinx_hash_len(hash)); +} + +static void kid_for(sfinx_hash hash, size_t path_len, const uint8_t *path, size_t k, uint8_t *out) { + uint8_t suffix[SFINX_HASH_LEN_MAX]; + _sfinx_e4m4_encode((uint32_t)path_len, suffix); + for (size_t i = 0; i < k; i++) { + suffix[1 + i] = path[i]; + } + _sfinx_kid(hash, suffix, k + 1, out); +} + +static void roundtrip(sfinx_hash hash, size_t path_len, const char *label) { + static const uint8_t seed[] = "sfinx tweak seed"; + uint8_t path[32]; + uint8_t pub[SFINX_HASH_LEN_MAX]; + uint8_t *sig; + size_t seed_len = strlen((const char *)seed); + size_t n = sfinx_signature_len(hash, path_len); + size_t got = 0; + char name[96]; + + for (size_t i = 0; i < sizeof(path); i++) { + path[i] = (uint8_t)(i * 3 + 1); + } + sig = malloc(n); + if (!sig) { + tap(0, label, "out of memory"); + return; + } + + if (path_len == 0) { + sfinx_single_public_key(hash, seed, seed_len, pub, sizeof(pub), &got); + sfinx_single_sign(hash, seed, seed_len, (const uint8_t *)MSG, MSG_LEN, sig, n, NULL); + } else { + sfinx_tree_public_key(hash, seed, seed_len, path_len, pub, sizeof(pub), &got); + sfinx_tree_sign(hash, seed, seed_len, path, path_len, (const uint8_t *)MSG, MSG_LEN, sig, n, NULL); + } + + snprintf(name, sizeof(name), "%s verifies", label); + tap(sfinx_verify(pub, got, (const uint8_t *)MSG, MSG_LEN, sig, n) == SFINX_OK, name, "verify failed"); + + sig[n / 2] ^= 0x01; + snprintf(name, sizeof(name), "%s rejects a tampered signature", label); + tap(sfinx_verify(pub, got, (const uint8_t *)MSG, MSG_LEN, sig, n) != SFINX_OK, name, "verify passed"); + + free(sig); +} + +int main(void) { + static const sfinx_hash hashes[] = {SFINX_HASH_224, SFINX_HASH_256, SFINX_HASH_384, SFINX_HASH_512}; + static const char *sizes[] = {"224", "256", "384", "512"}; + uint8_t kid[SFINX_HASH_LEN_MAX]; + uint8_t other[SFINX_HASH_LEN_MAX]; + uint8_t a[SFINX_HASH_LEN_MAX]; + uint8_t b[SFINX_HASH_LEN_MAX]; + uint8_t path1[] = {0x0a, 0x1b}; + uint8_t path2[] = {0x0a, 0x2c}; + size_t len = sfinx_hash_len(SFINX_HASH_256); + size_t k = _sfinx_kid_len(SFINX_HASH_256); + + tap_begin("sfinx chain tweak"); + + _sfinx_kid(SFINX_HASH_256, (const uint8_t *)"\x01\x0a", 2, kid); + + memcpy(other, kid, k); + other[0] ^= 0x01; + step(SFINX_HASH_256, kid, 3, 0, a); + step(SFINX_HASH_256, other, 3, 0, b); + tap(memcmp(a, b, len) != 0, "a different key id changes the step", "outputs match"); + + step(SFINX_HASH_256, kid, 3, 0, a); + step(SFINX_HASH_256, kid, 4, 0, b); + tap(memcmp(a, b, len) != 0, "a different chain index changes the step", "outputs match"); + + step(SFINX_HASH_256, kid, 3, 0, a); + step(SFINX_HASH_256, kid, 3, 1, b); + tap(memcmp(a, b, len) != 0, "a different step index changes the step", "outputs match"); + + kid_for(SFINX_HASH_256, 2, path1, 2, a); + kid_for(SFINX_HASH_256, 2, path2, 2, b); + tap(memcmp(a, b, k) != 0, "different paths give different key ids", "key ids match"); + + kid_for(SFINX_HASH_256, 2, path1, 1, a); + kid_for(SFINX_HASH_256, 3, path1, 1, b); + tap(memcmp(a, b, k) != 0, "the same path at a different N gives a different key id", "key ids match"); + + for (size_t h = 0; h < 4; h++) { + char label[64]; + for (size_t p = 0; p < 3; p++) { + snprintf(label, sizeof(label), "L%s N%zu", sizes[h], p); + roundtrip(hashes[h], p, label); + } + } + roundtrip(SFINX_HASH_256, 32, "L256 N32"); + + return tap_plan(); +} diff --git a/test/Makefile b/test/Makefile @@ -10,7 +10,7 @@ endif include ../lib/.dep/config.mk OUT := ../build/test -SRCS := $(filter-out _tap.c bench.c,$(wildcard *.c)) +SRCS := $(filter-out _tap.c bench.c bench-chain.c,$(wildcard *.c)) TESTS := $(patsubst %.c,%,$(SRCS)) BINS := $(addprefix $(OUT)/,$(TESTS)) SH := $(filter-out _tap.sh,$(wildcard *.sh)) @@ -45,11 +45,19 @@ $(OUT)/bench-seq: CFLAGS := $(filter-out -pthread,$(CFLAGS)) $(OUT)/bench-seq: bench.c ../src/sfinx.c $(HASH) | $(OUT) @$(CC) $(CFLAGS) bench.c ../src/sfinx.c $(HASH) -o $@ +$(OUT)/bench-chain: CFLAGS += -I$(KECCAK) +$(OUT)/bench-chain: bench-chain.c ../src/sfinx.c $(LIB) $(HASH) | $(OUT) + @$(CC) $(CFLAGS) bench-chain.c $(LIB) $(HASH) -o $@ + .PHONY: bench bench: $(OUT)/bench $(OUT)/bench-seq @$(OUT)/bench $(BENCH_ARGS) @$(OUT)/bench-seq $(BENCH_ARGS) +.PHONY: bench-chain +bench-chain: $(OUT)/bench-chain + @$(OUT)/bench-chain $(BENCH_ARGS) + .PHONY: run run: all @rc=0; \ diff --git a/test/bench-chain.c b/test/bench-chain.c @@ -0,0 +1,194 @@ +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> + +#include "keccak-fast-internal.h" +#include "src/sfinx.c" + +#define KF_CHAIN_PROTO(name) \ + void name(size_t, uint8_t *, size_t, const uint8_t *, size_t, size_t, uint8_t, uint32_t, size_t, uint8_t) + +KF_CHAIN_PROTO(kf_scalar_chain); +KF_CHAIN_PROTO(kf_scalar_chain12); +void kf_scalar_batch(uint64_t states[][25], size_t count); +void kf_scalar_batch12(uint64_t states[][25], size_t count); + +#if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX2) +KF_CHAIN_PROTO(kf_avx2_chain); +KF_CHAIN_PROTO(kf_avx2_chain12); +void kf_avx2_batch(uint64_t states[][25], size_t count); +void kf_avx2_batch12(uint64_t states[][25], size_t count); +#endif +#if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX512) +KF_CHAIN_PROTO(kf_avx512_chain); +KF_CHAIN_PROTO(kf_avx512_chain12); +void kf_avx512_batch(uint64_t states[][25], size_t count); +void kf_avx512_batch12(uint64_t states[][25], size_t count); +#endif +#if defined(__aarch64__) && !defined(KECCAK_FAST_NO_SHA3) +int kf_armsha3_available(void); +KF_CHAIN_PROTO(kf_armsha3_chain); +KF_CHAIN_PROTO(kf_armsha3_chain12); +void kf_armsha3_batch(uint64_t states[][25], size_t count); +void kf_armsha3_batch12(uint64_t states[][25], size_t count); +#endif + +typedef struct { + const char *label; + kf_batch_perm_fn perm; + kf_batch_perm_fn perm12; + kf_chain_fn chain; + kf_chain_fn chain12; + int lanes; +} row; + +static uint64_t now_ns(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec; +} + +static double mhs(uint64_t ns, size_t hashes) { + return (double)hashes * 1000.0 / (double)ns; +} + +static void cell(double v) { + if (v < 0.0) { + printf(" %10s", "-"); + } else { + printf(" %10.3f", v); + } +} + +int main(int argc, char **argv) { + static const sfinx_hash hashes[] = {SFINX_HASH_224, SFINX_HASH_256, SFINX_HASH_384, SFINX_HASH_512}; + static const char *sizes[] = {"SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512"}; + unsigned reps = 5; + row rows[4]; + int nr = 0; + + for (int i = 1; i + 1 < argc; i += 2) { + if (strcmp(argv[i], "-n") == 0) { + reps = (unsigned)strtoul(argv[i + 1], NULL, 10); + } + } + if (reps == 0) { + reps = 1; + } + + rows[nr++] = (row){"scalar", kf_scalar_batch, kf_scalar_batch12, kf_scalar_chain, kf_scalar_chain12, 1}; +#if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX2) + if (__builtin_cpu_supports("avx2")) { + rows[nr++] = (row){"avx2 x4", kf_avx2_batch, kf_avx2_batch12, kf_avx2_chain, kf_avx2_chain12, 4}; + } +#endif +#if (defined(__x86_64__) || defined(_M_X64) || defined(__i386__)) && !defined(KECCAK_FAST_NO_AVX512) + if (__builtin_cpu_supports("avx512f")) { + rows[nr++] = (row){"avx512 x8", kf_avx512_batch, kf_avx512_batch12, kf_avx512_chain, kf_avx512_chain12, 8}; + } +#endif +#if defined(__aarch64__) && !defined(KECCAK_FAST_NO_SHA3) + if (kf_armsha3_available()) { + rows[nr++] = (row){"arm-sha3 x2", kf_armsha3_batch, kf_armsha3_batch12, kf_armsha3_chain, kf_armsha3_chain12, 2}; + } +#endif + + printf("sfinx WOTS chain microbenchmark\n"); + printf("# one subtree of chains, 256 steps, best of %u\n", reps); + printf("# plain: the untweaked batch loop this replaced\n"); + printf("# glue: the tweak over the batch API, rebuilding records each step\n"); + printf("# fused: the chain kernel\n\n"); + + for (size_t h = 0; h < 4; h++) { + sfinx_hash hash = hashes[h]; + size_t len = sfinx_hash_len(hash); + size_t c = len + 2; + size_t k = _sfinx_kid_len(hash); + size_t tail_len = k + 1; + size_t reclen = len + k + 2; + size_t count = 256 * c; + size_t total = count * 256; + uint8_t *x = malloc(count * len); + uint8_t *seedx = malloc(count * len); + uint8_t *tails = malloc(count * tail_len); + uint8_t *recs = malloc(count * reclen); + uint8_t kid[SFINX_HASH_LEN_MAX]; + + if (!x || !seedx || !tails || !recs) { + fprintf(stderr, "out of memory\n"); + return 1; + } + for (size_t i = 0; i < count * len; i++) { + seedx[i] = (uint8_t)(i * 31 + 7); + } + _sfinx_kid(hash, (const uint8_t *)"\x01\x0a", 2, kid); + for (size_t r = 0; r < count; r++) { + memcpy(tails + r * tail_len, kid, k); + tails[r * tail_len + k] = (uint8_t)(r % c); + memcpy(recs + r * reclen + len, kid, k); + recs[r * reclen + len + k] = (uint8_t)(r % c); + } + + printf("%s, %zu chains x 256 steps\n", sizes[h], count); + printf(" %-12s %10s %10s %10s\n", "backend", "plain", "glue", "fused"); + printf(" %-12s %10s %10s %10s\n", "", "Mh/s", "Mh/s", "Mh/s"); + + for (int i = 0; i < nr; i++) { + double best_plain = -1.0, best_glue = -1.0, best_fused = -1.0; + + kf_batch_perm = rows[i].perm; + kf_batch_perm12 = rows[i].perm12; + kf_batch_lanes = rows[i].lanes; + kf_chain_kernel = rows[i].chain; + kf_chain_kernel12 = rows[i].chain12; + kf_chain_lanes = rows[i].lanes; + + for (unsigned rep = 0; rep < reps; rep++) { + uint64_t t0; + double dt; + + memcpy(x, seedx, count * len); + t0 = now_ns(); + for (uint32_t step = 0; step < 256u; step++) { + _sfinx_hash_batch(hash, count, x, len, x, len); + } + dt = mhs(now_ns() - t0, total); + if (best_plain < 0.0 || dt > best_plain) best_plain = dt; + + memcpy(x, seedx, count * len); + t0 = now_ns(); + for (uint32_t step = 0; step < 256u; step++) { + for (size_t r = 0; r < count; r++) { + memcpy(recs + r * reclen, x + r * len, len); + recs[r * reclen + len + k + 1] = (uint8_t)step; + } + _sfinx_hash_batch(hash, count, recs, reclen, x, len); + } + dt = mhs(now_ns() - t0, total); + if (best_glue < 0.0 || dt > best_glue) best_glue = dt; + + memcpy(x, seedx, count * len); + t0 = now_ns(); + _sfinx_chain_batch(hash, count, x, tails, tail_len, 0, 256); + dt = mhs(now_ns() - t0, total); + if (best_fused < 0.0 || dt > best_fused) best_fused = dt; + } + + printf(" %-12s", rows[i].label); + cell(best_plain); + cell(best_glue); + cell(best_fused); + printf("\n"); + } + printf("\n"); + + free(x); + free(seedx); + free(tails); + free(recs); + } + + return 0; +} diff --git a/test/ref/sfinx_ref.c b/test/ref/sfinx_ref.c @@ -115,43 +115,74 @@ static void ref_digits(int bits, const uint8_t *value, uint8_t *out) { out[len + 1] = (uint8_t)(checksum & 0xff); } -static void ref_chain(int bits, uint8_t *node, uint32_t steps) { +// Spell the rate out rather than reusing the library's folded constant +static size_t ref_kid_len(int bits) { + size_t len = ref_len(bits); + size_t rate = 200 - 2 * len; + size_t room = rate - 1 - len - 2; + return len < room ? len : room; +} + +static void ref_kid(int bits, const uint8_t *suffix, size_t suffix_len, uint8_t *out) { + uint8_t full[REF_LEN_MAX]; + size_t k = ref_kid_len(bits); + ref_sha3(bits, suffix, suffix_len, full); + for (size_t i = 0; i < k; i++) { + out[i] = full[i]; + } +} + +static void ref_chain(int bits, uint8_t *node, const uint8_t *kid, uint8_t index, uint8_t from, uint32_t steps) { size_t len = ref_len(bits); - uint8_t next[REF_LEN_MAX]; - for (uint32_t i = 0; i < steps; i++) { - ref_sha3(bits, node, len, next); - memcpy(node, next, len); + size_t k = ref_kid_len(bits); + uint8_t blk[2 * REF_LEN_MAX + 2]; + for (uint32_t s = 0; s < steps; s++) { + size_t at = 0; + for (size_t i = 0; i < len; i++) { + blk[at++] = node[i]; + } + for (size_t i = 0; i < k; i++) { + blk[at++] = kid[i]; + } + blk[at++] = index; + blk[at++] = (uint8_t)(from + s); + ref_sha3(bits, blk, at, node); } } -static void ref_pub(int bits, const uint8_t *key, size_t key_len, uint8_t *out) { +static void ref_pub(int bits, const uint8_t *key, size_t key_len, size_t seed_len, uint8_t *out) { size_t len = ref_len(bits); uint8_t ends[REF_WOTS_MAX]; + uint8_t kid[REF_LEN_MAX]; ref_pre(bits, key, key_len, ends); + ref_kid(bits, key + seed_len, key_len - seed_len, kid); for (size_t i = 0; i < len + 2; i++) { - ref_chain(bits, ends + i * len, 256); + ref_chain(bits, ends + i * len, kid, (uint8_t)i, 0, 256); } ref_sha3(bits, ends, (len + 2) * len, out); } -static void ref_wots_sign(int bits, const uint8_t *key, size_t key_len, const uint8_t *value, uint8_t *proof) { +static void ref_wots_sign(int bits, const uint8_t *key, size_t key_len, size_t seed_len, const uint8_t *value, + uint8_t *proof) { size_t len = ref_len(bits); uint8_t digits[REF_DIGITS_MAX]; + uint8_t kid[REF_LEN_MAX]; ref_pre(bits, key, key_len, proof); ref_digits(bits, value, digits); + ref_kid(bits, key + seed_len, key_len - seed_len, kid); for (size_t i = 0; i < len + 2; i++) { - ref_chain(bits, proof + i * len, digits[i]); + ref_chain(bits, proof + i * len, kid, (uint8_t)i, 0, digits[i]); } } -static void ref_wots_rebuild(int bits, const uint8_t *value, const uint8_t *proof, uint8_t *out) { +static void ref_wots_rebuild(int bits, const uint8_t *value, const uint8_t *proof, const uint8_t *kid, uint8_t *out) { size_t len = ref_len(bits); uint8_t digits[REF_DIGITS_MAX]; uint8_t ends[REF_WOTS_MAX]; ref_digits(bits, value, digits); for (size_t i = 0; i < len + 2; i++) { memcpy(ends + i * len, proof + i * len, len); - ref_chain(bits, ends + i * len, 256 - digits[i]); + ref_chain(bits, ends + i * len, kid, (uint8_t)i, digits[i], 256 - digits[i]); } ref_sha3(bits, ends, (len + 2) * len, out); } @@ -175,7 +206,7 @@ static void ref_subtree(int bits, const uint8_t *seed, size_t seed_len, const ui } for (uint32_t i = 0; i < 256; i++) { key[key_len - 1] = (uint8_t)i; - ref_pub(bits, key, key_len, leaves + (size_t)i * len); + ref_pub(bits, key, key_len, seed_len, leaves + (size_t)i * len); } for (uint8_t depth = 0; depth < 8; depth++) { uint8_t bitlen = (uint8_t)(7 - depth); @@ -210,7 +241,7 @@ static size_t ref_signature_len(int bits, size_t path_len) { } static void ref_single_pub(int bits, const uint8_t *seed, size_t seed_len, uint8_t *out) { - ref_pub(bits, seed, seed_len, out); + ref_pub(bits, seed, seed_len, seed_len, out); } static void ref_single_sign(int bits, const uint8_t *seed, size_t seed_len, const uint8_t *msg, size_t msg_len, @@ -220,7 +251,7 @@ static void ref_single_sign(int bits, const uint8_t *seed, size_t seed_len, cons ref_sha3(bits, msg, msg_len, org); ref_e4m4_encode(0, sig); ref_e4m4_encode((uint32_t)len, sig + 1); - ref_wots_sign(bits, seed, seed_len, org, sig + 2); + ref_wots_sign(bits, seed, seed_len, seed_len, org, sig + 2); } static void ref_tree_pub(int bits, const uint8_t *seed, size_t seed_len, size_t path_len, uint8_t *out) { @@ -271,7 +302,7 @@ static void ref_tree_sign(int bits, const uint8_t *seed, size_t seed_len, const for (size_t k = path_len; k >= 1; k--) { ref_subtree(bits, seed, seed_len, npath, k, npath[k], root, auth); - ref_wots_sign(bits, key, seed_len + k + 1, value, sig + at); + ref_wots_sign(bits, key, seed_len + k + 1, seed_len, value, sig + at); at += c * len; for (size_t i = 0; i < 8 * len; i++) { sig[at++] = auth[i]; @@ -322,8 +353,10 @@ static int ref_verify(const uint8_t *pub, size_t pub_len, const uint8_t *msg, si at = 2 + path_len; if (path_len == 0) { + uint8_t kid[REF_LEN_MAX]; ref_sha3(bits, msg, msg_len, value); - ref_wots_rebuild(bits, value, sig + at, leaf); + ref_kid(bits, NULL, 0, kid); + ref_wots_rebuild(bits, value, sig + at, kid, leaf); return memcmp(leaf, pub, len) == 0; } @@ -337,7 +370,9 @@ static int ref_verify(const uint8_t *pub, size_t pub_len, const uint8_t *msg, si free(joined); for (size_t k = path_len; k >= 1; k--) { - ref_wots_rebuild(bits, value, sig + at, leaf); + uint8_t kid[REF_LEN_MAX]; + ref_kid(bits, sig, k + 1, kid); + ref_wots_rebuild(bits, value, sig + at, kid, leaf); at += c * len; pos = sig[k]; for (size_t i = 0; i < len; i++) { diff --git a/test/vectors/sig-L28-N0.hex b/test/vectors/sig-L28-N0.hex @@ -1 +1 @@ -001ca124a58318de720c65f8844063941528d3393305b2ff64774622bc237d4d9c239e6fccce99281ce2ef46bacd704c466d9edd6179c7b3d54d249e0a3f3bf2a4d0077b403f848f0454285dc703645299ebd3eeac440cc04fa5ce1f7350f3bdc87cd8c3b4e92647a3f058d0b59c5988aeeb7f0eec0f098afe1dd2f563b130c20a4fdb0cdd5bfd672f3455d7c5ee2b5ad7cb1e75899d4f791e8c62ce2e41e66d0ab93eba053bed5dfbf82de32811233330539056f58947943661e8d8e8b18e1ff4f004ebe21aadd675e23b25875b10e43e5d52ec4733a7b5e2ff1addb5ea9804c300b0ae4be03be43ee01c2c6433bf23e53fe72b87ad1b0f943a1a9f63560a1bec31643b7e6e42dc07063e2daab649bedc44e3c2546f3f6617d7da9f208a37d24fc3175dc7c00f14252879e717cb38ce9434c876b5c33b0584cbcfc4b18f15a72750fc305003767c96b4f08ec63aee830c5847c23e2f84cfa89a81914b59de0696156e0ba3c9dd5d5507181dedd72f4428a3d324b30719cfdd01e9acc40f27174295870b08205c91eccd344d159d15dc81ad23a51bb028d884e5fe63b8e1bace822f9b286e48103fa17a2f45fda481f19b9e73d68510c85d8ef8f04be8962539f84f193660ede7a07ca96e96b5a09d6b471e2925d7a65e242bb33160d84bb4639ce4bb57fcf63d8e7bb0af0670de17794eefc6e1b382d76e5c53066d3dc11de7ee1171cc34946e645a7af0c2ae0011e8f5c8ad956cff05c6ce9748e39611dd102610ed3731df707e06aac7dfdb9af959337080be2a167114792c2d83c9567b3cabd30047c1caaa03ee8c66d87ba53a97eceafe430a54cebca6fa75bd798f04256e15db236b65bc227f8636077691d435ff1d7a19ee8136fc1c589d1b5fc78503a2e985231a9d05b987cc08220d625027328464bb043497b2239b4078f2be7d2185efd6308e7784e2884462741a874a1fbf2c651edfdefdbd73d7f9b8a7353a98eec64a4dc5886fb5d0b2420b2e2830e7949b13f0774fb2949b3973e0d603cd98207802cfaec49510710664ef38a6df2b3679ba9e48aa0a6485f60206493b4fab7a6346219e900d43bf9768617b16c15f4bee8610a8d4c55a66543199699216a30ae04d26af56b3bba890ae718049f960ae8d6661e355cf2845827e23afb97d070fc9c604f20396eb2958 +001cf308be2035d5bf230f503029eafbffec575bd64d00523df80185c849ce70bdbbc34e265aa1e9031c4a04691396a0c1530bfba20e366ca710bf73a4b504ed90389e8da7a9593736200ba0a71e1a7d3186bbf4ade67ec622e6a7d6eb41b70f7e235a8e8e65232756bb5b70fce1c843b222dd1e3d8c884b3f11d19694367b54433275fc56e43cb28abd21c37a3cfd4c8305e838dbd1632d1f55e99289ffd823c23f1af8d2316ebb253255cf121ab4fb73cd3d61755a785bc37ce954866f0b46e3cde8738d6b698faba2ad2861d0e51d0952b10eadf440c491b969d3824580b709f9277087f5a2a92189c152484c85d5ad248a529e3636084cb6d45f03604ac61f4093c445748ca9af6c5c0285d93f9096b4f72929995243657745771dbb30a7ea79ce2b4b167f774798937052ff148ea933d7d18e78255d8b9a688583464efb6b4e11423cb4f41c5a9b49458ef8edff2495457292b3afa02dca6c8d2156b81f087868d4b498978bfcc3a7e28cb9fe44c6cebc2792aa0fcdbabd6e1fbbd8b7a0fc6b8b17bf3d4330dffa4f5c6e6853bd4a4397d02543006c0e5a64cf0e1c091de5113f298cc562826f7f5905e95f7b227ef5c17d6a906668f6a189328c2236fd4fe8f451a27097f950977c75b69a29696e30766f3e04c289ce5a1bacde20df1f8d32afc9affa31522014d835f0b9eccc27556ec7b5d4c60a288ad1dfebaa2baff933c72ba01f03507466464613ebb80d5f8614f5e27b75d01201dc8cdcd9228629013b201b32a151b5b37ac0ff1236fc01a74fd5ce405d4c1c61dd250bec0be0adde48975a9a69459cc51003cbe0bcfec48e91d46d32024178b890348673c6a2645505d20b0257942d3b8a8f7c7d3a681e669e99d465a7b6f715aa686b6aa78b1424dece10b52313b1b5fa7d920ad330a4104b345ace7ecc47287efd9205c7488d1f7bf0460991c7a27e5e9e1b5c77cb0fa4b15461ea29ff0f911ea0eef5a210df6b9dbb5698a1a9ea26fd20f5c2d1f2c8e57e6e552460d97ac70cdd62f29457fa49c0351ff8deb9e3883778ad95929f27ff4411ff3c4fcf7eac86b21b4556c1b56d215a9488564feb208429320eee8036d7e96c259e8cfb008c9acf4db5627ae022c947137e628cce47409a9b9adecda1483e5dc7eaacbe1c3e6b2dfadaa22f1dcee70442d9203fa183 diff --git a/test/vectors/sig-L28-N1.hex b/test/vectors/sig-L28-N1.hex @@ -1 +1 @@ -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 diff --git a/test/vectors/sig-L32-N0.hex b/test/vectors/sig-L32-N0.hex @@ -1 +1 @@ -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 diff --git a/test/vectors/sig-L32-N1.hex b/test/vectors/sig-L32-N1.hex @@ -1 +1 @@ -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 diff --git a/test/vectors/sig-L32-N2.hex b/test/vectors/sig-L32-N2.hex @@ -1 +1 @@ -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 diff --git a/test/vectors/sig-L48-N0.hex b/test/vectors/sig-L48-N0.hex @@ -1 +1 @@ -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 diff --git a/test/vectors/sig-L48-N1.hex b/test/vectors/sig-L48-N1.hex @@ -1 +1 @@ -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 +010a2892554169286c7e336616701f5a30490765a68847ba39addae541c93c5d611d1c0e84774a7a6ab25ff327de1fb528263e9f8d404646685e1385b7ffc2b5fb413e6428c45f20b5180338461a194e8151d4ea8655d7bb91f59ced03a7b0f53990b236495241c7aa17e780a7805847854cc05c5c1a0563685d1e21993d130e39d805a71a985da4b2b595eb0add6bdd2accac17276a1c41ea89f484e10cda6c1b4ac58e55486bb4f5c71fbdddbb73e54dbff38d5bac7c43fadd89b7728451b4cf8ccbcc20bbad7735f6196369ea06308f074788cbbb194fabb62fb7f4c7af9c39d6b1e15e0c9cf4e1a12e395b552d10a78396a83df89d676055c7b98b5ba59bad2b9119ff82013d845ab66b2973967f3c6cc2bcde8f65d13fda34fd0d8abf2e1eaeceba3d6ef51b3a98c5e7f20b76be6d2ab1323a81a68531f43b977f69e3f6f0341ad6b8264ef6c84c15aecf59841ce698c3484224bc40adf75032b30ec1aa5ad73b74a5d36e0c50c5e0c341952aca136204601620b9a1b5f24485600885d8b0fac7a6a1eb16fb06ce488e0cb5850ecdfc38e7804b508e5ee1c9369b221f838de9f25de7f2335ec1419e29aa4652e83f39457c8244ad10e4f03a9cac7a9bd415ca1447050714bacc7561085410fefc35358c10483a5dd4494bed6d9728d5e24e88490eccd923aaaa40f01329370e48974ed8390907e953b4f3bf9bd9219b7fa057b19255f96e1eacef3044a95d276fbaeb28fa17652b5eca3a89431d13fd077d684aceea13151c76475530bef85bba087fc2aec51a57ba1d1114c18b259de4c8e3b4f79ab947bfd47a2d3aee5c5a30c986cdf85f4aa30cd16a0e5b3c308a04607d3a579a3bc7944863cbe7d14bc25238d0808707127ad3cada6edadf49382989902888de5ff5c591c280dfc5a1920f50e09dad6bdd54f8f9e3f1a8565488532595ea25f7d53bf29d606bc1c728bcaa62848b662cccb2e9931e2e294390be7e3430f8f51e715cf1c02a906d24cc839334243faa5ce94bae549fa2b513b9bbde2190da363b71cb650750436103db65faa4e0e2d75ef722d5fd6a521ac3c35bda15aef8a26b2475963866bc709e994d0ba9f2c5cdde17a8c1e053930c06f7644e6120ed91f9742aebc697d3e2ac2703f0d1c21d7cab3628501b99f715375a1794c004d4abc66b0088590dad664e36c976ac2b2ebe721dbcccbe113a87ed85aaeb6c61890d447b6214f02d2a1cdbde9a203f42050d671a16facda236083614a72fccba9ae0e3afbcda69e70961681183d45a75b4e0f5f2a453b526497aa948d12dcda6274b94d36c35530ed7016f5e2cf2af87e66294993f09cef69f2b312594c396d66c75976a1d0f1c0fd11dbdb1a399090c85d3e1acf10f2bf72b591e3b5b2b59044d12b5ffe0903cd23a84dff3cdd62c950356cd0ddc17084ab1eaf1badb73af158980ac9b40f65770060fd04ea0563ec6de8308ce72fff6ba01d3d4259db32a123c427714e5b4a1a58fab0b919c7200e00538cb061b5591da8b601fd777a11f8c1a2fb4667f75e129d5aa22ec1152e0e61157afed129c252e0567a3bfe9ef52ef2955b3eda51e1aa3a9e818a9110cad378865a1933d709638ed6900a2984cb0b29da058405b2efa3722eb4db56b0170bac1413b286409af92a73233d0ea4f3767da4615b871a693aa83cabc3f446d8fe1cecf48934baa2e6502aa9a40d9d9d487e80d05f92334beab57dad362534bf6be1df51d661d06f8bd19b9d71830a08f19e96938d533c8dfd20c7aee08a9d20c24d54a4f0dba2771669c010e1c7cf5cbf0a75ef84fef0361877cffe665b70715610bbb9b6a1a2a310507cfc8667b9b9ae6177a1333a758bd7d49a39d9fefc12431a51d7a3288593954c6c51b10598e27b2ed290b99630a7ab9bf4eed2ba8a6eee7a78dc6500095d40111dd1158a5d5c9dd89d3d64db6a48d1d3d5be49160a66642766858dde7ee0026ea39a8cc910399171edaded293a73ef36b71727bc77f7531a0ec5fd09ec77dd00e44a34803ec5e54b4e6a6da559351d0404c2efe087e33a604494eb97a65b53b524e367bc22d1a333bb2566e818b4fcc851e8c5507bfde26d732f349b9c77fc47cc46831c61b60314dbe8971539021ceea64cff7258a3e9064dab019fc4751397fa398ee3f5f9a4b23366176269de97a9aebd22c7479faad9c6283a684de4135f69d403a6f7d2c198411b8c233503678263d6a94edb09023f217560b51d062e72c025b3fd1d98e1ca84854ba56ae9350c8513a84b4d04646068493e6180e382327c689269f7b942ddbec8764aa0eb4dec0dfba8252236d070c739d292598331659c0cc9e629c2699a639ecd6add1c9ca0b87ba92ec4cef8ab5bb162bf35b48374a922a4557bf1573c1bac17c5c797e6439aaeb071248da29fa4bce0221da336681eb17a6bf0da81896f6bd606eca86d58bc27813cae9d30cefc829c483dcce143a4cc483c4f560396478b3ed36bfd14bc98363c79c673dd1cd8b4ca3a724a76bd1cb2a5f65a7821dc1b9bdae5e6e136f902160565672b55d1b6a42ae834314cb05f94557622bd9226025e369456bfef69ed203b360cc8a82073bf1b8690e3ffa7d22f985935ffd8f57fddeb94c12bac4643b56e668cff740cb8cbc825a999f8e393b9a2298add11cb8526eede065d5c5f615bc98eb422d256c8c6c93d8c5063303763a515f00db43fd20c829d8c5f3bfc6a3f72fc0b82e48f804684a4cff1dcbb9fd8488ed2e60116894f252e808b675eb3e5795724cc89cc67da388a1456a16e4e5f653f3535910d067b2f2ad838e54e36942af8facf8878f4cf564c96c1d09f72e75b53853aea2f4d9d2d5d49f192ff48d6ba7429e8f38b6771f8cbe397adf098e1c46b180682c5ee333bf0a7c55747c75a2acafe58a146a6f211173ec2bff91f4e6ab1a3202ff9c580434f570c8ba982bf44b9d63291515bf6397af0aab9a9add4f60f6326230a2bfed5969157dd0bde6e2464a4f90769bc7dfb6b9378f8b42074c1f83bd5b406b83f91d498489a66f6c874246333048cbf33c6ea0bd4a5c36a2ae6b612954d4dc7f2f5ec7aebd513b5ac779aa60f001f5c834de4adaed4a3d3db2a80d9caaa19cf04a3b60a3dbf31d8173dd31f623a1f81ef63fa088286395a0602bdc301328add7fc757e7adb0299d3481193d324e7d12f2cee819773ca225b80c23755acebc74fc58eaafc2100582c38ae3abbb81dde2f819fd4a09cc34bb22fcdde4b5f0c2472a06eeb98e2a3018bfebd5e73cc2cba350baa4bc57fee3fd2081413a1e156aa02089524f960a576cd444a5eb04681f713f0cff71d3c694caeccca8b084d602f722b644239d10e54af9436e3a14a4cfe503f9309094790772dfdd774c26c51795ff86f7a2a1bc61bd6313e860482a154476b08bfc692c6ea3d3e0e972078a9cab3c979be222760cf3faa52ac0051cbde7f5569a24233483b6bf820b6377546f64828ec5e3d1b31208428b5922117a99a5bca2805af0bf57d7d0611debfc4dcf4e7f61e26f835d656a028e34410d7439dba0b02777c01cdebe1df0533b27ce58a24c983605abb3c4fecbeead0b1ba5d6d16466c3bbbd7171681e308385d898a1bd16714294b237df0e79484095ce07d1b63c20e57d740c8bbe6ed63f7eb193b354a00cb2bb7839d3001008f11d4b6c6d9735a541ec3a33f5a012c0f61a84b663763bfbe8c7f95947342b062f8115d287c40d9ec92d8d64dd42a453a020150ff14029714969aa5b3c4d52e6c957faa8b6c2d02011a3162321413d8cf875d675c05daf76b03088583ae38397db7911ca22847ce1224f680bde1656f01e1c06a7beff7a865098b2ca8fdd1577a09e014a245b363362e3fbd770c102529ea2ffb4181b4f06e859de83be5b25b940a59f62f0e298a8881dd02ae4ab06a32732f2e89a5 diff --git a/test/vectors/sig-L64-N0.hex b/test/vectors/sig-L64-N0.hex @@ -1 +1 @@ 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 +003037c0ed5ad528473c07487c5353703318292eda9461e706f5612b7975932e4deaa143938479ce2538c92eb1759f398181abeb4ea4375585bc88cc50c92e27644d24d7502cfbf22f716df4e765892227fbef85b6b4859f454be1d38e8af2a44c7430830d760901dd3b9f0f54ba271d9ce86bb0ba798f03762633c83c9c3b33aab1f46d3004fc731a1572f4f44cf177cd680bc583dc0503dda53070eff5fb3ebc2d939af13e178505b6c0613028b09cb52561f2e0ed72f82e440b906d901a4e822945be32b67935d45e9d1c33634622ea8fe3a460c0737e9e678356bd961891b64b7a20586483b069a4a6f38e3bc23440934afea7fd0e6770f5a5e319aaf7862292a12ecf3f43dfdf1e05675f98e71bd99bbfea400e49fd77ac897733b842ed8b80def719ba83483849ec33b086fbd1d045afe9aef3bb6cd76dc93fcf804141ff11b99e552bc1f86eb47c676a2f5a95ba65194c4d4c25a3b2f1ad41950ab1174e744eadc89133392800ea321ff84d6d60032fe2a1218c89e329414e043b6c862906b892d1e999ca7901ef79b98f05aaa3e56251fcd30b2ae6801141551345997eef9801297ed239c94e354d53173294d1e9e0d5957fd5f8173182c72c54b9b04aa346167e21d0a2b891624ef9fd50c04cbe0cd744c1f3cc25576ac70e0d265cd8795b94f7eee0d5353241076b8b438d893d2feef602954589fb4eda03238f54196c09f7ed642d20d093e183b6ffa53108531b044673ac0f6a1e5d03c186000df77bf7169d61da96e5999678bc4d3c15defbc2eaf1d641092de948ab39978e0fae5ef6fd0e0ef188d5036190edb43a656e6380ec6cbdf40b63bd9b9741a93a01c2982a26a734b34d0d8866ba8177b34aebaaed5520ba9c45f09a919a4b12828441021d5b2d97409d35c3629bc429fef8961fbc871789e215e7a438f0fbf2ff852f6d089e203a295af96ce87c7f5c530f07df494b0eaf45d61962945e2d1c694f4f5db236b205560be5b63ffe51893fc54b35500e24fff492aafe78de769452195a775c0543bbdbc368302781d8801881ad677a092a4e2317504ccd30e1b18e657434ffe164136ea304269a793476ec2619ae4b16a806eea17231e434865ec3418eb0532cf24d0636a3ca08c59ff7fa7bf1400634112f55fda704271949faca1c935d74e3d4f0d8b6c5d5c5ad293a6f1b914daf98d84ea9b1844ae833655b698518e74ea5fdef17fcaa8f8f470c293955c5bd35b473c9e2794e7986910cebc1c5365bffe41d28877a79bd827dd4c7eb77d5833547a02fa5e48ed183b4fe8ad9df127100555a92a1a4426da5a7aabc8276be456c0eaf95bd8c6ffc4bd33351b3f3fd966aa3ddc32a4f2bc1c6ab149ca306cba6f6167d3b4f9f9b1445aecde6a0893b5ef3d982c9aeadd4db12b525f6c473ece312a36d4c5015f2666db239401bc47aa09842de18fd359e5ebdd495f7a4342bd5a4350bcea2916c27a1c695d418dbf58784a45431aa7f9ed9188a9ddf79435423827242671cef7bfd6a5689c79a6efac7963b40d665a82c586a0d58618d1d42a88ad4cc13ba54e37b0bffdeb0c2af0c3fe582e6a21d86468d109ca7acd06c41e5ec622b81bd8b130dec36793bb95436bf7a67ba671821aaaeadc77bd47087a3793bfbcd4212674c9fd677cb1003a091a91b4731034b83e807e0d3432382540c7b4ffa0846ee1af675720863b9480f8b1800a98f263629e0fef3887fd60ef1f943b986cf0188dd2d9148239bb20734d0b74f429ca769820d2bf5499daea8e54486f5fdde08af058b0f1fd8293885e8f9748d6bc26e98fb5bbd206c72987a42078683e1838c54cd9f454c0a695bca7f3b8bf6e4e39d641533c530413b553090b92f7d3f928c5cb9d4945744b7c2d9ca69592135e470654f8429d83991379cbb6c48db273ee2fecbf88529e437b6ef59d60a2d8797aeb6f0b086b2a76a18f7792fb51c2effa1342d63d15ddce598cabbbe2f62e1da1ad9ca23aa1cabd6c912773b719283d7ff4cffe307a18881cc7184cb5e43cc0826ddd013c679d4a8888821b393f51dc9364fdced7216f8e7ec63c401a675ca1b5e032ead23905bb3016efb822c005c4fbebdbe9724c0b7b7d345aeb12913f332f70e39153415abdb370afd14f2fc9c82f381076627972d4f06a5f28f83aa64a0ef88db2a9c7a5f1376738f3b386b78662f8e2ac1e514c0da57f14e8d7bf6f1e10bcd3b6a7caf6b34ae1368cbd9becb9de053557bdd1cca92dcc0cd8fe6926de825e3e1aa73ba1af9570015ac2ca337469eee7186d8df94832934f5dcb6aa78257b9d6fc3c5460a357497ab32aeb1e7a7431f062a59cba513fd04c7b14215b354fd1ed450106dd46659c60e1326fe2f1dd93e460c8b6cfff3490ff76b9fd755aea2b9af5d1db91b03ff2c6bf020ca7890577e4ee94be4a3c24caf0ba42707a65d50ffe7767a44573f3fa3d12e02c625baf9e5c0e3d1d2f2ef8550f32b55621e80a64f13f3eea8b16764d8bc1695038c9ad522056211d257082434718bfcbe32cd096c4c29fb90dc61ed618185ac0ba97fdb80ab0092078ec66f517cbd2232385040491dacb83397234a1f6dd465cfcf5c7f9c21a60c52c4705e10e4e9cade1836737e653692e17211efbfdb0a06b92b2564d66b05915bc24605272588a854d43e296fca85113e020db0a47a76b3001d874779790ac42d8edc3b166a03404791860856923f7d3c6bcf761d7b26499b1a1c99cdc6bc21275d67b295ce2a745b3c8d700252d368ddf449cb4de57686907fe9cd321d3e336d4568212f911a25d55ab3267ae5327be776920800f7b703aff4aaa35f93e2ddeb2692ecf7978c544b7eb4e2302923c32958769cfdb60f5cd8abf7e38d5aef6bdada775306c78628530f413cd5693f5ea55bb680d049672546dab8a6a4bdc95e11bc85966178c4e0189801ba8b7844c04f79f5efd34cadf6c34d59d972966c9f2fd16ef01a7522d2818ef0c61bde3d2eb56d4b567eb173f3571824f6c7416dfc36a0a40a301964ab36f9bd5a113ce9c73d7fa7e52490ffbb5c21fe499f45440615805fbdcce9e1d67565838987528fc990a2c1cfac75f938f644a35fba9c8ae3cb1a6bb4bea70d7ff1f964148755b8de89e30e3958369bd55c8f29832c001c47c21ea04c20113216d2eda4e26682de1ebf16e7c765bff4342fa7323fd9f7817a834bd0a5853c082e9ae113347b8ffb826f5356ca055b645d83d17de6bcbe2be267f1b3f2a5409344bfb884e30f3e6f41081b12dac4775e0be653a351e4b1e95ba4cdcc754f19def050ff7d2d05cd9fa4b63dfe5213a437f7a8173437c35fe7caf7ccdfe4da45e820d24f015c253ca97d216c7ad258a99704af4ec5fcf8675e963340c8caf8c8d01d6a4aaf520bb455a030b8e396e6eb7dd9e0b0791332017677b14b4db64ee333c8aa1382f45504ba485e75d8e4c52fdab931052b5bb13bf81120f7cd1344c2f3ebc7f7008f0f717b52222830068d687972e24601ff523bf0309881e2dc0a7233088f330e202d0cdf3ade0fab7f2aa5c4bcf0e7f5d0f9727d3fbe965aeb39784942cef5805f4b1efa5c0e9f465f086c83eaaa645ed8ccf546fa4bc1addccc7a2f9d6d5ce5a1effd93bb05ced4ff0239c2eab084e1872f90e8852647c0e9527ee05ff58ff83b67e2aa94fcc9180dcc401a264695deb8afc4f5012e9853646dc22831ae115a850080f2736240877e8cfdcc969dbfffef623180ee805ad309d797d81ffe137407e2948157b2502c3e318ec4ed588235e2e50cc84e010a6e79c13cb78d0e24aa55a444b253c9630d908b111fa56149fd3665f7fa49e3ea6357ce6b948027ac034bce479d572c5af8c5fbbb807d942c4a33b98369a36ca01d4e51630a8e09aed0eb59b85310d91e8a7200e58216a44d80b2a253d9f532b0345a8360b1299bda5a663ef0e5ddc84b580f79a180caeb6d132d9d83650b8a64496c4a0ee260ae01c9f7601dff4e4cac06dac34491231cea194300bf76ded7963e3d31742190ee8fbfc48d4524532e8fd22d757ef91f276bb1f9f43d8ffa4fa4ba1c208e396076b35389a3ed31b6d3397afb2cfb7be90350812f48080c867c60d0081aa520f68c07e7345d97443204850653390fe3dfd7e5407bfc8d16d428936ec4778cdcc5d80ba5cd0b94edd2a8e5c655f4fcc6db985bb6b06c088f75521ca8b54055b0e59eb2a5a2a2237b2b361c53183cade5189b6f7e28346a7b3842750536d274c924f9f2e46b0dd5a64e4f8ac1cc3081a34f3eba11940c6f1f5815f154d9d474f8c438986d90f755a4d544cafd7c000b7f7b0d71b3ee57654d147b961af9a77ed5821813a5c6e41aed149f40e9afa25e30b807ee0f2726d764f9d34d62da9314812f6b194d663d25c474f446aef63834940a675e82a65fc77a7fa7016030f621b86a54e3d175fa0fb5edaa8fa648b0bed11c1e3083e2ee1d856214cdee08bf5b70409503243481968c9e97407a896ea348c2370dac44adad3e05bc530b46b8ace0c89ac17c3437e51edaed9d0ba5ce2964bc75dd1246cbc5f8ebbfaed00710912b24b1357b45180993e012f7fed5c3bd36bb044def92ce9fffbc8f440c141d2ca98683e9d407f123c1b9cb12f92cd867152c101d6a050bdc7d82afb418f29b2466018b13bd33c058d6a43f9d028f74e8577872a1212e794f32b5f207b29859aafd66a7294b37a51d184207ef5157e76fca5c4d70f3210ac154d1ece3f14b686eeed218040d9ee618d36f72c594f1e231f0bd30dbf98738bff2905ab5b6121200ccabebcf6ef5f9302685e2e4715f5e6aec205c6c4bcd1874cc49feb6a805e8b208d2fba1752ef625f2da3688e914602e08e7fcf937528dfd1011e13d71c82d1948760702a8e18f074c74026b4e36b69f84783a929d4e396c2ef785e165803992de6b8f7275399dc665b756640ea57a5f4e939b965f4ca20f04cae9178e43b6e4184ad6b92ce9cea5a5d3c2f2d72d85e184c725137fe36d4d53ea8df00da8a18a4fe0d8a1b1730b4474241c524168bc7e425398121996a9b1d8c79980e584edd4c5e1ad1463e86749e75262477cef0667baf3c0ab7643e9b9fd977ea6961ee17385f2156693346d9184191e98182c6bd25f8d62af91db0bd0e074d4e936b8bfbe3451fe8ed0973b3d2bdface6903fc85e69422fece713e7533a397b4f0368286ba6959b3bae138b23917f5340060c01d915a7d16bd485bac562d64faac41319e644566e59fbc661c9f714306e44fd92785478ee48a318ce50acf28d936e0988654cfd870bc5bf2e4576a7d264eea6e98c2496625989f19b3689b55a973608d472768e4269334b306fa5eaf0ad3fa1da56a2d4efadd8852feb28a9141123a2fac7d63bdd0fec7de7cfa46277bc17ead4b573a32c5ed52a2d8cb6cf505e746be67ef8b4a60767547ce7d1353253ab00ebd293e026b206b569bdc9efe0cdd529cddbd9de6d5db4562234b12949c29b266eb0ec3b60a38caabeb3f816545acacd3e353eb68539ce8e3c6159657e36d09aadfe70b56de66d7cd34730a0fb06ecc8756f7bfd3752ea526ebc21dc3323e52ed862a026c69c784a031634d810f738cd6a392cbb7f261d02c91d300cf81bf19668b844d771931235ffd7d8d406ff1764516d41056e264c5a1243d5e9aa93ee8f7159f3f86f43c08d48e986dc9ed11de1f4c3e906fd27a2cc2656a976ab5e3007e36f90cab9d293c7c26e460d1ad092f3a46e4db8c109885a8062c59da230299cea6f4dc0eeaeade5557088d5f506e8fe560cfc9ef1b74e5557f9e9eba8ef1f30f033490be91c4a85674d3c2ed12b871f0423cb607e2e83a7a6267a93afd43489a23263c18c9b5dc3647de2d5c99affaca73f293da1e185fa12821596fb6bae256d8dee59978daedd20075bf46a4866be258550cae033171d2d2aa0121d3f040191e6fa1de50067637a53320eda91af00c235aac4 diff --git a/test/vectors/sig-L64-N1.hex b/test/vectors/sig-L64-N1.hex @@ -1 +1 @@ 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 +010a30f243afb788d748576f74b5c4c1521ac5fb1c62d7f0418a412659a19aa349b908f1d18d73be96e1b882afbcc4a5c1bed2f36bdeea792d6a7e7725a6da8150c6181becdb68d4312c6f52f8300dbb2e01a88621b42bf06efe8ec30437b1c3438c4906e4600a2982bf0792bed4b8d7feb932ac2a640b16d76ed009565e5deac40f7c9671ca86f866e3e753c78bf9f640bc3f3aef0edc263d298e371e6d532c945a86e6104446ad5a1614cb6b5ea679c9bab9e4c92290b98a0be26c840a3f3874c852f0731cd8df9280e2b5541b946f01fea2acf7b392e6c7d893a122348b900950185fd83dd364eeca1ca04a7b005b9d589aa964adcf080b9a989b64107b842b957faf25a3517b6f5743a642ab9e535ad01d2d928e8d7b39a8fa524f0fc317d82dce46b2d91e622a22b18718769fd2047f5d3e2ae8c7fdbce4c587c18b3a1fc68c6caae43f443463f932c2c0bdcf1d26609de9d99bc093887d189abe4ddae536a4f63f107e072314c3c88e897150a5062a875fc59fb7a6cfd7f95e4ae4ebe33ffd4d225c13674ec457bfe5bfad6551b3e517ca9720a403ccec04dbfba0150ac300ff5b5b4153337be78498fc370d6ffc1f9cee9e24e5ee96a59b0ba509e713c4cc597d86e0c060df360428dac2aea08b9f9eaacc8573c31aafc5228701572f391a5dbeef55c824e9701032c1a903d740c92a24842a34e50887a1715da1f330a3e741abd767745403253ac681f517ad3a2f87725e4033c063d2542e710073f0d4884706ddb82bee43d9bd4d0afb7fde3d42d85fc7fb4cf61f428380d42e984e652c7b78192dcef1dc3893bd6ace1ec5547fedae9ce2840652a4e0c247d017a1ede2c70062e96b9efbb49becd55eee1e22cf638bf606b919ed7442072e79794bff69c84dfbf5d7a170989bd93d6d67db88588a1ec9ed63260fd4e9b643ea274606bfab83b75280cf4df80f130cee8121fc6a8061c9e60bf86c1a6aa5604690eea2a4f624b70dcf43ae1f8674fa04392f498cf2c34506d329622d4880465bdaca037a94ffe4ba55e3e76e49975b7525fd2ad4232254de315a198bd7fd1f17e9ec4f9e700c799da6396ae2e0d36b1d20c50680490a6339561cfa08f270ee17cb5f607be24989b6cd29d950e269dc99fb67f072cdcbeb051afbb7d0217561ea10aac7c8217f41f3dbe417df3a6376d01a572c99ef70b2d354dbcfe1ffa355596b7167ed3cdb979b9b1bdc8ea10996d1a75502f1ede3899998b9a66e000df32c247304b8204f4b62c9f03b52fdc6ff439aba543ccf4ed07beff8be5e3881f7a8989521cc23c2c1180b7f6a89328c21e8e8bf695e7cc9a3fcd869626cf6de2e1066ac3782f16c52c705b1c765308ad9d3b1dcf33e57e054cd0cba2975158f92a2d4c8bedde89f22889b4c11c0dd5bedc993ee5647ab66aedcb84ba4241d73000b5a81e76e68fb47500636aecc3a9f92f25d098e31a6a463710873677c35d8796a30b8ce45683df9447d3e155d5c0d1d4ba10b91ff63ad453ab5525239bcb81da24f051dc7c7fe89a3bb05cc9fbc10712e69e34a82e26e2e680e32be8f7b423e5b2017b43897b0bf942323ee9b636292e71454be227ebf253fdb9aca4d995b01fb451b2a5d4e50c180e520bc7419dc9c5490bbbb9dab978ac19185ff21543f538bc56bb578cbf014f795066df3276517d2f0932dbc2262549c15cdddadee0e095f13040085aa0e985f186a3c821c9c2b379e25597f301dc1488aa2ee911715684628dc8b19cc4302ee550bf3fdead9ccacf66ed6c03c9de601118f51943cf810959a63ea2d99ae858bdc94c4b623de7982baef8f03498677c2eefe06098df5f28a55667ca777f8f224c475b4600133fcf444e40f9fc58571da2d8557913bb35ecec193d38c062a17850836136a3598b0f1955e0fcbe4ed2ccb846492110773099d54b79f49210422387385857991f11f7372da9f3e8839d59a80f94f737209e9c95fab48d00fe03361042ae9dd00ad462370e3acad250e88e6d29657accf41ede25dc0f6127969441ee6caa221624d12d6b066943316ee29f84a83e21ebad23822a60e4389ef87eb7380e1aee25072cccdf60303616a102a8de3c721b264010466a8b148f0872dc765d30e9768715862aa3715cb083caa25fd434277bf2b3706f0989664dc4a1ddb1848330c1b7999c8d36dff053c6c1364417e369e4ca89fbd19cf2ed7db4e6284d89aedf496945de44d30652e0dba4c10d6db2f2d15a122b268a78cf81f5d8faa09f31b4992ef6a07888ff783d2592c716ba50dffd5aa85d7280f0ef6180c929a06d41d65b5a377fe712ccb8a6626612bf4081cf91118001587d1dec2852a7171913f13d0e990ab5ef392c74b54e648035860b76f4c09f7d28abcb90184fcceec2256ab4a3ee7f6f81ec88e88ae3c4811823e3a8fe50a6e198a4202c2b1282e3fe205525ef27417782da1c531c6e3bcfeae065ef0d3071914d4a65bb4f6047883350251fb1eaabc14b20bdd7ec42bfaa3d246458d1eb416746ef711ed9f5ef299fbd9d851c254f759f50953d0d2d21927fc65779975286d9984bf6b7b904c39d6ac836499a7eb292125be524746fe6fbfcb41cc10dcd34d8e6c546cfe9896fb8d4bbdc74f1fe1976a56fb981c6267ceecc59cacab8f1eb124236dc891d8ed559bae0d8c02e1b221d155e9eb243aa5d3c3facd97980028e7ba8de84363249e275201652641a036bbcbbf6d463a8a056cd95240d7709a40c71ec373b7211b5f08687c3d9348613bbd8272ad3e0c9643ff41a48959cf93e350f3f7f74eff38dda5c91111054b997f7f3af4f0269cdb14f62fa3b260297d2af351132791b0c555c205389d59682063db8c16d1e7fd562c2a71ee70ddfc252929c68d4e4d6a654f2aaae1a2f2b70cd4d0211bf8ebb7b34f5002921b6980379d307cac58e8b7923120188cfd943e47e8148220bf462ff166b5d5784f156dddde77709a0a038c4c2e1e8d0d8a5e190bb417608850956e4a9194a0f820bbdf548ce98c1a27550f5fc21dec4781c69988331cc5705cd1177e85c88eff2cba55b6bd81c99ba34ad3ff8d6813a306bcc9e41221e3ea193dbf1a347faaf62184bfdd16490dc1a7d3f987ca44a7fac701e3c4e39d5abf46867b9db1826d7bc01bcd05cdf8f8cad74d8258725b5c50b64e549e6093331ef707df067bf46dcf34dfb896e578c8a2189fd182ec90c4c26661040cc607337053d1122b54c34d4dc94fd04da6643bdf8b7ff3f7129296313c90d1cc9757ac15daef040e0bbe02de06812cc72095415d680a5037f9818cfa6f9e0d7568d4bdc5d3373802a9f147bd206567163b657463594b0e4245ae11a92d25041a163112428f1628a10f39d869e8f2bbb40f79f37630d519477308f128b58e72c79349888eb94b85a7710252049815569da85aa63a22b2cba1d320299622bc088569e1e3a6a6c2fb3404740e1398e4db3e8c82525f4715625227bcbb80e3202d2d08b8f46e7ea3c08d93f0c620db60961d6d8989650e36ced3e57ca2e4061adfa9150c57510651c0fd6a5a5aca8084868a410c7c1c271c63dc35dfa5fc7d0bff390b1713dceb9f9430755123ce66a0d84009b836f17b4b489845164d499206910065aec74e4ca97f9e680517c38c1ccab98a259a0d0a69e6f12fdbb49fa84de5ec903535c97656530ca7f2530e4533f84786f1e0b6aa617f1c00e44235f670cc2eb1a16105fca798065c724d7cf42223dfc7690711653bb4640a5a3237ba14d94af7f953c27603fca175f813aa5eef790714f8f58e370bb43ace436f46f3444fdacfaf074ebd3968a74df8f8eb31c1e1dd6c1e249f14f1e9e931bd9e488e533745174f2a2ed45d32d46da2bf56944327e28d455f104bae0a1186b8e18ae05ed450f4c0553a5dedb014e38c455ada3e8e10b382353816ad1c0b3652b3f4f0d7730d94d58b3c75bef26a672b6b20152e0fb08c52d51b3a46cb9fef5b47e0cf67886dcf1be445accc431d92318aa5c3a0a6ed4265471dfc1423a3cdc9251fffde8aa84488ab271bca78a9708fd2cd667a61e0b6704ccf8613e76e0318df25bb2363a0dfb09cb60d797c658934dcf9fd9e5e57483333af27ba883b646a49257b43575d5cb5097042693dba68ab25b1cd8d41295a5871e77a83e3ef63875f96ac22e4839bb403ee5a32b4efe041eef005b20b2ac7ead27e5fdf6a7568791562bb949aebd8752e0e4f484e5d8595df699bcf84ce615093f7218f4218d5000ba7d6a5104b5db4c08f7cef306929f3feeec3d4a5257d720ddf355336de58f23dc975988b2a29d8a855c23634a4470be6f5cdca07f60044f116dc82d0aebb85a9955f66f8fa758862f1edaa87e240d9c5507d7da667ee803605f506dd9f518b16c5ce493ff9354c8b67162fd02cbc744c3935692815074b01b9f5a0065bcae7334da118ce1df7177033bc918087dbd99c6331123abc18d81bf9f4b1e2fbcafcfa15c3070f2dc014964e8699ca7da1d9af9bb52ef7d097e87aea0f475630b0084c54baeccae6ce585f3568984a125e86b8ec5ee0f8e32387273b4da9ad298927e5560bbf471e79898d6d37221b638d461666d1d533f2ef38406ef5a3f5e4a8e59e128ed2ab9b9db99a4b2a75437378489e850e0e0f69b71247527d9ab5190de1c122367a1e9ce3d7170c77889766a28a58ae70d36b42f5c58a0796aa13332ffc1f5bd04556d1a109c8faf270076ad583892b41ca326c410792dfa431bb28d2b77fc736b7c2a5197ef18631a3d1ebe4ecfa7b1e4e02106f9a439df73d6a7a5ef6c3e8cb55389f2d5f7ae8a5e5ee1d6691a1d3ac40ca839850bac0d18b721bbf6d670d679a2afd19ef42d972bf6ba3f49d599ab56ce9b7cee217f350b194df7be7a19a763634609a1b428e32b259ff7bf4442e8a413d0d5166d10b47990a439eac925b45efaaf378a531cf81ac7cc983163f0647272d193f8427c7fc5483c91a8a129b1e3d76ecdbf875efca2520e0b5d805015811c73794283e18259594361ea66e9dfd00f3864a3db48dd5648144eec67e12165d7ab1a436e2cb322862ae7c032d39fa42c8d1b6a47dd367365ba12c6ed6a2b78a90cb1c35e1f46a425ed68dad7027727ff711a47ba22ad3bf82de0c8a93a286155f842407f631fcdd1b50471b147ef0b20ad82f3cfce28c356c26489311428a7df19b093f2f967eda3b3a71ed4d681da14f1b495efcb885f32d3d8fc3429e8450db00f78957cfb217503f25a6915c5c88965888d09613fa62082f54dbb74e72ba8855d2ed604708bae7fe14b7b23d6743223603363d54831c52bfa44cea503b70328f3d7d0a19150fea31d6cd1fd22a1d3f44201d0590dfb62b7222a0d356582b435fc2a95572a8e34a1eb589c4ddab808aebf239c19df87d2867712c7018b25e6ee8eecc3336b5962871553f8c141b79bbaa61163a9d5f3104f6d8555867510e37f9f1ee17aa61b29c3b85d55e823557149db89205e9f2cf466417a6141664d062d951bc889da8a953b38977de59df19b951ecf91d36509fa487d02f2676fb638f478f02fbbf37cb1dcdb5af150ae92c846b90bb45020807b3197842211fe4cf3d79e289111adf6c7f34f77d844b8edb4b5dee639ace90a57c8ead71bf802104631d47e92fb1e4c9235a270b3a2e4a9d1913827c08b074aadfe8816718126b918435167b521ea5ee04ab98f01c6cd85dcb4a38c2b6bf8872769aa732e6b800d4e16565effd77dc06e86f90c16185af60239a9d0aa1b6df4ee0b6710fd4087910b0c84ad4904d09216926031b002dfd68c6c19de6c7e7a2d2ffdfba03b887f59d0252bd4c3d443648a24637c831425afdc1f26a9015ff8f907d81b4888fe256447ff6773986a2b1fc83581c42b6ae9825d2a3aec197c97801884b221fdceb17699ac8a755c0d7cc532e831e379840be4eb8842ba9031be2433f1ca939fc478bcd31ea1267e729e3a495b65ad73af5d0d02185db1a998ac4d3fea640cf9a036bc193b2f6fdb2ebaf9f62856e7fa073e755639c0287458174772cec396a91ade8b5c0529c76bfcf70fe7596c048ed5b42df4459ee7635a43959236d6ca4675e820bee9d7fe2a9f13b882ce3a1aaaff82e93ab35034129e7c3c68eae2850568c5e917f95c57ca0fff14de718217f4ecd3f9a842a3395269e8fbad2392ff1cdaf58b9fa5bd93d91add61f7f62a50dc6c6df360db0ec7caa8031b1612b3f209de185607c716ef433f7bf8ee5656f36c43f299ac96dc65ba141bec88a77888fe4a90b403cf819285e22c1fee75d009c3d8581577e3f7ee8c068a40f5fe425382b3c920f49d7e04c758b24159f57a5ba41aaf89fcd8d75581a965a10e34c7214d8ae5387a6859b26c2af78c271da279def65aa72dad2da62f4a034227a9018657e46605284a73019920587f7cf987860a10b398a50116a89bd2471e8288fb3ff5cbbd16c7e9b0cba46ca1e81472cb6fd53abd085ad7815618043bc93111c9126c0dad26114130f3e2f16b12241c679ab58253fdbcb6a395cb0e5478f5acea908978c3c22e1f2bbdb263e694f4c728b476271520833dfb6d15ef41ff29c44cd8cb3fcb0cf8d4ea550e583a873f5f9f33b1ab39b5c31eef1a7b70ce2900de36876cc5f98b6458c6a1d7524d5e7de41a77272bb9cdac50ff63bad6ccea68db125ee35c70243e2176ae5bcbf436a411e01