sfinx

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

commit 8b07b04885e311e6540231ea57423444b0af5bcd
parent 2fc824e2073a38fda6d3d9b72d8aa1213fe7c9ef
Author: finwo <finwo@pm.me>
Date:   Fri,  9 Oct 2026 19:14:28 +0200

Tie core together in abi

Diffstat:
Msrc/sfinx.c | 335+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
Msrc/sfinx.h | 53+++++++++++++++++++++++++++++++++++++++++++++++++++--
Mtest/02-wots.c | 8++++----
Atest/05-tree.c | 54++++++++++++++++++++++++++++++++++++++++++++++++++++++
Atest/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(); +}