sfinx

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

hdr.c (8190B)


      1 #include <stdlib.h>
      2 #include <string.h>
      3 
      4 #include "../sfinx.h"
      5 
      6 // hdr format {{{
      7 //
      8 // Text key or signature file, self-describing by label, unknown labels ignored
      9 //   hash: <bits>
     10 //   seed: <hex | (no seed)>
     11 //   public-key: <hex>
     12 //   path-len: <decimal>
     13 //   signature: <hex>
     14 //   labels are case-insensitive, first valid occurrence wins
     15 
     16 static int hdr_hexval(uint8_t c) {
     17   if (c >= '0' && c <= '9') return c - '0';
     18   if (c >= 'a' && c <= 'f') return c - 'a' + 10;
     19   if (c >= 'A' && c <= 'F') return c - 'A' + 10;
     20   return -1;
     21 }
     22 
     23 static sfinx_status hdr_hex_decode(const uint8_t *in, size_t in_len, uint8_t *out, size_t cap, size_t *out_len) {
     24   size_t n;
     25   if (in_len % 2 != 0) {
     26     return SFINX_ERR_FORMAT;
     27   }
     28   n = in_len / 2;
     29   if (cap < n) {
     30     return SFINX_ERR_NOSPACE;
     31   }
     32   for (size_t i = 0; i < n; i++) {
     33     int hi = hdr_hexval(in[i * 2]);
     34     int lo = hdr_hexval(in[i * 2 + 1]);
     35     if (hi < 0 || lo < 0) {
     36       return SFINX_ERR_FORMAT;
     37     }
     38     out[i] = (uint8_t)((hi << 4) | lo);
     39   }
     40   if (out_len) {
     41     *out_len = n;
     42   }
     43   return SFINX_OK;
     44 }
     45 
     46 static void hdr_hex_encode(uint8_t *out, const uint8_t *in, size_t in_len) {
     47   static const char digits[] = "0123456789abcdef";
     48   for (size_t i = 0; i < in_len; i++) {
     49     out[i * 2]     = (uint8_t)digits[(in[i] >> 4) & 0x0f];
     50     out[i * 2 + 1] = (uint8_t)digits[in[i] & 0x0f];
     51   }
     52 }
     53 
     54 static size_t hdr_uint_len(uint32_t value) {
     55   size_t n = 1;
     56   while (value >= 10) {
     57     value /= 10;
     58     n++;
     59   }
     60   return n;
     61 }
     62 
     63 static size_t hdr_uint_encode(uint8_t *out, uint32_t value) {
     64   size_t n = hdr_uint_len(value);
     65   for (size_t i = n; i-- > 0;) {
     66     out[i] = (uint8_t)('0' + value % 10);
     67     value /= 10;
     68   }
     69   return n;
     70 }
     71 
     72 static int hdr_match(const uint8_t *line, size_t len, const char *label, const uint8_t **val, size_t *val_len) {
     73   size_t at        = 0;
     74   size_t label_len = strlen(label);
     75   while (at < len && (line[at] == ' ' || line[at] == '\t')) at++;
     76   if (at + label_len > len) return 0;
     77   for (size_t i = 0; i < label_len; i++) {
     78     uint8_t c = line[at + i];
     79     if (c >= 'A' && c <= 'Z') c = (uint8_t)(c - 'A' + 'a');
     80     if (c != (uint8_t)label[i]) return 0;
     81   }
     82   at += label_len;
     83   while (at < len && (line[at] == ' ' || line[at] == '\t')) at++;
     84   if (at >= len || line[at] != ':') return 0;
     85   at++;
     86   while (at < len && (line[at] == ' ' || line[at] == '\t')) at++;
     87   size_t end = len;
     88   while (end > at && (line[end - 1] == ' ' || line[end - 1] == '\t' || line[end - 1] == '\r')) end--;
     89   *val     = line + at;
     90   *val_len = end - at;
     91   return 1;
     92 }
     93 
     94 static int hdr_scan(const uint8_t *data, size_t len, const char *label, const uint8_t **val, size_t *val_len) {
     95   for (size_t pos = 0; pos < len;) {
     96     size_t end = pos;
     97     while (end < len && data[end] != '\n') end++;
     98     if (hdr_match(data + pos, end - pos, label, val, val_len)) {
     99       return 1;
    100     }
    101     pos = end + 1;
    102   }
    103   return 0;
    104 }
    105 
    106 static int hdr_scan_uint(const uint8_t *data, size_t len, const char *label, uint32_t *out) {
    107   const uint8_t *val;
    108   size_t         val_len;
    109   uint32_t       acc = 0;
    110   if (!hdr_scan(data, len, label, &val, &val_len) || val_len == 0) {
    111     return 0;
    112   }
    113   for (size_t i = 0; i < val_len; i++) {
    114     if (val[i] < '0' || val[i] > '9') {
    115       return 0;
    116     }
    117     acc = acc * 10 + (uint32_t)(val[i] - '0');
    118   }
    119   *out = acc;
    120   return 1;
    121 }
    122 
    123 static int hdr_key_detect(const uint8_t *data, size_t len) {
    124   const uint8_t *val;
    125   size_t         val_len;
    126   return hdr_scan(data, len, "seed", &val, &val_len) || hdr_scan(data, len, "public-key", &val, &val_len);
    127 }
    128 
    129 static sfinx_status hdr_key_decode(const uint8_t *data, size_t len, sfinx_key *out) {
    130   const uint8_t *val;
    131   size_t         val_len;
    132   int            have_seed = 0;
    133   int            have_pub  = 0;
    134   uint32_t       num;
    135   sfinx_status   status;
    136 
    137   if (hdr_scan_uint(data, len, "hash", &num) && sfinx_hash_len((sfinx_hash)num) != 0) {
    138     out->hash = (sfinx_hash)num;
    139   }
    140   if (hdr_scan_uint(data, len, "path-len", &num) && sfinx_path_len_valid(num)) {
    141     out->path_len = (ssize_t)num;
    142   }
    143   if (hdr_scan(data, len, "seed", &val, &val_len)) {
    144     have_seed = 1;
    145     if (val_len > 0 && val[0] != '(') {
    146       if (val_len / 2 > SFINX_SEED_LEN_MAX) return SFINX_ERR_FORMAT;
    147       out->seed = malloc(val_len / 2 + 1);
    148       if (!out->seed) return SFINX_ERR_NOSPACE;
    149       status = hdr_hex_decode(val, val_len, out->seed, val_len / 2, &out->seed_len);
    150       if (status != SFINX_OK) {
    151         free(out->seed);
    152         out->seed = NULL;
    153         return status;
    154       }
    155     }
    156   }
    157   if (hdr_scan(data, len, "public-key", &val, &val_len)) {
    158     have_pub = 1;
    159     if (val_len > 0 && val[0] != '(') {
    160       out->pub = malloc(val_len / 2 + 1);
    161       if (!out->pub) return SFINX_ERR_NOSPACE;
    162       status = hdr_hex_decode(val, val_len, out->pub, val_len / 2, &out->pub_len);
    163       if (status != SFINX_OK) {
    164         free(out->pub);
    165         out->pub = NULL;
    166         return status;
    167       }
    168     }
    169   }
    170 
    171   if (!have_seed && !have_pub) return SFINX_ERR_FORMAT;
    172   if (!out->seed && !out->pub) return SFINX_ERR_FORMAT;
    173   return SFINX_OK;
    174 }
    175 
    176 static size_t hdr_key_encode_len(const sfinx_key *key) {
    177   size_t need = strlen("hash: 000\n");
    178   need += strlen("seed: \n") + (key->seed ? key->seed_len * 2 : strlen("(no seed)"));
    179   need += strlen("public-key: \n") + (key->pub ? key->pub_len * 2 : strlen("(no public key)"));
    180   if (key->pub && key->path_len >= 0) {
    181     need += strlen("path-len: \n") + hdr_uint_len((uint32_t)key->path_len);
    182   }
    183   return need;
    184 }
    185 
    186 static sfinx_status hdr_key_encode(const sfinx_key *key, uint8_t *out, size_t cap, size_t *len_out) {
    187   uint32_t bits = (uint32_t)key->hash;
    188   size_t   at   = 0;
    189   if (cap < hdr_key_encode_len(key)) {
    190     return SFINX_ERR_NOSPACE;
    191   }
    192 
    193   memcpy(out + at, "hash: ", 6);
    194   at += 6;
    195   out[at++] = (uint8_t)('0' + (bits / 100) % 10);
    196   out[at++] = (uint8_t)('0' + (bits / 10) % 10);
    197   out[at++] = (uint8_t)('0' + bits % 10);
    198   out[at++] = '\n';
    199 
    200   memcpy(out + at, "seed: ", 6);
    201   at += 6;
    202   if (key->seed) {
    203     hdr_hex_encode(out + at, key->seed, key->seed_len);
    204     at += key->seed_len * 2;
    205   } else {
    206     memcpy(out + at, "(no seed)", 9);
    207     at += 9;
    208   }
    209   out[at++] = '\n';
    210 
    211   memcpy(out + at, "public-key: ", 12);
    212   at += 12;
    213   if (key->pub) {
    214     hdr_hex_encode(out + at, key->pub, key->pub_len);
    215     at += key->pub_len * 2;
    216   } else {
    217     memcpy(out + at, "(no public key)", 15);
    218     at += 15;
    219   }
    220   out[at++] = '\n';
    221 
    222   if (key->pub && key->path_len >= 0) {
    223     memcpy(out + at, "path-len: ", 10);
    224     at += 10;
    225     at += hdr_uint_encode(out + at, (uint32_t)key->path_len);
    226     out[at++] = '\n';
    227   }
    228 
    229   if (len_out) {
    230     *len_out = at;
    231   }
    232   return SFINX_OK;
    233 }
    234 
    235 static int hdr_sig_detect(const uint8_t *data, size_t len) {
    236   const uint8_t *val;
    237   size_t         val_len;
    238   return hdr_scan(data, len, "signature", &val, &val_len);
    239 }
    240 
    241 static sfinx_status hdr_sig_decode(const uint8_t *data, size_t len, uint8_t *out, size_t cap, size_t *len_out) {
    242   const uint8_t *val;
    243   size_t         val_len;
    244   if (!hdr_scan(data, len, "signature", &val, &val_len)) {
    245     return SFINX_ERR_FORMAT;
    246   }
    247   return hdr_hex_decode(val, val_len, out, cap, len_out);
    248 }
    249 
    250 static size_t hdr_sig_encode_len(const uint8_t *sig, size_t sig_len) {
    251   (void)sig;
    252   return strlen("signature: \n") + sig_len * 2;
    253 }
    254 
    255 static sfinx_status hdr_sig_encode(const uint8_t *sig, size_t sig_len, uint8_t *out, size_t cap, size_t *len_out) {
    256   size_t at = 0;
    257   if (cap < hdr_sig_encode_len(sig, sig_len)) {
    258     return SFINX_ERR_NOSPACE;
    259   }
    260   memcpy(out + at, "signature: ", 11);
    261   at += 11;
    262   hdr_hex_encode(out + at, sig, sig_len);
    263   at += sig_len * 2;
    264   out[at++] = '\n';
    265   if (len_out) {
    266     *len_out = at;
    267   }
    268   return SFINX_OK;
    269 }
    270 
    271 static sfinx_format hdr_format = {
    272     .name           = "hdr",
    273     .key_detect     = hdr_key_detect,
    274     .key_decode     = hdr_key_decode,
    275     .key_encode_len = hdr_key_encode_len,
    276     .key_encode     = hdr_key_encode,
    277     .sig_detect     = hdr_sig_detect,
    278     .sig_decode     = hdr_sig_decode,
    279     .sig_encode_len = hdr_sig_encode_len,
    280     .sig_encode     = hdr_sig_encode,
    281 };
    282 
    283 __attribute__((constructor)) static void hdr_register(void) {
    284   sfinx_format_register(&hdr_format);
    285 }
    286 // }}}
    287 
    288 // vim:fdm=marker:fdl=0