commit 84f231a54a3385ce4415f7a3c67f1439cbceadd4
parent 09ac7fe49c114a50906a4dd41e014d86d0e615bb
Author: finwo <finwo@pm.me>
Date: Sat, 10 Oct 2026 01:40:14 +0200
Added reference to within openssl, ensuring we're accurate
Diffstat:
17 files changed, 804 insertions(+), 0 deletions(-)
diff --git a/test/09-ref.c b/test/09-ref.c
@@ -0,0 +1,95 @@
+#include <string.h>
+
+#include "_tap.c"
+#include "ref/sfinx_ref.c"
+#include "src/sfinx.c"
+
+#define MSG "sfinx reference vector"
+#define MSG_LEN (sizeof(MSG) - 1)
+
+static const uint8_t SEED[32] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+ 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+ 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
+static const uint8_t PATH1[1] = {0x0a};
+static const uint8_t PATH2[2] = {0x0a, 0x1b};
+
+static void run_tree(int bits, sfinx_hash hash, size_t len, const uint8_t *path, size_t path_len) {
+ uint8_t lib_pub[SFINX_HASH_LEN_MAX];
+ uint8_t lib_sig[16384];
+ uint8_t ref_sig[16384];
+ uint8_t tamper[16384];
+ size_t n = sfinx_signature_len(hash, path_len);
+ char label[96];
+
+ sfinx_tree_public_key(hash, SEED, sizeof(SEED), lib_pub, sizeof(lib_pub), NULL);
+ sfinx_tree_sign(hash, SEED, sizeof(SEED), path, path_len, (const uint8_t *)MSG, MSG_LEN, lib_sig, sizeof(lib_sig),
+ NULL);
+ ref_tree_sign(bits, SEED, sizeof(SEED), path, path_len, (const uint8_t *)MSG, MSG_LEN, ref_sig);
+
+ snprintf(label, sizeof(label), "L%zu N%zu signature matches reference", len, path_len);
+ tap(memcmp(lib_sig, ref_sig, n) == 0, label, "differs");
+
+ snprintf(label, sizeof(label), "L%zu N%zu library verifies the reference", len, path_len);
+ tap(sfinx_verify(lib_pub, len, (const uint8_t *)MSG, MSG_LEN, ref_sig, n) == SFINX_OK, label, "rejected");
+
+ snprintf(label, sizeof(label), "L%zu N%zu reference verifies the library", len, path_len);
+ tap(ref_verify(lib_pub, len, (const uint8_t *)MSG, MSG_LEN, lib_sig, n) != 0, label, "rejected");
+
+ memcpy(tamper, ref_sig, n);
+ tamper[2 + path_len] ^= 0x01;
+ snprintf(label, sizeof(label), "L%zu N%zu tampered reference fails", len, path_len);
+ tap(sfinx_verify(lib_pub, len, (const uint8_t *)MSG, MSG_LEN, tamper, n) != SFINX_OK, label, "accepted");
+
+ memcpy(tamper, lib_sig, n);
+ tamper[n - 1] ^= 0x01;
+ snprintf(label, sizeof(label), "L%zu N%zu tampered library fails", len, path_len);
+ tap(ref_verify(lib_pub, len, (const uint8_t *)MSG, MSG_LEN, tamper, n) == 0, label, "accepted");
+
+ memcpy(tamper, lib_sig, n);
+ ref_e4m4_encode((uint32_t)(len == 32 ? 64 : 32), tamper + 1 + path_len);
+ snprintf(label, sizeof(label), "L%zu N%zu reference rejects a wrong E4M4(L)", len, path_len);
+ tap(ref_verify(lib_pub, len, (const uint8_t *)MSG, MSG_LEN, tamper, n) == 0, label, "accepted");
+}
+
+static void run_bits(int bits) {
+ sfinx_hash hash = (sfinx_hash)bits;
+ size_t len = sfinx_hash_len(hash);
+ uint8_t lib_pub[SFINX_HASH_LEN_MAX];
+ uint8_t ref_pub[SFINX_HASH_LEN_MAX];
+ uint8_t lib_sig[16384];
+ uint8_t ref_sig[16384];
+ size_t n;
+ char label[96];
+
+ sfinx_single_public_key(hash, SEED, sizeof(SEED), lib_pub, sizeof(lib_pub), NULL);
+ ref_single_pub(bits, SEED, sizeof(SEED), ref_pub);
+ snprintf(label, sizeof(label), "L%zu single pub matches reference", len);
+ tap(memcmp(lib_pub, ref_pub, len) == 0, label, "differs");
+
+ sfinx_tree_public_key(hash, SEED, sizeof(SEED), lib_pub, sizeof(lib_pub), NULL);
+ ref_tree_pub(bits, SEED, sizeof(SEED), ref_pub);
+ snprintf(label, sizeof(label), "L%zu tree pub matches reference", len);
+ tap(memcmp(lib_pub, ref_pub, len) == 0, label, "differs");
+
+ n = sfinx_signature_len(hash, 0);
+ sfinx_single_sign(hash, SEED, sizeof(SEED), (const uint8_t *)MSG, MSG_LEN, lib_sig, sizeof(lib_sig), NULL);
+ ref_single_sign(bits, SEED, sizeof(SEED), (const uint8_t *)MSG, MSG_LEN, ref_sig);
+ snprintf(label, sizeof(label), "L%zu single signature matches reference", len);
+ tap(memcmp(lib_sig, ref_sig, n) == 0, label, "differs");
+
+ run_tree(bits, hash, len, PATH1, sizeof(PATH1));
+ if (bits == 224 || bits == 256) {
+ run_tree(bits, hash, len, PATH2, sizeof(PATH2));
+ }
+}
+
+int main(void) {
+ tap_begin("sfinx reference differential");
+
+ run_bits(224);
+ run_bits(256);
+ run_bits(384);
+ run_bits(512);
+
+ return tap_plan();
+}
diff --git a/test/Makefile b/test/Makefile
@@ -20,6 +20,9 @@ $(OUT):
$(KECCAK):
@cd .. && dep install
+$(OUT)/09-ref: 09-ref.c ref/sfinx_ref.c ../src/sfinx.c _tap.c $(LIB) $(KECCAK) | $(OUT)
+ @$(CC) $(CFLAGS) $< $(LIB) $(KECCAK) -o $@
+
$(OUT)/%: %.c ../src/sfinx.c _tap.c $(LIB) $(KECCAK) | $(OUT)
@$(CC) $(CFLAGS) $< $(LIB) $(KECCAK) -o $@
diff --git a/test/ref/hash.c b/test/ref/hash.c
@@ -0,0 +1,105 @@
+// Hash CLI {{{
+//
+// Exposes the sfinx hash wrappers to the openssl anchor test
+// hash <224|256|384|512> read stdin, print the SHA3 hex
+// hash shake <bytes> read stdin, print the SHAKE256 hex
+// This is the only place the wrappers and openssl meet
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "src/sfinx.c"
+
+static void print_hex(const uint8_t *in, size_t len) {
+ static const char digits[] = "0123456789abcdef";
+ for (size_t i = 0; i < len; i++) {
+ putchar(digits[in[i] >> 4]);
+ putchar(digits[in[i] & 0x0f]);
+ }
+ putchar('\n');
+}
+
+static int read_stdin(uint8_t **out, size_t *out_len) {
+ size_t cap = 4096;
+ size_t len = 0;
+ uint8_t *buf = malloc(cap);
+ if (!buf) {
+ return 0;
+ }
+ for (;;) {
+ if (len == cap) {
+ size_t next_cap = cap * 2;
+ uint8_t *next = realloc(buf, next_cap);
+ if (!next) {
+ free(buf);
+ return 0;
+ }
+ buf = next;
+ cap = next_cap;
+ }
+ len += fread(buf + len, 1, cap - len, stdin);
+ if (feof(stdin)) {
+ break;
+ }
+ }
+ *out = buf;
+ *out_len = len;
+ return 1;
+}
+
+int main(int argc, char **argv) {
+ uint8_t *in = NULL;
+ size_t in_len = 0;
+
+ if (argc == 3 && strcmp(argv[1], "shake") == 0) {
+ char *end = NULL;
+ long out_len = strtol(argv[2], &end, 10);
+ uint8_t *out;
+ if (!end || *end != '\0' || out_len < 0 || out_len > (1 << 20)) {
+ fprintf(stderr, "usage: hash shake <bytes>\n");
+ return 2;
+ }
+ if (!read_stdin(&in, &in_len)) {
+ fprintf(stderr, "hash: out of memory\n");
+ return 2;
+ }
+ out = malloc((size_t)out_len > 0 ? (size_t)out_len : 1);
+ if (!out) {
+ free(in);
+ fprintf(stderr, "hash: out of memory\n");
+ return 2;
+ }
+ _sfinx_shake256(in, in_len, out, (size_t)out_len);
+ print_hex(out, (size_t)out_len);
+ free(out);
+ free(in);
+ return 0;
+ }
+
+ if (argc == 2) {
+ char *end = NULL;
+ long bits = strtol(argv[1], &end, 10);
+ sfinx_hash hash = (sfinx_hash)bits;
+ uint8_t out[SFINX_HASH_LEN_MAX];
+ if (!end || *end != '\0' || sfinx_hash_len(hash) == 0) {
+ fprintf(stderr, "usage: hash <224|256|384|512>\n");
+ return 2;
+ }
+ if (!read_stdin(&in, &in_len)) {
+ fprintf(stderr, "hash: out of memory\n");
+ return 2;
+ }
+ _sfinx_hash(hash, in, in_len, out);
+ print_hex(out, sfinx_hash_len(hash));
+ free(in);
+ return 0;
+ }
+
+ fprintf(stderr, "usage: hash <224|256|384|512>\n hash shake <bytes>\n");
+ return 2;
+}
+// }}}
+
+// vim:fdm=marker:fdl=0
diff --git a/test/ref/sfinx_ref.c b/test/ref/sfinx_ref.c
@@ -0,0 +1,362 @@
+// Reference signer {{{
+//
+// Independent re-derivation of the sfinx scheme
+// shares only the keccak-tiny primitive with src/sfinx.c
+// a second code path, not a second language, so it checks the scheme logic and
+// the byte layout, not the hash (the hash is anchored by test_openssl.sh)
+// nothing here is production code, all symbols are static and prefixed ref_
+
+#include <coruus/keccak-tiny.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define REF_LEN_MAX 64
+#define REF_DIGITS_MAX (REF_LEN_MAX + 2)
+#define REF_WOTS_MAX ((REF_LEN_MAX + 2) * REF_LEN_MAX)
+#define REF_LEAVES_MAX (256 * REF_LEN_MAX)
+#define REF_KEY_MAX 1024
+#define REF_PARENT_MAX (2 + 256 + 2 * REF_LEN_MAX)
+
+static size_t ref_len(int bits) {
+ switch (bits) {
+ case 224: return 28;
+ case 256: return 32;
+ case 384: return 48;
+ case 512: return 64;
+ }
+ return 0;
+}
+
+static void ref_sha3(int bits, const uint8_t *in, size_t in_len, uint8_t *out) {
+ switch (bits) {
+ case 224: sha3_224(out, 28, in, in_len); break;
+ case 256: sha3_256(out, 32, in, in_len); break;
+ case 384: sha3_384(out, 48, in, in_len); break;
+ case 512: sha3_512(out, 64, in, in_len); break;
+ }
+}
+
+static void ref_shake(const uint8_t *in, size_t in_len, uint8_t *out, size_t out_len) {
+ shake256(out, out_len, in, in_len);
+}
+
+static uint32_t ref_e4m4_decode(uint8_t byte) {
+ uint8_t exponent = (uint8_t)(byte >> 4);
+ uint8_t mantissa = (uint8_t)(byte & 0x0f);
+ if (exponent == 0) {
+ return mantissa;
+ }
+ return (uint32_t)(16 + mantissa) << (exponent - 1);
+}
+
+static int ref_e4m4_encode(uint32_t value, uint8_t *out) {
+ // Brute force the small field rather than the library's shift loop
+ for (uint32_t exponent = 0; exponent < 16; exponent++) {
+ for (uint32_t mantissa = 0; mantissa < 16; mantissa++) {
+ uint32_t candidate = exponent == 0 ? mantissa : (16 + mantissa) << (exponent - 1);
+ if (candidate == value) {
+ *out = (uint8_t)((exponent << 4) | mantissa);
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+static uint8_t ref_mask(uint8_t bitlen, uint8_t index) {
+ // Keep the top bitlen bits with an explicit bit walk
+ uint8_t out = 0;
+ for (uint8_t i = 0; i < bitlen; i++) {
+ uint8_t bit = (uint8_t)(1u << (7 - i));
+ if (index & bit) {
+ out |= bit;
+ }
+ }
+ return out;
+}
+
+static void ref_parent(int bits, uint8_t bitlen, uint8_t mask, const uint8_t *prefix, size_t prefix_len,
+ const uint8_t *left, const uint8_t *right, uint8_t *out) {
+ size_t len = ref_len(bits);
+ uint8_t buf[REF_PARENT_MAX];
+ size_t at = 0;
+ if (prefix_len > 256) {
+ return;
+ }
+ buf[at++] = bitlen;
+ buf[at++] = mask;
+ for (size_t i = 0; i < prefix_len; i++) {
+ buf[at++] = prefix[i];
+ }
+ for (size_t i = 0; i < len; i++) {
+ buf[at++] = left[i];
+ }
+ for (size_t i = 0; i < len; i++) {
+ buf[at++] = right[i];
+ }
+ ref_sha3(bits, buf, at, out);
+}
+
+static void ref_pre(int bits, const uint8_t *key, size_t key_len, uint8_t *out) {
+ size_t len = ref_len(bits);
+ ref_shake(key, key_len, out, (len + 2) * len);
+}
+
+static void ref_digits(int bits, const uint8_t *value, uint8_t *out) {
+ size_t len = ref_len(bits);
+ uint32_t checksum = 0;
+ for (size_t i = 0; i < len; i++) {
+ out[i] = value[i];
+ checksum += (uint32_t)(255 - value[i]);
+ }
+ out[len] = (uint8_t)((checksum >> 8) & 0xff);
+ out[len + 1] = (uint8_t)(checksum & 0xff);
+}
+
+static void ref_chain(int bits, uint8_t *node, 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);
+ }
+}
+
+static void ref_pub(int bits, const uint8_t *key, size_t key_len, uint8_t *out) {
+ size_t len = ref_len(bits);
+ uint8_t ends[REF_WOTS_MAX];
+ ref_pre(bits, key, key_len, ends);
+ for (size_t i = 0; i < len + 2; i++) {
+ ref_chain(bits, ends + i * len, 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) {
+ size_t len = ref_len(bits);
+ uint8_t digits[REF_DIGITS_MAX];
+ ref_pre(bits, key, key_len, proof);
+ ref_digits(bits, value, digits);
+ for (size_t i = 0; i < len + 2; i++) {
+ ref_chain(bits, proof + i * len, digits[i]);
+ }
+}
+
+static void ref_wots_rebuild(int bits, const uint8_t *value, const uint8_t *proof, 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_sha3(bits, ends, (len + 2) * len, out);
+}
+
+static void ref_subtree(int bits, 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 = ref_len(bits);
+ size_t key_len = seed_len + prefix_len + 1;
+ size_t pos = leaf_index;
+ uint8_t leaves[REF_LEAVES_MAX];
+ uint8_t key[REF_KEY_MAX];
+
+ if (key_len > REF_KEY_MAX) {
+ return;
+ }
+ for (size_t i = 0; i < seed_len; i++) {
+ key[i] = seed[i];
+ }
+ for (size_t i = 0; i < prefix_len; i++) {
+ key[seed_len + i] = prefix[i];
+ }
+ 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);
+ }
+ for (uint8_t depth = 0; depth < 8; depth++) {
+ uint8_t bitlen = (uint8_t)(7 - depth);
+ size_t pairs = (size_t)1 << (7 - depth);
+ if (auth_out) {
+ size_t sibling = pos ^ 1u;
+ for (size_t i = 0; i < len; i++) {
+ auth_out[(size_t)depth * len + i] = leaves[sibling * len + i];
+ }
+ }
+ for (size_t j = 0; j < pairs; j++) {
+ uint8_t mask = ref_mask(bitlen, (uint8_t)(j << (8 - bitlen)));
+ ref_parent(bits, bitlen, mask, prefix, prefix_len, leaves + (2 * j) * len, leaves + (2 * j + 1) * len,
+ leaves + j * len);
+ }
+ pos >>= 1;
+ }
+ for (size_t i = 0; i < len; i++) {
+ root_out[i] = leaves[i];
+ }
+}
+
+static size_t ref_signature_len(int bits, size_t path_len) {
+ size_t len = ref_len(bits);
+ if (len == 0) {
+ return 0;
+ }
+ if (path_len == 0) {
+ return 2 + (len + 2) * len;
+ }
+ return 2 + path_len + path_len * (len + 10) * 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);
+}
+
+static void ref_single_sign(int bits, const uint8_t *seed, size_t seed_len, const uint8_t *msg, size_t msg_len,
+ uint8_t *sig) {
+ size_t len = ref_len(bits);
+ uint8_t org[REF_LEN_MAX];
+ 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);
+}
+
+static void ref_tree_pub(int bits, const uint8_t *seed, size_t seed_len, uint8_t *out) {
+ ref_subtree(bits, seed, seed_len, NULL, 0, 0, out, NULL);
+}
+
+static void ref_tree_sign(int bits, const uint8_t *seed, size_t seed_len, const uint8_t *path, size_t path_len,
+ const uint8_t *msg, size_t msg_len, uint8_t *sig) {
+ size_t len = ref_len(bits);
+ size_t c = len + 2;
+ size_t at = 0;
+ uint8_t value[REF_LEN_MAX];
+ uint8_t root[REF_LEN_MAX];
+ uint8_t auth[8 * REF_LEN_MAX];
+ uint8_t key[REF_KEY_MAX];
+ uint8_t *joined = malloc(path_len + msg_len);
+
+ if (!joined || seed_len + path_len + 1 > REF_KEY_MAX) {
+ free(joined);
+ return;
+ }
+ memcpy(joined, path, path_len);
+ memcpy(joined + path_len, msg, msg_len);
+ ref_sha3(bits, joined, path_len + msg_len, value);
+ free(joined);
+
+ ref_e4m4_encode((uint32_t)path_len, sig);
+ at = 1;
+ for (size_t i = 0; i < path_len; i++) {
+ sig[at++] = path[i];
+ }
+ ref_e4m4_encode((uint32_t)len, sig + at);
+ at += 1;
+
+ for (size_t i = 0; i < seed_len; i++) {
+ key[i] = seed[i];
+ }
+ for (size_t i = 0; i < path_len; i++) {
+ key[seed_len + i] = path[i];
+ }
+
+ for (size_t k = path_len; k >= 1; k--) {
+ ref_subtree(bits, seed, seed_len, path, k - 1, path[k - 1], root, auth);
+ ref_wots_sign(bits, key, seed_len + k, value, sig + at);
+ at += c * len;
+ for (size_t i = 0; i < 8 * len; i++) {
+ sig[at++] = auth[i];
+ }
+ for (size_t i = 0; i < len; i++) {
+ value[i] = root[i];
+ }
+ }
+}
+
+static int ref_verify(const uint8_t *pub, size_t pub_len, const uint8_t *msg, size_t msg_len, const uint8_t *sig,
+ size_t sig_len) {
+ size_t path_len;
+ size_t len;
+ size_t c;
+ size_t at;
+ size_t pos;
+ int bits;
+ uint8_t value[REF_LEN_MAX];
+ uint8_t leaf[REF_LEN_MAX];
+ uint8_t root[REF_LEN_MAX];
+ uint8_t *joined;
+
+ if (sig_len < 2) {
+ return 0;
+ }
+ path_len = ref_e4m4_decode(sig[0]);
+ at = 1 + path_len;
+ if (at + 1 > sig_len) {
+ return 0;
+ }
+ len = ref_e4m4_decode(sig[at]);
+ if (len == 28) {
+ bits = 224;
+ } else if (len == 32) {
+ bits = 256;
+ } else if (len == 48) {
+ bits = 384;
+ } else if (len == 64) {
+ bits = 512;
+ } else {
+ return 0;
+ }
+ if (len != pub_len || sig_len != ref_signature_len(bits, path_len)) {
+ return 0;
+ }
+ c = len + 2;
+ at = 2 + path_len;
+
+ if (path_len == 0) {
+ ref_sha3(bits, msg, msg_len, value);
+ ref_wots_rebuild(bits, value, sig + at, leaf);
+ return memcmp(leaf, pub, len) == 0;
+ }
+
+ joined = malloc(path_len + msg_len);
+ if (!joined) {
+ return 0;
+ }
+ memcpy(joined, sig + 1, path_len);
+ memcpy(joined + path_len, msg, msg_len);
+ ref_sha3(bits, joined, path_len + msg_len, value);
+ free(joined);
+
+ for (size_t k = path_len; k >= 1; k--) {
+ ref_wots_rebuild(bits, value, sig + at, leaf);
+ at += c * len;
+ pos = sig[k];
+ for (size_t i = 0; i < len; i++) {
+ root[i] = leaf[i];
+ }
+ for (uint8_t depth = 0; depth < 8; depth++) {
+ uint8_t bitlen = (uint8_t)(7 - depth);
+ uint8_t mask = ref_mask(bitlen, (uint8_t)((pos >> 1) << (8 - bitlen)));
+ const uint8_t *sibling = sig + at + (size_t)depth * len;
+ uint8_t tmp[REF_LEN_MAX];
+ if (pos & 1) {
+ ref_parent(bits, bitlen, mask, sig + 1, k - 1, sibling, root, tmp);
+ } else {
+ ref_parent(bits, bitlen, mask, sig + 1, k - 1, root, sibling, tmp);
+ }
+ memcpy(root, tmp, len);
+ pos >>= 1;
+ }
+ at += 8 * len;
+ if (k == 1) {
+ return memcmp(root, pub, len) == 0;
+ }
+ memcpy(value, root, len);
+ }
+ return 0;
+}
+// }}}
+
+// vim:fdm=marker:fdl=0
diff --git a/test/test_format.sh b/test/test_format.sh
@@ -0,0 +1,105 @@
+#!/bin/sh
+# Pins the wire layout E4M4(N) | path | E4M4(L) | data against committed vectors.
+# Fixed inputs: seed 00..1f, message "sfinx golden vector", paths 0a (N1) and 0a1b (N2).
+set -eu
+HERE=$(cd "$(dirname "$0")" && pwd)
+ROOT=$(cd "${HERE}/.." && pwd)
+. "${HERE}/_tap.sh"
+
+BIN=$(ensure_bin "${ROOT}")
+TMP=$(mktemp -d)
+trap 'rm -rf "${TMP}"' EXIT
+
+V="${ROOT}/test/vectors"
+
+tap_begin "cli: wire format"
+
+missing=""
+for f in seed.bin sig-L28-N0.hex sig-L28-N1.hex sig-L32-N0.hex sig-L32-N1.hex sig-L32-N2.hex \
+ sig-L48-N0.hex sig-L48-N1.hex sig-L64-N0.hex sig-L64-N1.hex; do
+ [ -f "${V}/${f}" ] || missing="${missing} ${f}"
+done
+tap "$([ -z "${missing}" ] && echo 1 || echo 0)" "all vectors present" "missing:${missing}"
+
+sign_hex() {
+ # sign_hex <bits> <path|single>
+ if [ "$2" = single ]; then
+ "${BIN}" sign --key-fmt raw -k "${V}/seed.bin" -L "$1" --single -m 'sfinx golden vector' --sig-fmt hex
+ else
+ "${BIN}" sign --key-fmt raw -k "${V}/seed.bin" -L "$1" -P "$2" -m 'sfinx golden vector' --sig-fmt hex
+ fi
+}
+
+check_vector() {
+ # check_vector <bits> <path|single> <L> <N> <bytes>
+ got=$(sign_hex "$1" "$2")
+ if printf '%s\n' "${got}" | cmp -s - "${V}/sig-L$3-N$4.hex"; then ok=1; else ok=0; fi
+ tap "${ok}" "vector L$3 N$4 bytes match" "differs from sig-L$3-N$4.hex"
+ n=$(printf '%s' "${got}" | wc -c | tr -d '[:space:]')
+ tap "$([ "${n}" = "$(( $5 * 2 ))" ] && echo 1 || echo 0)" "vector L$3 N$4 hex length" "got ${n} want $(( $5 * 2 ))"
+}
+
+check_vector 224 single 28 0 842
+check_vector 224 0a 28 1 1067
+check_vector 256 single 32 0 1090
+check_vector 256 0a 32 1 1347
+check_vector 256 0a1b 32 2 2692
+check_vector 384 single 48 0 2402
+check_vector 384 0a 48 1 2787
+check_vector 512 single 64 0 4226
+check_vector 512 0a 64 1 4739
+
+# Derive the public halves the vectors must verify against
+for L in 28 32 48 64; do
+ bits=$((L * 8))
+ "${BIN}" printkey --in-fmt raw -k "${V}/seed.bin" -L $bits --public-only --out-fmt rawpub -o "${TMP}/pub-$L.bin"
+ "${BIN}" printkey --in-fmt raw -k "${V}/seed.bin" -L $bits --single --public-only --out-fmt rawpub \
+ -o "${TMP}/pub0-$L.bin"
+done
+
+# The hex decoder wants bare hex, strip the vectors' trailing newline
+tr -d '\n' <"${V}/sig-L32-N1.hex" >"${TMP}/v-L32-N1.hex"
+tr -d '\n' <"${V}/sig-L32-N0.hex" >"${TMP}/v-L32-N0.hex"
+
+"${BIN}" verify --key-fmt rawpub -k "${TMP}/pub-32.bin" -m 'sfinx golden vector' --sig-fmt hex \
+ -S "${TMP}/v-L32-N1.hex" >/dev/null && ok=1 || ok=0
+tap "${ok}" "committed tree vector verifies" "failed"
+
+"${BIN}" verify --key-fmt rawpub -k "${TMP}/pub0-32.bin" -m 'sfinx golden vector' --sig-fmt hex \
+ -S "${TMP}/v-L32-N0.hex" >/dev/null && ok=1 || ok=0
+tap "${ok}" "committed single vector verifies" "failed"
+
+# Raw signature is the same bytes, check the byte count too
+"${BIN}" sign --key-fmt raw -k "${V}/seed.bin" -L 256 -P 0a -m 'sfinx golden vector' --sig-fmt raw \
+ -o "${TMP}/sig-raw.bin"
+n=$(wc -c <"${TMP}/sig-raw.bin" | tr -d '[:space:]')
+tap "$([ "${n}" = 1347 ] && echo 1 || echo 0)" "raw N1 signature is 1347 bytes" "got ${n}"
+
+patch_byte() {
+ # patch_byte <file> <offset> <decimal>
+ printf "\\$(printf '%03o' "$3")" | dd of="$1" bs=1 seek="$2" count=1 conv=notrunc 2>/dev/null
+}
+
+verify_raw() {
+ # verify_raw <pub> <sig>
+ "${BIN}" verify --key-fmt rawpub -k "$1" -m 'sfinx golden vector' -S "$2" >/dev/null 2>&1
+}
+
+head -c 1346 "${TMP}/sig-raw.bin" >"${TMP}/short.bin"
+rc=0
+verify_raw "${TMP}/pub-32.bin" "${TMP}/short.bin" || rc=$?
+tap "$([ "${rc}" != 0 ] && echo 1 || echo 0)" "a truncated signature fails" "exit ${rc}"
+
+cp "${TMP}/sig-raw.bin" "${TMP}/bad-n.bin"
+patch_byte "${TMP}/bad-n.bin" 0 2
+rc=0
+verify_raw "${TMP}/pub-32.bin" "${TMP}/bad-n.bin" || rc=$?
+tap "$([ "${rc}" != 0 ] && echo 1 || echo 0)" "a patched N fails" "exit ${rc}"
+
+cp "${TMP}/sig-raw.bin" "${TMP}/bad-path.bin"
+patch_byte "${TMP}/bad-path.bin" 1 11
+rc=0
+verify_raw "${TMP}/pub-32.bin" "${TMP}/bad-path.bin" || rc=$?
+tap "$([ "${rc}" != 0 ] && echo 1 || echo 0)" "a patched path byte fails" "exit ${rc}"
+
+tap_plan
diff --git a/test/test_hash_sizes.sh b/test/test_hash_sizes.sh
@@ -0,0 +1,56 @@
+#!/bin/sh
+# Round trips every hash size through the CLI and checks the E4M4(L) negative.
+set -eu
+HERE=$(cd "$(dirname "$0")" && pwd)
+ROOT=$(cd "${HERE}/.." && pwd)
+. "${HERE}/_tap.sh"
+
+BIN=$(ensure_bin "${ROOT}")
+TMP=$(mktemp -d)
+trap 'rm -rf "${TMP}"' EXIT
+
+bytes() {
+ wc -c <"$1" | tr -d '[:space:]'
+}
+
+size_n1() {
+ # 2 + N + N * (L + 10) * L with N = 1
+ echo $((3 + ($1 + 10) * $1))
+}
+
+patch_byte() {
+ # patch_byte <file> <offset> <decimal>
+ printf "\\$(printf '%03o' "$3")" | dd of="$1" bs=1 seek="$2" count=1 conv=notrunc 2>/dev/null
+}
+
+tap_begin "cli: hash sizes"
+
+for L in 28 32 48 64; do
+ bits=$((L * 8))
+ "${BIN}" generate --out-fmt raw -L $bits -o "${TMP}/k$L.key"
+ "${BIN}" sign -k "${TMP}/k$L.key" -L $bits -P 0a -m 'hash size' -o "${TMP}/s$L.sig"
+
+ n=$(bytes "${TMP}/s$L.sig")
+ tap "$([ "${n}" = "$(size_n1 $L)" ] && echo 1 || echo 0)" "L$L N1 signature is $(size_n1 $L) bytes" \
+ "got ${n}"
+ tap "$([ "$(bytes "${TMP}/k$L.pub")" = "${L}" ] && echo 1 || echo 0)" "L$L public key is ${L} bytes" \
+ "got $(bytes "${TMP}/k$L.pub")"
+
+ "${BIN}" verify -k "${TMP}/k$L.pub" -L $bits -m 'hash size' -S "${TMP}/s$L.sig" >/dev/null && ok=1 || ok=0
+ tap "${ok}" "L$L round trip verifies" "failed"
+done
+
+# E4M4(L) at offset 1 + N = 2 in the L32 signature must match the public key length
+cp "${TMP}/s32.sig" "${TMP}/bad-l.sig"
+patch_byte "${TMP}/bad-l.sig" 2 48
+rc=0
+"${BIN}" verify -k "${TMP}/k32.pub" -m 'hash size' -S "${TMP}/bad-l.sig" >/dev/null 2>&1 || rc=$?
+tap "$([ "${rc}" != 0 ] && echo 1 || echo 0)" "E4M4(L) 64 against a 32-byte key fails" "exit ${rc}"
+
+cp "${TMP}/s32.sig" "${TMP}/bad-l2.sig"
+patch_byte "${TMP}/bad-l2.sig" 2 31
+rc=0
+"${BIN}" verify -k "${TMP}/k32.pub" -m 'hash size' -S "${TMP}/bad-l2.sig" >/dev/null 2>&1 || rc=$?
+tap "$([ "${rc}" != 0 ] && echo 1 || echo 0)" "an invalid E4M4(L) fails" "exit ${rc}"
+
+tap_plan
diff --git a/test/test_openssl.sh b/test/test_openssl.sh
@@ -0,0 +1,69 @@
+#!/bin/sh
+# Anchors the sfinx hash wrappers to the openssl CLI, no Python.
+# Skips cleanly when openssl or od is absent.
+set -eu
+HERE=$(cd "$(dirname "$0")" && pwd)
+ROOT=$(cd "${HERE}/.." && pwd)
+. "${HERE}/_tap.sh"
+
+CC=${CC:-cc}
+
+tap_begin "openssl hash anchor"
+
+if ! command -v openssl >/dev/null 2>&1 || ! command -v od >/dev/null 2>&1; then
+ # No helper to call, so write the lone skip assertion directly
+ printf 'TAP version 13\n'
+ printf '# openssl hash anchor\n'
+ printf 'ok 1 - openssl and od available # SKIP openssl or od not installed\n'
+ printf '1..1\n'
+ exit 0
+fi
+tap 1 "openssl and od available" ""
+
+TMP=$(mktemp -d)
+trap 'rm -rf "${TMP}"' EXIT
+
+KECCAK="${ROOT}/lib/coruus/keccak-tiny/keccak-tiny.c"
+if [ ! -f "${KECCAK}" ]; then
+ (cd "${ROOT}" && dep install) >/dev/null 2>&1 || true
+fi
+
+if "${CC}" -Wall -Wextra -O2 -I"${ROOT}" -I"${ROOT}/src" -I"${ROOT}/lib/.dep/include" \
+ "${HERE}/ref/hash.c" "${KECCAK}" -o "${TMP}/hash" >"${TMP}/build.log" 2>&1; then
+ tap 1 "hash helper builds" ""
+else
+ tap 0 "hash helper builds" "$(cat "${TMP}/build.log")"
+fi
+
+# Inputs: empty, a short string, and a 200-byte pattern that crosses the SHAKE rate
+: >"${TMP}/empty"
+printf 'abc' >"${TMP}/abc"
+i=0
+: >"${TMP}/pattern"
+while [ $i -lt 200 ]; do
+ printf "\\$(printf '%03o' $((i % 256)))" >>"${TMP}/pattern"
+ i=$((i + 1))
+done
+
+for f in empty abc pattern; do
+ for h in 224 256 384 512; do
+ got=$("${TMP}/hash" $h <"${TMP}/$f")
+ want=$(openssl dgst -sha3-$h -binary <"${TMP}/$f" | od -An -v -tx1 | tr -d ' \n')
+ tap "$([ "$got" = "$want" ] && echo 1 || echo 0)" "sha3-$h $f" "got $got want $want"
+ done
+done
+
+# -xoflen is mandatory for SHAKE on openssl 3, probe before the group
+if printf '' | openssl dgst -shake256 -xoflen 16 -binary >/dev/null 2>&1; then
+ for f in empty abc pattern; do
+ for n in 16 32 64 200; do
+ got=$("${TMP}/hash" shake $n <"${TMP}/$f")
+ want=$(openssl dgst -shake256 -xoflen $n -binary <"${TMP}/$f" | od -An -v -tx1 | tr -d ' \n')
+ tap "$([ "$got" = "$want" ] && echo 1 || echo 0)" "shake256 $n $f" "got $got want $want"
+ done
+ done
+else
+ tap 0 "openssl dgst supports -shake256 -xoflen" "not supported by this openssl"
+fi
+
+tap_plan
diff --git a/test/vectors/seed.bin b/test/vectors/seed.bin
Binary files differ.
diff --git a/test/vectors/sig-L28-N0.hex b/test/vectors/sig-L28-N0.hex
@@ -0,0 +1 @@
+001ca124a58318de720c65f8844063941528d3393305b2ff64774622bc237d4d9c239e6fccce99281ce2ef46bacd704c466d9edd6179c7b3d54d249e0a3f3bf2a4d0077b403f848f0454285dc703645299ebd3eeac440cc04fa5ce1f7350f3bdc87cd8c3b4e92647a3f058d0b59c5988aeeb7f0eec0f098afe1dd2f563b130c20a4fdb0cdd5bfd672f3455d7c5ee2b5ad7cb1e75899d4f791e8c62ce2e41e66d0ab93eba053bed5dfbf82de32811233330539056f58947943661e8d8e8b18e1ff4f004ebe21aadd675e23b25875b10e43e5d52ec4733a7b5e2ff1addb5ea9804c300b0ae4be03be43ee01c2c6433bf23e53fe72b87ad1b0f943a1a9f63560a1bec31643b7e6e42dc07063e2daab649bedc44e3c2546f3f6617d7da9f208a37d24fc3175dc7c00f14252879e717cb38ce9434c876b5c33b0584cbcfc4b18f15a72750fc305003767c96b4f08ec63aee830c5847c23e2f84cfa89a81914b59de0696156e0ba3c9dd5d5507181dedd72f4428a3d324b30719cfdd01e9acc40f27174295870b08205c91eccd344d159d15dc81ad23a51bb028d884e5fe63b8e1bace822f9b286e48103fa17a2f45fda481f19b9e73d68510c85d8ef8f04be8962539f84f193660ede7a07ca96e96b5a09d6b471e2925d7a65e242bb33160d84bb4639ce4bb57fcf63d8e7bb0af0670de17794eefc6e1b382d76e5c53066d3dc11de7ee1171cc34946e645a7af0c2ae0011e8f5c8ad956cff05c6ce9748e39611dd102610ed3731df707e06aac7dfdb9af959337080be2a167114792c2d83c9567b3cabd30047c1caaa03ee8c66d87ba53a97eceafe430a54cebca6fa75bd798f04256e15db236b65bc227f8636077691d435ff1d7a19ee8136fc1c589d1b5fc78503a2e985231a9d05b987cc08220d625027328464bb043497b2239b4078f2be7d2185efd6308e7784e2884462741a874a1fbf2c651edfdefdbd73d7f9b8a7353a98eec64a4dc5886fb5d0b2420b2e2830e7949b13f0774fb2949b3973e0d603cd98207802cfaec49510710664ef38a6df2b3679ba9e48aa0a6485f60206493b4fab7a6346219e900d43bf9768617b16c15f4bee8610a8d4c55a66543199699216a30ae04d26af56b3bba890ae718049f960ae8d6661e355cf2845827e23afb97d070fc9c604f20396eb2958
diff --git a/test/vectors/sig-L28-N1.hex b/test/vectors/sig-L28-N1.hex
@@ -0,0 +1 @@
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
diff --git a/test/vectors/sig-L32-N0.hex b/test/vectors/sig-L32-N0.hex
@@ -0,0 +1 @@
+002060dd479846271d99d47bee909a4d7cbd1dba4c344b033b4a49ed4dec5dbc2ccf6338124298364f713406efdaaf00b80cb2374bf82a1d309a696a24702e857db1bf620fab6c97f2df7517fe0f9dc79f808970b0f1b125463864ba496fd03b915b168c920ecd062fbe8f03c741e174d15a81796cbfa897094ffffc953074b0e741f3cfa76f6b6a196f9c7a6c397e7d2cc55f9691dfb418b494155b50acb24494d700434ef4f0c8da52f670f08b91b4514f79b422eceedb7d9ec6a4e1758542a8b341567f96a6fe643a0f9efc0564273d423001cf8d9c224b421b023b918b70fe1969f2d53e8570f72492ceec4757ed7ff4909fc1da517a5688bd2bc7beebaeb783bff714c1820492b023b94468a30ab5ad1781b2cfb6b758624cfff9ae6f1f36014b5cca59e9b42d8c9720bf096928bde317016e2eceae5febc241f3b3793ee822c16acc9f70c334b6ce58f7ce9e8c8cc7864d19615702d99cf1e9939bb8d3a5645cd25131cc85958f70ffdfbd33f9cdbd4bf5cf274697f8c99c57f4253210b5bf451102e40e8315f26d0919cfdbb5477193aa647c6002ee6884e615f1a371b04c491fb1dd67a471eb3dd8972f55137e04f970854ffd113f4a2c789903e04aafddf4deb29ebce12a33304019a0f0e8e9d049b70a40ca31ff6bb8b9840a4cb8f3bef67bcfa77adf93446e9f9eab3b7102977dda904f2188788f04dfe51e162a021ad9f86438f9a26e2437480ef8bfff1d5b0569586d700bd8d7eb347af5fd28f8cb312f29b1bd27d5f36b53fb0ceddcb78676d7f12bf050105f572e742d8c8a9775881919eee8651e2b390e8e95df48e7d3c7a220a73839fb600bc8ea47c85fd2dcb60765830d85c5a74cf1bfa45a6f78cad1dee68d15a3deb0267d29d8d8facf51e56bf620fc27f84395a17c60e14bbcdd84d2db478501beee26ddc7d02b838fda881589c95bba4f0554432a34f9b83c9709ceece56ffd9b283b24a4b161e080b5ac541d3e8186758c2244aa36fee384f1c3b4d7cd317be94562b6b79a6d552d50ad48b148985b36561d8dc454e1f64b0465f22b892e41ba8818143423e33f2de175662ec2ff960591c394a8209ada2aabf8cb6d1c3a5790ff3853287d7d943a8018f23947fe90b13c0b759d4bc12bfa272651a06fc2f8f8e8b84a3b72f8d7739525151b7fb8cdf7b911eec33b8d2aef0e8ee946b2eaa4fea78ac6b442f8bc54a9aa6562546102a9895ae22b57524e329575ebfc17d47ecafccdfc5ce3136b8c3be0e93cfe5030489ab9da1b480289bd2e8f0a7bc156200d893afabb46f67696736ea1510a27b48f19201ee78d2170220a9315b81e1a0051bb37e822af5f66487c30bad36e939d39249ded9ebd22c01736fa262ec883d34efab5a5bd9eea8373157eb508953b07fb6077e5095c0ec4c39cb7642a0bd2d46968c3fa2cad14598e00a9a72170358f227d1151b14dc760082329572c80102a44e504ba97d5efca5198264d4ab53d4da81bf9830d841e64a9647dd5566290ce9633e0c0c7ddffadc259
diff --git a/test/vectors/sig-L32-N1.hex b/test/vectors/sig-L32-N1.hex
@@ -0,0 +1 @@
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
diff --git a/test/vectors/sig-L32-N2.hex b/test/vectors/sig-L32-N2.hex
@@ -0,0 +1 @@
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
diff --git a/test/vectors/sig-L48-N0.hex b/test/vectors/sig-L48-N0.hex
@@ -0,0 +1 @@
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
diff --git a/test/vectors/sig-L48-N1.hex b/test/vectors/sig-L48-N1.hex
@@ -0,0 +1 @@
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
diff --git a/test/vectors/sig-L64-N0.hex b/test/vectors/sig-L64-N0.hex
@@ -0,0 +1 @@
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
diff --git a/test/vectors/sig-L64-N1.hex b/test/vectors/sig-L64-N1.hex
@@ -0,0 +1 @@
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