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