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