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