commit 8b07b04885e311e6540231ea57423444b0af5bcd
parent 2fc824e2073a38fda6d3d9b72d8aa1213fe7c9ef
Author: finwo <finwo@pm.me>
Date: Fri, 9 Oct 2026 19:14:28 +0200
Tie core together in abi
Diffstat:
| M | src/sfinx.c | | | 335 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------ |
| M | src/sfinx.h | | | 53 | +++++++++++++++++++++++++++++++++++++++++++++++++++-- |
| M | test/02-wots.c | | | 8 | ++++---- |
| A | test/05-tree.c | | | 54 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| A | test/06-api.c | | | 42 | ++++++++++++++++++++++++++++++++++++++++++ |
5 files changed, 463 insertions(+), 29 deletions(-)
diff --git a/src/sfinx.c b/src/sfinx.c
@@ -3,6 +3,7 @@
#include <coruus/keccak-tiny.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
// E4M4 {{{
//
@@ -70,6 +71,16 @@ size_t sfinx_hash_len(sfinx_hash hash) {
}
return 0;
}
+
+static inline sfinx_hash _sfinx_hash_from_len(size_t len) {
+ switch (len) {
+ case 28: return SFINX_HASH_224;
+ case 32: return SFINX_HASH_256;
+ case 48: return SFINX_HASH_384;
+ case 64: return SFINX_HASH_512;
+ }
+ return 0;
+}
// }}}
// WOTS {{{
@@ -79,8 +90,9 @@ size_t sfinx_hash_len(sfinx_hash hash) {
// preimage = SHAKE256(key), c * L bytes, c elements of L bytes
// digits = the value bytes, then 2 checksum bytes of 255 - value[i]
// pubkey = H of every element chained w times
-// proof = every element chained d[i] times
-// verify = chain every proof element w - d[i] times, then the pubkey hash
+// sign = every preimage element chained d[i] times
+// rebuild = chain every proof element w - d[i] times, then the pubkey hash
+// verify = rebuild over the value and compare to a known pubkey
#define SFINX_WOTS_BYTES_MAX ((SFINX_HASH_LEN_MAX + 2) * SFINX_HASH_LEN_MAX)
#define SFINX_WOTS_DIGITS_MAX (SFINX_HASH_LEN_MAX + 2)
@@ -120,23 +132,26 @@ static inline void _sfinx_wots_pubkey(sfinx_hash hash, const uint8_t *key, size_
_sfinx_hash(hash, ends, (len + 2) * len, pubkey_out);
}
-static inline void _sfinx_wots_proof(sfinx_hash hash, const uint8_t *key, size_t key_len, const uint8_t *value,
- uint8_t *proof_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) {
size_t len = sfinx_hash_len(hash);
uint8_t digits[SFINX_WOTS_DIGITS_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);
for (size_t i = 0; i < len + 2; i++) {
_sfinx_wots_chain(hash, proof_out + i * len, digits[i]);
}
+ return SFINX_OK;
}
-static inline int _sfinx_wots_verify(sfinx_hash hash, const uint8_t *pubkey, 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,
+ uint8_t *pubkey_out) {
size_t len = sfinx_hash_len(hash);
uint8_t digits[SFINX_WOTS_DIGITS_MAX];
uint8_t ends[SFINX_WOTS_BYTES_MAX];
- uint8_t want[SFINX_HASH_LEN_MAX];
uint8_t node[SFINX_HASH_LEN_MAX];
_sfinx_wots_digits(hash, value, digits);
for (size_t i = 0; i < len + 2; i++) {
@@ -144,16 +159,24 @@ static inline int _sfinx_wots_verify(sfinx_hash hash, const uint8_t *pubkey, con
_sfinx_wots_chain(hash, node, 256 - digits[i]);
memcpy(ends + i * len, node, len);
}
- _sfinx_hash(hash, ends, (len + 2) * len, want);
- return memcmp(want, pubkey, len) == 0;
+ _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) {
+ uint8_t want[SFINX_HASH_LEN_MAX];
+ _sfinx_wots_rebuild(hash, value, proof, want);
+ return memcmp(want, pubkey, sfinx_hash_len(hash)) == 0;
}
// }}}
-// Merkle {{{
+// Subtree {{{
//
-// Position-keyed parent hash of a binary subtree of height 8, 256 leaves
-// parent = H(bitlen | mask | prefix | left | right)
-// bitlen = the sub-byte depth d, mask = index & (0xFF << (8 - d)), low bits dropped
+// One binary subtree of height 8, 256 WOTS leaves folded into a root
+// leaf i is keyed by SHAKE256(seed | prefix | i)
+// parent = H(bitlen | mask | prefix | left | right), the mask from the leaf index
+// build returns the root, and for one leaf the 8 auth siblings, deepest first
+// verify folds a leaf and its siblings back up to the root
static inline uint8_t _sfinx_node_mask(uint8_t bitlen, uint8_t index) {
return (uint8_t)(index & (0xFFu << (8 - bitlen)));
@@ -162,7 +185,7 @@ static inline uint8_t _sfinx_node_mask(uint8_t bitlen, uint8_t index) {
static inline void _sfinx_merkle_parent(sfinx_hash hash, 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 = sfinx_hash_len(hash);
- uint8_t buf[2 + SFINX_PATH_LEN_MAX + 2 * SFINX_HASH_LEN_MAX];
+ uint8_t buf[2 + prefix_len + 2 * len];
size_t at = 0;
buf[at++] = bitlen;
buf[at++] = mask;
@@ -176,15 +199,6 @@ static inline void _sfinx_merkle_parent(sfinx_hash hash, uint8_t bitlen, uint8_t
at += len;
_sfinx_hash(hash, buf, at, out);
}
-// }}}
-
-// Subtree {{{
-//
-// One subtree of height 8, 256 WOTS leaves folded into a root
-// leaf i is keyed by SHAKE256(seed | prefix | i)
-// parent = H(bitlen | mask | prefix | left | right), the mask from the leaf index
-// build returns the root, and for one leaf the 8 auth siblings, deepest first
-// verify folds a leaf and its siblings back up to the root
static inline int _sfinx_subtree_build(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) {
@@ -242,4 +256,279 @@ static inline void _sfinx_subtree_verify(sfinx_hash hash, const uint8_t *prefix,
}
// }}}
+// API - Sign {{{
+//
+// Thin wrappers over WOTS and Subtree, one WOTS per layer
+// single = one WOTS over SHAKE256(seed), signs H(message)
+// tree = N subtrees, layer k signs R_k, R_N = org = H(path | message)
+
+sfinx_status sfinx_single_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, uint8_t *pubkey_out,
+ size_t pubkey_cap, size_t *pubkey_len_out) {
+ size_t len = sfinx_hash_len(hash);
+ if (len == 0 || seed_len > SFINX_SEED_LEN_MAX) {
+ return SFINX_ERR_ARGS;
+ }
+ if (!pubkey_out || pubkey_cap < len) {
+ return SFINX_ERR_NOSPACE;
+ }
+ _sfinx_wots_pubkey(hash, seed, seed_len, pubkey_out);
+ if (pubkey_len_out) {
+ *pubkey_len_out = len;
+ }
+ return SFINX_OK;
+}
+
+sfinx_status sfinx_single_sign(sfinx_hash hash, const uint8_t *seed, size_t seed_len, const uint8_t *msg,
+ size_t msg_len, uint8_t *sig, size_t sig_cap, size_t *sig_len_out) {
+ size_t len = sfinx_hash_len(hash);
+ size_t need = sfinx_signature_len(hash, 0);
+ uint8_t org[SFINX_HASH_LEN_MAX];
+ if (len == 0 || seed_len > SFINX_SEED_LEN_MAX) {
+ return SFINX_ERR_ARGS;
+ }
+ if (!sig || sig_cap < need) {
+ return SFINX_ERR_NOSPACE;
+ }
+ _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) {
+ return SFINX_ERR_ARGS;
+ }
+ if (sig_len_out) {
+ *sig_len_out = need;
+ }
+ return SFINX_OK;
+}
+
+sfinx_status sfinx_tree_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, uint8_t *pubkey_out,
+ size_t pubkey_cap, size_t *pubkey_len_out) {
+ size_t len = sfinx_hash_len(hash);
+ if (len == 0 || seed_len > SFINX_SEED_LEN_MAX) {
+ return SFINX_ERR_ARGS;
+ }
+ if (!pubkey_out || pubkey_cap < len) {
+ return SFINX_ERR_NOSPACE;
+ }
+ if (!_sfinx_subtree_build(hash, seed, seed_len, NULL, 0, 0, pubkey_out, NULL)) {
+ return SFINX_ERR_NOSPACE;
+ }
+ if (pubkey_len_out) {
+ *pubkey_len_out = len;
+ }
+ return SFINX_OK;
+}
+
+sfinx_status sfinx_tree_sign(sfinx_hash hash, 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 sig_cap,
+ size_t *sig_len_out) {
+ size_t len = sfinx_hash_len(hash);
+ size_t c = len + 2;
+ size_t need = sfinx_signature_len(hash, path_len);
+ uint8_t org[SFINX_HASH_LEN_MAX];
+ uint8_t value[SFINX_HASH_LEN_MAX];
+ uint8_t root[SFINX_HASH_LEN_MAX];
+ uint8_t auth[8 * SFINX_HASH_LEN_MAX];
+ uint8_t *key;
+ uint8_t *joined;
+ size_t at;
+
+ if (len == 0 || seed_len > SFINX_SEED_LEN_MAX || !path || path_len == 0 || !sfinx_path_len_valid(path_len)) {
+ return SFINX_ERR_ARGS;
+ }
+ if (!sig || sig_cap < need) {
+ return SFINX_ERR_NOSPACE;
+ }
+ joined = malloc(path_len + msg_len);
+ key = malloc(seed_len + path_len);
+ if (!joined || !key) {
+ free(joined);
+ free(key);
+ return SFINX_ERR_NOSPACE;
+ }
+ // Sign (path||message)
+ memcpy(joined, path, path_len);
+ memcpy(joined + path_len, msg, msg_len);
+ _sfinx_hash(hash, joined, path_len + msg_len, org);
+ free(joined);
+ // Start at (seed||full-path) for WOTS
+ memcpy(key, seed, seed_len);
+ memcpy(key + seed_len, path, path_len);
+
+ // Prep sig header
+ _sfinx_e4m4_encode((uint32_t)path_len, sig);
+ memcpy(sig + 1, path, path_len);
+ at = 1 + path_len;
+ _sfinx_e4m4_encode((uint32_t)len, sig + at);
+ at += 1;
+
+ // WOTS-sign up the tree
+ memcpy(value, org, len);
+ for (size_t k = path_len; k >= 1; k--) {
+ if (!_sfinx_subtree_build(hash, seed, seed_len, path, k - 1, path[k - 1], root, auth)) {
+ free(key);
+ return SFINX_ERR_NOSPACE;
+ }
+ if (_sfinx_wots_sign(hash, key, seed_len + k, value, len, sig + at) != SFINX_OK) {
+ free(key);
+ return SFINX_ERR_ARGS;
+ }
+ at += c * len;
+ memcpy(sig + at, auth, 8 * len);
+ at += 8 * len;
+ memcpy(value, root, len);
+ }
+
+ free(key);
+ if (sig_len_out) {
+ *sig_len_out = need;
+ }
+ return SFINX_OK;
+}
+
+// }}}
+
+// API - Verify {{{
+//
+// Parse the layout, then walk from the top round down
+// single: rebuild the one WOTS pubkey over H(message) and compare
+// tree: rebuild layer k over R_k, fold subtree k-1 to R_{k-1}, R_0 is the pubkey
+
+sfinx_status sfinx_verify(const uint8_t *pubkey, size_t pubkey_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;
+ sfinx_hash hash;
+ uint8_t org[SFINX_HASH_LEN_MAX];
+ uint8_t value[SFINX_HASH_LEN_MAX];
+ uint8_t leaf[SFINX_HASH_LEN_MAX];
+ uint8_t root[SFINX_HASH_LEN_MAX];
+ const uint8_t *path;
+ uint8_t *joined;
+
+ if (!pubkey || !sig || sig_len < 2) {
+ return SFINX_ERR_ARGS;
+ }
+ path_len = _sfinx_e4m4_decode(sig[0]);
+ path = sig + 1;
+ at = 1 + path_len;
+ if (!sfinx_path_len_valid(path_len) || sig_len < at + 1) {
+ return SFINX_ERR_FORMAT;
+ }
+ len = _sfinx_e4m4_decode(sig[at]);
+ at += 1;
+ hash = _sfinx_hash_from_len(len);
+ if (!hash || len != pubkey_len || sig_len != sfinx_signature_len(hash, path_len)) {
+ return SFINX_ERR_FORMAT;
+ }
+ c = len + 2;
+ if (path_len == 0) {
+ _sfinx_hash(hash, msg, msg_len, org);
+ _sfinx_wots_rebuild(hash, org, sig + at, leaf);
+ return memcmp(leaf, pubkey, len) == 0 ? SFINX_OK : SFINX_ERR_VERIFY;
+ }
+ joined = malloc(path_len + msg_len);
+ if (!joined) {
+ return SFINX_ERR_NOSPACE;
+ }
+ memcpy(joined, path, path_len);
+ memcpy(joined + path_len, msg, msg_len);
+ _sfinx_hash(hash, joined, path_len + msg_len, org);
+ free(joined);
+ memcpy(value, org, len);
+ for (size_t k = path_len; k >= 1; k--) {
+ _sfinx_wots_rebuild(hash, value, sig + at, leaf);
+ at += c * len;
+ _sfinx_subtree_verify(hash, path, k - 1, leaf, path[k - 1], sig + at, root);
+ at += 8 * len;
+ if (k == 1) {
+ return memcmp(root, pubkey, len) == 0 ? SFINX_OK : SFINX_ERR_VERIFY;
+ }
+ memcpy(value, root, len);
+ }
+ return SFINX_ERR_FORMAT;
+}
+// }}}
+
+// API - Utilities {{{
+//
+// Pure size helpers, status names, and the optional RNG
+// sizes = E4M4(N) | path | E4M4(L) | N rounds of WOTS proof and auth path
+
+const char *sfinx_strerror(sfinx_status status) {
+ switch (status) {
+ case SFINX_OK: return "ok";
+ case SFINX_ERR_ARGS: return "invalid arguments";
+ case SFINX_ERR_PATH_LEN: return "invalid path length";
+ case SFINX_ERR_NOSPACE: return "no space available";
+ case SFINX_ERR_FORMAT: return "invalid signature format";
+ case SFINX_ERR_VERIFY: return "verification failed";
+ case SFINX_ERR_RANDOM: return "random source failed";
+ case SFINX_ERR_UNIMPLEMENTED: return "unimplemented";
+ }
+ return "unknown error";
+}
+
+const char *sfinx_version(void) {
+ return "0.1.0";
+}
+
+size_t sfinx_signature_len(sfinx_hash hash, size_t path_len) {
+ size_t len = sfinx_hash_len(hash);
+ if (len == 0) {
+ return 0;
+ }
+ if (path_len == 0) {
+ return 2 + (len + 2) * len;
+ }
+ return 2 + path_len + path_len * (len + 10) * len;
+}
+
+size_t sfinx_signature_len_max(sfinx_hash hash) {
+ return sfinx_signature_len(hash, SFINX_PATH_LEN_MAX);
+}
+
+int sfinx_path_len_valid(size_t path_len) {
+ uint8_t byte;
+ return path_len <= SFINX_PATH_LEN_MAX && _sfinx_e4m4_encode((uint32_t)path_len, &byte);
+}
+
+sfinx_status sfinx_signature_info(const uint8_t *sig, size_t sig_len, sfinx_hash *hash_out, size_t *path_len_out) {
+ size_t path_len;
+ sfinx_hash hash;
+ if (!sig || sig_len < 2) {
+ return SFINX_ERR_ARGS;
+ }
+ path_len = _sfinx_e4m4_decode(sig[0]);
+ if (!sfinx_path_len_valid(path_len) || sig_len < 2 + path_len) {
+ return SFINX_ERR_FORMAT;
+ }
+ hash = _sfinx_hash_from_len(_sfinx_e4m4_decode(sig[1 + path_len]));
+ if (!hash) {
+ return SFINX_ERR_FORMAT;
+ }
+ if (hash_out) {
+ *hash_out = hash;
+ }
+ if (path_len_out) {
+ *path_len_out = path_len;
+ }
+ return SFINX_OK;
+}
+
+sfinx_status sfinx_random_bytes(uint8_t *out, size_t len) {
+ while (len > 0) {
+ size_t chunk = len > 256 ? 256 : len;
+ if (getentropy(out, chunk) != 0) {
+ return SFINX_ERR_RANDOM;
+ }
+ out += chunk;
+ len -= chunk;
+ }
+ return SFINX_OK;
+}
+// }}}
+
// vim:fdm=marker:fdl=0
diff --git a/src/sfinx.h b/src/sfinx.h
@@ -25,10 +25,59 @@ size_t sfinx_hash_len(sfinx_hash hash);
// Path {{{
//
// N is the number of subtrees, and the path length in bytes
-// 32 by default, at most 64
+// 32 by default, the only bound is E4M4, 507904
#define SFINX_PATH_LEN_DEFAULT 32
-#define SFINX_PATH_LEN_MAX 64
+#define SFINX_PATH_LEN_MAX 507904
+// }}}
+
+// Seed {{{
+//
+// Any byte string, at most 64 MiB, random recommended
+
+#define SFINX_SEED_LEN_MAX (64u * 1024u * 1024u)
+// }}}
+
+// Status {{{
+//
+// Every entry point returns one of these, sfinx_strerror names them
+
+typedef enum {
+ SFINX_OK = 0,
+ SFINX_ERR_ARGS,
+ SFINX_ERR_PATH_LEN,
+ SFINX_ERR_NOSPACE,
+ SFINX_ERR_FORMAT,
+ SFINX_ERR_VERIFY,
+ SFINX_ERR_RANDOM,
+ SFINX_ERR_UNIMPLEMENTED
+} sfinx_status;
+
+const char *sfinx_strerror(sfinx_status status);
+const char *sfinx_version(void);
+// }}}
+
+// API {{{
+//
+// Sizes are pure, the key and sign calls take the seed, verify takes raw bytes
+
+size_t sfinx_signature_len(sfinx_hash hash, size_t path_len);
+size_t sfinx_signature_len_max(sfinx_hash hash);
+int sfinx_path_len_valid(size_t path_len);
+sfinx_status sfinx_signature_info(const uint8_t *sig, size_t sig_len, sfinx_hash *hash_out, size_t *path_len_out);
+
+sfinx_status sfinx_single_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, uint8_t *pubkey_out,
+ size_t pubkey_cap, size_t *pubkey_len_out);
+sfinx_status sfinx_single_sign(sfinx_hash hash, const uint8_t *seed, size_t seed_len, const uint8_t *msg,
+ size_t msg_len, uint8_t *sig, size_t sig_cap, size_t *sig_len_out);
+sfinx_status sfinx_tree_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, uint8_t *pubkey_out,
+ size_t pubkey_cap, size_t *pubkey_len_out);
+sfinx_status sfinx_tree_sign(sfinx_hash hash, 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 sig_cap,
+ size_t *sig_len_out);
+sfinx_status sfinx_verify(const uint8_t *pubkey, size_t pubkey_len, const uint8_t *msg, size_t msg_len,
+ const uint8_t *sig, size_t sig_len);
+sfinx_status sfinx_random_bytes(uint8_t *out, size_t len);
// }}}
#endif // __SFINX_H__
diff --git a/test/02-wots.c b/test/02-wots.c
@@ -70,18 +70,18 @@ int main(void) {
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_proof(SFINX_HASH_256, seed, seed_len, value, proof);
+ _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");
proof[17] ^= 0x40;
tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof), "tampered proof fails", "verify passed");
- _sfinx_wots_proof(SFINX_HASH_256, seed, seed_len, value, proof);
+ _sfinx_wots_sign(SFINX_HASH_256, seed, 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");
_sfinx_hash(SFINX_HASH_256, (const uint8_t *)"hello", 5, value);
- _sfinx_wots_proof(SFINX_HASH_256, seed, seed_len, value, proof);
+ _sfinx_wots_sign(SFINX_HASH_256, seed, 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");
@@ -89,7 +89,7 @@ int main(void) {
for (size_t h = 0; h < 4; h++) {
_sfinx_hash(hashes[h], (const uint8_t *)"message", 7, value);
_sfinx_wots_pubkey(hashes[h], seed, seed_len, pubkey);
- _sfinx_wots_proof(hashes[h], seed, seed_len, value, proof);
+ _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");
}
diff --git a/test/05-tree.c b/test/05-tree.c
@@ -0,0 +1,54 @@
+#include <string.h>
+
+#include "_tap.c"
+#include "src/sfinx.c"
+
+#define SIG_MAX 8192
+
+int main(void) {
+ static const uint8_t seed[] = "sfinx tree seed";
+ static const uint8_t msg[] = "hello tree";
+ uint8_t single_pub[SFINX_HASH_LEN_MAX];
+ uint8_t tree_pub[SFINX_HASH_LEN_MAX];
+ uint8_t path1[1] = {0xa5};
+ uint8_t path2[2] = {0xa5, 0x3c};
+ uint8_t sig[SIG_MAX];
+ uint8_t sig2[SIG_MAX];
+ size_t len = sfinx_hash_len(SFINX_HASH_256);
+ size_t seed_len = strlen((const char *)seed);
+ size_t msg_len = strlen((const char *)msg);
+ size_t n0 = sfinx_signature_len(SFINX_HASH_256, 0);
+ size_t n1 = sfinx_signature_len(SFINX_HASH_256, 1);
+ size_t n2 = sfinx_signature_len(SFINX_HASH_256, 2);
+ size_t outlen;
+
+ tap_begin("sfinx tree");
+
+ tap(sfinx_single_public_key(SFINX_HASH_256, seed, seed_len, single_pub, len, &outlen) == SFINX_OK,
+ "single pubkey builds", "build failed");
+ tap(sfinx_single_sign(SFINX_HASH_256, seed, seed_len, msg, msg_len, sig, n0, &outlen) == SFINX_OK, "single signs",
+ "sign failed");
+ tap(sfinx_verify(single_pub, len, msg, msg_len, sig, n0) == SFINX_OK, "single verifies", "verify failed");
+ sig[5] ^= 0x01;
+ tap(sfinx_verify(single_pub, len, msg, msg_len, sig, n0) != SFINX_OK, "single tamper fails", "verify passed");
+
+ tap(sfinx_tree_public_key(SFINX_HASH_256, seed, seed_len, tree_pub, len, &outlen) == SFINX_OK, "tree pubkey builds",
+ "build failed");
+ tap(sfinx_tree_sign(SFINX_HASH_256, seed, seed_len, path1, 1, msg, msg_len, sig, n1, &outlen) == SFINX_OK,
+ "tree signs N=1", "sign failed");
+ tap(sfinx_verify(tree_pub, len, msg, msg_len, sig, n1) == SFINX_OK, "tree verifies N=1", "verify failed");
+ sig[n1 - 1] ^= 0x01;
+ tap(sfinx_verify(tree_pub, len, msg, msg_len, sig, n1) != SFINX_OK, "tree tamper N=1 fails", "verify passed");
+
+ tap(sfinx_tree_sign(SFINX_HASH_256, seed, seed_len, path2, 2, msg, msg_len, sig2, n2, &outlen) == SFINX_OK,
+ "tree signs N=2", "sign failed");
+ tap(sfinx_verify(tree_pub, len, msg, msg_len, sig2, n2) == SFINX_OK, "tree verifies N=2", "verify failed");
+ tap(sfinx_verify(tree_pub, len, (const uint8_t *)"other", 5, sig2, n2) != SFINX_OK, "tree wrong message fails",
+ "verify passed");
+
+ tree_pub[0] ^= 0x01;
+ tap(sfinx_verify(tree_pub, len, msg, msg_len, sig2, n2) != SFINX_OK, "tree wrong pubkey fails", "verify passed");
+ tree_pub[0] ^= 0x01;
+
+ return tap_plan();
+}
diff --git a/test/06-api.c b/test/06-api.c
@@ -0,0 +1,42 @@
+#include "src/sfinx.c"
+#include "_tap.c"
+
+#include <string.h>
+
+static void check_size(size_t got, size_t want, const char *what) {
+ tap(got == want, what, "got %zu, want %zu", got, want);
+}
+
+int main(void) {
+ uint8_t sig[3] = {0x01, 0xaa, 0x20};
+ uint8_t bad[3] = {0x41, 0xaa, 0x20};
+ sfinx_hash hash = SFINX_HASH_224;
+ size_t path_len = 99;
+
+ tap_begin("sfinx api");
+
+ check_size(sfinx_hash_len(SFINX_HASH_256), 32, "hash_len 256");
+ check_size(sfinx_signature_len(SFINX_HASH_256, 0), 1090, "signature_len N=0");
+ check_size(sfinx_signature_len(SFINX_HASH_256, 1), 1347, "signature_len N=1");
+ check_size(sfinx_signature_len(SFINX_HASH_256, 32), 2 + 32 + 32 * 1344, "signature_len N=32");
+ check_size(sfinx_signature_len_max(SFINX_HASH_256), sfinx_signature_len(SFINX_HASH_256, SFINX_PATH_LEN_MAX),
+ "signature_len_max");
+
+ tap(sfinx_path_len_valid(0), "path_len 0 valid", "rejected");
+ tap(sfinx_path_len_valid(32), "path_len 32 valid", "rejected");
+ tap(!sfinx_path_len_valid(33), "path_len 33 invalid", "accepted");
+ tap(!sfinx_path_len_valid(63), "path_len 63 invalid", "accepted");
+ tap(sfinx_path_len_valid(64), "path_len 64 valid", "rejected");
+ tap(!sfinx_path_len_valid(SFINX_PATH_LEN_MAX + 1), "path_len over max invalid", "accepted");
+
+ tap(strcmp(sfinx_strerror(SFINX_OK), "ok") == 0, "strerror ok", "got %s", sfinx_strerror(SFINX_OK));
+ tap(sfinx_version()[0] != '\0', "version non-empty", "empty");
+
+ tap(sfinx_signature_info(sig, sizeof(sig), &hash, &path_len) == SFINX_OK, "signature_info parses", "failed");
+ check_size(path_len, 1, "signature_info path_len");
+ tap(hash == SFINX_HASH_256, "signature_info hash", "got %d", (int)hash);
+ tap(sfinx_signature_info(sig, sizeof(sig), NULL, NULL) == SFINX_OK, "signature_info accepts NULL outs", "failed");
+ tap(sfinx_signature_info(bad, sizeof(bad), NULL, NULL) == SFINX_ERR_FORMAT, "signature_info rejects bad N", "accepted");
+
+ return tap_plan();
+}