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