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

(back) ported win32 32bit compatibility along with lots of fixes

Browse Source
This commit is contained in:
scip
2014-03-15 17:26:42 +01:00
parent 080456219a
commit a1cfe16c3c
19 changed files with 135 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
libpcp/buffer.c Normal file → Executable file
View File

@@ -265,10 +265,10 @@ void buffer_dump(const Buffer *b) {
void buffer_info(const Buffer *b) {
fprintf(stderr, " buffer: %s\n", b->name);
fprintf(stderr, "blocksize: %ld\n", b->blocksize);
fprintf(stderr, " size: %ld\n", b->size);
fprintf(stderr, " offset: %ld\n", b->offset);
fprintf(stderr, " end: %ld\n", b->end);
fprintf(stderr, "blocksize: %"FMT_SIZE_T"\n", (SIZE_T_CAST)b->blocksize);
fprintf(stderr, " size: %"FMT_SIZE_T"\n", (SIZE_T_CAST)b->size);
fprintf(stderr, " offset: %"FMT_SIZE_T"\n", (SIZE_T_CAST)b->offset);
fprintf(stderr, " end: %"FMT_SIZE_T"\n", (SIZE_T_CAST)b->end);
fprintf(stderr, "allocated: %d\n\n", b->allocated);
}
@@ -329,7 +329,7 @@ size_t buffer_fd_read(Buffer *b, FILE *in, size_t len) {
size_t s = fread(data, 1, len, in);
if(s < len) {
fatal("[buffer %s] attempt to read %ld bytes from FILE, but got %ld bytes only\n", b->name, len, s);
fatal("[buffer %s] attempt to read %"FMT_SIZE_T" bytes from FILE, but got %"FMT_SIZE_T" bytes only\n", b->name, (SIZE_T_CAST)len, (SIZE_T_CAST)s);
return 0;
}

48
libpcp/key.c Normal file → Executable file
View File

@@ -301,11 +301,55 @@ pcp_pubkey_t *pubkey2native(pcp_pubkey_t *k) {
}
void pcp_seckeyblob(void *blob, pcp_key_t *k) {
memcpy(blob, k, PCP_RAW_KEYSIZE);
//memcpy(blob, k, PCP_RAW_KEYSIZE);
Buffer *b = buffer_new(PCP_RAW_KEYSIZE, "bs");
buffer_add(b, k->masterpub, 32);
buffer_add(b, k->mastersecret, 64);
buffer_add(b, k->pub, 32);
buffer_add(b, k->secret, 32);
buffer_add(b, k->edpub, 32);
buffer_add(b, k->edsecret, 64);
buffer_add(b, k->nonce, 24);
buffer_add(b, k->encrypted, 176);
buffer_add(b, k->owner, 255);
buffer_add(b, k->mail, 255);
buffer_add(b, k->id, 17);
buffer_add8(b, k->type);
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) {
memcpy(blob, k, PCP_RAW_PUBKEYSIZE);
Buffer *b = buffer_new(PCP_RAW_PUBKEYSIZE, "bp");
buffer_add(b, k->masterpub, 32);
buffer_add(b, k->sigpub, 32);
buffer_add(b, k->pub, 32);
buffer_add(b, k->edpub, 32);
buffer_add(b, k->owner, 255);
buffer_add(b, k->mail, 255);
buffer_add(b, k->id, 17);
buffer_add8(b, k->type);
buffer_add64(b, k->ctime);
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) {

0
libpcp/mgmt.c Normal file → Executable file
View File

2
libpcp/util.c Normal file → Executable file
View File

@@ -61,7 +61,7 @@ void _xorbuf(byte *iv, byte *buf, size_t xlen) {
/* print some binary data to stderr */
void _dump(char *n, byte *d, size_t s) {
int l = strlen(n) + 9;
fprintf(stderr, "%s (%04ld): ", n, s);
fprintf(stderr, "%s (%04"FMT_SIZE_T"): ", n, (SIZE_T_CAST)s);
size_t i;
int c;
for (i=0; i<s; ++i) {

18
libpcp/vault.c Normal file → Executable file
View File

@@ -281,9 +281,12 @@ byte *pcpvault_create_checksum() {
size_t datapos = 0;
pcp_key_t *k = NULL;
void *blob = NULL;
pcphash_iterate(k) {
key2be(k);
memcpy(&data[datapos], k, PCP_RAW_KEYSIZE);
blob = pcp_keyblob(k, PCP_KEY_TYPE_SECRET);
memcpy(&data[datapos], blob, PCP_RAW_KEYSIZE);
ucfree(blob, PCP_RAW_KEYSIZE);
key2native(k);
datapos += PCP_RAW_KEYSIZE;
}
@@ -292,15 +295,17 @@ byte *pcpvault_create_checksum() {
pcphash_iteratepub(p) {
/* pcp_dumppubkey(p); */
pubkey2be(p);
memcpy(&data[datapos], p, PCP_RAW_PUBKEYSIZE);
blob = pcp_keyblob(p, PCP_KEY_TYPE_PUBLIC);
memcpy(&data[datapos], blob, PCP_RAW_PUBKEYSIZE);
ucfree(blob, PCP_RAW_PUBKEYSIZE);
pubkey2native(p);
datapos += PCP_RAW_PUBKEYSIZE;
}
/* scip
/*
printf("PUB: %d, SEC: %d\n", PCP_RAW_PUBKEYSIZE, PCP_RAW_KEYSIZE);
printf("DATA (%d) (s: %d, p: %d):\n", (int)datasize, numskeys, numpkeys);
pcpprint_bin(stdout, data, datasize); printf("\n");
_dump("data", data, datasize);
*/
crypto_hash_sha256(checksum, data, datasize);
@@ -496,9 +501,10 @@ int pcpvault_fetchall(vault_t *vault) {
byte *checksum = NULL;
checksum = pcpvault_create_checksum(vault);
/*
printf(" calc checksum: "); pcpprint_bin(stdout, checksum, 32); printf("\n");
printf("vault checksum: "); pcpprint_bin(stdout, vault->checksum, 32); printf("\n");
_dump(" calc checksum", checksum, 32);
_dump("vault checksum", vault->checksum, 32);
*/
if(pcphash_count() + pcphash_countpub() > 0) {