commit 9a442bac4584f7be428b34273d17fa2c046ef7e3
parent 8794442a1a1a684af848b0f252d7918d3c9850f1
Author: finwo <finwo@pm.me>
Date: Tue, 13 Oct 2026 01:32:17 +0200
Bind path length into key derivation
Diffstat:
31 files changed, 321 insertions(+), 155 deletions(-)
diff --git a/README.md b/README.md
@@ -8,9 +8,9 @@ that is never stored. Every key is derived from the seed and the path that
reaches it, so there is no counter and no state file to keep in sync. The secret
is a seed, and the public key is a single hash.
-The hash size and the path length are arguments rather than build options, and
-the top of the tree is fixed, so one keypair covers every path length at a given
-hash size.
+The hash size and the tree depth (`-p`) are arguments rather than build options.
+The depth defaults to 32 and sets the signature size. The docs cover changing
+either.
This project makes use of [dep](https://git.finwo.net/app/dep) to manage its
dependencies and exports.
@@ -19,7 +19,7 @@ Features
--------
- The seed is any byte string up to 64 MiB, random bytes recommended
-- Hash size and path length are chosen per call
+- Hash size and tree depth are chosen per call
- Hashing comes from [keccak-fast](https://git.finwo.net/lib/keccak-fast.c),
dispatched per CPU and batched
- C99 with POSIX calls, needing only libc and the hash core
@@ -61,7 +61,7 @@ Usage
```sh
sfinx generate -o demo.key
-sfinx sign -k demo.key -p 32 -m "hello sfinx" -o demo.sig
+sfinx sign -k demo.key -m "hello sfinx" -o demo.sig
sfinx verify -k demo.key -S demo.sig -m "hello sfinx"
```
@@ -70,8 +70,7 @@ random 32-byte path, so the same message signs differently every time, and
`verify` prints `OK` or `FAIL`. At these defaults a signature is 43,042 bytes.
The path is the randomizer and must not repeat across messages. Drawn at random
-it collides after roughly `2^128` signatures, which is what makes a one-time
-construction usable many times.
+it collides after roughly `2^128` signatures.
### Single-key mode
diff --git a/docs/api.md b/docs/api.md
@@ -171,14 +171,14 @@ sfinx_status sfinx_single_sign(sfinx_hash hash, const uint8_t *seed, size_t seed
</details>
<details>
- <summary>sfinx_tree_public_key(hash, seed, seed_len, pubkey_out, pubkey_cap, pubkey_len_out)</summary>
+ <summary>sfinx_tree_public_key(hash, seed, seed_len, path_len, pubkey_out, pubkey_cap, pubkey_len_out)</summary>
- Derive the tree public key from a seed. The top subtree is fixed, so the
- result covers every path length at this hash size.
+ Derive the tree public key from a seed. `N` is bound into every key, so a
+ public key verifies one path length.
```c
-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_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, size_t path_len,
+ uint8_t *pubkey_out, size_t pubkey_cap, size_t *pubkey_len_out);
```
</details>
@@ -222,7 +222,8 @@ Keys
----
A key holds a seed, a public key, or both. A null `seed` means public-only.
-Decoding allocates into the key, `sfinx_key_free` releases it.
+Decoding allocates into the key, `sfinx_key_free` releases it. `path_len`
+is the length the public half was derived for, -1 when not recorded.
```c
typedef struct {
@@ -230,6 +231,7 @@ typedef struct {
size_t seed_len;
uint8_t *pub;
size_t pub_len;
+ ssize_t path_len;
sfinx_hash hash;
} sfinx_key;
```
@@ -237,7 +239,7 @@ typedef struct {
<details>
<summary>sfinx_key_init(key)</summary>
- Zero a key and set the default hash size
+ Zero a key and set the default hash size and path length
```c
void sfinx_key_init(sfinx_key *key);
@@ -257,8 +259,8 @@ void sfinx_key_free(sfinx_key *key);
<details>
<summary>sfinx_key_derive(key)</summary>
- Fill in the public key from the seed. A key that already carries one is
- left alone.
+ Fill in the public key from the seed, for the key's `path_len`. A key
+ that already carries one is left alone.
```c
sfinx_status sfinx_key_derive(sfinx_key *key);
diff --git a/docs/cli.md b/docs/cli.md
@@ -19,10 +19,10 @@ random path of 32 bytes, so the same message signs differently every time.
## Commands
- `sfinx seed [length] [-o file] [--force]`: write `length` random seed bytes, default 32, to stdout or a file.
-- `sfinx generate [length] [-L hash] [--out-fmt fmt] [--single] [-o file] [-F]`: generate a seed and derive its public key. `--out-fmt hdr` writes one combined file, `raw` and `hex` write a key file and a `.pub` file beside it. Stdout carries the seed alone.
-- `sfinx printkey -k file [-L hash] [--in-fmt fmt] [--out-fmt fmt] [--single] [-o file] [--public-only] [--force]`: read a key file, derive the public key from the seed, and re-encode it. `--in-fmt` defaults to auto-detect, `--out-fmt` to `hdr`. `--public-only` drops the seed.
+- `sfinx generate [length] [-L hash] [-p path-len] [--out-fmt fmt] [--single] [-o file] [-F]`: generate a seed and derive its public key. `--out-fmt hdr` writes one combined file, `raw` and `hex` write a key file and a `.pub` file beside it. Stdout carries the seed alone.
+- `sfinx printkey -k file [-L hash] [-p path-len] [--in-fmt fmt] [--out-fmt fmt] [--single] [-o file] [--public-only] [--force]`: read a key file, derive the public key from the seed, and re-encode it. `--in-fmt` defaults to auto-detect, `--out-fmt` to `hdr`. `--public-only` drops the seed.
- `sfinx sign -k keyfile [-L hash] [--single | -p path-len | -P path] [-m message | -M message-file] [--key-fmt fmt] [--sig-fmt fmt] [-o file] [-F]`: sign a message and write the signature. `--key-fmt` defaults to auto-detect with a `raw` seed fallback, `--sig-fmt` to `hex` on stdout and `raw` to a file.
-- `sfinx verify -k keyfile [-L hash] [-s signature | -S signature-file] [-m message | -M message-file] [--key-fmt fmt] [--sig-fmt fmt]`: verify a signature and print `OK` or `FAIL`. `--key-fmt` defaults to auto-detect with a `rawpub` fallback, `--sig-fmt` to auto-detect with a `raw` fallback.
+- `sfinx verify -k keyfile [-L hash] [-p path-len] [-s signature | -S signature-file] [-m message | -M message-file] [--key-fmt fmt] [--sig-fmt fmt]`: verify a signature and print `OK` or `FAIL`. `--key-fmt` defaults to auto-detect with a `rawpub` fallback, `--sig-fmt` to auto-detect with a `raw` fallback.
- `sfinx help` and `sfinx version`.
`-h/--help` on any command prints its options.
@@ -30,7 +30,7 @@ random path of 32 bytes, so the same message signs differently every time.
## Hashing and paths
- `-L hash`: hash size, one of `224`, `256`, `384`, `512`. Default `256`.
-- `-p path-len`: draw a random path of that many bytes.
+- `-p path-len`: the path length. `sign` draws a random path that long, `generate` and `printkey` derive the public key for it, `verify` cross-checks it against the signature.
- `-P path`: use an explicit path, as hex.
- `--single`: single-key mode (`N = 0`), one WOTS key signing `H(message)` for a seed.
- `-F`, `--force`: overwrite existing output files.
@@ -48,7 +48,7 @@ sfinx reads and writes the same files.
Key and signature formats (`--key-fmt`, `--sig-fmt`, `--in-fmt`, `--out-fmt`):
-- `hdr`: text, self-detecting. Lines are `hash:`, `seed:`, `public-key:`, and `signature:`, with hex values.
+- `hdr`: text, self-detecting. Lines are `hash:`, `seed:`, `public-key:`, `path-len:`, and `signature:`. `path-len:` is decimal and accompanies a public key, the rest are hex.
- `raw`: bare bytes. A key seed is bare seed bytes, a signature is bare signature bytes.
- `hex`: lowercase hex, one line.
- `rawpub`: a bare public key, `L` bytes. Explicit only.
@@ -58,5 +58,8 @@ Auto-detect (a null or omitted format) recognises `hdr` and `hex` by looking at
the content. `raw`, `rawpub`, and `hexpub` are never guessed; name them
explicitly.
+`verify` reads the path length from the signature. Only `hdr` records one, and a
+recorded length is cross-checked, naming a mismatch instead of reporting `FAIL`.
+
The wire layout of the signature itself, including `E4M4(N)` and the path, is in
`scheme.md`.
diff --git a/docs/idea.md b/docs/idea.md
@@ -32,11 +32,9 @@ The tree is binary, stacked as `N` subtrees of height `b = 8`.
- Each subtree has 256 leaves, and each leaf is a WOTS public key.
- Each subtree root is only a hash of its children.
- The WOTS at layer `k` signs the root of the subtree below it.
+- The bottom WOTS has no subtree below it, so it signs `org = H(path | message)`.
- The public key is the top subtree root, with nothing above it.
-
-Because the top subtree is fixed, its root is the same for every `N >= 1`, so
-one keypair covers every tree depth. The bottom WOTS has no subtree below it, so
-it signs `org = H(path | message)`.
+- The path length is part of every key derivation, so each depth has its own public key.
`N = 0` collapses the whole thing: no subtrees, no path, and the public key is a
single WOTS key over `org = H(message)`.
@@ -49,14 +47,14 @@ keys.
- `path[0]` is the most significant byte (near the root), `path[N-1]` the least significant (near the message).
- One path byte selects a leaf in one subtree, most significant bit first.
-- A one-time key is named by the truncated path that reaches it, `path[0..k-1]` for a layer-`k` key. No mask and no layer byte, because the path is already split into bytes and SHA3 resists length extension.
+- A one-time key is named `E4M4(N) | path[0..k-1]` for a layer-`k` key. No mask, because the path is already split into bytes and SHA3 resists length extension.
- `N` must be E4M4-representable, because the signature carries it as an E4M4 byte.
## WOTS
Each key is a Winternitz one-time signature over an `L`-byte value.
-- Pre-image: `SHAKE256(seed | path[0..k-1])` for a layer-`k` key, `c * L` bytes, split into `c = L + 2` chains of `L` bytes.
+- 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.
- 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.
@@ -116,22 +114,19 @@ is compared to the public key directly.
- Numbers are MSB first, matching human notation: `E4M4(N)`, `E4M4(L)`, the path bytes (most significant, near the root, first), the `bitlen` and `mask` bytes, and the checksum (high byte first).
- The Merkle neighbour list is a sequence, not a number, so it follows the verification algorithm: LSB (deepest) first, MSB (top) last.
-## Why reuse is fine
-
-The path is random, so every signature normally lands on a fresh set of one-time
-keys. The upper keys only ever sign a fixed subtree root, and the bottom key
-signs `org`, which changes with the path. As long as the path does not repeat, no
-key is ever asked to sign two different values.
-
## How many times can a seed sign?
-What eventually breaks is a path collision: two signatures reaching the same
-bottom key with different messages. The bottom key is named by the full `N`-byte
-path, so for the default `N = 32` the collision space is 256 bits.
+A key is named `E4M4(N) | path[0..k-1]`, which fixes what it signs: the subtree
+root beneath it when `k < N`, `org` when `k = N`. Two signatures share a key
+only at the same `N` and the same prefix.
+
+The limit is therefore a path collision: same `N`, same path, different message.
+The bottom key is named by the full path, so at the default `N = 32` the
+collision space is 256 bits.
-- Random path, which is what the library does: the birthday bound puts a 50 percent chance of one collision at about `2^128` signatures. The scheme is many-time up to roughly `2^128`, even though each individual key is one-time.
-- Tracked paths, where the caller never repeats one: the limit is the path space, `2^256` signatures, on one machine for one purpose. The library tracks nothing, so this is for the caller to build.
-- Single-key mode (`N = 0`): one key signs `H(message)` every time, so two different messages break it. That mode really is one-time.
+- Random path, what the library does: the birthday bound gives a 50 percent chance of one collision at about `2^128` signatures.
+- Tracked paths, where the caller never repeats one: the limit is the path space, `2^256`. The library tracks nothing, so the caller builds this.
+- Single-key mode (`N = 0`): one key signs `H(message)` every time, so two messages break it.
## No state
diff --git a/docs/scheme.md b/docs/scheme.md
@@ -51,25 +51,24 @@ extension, so `seed | prefix` cannot be confused with another prefix.
- The signer draws `N` bytes from a CSPRNG. This is the randomizer and it is carried in the signature.
- `path[0]` is the most significant byte (near the root), `path[N-1]` the least significant (near the message).
- Each path byte navigates one subtree of height `b = 8`, most significant bit first: bit 7 is the decision nearest the subtree root, bit 0 the decision at the leaf.
-- A WOTS key is named by the truncated path that reaches it: a layer-`k` key uses `path[0..k-1]`.
+- A WOTS key is named by `E4M4(N)` and the truncated path that reaches it: a layer-`k` key uses `E4M4(N) | path[0..k-1]`.
- `N` must be E4M4-representable, because `E4M4(N)` leads the signature.
- The library never draws the path. `sfinx_tree_sign` takes `path` as an argument, and `sfinx_random_bytes` is a helper the caller uses.
## WOTS
-One WOTS key signs one `L`-byte value. It is derived from the seed and the
-truncated path that reaches it.
+One WOTS key signs one `L`-byte value, derived from the seed, the path length
+and the truncated path that reaches it.
Pre-image, `c * L = (L + 2) * L` bytes:
```
-stream = SHAKE256(seed | path[0..k-1]) for a layer-k key
+stream = SHAKE256(seed | E4M4(N) | path[0..k-1]) for a layer-k key
pre[i] = stream[i*L .. i*L + L-1] for i in 0..c-1
```
-The layer-0 key (the `N = 0` case) has an empty prefix, so its stream is
-`SHAKE256(seed)`. There is no layer byte, because the truncation length already
-encodes the depth.
+- `E4M4(N)` is at a fixed offset and the prefix length gives `k`, so the key is a bottom key iff `k = N` and interior otherwise.
+- `N = 0` is single mode: empty prefix, `stream = SHAKE256(seed)`.
Digits, from the `L`-byte `value`:
@@ -107,12 +106,11 @@ public key. The parent hash is keyed by the parent's position:
parent = H(bitlen (1) | mask (1) | prefix (k) | left (L) | right (L))
```
-- `prefix` is the byte-aligned path prefix above the parent.
+- For a node at depth `8k + d`, `prefix` is `E4M4(N) | path[0..k-1]` and `bitlen` is `d`.
- `bitlen` is 0..8, the number of sub-byte bits in the position. `mask` holds those bits in its top `bitlen` positions with the low `8 - bitlen` bits zeroed, so a prefix has one encoding.
-- For a node at depth `8k + d`, `prefix` is `path[0..k-1]` and `bitlen` is `d`.
- `left` is the child reached by a 0 bit, `right` the child reached by a 1 bit.
- Keying by position is what moves the tree from collision resistance to second-preimage resistance.
-- A leaf is `H(ends)` over the `c` chain ends, and a parent is keyed by position. The two input shapes differ, so a leaf hash cannot pass as a parent hash.
+- Leaf and parent inputs coincide in length at `L*L - 2` bytes. The verifier's walk is fixed by `N` and the subtree height, so a leaf is never read as a parent.
## Tree structure
@@ -120,7 +118,7 @@ parent = H(bitlen (1) | mask (1) | prefix (k) | left (L) | right (L))
- `R_k` is the root of subtree `k`. `R_0` is the public key. `R_N := org`.
- WOTS at layer `k` signs `R_k`, so `k = N` signs `org` and `1 <= k <= N-1` signs `R_k`.
- `R_{k-1}` is the WOTS pubkey at layer `k` hashed up subtree `k-1` with its `b` neighbours. At `k = 1` that is the public key.
-- `N >= 1`: the public key is `R_0`, the top subtree root, with no WOTS above it. This matches SPHINCS+. `R_0` depends only on the seed and `L`, never on `N`, so one keypair verifies any `N >= 1`.
+- `N >= 1`: the public key is `R_0`, the top subtree root, with no WOTS above it, matching SPHINCS+. `R_0` depends on the seed, `L` and `N`: one public key per length.
- `N = 0`: no subtrees and no path. The public key is the layer-0 WOTS pubkey over `SHAKE256(seed)`, and that key signs `org = H(message)`.
## org
@@ -192,7 +190,7 @@ With `c = L + 2`, at the default `L = 32` (`c = 34`):
A sketch, not reference code.
```c
-// A one-time key is named by the truncated path that reaches it.
+// A key is named E4M4(N) | path[0..k-1] for a layer-k key.
pre_image(seed, prefix) = SHAKE256(seed | prefix, c * L) // c = L + 2
// L message digits, then the 2 checksum digits.
@@ -229,7 +227,7 @@ tree_sign(seed, message, N):
return out
for k = N down to 1:
- out += single_sign(seed, path[0..k-1], value) // the value from below
+ out += single_sign(seed, E4M4(N) | path[0..k-1], value)
out += auth(subtree = k-1, path) // 8 neighbours, LSB first
value = root(subtree = k-1, path) // what the next round signs
diff --git a/src/cli/common.c b/src/cli/common.c
@@ -51,7 +51,7 @@ sfinx_status cli_seed_random(size_t len, uint8_t **out) {
return SFINX_OK;
}
-sfinx_status cli_key_derive(sfinx_key *key, int single) {
+sfinx_status cli_key_derive(sfinx_key *key, int single, ssize_t path_len) {
size_t len;
uint8_t *pub;
sfinx_status status;
@@ -67,9 +67,11 @@ sfinx_status cli_key_derive(sfinx_key *key, int single) {
key->pub = NULL;
key->pub_len = 0;
if (!single) {
+ key->path_len = path_len;
return sfinx_key_derive(key);
}
- pub = malloc(len);
+ key->path_len = 0;
+ pub = malloc(len);
if (!pub) {
return SFINX_ERR_NOSPACE;
}
diff --git a/src/cli/common.h b/src/cli/common.h
@@ -30,7 +30,7 @@ sfinx_status cli_seed_random(size_t len, uint8_t **out);
// single selects the N = 0 key, otherwise the stacked subtrees
// a seed in the key wins over a stored public key, so --hash cannot disagree with the file
-sfinx_status cli_key_derive(sfinx_key *key, int single);
+sfinx_status cli_key_derive(sfinx_key *key, int single, ssize_t path_len);
// }}}
#endif // __SFINX_CLI_COMMON_H__
diff --git a/src/cli/generate.c b/src/cli/generate.c
@@ -67,6 +67,7 @@ static int cmd_generate(int argc, const char **argv) {
int hash = 0;
int single = 0;
int force = 0;
+ int path_len = -1;
size_t seed_len = CLI_SEED_LEN_DEFAULT;
uint8_t *seed = NULL;
uint8_t *key_buf = NULL;
@@ -80,7 +81,7 @@ static int cmd_generate(int argc, const char **argv) {
int rc = 1;
static const char *const usages[] = {
- "sfinx generate [length] [-L hash] [--out-fmt fmt] [--single] [-o file] [-F]",
+ "sfinx generate [length] [-L hash] [-p len] [--out-fmt fmt] [--single] [-o file] [-F]",
NULL,
};
struct argparse_option options[] = {
@@ -88,6 +89,7 @@ static int cmd_generate(int argc, const char **argv) {
OPT_STRING(0, "out-fmt", &format, "hdr writes one file, raw and hex write a key file and a .pub file", NULL, 0,
0),
OPT_INTEGER('L', "hash", &hash, "hash size 224/256/384/512", NULL, 0, 0),
+ OPT_INTEGER('p', "path-len", &path_len, "path length the public key is derived for", NULL, 0, 0),
OPT_STRING('o', "out", &out_file, "key file, - for stdout", NULL, 0, 0),
OPT_BOOLEAN(0, "single", &single, "single-key mode, derive the N = 0 public key", NULL, 0, 0),
OPT_BOOLEAN('F', "force", &force, "overwrite existing files", NULL, 0, 0),
@@ -104,6 +106,19 @@ static int cmd_generate(int argc, const char **argv) {
fprintf(stderr, "sfinx: generate: too many arguments\n");
return 1;
}
+ if (single && path_len != -1) {
+ fprintf(stderr, "sfinx: generate: --single cannot be combined with --path-len\n");
+ return 1;
+ }
+ if (!single) {
+ if (path_len == -1) {
+ path_len = SFINX_PATH_LEN_DEFAULT;
+ }
+ if (path_len <= 0 || !sfinx_path_len_valid((size_t)path_len)) {
+ fprintf(stderr, "sfinx: generate: invalid path length: %d\n", path_len);
+ return 1;
+ }
+ }
if (strcmp(format, "hdr") == 0) {
pub_format = NULL;
} else if (strcmp(format, "raw") == 0) {
@@ -132,7 +147,7 @@ static int cmd_generate(int argc, const char **argv) {
fprintf(stderr, "sfinx: generate: invalid hash size: %d\n", hash);
goto done;
}
- status = cli_key_derive(&key, single);
+ status = cli_key_derive(&key, single, (ssize_t)path_len);
if (status != SFINX_OK) {
fprintf(stderr, "sfinx: generate: cannot derive the public key: %s\n", sfinx_strerror(status));
goto done;
diff --git a/src/cli/printkey.c b/src/cli/printkey.c
@@ -16,6 +16,7 @@ static int cmd_printkey(int argc, const char **argv) {
int public_only = 0;
int single = 0;
int force = 0;
+ int path_len = -1;
uint8_t *data = NULL;
uint8_t *out = NULL;
size_t data_len = 0;
@@ -25,7 +26,8 @@ static int cmd_printkey(int argc, const char **argv) {
int rc = 0;
static const char *const usages[] = {
- "sfinx printkey -k file [-L hash] [--in-fmt fmt] [--out-fmt fmt] [--single] [-o file] [--public-only] [--force]",
+ "sfinx printkey -k file [-L hash] [-p len] [--in-fmt fmt] [--out-fmt fmt] [--single] [-o file] [--public-only] "
+ "[--force]",
NULL,
};
struct argparse_option options[] = {
@@ -34,6 +36,7 @@ static int cmd_printkey(int argc, const char **argv) {
OPT_STRING(0, "out-fmt", &format, "output format (default hdr)", NULL, 0, 0),
OPT_STRING(0, "in-fmt", &in_format, "input format (default auto)", NULL, 0, 0),
OPT_INTEGER('L', "hash", &hash, "hash size (224/256/384/512)", NULL, 0, 0),
+ OPT_INTEGER('p', "path-len", &path_len, "path length to derive the public key for", NULL, 0, 0),
OPT_STRING('o', "out", &out_file, "write to a file instead of stdout", NULL, 0, 0),
OPT_BOOLEAN(0, "public-only", &public_only, "output only the public key", NULL, 0, 0),
OPT_BOOLEAN(0, "single", &single, "single-key mode, derive the N = 0 public key", NULL, 0, 0),
@@ -53,6 +56,14 @@ static int cmd_printkey(int argc, const char **argv) {
fprintf(stderr, "sfinx: printkey: missing --key-file\n");
return 1;
}
+ if (single && path_len != -1) {
+ fprintf(stderr, "sfinx: printkey: --single cannot be combined with --path-len\n");
+ return 1;
+ }
+ if (path_len != -1 && (path_len <= 0 || !sfinx_path_len_valid((size_t)path_len))) {
+ fprintf(stderr, "sfinx: printkey: invalid path length: %d\n", path_len);
+ return 1;
+ }
if (util_file_read(key_file, &data, &data_len) != 0) {
fprintf(stderr, "sfinx: printkey: cannot read %s\n", key_file);
return 1;
@@ -72,7 +83,10 @@ static int cmd_printkey(int argc, const char **argv) {
sfinx_key_free(&key);
return 1;
}
- status = cli_key_derive(&key, single);
+ if (path_len != -1) {
+ key.path_len = (ssize_t)path_len;
+ }
+ status = cli_key_derive(&key, single, key.path_len);
if (status != SFINX_OK) {
fprintf(stderr, "sfinx: printkey: cannot derive public key: %s\n", sfinx_strerror(status));
sfinx_key_free(&key);
diff --git a/src/cli/verify.c b/src/cli/verify.c
@@ -18,6 +18,7 @@ static int cmd_verify(int argc, const char **argv) {
const char *message = NULL;
const char *msg_file = NULL;
int hash = 0;
+ int path_len = -1;
uint8_t *key_data = NULL;
uint8_t *msg_data = NULL;
uint8_t *sig_data = NULL;
@@ -33,7 +34,7 @@ static int cmd_verify(int argc, const char **argv) {
int rc = 1;
static const char *const usages[] = {
- "sfinx verify -k keyfile [-L hash] [-s signature | -S signature-file] [-m message | -M message-file] "
+ "sfinx verify -k keyfile [-L hash] [-p len] [-s signature | -S signature-file] [-m message | -M message-file] "
"[--key-fmt fmt] [--sig-fmt fmt]",
NULL,
};
@@ -43,6 +44,7 @@ static int cmd_verify(int argc, const char **argv) {
OPT_STRING(0, "key-fmt", &key_format, "key format, auto by default", NULL, 0, 0),
OPT_STRING(0, "sig-fmt", &format, "signature format, auto by default", NULL, 0, 0),
OPT_INTEGER('L', "hash", &hash, "expected hash size", NULL, 0, 0),
+ OPT_INTEGER('p', "path-len", &path_len, "path length the public key is for", NULL, 0, 0),
OPT_STRING('s', "signature", &signature, "signature as hex", NULL, 0, 0),
OPT_STRING('S', "signature-file", &sig_file, "signature file, - for stdin", NULL, 0, 0),
OPT_STRING('m', "message", &message, "message string", NULL, 0, 0),
@@ -131,8 +133,16 @@ static int cmd_verify(int argc, const char **argv) {
fprintf(stderr, "sfinx: verify: signature is not %d-bit\n", hash);
goto done;
}
- if (key.seed && cli_key_derive(&key, sig_path == 0) != SFINX_OK) {
- fprintf(stderr, "sfinx: verify: cannot derive the public key\n");
+ if (path_len != -1) {
+ key.path_len = (ssize_t)path_len;
+ }
+ if (key.seed) {
+ if (cli_key_derive(&key, sig_path == 0, (ssize_t)sig_path) != SFINX_OK) {
+ fprintf(stderr, "sfinx: verify: cannot derive the public key\n");
+ goto done;
+ }
+ } else if (key.path_len >= 0 && (size_t)key.path_len != sig_path) {
+ fprintf(stderr, "sfinx: verify: public key is for path length %zd, signature uses %zu\n", key.path_len, sig_path);
goto done;
}
if (!key.pub) {
diff --git a/src/fmt/hdr.c b/src/fmt/hdr.c
@@ -9,8 +9,9 @@
// hash: <bits>
// seed: <hex | (no seed)>
// public-key: <hex>
+// path-len: <decimal>
// signature: <hex>
-// labels are case-insensitive, first valid occurrence wins, a lone seed derives its public half
+// labels are case-insensitive, first valid occurrence wins
static int hdr_hexval(uint8_t c) {
if (c >= '0' && c <= '9') return c - '0';
@@ -50,6 +51,24 @@ static void hdr_hex_encode(uint8_t *out, const uint8_t *in, size_t in_len) {
}
}
+static size_t hdr_uint_len(uint32_t value) {
+ size_t n = 1;
+ while (value >= 10) {
+ value /= 10;
+ n++;
+ }
+ return n;
+}
+
+static size_t hdr_uint_encode(uint8_t *out, uint32_t value) {
+ size_t n = hdr_uint_len(value);
+ for (size_t i = n; i-- > 0;) {
+ out[i] = (uint8_t)('0' + value % 10);
+ value /= 10;
+ }
+ return n;
+}
+
static int hdr_match(const uint8_t *line, size_t len, const char *label, const uint8_t **val, size_t *val_len) {
size_t at = 0;
size_t label_len = strlen(label);
@@ -84,6 +103,23 @@ static int hdr_scan(const uint8_t *data, size_t len, const char *label, const ui
return 0;
}
+static int hdr_scan_uint(const uint8_t *data, size_t len, const char *label, uint32_t *out) {
+ const uint8_t *val;
+ size_t val_len;
+ uint32_t acc = 0;
+ if (!hdr_scan(data, len, label, &val, &val_len) || val_len == 0) {
+ return 0;
+ }
+ for (size_t i = 0; i < val_len; i++) {
+ if (val[i] < '0' || val[i] > '9') {
+ return 0;
+ }
+ acc = acc * 10 + (uint32_t)(val[i] - '0');
+ }
+ *out = acc;
+ return 1;
+}
+
static int hdr_key_detect(const uint8_t *data, size_t len) {
const uint8_t *val;
size_t val_len;
@@ -95,21 +131,14 @@ static sfinx_status hdr_key_decode(const uint8_t *data, size_t len, sfinx_key *o
size_t val_len;
int have_seed = 0;
int have_pub = 0;
+ uint32_t num;
sfinx_status status;
- if (hdr_scan(data, len, "hash", &val, &val_len)) {
- uint32_t bits = 0;
- int ok = val_len > 0;
- for (size_t i = 0; i < val_len && ok; i++) {
- if (val[i] < '0' || val[i] > '9') {
- ok = 0;
- break;
- }
- bits = bits * 10 + (uint32_t)(val[i] - '0');
- }
- if (ok && sfinx_hash_len((sfinx_hash)bits) != 0) {
- out->hash = (sfinx_hash)bits;
- }
+ if (hdr_scan_uint(data, len, "hash", &num) && sfinx_hash_len((sfinx_hash)num) != 0) {
+ out->hash = (sfinx_hash)num;
+ }
+ if (hdr_scan_uint(data, len, "path-len", &num) && sfinx_path_len_valid(num)) {
+ out->path_len = (ssize_t)num;
}
if (hdr_scan(data, len, "seed", &val, &val_len)) {
have_seed = 1;
@@ -141,9 +170,6 @@ static sfinx_status hdr_key_decode(const uint8_t *data, size_t len, sfinx_key *o
if (!have_seed && !have_pub) return SFINX_ERR_FORMAT;
if (!out->seed && !out->pub) return SFINX_ERR_FORMAT;
- if (out->seed && !out->pub && sfinx_key_derive(out) != SFINX_OK) {
- return SFINX_ERR_FORMAT;
- }
return SFINX_OK;
}
@@ -151,6 +177,9 @@ static size_t hdr_key_encode_len(const sfinx_key *key) {
size_t need = strlen("hash: 000\n");
need += strlen("seed: \n") + (key->seed ? key->seed_len * 2 : strlen("(no seed)"));
need += strlen("public-key: \n") + (key->pub ? key->pub_len * 2 : strlen("(no public key)"));
+ if (key->pub && key->path_len >= 0) {
+ need += strlen("path-len: \n") + hdr_uint_len((uint32_t)key->path_len);
+ }
return need;
}
@@ -190,6 +219,13 @@ static sfinx_status hdr_key_encode(const sfinx_key *key, uint8_t *out, size_t ca
}
out[at++] = '\n';
+ if (key->pub && key->path_len >= 0) {
+ memcpy(out + at, "path-len: ", 10);
+ at += 10;
+ at += hdr_uint_encode(out + at, (uint32_t)key->path_len);
+ out[at++] = '\n';
+ }
+
if (len_out) {
*len_out = at;
}
diff --git a/src/keypair.c b/src/keypair.c
@@ -11,7 +11,8 @@
void sfinx_key_init(sfinx_key *key) {
if (!key) return;
memset(key, 0, sizeof(*key));
- key->hash = SFINX_HASH_DEFAULT;
+ key->hash = SFINX_HASH_DEFAULT;
+ key->path_len = -1;
}
void sfinx_key_free(sfinx_key *key) {
@@ -39,11 +40,14 @@ sfinx_status sfinx_key_derive(sfinx_key *key) {
if (len == 0) {
return SFINX_ERR_ARGS;
}
+ if (key->path_len < 0) {
+ key->path_len = SFINX_PATH_LEN_DEFAULT;
+ }
pub = malloc(len);
if (!pub) {
return SFINX_ERR_NOSPACE;
}
- status = sfinx_tree_public_key(key->hash, key->seed, key->seed_len, pub, len, NULL);
+ status = sfinx_tree_public_key(key->hash, key->seed, key->seed_len, (size_t)key->path_len, pub, len, NULL);
if (status != SFINX_OK) {
free(pub);
return status;
diff --git a/src/sfinx.c b/src/sfinx.c
@@ -106,7 +106,6 @@ static inline sfinx_hash _sfinx_hash_from_len(size_t len) {
// WOTS {{{
//
// One WOTS key over an L-byte value, c = L + 2 chains of length 256
-// key = seed for N = 0, seed | path for a tree leaf
// 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
@@ -637,19 +636,24 @@ sfinx_status sfinx_single_sign(sfinx_hash hash, const uint8_t *seed, size_t seed
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) {
+sfinx_status sfinx_tree_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, size_t path_len,
+ uint8_t *pubkey_out, size_t pubkey_cap, size_t *pubkey_len_out) {
size_t len = sfinx_hash_len(hash);
+ uint8_t prefix;
_sfinx_pool *pool;
int ok;
if (len == 0 || !seed || seed_len > SFINX_SEED_LEN_MAX) {
return SFINX_ERR_ARGS;
}
+ if (path_len == 0 || !sfinx_path_len_valid(path_len)) {
+ return SFINX_ERR_PATH_LEN;
+ }
if (!pubkey_out || pubkey_cap < len) {
return SFINX_ERR_NOSPACE;
}
- pool = _sfinx_pool_create(_sfinx_pool_scratch(seed_len + 1));
- ok = _sfinx_subtree_build(pool, hash, seed, seed_len, NULL, 0, 0, pubkey_out, NULL);
+ _sfinx_e4m4_encode((uint32_t)path_len, &prefix);
+ pool = _sfinx_pool_create(_sfinx_pool_scratch(seed_len + 2));
+ ok = _sfinx_subtree_build(pool, hash, seed, seed_len, &prefix, 1, 0, pubkey_out, NULL);
_sfinx_pool_destroy(pool);
if (!ok) {
return SFINX_ERR_NOSPACE;
@@ -683,38 +687,38 @@ sfinx_status sfinx_tree_sign(sfinx_hash hash, const uint8_t *seed, size_t seed_l
return SFINX_ERR_NOSPACE;
}
joined = malloc(path_len + msg_len);
- key = malloc(seed_len + path_len);
+ key = malloc(seed_len + path_len + 1);
if (!joined || !key) {
free(joined);
free(key);
return SFINX_ERR_NOSPACE;
}
- pool = _sfinx_pool_create(_sfinx_pool_scratch(seed_len + path_len));
+ pool = _sfinx_pool_create(_sfinx_pool_scratch(seed_len + path_len + 1));
// 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
+ // Prep sig header, sig[0..path_len] is also the derivation prefix
_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;
+ memcpy(key, seed, seed_len);
+ memcpy(key + seed_len, sig, path_len + 1);
+
// WOTS-sign up the tree
memcpy(value, org, len);
for (size_t k = path_len; k >= 1; k--) {
- if (!_sfinx_subtree_build(pool, hash, seed, seed_len, path, k - 1, path[k - 1], root, auth)) {
+ if (!_sfinx_subtree_build(pool, hash, seed, seed_len, sig, k, sig[k], root, auth)) {
_sfinx_pool_destroy(pool);
free(key);
return SFINX_ERR_NOSPACE;
}
- if (_sfinx_wots_sign(hash, key, seed_len + k, value, len, sig + at) != SFINX_OK) {
+ if (_sfinx_wots_sign(hash, key, seed_len + k + 1, value, len, sig + at) != SFINX_OK) {
_sfinx_pool_destroy(pool);
free(key);
return SFINX_ERR_ARGS;
@@ -787,7 +791,7 @@ sfinx_status sfinx_verify(const uint8_t *pubkey, size_t pubkey_len, const uint8_
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);
+ _sfinx_subtree_verify(hash, sig, k, leaf, sig[k], sig + at, root);
at += 8 * len;
if (k == 1) {
return memcmp(root, pubkey, len) == 0 ? SFINX_OK : SFINX_ERR_VERIFY;
diff --git a/src/sfinx.h b/src/sfinx.h
@@ -15,6 +15,7 @@
#include <stddef.h>
#include <stdint.h>
+#include <sys/types.h>
// Hash sizes {{{
@@ -179,13 +180,13 @@ sfinx_status sfinx_single_sign(sfinx_hash hash, const uint8_t *seed, size_t seed
///>
/// </details>
/// <details>
-/// <summary>sfinx_tree_public_key(hash, seed, seed_len, pubkey_out, pubkey_cap, pubkey_len_out)</summary>
+/// <summary>sfinx_tree_public_key(hash, seed, seed_len, path_len, pubkey_out, pubkey_cap, pubkey_len_out)</summary>
///
-/// Derive the tree public key from a seed. The top subtree is fixed, so the
-/// result covers every path length at this hash size.
+/// Derive the tree public key from a seed. `N` is bound into every key, so a
+/// public key verifies one path length.
///< c
-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_public_key(sfinx_hash hash, const uint8_t *seed, size_t seed_len, size_t path_len,
+ uint8_t *pubkey_out, size_t pubkey_cap, size_t *pubkey_len_out);
///>
/// </details>
/// <details>
@@ -227,13 +228,15 @@ sfinx_status sfinx_random_bytes(uint8_t *out, size_t len);
/// ----
///
/// A key holds a seed, a public key, or both. A null `seed` means public-only.
-/// Decoding allocates into the key, `sfinx_key_free` releases it.
+/// Decoding allocates into the key, `sfinx_key_free` releases it. `path_len`
+/// is the length the public half was derived for, -1 when not recorded.
///< c
typedef struct {
uint8_t *seed;
size_t seed_len;
uint8_t *pub;
size_t pub_len;
+ ssize_t path_len;
sfinx_hash hash;
} sfinx_key;
///>
@@ -241,7 +244,7 @@ typedef struct {
/// <details>
/// <summary>sfinx_key_init(key)</summary>
///
-/// Zero a key and set the default hash size
+/// Zero a key and set the default hash size and path length
///< c
void sfinx_key_init(sfinx_key *key);
///>
@@ -257,8 +260,8 @@ void sfinx_key_free(sfinx_key *key);
/// <details>
/// <summary>sfinx_key_derive(key)</summary>
///
-/// Fill in the public key from the seed. A key that already carries one is
-/// left alone.
+/// Fill in the public key from the seed, for the key's `path_len`. A key
+/// that already carries one is left alone.
///< c
sfinx_status sfinx_key_derive(sfinx_key *key);
///>
diff --git a/test/05-tree.c b/test/05-tree.c
@@ -9,7 +9,8 @@ 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 tree_pub1[SFINX_HASH_LEN_MAX];
+ uint8_t tree_pub2[SFINX_HASH_LEN_MAX];
uint8_t path1[1] = {0xa5};
uint8_t path2[2] = {0xa5, 0x3c};
uint8_t sig[SIG_MAX];
@@ -32,23 +33,29 @@ int main(void) {
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_public_key(SFINX_HASH_256, seed, seed_len, 1, tree_pub1, len, &outlen) == SFINX_OK,
+ "tree pubkey builds N=1", "build failed");
+ tap(sfinx_tree_public_key(SFINX_HASH_256, seed, seed_len, 2, tree_pub2, len, &outlen) == SFINX_OK,
+ "tree pubkey builds N=2", "build failed");
+ tap(memcmp(tree_pub1, tree_pub2, len) != 0, "one seed gives a pubkey per path length", "pubkeys match");
+
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");
+ tap(sfinx_verify(tree_pub1, 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_verify(tree_pub1, 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",
+ tap(sfinx_verify(tree_pub2, len, msg, msg_len, sig2, n2) == SFINX_OK, "tree verifies N=2", "verify failed");
+ tap(sfinx_verify(tree_pub1, len, msg, msg_len, sig2, n2) != SFINX_OK, "N=2 fails against the N=1 pubkey",
+ "verify passed");
+ tap(sfinx_verify(tree_pub2, 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;
+ tree_pub2[0] ^= 0x01;
+ tap(sfinx_verify(tree_pub2, len, msg, msg_len, sig2, n2) != SFINX_OK, "tree wrong pubkey fails", "verify passed");
+ tree_pub2[0] ^= 0x01;
return tap_plan();
}
diff --git a/test/06-api.c b/test/06-api.c
@@ -50,8 +50,11 @@ int main(void) {
"single_sign rejects NULL seed", "accepted");
tap(sfinx_single_sign(SFINX_HASH_256, (const uint8_t *)"seed", 4, NULL, 1, buf, sizeof(buf), NULL) == SFINX_ERR_ARGS,
"single_sign rejects NULL msg", "accepted");
- tap(sfinx_tree_public_key(SFINX_HASH_256, NULL, 4, buf, sizeof(buf), NULL) == SFINX_ERR_ARGS,
+ tap(sfinx_tree_public_key(SFINX_HASH_256, NULL, 4, 32, buf, sizeof(buf), NULL) == SFINX_ERR_ARGS,
"tree_public_key rejects NULL seed", "accepted");
+ tap(sfinx_tree_public_key(SFINX_HASH_256, (const uint8_t *)"seed", 4, 0, buf, sizeof(buf), NULL) ==
+ SFINX_ERR_PATH_LEN,
+ "tree_public_key rejects a zero path length", "accepted");
tap(sfinx_tree_sign(SFINX_HASH_256, NULL, 4, (const uint8_t *)"\x20", 1, (const uint8_t *)"m", 1, buf, sizeof(buf),
NULL) == SFINX_ERR_ARGS,
"tree_sign rejects NULL seed", "accepted");
diff --git a/test/07-key.c b/test/07-key.c
@@ -21,6 +21,7 @@ int main(void) {
sfinx_key_init(&key);
tap(key.hash == SFINX_HASH_DEFAULT, "init sets the default hash", "got %d", (int)key.hash);
+ tap(key.path_len == -1, "init leaves the path length unrecorded", "got %zd", key.path_len);
tap(key.seed == NULL && key.pub == NULL, "init zeroes both halves", "not zeroed");
status = sfinx_key_decode(seed, sizeof(seed), "raw", &key);
@@ -28,7 +29,8 @@ int main(void) {
tap(key.seed_len == sizeof(seed), "raw seed length", "got %zu", key.seed_len);
tap(key.pub == NULL, "raw has no pub yet", "pub present");
- status = sfinx_key_derive(&key);
+ key.path_len = 3;
+ status = sfinx_key_derive(&key);
tap(status == SFINX_OK, "derive", "%s", sfinx_strerror(status));
tap(key.pub_len == 32, "derived pub length", "got %zu", key.pub_len);
@@ -43,6 +45,7 @@ int main(void) {
tap(other.pub_len == key.pub_len && memcmp(other.pub, key.pub, key.pub_len) == 0, "hdr pub matches", "mismatch");
tap(other.seed_len == key.seed_len && memcmp(other.seed, key.seed, key.seed_len) == 0, "hdr seed matches",
"mismatch");
+ tap(other.path_len == key.path_len, "hdr path-len matches", "got %zd want %zd", other.path_len, key.path_len);
free(other.seed);
other.seed = NULL;
@@ -77,6 +80,13 @@ int main(void) {
status = sfinx_key_decode(hdr, hdr_len, "hexpub", &pubkey);
tap(status == SFINX_OK && pubkey.pub_len == key.pub_len && memcmp(pubkey.pub, key.pub, key.pub_len) == 0,
"hexpub round trip", "mismatch");
+ tap(pubkey.path_len == -1, "hexpub records no path length", "got %zd", pubkey.path_len);
+ sfinx_key_free(&pubkey);
+
+ sfinx_key_init(&pubkey);
+ status = sfinx_key_decode(seed, sizeof(seed), "raw", &pubkey);
+ tap(status == SFINX_OK && sfinx_key_derive(&pubkey) == SFINX_OK && pubkey.path_len == SFINX_PATH_LEN_DEFAULT,
+ "an unrecorded path length derives at the default", "got %zd", pubkey.path_len);
sfinx_key_free(&pubkey);
sfinx_key_free(&key);
diff --git a/test/09-ref.c b/test/09-ref.c
@@ -15,13 +15,18 @@ 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 ref_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_public_key(hash, SEED, sizeof(SEED), path_len, lib_pub, sizeof(lib_pub), NULL);
+ ref_tree_pub(bits, SEED, sizeof(SEED), path_len, ref_pub);
+ snprintf(label, sizeof(label), "L%zu N%zu tree pub matches reference", len, path_len);
+ tap(memcmp(lib_pub, ref_pub, len) == 0, label, "differs");
+
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);
@@ -66,11 +71,6 @@ static void run_bits(int bits) {
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);
diff --git a/test/11-reuse.c b/test/11-reuse.c
@@ -0,0 +1,52 @@
+#include <string.h>
+
+#include "_tap.c"
+#include "src/sfinx.c"
+
+#define MSG "sfinx reuse regression"
+#define MSG_LEN (sizeof(MSG) - 1)
+
+// Without N in the key, an N=1 signature shares its layer-1 key with any longer one on the same path[0]
+
+static void layer1_pubkey(const uint8_t *seed, size_t seed_len, size_t path_len, uint8_t first, uint8_t *out) {
+ uint8_t key[64];
+ memcpy(key, seed, seed_len);
+ _sfinx_e4m4_encode((uint32_t)path_len, key + seed_len);
+ key[seed_len + 1] = first;
+ _sfinx_wots_pubkey(SFINX_HASH_256, key, seed_len + 2, out);
+}
+
+int main(void) {
+ static const uint8_t seed[] = "sfinx reuse seed";
+ uint8_t path1[] = {0x0a};
+ uint8_t path2[] = {0x0a, 0x1b};
+ uint8_t pub1[SFINX_HASH_LEN_MAX];
+ uint8_t pub2[SFINX_HASH_LEN_MAX];
+ uint8_t sig1[4096];
+ uint8_t sig2[4096];
+ size_t len = sfinx_hash_len(SFINX_HASH_256);
+ size_t seed_len = strlen((const char *)seed);
+ size_t n1 = sfinx_signature_len(SFINX_HASH_256, 1);
+ size_t n2 = sfinx_signature_len(SFINX_HASH_256, 2);
+
+ tap_begin("sfinx cross-length key reuse");
+
+ layer1_pubkey(seed, seed_len, 1, path1[0], pub1);
+ layer1_pubkey(seed, seed_len, 2, path2[0], pub2);
+ tap(memcmp(pub1, pub2, len) != 0, "layer-1 key differs across path lengths", "one key serves both");
+
+ tap(sfinx_tree_sign(SFINX_HASH_256, seed, seed_len, path1, 1, (const uint8_t *)MSG, MSG_LEN, sig1, n1, NULL) ==
+ SFINX_OK,
+ "N=1 signs", "sign failed");
+ tap(sfinx_tree_sign(SFINX_HASH_256, seed, seed_len, path2, 2, (const uint8_t *)MSG, MSG_LEN, sig2, n2, NULL) ==
+ SFINX_OK,
+ "N=2 signs", "sign failed");
+
+ 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");
+
+ tap(memcmp(sig1 + 3, sig2 + n2 - (len + 10) * len, (len + 2) * len) != 0, "layer-1 proofs are not a reuse pair",
+ "proofs come from one key");
+
+ return tap_plan();
+}
diff --git a/test/bench.c b/test/bench.c
@@ -155,7 +155,7 @@ int main(int argc, char **argv) {
for (unsigned r = 0; r < args.reps && ok; r++) {
size_t got = 0;
uint64_t t0 = now_ns();
- sfinx_status rc = sfinx_tree_public_key(args.hash, seed, sizeof(seed), pub, len, &got);
+ sfinx_status rc = sfinx_tree_public_key(args.hash, seed, sizeof(seed), args.path_len, pub, len, &got);
double dt = elapsed_ms(t0);
if (rc != SFINX_OK) {
ok = 0;
diff --git a/test/ref/sfinx_ref.c b/test/ref/sfinx_ref.c
@@ -223,8 +223,10 @@ static void ref_single_sign(int bits, const uint8_t *seed, size_t seed_len, cons
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_pub(int bits, const uint8_t *seed, size_t seed_len, size_t path_len, uint8_t *out) {
+ uint8_t prefix;
+ ref_e4m4_encode((uint32_t)path_len, &prefix);
+ ref_subtree(bits, seed, seed_len, &prefix, 1, 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,
@@ -236,9 +238,10 @@ static void ref_tree_sign(int bits, const uint8_t *seed, size_t seed_len, const
uint8_t root[REF_LEN_MAX];
uint8_t auth[8 * REF_LEN_MAX];
uint8_t key[REF_KEY_MAX];
+ uint8_t npath[REF_KEY_MAX];
uint8_t *joined = malloc(path_len + msg_len);
- if (!joined || seed_len + path_len + 1 > REF_KEY_MAX) {
+ if (!joined || seed_len + path_len + 2 > REF_KEY_MAX) {
free(joined);
return;
}
@@ -255,16 +258,20 @@ static void ref_tree_sign(int bits, const uint8_t *seed, size_t seed_len, const
ref_e4m4_encode((uint32_t)len, sig + at);
at += 1;
+ ref_e4m4_encode((uint32_t)path_len, npath);
+ for (size_t i = 0; i < path_len; i++) {
+ npath[1 + i] = path[i];
+ }
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 i = 0; i <= path_len; i++) {
+ key[seed_len + i] = npath[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);
+ ref_subtree(bits, seed, seed_len, npath, k, npath[k], root, auth);
+ ref_wots_sign(bits, key, seed_len + k + 1, value, sig + at);
at += c * len;
for (size_t i = 0; i < 8 * len; i++) {
sig[at++] = auth[i];
@@ -342,9 +349,9 @@ static int ref_verify(const uint8_t *pub, size_t pub_len, const uint8_t *msg, si
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);
+ ref_parent(bits, bitlen, mask, sig, k, sibling, root, tmp);
} else {
- ref_parent(bits, bitlen, mask, sig + 1, k - 1, root, sibling, tmp);
+ ref_parent(bits, bitlen, mask, sig, k, root, sibling, tmp);
}
memcpy(root, tmp, len);
pos >>= 1;
diff --git a/test/test_embed.sh b/test/test_embed.sh
@@ -20,11 +20,11 @@ else
fi
bad=$(grep -E '^[[:space:]]*#include' "${ROOT}/src/sfinx.h" |
- grep -vE '^[[:space:]]*#include[[:space:]]+<(stddef|stdint)\.h>' || true)
+ grep -vE '^[[:space:]]*#include[[:space:]]+<(stddef|stdint|sys/types)\.h>' || true)
if [ -z "${bad}" ]; then
- tap 1 "sfinx.h includes only stddef and stdint" ""
+ tap 1 "sfinx.h includes only stddef, stdint and sys/types" ""
else
- tap 0 "sfinx.h includes only stddef and stdint" "${bad}"
+ tap 0 "sfinx.h includes only stddef, stdint and sys/types" "${bad}"
fi
if [ ! -f "${HASH_FIRST}" ]; then
@@ -103,7 +103,7 @@ int main(void) {
sfinx_key reread;
sfinx_status status;
- if (sfinx_tree_public_key(SFINX_HASH_256, seed, sizeof(seed), pub, sizeof(pub), &pub_len) != SFINX_OK) {
+ if (sfinx_tree_public_key(SFINX_HASH_256, seed, sizeof(seed), sizeof(path), pub, sizeof(pub), &pub_len) != SFINX_OK) {
return fail("tree_public_key");
}
if (sfinx_tree_sign(SFINX_HASH_256, seed, sizeof(seed), path, sizeof(path), msg, msg_len, sig, sizeof(sig),
@@ -124,6 +124,7 @@ int main(void) {
if (status != SFINX_OK) {
return fail("decode raw");
}
+ key.path_len = sizeof(path);
if (sfinx_key_derive(&key) != SFINX_OK) {
return fail("derive");
}
diff --git a/test/test_format.sh b/test/test_format.sh
@@ -49,10 +49,10 @@ 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
+# Derive the public halves the vectors must verify against, one per path length
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 -p 1 --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
@@ -61,7 +61,7 @@ done
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 \
+"${BIN}" verify --key-fmt rawpub -k "${TMP}/pub-32.bin" -p 1 -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"
@@ -82,7 +82,7 @@ patch_byte() {
verify_raw() {
# verify_raw <pub> <sig>
- "${BIN}" verify --key-fmt rawpub -k "$1" -m 'sfinx golden vector' -S "$2" >/dev/null 2>&1
+ "${BIN}" verify --key-fmt rawpub -k "$1" -p 1 -m 'sfinx golden vector' -S "$2" >/dev/null 2>&1
}
head -c 1346 "${TMP}/sig-raw.bin" >"${TMP}/short.bin"
diff --git a/test/test_generate.sh b/test/test_generate.sh
@@ -93,9 +93,9 @@ rc=0
"${BIN}" generate abc >/dev/null 2>&1 || rc=$?
tap "$([ "${rc}" != 0 ] && echo 1 || echo 0)" "rejects a non-numeric length" "exit ${rc}"
-"${BIN}" generate --out-fmt raw -o "${TMP}/v.key"
+"${BIN}" generate --out-fmt raw -p 2 -o "${TMP}/v.key"
"${BIN}" sign -k "${TMP}/v.key" -m hello -P 0011 -o "${TMP}/v.sig"
-"${BIN}" verify -k "${TMP}/v.pub" -m hello -S "${TMP}/v.sig" >/dev/null && ok=1 || ok=0
+"${BIN}" verify -k "${TMP}/v.pub" -p 2 -m hello -S "${TMP}/v.sig" >/dev/null && ok=1 || ok=0
tap "${ok}" "sign with the key, verify with the pub" "failed"
tap_plan
diff --git a/test/test_hash_sizes.sh b/test/test_hash_sizes.sh
@@ -27,7 +27,7 @@ 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}" generate --out-fmt raw -L $bits -p 1 -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")
@@ -36,7 +36,7 @@ for L in 28 32 48 64; do
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
+ "${BIN}" verify -k "${TMP}/k$L.pub" -L $bits -p 1 -m 'hash size' -S "${TMP}/s$L.sig" >/dev/null && ok=1 || ok=0
tap "${ok}" "L$L round trip verifies" "failed"
done
@@ -44,13 +44,13 @@ done
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=$?
+"${BIN}" verify -k "${TMP}/k32.pub" -p 1 -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=$?
+"${BIN}" verify -k "${TMP}/k32.pub" -p 1 -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_sign_verify.sh b/test/test_sign_verify.sh
@@ -11,7 +11,7 @@ trap 'rm -rf "${TMP}"' EXIT
tap_begin "cli: sign and verify"
"${BIN}" seed -o "${TMP}/seed.bin"
-"${BIN}" printkey --in-fmt raw -k "${TMP}/seed.bin" -o "${TMP}/key.hdr"
+"${BIN}" printkey --in-fmt raw -k "${TMP}/seed.bin" -p 2 -o "${TMP}/key.hdr"
"${BIN}" printkey -k "${TMP}/key.hdr" --public-only -o "${TMP}/pub.hdr"
"${BIN}" sign -k "${TMP}/key.hdr" -m hello -P 0011 -o "${TMP}/sig.bin"
@@ -33,11 +33,12 @@ tap "${ok}" "hdr signature auto-detected from stdin" "failed"
"${BIN}" printkey -k "${TMP}/key.hdr" --public-only --out-fmt rawpub >"${TMP}/pub.bin"
"${BIN}" sign --key-fmt raw -k "${TMP}/seed.bin" -m hello -P 0011 --sig-fmt hex -o "${TMP}/sig.hex"
-"${BIN}" verify --key-fmt rawpub -k "${TMP}/pub.bin" --sig-fmt hex -m hello -S "${TMP}/sig.hex" >/dev/null && ok=1 || ok=0
+"${BIN}" verify --key-fmt rawpub -k "${TMP}/pub.bin" -p 2 --sig-fmt hex -m hello -S "${TMP}/sig.hex" >/dev/null &&
+ ok=1 || ok=0
tap "${ok}" "explicit key-fmt and sig-fmt round trip" "failed"
"${BIN}" printkey -k "${TMP}/key.hdr" --public-only --out-fmt hexpub >"${TMP}/pub.hex"
-"${BIN}" verify --key-fmt hexpub -k "${TMP}/pub.hex" -m hello -S "${TMP}/sig.bin" >/dev/null && ok=1 || ok=0
+"${BIN}" verify --key-fmt hexpub -k "${TMP}/pub.hex" -p 2 -m hello -S "${TMP}/sig.bin" >/dev/null && ok=1 || ok=0
tap "${ok}" "hexpub key reads back" "failed"
printf 'hello' >"${TMP}/msg"
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-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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
+020a1b20ce57801d6346eb2c34eb176ce58c729d3e8eed0c6022c39c3d2ce129afe6fd138b879798a174e447dbcedac40a7c5e25173156eb4fd87c4227508a73d52cb53a6e3858d51e454f98e492ced2d490783eb46dca6d41cbffd6db5ce5a50d32cb1b8afacba06c19d8eddf1c7d91447accdd6def47b2cba83934ecda33f52922f6a0508997a04161a3bee59894ad65c7d68ffaefb61cbe1d1568777c06f48ac3e5c6e6896f7d393055d5c29b04cb12f1b4d5663be9498f33837267f4cc3e97a17c2f23f1945f03859e33b9e71c6ddbbfdb95716a620db1d5c32b2aa42eab2d655977398f252d12b486ec33c51c69a5dca3e3cc92c89276d0fff9f35e895f98d6983a085852f71d369ab82ac522620757ca591eec842149d6ebc84c7c99feb427483faf497920855b889eb3ed9278d122e4cf6170a44c6153a9e475f6b94b06d7eada02f9229f02904e10a5e29f5562d54a896a03272544bd739fc31bd6f6612d769767fdfe06d31681c29ad949d7af57abf29a6a4da97f4830b14d575a3c6aa196c984760dbcf9430fe32a9ce1320eb1617c6802d259547888b991ef667410e47dea264ef97a54790ff288cbd28924c43b56188b728dd785c9bf93ccb3ee4b446f4a7a68592bf250cb7c55f8bbc6004aedf29a230bf9b496272de70a79d02a96176d7b6b47003b3c93001d3921382e245b8ff033bccac8470ea98c08cc628b63b0811c29977524fd30f6e79691dce07cb1dd6f6fce87f5aef06b0ed845df5fbc819644c21dedfa533d6d25ab05285e43c9a33b5c25802f86d574d49e1bc44895f62ff705b164378f77c58cc0cf46235d2050c7f5fbd573629e49bd432b556765ad0d58e3b7cc011dcef127784a315427f1f3bed477c9e13cfd8fee1ca7091387e9e9a90a9723ca82dd11a17dafe4bcb7b7f03e10a5f25339432bc527e73501a400c9e5f286371d114f5c7dd0cc4de9e6984a7e82facfe2ac741fd5799adda79f504903a69034e9d0e434da992f19c778b7fc5e1e0e21bb3d962cf77da4b8a24839c00ba4f0fe0cd9d29bf405c7fb605169a349673bb5df82baf3ff262ee933d1db1b659e3962ac78959df76e4d8fa407451fc2dfa66d58ac92fbe9864f7def596c43954c57c722800b2a83cb400598f80ec51b26a08c3eba6c948ac74623a4612930afeb75cb0e94084bf7a431b609ad3c7ceb77870468b68e0e4bc760fedd7ed30356f2067fd01b96b7ef281ce30bd6609782b1ae4b904ddcd47b5632e2c30a98286819a49670386d5ce31c87e62c7d31031b1b93cee9e8245c4134f07d8207a2056989f2a2837768d596fc1266d2a2996b1fa6606e692684c2e7e18f295d65e164e022ffdff5bee8b0a08d04fbbd63ac06f50529b2356740c26c23a2ed3719ad6f56fa64d6189ed4780872c5f6cb2bb57e167fffc3e293e2dadae07783aeb2841a55b0c2d799f7c1dfa1b80529affe40ec83247864358192f4d9a8808b3df09651a98b8795896de3ff12a3cd4385e0f3f71ccee95fd38cc89bf70664a7a16b6a2b485f667a1f7f48df2677e009ef794213d25a5ee5a58a1d98fc73f6a096c77eca868ac55857f38979e87e828fc84087e9c5222609a8a807e62109ae709b4eabe05c69e8ada7163333c44b967fb71630b6ca6b1f8330505b0dfd0e5e1f159e36941b359e91813c2cca66a6dd062de7b3d463975c9b87a91455e987bcc1e6b4ff47f6aceccca4561fe7442a6633da5e170cb49881e551d2984b1db0c3da3ccc1c988039b47a956aaeeb39a5b49105901e1356f0edb6e04752af3ff464ecdd0c21ddf9cbe8204e88f690fab19d6580c3715f941dbc61e6d3119f8fab793f3d7f94e038ad1214fd2998ceed1d1b09c3109a312d4f77cd12a2d30178024090e0958bdff42748666dab54dd25ccc5bad60471dea9fef49bc85186e018ea018f4432cb33d921e92ae0839d1401ed7cddf17042e6f7fc372fddb41f11bc11e5b9884422e4fd19f65a9d6c97b6d0372fc4b8a29eaa498b82a63dd47f386bbcd789388170d96b64039e19740876b3d27f34b8a4c16e31339095eeb52d4297ed9770d299e55fa19c64c8b34b202e27bb44710ce54e72cd50b11a712044781d4cfa41388e5c2b96b5a356cdcc07f7b534eccb10edd5561e3e5406144c18b70805b4956c9c9f54faa033375a2805307df24e01af1322362f66cc48087c3bfa4f201586c7377f23f22cf8393e8d2e2df09cd1a0482580b69e3b8baca1ac310322489bc8c4ef4f005aa48997c02858e904ea156931b81d8ca54defea33eb4fa8cc7943e973143a779e3ac3f163679e910b893ba15db91c7e0f545ce6d18e03d6b982b61159dabb3f8d639b5910f58e45fce4be26127c06a8f38723eade18086c975f6b2c7c6648a2c86a849936bee650e8e12c9ed01d80f0a420b06d6b96156acf589a67fe845fc9812be575bcc6e8ec1fbcaa9187e11f0cbca275d1cc99fe2c82ad63d284782676b4bbf2c424bfc86535cebbb5ed990a77e78e67e87142e76e14d79b88a8e2ad7bdc2a623f1c1c05002107ae966e54c59d11f1776c355f792314c85b39dadeb1c35fe4066a11e45ba5dc68dd3b8f5a0d93c418d0063e8681aea92bb7469bed5d3eacf59d9de817253206a07105147ffe25d61fe8b7f5d82fc8fb0aca43f2b94e9f8349f7c34eb097e53aad241d1fe6a8227a4f935840cf7351c732dfbbd02a3e6b81a15ac4312d25b83f7f2e87abc4e749523c3ed2787aefbe86ca78747d2b4ed593f4eef4c0daf4189b9c2cad0b271dad03f1882d6fa3f7836f1e73ea630441b98d2c603a05b7826eb9d5120bea4e247fe398b152fa5443aae01ddd5b5fdfb2adb1112a293d4cb7e6c6a0e749d7a445386718ca9eca87af833e56588c6593e415b5fcf777623f27e63cd3e3b5674bd4bfa322388a7cfe5ab0d2393b78cf0428d4f4c1b769d9401899d8f7bb8e86da17e9d8e6af04686e8ab440a515d25530cc1665f5a34ff1f4642bb4dc9beb199c60c3baaad655872fb4bc7d607a5da047a6d3923b4eb4e23a194af5d07dddcf08d27d92cfa183a979faa55fd22efca9ac367b57195aef7e4111a2104064fbd76a325c13d8e5d78757788f60948263647f8ba329dcc38df843228bf1ccc213427344d50ee30306fbb2ad5cf9f5cad8b1bd407f4e391ef85476143c1357d510a992ebf9bb650143db0219de3a805dbef802026abb0656e9df1c8922332effa302503e8d179a4e548d6e5a52ec3f39ef7becd8553411e7a2ce7da8127ebee30839426cba0aba5000475c94b9ad0d077462176bd9dfba6b9428309c5f9515d71be6b822d7954b2b2816abac851050e37d5b874fc661a0c60542237d709f0e2ebb9f864fbad85045bed173a4876e04451f1dde433fc209a3bfdcd897cadbbedefbe6b23d8f42c36b4561efcba6d580a708609b57a24953ddfd6a5a1d5a0228cbb5316d5bf3096d42fd453fa0f54e1687e7fe0fc01c4284b8209fd32340c98571c1ac8c061a6b02dfe6ee4845ba0f9d9ea7040e03a1f7577ae917e6ffb7021ec0bb64722b84b0ccd69f403874803d15dd943babb37e09e62edc3f20b75b2028d041d1b76a979b701f092c1c5decb81205359cf8510fa12aba710c2897ae6e02360c8f250c62182773037b2cb11fc22402c2dd337dce068e8af0959a8dd09f51f390bef4c53c3170ed4bf5f18634d12e4b56751a8bfdbd271cd09d7d0d2aedd42e4ec81af350d2d499253cf91386a7fda8ed47492f8a9f3f63723e98ba21dd4f86500504e78bbd763274f417bfa906622233d2f74c8e
diff --git a/test/vectors/sig-L48-N1.hex b/test/vectors/sig-L48-N1.hex
@@ -1 +1 @@
-010a287c08eea5425a5bf1fff381205ef3e241703c9f80d7951949b19f87069a347727642fb9ba5808ac28b649e15d4b06062c66c6d547777621e7e4b1320f9efda8e32ec637451d3bf24961bcd2cb5ef340736d57208b073feed2122dbd9a656e8cc4659aec205ca2badad5cd25677f0f62c26ac049804739472118cb2e21e9ad2bf46cacf37573808a031b6db994854a591e5ba70f77f32af5a98d4a9af824d567e9c8c6f83d6997003796d267dabefdce54b93b3e8d3c6c0d3a8d6b9d90ed23b7a8f65b1be727676e5ed429f21df146701450303633c8ada3abff3c57972d39822a21ea23c8afcc0f8a645db17c54d4e79ef6359496aa4c5fd108229b289e905a8e632d2acb4839d21f426acbb60c67b6fcd8e439dfcc0f6cceb74d6744d3de761f8ae12c0594ac1ecb428250c012c7cf4a61c0aa754ce6bc78a7e5f9c76db2be3b6a76adc1fe731782cbb2e30816bf0ea7ac107eb05c472d72e628dd46988e01817cd2da42d90899e18917bf1731e4bd0052c5a7d8c647208d201aa50c7063876c926ca1eab0764b24229f256959e7a79598d4c2e6d1f6088e7fe8d54cb2839489dacc01a642dfd88b29f5064a6aa50968b164b1d287b602473b0cc1d41d43eff2602f758973e971e17ad84d8c551715bb0275c93dcb56a9cc7588edef36e298256f8776a290f16a0d15138fe1d197297022deddddf46eefcf18124dbe89d5244e5effa6e19cc677dc5ee3efbb572e0e4bba3d871736a2f7d65474e83bc9653f4c15507b35d8ecd2becd9575e66ac37fee85cca1168702fa15e586ce063075310091ed1d86f93ce8a740e6cc2ba9538d571e3a938ee0f5e8aab023ef69d3168030ab35bde8140fe459c3745287c9816dbd3895ec1a45b134931ed57e0151bf810fa027c441cdf33f7031050a5a863a59366644196110ae515982b81443f35603ae615cb794a8fac0a680386800fbf0cf0ce6b53d3f038a891769c5c8fc6eab5b81c4ee0a60cedb6528f1fc0f9d59df18a7971760c6e09075445bb45bbc62fc87c7c3c10bdf7158df80167a00e1f35cb3f227a9c0f1a3bd3f6b120a19ccde70d50a9b7feee8dcb74035c04e37440606e5d50aefcdd1472c3b8585e763f060b96d651dfac066b4c3f8f221552e2f1e687b85578e072eca4c2c5567cbe6edd0fad301a52d2c7994b2962e44e6bc517ad438e575a20d2549791d69460f133c977ad4e88eda7e99d86fd6d831491d91134beb852b615b03f5d3bf5d3a3d5f7a320fc8077b8217176f08329efb1528114c4527d0356ae592052e736ccbdfb61afc8c2afc4bba9ada031d82d6bfcc24d0b56ea3c7fb92bb52632639ff91e4aeda94d12c151991ef3412db654b526e046fc93a096358659f46644043a8a7666a56262e3b6634ecfee51fc6739be4b71c642c9cfae428885d968c0408ee0686936b71b3384fb00e7ca80d05f7369e019963eb56e080555089afb12d31b9dfdd5a6e227c2da29b8901a4519e10197cf9d8215827ed1abf9a781cc833bb6b96eecdc60c1de4d6697c8add6ec50c1456dd5a2e27e529f3b8b084d1429628eff4f707e5260004c846d00a3001b52f3a0f4994f25ae93ee31ac3b11a7d7fd0de5ea1943a3f8de918bbc54cb22ca899bb0a49e06e5050c174cc7eb22558958ae64d6e285bdf173272e90d570749861213eb4a35144532c808928c0564bccdf4d0c0b4a245faeb085a26a9f3955c8f90dbf92d756d5aff0a19fbe88b247cba54bb2189b6e3de7f431615a1267afbe7d2d45172e0594671e6a46a1a06dcf8ab8d70a1a0e9d5104a71bec5cfd41991b3cf7cb1454b15150657d0e3d91dd21a1a5c80d0db556a4cb57c98b7bc9a714d8e23fbf95b3f31aada4aed0d1fe5437cb42d083e4fb3e13ae99552df132e37e781b0b4011d7e2d6fba7679514dde185e49c92ac9e9908974cf6bfb60d34bbc73c22380a7e3edcdda2689fbc6b96d14b55bad91784bdb70719ba0591315d605c56d766a7cb1240143984f30f3fe77669a4d5db562ed79520e4b252eeb843cf50789551d72dcc0ad0ac0c51270679aa53d73d4887ce866cd20b672ecdb6224e075aa525478565cfa282d5dfa9b4de5549dc008f8f151afd819a99f77137489503048a7aba66af9606326935e267f3621b049b25f5df9e4edb879942f5c2be71e46ed73005d6ad1b9cdb1733eab819a4dac0e6cc52dc6898b92903286f5994796ad79f9749df53dc3e6eeb2bd92598e1e323c65b8586989b4c78ecd8665899126a23c5119989d101b2aed8cca88b5f0c75ac841886f6b62bad50a59fbb7d1463418845338c1d0d2b3105bd8d72baf8b70beeeeffc4376db31b48a273abf35fa5e9b95b7e71925704a55b113676724f81fc3e5c06bcea7954df4c56ee4962817021412a9e1778d5d9faf87884e438c6aea62265bc2bd2358769c1b4d20d20e987aa093443ce4f774e226fd29ac34bc926468c6bbdd7054f1787a12a7c45b138e3c5c11c33ffcbdd8f7a4afbf05f7a9a1af36c44a21d81cb64c11245c804d4db69f8c94bed7d951022b8815586c3df7f98bb6fde16470f0d42c79c8a27dda28eddd049c9996881f6111f2e5ec85e70cb2397ce9d3c7e2fb91cb26a2d511332d03be29eeb66da347f0cb36780eebbc0bdfdd8e217d1c6fa2fa3cd67c5eb6b979217dbed3db2e73fdb8b83d131aa75d88d450f076810d54a6e2b3394105fb6ed871a3f577689517373b321f69cbda9eb854aada9886243603e5e9e29531319665c3768811c77a4faf1689b5ba381869d850f9e680d545a26014704249f72c784cbd518576308094a5b68138157c111b8b92c79bd4d4c2aa6f62db9364b17d40f6ee916adb265847edb09b66c76e15423e7d7bb833d9cd84875650f7e000dd00574c79d77c622da8011ce14719f143fb96b0b49f3e1a6cf9b1412fa1485cfb137afd241c41aaf0f46501e223edeb0bc41d0957251d726183f1efb30ce429611627547908ea5a79541af1961877bc858e1ee287f23bc770329e43b49838d9e70de3d14460636b99d8c6fa2f4b5e8604cb50f611368ff918d2af11e16dd2ebe52036de0b4b3044d1a6261cb6aebb34af53f75a0cbed149725ce7fd6aa5ee4f35f754167472716a833e316797ec05daf2385fe7bd12d174e7759bc04ea14fd0a4482449fe0657d77a3d02407f77458200875f6abb53438bec1377bad9c5002fe79060100eb62c64ae7e15474ec83a2c381090d514f91f692dc96de9146516704de40243e26fc8cbfe73811f6a8858b4715dc1724c905380f1ca13aff5ce36818ef5f3dab2254e89276f904d27eb751d0033604614ee648d2019424ff44cf3c755526432d8f88399ce244511f2a123670dbeb77c30eb9afe3d19d970c82e6c3d944c9c66d2f1aa3a6b9f80ce2f32bd9c7c6950a2366aa513e9238fa6debc0b9e630d036d0ca7406d4c6cc3f5416c20a5a43ffab0f2f23412d6cc03e443747a39d4dd5151c879502d18819afa0e1b55014b62feba25e5ad97d52635049631d66237af47cd3327a0755b88307cf73d65ec6f6f694a3fa2a3e24d2daf7149bd3316cecef8e64f3ab424af2618a6f915d24fee29ed64174e28a36c6d3d13b304f24b662ebd77f8a4b0026ebf5e3d2171003323f8c8ad28c9827aac6f0fd367b82d7edd266380e4ed38e92b8517b97b73fbdbfbf60fc81b1afddda6c4aaaa36700c07db9a64be9ca6c6bf830574abd4c57f382666549fb6ae172e1b9eb7d9a0512873904cb20128090788ff30098c28a1a63cac7ce796d45f385948a04977323e846832b0064147e50e090d0fe1b28ab8bdf211dc79cbc93e2862ed743de95200aa02158b8517a2c9fdc3d8e4ce9bfb2ae19bdac46bf588dd349fc5d52b728bfd0f2e09687fe8877f28cbce10fc7d33f12e5c1f51d765ea5580b292b1f55cd171111e0b
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
diff --git a/test/vectors/sig-L64-N1.hex b/test/vectors/sig-L64-N1.hex
@@ -1 +1 @@
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