From 5e8324bb0b6ae7ece08c412b2ef290b13005c7b6 Mon Sep 17 00:00:00 2001 From: TLINDEN Date: Mon, 18 Nov 2013 17:38:03 +0100 Subject: [PATCH] fixed yet another endianess problem, now always using the raw key values for export, sotrage and checksum calculation --- TODO | 3 +- include/pcp/defines.h | 14 +++++----- include/pcp/key.h | 15 +++++++--- include/pcp/vault.h | 2 +- libpcp/key.c | 45 ++++++++++++++++++++++++++---- libpcp/vault.c | 63 ++++++++++++++++++++++++++++-------------- man/pcp1.1 | 2 +- src/keymgmt.c | 19 +++++++------ src/keyprint.c | 30 ++++++++++++++------ tests/bart.pub | 51 +++++++++++++++++----------------- tests/gentestkeys.sh | 7 +++-- tests/key-alicia-pub | 53 +++++++++++++++++------------------ tests/key-alicia-sec | 39 +++++++++++++------------- tests/key-bobby-pub | 49 ++++++++++++++++---------------- tests/key-bobby-sec | 39 +++++++++++++------------- tests/keys.cfg | 8 +++--- tests/unknown1 | 23 ++++++++------- tests/unknown2 | 31 ++++++++++----------- tests/unknown3 | Bin 40 -> 40 bytes tests/unknown4 | 4 +-- tests/unknown5 | 4 +-- 21 files changed, 287 insertions(+), 214 deletions(-) diff --git a/TODO b/TODO index 139597f..9f93cb5 100644 --- a/TODO +++ b/TODO @@ -1,2 +1,3 @@ - +- key exports without hash handle (like I do in the vault), + checksum the same: without the handle as well. diff --git a/include/pcp/defines.h b/include/pcp/defines.h index 5d9475a..4644f31 100644 --- a/include/pcp/defines.h +++ b/include/pcp/defines.h @@ -45,12 +45,12 @@ typedef unsigned int qbyte; // Quad byte = 32 bits #define PCP_ME "Pretty Curved Privacy" -#define PCP_KEY_VERSION 0x00000003U +#define PCP_KEY_VERSION 4 #define PCP_KEY_PRIMITIVE "CURVE25519-ED25519-SALSA20-POLY1305" -#define PCP_KEY_TYPE_MAINSECRET 0x01 -#define PCP_KEY_TYPE_SECRET 0x02 -#define PCP_KEY_TYPE_PUBLIC 0x03 +#define PCP_KEY_TYPE_MAINSECRET 1 +#define PCP_KEY_TYPE_SECRET 2 +#define PCP_KEY_TYPE_PUBLIC 3 // how many times do we hash a passphrase #define HCYCLES 128000 @@ -59,11 +59,11 @@ typedef unsigned int qbyte; // Quad byte = 32 bits #define PCP_ENCRYPT_PAD crypto_secretbox_ZEROBYTES + crypto_secretbox_NONCEBYTES // vault id -#define PCP_VAULT_ID 0xC4 -#define PCP_VAULT_VERSION 0x02 +#define PCP_VAULT_ID 14 +#define PCP_VAULT_VERSION 2 // sigs -#define PCP_SIG_VERSION 0x01 +#define PCP_SIG_VERSION 1 char *PCP_ERR; byte PCP_ERRSET; diff --git a/include/pcp/key.h b/include/pcp/key.h index ad66890..0846e9d 100644 --- a/include/pcp/key.h +++ b/include/pcp/key.h @@ -87,10 +87,10 @@ struct _pcp_key_t { char owner[255]; char mail[255]; char id[17]; - long ctime; - uint32_t version; - uint32_t serial; uint8_t type; + uint64_t ctime; // 8 + uint32_t version; // 4 + uint32_t serial; // 4 UT_hash_handle hh; }; @@ -100,7 +100,7 @@ struct _pcp_pubkey_t { char owner[255]; char mail[255]; char id[17]; - long ctime; + uint64_t ctime; uint32_t version; uint32_t serial; uint8_t type; @@ -110,6 +110,9 @@ struct _pcp_pubkey_t { typedef struct _pcp_key_t pcp_key_t; typedef struct _pcp_pubkey_t pcp_pubkey_t; +#define PCP_RAW_KEYSIZE sizeof(pcp_key_t) - sizeof(UT_hash_handle) +#define PCP_RAW_PUBKEYSIZE sizeof(pcp_pubkey_t) - sizeof(UT_hash_handle) + void pcp_cleanhashes(); pcp_key_t *pcpkey_new (); @@ -156,6 +159,10 @@ unsigned char *pcp_derivekey(char *passphrase); pcp_key_t *pcp_derive_pcpkey (pcp_key_t *ours, char *theirs); +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 + #ifdef __cplusplus } #endif diff --git a/include/pcp/vault.h b/include/pcp/vault.h index bfc234e..3b07334 100644 --- a/include/pcp/vault.h +++ b/include/pcp/vault.h @@ -69,7 +69,7 @@ vault_t *pcpvault_init(char *filename); vault_t *pcpvault_new(char *filename, int is_tmp); int pcpvault_create(vault_t *vault); int pcpvault_additem(vault_t *vault, void *item, size_t itemsize, uint8_t type, uint8_t do_hash); -int pcpvault_addkey(vault_t *vault, void *item, size_t itemsize, uint8_t type); +int pcpvault_addkey(vault_t *vault, void *item, uint8_t type); int pcpvault_close(vault_t *vault); int pcpvault_fetchall(vault_t *vault); int pcpvault_writeall(vault_t *vault); diff --git a/libpcp/key.c b/libpcp/key.c index b653e11..8cfc836 100644 --- a/libpcp/key.c +++ b/libpcp/key.c @@ -227,9 +227,13 @@ unsigned char *pcpkey_getchecksum(pcp_key_t *k) { pcp_key_t * key2be(pcp_key_t *k) { - k->version = htobe32(k->version); - k->serial = htobe32(k->serial); - k->ctime = htobe64(k->ctime); + uint32_t version = k->version; + unsigned char* p = (unsigned char*)&version; + if(p[0] != 0) { + k->version = htobe32(k->version); + k->serial = htobe32(k->serial); + k->ctime = htobe64(k->ctime); + } return k; } @@ -241,9 +245,13 @@ pcp_key_t *key2native(pcp_key_t *k) { } pcp_pubkey_t * pubkey2be(pcp_pubkey_t *k) { - k->version = htobe32(k->version); - k->serial = htobe32(k->serial); - k->ctime = htobe64(k->ctime); + uint32_t version = k->version; + unsigned char* p = (unsigned char*)&version; + if(p[0] != 0) { + k->version = htobe32(k->version); + k->serial = htobe32(k->serial); + k->ctime = htobe64(k->ctime); + } return k; } @@ -301,3 +309,28 @@ pcp_key_t *pcp_derive_pcpkey (pcp_key_t *ours, char *theirs) { return NULL; } + +void pcp_seckeyblob(void *blob, pcp_key_t *k) { + memcpy(blob, k, PCP_RAW_KEYSIZE); + //printf("key (%d):\n", (int)sizeof(pcp_key_t)); + //pcpprint_bin(stdout, k, sizeof(pcp_key_t));printf("\n"); + //printf("blob (%d):\n", (int)(PCP_RAW_KEYSIZE)); + //pcpprint_bin(stdout, blob, PCP_RAW_KEYSIZE);printf("\n"); +} + +void pcp_pubkeyblob(void *blob, pcp_pubkey_t *k) { + memcpy(blob, k, PCP_RAW_PUBKEYSIZE); +} + +void *pcp_keyblob(void *k, int type) { + void *blob; + if(type == PCP_KEY_TYPE_PUBLIC) { + blob = ucmalloc(PCP_RAW_PUBKEYSIZE); + pcp_pubkeyblob(blob, (pcp_pubkey_t *)k); + } + else { + blob = ucmalloc(PCP_RAW_KEYSIZE); + pcp_seckeyblob(blob, (pcp_key_t *)k); + } + return blob; +} diff --git a/libpcp/vault.c b/libpcp/vault.c index 236a723..d10c70d 100644 --- a/libpcp/vault.c +++ b/libpcp/vault.c @@ -139,10 +139,7 @@ int pcpvault_additem(vault_t *vault, void *item, size_t itemsize, uint8_t type, void *saveitem = ucmalloc(itemsize); memcpy(saveitem, item, itemsize); - if(type == PCP_KEY_TYPE_PUBLIC) - pubkey2be((pcp_pubkey_t *)saveitem); - else - key2be((pcp_key_t *)saveitem); + fwrite(header, sizeof(vault_item_header_t), 1, vault->fd); fwrite(saveitem, itemsize, 1, vault->fd); @@ -167,12 +164,26 @@ int pcpvault_additem(vault_t *vault, void *item, size_t itemsize, uint8_t type, } -int pcpvault_addkey(vault_t *vault, void *item, size_t itemsize, uint8_t type) { +int pcpvault_addkey(vault_t *vault, void *item, uint8_t type) { vault_t *tmp = pcpvault_new(vault->filename, 1); + size_t itemsize; + + if(type == PCP_KEY_TYPE_PUBLIC) { + pubkey2be((pcp_pubkey_t *)item); + itemsize = PCP_RAW_PUBKEYSIZE; + } + else { + //pcp_dumpkey((pcp_key_t *)item); + key2be((pcp_key_t *)item); + itemsize = PCP_RAW_KEYSIZE; + } + + void *blob = pcp_keyblob(item, type); + if(tmp != NULL) { if(pcpvault_copy(vault, tmp) != 0) goto errak1; - if(pcpvault_additem(tmp, item, itemsize, type, 1) != 0) + if(pcpvault_additem(tmp, blob, itemsize, type, 1) != 0) goto errak1; pcpvault_update_checksum(tmp); if(pcpvault_copy(tmp, vault) == 0) { @@ -182,12 +193,14 @@ int pcpvault_addkey(vault_t *vault, void *item, size_t itemsize, uint8_t type) { fprintf(stderr, "Keeping tmp vault %s\n", tmp->filename); goto errak1; } + free(blob); free(tmp); return 0; } - return 1; errak1: + free(blob); + if(tmp != NULL) { free(tmp); } @@ -196,16 +209,21 @@ int pcpvault_addkey(vault_t *vault, void *item, size_t itemsize, 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; pcphash_iterate(k) { - if(pcpvault_additem(tmp, (void *)k, sizeof(pcp_key_t), PCP_KEY_TYPE_SECRET, 0) != 0) + pcp_seckeyblob(blob_s, k); + if(pcpvault_additem(tmp, blob_s, PCP_RAW_KEYSIZE, PCP_KEY_TYPE_SECRET, 0) != 0) goto errwa; } pcp_pubkey_t *p = NULL; pcphash_iteratepub(p) { - if(pcpvault_additem(tmp, (void *)p, sizeof(pcp_pubkey_t), PCP_KEY_TYPE_PUBLIC, 0) != 0) + pcp_pubkeyblob(blob_p, p); + if(pcpvault_additem(tmp, blob_p, PCP_RAW_PUBKEYSIZE, PCP_KEY_TYPE_PUBLIC, 0) != 0) goto errwa; } pcpvault_update_checksum(tmp); @@ -236,6 +254,8 @@ void pcpvault_update_checksum(vault_t *vault) { memcpy(header->checksum, checksum, 32); memcpy(vault->checksum, checksum, 32); + //printf("write checksum: "); pcpprint_bin(stdout, checksum, 32); printf("\n"); + vh2be(header); fseek(vault->fd, 0, SEEK_SET); @@ -244,13 +264,11 @@ void pcpvault_update_checksum(vault_t *vault) { } unsigned char *pcpvault_create_checksum(vault_t *vault) { - size_t skeysize = sizeof(pcp_key_t) - sizeof(UT_hash_handle); - size_t pkeysize = sizeof(pcp_pubkey_t) - sizeof(UT_hash_handle); - int numskeys = pcphash_count(); int numpkeys = pcphash_countpub(); - size_t datasize = (skeysize * numskeys) + (pkeysize * numpkeys); + size_t datasize = ((PCP_RAW_KEYSIZE) * numskeys) + + ((PCP_RAW_PUBKEYSIZE) * numpkeys); unsigned char *data = ucmalloc(datasize); unsigned char *checksum = ucmalloc(32); size_t datapos = 0; @@ -258,19 +276,22 @@ unsigned char *pcpvault_create_checksum(vault_t *vault) { pcp_key_t *k = NULL; pcphash_iterate(k) { key2be(k); - memcpy(&data[datapos], k, skeysize); + memcpy(&data[datapos], k, PCP_RAW_KEYSIZE); key2native(k); - datapos += skeysize; + datapos += PCP_RAW_KEYSIZE; } pcp_pubkey_t *p = NULL; pcphash_iteratepub(p) { pubkey2be(p); - memcpy(&data[datapos], p, pkeysize); + memcpy(&data[datapos], p, PCP_RAW_PUBKEYSIZE); pubkey2native(p); - datapos += pkeysize; + datapos += PCP_RAW_PUBKEYSIZE; } + //printf("DATA (%d) (s: %d, p: %d): ", (int)datasize, numskeys, numpkeys); + //pcpprint_bin(stdout, data, datasize); printf("\n"); + crypto_hash_sha256(checksum, data, datasize); memset(data, 0, datasize); @@ -372,7 +393,7 @@ int pcpvault_fetchall(vault_t *vault) { pcp_key_t *key; pcp_pubkey_t *pubkey; int bytesleft = 0; - int ksize = sizeof(pcp_pubkey_t); // smallest possbile item + int ksize = PCP_RAW_PUBKEYSIZE; // smallest possbile item pcphash_init(); @@ -396,15 +417,16 @@ int pcpvault_fetchall(vault_t *vault) { item->type == PCP_KEY_TYPE_SECRET) { // read a secret key key = ucmalloc(sizeof(pcp_key_t)); - fread(key, sizeof(pcp_key_t), 1, vault->fd); + fread(key, PCP_RAW_KEYSIZE, 1, vault->fd); key2native(key); //pcp_dumpkey(key); + //pcpprint_bin(stdout, key, sizeof(pcp_key_t));printf("\n"); pcphash_add((void *)key, item->type); } else if(item->type == PCP_KEY_TYPE_PUBLIC) { // read a public key pubkey = ucmalloc(sizeof(pcp_pubkey_t)); - fread(pubkey, sizeof(pcp_pubkey_t), 1, vault->fd); + fread(pubkey, PCP_RAW_PUBKEYSIZE, 1, vault->fd); pubkey2native(pubkey); pcphash_add((void *)pubkey, item->type); } @@ -437,6 +459,7 @@ int pcpvault_fetchall(vault_t *vault) { unsigned char *checksum = NULL; checksum = pcpvault_create_checksum(vault); + //printf(" calc checksum: "); pcpprint_bin(stdout, checksum, 32); printf("\n"); if(pcphash_count() + pcphash_countpub() > 0) { // only validate the checksum if there are keys if(memcmp(checksum, vault->checksum, 32) != 0) { diff --git a/man/pcp1.1 b/man/pcp1.1 index 1b7bdec..632b099 100644 --- a/man/pcp1.1 +++ b/man/pcp1.1 @@ -124,7 +124,7 @@ .\" ======================================================================== .\" .IX Title "PCP1 1" -.TH PCP1 1 "2013-11-17" "PCP 0.1.5" "USER CONTRIBUTED DOCUMENTATION" +.TH PCP1 1 "2013-11-18" "PCP 0.1.5" "USER CONTRIBUTED DOCUMENTATION" .\" For nroff, turn off justification. Always turn off hyphenation; it makes .\" way too many mistakes in technical documents. .if n .ad l diff --git a/src/keymgmt.c b/src/keymgmt.c index 7a06540..52fc746 100644 --- a/src/keymgmt.c +++ b/src/keymgmt.c @@ -52,7 +52,7 @@ int pcp_storekey (pcp_key_t *key) { key->type = PCP_KEY_TYPE_MAINSECRET; } - if(pcpvault_addkey(vault, key, sizeof(pcp_key_t), key->type) == 0) { + if(pcpvault_addkey(vault, key, key->type) == 0) { if(vault->isnew) fprintf(stderr, "new vault created, "); fprintf(stderr, "key 0x%s added to %s.\n", key->id, vault->filename); @@ -360,14 +360,15 @@ int pcp_importsecret (vault_t *vault, FILE *in) { return 1; } - if(clen != sizeof(pcp_key_t)) { + if(clen != PCP_RAW_KEYSIZE) { fatal("Error: decoded input didn't result to a proper sized key! (got %d bytes)\n", clen); free(z85decoded); return 1; } - // all good now - pcp_key_t *key = (pcp_key_t *)z85decoded; + // all good now, import the blob + pcp_key_t *key = ucmalloc(sizeof(pcp_key_t)); + memcpy(key, z85decoded, PCP_RAW_KEYSIZE); key2native(key); if(debug) @@ -385,8 +386,7 @@ int pcp_importsecret (vault_t *vault, FILE *in) { if(nkeys == 0) key->type = PCP_KEY_TYPE_MAINSECRET; - if(pcpvault_addkey(vault, (void *)key, sizeof(pcp_key_t), - PCP_KEY_TYPE_SECRET) == 0) { + if(pcpvault_addkey(vault, (void *)key, PCP_KEY_TYPE_SECRET) == 0) { fprintf(stderr, "key 0x%s added to %s.\n", key->id, vault->filename); return 0; } @@ -411,20 +411,21 @@ int pcp_importpublic (vault_t *vault, FILE *in) { return 1; } - if(clen != sizeof(pcp_pubkey_t)) { + if(clen != PCP_RAW_PUBKEYSIZE) { fatal("Error: decoded input didn't result to a proper sized key!\n", clen); free(z85decoded); return 1; } // all good now - pcp_pubkey_t *pub = (pcp_pubkey_t *)z85decoded; + pcp_pubkey_t *pub = ucmalloc(sizeof(pcp_pubkey_t)); + memcpy(pub, z85decoded, PCP_RAW_PUBKEYSIZE); pubkey2native(pub); if(debug) pcp_dumppubkey(pub); if(pcp_sanitycheck_pub(pub) == 0) { - if(pcpvault_addkey(vault, (void *)pub, sizeof(pcp_pubkey_t), PCP_KEY_TYPE_PUBLIC) == 0) { + if(pcpvault_addkey(vault, (void *)pub, PCP_KEY_TYPE_PUBLIC) == 0) { fprintf(stderr, "key 0x%s added to %s.\n", pub->id, vault->filename); return 0; } diff --git a/src/keyprint.c b/src/keyprint.c index a6e451c..b0c275a 100644 --- a/src/keyprint.c +++ b/src/keyprint.c @@ -59,13 +59,16 @@ int pcptext_infile(char *infile) { size_t clen; unsigned char *bin = pcp_z85_decode((char *)z85, &clen); free(z85); - + if(bin == NULL) { fprintf(stdout, "%s isn't properly Z85 encoded - unknown file type.\n", infile); goto errtinf1; } - if(clen == sizeof(pcp_key_t)) { + //fprintf(stdout, "have: %d, secret: %d, public: %d, sig: %d, hh: %d\n", (int)clen, + // (int)sizeof(pcp_key_t), (int)sizeof(pcp_pubkey_t), (int)sizeof(pcp_sig_t), (int)sizeof(UT_hash_handle)); + + if(clen == PCP_RAW_KEYSIZE) { // secret key? pcp_key_t *key = (pcp_key_t *)bin; key2native(key); @@ -82,7 +85,7 @@ int pcptext_infile(char *infile) { } } - if(clen == sizeof(pcp_pubkey_t)) { + if(clen == PCP_RAW_PUBKEYSIZE) { // public key? pcp_pubkey_t *key = (pcp_pubkey_t *)bin; pubkey2native(key); @@ -203,9 +206,13 @@ void pcppubkey_printlineinfo(pcp_pubkey_t *key) { void pcpkey_print(pcp_key_t *key, FILE* out) { size_t zlen; key2be(key); - char *z85encoded = pcp_z85_encode((unsigned char*)key, sizeof(pcp_key_t), &zlen); + void *blob = ucmalloc(PCP_RAW_KEYSIZE); + pcp_seckeyblob(blob, key); + char *z85encoded = pcp_z85_encode((unsigned char*)blob, PCP_RAW_KEYSIZE, &zlen); key2native(key); + free(blob); + struct tm *c; time_t t = (time_t)key->ctime; c = localtime(&t); @@ -237,9 +244,14 @@ void pcpkey_print(pcp_key_t *key, FILE* out) { void pcppubkey_print(pcp_pubkey_t *key, FILE* out) { size_t zlen; pubkey2be(key); - char *z85encoded = pcp_z85_encode((unsigned char*)key, sizeof(pcp_pubkey_t), &zlen); + + void *blob = ucmalloc(PCP_RAW_PUBKEYSIZE); + pcp_pubkeyblob(blob, key); + char *z85encoded = pcp_z85_encode((unsigned char*)blob, PCP_RAW_PUBKEYSIZE, &zlen); pubkey2native(key); + free(blob); + struct tm *c; time_t t = (time_t)key->ctime; c = localtime(&t); @@ -331,7 +343,7 @@ void pcp_dumpkey(pcp_key_t *k) { printf(" id: %s\n", k->id); - printf(" ctime: %ld\n", k->ctime); + printf(" ctime: %ld\n", (long int)k->ctime); printf(" version: 0x%08X\n", k->version); @@ -358,7 +370,7 @@ void pcp_dumppubkey(pcp_pubkey_t *k) { printf(" id: %s\n", k->id); - printf(" ctime: %ld\n", k->ctime); + printf(" ctime: %ld\n", (long int)k->ctime); printf(" version: 0x%08X\n", k->version); @@ -436,7 +448,7 @@ void pcpexport_yaml(char *outfile) { fprintf(out, " id: %s\n", s->id); fprintf(out, " owner: %s\n", s->owner); fprintf(out, " mail: %s\n", s->mail); - fprintf(out, " ctime: %ld\n", s->ctime); + fprintf(out, " ctime: %ld\n", (long int)s->ctime); fprintf(out, " version: %08x\n", s->version); fprintf(out, " serial: %08x\n", s->serial); fprintf(out, " type: %s\n", @@ -461,7 +473,7 @@ void pcpexport_yaml(char *outfile) { fprintf(out, " id: %s\n", p->id); fprintf(out, " owner: %s\n", p->owner); fprintf(out, " mail: %s\n", p->mail); - fprintf(out, " ctime: %ld\n", p->ctime); + fprintf(out, " ctime: %ld\n", (long int)p->ctime); fprintf(out, " version: %08x\n", p->version); fprintf(out, " serial: %08x\n", p->serial); fprintf(out, " type: public\n"); diff --git a/tests/bart.pub b/tests/bart.pub index 5924bfc..70c049a 100644 --- a/tests/bart.pub +++ b/tests/bart.pub @@ -3,34 +3,33 @@ Cipher: CURVE25519-ED25519-SALSA20-POLY1305 Owner: Bart Mail: bart@local - Key-ID: 0x9E10052F7813BB61 - Public-Key: 1o5w-+a:}aOe..:ie8#FXylr@Fq?C)R^LR%G)KB.b(^]B - Creation Time: 2013-11-12T19:37:58 - Checksum: 45:FE:04:C5:C0:DE:4A:87:FC:CF:4E:C0:68:26:98:75 - 7F:F0:01:EC:5D:A3:2C:5C:FD:20:36:0B:1B:2B:6C:45 - Serial Number: 0x135F07C1 - Key Version: 0x00000003 + Key-ID: 0x35FDF1A7B943B936 + Public-Key: 17f3evk3V]/UE-m.Gh?oK:5(#aXT=f=9R@>+[fE12(<@9 + Creation Time: 2013-11-18T17:31:54 + Checksum: 92:77:7B:CA:24:2D:E7:20:CB:BF:84:84:96:85:A3:8E + FB:7C:64:7A:C2:E6:D9:A9:AB:30:BD:8F:FF:59:CD:7D + Serial Number: 0x31D2B93C + Key Version: 0x00000004 Random Art ID: +----------------+ + | +o | + | ..+ | + | o + | + | . O | + | . = o | + | . . | + | . | | | - | | - | . | - | o | - | . . . o | - | + . + | - | +. o o | - | ooo. o. | +----------------+ -1o5w-+a:}aOe..:ie8#FXylr@Fq?C)R^LR%G)KB.chOo$is$DAGJT4FVwhih}B -P4&*ai]VKZ3MHcTbnG4x7za}xLXU]FKsp]U/P.SisHQTy&/aZpVM1H9MGTN5-fQROClQXduqJ}AV>vQTq0kX$vGvqC}2G.IyjQ-(r?= -2SwKiNmoFnb6kifcksGFG]+4pmHTqqnyIY@33cf4?t?<*WU^1ZoG21Q]YU:T-^fHG*{R7&)0Xd=?gGaBWyBl/p9a[2Sj)4B}gi-keO9#:JjC}.KfsN -y+FvH^THnX!7C]+nML).6V:cRtoQ-F6ILVh=lTv4Qa*5grNf@RDzwiSTJFE:yKt?:m7rcRk -9B?)^FY3W!n$(w&z7VuPF%qZQ[T:1If@{Xdya^oQ0#]oSpnOt>-&ha1Tq7%Y -BL{gvx@LM4mklFIh8mSWi59iQln*K#kl7V-08!z>H5.hN0#22D.2+[fE133UEVj$-tH^Y)3ll^ZAs({uEC[[thbg +Om6um#Rvp-x[0NBo4.*KGy.8g.NMqjlFfc!/=!h:aojAUNtnS&iH!kP{3C& +lFIncucEEfD3p]etIU2N1V@K%Aayj.XfzEdUW:sD=KyyeAHz73O-eft/AqHq}z@6qRkovDg +SnSiA[-MkBImmTdyX! unknown4 echo blah | $pcp -g -x a | egrep -v "^ " | egrep -v -- "----" | grep . > unknown5 diff --git a/tests/key-alicia-pub b/tests/key-alicia-pub index 82d56c7..a480621 100644 --- a/tests/key-alicia-pub +++ b/tests/key-alicia-pub @@ -3,34 +3,33 @@ Cipher: CURVE25519-ED25519-SALSA20-POLY1305 Owner: Alicia Mail: alicia@local - Key-ID: 0xDA48FD18B96B55BD - Public-Key: 16*v6dWb#TPCwmbq5G{(C97%x9&?O*yzq:)no4RZu&Qfb - Creation Time: 2013-11-12T19:37:58 - Checksum: 9A:2E:73:0E:72:35:A7:CA:7E:3F:F0:64:8F:ED:0B:B4 - 7B:F9:75:56:33:AC:DF:BE:FA:C2:50:43:8D:07:A3:1A - Serial Number: 0xF27F9345 - Key Version: 0x00000003 + Key-ID: 0xEF4731C1CBB47218 + Public-Key: 1b1vJ1=xrBrOB&*FL&RuW4uxNd7WTNBu5f#pKp8>&GE$#axlj -AQQzCq1P]f$?WkvfDn]0>55gdz5Ae-py6!z8^EeJEo+T0t$KX(lI#/)12kQChIO1=iSH!74 -+Se=S(AayI7FtC:9r:I:A!PqmNL.)m1O5sw]rfaOm(&L5^Q6aJk@fxWj/x]!W*&{0wW7b>K -gI)v&^O.9Gzwg$mfLm).Wi#Km+b5oPe1K(DfE*4xrb&e=Lh!e[xWkxtb-Jdc3P)c8A}[%m$ -bURwWV5-1dd!9H92X^syE=h.9a:g3s+o$?u$3n>lIP--G2[cvpJWrp8J[c9jBLP]I0wIkazl[07@ -gPWW(Fm0cySbtv7{CZ[tZ?EJhxVH)zn/yoiFybarlK^@A0GCCP2+.F%9W+(*9N{!zr7nL)? -8)q^FNJp35[H9059.hOwKWH#4Dl*aog}$sh#eTx{$Cp0x5lB!J -!0Qgiz=7yr]R-0o)Kn-vVXNVFv*/lLPnq:t[MMR6(9KHaJa/6y:+2j:69Z5-:gNDtqp>dBj -Hn$4yV@pTak@pLH5.hN1m*@9mfsIXzp(2mM#PwAHFqEud -if[JbPHzDp.Y&92[/)NM=[k%Y6QMUU?z.6QVisFreWC]))m.j!M@WCyOJjtR#M!$ +1b1vJ1=xrBrOB&*FL&RuW4uxNd7Wz2Mv}kdC0P}Uv}/uKoY@<}Za7[!76.xC)-7@BLT?}L2?oOKdnE5LgN>AARpm+4u6y!oee +W0txq93K]EIp$=Yx}7Qc*&J:(nvP2!?KvsJ{$vqGT/x<8awsIj!4{$G@+T*x&@rn5{p(-:mD$b.@}lb>5e9lU1kndE +b&tUP8a+}y#Ye*I4r+D&nrD ------ END PCP PUBLICKEY ------ diff --git a/tests/key-alicia-sec b/tests/key-alicia-sec index 2876c03..66a2ff4 100644 --- a/tests/key-alicia-sec +++ b/tests/key-alicia-sec @@ -1,25 +1,24 @@ ----- BEGIN PCP SECRET KEY ----- Generated by: Pretty Curved Privacy Version 0.1.5 Cipher: CURVE25519-ED25519-SALSA20-POLY1305 - Key-ID: 0xDA48FD18B96B55BD - Creation Time: 2013-11-12T19:37:58 - Serial Number: 0x0E2FB099 - Key Version: 0x00000003 + Key-ID: 0xEF4731C1CBB47218 + Creation Time: 2013-11-18T17:31:53 + Serial Number: 0x6C892F90 + Key Version: 0x00000004 -16*v6dWb#TPCwmbq5G{(C97%x9&?O*yzq:)no4RZu&Vc6GUN]4mH}eIYlJZfwxYf%NbT-b! -(jZocqnW%s3lOGV*:?f}nDe/h/aEuNH1sV?4mvF}d#n%P@r#3s]-cAz$0%=WT5Ln4xH?HTL -BpKQDV%qjt[7?IaaYK:&Aztv5o&}(g]?X7r(a*=WVorWU>/2^Lt7a=G}F++uQm(K.Xhow!Z -mTs+sGU8d@T*>KgZelYvFwy7HjSZgkq$mQ5)^TT)8hkTwv8jkn$SrMo/t3v}/uK2^)r2tq:tCDKaQz -PV(7O?3]Q$Y#Fm1>TNBu5f#pKp8>&GE$#axljAQQzCq1P]f$?WkvfDn]0>55gdz5Ae-py6! -z8^EeJEo+T0t$KX(lI#/)12kQChIO1=iSH!74+Se=S(AayI7FtC:9r:I:A!PqmNL.)m1O5s -w]rfaOm(&L5^Q6aJk@fxWj/x]!W*&{0wW7b>KgI)v&^O.9Gzwg$mfLm).Wi#Km+b5oPe1K( -DfE*4xrb&e=Lh!e[xWkxtb-Jdc3P)c8A}[%m$bURwWV5-1dd!9H92X^syE=h.9a:g3s+o$?u$3n> -lIP--G2[cvpJWrp8J[c9jBLP]I0wIkazl[07@gPWW(Fm0cySbtv7{CZ[tZ?EJhxVH)zn/yo -iFybarlK^@A0GCCP2+.F%9W+(*9N{!zr7nL)?8)q^FNJp35[H9059.hOwKWH#4Dl*aog}$sh#eTx{$Cp0x5lB!J!0Qgiz=7yr]R-0o)Kn-vVXNVFv*/lLPnq: -t[MMR6(9KHaJa/6y:+2j:69Z5-:gNDtqp>dBjHn$4yV@pTak@pLH5.hN0$D#*Ne[=HOV%d$wi^v?0seV900000000000000000000000000000000000 -0000000W{r0seV901Ybg081Bc0@@r3 +1b1vJ1=xrBrOB&*FL&RuW4uxNd7Wz2Mv}kdB]Z{$97<671ln0f77[/S.F +pS5/LHOuFnkvar/vscSSGR?AARpm+4u6y!oeeW0txq93K]EIp$=Yx}7Qc*&J:(n +vP2!?KvsJ{$vqGT/x<8awsIj!4{ +$G@+T*x&@rn5{p(-:mD$b.@}lb>5e9lU1kndEb&tUP8a+}y#Ye*I4r+D&nrD0o!PyTIxzlS+Qso5s3 - Creation Time: 2013-11-12T19:37:58 - Checksum: 6E:90:91:B6:53:EE:D8:5F:55:A1:03:33:0A:2E:28:C0 - C5:16:B2:A8:32:94:9D:BF:D7:4B:C6:D6:5A:FD:C6:22 - Serial Number: 0x1E92BBC6 - Key Version: 0x00000003 + Key-ID: 0x189D957F63A985E8 + Public-Key: 13+z>XxVw^*a&DvLYnD-0o!PyTIxzlS+QsA6K.n0m%HVHu7j8vT<7J2@fu*zah/WVQXYlU3ng.mL.+{.+.CuR -&xw&p[k/cuyl1/gU!Yu%Tk7]MsscTD-nuoyHH^3u{1!zCDU0Z9rwYN=CIkkyN/$1VIr2&$b -ZeR*4X(e{KJ6k({5UZ+R0.}qF.+-E!UYLsl^V@?+xTx7S6MKGefNF@.o8d5JHx -KGOnXq(^7J>0TYDvY5-)?/${y@ZY1Dp]zE&eyat1EuB%E>aYnQ!JF//cZ5DTJ7LA+QNFq7S -FD8p0L)b]d[^p/xxMasww*#X6>D7ae0D/j5PC59cz3+e{vSbZ+C%Dg:v{%fNmrm1sa%QYW0 -nKBL+/D-!7zVV)HleUT=Gq.LKcC1I[7QA%KWVhGP=kDm.w>%Z{Qm@b2k[qPd?zRlf0l85[4 -Q]Yi-G37dn7/#FSq3-Zyk{lilF/:g835@ItyYddItAHZ$xqSdj}3wO -R%vguX6BBZq%NeJ^V]{gl^QB1d5sk/]:tcOqpF.WyT7H5.hN10iSq-SDP:WNto?QLBJx^9mLHw -fp!WT[pLONDU{}XxVw^*a&DvLYnD-bin/qmr*4 ++6<%{A=R3/MCA)n(iRg1t{/gHxn-mutYHm(^s3JTS?>qhvSbZ+C%Dg:v{%fNQ[qOC[yv=ae +SW>Zy%T$5L!Pi6f[.Y[2[I!jq5.(szqG^[JY-fT%#WIB( +w.1U0nbxvf)(Mjks{h$!A-ou5ZONo#dgy04Sgk/}*>}GkUo1AbcOpf1O@euz+jSdGFDBPJ$ +hJg%IJs(/DCx9NEh*lXXDZpt0a7lZDWfSArOS58=3fYqSMkmZx^QaHXlWmf}0o!PyTIxzlS+Qso6oFGXi9fW818]U%/]KnF>/1couE/m -cnX{7n*z>{hDpOn0m%HVHu7j8vT<7J2@fzH6Lmn*rrMY -].!81!a5ympcd0]<4(%e/<}wWLV]wDQIZOBhxib(ILOY&&+/op]BZ[:Y)/t[TAiZYqXk*u9 -0Z=:bLyl&e=pT5C2=f7+ou*zah/WVQXYlU3ng.mL.+{.+.CuR&xw&p[k/cuyl1/gU!Yu%Tk7]MsscTD-nuo -yHH^3u{1!zCDU0Z9rwYN=CIkkyN/$1VIr2&$bZeR*4X(e{KJ6k({5UZ+R0.}qF.+-E!UYLs -l^V@?+xTx7S6MKGefNF@.o8d5JHxKGOnXq(^7J>0TYDvY5-)?/${y@ZY1Dp]zE -&eyat1EuB%E>aYnQ!JF//cZ5DTJ7LA+QNFq7SFD8p0L)b]d[^p/xxMasww*#X6>D7ae0D/j -5PC59cz3+e{vSbZ+C%Dg:v{%fNmrm1sa%QYW0nKBL+/D-!7zVV)HleUT=Gq.LKcC1I[7QA% -KWVhGP=kDm.w>%Z{Qm@b2k[qPd?zRlf0l85[4Q]Yi-G37dn7/#FSq3-Zyk{lilF/:g835@ItyYddItAHZ$xqSdj}3wOR%vguX6BBZq%NeJ^V]{gl^QB1d5sk/]:tc -OqpF.WyT7H5.hN19A2GgY)d}dGTJJVoUS:0seV9004yi0seV90000000000000000000000000 -0000000X6v0seV901Ybg03A1^4GDFe +13+z>XxVw^*a&DvLYnD-FB^UHZrAiB!GFR{C:?-VCX80b.VWj*az.C79To@yq9rqKT)0e*F@MIRy!vd!313 +AQ{}sL+w(/BQ[fOvQA?s:^1PkY{HB2*LTakWDnQj]OLGflEr5tqoz?w{K*lM?&iY9*U(bin/qmr*4+6<%{A=R3/MCA)n(iRg1t{/gHxn-mutYHm +(^s3JTS?>qhvSbZ+C%Dg:v{%fNQ[qOC[yv=aeSW>Zy%T$5L!Pi6f[.Y[2[I!jq5.(szqG^[JY-fT%#WIB(w.1U0nbxvf)(Mjks{h$!A-ou5ZONo#dgy0 +4Sgk/}*>}GkUo1AbcOpf1O@euz+jSdGFDBPJ$hJg%IJs(/DCx9NEh*lXXDZpt0a7lZDWfSA +rOS58=3fYqSMkmZx^QaHXlWmf}Qjui&pf!Vu>j{V(&ZE>1*Q-M^hu9Dnm0P10$*=SdY5BWoSOFNA-6L*6&g)mQQ$Piq -rkfQPhEPa}C7:ozddr)03{68f?xvQYTkG8w:G&k!%V<&AA.n6yMom+7L0L8w&kQ.5UB3q+h -.XelalW9GHMg1}N@*:jCfBNX]4/u@G6:&m!Etcn7s:HmXEqemv+9z+=90vC+u2=R)RCZ8fRB/tfIfUyz9(uYd]Hl:>nlqjo -[*rQzWb-ePMx0OFf2E:yjzrgp8s-jxR5Vem9]V0XB=jPGzFrW0vqYQvy&r/(yYHSL^4#x6y -mku9x+8nYkN77[zPwQBpiBOldb[0eTM5j6(EOIaJP5Y5ko1@a7N -Tg2dlit33squ>Paw/7?bc]X]FELwNQjoNq(^f2D9EA.@cb>ZP3!YENd+S??)/BQLOd<@[y/ -GZqe]EgcPo99.OZC:HrGK(e7%2Zf7DJ@zug:EUonoe<^m^[kfB3=cw!dH#)Jyq -ld>cNMMS@U6t3eZ/8H3/]G)gs]Zg85?=dJo{61L7^mk)4Tml0:]g=Wq>Bn#pv08!z>H5.hN13DV#tM-u}u**?PHXVR!p]X%Ps -z8A{S]0#EfXFd(@S3ShwuohGB*qJBQu-3xTs-#i?5!^5b//D:RLraTfL&fLFDbVI +0%mAR2+heUb3:fpeM1rSP@.1H +F%@S0sDp5*lhUp$c0}}22#cFi +zFaJ0*o=(c52n26%$2Rf5f8Q>f=AcsSmZe%P<-RVZoTrAYN^ea@J}ng>kt-gJYuNn(gG98- +M=1g.DAPT*LS&?hwpwE=fqoKmGL2Ln])Wx?fw0drgA%k$:!I{OB-^2ay%9Mta3ttLb7]ks< +bT[&*zAGPAVlf#f?zQQP:PckD{..CetX(JXmPZ@N#5^PMlm^2PzrC]e0kIP7Y{ubv1:D&hE7 +D<{xb7UQTFjD3O7IJZ9<=N5Cs6&j[=M:yaaJ).Qjui&pf!Vu>j{V(&ZE>1*Q-M^hu9Dnm0P10@$eEK:7qS5miK{n-KRCsePPz=Bg#!F -qdvF)=5jozv@a)dY5BWoSOFNA-6L*6&g)mQQ$PiqrkfQPhEPa}t:*#QNZ?gJ2eReD6*OsKO -R:467?ur3v@+>GQ]m[51!<)jJL][!U$7UU1PY6YFaeD*o3oo[a3:JY#5/adi^<-8h++uPV3 -b=S+y1sIF?SJYC*S#25HM?9*u$-(<9h.Pjue{bBKftB}2x*7KXqwU^SVxQ.B^aH=[3#)etR -7Py+d]N2!N.t}X%e%3jqAWRC)r}3F5+!ZXrrLGoZjs?#kMv[{-Hzddr)03{68f?xvQYTkG8 -w:G&k!%V<&AA.n6yMom+7L0L8w&kQ.5UB3q+h.XelalW9GHMg1}N@*:jCfBNX]4/u@G6:&m -!Etcn7s:HmXEqemv+9z+=90vC+u2=R)RCZ8fRB/tfIfUyz9(uYd]Hl:>nlqjo[*rQzWb-ePMx0OFf2E:yjzrgp8s-jxR5Ve -m9]V0XB=jPGzFrW0vqYQvy&r/(yYHSL^4#x6ymku9x+8nYkN77[ -zPwQBpiBOldb[0eTM5j6(EOIaJP5Y5ko1@a7NTg2dlit33squ>Paw/7?bc]X]FELwNQjoNq -(^f2D9EA.@cb>ZP3!YENd+S??)/BQLOd<@[y/GZqe]EgcPo99.OZC:HrGK(e7%2Zf7DJ@zu -g:EUonoe<^m^[kfB3=cw!dH#)Jyqld>cNMMS@U6t3eZ/8H3/]G)gs]Zg85?=dJ -o{61L7^mk)4Tml0:]g=Wq>uh%% -908!z>H5.hN1f{zy]A509PUR@I]GY6t0seV9004Wq0seV90000000000000000000000000 -0000000XuD0seV901Ybg0dmNa*w?iN +0%mAR2+heUb3:fpeM1rSP@.1HF%y?vkUUaxsj)K]ox!fHvf=Wz82Ls8.:-dLHXl7&HF^HMm[T*.[ZcLxCtVE*UtH +4l:Z?Vbu/fh]*eZc#Ke(a}6hoaH6X2UIWZQDFxc5TH@S0sDp5*lhUp$c0}}22#cFizFaJ0*o=(c52n26%$2Rf5f8Q>f=AcsSmZe +%P<-RVZoTrAYN^ea@J}ng>kt-gJYuNn(gG98-M=1g.DAPT*LS&?hwpwE=fqoKmGL2Ln])Wx +?fw0drgA%k$:!I{OB-^2ay%9Mta3ttLb7]ks*zAGPAVlf#f?zQQP:P +ckD{..CetX(JXmPZ@N#5^PMlm^2PzrC]e0kIP7Y{ubv1:D&hE7D<{xb7UQTFjD3O7IJZ9<=N5Cs6&j[=M:yaa +J).H5.hN0Ef9+JYdd^ILWb1E[pA0T*:ny- -06m)p=@{s7}8/-ppqwtHD36NJB-o74[cZ=Fkx@XTyJ7&sp/1oTc:Td3JHeb000000000000 +14tWoh-0fQf*!n]g=EfAh#&{U000000000008!Xt}tZG}0EvQCs3?LOfdxS+FIz3FIQ-No= +p58!l{ox)Lg]mel6-:y:{8c?gbksfO[8/r1!G5n/Akgaw>}%@v)Wg$1][S6000000000000 000000000000000000000000000000000