scip/pcp
1
0
Fork 0
mirror of https://codeberg.org/scip/pcp.git synced 2025-12-17 12:00:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

using Buffer instead of void for key2blob storage directly

Browse Source
This commit is contained in:
TLINDEN
2014-03-17 18:04:26 +01:00
parent b3851f62e8
commit 322a135ee3
3 changed files with 43 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
include/pcp/key.h
View File

@@ -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.

29
libpcp/key.c
View File

@@ -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;
}

51
libpcp/vault.c
View File

@@ -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);