sfinx

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

hex.c (5114B)


      1 #include <stdlib.h>
      2 
      3 #include "../sfinx.h"
      4 
      5 // hex format {{{
      6 //
      7 // Lowercase hex text, no marker, so it is never auto-detected
      8 //   key decode reads a seed, key encode writes the seed if present else the public key
      9 //   signature decode parses hex, encode emits hex
     10 
     11 static int hex_val(uint8_t c) {
     12   if (c >= '0' && c <= '9') return c - '0';
     13   if (c >= 'a' && c <= 'f') return c - 'a' + 10;
     14   if (c >= 'A' && c <= 'F') return c - 'A' + 10;
     15   return -1;
     16 }
     17 
     18 static void hex_put(uint8_t *out, const uint8_t *in, size_t in_len) {
     19   static const char digits[] = "0123456789abcdef";
     20   for (size_t i = 0; i < in_len; i++) {
     21     out[i * 2]     = (uint8_t)digits[(in[i] >> 4) & 0x0f];
     22     out[i * 2 + 1] = (uint8_t)digits[in[i] & 0x0f];
     23   }
     24 }
     25 
     26 static sfinx_status hex_get(const uint8_t *in, size_t in_len, uint8_t *out, size_t cap, size_t *out_len) {
     27   size_t n;
     28   if (in_len % 2 != 0) {
     29     return SFINX_ERR_FORMAT;
     30   }
     31   n = in_len / 2;
     32   if (cap < n) {
     33     return SFINX_ERR_NOSPACE;
     34   }
     35   for (size_t i = 0; i < n; i++) {
     36     int hi = hex_val(in[i * 2]);
     37     int lo = hex_val(in[i * 2 + 1]);
     38     if (hi < 0 || lo < 0) {
     39       return SFINX_ERR_FORMAT;
     40     }
     41     out[i] = (uint8_t)((hi << 4) | lo);
     42   }
     43   if (out_len) {
     44     *out_len = n;
     45   }
     46   return SFINX_OK;
     47 }
     48 
     49 static sfinx_status hex_key_decode(const uint8_t *data, size_t len, sfinx_key *out) {
     50   sfinx_status status;
     51   if (len == 0 || len / 2 > SFINX_SEED_LEN_MAX) {
     52     return SFINX_ERR_FORMAT;
     53   }
     54   out->seed = malloc(len / 2 + 1);
     55   if (!out->seed) {
     56     return SFINX_ERR_NOSPACE;
     57   }
     58   status = hex_get(data, len, out->seed, len / 2, &out->seed_len);
     59   if (status != SFINX_OK) {
     60     free(out->seed);
     61     out->seed = NULL;
     62   }
     63   return status;
     64 }
     65 
     66 static size_t hex_key_encode_len(const sfinx_key *key) {
     67   if (key->seed) return key->seed_len * 2;
     68   if (key->pub) return key->pub_len * 2;
     69   return 0;
     70 }
     71 
     72 static sfinx_status hex_key_encode(const sfinx_key *key, uint8_t *out, size_t cap, size_t *len_out) {
     73   const uint8_t *src;
     74   size_t         len;
     75   if (key->seed) {
     76     src = key->seed;
     77     len = key->seed_len;
     78   } else if (key->pub) {
     79     src = key->pub;
     80     len = key->pub_len;
     81   } else {
     82     return SFINX_ERR_ARGS;
     83   }
     84   if (cap < len * 2) {
     85     return SFINX_ERR_NOSPACE;
     86   }
     87   hex_put(out, src, len);
     88   if (len_out) {
     89     *len_out = len * 2;
     90   }
     91   return SFINX_OK;
     92 }
     93 
     94 static sfinx_status hex_sig_decode(const uint8_t *data, size_t len, uint8_t *out, size_t cap, size_t *len_out) {
     95   return hex_get(data, len, out, cap, len_out);
     96 }
     97 
     98 static size_t hex_sig_encode_len(const uint8_t *sig, size_t sig_len) {
     99   (void)sig;
    100   return sig_len * 2;
    101 }
    102 
    103 static sfinx_status hex_sig_encode(const uint8_t *sig, size_t sig_len, uint8_t *out, size_t cap, size_t *len_out) {
    104   if (cap < sig_len * 2) {
    105     return SFINX_ERR_NOSPACE;
    106   }
    107   hex_put(out, sig, sig_len);
    108   if (len_out) {
    109     *len_out = sig_len * 2;
    110   }
    111   return SFINX_OK;
    112 }
    113 
    114 static sfinx_format hex_format = {
    115     .name           = "hex",
    116     .key_decode     = hex_key_decode,
    117     .key_encode_len = hex_key_encode_len,
    118     .key_encode     = hex_key_encode,
    119     .sig_decode     = hex_sig_decode,
    120     .sig_encode_len = hex_sig_encode_len,
    121     .sig_encode     = hex_sig_encode,
    122 };
    123 
    124 __attribute__((constructor)) static void hex_register(void) {
    125   sfinx_format_register(&hex_format);
    126 }
    127 // }}}
    128 
    129 // hexpub format {{{
    130 //
    131 // A public key as hex text, no marker, so it is never auto-detected
    132 //   decode infers the hash from the length, encode emits hex
    133 
    134 static sfinx_hash hexpub_hash_for_len(size_t len) {
    135   static const sfinx_hash hashes[] = {SFINX_HASH_224, SFINX_HASH_256, SFINX_HASH_384, SFINX_HASH_512};
    136   for (size_t i = 0; i < sizeof(hashes) / sizeof(hashes[0]); i++) {
    137     if (sfinx_hash_len(hashes[i]) == len) return hashes[i];
    138   }
    139   return 0;
    140 }
    141 
    142 static sfinx_status hexpub_key_decode(const uint8_t *data, size_t len, sfinx_key *out) {
    143   sfinx_status status;
    144   size_t       n;
    145   sfinx_hash   hash;
    146   if (len % 2 != 0) {
    147     return SFINX_ERR_FORMAT;
    148   }
    149   n    = len / 2;
    150   hash = hexpub_hash_for_len(n);
    151   if (hash == 0) {
    152     return SFINX_ERR_FORMAT;
    153   }
    154   out->pub = malloc(n);
    155   if (!out->pub) {
    156     return SFINX_ERR_NOSPACE;
    157   }
    158   status = hex_get(data, len, out->pub, n, &out->pub_len);
    159   if (status != SFINX_OK) {
    160     free(out->pub);
    161     out->pub = NULL;
    162     return status;
    163   }
    164   out->hash = hash;
    165   return SFINX_OK;
    166 }
    167 
    168 static size_t hexpub_key_encode_len(const sfinx_key *key) {
    169   return key->pub ? key->pub_len * 2 : 0;
    170 }
    171 
    172 static sfinx_status hexpub_key_encode(const sfinx_key *key, uint8_t *out, size_t cap, size_t *len_out) {
    173   if (!key->pub) {
    174     return SFINX_ERR_ARGS;
    175   }
    176   if (cap < key->pub_len * 2) {
    177     return SFINX_ERR_NOSPACE;
    178   }
    179   hex_put(out, key->pub, key->pub_len);
    180   if (len_out) {
    181     *len_out = key->pub_len * 2;
    182   }
    183   return SFINX_OK;
    184 }
    185 
    186 static sfinx_format hexpub_format = {
    187     .name           = "hexpub",
    188     .key_decode     = hexpub_key_decode,
    189     .key_encode_len = hexpub_key_encode_len,
    190     .key_encode     = hexpub_key_encode,
    191 };
    192 
    193 __attribute__((constructor)) static void hexpub_register(void) {
    194   sfinx_format_register(&hexpub_format);
    195 }
    196 // }}}
    197 
    198 // vim:fdm=marker:fdl=0