sfinx

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

03-merkle.c (3493B)


      1 #include <string.h>
      2 
      3 #include "_tap.c"
      4 #include "src/sfinx.c"
      5 
      6 static void check_u8(uint8_t got, uint8_t want, const char *what) {
      7   tap(got == want, what, "got 0x%02x, want 0x%02x", got, want);
      8 }
      9 
     10 int main(void) {
     11   static uint8_t tree[9][256][SFINX_HASH_LEN_MAX];
     12   static uint8_t auth[8][SFINX_HASH_LEN_MAX];
     13   uint8_t        manual[2 + SFINX_PATH_LEN_MAX + 2 * SFINX_HASH_LEN_MAX];
     14   uint8_t        prefix[4] = {0xde, 0xad, 0xbe, 0xef};
     15   uint8_t        parent[SFINX_HASH_LEN_MAX];
     16   uint8_t        other[SFINX_HASH_LEN_MAX];
     17   uint8_t        node[SFINX_HASH_LEN_MAX];
     18   uint8_t        tmp[SFINX_HASH_LEN_MAX];
     19   size_t         len = sfinx_hash_len(SFINX_HASH_256);
     20   size_t         idx = 0x5a;
     21   size_t         pos;
     22 
     23   tap_begin("sfinx Merkle");
     24 
     25   check_u8(_sfinx_node_mask(0, 0xff), 0x00, "mask depth 0");
     26   check_u8(_sfinx_node_mask(1, 0x80), 0x80, "mask depth 1, right");
     27   check_u8(_sfinx_node_mask(1, 0x7f), 0x00, "mask depth 1, left");
     28   check_u8(_sfinx_node_mask(6, 0x96), 0x94, "mask depth 6");
     29   check_u8(_sfinx_node_mask(7, 0xff), 0xfe, "mask depth 7");
     30   check_u8(_sfinx_node_mask(8, 0xab), 0xab, "mask depth 8");
     31 
     32   for (size_t i = 0; i < SFINX_HASH_LEN_MAX; i++) {
     33     tree[8][0][i] = (uint8_t)i;
     34     tree[8][1][i] = (uint8_t)(255 - i);
     35   }
     36 
     37   manual[0] = 3;
     38   manual[1] = 0x28;
     39   memcpy(manual + 2, prefix, 4);
     40   memcpy(manual + 6, tree[8][0], len);
     41   memcpy(manual + 6 + len, tree[8][1], len);
     42   _sfinx_hash(SFINX_HASH_256, manual, 2 + 4 + 2 * len, other);
     43   _sfinx_merkle_parent(SFINX_HASH_256, 3, 0x28, prefix, 4, tree[8][0], tree[8][1], parent);
     44   tap(memcmp(parent, other, len) == 0, "parent matches manual assembly", "parent differs");
     45 
     46   _sfinx_merkle_parent(SFINX_HASH_256, 4, 0x28, prefix, 4, tree[8][0], tree[8][1], tmp);
     47   tap(memcmp(parent, tmp, len) != 0, "bitlen changes the parent", "parents match");
     48   _sfinx_merkle_parent(SFINX_HASH_256, 3, 0x29, prefix, 4, tree[8][0], tree[8][1], tmp);
     49   tap(memcmp(parent, tmp, len) != 0, "mask changes the parent", "parents match");
     50   _sfinx_merkle_parent(SFINX_HASH_256, 3, 0x28, prefix, 3, tree[8][0], tree[8][1], tmp);
     51   tap(memcmp(parent, tmp, len) != 0, "prefix changes the parent", "parents match");
     52   _sfinx_merkle_parent(SFINX_HASH_256, 3, 0x28, prefix, 4, tree[8][1], tree[8][0], tmp);
     53   tap(memcmp(parent, tmp, len) != 0, "child order changes the parent", "parents match");
     54 
     55   for (size_t i = 0; i < 256; i++) {
     56     uint8_t leaf = (uint8_t)i;
     57     _sfinx_hash(SFINX_HASH_256, &leaf, 1, tree[8][i]);
     58   }
     59 
     60   for (size_t d = 8; d-- > 0;) {
     61     size_t n = (size_t)1 << d;
     62     for (size_t j = 0; j < n; j++) {
     63       _sfinx_merkle_parent(SFINX_HASH_256, (uint8_t)d, _sfinx_node_mask((uint8_t)d, (uint8_t)(j << (8 - d))), NULL, 0,
     64                            tree[d + 1][2 * j], tree[d + 1][2 * j + 1], tree[d][j]);
     65     }
     66   }
     67 
     68   pos = idx;
     69   for (size_t k = 0; k < 8; k++) {
     70     memcpy(auth[k], tree[8 - k][pos ^ 1], len);
     71     pos >>= 1;
     72   }
     73 
     74   pos = idx;
     75   memcpy(node, tree[8][idx], len);
     76   for (size_t k = 0; k < 8; k++) {
     77     uint8_t pd = (uint8_t)(7 - k);
     78     uint8_t pi = (uint8_t)((pos >> 1) << (8 - pd));
     79     if (pos & 1) {
     80       _sfinx_merkle_parent(SFINX_HASH_256, pd, _sfinx_node_mask(pd, pi), NULL, 0, auth[k], node, tmp);
     81     } else {
     82       _sfinx_merkle_parent(SFINX_HASH_256, pd, _sfinx_node_mask(pd, pi), NULL, 0, node, auth[k], tmp);
     83     }
     84     memcpy(node, tmp, len);
     85     pos >>= 1;
     86   }
     87   tap(memcmp(node, tree[0][0], len) == 0, "auth path rebuilds the root", "root differs");
     88 
     89   return tap_plan();
     90 }