diff --git a/include/pcp/key.h b/include/pcp/key.h index f86b0f3..055ce35 100644 --- a/include/pcp/key.h +++ b/include/pcp/key.h @@ -31,6 +31,7 @@ #include "defines.h" #include "platform.h" #include "mem.h" +#include "buffer.h" #include "mac.h" #include "randomart.h" #include "version.h" @@ -401,14 +402,14 @@ pcp_pubkey_t *pubkey2native(pcp_pubkey_t *k); byte * pcp_gennonce(); /* use scrypt() to create a key from a passphrase and a nonce - FIXME: use pure scrypt() instead. + this is a wrapper around pcp_scrypt() */ byte *pcp_derivekey(char *passphrase, byte *nonce); -/* FIXME: abandon and use Buffer instead */ -void pcp_seckeyblob(void *blob, pcp_key_t *k); -void pcp_pubkeyblob(void *blob, pcp_pubkey_t *k); -void *pcp_keyblob(void *k, int type); /* allocates blob */ +/* convert the key struct into a binary blob */ +void pcp_seckeyblob(Buffer *b, pcp_key_t *k); +void pcp_pubkeyblob(Buffer *b, pcp_pubkey_t *k); +Buffer *pcp_keyblob(void *k, int type); /* allocates blob */ /** Make a sanity check of the given public key structure. diff --git a/libpcp/key.c b/libpcp/key.c index da77a89..fc2b4e0 100644 --- a/libpcp/key.c +++ b/libpcp/key.c @@ -300,10 +300,7 @@ pcp_pubkey_t *pubkey2native(pcp_pubkey_t *k) { #endif } -void pcp_seckeyblob(void *blob, pcp_key_t *k) { - //memcpy(blob, k, PCP_RAW_KEYSIZE); - Buffer *b = buffer_new(PCP_RAW_KEYSIZE, "bs"); - +void pcp_seckeyblob(Buffer *b, pcp_key_t *k) { buffer_add(b, k->masterpub, 32); buffer_add(b, k->mastersecret, 64); @@ -325,14 +322,9 @@ void pcp_seckeyblob(void *blob, pcp_key_t *k) { buffer_add64(b, k->ctime); buffer_add32(b, k->version); buffer_add32(b, k->serial); - // buffer_dump(b); - buffer_get_chunk(b, blob, b->end - b->offset); - buffer_free(b); } -void pcp_pubkeyblob(void *blob, pcp_pubkey_t *k) { - Buffer *b = buffer_new(PCP_RAW_PUBKEYSIZE, "bp"); - +void pcp_pubkeyblob(Buffer *b, pcp_pubkey_t *k) { buffer_add(b, k->masterpub, 32); buffer_add(b, k->sigpub, 32); buffer_add(b, k->pub, 32); @@ -347,22 +339,19 @@ void pcp_pubkeyblob(void *blob, pcp_pubkey_t *k) { buffer_add32(b, k->version); buffer_add32(b, k->serial); buffer_add8(b, k->valid); - - buffer_get_chunk(b, blob, b->end - b->offset); - buffer_free(b); } -void *pcp_keyblob(void *k, int type) { - void *blob; +Buffer *pcp_keyblob(void *k, int type) { if(type == PCP_KEY_TYPE_PUBLIC) { - blob = ucmalloc(PCP_RAW_PUBKEYSIZE); - pcp_pubkeyblob(blob, (pcp_pubkey_t *)k); + Buffer *b = buffer_new(PCP_RAW_PUBKEYSIZE, "bp"); + pcp_pubkeyblob(b, (pcp_pubkey_t *)k); + return b; } else { - blob = ucmalloc(PCP_RAW_KEYSIZE); - pcp_seckeyblob(blob, (pcp_key_t *)k); + Buffer *b = buffer_new(PCP_RAW_KEYSIZE, "bs"); + pcp_seckeyblob(b, (pcp_key_t *)k); + return b; } - return blob; } diff --git a/libpcp/vault.c b/libpcp/vault.c index 7b9cbdc..411d12f 100644 --- a/libpcp/vault.c +++ b/libpcp/vault.c @@ -156,7 +156,7 @@ int pcpvault_addkey(vault_t *vault, void *item, uint8_t type) { size_t itemsize; void *saveitem = NULL; - void *blob = NULL; + Buffer *blob = NULL; if(type == PCP_KEY_TYPE_PUBLIC) { itemsize = PCP_RAW_PUBKEYSIZE; @@ -168,12 +168,8 @@ int pcpvault_addkey(vault_t *vault, void *item, uint8_t type) { else if(type == PCP_KEYSIG_NATIVE || type == PCP_KEYSIG_NATIVE) { pcp_keysig_t *sk = (pcp_keysig_t *)item; - Buffer *b = pcp_keysig2blob(sk); - itemsize = buffer_size(b); - blob = ucmalloc(itemsize); - - memcpy(blob, buffer_get(b), buffer_size(b)); - buffer_free(b); + blob = pcp_keysig2blob(sk); + itemsize = buffer_size(blob); saveitem = (void *)sk; } @@ -189,7 +185,7 @@ int pcpvault_addkey(vault_t *vault, void *item, uint8_t type) { if(tmp != NULL) { if(pcpvault_copy(vault, tmp) != 0) goto errak1; - if(pcpvault_additem(tmp, blob, itemsize, type) != 0) + if(pcpvault_additem(tmp, buffer_get(blob), itemsize, type) != 0) goto errak1; pcphash_add(saveitem, type); @@ -202,13 +198,13 @@ int pcpvault_addkey(vault_t *vault, void *item, uint8_t type) { fprintf(stderr, "Keeping tmp vault %s\n", tmp->filename); goto errak1; } - free(blob); + buffer_free(blob); free(tmp); return 0; } errak1: - free(blob); + buffer_free(blob); if(tmp != NULL) { free(tmp); @@ -218,28 +214,34 @@ int pcpvault_addkey(vault_t *vault, void *item, uint8_t type) { int pcpvault_writeall(vault_t *vault) { vault_t *tmp = pcpvault_new(vault->filename, 1); - void *blob_s = ucmalloc(PCP_RAW_KEYSIZE); - void *blob_p = ucmalloc(PCP_RAW_PUBKEYSIZE); if(tmp != NULL) { if(pcpvault_create(tmp) == 0) { pcp_key_t *k = NULL; + Buffer *blob = buffer_new(PCP_RAW_PUBKEYSIZE, "bs"); pcphash_iterate(k) { - pcp_seckeyblob(blob_s, k); - if(pcpvault_additem(tmp, blob_s, PCP_RAW_KEYSIZE, PCP_KEY_TYPE_SECRET) != 0) + pcp_seckeyblob(blob, k); + if(pcpvault_additem(tmp, buffer_get(blob), PCP_RAW_KEYSIZE, PCP_KEY_TYPE_SECRET) != 0) { + buffer_free(blob); goto errwa; + } + buffer_clear(blob); } pcp_pubkey_t *p = NULL; pcphash_iteratepub(p) { - pcp_pubkeyblob(blob_p, p); - if(pcpvault_additem(tmp, blob_p, PCP_RAW_PUBKEYSIZE, PCP_KEY_TYPE_PUBLIC) != 0) + pcp_pubkeyblob(blob, p); + if(pcpvault_additem(tmp, buffer_get(blob), PCP_RAW_PUBKEYSIZE, PCP_KEY_TYPE_PUBLIC) != 0) { + buffer_free(blob); goto errwa; + } + buffer_clear(blob); } pcpvault_update_checksum(tmp); if(pcpvault_copy(tmp, vault) == 0) { pcpvault_unlink(tmp); } free(tmp); + buffer_clear(blob); return 0; } } @@ -271,6 +273,10 @@ void pcpvault_update_checksum(vault_t *vault) { } byte *pcpvault_create_checksum() { + pcp_key_t *k = NULL; + Buffer *blob = NULL; + size_t datapos = 0; + int numskeys = pcphash_count(); int numpkeys = pcphash_countpub(); @@ -278,15 +284,12 @@ byte *pcpvault_create_checksum() { ((PCP_RAW_PUBKEYSIZE) * numpkeys); byte *data = ucmalloc(datasize); byte *checksum = ucmalloc(32); - size_t datapos = 0; - pcp_key_t *k = NULL; - void *blob = NULL; pcphash_iterate(k) { key2be(k); blob = pcp_keyblob(k, PCP_KEY_TYPE_SECRET); - memcpy(&data[datapos], blob, PCP_RAW_KEYSIZE); - ucfree(blob, PCP_RAW_KEYSIZE); + memcpy(&data[datapos], buffer_get(blob), PCP_RAW_KEYSIZE); + buffer_clear(blob); key2native(k); datapos += PCP_RAW_KEYSIZE; } @@ -296,12 +299,14 @@ byte *pcpvault_create_checksum() { /* pcp_dumppubkey(p); */ pubkey2be(p); blob = pcp_keyblob(p, PCP_KEY_TYPE_PUBLIC); - memcpy(&data[datapos], blob, PCP_RAW_PUBKEYSIZE); - ucfree(blob, PCP_RAW_PUBKEYSIZE); + memcpy(&data[datapos], buffer_get(blob), PCP_RAW_PUBKEYSIZE); + buffer_clear(blob); pubkey2native(p); datapos += PCP_RAW_PUBKEYSIZE; } + buffer_free(blob); + /* printf("PUB: %d, SEC: %d\n", PCP_RAW_PUBKEYSIZE, PCP_RAW_KEYSIZE); printf("DATA (%d) (s: %d, p: %d):\n", (int)datasize, numskeys, numpkeys);