sfinx

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

11-reuse.c (2744B)


      1 #include <string.h>
      2 
      3 #include "_tap.c"
      4 #include "src/sfinx.c"
      5 
      6 #define MSG     "sfinx reuse regression"
      7 #define MSG_LEN (sizeof(MSG) - 1)
      8 
      9 // A proof element sits at an unknown chain position, so every start is tried
     10 static size_t chains_linked(sfinx_hash hash, const uint8_t *kid_a, const uint8_t *a, const uint8_t *kid_b,
     11                             const uint8_t *b, size_t len, size_t count) {
     12   uint8_t walk[SFINX_HASH_LEN_MAX];
     13   size_t  linked = 0;
     14   for (size_t i = 0; i < count; i++) {
     15     int hit = 0;
     16     for (int dir = 0; dir < 2 && !hit; dir++) {
     17       const uint8_t *from = dir ? b : a;
     18       const uint8_t *to   = dir ? a : b;
     19       const uint8_t *kid  = dir ? kid_b : kid_a;
     20       for (size_t j0 = 0; j0 < 256 && !hit; j0++) {
     21         memcpy(walk, from + i * len, len);
     22         for (size_t step = j0; step < 256; step++) {
     23           if (memcmp(walk, to + i * len, len) == 0) {
     24             hit = 1;
     25             break;
     26           }
     27           _sfinx_wots_chain(hash, walk, kid, (uint8_t)i, (uint8_t)step, 1);
     28         }
     29       }
     30     }
     31     linked += (size_t)hit;
     32   }
     33   return linked;
     34 }
     35 
     36 int main(void) {
     37   static const uint8_t seed[]  = "sfinx reuse seed";
     38   uint8_t              path1[] = {0x0a};
     39   uint8_t              path2[] = {0x0a, 0x1b};
     40   uint8_t              sig1[4096];
     41   uint8_t              sig2[4096];
     42   size_t               len      = sfinx_hash_len(SFINX_HASH_256);
     43   size_t               seed_len = strlen((const char *)seed);
     44   size_t               n1       = sfinx_signature_len(SFINX_HASH_256, 1);
     45   size_t               n2       = sfinx_signature_len(SFINX_HASH_256, 2);
     46   size_t               linked;
     47   uint8_t              kid1[SFINX_HASH_LEN_MAX];
     48   uint8_t              kid2[SFINX_HASH_LEN_MAX];
     49 
     50   tap_begin("sfinx cross-length key reuse");
     51 
     52   tap(sfinx_tree_sign(SFINX_HASH_256, seed, seed_len, path1, 1, (const uint8_t *)MSG, MSG_LEN, sig1, n1, NULL) ==
     53           SFINX_OK,
     54       "N=1 signs", "sign failed");
     55   tap(sfinx_tree_sign(SFINX_HASH_256, seed, seed_len, path2, 2, (const uint8_t *)MSG, MSG_LEN, sig2, n2, NULL) ==
     56           SFINX_OK,
     57       "N=2 signs", "sign failed");
     58 
     59   tap(memcmp(sig1 + n1 - 8 * len, sig2 + n2 - 8 * len, 8 * len) != 0, "layer-1 auth paths differ across path lengths",
     60       "auth paths are identical");
     61 
     62   _sfinx_kid(SFINX_HASH_256, sig1, 2, kid1);
     63   _sfinx_kid(SFINX_HASH_256, sig2, 2, kid2);
     64   tap(memcmp(kid1, kid2, _sfinx_kid_len(SFINX_HASH_256)) != 0, "layer-1 key ids differ across path lengths",
     65       "key ids are identical");
     66 
     67   linked = chains_linked(SFINX_HASH_256, kid1, sig1 + 3, kid2, sig2 + n2 - (len + 10) * len, len, len + 2);
     68   tap(linked == 0, "layer-1 proofs do not chain onto each other", "%zu of %zu chains link", linked, len + 2);
     69 
     70   return tap_plan();
     71 }