sfinx

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

raw.c (3817B)


      1 #include <stdlib.h>
      2 #include <string.h>
      3 
      4 #include "../sfinx.h"
      5 
      6 // raw format {{{
      7 //
      8 // The whole input is raw bytes, no marker, so it is never auto-detected
      9 //   key decode reads a seed, key encode writes the seed if present else the public key
     10 //   signature decode and encode are the identity
     11 
     12 static sfinx_status raw_key_decode(const uint8_t *data, size_t len, sfinx_key *out) {
     13   uint8_t *seed;
     14   if (len == 0 || len > SFINX_SEED_LEN_MAX) {
     15     return SFINX_ERR_FORMAT;
     16   }
     17   seed = malloc(len);
     18   if (!seed) {
     19     return SFINX_ERR_NOSPACE;
     20   }
     21   memcpy(seed, data, len);
     22   out->seed     = seed;
     23   out->seed_len = len;
     24   return SFINX_OK;
     25 }
     26 
     27 static size_t raw_key_encode_len(const sfinx_key *key) {
     28   if (key->seed) return key->seed_len;
     29   if (key->pub) return key->pub_len;
     30   return 0;
     31 }
     32 
     33 static sfinx_status raw_key_encode(const sfinx_key *key, uint8_t *out, size_t cap, size_t *len_out) {
     34   const uint8_t *src;
     35   size_t         len;
     36   if (key->seed) {
     37     src = key->seed;
     38     len = key->seed_len;
     39   } else if (key->pub) {
     40     src = key->pub;
     41     len = key->pub_len;
     42   } else {
     43     return SFINX_ERR_ARGS;
     44   }
     45   if (cap < len) {
     46     return SFINX_ERR_NOSPACE;
     47   }
     48   memcpy(out, src, len);
     49   if (len_out) {
     50     *len_out = len;
     51   }
     52   return SFINX_OK;
     53 }
     54 
     55 static sfinx_status raw_sig_decode(const uint8_t *data, size_t len, uint8_t *out, size_t cap, size_t *len_out) {
     56   if (cap < len) {
     57     return SFINX_ERR_NOSPACE;
     58   }
     59   memcpy(out, data, len);
     60   if (len_out) {
     61     *len_out = len;
     62   }
     63   return SFINX_OK;
     64 }
     65 
     66 static size_t raw_sig_encode_len(const uint8_t *sig, size_t sig_len) {
     67   (void)sig;
     68   return sig_len;
     69 }
     70 
     71 static sfinx_status raw_sig_encode(const uint8_t *sig, size_t sig_len, uint8_t *out, size_t cap, size_t *len_out) {
     72   return raw_sig_decode(sig, sig_len, out, cap, len_out);
     73 }
     74 
     75 static sfinx_format raw_format = {
     76     .name           = "raw",
     77     .key_decode     = raw_key_decode,
     78     .key_encode_len = raw_key_encode_len,
     79     .key_encode     = raw_key_encode,
     80     .sig_decode     = raw_sig_decode,
     81     .sig_encode_len = raw_sig_encode_len,
     82     .sig_encode     = raw_sig_encode,
     83 };
     84 
     85 __attribute__((constructor)) static void raw_register(void) {
     86   sfinx_format_register(&raw_format);
     87 }
     88 // }}}
     89 
     90 // rawpub format {{{
     91 //
     92 // A bare public key of L bytes, no marker, so it is never auto-detected
     93 //   decode infers the hash from the length, encode writes the public half
     94 
     95 static sfinx_hash rawpub_hash_for_len(size_t len) {
     96   static const sfinx_hash hashes[] = {SFINX_HASH_224, SFINX_HASH_256, SFINX_HASH_384, SFINX_HASH_512};
     97   for (size_t i = 0; i < sizeof(hashes) / sizeof(hashes[0]); i++) {
     98     if (sfinx_hash_len(hashes[i]) == len) return hashes[i];
     99   }
    100   return 0;
    101 }
    102 
    103 static sfinx_status rawpub_key_decode(const uint8_t *data, size_t len, sfinx_key *out) {
    104   sfinx_hash hash = rawpub_hash_for_len(len);
    105   if (hash == 0) {
    106     return SFINX_ERR_FORMAT;
    107   }
    108   out->pub = malloc(len);
    109   if (!out->pub) {
    110     return SFINX_ERR_NOSPACE;
    111   }
    112   memcpy(out->pub, data, len);
    113   out->pub_len = len;
    114   out->hash    = hash;
    115   return SFINX_OK;
    116 }
    117 
    118 static size_t rawpub_key_encode_len(const sfinx_key *key) {
    119   return key->pub ? key->pub_len : 0;
    120 }
    121 
    122 static sfinx_status rawpub_key_encode(const sfinx_key *key, uint8_t *out, size_t cap, size_t *len_out) {
    123   if (!key->pub) {
    124     return SFINX_ERR_ARGS;
    125   }
    126   if (cap < key->pub_len) {
    127     return SFINX_ERR_NOSPACE;
    128   }
    129   memcpy(out, key->pub, key->pub_len);
    130   if (len_out) {
    131     *len_out = key->pub_len;
    132   }
    133   return SFINX_OK;
    134 }
    135 
    136 static sfinx_format rawpub_format = {
    137     .name           = "rawpub",
    138     .key_decode     = rawpub_key_decode,
    139     .key_encode_len = rawpub_key_encode_len,
    140     .key_encode     = rawpub_key_encode,
    141 };
    142 
    143 __attribute__((constructor)) static void rawpub_register(void) {
    144   sfinx_format_register(&rawpub_format);
    145 }
    146 // }}}
    147 
    148 // vim:fdm=marker:fdl=0