libswarm-ng

C implementation of BMT hasher, Swarmhash and Single Owner Chunk for swarm
git clone git://git.defalsify.org/libswarm-ng.git
Log | Files | Refs | Submodules | README

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 }