sfinx

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

02-wots.c (5446B)


      1 #include <string.h>
      2 
      3 #include "_tap.c"
      4 #include "src/sfinx.c"
      5 
      6 static void check_size(size_t got, size_t want, const char *what) {
      7   tap(got == want, what, "got %zu, want %zu", got, want);
      8 }
      9 
     10 static void chain_manual(sfinx_hash hash, uint8_t *node, const uint8_t *kid, uint8_t index, uint8_t from,
     11                          uint32_t steps) {
     12   uint8_t blk[SFINX_HASH_LEN_MAX * 2 + 2];
     13   size_t  len = sfinx_hash_len(hash);
     14   size_t  k   = _sfinx_kid_len(hash);
     15   for (uint32_t i = 0; i < steps; i++) {
     16     memcpy(blk, node, len);
     17     memcpy(blk + len, kid, k);
     18     blk[len + k]     = index;
     19     blk[len + k + 1] = (uint8_t)(from + i);
     20     _sfinx_hash(hash, blk, len + k + 2, node);
     21   }
     22 }
     23 
     24 int main(void) {
     25   static const sfinx_hash hashes[] = {SFINX_HASH_224, SFINX_HASH_256, SFINX_HASH_384, SFINX_HASH_512};
     26   static const char      *labels[] = {"round trip 224", "round trip 256", "round trip 384", "round trip 512"};
     27   const uint8_t          *seed     = (const uint8_t *)"sfinx wots seed";
     28   size_t                  seed_len = strlen((const char *)seed);
     29   uint8_t                 zero[SFINX_HASH_LEN_MAX] = {0};
     30   uint8_t                 ones[SFINX_HASH_LEN_MAX];
     31   uint8_t                 value[SFINX_HASH_LEN_MAX];
     32   uint8_t                 digits[SFINX_WOTS_DIGITS_MAX];
     33   uint8_t                 pubkey[SFINX_HASH_LEN_MAX];
     34   uint8_t                 other[SFINX_HASH_LEN_MAX];
     35   uint8_t                 proof[SFINX_WOTS_BYTES_MAX];
     36   uint8_t                 node[SFINX_HASH_LEN_MAX];
     37   uint8_t                 manual[SFINX_HASH_LEN_MAX];
     38   uint8_t                 kid[SFINX_HASH_LEN_MAX];
     39 
     40   tap_begin("sfinx WOTS");
     41 
     42   _sfinx_wots_digits(SFINX_HASH_256, zero, digits);
     43   check_size(digits[32], 0x1f, "checksum high, all zero");
     44   check_size(digits[33], 0xe0, "checksum low, all zero");
     45 
     46   memset(ones, 0xff, sizeof(ones));
     47   _sfinx_wots_digits(SFINX_HASH_256, ones, digits);
     48   check_size(digits[0], 0xff, "digit copies value, all one");
     49   check_size(digits[32], 0x00, "checksum high, all one");
     50   check_size(digits[33], 0x00, "checksum low, all one");
     51 
     52   _sfinx_wots_digits(SFINX_HASH_512, zero, digits);
     53   check_size(digits[64], 0x3f, "checksum high, L 64");
     54   check_size(digits[65], 0xc0, "checksum low, L 64");
     55 
     56   for (size_t i = 0; i < 32; i++) value[i] = (uint8_t)(i * 7 + 1);
     57   _sfinx_wots_digits(SFINX_HASH_256, value, digits);
     58   tap(memcmp(digits, value, 32) == 0, "digits copy the value", "digits differ");
     59 
     60   _sfinx_kid(SFINX_HASH_256, NULL, 0, kid);
     61 
     62   for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1);
     63   memcpy(manual, node, 32);
     64   chain_manual(SFINX_HASH_256, manual, kid, 7, 0, 5);
     65   _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 0, 5);
     66   tap(memcmp(node, manual, 32) == 0, "chain of 5 matches manual", "chain differs");
     67 
     68   for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1);
     69   memcpy(manual, node, 32);
     70   chain_manual(SFINX_HASH_256, manual, kid, 7, 3, 4);
     71   _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 3, 4);
     72   tap(memcmp(node, manual, 32) == 0, "chain from 3 matches manual", "chain differs");
     73 
     74   for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1);
     75   memcpy(manual, node, 32);
     76   _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 0, 0);
     77   tap(memcmp(node, manual, 32) == 0, "chain of 0 is identity", "chain changed");
     78 
     79   for (size_t i = 0; i < 32; i++) node[i] = (uint8_t)(i + 1);
     80   memcpy(manual, node, 32);
     81   _sfinx_wots_chain(SFINX_HASH_256, node, kid, 7, 0, 1);
     82   _sfinx_wots_chain(SFINX_HASH_256, manual, kid, 8, 0, 1);
     83   tap(memcmp(node, manual, 32) != 0, "chain index changes the step", "steps match");
     84 
     85   _sfinx_wots_pubkey(SFINX_HASH_256, seed, seed_len, seed_len, pubkey);
     86   _sfinx_wots_pubkey(SFINX_HASH_256, seed, seed_len, seed_len, other);
     87   tap(memcmp(pubkey, other, 32) == 0, "pubkey is deterministic", "pubkeys differ");
     88 
     89   _sfinx_wots_pubkey(SFINX_HASH_256, (const uint8_t *)"other wots seed", 15, 15, other);
     90   tap(memcmp(pubkey, other, 32) != 0, "different seed gives a different pubkey", "pubkeys match");
     91 
     92   _sfinx_hash(SFINX_HASH_256, (const uint8_t *)"hello", 5, value);
     93   _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof);
     94   tap(_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof, kid), "proof verifies", "verify failed");
     95 
     96   proof[17] ^= 0x40;
     97   tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof, kid), "tampered proof fails", "verify passed");
     98 
     99   _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof);
    100   value[3] ^= 0x01;
    101   tap(!_sfinx_wots_verify(SFINX_HASH_256, pubkey, value, proof, kid), "tampered value fails", "verify passed");
    102 
    103   _sfinx_hash(SFINX_HASH_256, (const uint8_t *)"hello", 5, value);
    104   _sfinx_wots_sign(SFINX_HASH_256, seed, seed_len, seed_len, value, sfinx_hash_len(SFINX_HASH_256), proof);
    105   memcpy(other, pubkey, 32);
    106   other[0] ^= 0x01;
    107   tap(!_sfinx_wots_verify(SFINX_HASH_256, other, value, proof, kid), "wrong pubkey fails", "verify passed");
    108 
    109   for (size_t h = 0; h < 4; h++) {
    110     uint8_t hkid[SFINX_HASH_LEN_MAX];
    111     _sfinx_kid(hashes[h], NULL, 0, hkid);
    112     _sfinx_hash(hashes[h], (const uint8_t *)"message", 7, value);
    113     _sfinx_wots_pubkey(hashes[h], seed, seed_len, seed_len, pubkey);
    114     _sfinx_wots_sign(hashes[h], seed, seed_len, seed_len, value, sfinx_hash_len(hashes[h]), proof);
    115     tap(_sfinx_wots_verify(hashes[h], pubkey, value, proof, hkid), labels[h], "verify failed");
    116   }
    117 
    118   return tap_plan();
    119 }