keystore.c (3257B)
1 #include <string.h> 2 3 #include "secp256k1.h" 4 #include "secp256k1_recovery.h" 5 6 #include "keystore.h" 7 8 9 unsigned char* keystore_sign(const keystore_t *keystore, unsigned char *z, const int key_idx, const unsigned char *digest) { 10 int r; 11 int recover; 12 char recover_byte; 13 secp256k1_context *ecctx; 14 secp256k1_ecdsa_recoverable_signature signature; 15 keystore_key_t key; 16 17 ecctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY); 18 19 keystore_get(keystore, &key, key_idx); 20 r = secp256k1_ecdsa_sign_recoverable(ecctx, &signature, digest, key.pk, NULL, NULL); 21 if (r == 0) { 22 return NULL; 23 } 24 25 r = secp256k1_ecdsa_recoverable_signature_serialize_compact(ecctx, z, &recover, &signature); 26 if (r == 0) { 27 return NULL; 28 } 29 *(z+64) = (unsigned char)recover; 30 31 return z; 32 } 33 34 35 // will _copy_ key to keystore 36 keystore_key_t* keystore_put(keystore_t *keystore, const keystore_key_t *key_in, const unsigned char *passphrase, size_t passphrase_sz) { 37 keystore_key_t *key_out; 38 39 key_out = keystore->keys + keystore->keys_count; 40 41 memcpy(key_out, key_in, sizeof(keystore_key_t)); 42 43 keystore->keys_count++; 44 45 return key_out; 46 } 47 48 49 keystore_key_t* keystore_get(const keystore_t *keystore, keystore_key_t *z, const int idx) { 50 memcpy(z, keystore->keys+idx, sizeof(keystore_key_t)); 51 return z; 52 } 53 54 55 int key_from_public(keystore_key_t *key) { 56 int r; 57 secp256k1_context *ecctx; 58 unsigned char digest[SWARM_WORD_SIZE]; 59 60 r = keccak_hash_btc(digest, SWARM_WORD_SIZE, key->pubk + 1, SWARM_PUBLIC_KEY_SIZE - 1); 61 if (r < 0) { 62 return 1; 63 } 64 65 memcpy(key->label, digest + SWARM_WORD_SIZE - SWARM_ADDRESS_SIZE, SWARM_ADDRESS_SIZE); 66 67 return 0; 68 } 69 70 71 int key_from_private(keystore_key_t *key) { 72 int r; 73 secp256k1_context *ecctx; 74 secp256k1_pubkey public_key_o; 75 size_t public_key_sz; 76 unsigned char *p; 77 78 ecctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN); 79 80 r = secp256k1_ec_pubkey_create(ecctx, &public_key_o, key->pk); 81 if (r == 0) { 82 return 1; 83 } 84 85 public_key_sz = SWARM_PUBLIC_KEY_SIZE; 86 r = secp256k1_ec_pubkey_serialize(ecctx, key->pubk, &public_key_sz, &public_key_o, SECP256K1_EC_UNCOMPRESSED); 87 if (r == 0) { 88 return 1; 89 } 90 91 r = key_from_public(key); 92 if (r != 0) { 93 return 1; 94 } 95 96 return 0; 97 } 98 99 100 int key_recover_compact(const unsigned char *signature, unsigned char *public_key, const unsigned char *digest) { 101 int r; 102 size_t public_key_sz; 103 104 secp256k1_context *ecctx; 105 secp256k1_ecdsa_recoverable_signature signature_o; 106 secp256k1_pubkey public_key_o; 107 108 ecctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE); 109 110 r = secp256k1_ecdsa_recoverable_signature_parse_compact(ecctx, &signature_o, signature, (int)*(signature+64)); 111 if (r == 0) { 112 return 1; 113 } 114 115 r = secp256k1_ecdsa_recover(ecctx, &public_key_o, &signature_o, digest); 116 if (r == 0) { 117 return 1; 118 } 119 120 public_key_sz = SWARM_PUBLIC_KEY_SIZE; 121 r = secp256k1_ec_pubkey_serialize(ecctx, public_key, &public_key_sz, &public_key_o, SECP256K1_EC_UNCOMPRESSED); 122 if (r == 0) { 123 return 1; 124 } 125 if (public_key_sz != SWARM_PUBLIC_KEY_SIZE) { 126 return 1; 127 } 128 129 return 0; 130 } 131 132 133 keystore_key_t* key_recover(keystore_key_t *z, const unsigned char *signature, const unsigned char *digest) { 134 int r; 135 136 r = key_recover_compact(signature, z->pubk, digest); 137 if (r != 0) { 138 return NULL; 139 } 140 141 return z; 142 }