From 671352bc29eee6f7b48f8a8b0d6cc65f5835dad4 Mon Sep 17 00:00:00 2001 From: TLINDEN Date: Mon, 9 May 2016 22:24:13 +0200 Subject: [PATCH] unfortunately my tab/spc config was wrong for a couple of years. fixed all tabs=>spaces+re-indent --- bindings/cpp/helpers++.h | 10 +- bindings/cpp/key++.h | 6 +- bindings/cpp/key.cpp | 6 +- bindings/py/gencffi.pl | 64 ++--- include/pcp/crypto.h | 8 +- include/pcp/keyhash.h | 8 +- include/pcp/platform.h | 48 ++-- include/pcp/readpass.h | 2 +- include/pcp/structs.h | 1 + libpcp/buffer.c | 10 +- libpcp/context.c | 2 +- libpcp/crypto.c | 196 +++++++-------- libpcp/ed.c | 48 ++-- libpcp/jenhash.c | 12 +- libpcp/key.c | 10 +- libpcp/keyhash.c | 2 +- libpcp/keysig.c | 2 +- libpcp/mem.c | 2 +- libpcp/mgmt.c | 60 ++--- libpcp/pcpstream.c | 164 ++++++------- libpcp/platform.c | 12 +- libpcp/readpass.c | 210 ++++++++-------- libpcp/scrypt.c | 6 +- libpcp/util.c | 4 +- libpcp/vault.c | 148 +++++------ libpcp/z85.c | 76 +++--- src/encryption.c | 112 ++++----- src/keymgmt.c | 202 +++++++-------- src/keyprint.c | 86 +++---- src/pcp.c | 515 +++++++++++++++++++-------------------- src/signature.c | 4 +- tests/cpptest.cpp | 4 +- tests/decodertest.c | 18 +- tests/unittests.cfg | 4 +- 34 files changed, 1031 insertions(+), 1031 deletions(-) diff --git a/bindings/cpp/helpers++.h b/bindings/cpp/helpers++.h index 06eca56..3e72745 100644 --- a/bindings/cpp/helpers++.h +++ b/bindings/cpp/helpers++.h @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -41,12 +41,12 @@ namespace pcp { std::string msg; PCPCTX *ptx = P->ptx; if(ptx->pcp_errset == 1) { - msg = ptx->pcp_err; + msg = ptx->pcp_err; } if(errno) { - msg += std::string("\nError: ") - + std::string(strerror(errno)) - + std::string("\n"); + msg += std::string("\nError: ") + + std::string(strerror(errno)) + + std::string("\n"); } return msg; } diff --git a/bindings/cpp/key++.h b/bindings/cpp/key++.h index 9d11d9d..2dd5a44 100644 --- a/bindings/cpp/key++.h +++ b/bindings/cpp/key++.h @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -83,8 +83,8 @@ namespace pcp { Key(PcpContext *P, bool generate); Key(PcpContext *P, const std::string& passphrase); Key(PcpContext *P, const std::string& passphrase, - const std::string& owner, - const std::string& mail); + const std::string& owner, + const std::string& mail); Key(PcpContext *P, pcp_key_t *k); Key(PcpContext *P, pcp_key_t *k, bool store); Key(PcpContext *P, std::string &z85encoded, std::string& passphrase); diff --git a/bindings/cpp/key.cpp b/bindings/cpp/key.cpp index f4a2c75..49f7e50 100644 --- a/bindings/cpp/key.cpp +++ b/bindings/cpp/key.cpp @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -53,8 +53,8 @@ Key::Key(PcpContext *P, const string& passphrase) { } Key::Key(PcpContext *P, const string& passphrase, - const string& owner, - const string& mail) { + const string& owner, + const string& mail) { stored = false; pcp_key_t *_K = pcpkey_new(); K = pcpkey_encrypt(P->ptx, _K, (char *)passphrase.c_str()); diff --git a/bindings/py/gencffi.pl b/bindings/py/gencffi.pl index 422b54f..9995807 100755 --- a/bindings/py/gencffi.pl +++ b/bindings/py/gencffi.pl @@ -2,28 +2,28 @@ use Data::Dumper; my %sobytes = ( - 'crypto_box_NONCEBYTES' => 24, - 'crypto_box_PUBLICKEYBYTES' => 32, - 'crypto_box_SECRETKEYBYTES' => 32, - 'crypto_box_ZEROBYTES' => 32, - 'crypto_box_BOXZEROBYTES' => 16, - 'crypto_box_MACBYTES' => 16, - 'crypto_secretbox_KEYBYTES' => 32, - 'crypto_secretbox_NONCEBYTES' => 24, - 'crypto_secretbox_ZEROBYTES' => 32, - 'crypto_secretbox_BOXZEROBYTES' => 16, - 'crypto_secretbox_MACBYTES' => 16, - 'crypto_sign_PUBLICKEYBYTES' => 32, - 'crypto_sign_SECRETKEYBYTES' => 64, - 'crypto_sign_SEEDBYTES' => 32, - 'crypto_sign_BYTES' => 64, - 'crypto_stream_KEYBYTES' => 32, - 'crypto_stream_NONCEBYTES' => 24, - 'crypto_generichash_BYTES' => 32, - 'crypto_scalarmult_curve25519_BYTES' => 32, - 'crypto_scalarmult_BYTES' => 32, - 'crypto_generichash_BYTES_MAX' => 64, - ); + 'crypto_box_NONCEBYTES' => 24, + 'crypto_box_PUBLICKEYBYTES' => 32, + 'crypto_box_SECRETKEYBYTES' => 32, + 'crypto_box_ZEROBYTES' => 32, + 'crypto_box_BOXZEROBYTES' => 16, + 'crypto_box_MACBYTES' => 16, + 'crypto_secretbox_KEYBYTES' => 32, + 'crypto_secretbox_NONCEBYTES' => 24, + 'crypto_secretbox_ZEROBYTES' => 32, + 'crypto_secretbox_BOXZEROBYTES' => 16, + 'crypto_secretbox_MACBYTES' => 16, + 'crypto_sign_PUBLICKEYBYTES' => 32, + 'crypto_sign_SECRETKEYBYTES' => 64, + 'crypto_sign_SEEDBYTES' => 32, + 'crypto_sign_BYTES' => 64, + 'crypto_stream_KEYBYTES' => 32, + 'crypto_stream_NONCEBYTES' => 24, + 'crypto_generichash_BYTES' => 32, + 'crypto_scalarmult_curve25519_BYTES' => 32, + 'crypto_scalarmult_BYTES' => 32, + 'crypto_generichash_BYTES_MAX' => 64, + ); my @ignore = qw(uthash.h); @@ -87,19 +87,19 @@ foreach my $head (@ARGV) { print "PCP_RAW_CODE = '''\n"; print qq( typedef enum { - JSON_OBJECT, - JSON_ARRAY, - JSON_STRING, - JSON_INTEGER, - JSON_REAL, - JSON_TRUE, - JSON_FALSE, - JSON_NULL +JSON_OBJECT, +JSON_ARRAY, +JSON_STRING, +JSON_INTEGER, +JSON_REAL, +JSON_TRUE, +JSON_FALSE, +JSON_NULL } json_type; typedef struct json_t { - json_type type; - size_t refcount; +json_type type; +size_t refcount; } json_t; ); print join "\n", @typedefs; diff --git a/include/pcp/crypto.h b/include/pcp/crypto.h index ba0ec4e..b79ebd2 100644 --- a/include/pcp/crypto.h +++ b/include/pcp/crypto.h @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2015 T.Linden. + Copyright (C) 2013-2016 T.Linden. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -141,7 +141,7 @@ */ byte *pcp_box_encrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, byte *message, size_t messagesize, - size_t *csize); + size_t *csize); /** Asymmetrically decrypt a message. @@ -167,7 +167,7 @@ byte *pcp_box_encrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, */ byte *pcp_box_decrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, byte *cipher, size_t ciphersize, - size_t *dsize); + size_t *dsize); /** Asymmetrically encrypt a file or a buffer stream. @@ -196,7 +196,7 @@ byte *pcp_box_decrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, \return Returns the size of the output written to the output stream or 0 in case of errors. */ size_t pcp_encrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, pcp_key_t *s, - pcp_key_t *ss, pcp_pubkey_t *p, int signcrypt, int anon); + pcp_key_t *ss, pcp_pubkey_t *p, int signcrypt, int anon); /** Symmetrically encrypt a file or a buffer stream. diff --git a/include/pcp/keyhash.h b/include/pcp/keyhash.h index 53097ef..c3c73b3 100644 --- a/include/pcp/keyhash.h +++ b/include/pcp/keyhash.h @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2015 T.Linden. + Copyright (C) 2013-2016 T.Linden. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -54,7 +54,7 @@ Also, don't free() the keyhash or the temporary key pointer yourself. Use pcphash_clean() instead when done. */ -#define pcphash_iterate(ptx, key) \ +#define pcphash_iterate(ptx, key) \ pcp_key_t *__k = NULL; \ HASH_ITER(hh, ptx->pcpkey_hash, key, __k) @@ -73,7 +73,7 @@ Also, don't free() the keyhash or the temporary key pointer yourself. Use pcphash_clean() instead when done. */ -#define pcphash_iteratepub(ptx, key) \ +#define pcphash_iteratepub(ptx, key) \ pcp_pubkey_t *__p = NULL; \ HASH_ITER(hh, ptx->pcppubkey_hash, key, __p) @@ -142,7 +142,7 @@ int pcphash_countpub(PCPCTX *ptx); -#define pcphash_iteratekeysig(ptx, key) \ +#define pcphash_iteratekeysig(ptx, key) \ pcp_keysig_t *__s = NULL; \ HASH_ITER(hh, ptx->pcpkeysig_hash, key, __s) diff --git a/include/pcp/platform.h b/include/pcp/platform.h index 2c84264..bba945e 100644 --- a/include/pcp/platform.h +++ b/include/pcp/platform.h @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -39,24 +39,24 @@ # endif # else /* no sys/endian.h */ # ifdef __CPU_IS_BIG_ENDIAN -# define be16toh(x) (x) -# define htobe16(x) (x) -# define be32toh(x) (x) -# define htobe32(x) (x) -# define be64toh(x) (x) -# define htobe64(x) (x) +# define be16toh(x) (x) +# define htobe16(x) (x) +# define be32toh(x) (x) +# define htobe32(x) (x) +# define be64toh(x) (x) +# define htobe64(x) (x) # elif defined(__APPLE__) /* from https://gist.github.com/panzi/6856583 */ -# include -# define htobe16(x) OSSwapHostToBigInt16(x) -# define be16toh(x) OSSwapBigToHostInt16(x) -# define htobe32(x) OSSwapHostToBigInt32(x) -# define be32toh(x) OSSwapBigToHostInt32(x) -# define htobe64(x) OSSwapHostToBigInt64(x) -# define be64toh(x) OSSwapBigToHostInt64(x) -# define __BYTE_ORDER BYTE_ORDER -# define __BIG_ENDIAN BIG_ENDIAN -# define __LITTLE_ENDIAN LITTLE_ENDIAN -# define __PDP_ENDIAN PDP_ENDIAN +# include +# define htobe16(x) OSSwapHostToBigInt16(x) +# define be16toh(x) OSSwapBigToHostInt16(x) +# define htobe32(x) OSSwapHostToBigInt32(x) +# define be32toh(x) OSSwapBigToHostInt32(x) +# define htobe64(x) OSSwapHostToBigInt64(x) +# define be64toh(x) OSSwapBigToHostInt64(x) +# define __BYTE_ORDER BYTE_ORDER +# define __BIG_ENDIAN BIG_ENDIAN +# define __LITTLE_ENDIAN LITTLE_ENDIAN +# define __PDP_ENDIAN PDP_ENDIAN # else # ifdef HAVE_ARPA_INET_H # include @@ -67,12 +67,12 @@ # error Need either netinet/in.h or arpa/inet.h for ntohl() and htonl() # endif # endif -# define be16toh(x) ((uint16_t)ntohl((uint16_t)(x))) -# define htobe16(x) ((uint16_t)htonl((uint16_t)(x))) -# define be32toh(x) ((uint32_t)ntohl((uint32_t)(x))) -# define htobe32(x) ((uint32_t)htonl((uint32_t)(x))) -# define be64toh(x) ((uint64_t)ntohl((uint64_t)(x))) -# define htobe64(x) ((uint64_t)htonl((uint64_t)(x))) +# define be16toh(x) ((uint16_t)ntohl((uint16_t)(x))) +# define htobe16(x) ((uint16_t)htonl((uint16_t)(x))) +# define be32toh(x) ((uint32_t)ntohl((uint32_t)(x))) +# define htobe32(x) ((uint32_t)htonl((uint32_t)(x))) +# define be64toh(x) ((uint64_t)ntohl((uint64_t)(x))) +# define htobe64(x) ((uint64_t)htonl((uint64_t)(x))) # endif # endif /* HAVE_SYS_ENDIAN_H */ #endif /* HAVE_ENDIAN_H */ diff --git a/include/pcp/readpass.h b/include/pcp/readpass.h index b0714cb..9085011 100644 --- a/include/pcp/readpass.h +++ b/include/pcp/readpass.h @@ -58,7 +58,7 @@ * getpass / readpass / readpassphrase / etc. functions in various libraries. */ int pcp_readpass(PCPCTX *ptx, char **passwd, const char *prompt, - const char *confirmprompt, int devtty, char *readfromfile); + const char *confirmprompt, int devtty, char *readfromfile); /** from encfs getUserKey(). diff --git a/include/pcp/structs.h b/include/pcp/structs.h index f3b5286..fec91e6 100644 --- a/include/pcp/structs.h +++ b/include/pcp/structs.h @@ -311,6 +311,7 @@ struct _pcp_stream_t { Buffer *cache; /**< The caching Buffer object (for look ahead read) */ Buffer *next; /**< The caching Next-Buffer object (for look ahead read) */ Buffer *save; /**< Temporary buffer to backup overflow data */ + byte *xb; /**< Temporary byte buffer for reading/writing data */ uint8_t is_buffer; /**< Set to 1 if the backend is a Buffer */ uint8_t eof; /**< Set to 1 if EOF reached */ uint8_t err; /**< Set to 1 if an error occured */ diff --git a/libpcp/buffer.c b/libpcp/buffer.c index 0d1c0ad..933bba6 100644 --- a/libpcp/buffer.c +++ b/libpcp/buffer.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -62,7 +62,7 @@ void buffer_free(Buffer *b) { if(b->allocated == 1) { /* free the underlying data pointer only if we allocated it */ if(b->end > 0) { - buffer_clear(b); + buffer_clear(b); } free(b->buf); b->allocated = 0; @@ -132,7 +132,7 @@ byte *buffer_get(Buffer *b) { size_t buffer_get_chunk(Buffer *b, void *buf, size_t len) { if(len > b->end - b->offset) { final("[buffer %s] attempt to read %ld bytes data from buffer with %ld bytes left at offset %ld\n", - b->name, len, b->end - b->offset, b->offset); + b->name, len, b->end - b->offset, b->offset); } else if(len == 0) { /* FIXME: check how this happens */ @@ -148,7 +148,7 @@ size_t buffer_get_chunk(Buffer *b, void *buf, size_t len) { size_t buffer_fwd_offset(Buffer *b, size_t fwdby) { if(fwdby > b->end - b->offset) { final("[buffer %s] attempt to set offset %ld bytes forward data from buffer with %ld bytes left at offset %ld\n", - b->name, fwdby, b->end - b->offset, b->offset); + b->name, fwdby, b->end - b->offset, b->offset); } else if(fwdby == 0) { return 0; @@ -161,7 +161,7 @@ size_t buffer_fwd_offset(Buffer *b, size_t fwdby) { size_t buffer_get_chunk_tobuf(Buffer *b, Buffer *dst, size_t len) { if(len > b->end - b->offset) { final("[buffer %s] attempt to read %ld bytes data from buffer with %ld bytes left at offset %ld\n", - b->name, len, b->end - b->offset, b->offset); + b->name, len, b->end - b->offset, b->offset); } else if(len == 0) { /* FIXME: check how this happens */ diff --git a/libpcp/context.c b/libpcp/context.c index f9778a2..e05079e 100644 --- a/libpcp/context.c +++ b/libpcp/context.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/libpcp/crypto.c b/libpcp/crypto.c index 8aacf90..d28aa69 100644 --- a/libpcp/crypto.c +++ b/libpcp/crypto.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -27,8 +27,8 @@ /* asym encr */ byte *pcp_box_encrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, - byte *message, size_t messagesize, - size_t *csize) { + byte *message, size_t messagesize, + size_t *csize) { byte *nonce = pcp_gennonce(); @@ -66,8 +66,8 @@ byte *pcp_box_encrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, /* asym decr */ byte *pcp_box_decrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, - byte *cipher, size_t ciphersize, - size_t *dsize) { + byte *cipher, size_t ciphersize, + size_t *dsize) { byte *message = NULL; @@ -76,11 +76,11 @@ byte *pcp_box_decrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, memcpy(nonce, cipher, LNONCE); memcpy(cipheronly, &cipher[LNONCE], - ciphersize - LNONCE); + ciphersize - LNONCE); message = ucmalloc(ciphersize - LNONCE - crypto_box_MACBYTES); if(crypto_box_open_easy(message, cipheronly, ciphersize - LNONCE, - nonce, pub->pub, secret->secret) != 0) { + nonce, pub->pub, secret->secret) != 0) { fatal(ptx, "failed to decrypt message!\n"); goto errbed; } @@ -104,10 +104,10 @@ byte *pcp_box_decrypt(PCPCTX *ptx, pcp_key_t *secret, pcp_pubkey_t *pub, /* sym encr */ size_t pcp_sodium_mac(byte **cipher, - byte *cleartext, - size_t clearsize, - byte *nonce, - byte *key) { + byte *cleartext, + size_t clearsize, + byte *nonce, + byte *key) { *cipher = ucmalloc(clearsize + LMAC); crypto_secretbox_easy(*cipher, cleartext, clearsize, nonce, key); @@ -117,8 +117,8 @@ size_t pcp_sodium_mac(byte **cipher, /* sym decr */ int pcp_sodium_verify_mac(byte **cleartext, byte* message, - size_t messagesize, byte *nonce, - byte *key) { + size_t messagesize, byte *nonce, + byte *key) { return crypto_secretbox_open_easy(*cleartext, message, messagesize, nonce, key); } @@ -146,32 +146,32 @@ size_t pcp_decrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, pcp_key_t cur_bufsize = ps_read(in, head, 1); /* fread(head, 1, 1, in); */ if(cur_bufsize == 1 && !ps_end(in) && !ps_err(in)) { if(head[0] == PCP_SYM_CIPHER) { - if(symkey != NULL) - self = 1; - else { - fatal(ptx, "Input is symetrically encrypted but no key have been specified (lib usage failure)\n"); - goto errdef1; - } + if(symkey != NULL) + self = 1; + else { + fatal(ptx, "Input is symetrically encrypted but no key have been specified (lib usage failure)\n"); + goto errdef1; + } } else if(head[0] == PCP_ASYM_CIPHER_ANON) { - self = 0; - anon = 1; + self = 0; + anon = 1; } else if(head[0] == PCP_ASYM_CIPHER_ANON_SIG) { - self = 0; - anon = 1; - verify = 1; + self = 0; + anon = 1; + verify = 1; } else if(head[0] == PCP_ASYM_CIPHER) { - self = 0; + self = 0; } else if(head[0] == PCP_ASYM_CIPHER_SIG) { - self = 0; - verify = 1; + self = 0; + verify = 1; } else { - fatal(ptx, "Unknown file header (got: %02x)\n", head[0]); - goto errdef1; + fatal(ptx, "Unknown file header (got: %02x)\n", head[0]); + goto errdef1; } } } @@ -212,7 +212,7 @@ size_t pcp_decrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, pcp_key_t cur_bufsize = ps_read(in, rec_buf, PCP_ASYM_RECIPIENT_SIZE); if(cur_bufsize != PCP_ASYM_RECIPIENT_SIZE && !ps_end(in) && !ps_err(in)) { fatal(ptx, "Error: input file corrupted, incomplete or no recipients (got %ld, exp %ld)\n", - cur_bufsize, PCP_ASYM_RECIPIENT_SIZE ); + cur_bufsize, PCP_ASYM_RECIPIENT_SIZE ); ucfree(rec_buf, PCP_ASYM_RECIPIENT_SIZE); goto errdef1; } @@ -223,58 +223,58 @@ size_t pcp_decrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, pcp_key_t byte *recipient; recipient = pcp_box_decrypt(ptx, s, senderpub, rec_buf, PCP_ASYM_RECIPIENT_SIZE, &rec_size); if(recipient != NULL && rec_size == crypto_secretbox_KEYBYTES) { - /* found a match */ - recmatch = 1; - symkey = smalloc(crypto_secretbox_KEYBYTES); - memcpy(symkey, recipient, crypto_secretbox_KEYBYTES); - free(recipient); - ucfree(senderpub, sizeof(pcp_pubkey_t)); - if(verify) { - memcpy(reccipher, rec_buf, PCP_ASYM_RECIPIENT_SIZE); - } - nrec++; /* otherwise missing */ - break; + /* found a match */ + recmatch = 1; + symkey = smalloc(crypto_secretbox_KEYBYTES); + memcpy(symkey, recipient, crypto_secretbox_KEYBYTES); + free(recipient); + ucfree(senderpub, sizeof(pcp_pubkey_t)); + if(verify) { + memcpy(reccipher, rec_buf, PCP_ASYM_RECIPIENT_SIZE); + } + nrec++; /* otherwise missing */ + break; } free(recipient); } else { /* dig through our list of known public keys for a match */ pcphash_iteratepub(ptx, cur) { - byte *recipient; - recipient = pcp_box_decrypt(ptx, s, cur, rec_buf, PCP_ASYM_RECIPIENT_SIZE, &rec_size); - if(recipient != NULL && rec_size == crypto_secretbox_KEYBYTES) { - /* found a match */ - recmatch = 1; - symkey = smalloc(crypto_secretbox_KEYBYTES); - memcpy(symkey, recipient, crypto_secretbox_KEYBYTES); + byte *recipient; + recipient = pcp_box_decrypt(ptx, s, cur, rec_buf, PCP_ASYM_RECIPIENT_SIZE, &rec_size); + if(recipient != NULL && rec_size == crypto_secretbox_KEYBYTES) { + /* found a match */ + recmatch = 1; + symkey = smalloc(crypto_secretbox_KEYBYTES); + memcpy(symkey, recipient, crypto_secretbox_KEYBYTES); - free(recipient); - break; - } - free(recipient); + free(recipient); + break; + } + free(recipient); } /* do the same with our secret keys, just in case the sender used -M */ if(recmatch == 0) { - pcp_key_t *k; - pcphash_iterate(ptx, k) { - if(fromsec != NULL) - ucfree(fromsec, sizeof(pcp_pubkey_t)); /* avoid overwrite of used mem */ - fromsec = pcpkey_pub_from_secret(k); - - byte *recipient; - recipient = pcp_box_decrypt(ptx, s, fromsec, rec_buf, PCP_ASYM_RECIPIENT_SIZE, &rec_size); + pcp_key_t *k; + pcphash_iterate(ptx, k) { + if(fromsec != NULL) + ucfree(fromsec, sizeof(pcp_pubkey_t)); /* avoid overwrite of used mem */ + fromsec = pcpkey_pub_from_secret(k); + + byte *recipient; + recipient = pcp_box_decrypt(ptx, s, fromsec, rec_buf, PCP_ASYM_RECIPIENT_SIZE, &rec_size); - if(recipient != NULL && rec_size == crypto_secretbox_KEYBYTES) { - /* found a match */ - recmatch = 1; - symkey = smalloc(crypto_secretbox_KEYBYTES); - memcpy(symkey, recipient, crypto_secretbox_KEYBYTES); - free(recipient); - cur = fromsec; - break; - } - } + if(recipient != NULL && rec_size == crypto_secretbox_KEYBYTES) { + /* found a match */ + recmatch = 1; + symkey = smalloc(crypto_secretbox_KEYBYTES); + memcpy(symkey, recipient, crypto_secretbox_KEYBYTES); + free(recipient); + cur = fromsec; + break; + } + } } } if(verify) { @@ -316,7 +316,7 @@ size_t pcp_decrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, pcp_key_t } size_t pcp_encrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream *out, pcp_key_t *secret, - pcp_key_t *signsecret, pcp_pubkey_t *p, int sign, int anon) { + pcp_key_t *signsecret, pcp_pubkey_t *p, int sign, int anon) { byte *symkey; int recipient_count; byte *recipients_cipher; @@ -349,7 +349,7 @@ size_t pcp_encrypt_stream(PCPCTX *ptx, Pcpstream *in, Pcpstream *out, pcp_key_t if(es != rec_size) { fatal(ptx, "invalid rec_size, expected %dl, got %dl\n", rec_size, es); if(rec_cipher != NULL) - free(rec_cipher); + free(rec_cipher); goto errec1; } @@ -530,7 +530,7 @@ size_t pcp_encrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream *out, byte * } size_t pcp_decrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, - byte *symkey, pcp_rec_t *recverify) { + byte *symkey, pcp_rec_t *recverify) { byte *buf_nonce; byte *buf_cipher; byte *buf_clear; @@ -569,9 +569,9 @@ size_t pcp_decrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, if(recverify != NULL) { if(cur_bufsize < PCP_BLOCK_SIZE_IN || ps_end(in)) { - /* pull out signature */ - memcpy(signature_cr, &in_buf[cur_bufsize - siglen_cr], siglen_cr); - cur_bufsize -= siglen_cr; + /* pull out signature */ + memcpy(signature_cr, &in_buf[cur_bufsize - siglen_cr], siglen_cr); + cur_bufsize -= siglen_cr; } } @@ -585,7 +585,7 @@ size_t pcp_decrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, ctr = _get_nonce_ctr(buf_nonce); if(ctr -1 != pastctr) { fatal(ptx, "Mangled packet order, bailing out (got: %ld, expected: %ld)!\n", - ctr, pastctr+1); + ctr, pastctr+1); out_size = 0; break; } @@ -598,12 +598,12 @@ size_t pcp_decrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, ps_write(out, buf_clear, ciphersize - LMAC); if(recverify != NULL) - crypto_generichash_update(st, buf_cipher, ciphersize); + crypto_generichash_update(st, buf_cipher, ciphersize); if(ps_err(out) != 0) { - fatal(ptx, "Failed to write decrypted output!\n"); - out_size = 0; - break; + fatal(ptx, "Failed to write decrypted output!\n"); + out_size = 0; + break; } } else { @@ -622,7 +622,7 @@ size_t pcp_decrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, memcpy(buf_nonce, signature_cr, LNONCE); es = pcp_sodium_verify_mac(&signature, &signature_cr[LNONCE], - siglen_cr - LNONCE, buf_nonce, symkey); + siglen_cr - LNONCE, buf_nonce, symkey); if(es == 0) { /* add encrypted recipient list to the hash */ crypto_generichash_update(st, recverify->cipher, recverify->ciphersize); @@ -631,28 +631,28 @@ size_t pcp_decrypt_stream_sym(PCPCTX *ptx, Pcpstream *in, Pcpstream* out, byte *verifiedhash = NULL; if(recverify->pub == NULL) { - /* anonymous encrypted but with known pub signed, - dig through our list of known public keys for a match */ - pcp_pubkey_t *cur; - pcphash_iteratepub(ptx, cur) { - verifiedhash = pcp_ed_verify(ptx, signature, siglen, cur); - if(verifiedhash != NULL) - break; - } + /* anonymous encrypted but with known pub signed, + dig through our list of known public keys for a match */ + pcp_pubkey_t *cur; + pcphash_iteratepub(ptx, cur) { + verifiedhash = pcp_ed_verify(ptx, signature, siglen, cur); + if(verifiedhash != NULL) + break; + } } else { - verifiedhash = pcp_ed_verify(ptx, signature, siglen, recverify->pub); + verifiedhash = pcp_ed_verify(ptx, signature, siglen, recverify->pub); } if(verifiedhash == NULL) - out_size = 0; + out_size = 0; else { - if(cst_time_memcmp(verifiedhash, hash, crypto_generichash_BYTES_MAX) != 0) { - /* sig verified, but the hash doesn't match */ - fatal(ptx, "signed hash doesn't match actual hash of signed decrypted file content\n"); - out_size = 0; - } - free(verifiedhash); + if(cst_time_memcmp(verifiedhash, hash, crypto_generichash_BYTES_MAX) != 0) { + /* sig verified, but the hash doesn't match */ + fatal(ptx, "signed hash doesn't match actual hash of signed decrypted file content\n"); + out_size = 0; + } + free(verifiedhash); } } else { diff --git a/libpcp/ed.c b/libpcp/ed.c index fe772a1..4616d0a 100644 --- a/libpcp/ed.c +++ b/libpcp/ed.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -212,11 +212,11 @@ pcp_pubkey_t *pcp_ed_verify_buffered(PCPCTX *ptx, Pcpstream *in, pcp_pubkey_t *p cur_bufsize = offset; gotsig = 1; if(z85) { - cur_bufsize -= 1; - memcpy(z85encoded, &in_full[offset], zlen); + cur_bufsize -= 1; + memcpy(z85encoded, &in_full[offset], zlen); } else - memcpy(sighash, &in_full[offset + strlen(binsigstart)], mlen); + memcpy(sighash, &in_full[offset + strlen(binsigstart)], mlen); } else if(full_bufsize - offset == siglen) { /* sig fits within the 2nd half */ @@ -225,11 +225,11 @@ pcp_pubkey_t *pcp_ed_verify_buffered(PCPCTX *ptx, Pcpstream *in, pcp_pubkey_t *p next_bufsize -= siglen; gotsig = 1; if(z85) { - cur_bufsize -= 1; - memcpy(z85encoded, &in_full[full_bufsize - siglen], siglen); + cur_bufsize -= 1; + memcpy(z85encoded, &in_full[full_bufsize - siglen], siglen); } else - memcpy(sighash, &in_full[full_bufsize - mlen], mlen); + memcpy(sighash, &in_full[full_bufsize - mlen], mlen); } else offset = 0; @@ -276,7 +276,7 @@ pcp_pubkey_t *pcp_ed_verify_buffered(PCPCTX *ptx, Pcpstream *in, pcp_pubkey_t *p pcphash_iteratepub(ptx, p) { verifiedhash = pcp_ed_verify(ptx, sighash, mlen, p); if(verifiedhash != NULL) - break; + break; } /* no pubkey found yet, try our own */ @@ -284,13 +284,13 @@ pcp_pubkey_t *pcp_ed_verify_buffered(PCPCTX *ptx, Pcpstream *in, pcp_pubkey_t *p pcp_pubkey_t *pub; pcphash_iterate(ptx, k) { if(k->type == PCP_KEY_TYPE_MAINSECRET) { - pub = pcpkey_pub_from_secret(k); - verifiedhash = pcp_ed_verify(ptx, sighash, mlen, pub); - if(verifiedhash != NULL) { - /* good, self-signed */ - p = pub; - break; - } + pub = pcpkey_pub_from_secret(k); + verifiedhash = pcp_ed_verify(ptx, sighash, mlen, pub); + if(verifiedhash != NULL) { + /* good, self-signed */ + p = pub; + break; + } } } } @@ -341,7 +341,7 @@ size_t pcp_ed_detachsign_buffered(Pcpstream *in, Pcpstream *out, pcp_key_t *s) { size_t mlen = + crypto_sign_BYTES + crypto_generichash_BYTES_MAX; ps_print(out, "%s\r\nVersion: PCP v%d.%d.%d\r\n", - PCP_SIG_START, PCP_VERSION_MAJOR, PCP_VERSION_MINOR, PCP_VERSION_PATCH); + PCP_SIG_START, PCP_VERSION_MAJOR, PCP_VERSION_MINOR, PCP_VERSION_PATCH); size_t zlen; char *z85encoded = pcp_z85_encode((byte*)signature, mlen, &zlen, 1); ps_print(out, "%s\r\n%s\r\n", z85encoded, PCP_SIG_END); @@ -416,7 +416,7 @@ pcp_pubkey_t *pcp_ed_detachverify_buffered(PCPCTX *ptx, Pcpstream *in, Pcpstream pcphash_iteratepub(ptx, p) { verifiedhash = pcp_ed_verify(ptx, sighash, mlen, p); if(verifiedhash != NULL) - break; + break; } /* no pubkey found yet, try our own */ @@ -424,13 +424,13 @@ pcp_pubkey_t *pcp_ed_detachverify_buffered(PCPCTX *ptx, Pcpstream *in, Pcpstream pcp_pubkey_t *pub; pcphash_iterate(ptx, k) { if(k->type == PCP_KEY_TYPE_MAINSECRET) { - pub = pcpkey_pub_from_secret(k); - verifiedhash = pcp_ed_verify(ptx, sighash, mlen, pub); - if(verifiedhash != NULL) { - /* good, self-signed */ - p = pub; - break; - } + pub = pcpkey_pub_from_secret(k); + verifiedhash = pcp_ed_verify(ptx, sighash, mlen, pub); + if(verifiedhash != NULL) { + /* good, self-signed */ + p = pub; + break; + } } } } diff --git a/libpcp/jenhash.c b/libpcp/jenhash.c index 27de50a..445cba3 100644 --- a/libpcp/jenhash.c +++ b/libpcp/jenhash.c @@ -9,14 +9,14 @@ unsigned jen_hash ( unsigned char *k, unsigned length, unsigned initval ) { while ( len >= 12 ) { a += ( k[0] + ( (unsigned)k[1] << 8 ) - + ( (unsigned)k[2] << 16 ) - + ( (unsigned)k[3] << 24 ) ); + + ( (unsigned)k[2] << 16 ) + + ( (unsigned)k[3] << 24 ) ); b += ( k[4] + ( (unsigned)k[5] << 8 ) - + ( (unsigned)k[6] << 16 ) - + ( (unsigned)k[7] << 24 ) ); + + ( (unsigned)k[6] << 16 ) + + ( (unsigned)k[7] << 24 ) ); c += ( k[8] + ( (unsigned)k[9] << 8 ) - + ( (unsigned)k[10] << 16 ) - + ( (unsigned)k[11] << 24 ) ); + + ( (unsigned)k[10] << 16 ) + + ( (unsigned)k[11] << 24 ) ); jen_mix ( a, b, c ); diff --git a/libpcp/key.c b/libpcp/key.c index 37ed9bf..4df8a1b 100644 --- a/libpcp/key.c +++ b/libpcp/key.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -367,13 +367,13 @@ int pcp_sanitycheck_pub(PCPCTX *ptx, pcp_pubkey_t *key) { if(key->type != PCP_KEY_TYPE_PUBLIC) { fatal(ptx, "Pubkey sanity check: key type is not PUBLIC (expected: %02x, got: %02x)!\n", - PCP_KEY_TYPE_PUBLIC, key->type); + PCP_KEY_TYPE_PUBLIC, key->type); return 1; } if(key->version != PCP_KEY_VERSION) { fatal(ptx, "Pubkey sanity check: unknown key version (expected: %08X, got: %08X)!\n", - PCP_KEY_VERSION, key->version); + PCP_KEY_VERSION, key->version); return 1; } @@ -418,13 +418,13 @@ int pcp_sanitycheck_key(PCPCTX *ptx, pcp_key_t *key) { if(key->type != PCP_KEY_TYPE_SECRET && key->type != PCP_KEY_TYPE_MAINSECRET) { fatal(ptx, "Secretkey sanity check: key type is not SECRET (expected: %02x, got: %02x)!\n", - PCP_KEY_TYPE_SECRET, key->type); + PCP_KEY_TYPE_SECRET, key->type); return 1; } if(key->version != PCP_KEY_VERSION) { fatal(ptx, "Secretkey sanity check: unknown key version (expected: %08X, got: %08X)!\n", - PCP_KEY_VERSION, key->version); + PCP_KEY_VERSION, key->version); return 1; } diff --git a/libpcp/keyhash.c b/libpcp/keyhash.c index 674e03c..0b2f19d 100644 --- a/libpcp/keyhash.c +++ b/libpcp/keyhash.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/libpcp/keysig.c b/libpcp/keysig.c index a094998..738d148 100644 --- a/libpcp/keysig.c +++ b/libpcp/keysig.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/libpcp/mem.c b/libpcp/mem.c index 9b2363a..073ef0d 100644 --- a/libpcp/mem.c +++ b/libpcp/mem.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/libpcp/mgmt.c b/libpcp/mgmt.c index 436cb6d..6d83f2e 100644 --- a/libpcp/mgmt.c +++ b/libpcp/mgmt.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -42,17 +42,17 @@ int _check_keysig_h(PCPCTX *ptx, Buffer *blob, rfc_pub_sig_h *h) { if(h->version != EXP_SIG_VERSION) { fatal(ptx, "Unsupported pubkey signature version %d, expected %d\n", - h->version, EXP_SIG_VERSION); + h->version, EXP_SIG_VERSION); return 1; } if(h->type != EXP_SIG_TYPE) { fatal(ptx, "Unsupported pubkey signature type %d, expected %d\n", - h->type, EXP_SIG_TYPE); + h->type, EXP_SIG_TYPE); return 1; } if(h->pkcipher != EXP_SIG_CIPHER) { fatal(ptx, "Unsupported pubkey signature cipher %d, expected %d\n", - h->pkcipher, EXP_SIG_CIPHER); + h->pkcipher, EXP_SIG_CIPHER); return 1; } if(h->hashcipher != EXP_HASH_CIPHER) { @@ -61,7 +61,7 @@ int _check_keysig_h(PCPCTX *ptx, Buffer *blob, rfc_pub_sig_h *h) { } if(h->numsubs > 0 && buffer_left(blob) < sizeof(rfc_pub_sig_s) * h->numsubs) { fatal(ptx, "Signature size specification invalid (sig: %ld, bytes left: %ld, numsubs: %ld\n", - sizeof(rfc_pub_sig_s) * h->numsubs, buffer_left(blob), h->numsubs); + sizeof(rfc_pub_sig_s) * h->numsubs, buffer_left(blob), h->numsubs); return 1; } return 0; @@ -107,14 +107,14 @@ int _check_sigsubs(PCPCTX *ptx, Buffer *blob, pcp_pubkey_t *p, rfc_pub_sig_s *su if(strncmp(notation, "owner", 5) == 0) { if(buffer_get_chunk(blob, p->owner, vsize) == 0) { - fatal(ptx, "Invalid 'owner' notation, expected %ld bytes, but got 0\n", vsize); - goto sgcerr; + fatal(ptx, "Invalid 'owner' notation, expected %ld bytes, but got 0\n", vsize); + goto sgcerr; } } else if(strncmp(notation, "mail", 4) == 0) { if(buffer_get_chunk(blob, p->mail, vsize) == 0) { - fatal(ptx, "Invalid 'mail' notation, expected %ld bytes, but got 0\n", vsize); - goto sgcerr; + fatal(ptx, "Invalid 'mail' notation, expected %ld bytes, but got 0\n", vsize); + goto sgcerr; } } else if(strncmp(notation, "serial", 6) == 0) { @@ -487,10 +487,10 @@ Buffer *pcp_export_pbp_pub(pcp_key_t *sk) { v = localtime(&vt); date = ucmalloc(65); sprintf(date, "%04d-%02d-%02dT%02d:%02d:%02d.000000 %04d-%02d-%02dT%02d:%02d:%02d.000000 ", - c->tm_year+1900-1, c->tm_mon+1, c->tm_mday, // wtf? why -1? - c->tm_hour, c->tm_min, c->tm_sec, - v->tm_year+1900-1, v->tm_mon+1, v->tm_mday, - v->tm_hour, v->tm_min, v->tm_sec); + c->tm_year+1900-1, c->tm_mon+1, c->tm_mday, // wtf? why -1? + c->tm_hour, c->tm_min, c->tm_sec, + v->tm_year+1900-1, v->tm_mon+1, v->tm_mday, + v->tm_hour, v->tm_min, v->tm_sec); buffer_add(sig, date, 64); /* add owner */ @@ -781,15 +781,15 @@ pcp_key_t *pcp_import_secret_native(PCPCTX *ptx, Buffer *cipher, char *passphras cipherlen = buffer_left(cipher); if(cipherlen < minlen) { fatal(ptx, "failed to decrypt the secret key file:\n" - "expected encrypted secret key size %ld is less than minimum len %ld\n", - cipherlen, minlen); + "expected encrypted secret key size %ld is less than minimum len %ld\n", + cipherlen, minlen); goto impserr1; } /* decrypt the blob */ clear = ucmalloc(cipherlen - LMAC); if(pcp_sodium_verify_mac(&clear, buffer_get_remainder(cipher), - cipherlen, nonce, symkey) != 0) { + cipherlen, nonce, symkey) != 0) { fatal(ptx, "failed to decrypt the secret key file\n"); goto impserr1; @@ -914,20 +914,20 @@ json_t *pcp_sk2json(pcp_key_t *sk, byte *sig, size_t siglen) { } jout = json_pack(jformat, - "id", sk->id, - "owner", sk->owner, - "mail", sk->mail, - "ctime", (json_int_t)sk->ctime, - "expire", (json_int_t)sk->ctime+31536000, - "version", (json_int_t)sk->version, - "serial", (json_int_t)sk->serial, - "type", "public", - "cipher", EXP_PK_CIPHER_NAME, - "cryptpub", cryptpub, - "sigpub", sigpub, - "masterpub", masterpub, - "signature", ssig - ); + "id" , sk->id, + "owner" , sk->owner, + "mail" , sk->mail, + "ctime" , (json_int_t)sk->ctime, + "expire" , (json_int_t)sk->ctime+31536000, + "version" , (json_int_t)sk->version, + "serial" , (json_int_t)sk->serial, + "type" , "public", + "cipher" , EXP_PK_CIPHER_NAME, + "cryptpub" , cryptpub, + "sigpub" , sigpub, + "masterpub" , masterpub, + "signature" , ssig + ); free(cryptpub); free(sigpub); diff --git a/libpcp/pcpstream.c b/libpcp/pcpstream.c index f44264f..2bd0461 100644 --- a/libpcp/pcpstream.c +++ b/libpcp/pcpstream.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2015 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -109,12 +109,12 @@ size_t ps_read_raw(Pcpstream *stream, void *buf, size_t readbytes) { if(buffer_left(stream->save) >= readbytes) { gotbytes = buffer_get_chunk(stream->save, buf, readbytes); if(buffer_left(stream->save) == 0) - buffer_clear(stream->save); + buffer_clear(stream->save); goto rawdone; } else { /* fetch the remainder of the save buffer, remember how much - to fetch from source next */ + to fetch from source next */ idx = buffer_get_chunk(stream->save, buf, buffer_left(stream->save)); buffer_clear(stream->save); readbytes -= idx; @@ -159,10 +159,10 @@ size_t ps_read_raw(Pcpstream *stream, void *buf, size_t readbytes) { size_t ps_read_cached(Pcpstream *stream, void *buf, size_t readbytes) { /* fprintf(stderr, "%ld <= %ld && %ld <= %ld\n", - readbytes, buffer_left(stream->cache), readbytes, stream->blocksize) ; + readbytes, buffer_left(stream->cache), readbytes, stream->blocksize) ; fprintf(stderr, "%d == 1 && %ld >= %ld\n", - ps_end(stream), readbytes, buffer_left(stream->cache)); + ps_end(stream), readbytes, buffer_left(stream->cache)); */ if(readbytes <= buffer_left(stream->cache) && readbytes <= stream->blocksize) { /* enough left in current cache */ @@ -194,35 +194,35 @@ size_t ps_read_cached(Pcpstream *stream, void *buf, size_t readbytes) { /* not enough cached, fetch the next chunk */ // fprintf(stderr, " fetch next read_next\n"); if(ps_read_next(stream) == 0) - break; + break; // fprintf(stderr, " fetch next read_continue\n"); /* need to fetch more? */ left = readbytes - (buffer_size(tmp) + buffer_size(stream->next)); if(left < 0) { - /* no more to fetch, in fact there's more than we need */ - /* determine overlapping bytes */ - size_t overlap = readbytes - buffer_size(tmp); + /* no more to fetch, in fact there's more than we need */ + /* determine overlapping bytes */ + size_t overlap = readbytes - buffer_size(tmp); - /* avoid overflow */ - if(overlap > buffer_size(stream->next)) - overlap = buffer_size(stream->next); + /* avoid overflow */ + if(overlap > buffer_size(stream->next)) + overlap = buffer_size(stream->next); - /* add the overlap from next to tmp */ - buffer_get_chunk_tobuf(stream->next, tmp, overlap); + /* add the overlap from next to tmp */ + buffer_get_chunk_tobuf(stream->next, tmp, overlap); - /* move the rest of stream->next into cache */ - buffer_clear(stream->cache); - buffer_get_chunk_tobuf(stream->next, stream->cache, buffer_left(stream->next)); - buffer_clear(stream->next); + /* move the rest of stream->next into cache */ + buffer_clear(stream->cache); + buffer_get_chunk_tobuf(stream->next, stream->cache, buffer_left(stream->next)); + buffer_clear(stream->next); } else { - /* we've got precisely what we need, no need to calculate any overlap - OR there's more to fetch, we don't have enough stuff yet, - put next into tmp, reset next and loop again - same behavior */ - buffer_add_buf(tmp, stream->next); - buffer_clear(stream->next); + /* we've got precisely what we need, no need to calculate any overlap + OR there's more to fetch, we don't have enough stuff yet, + put next into tmp, reset next and loop again - same behavior */ + buffer_add_buf(tmp, stream->next); + buffer_clear(stream->next); } } @@ -278,7 +278,7 @@ size_t ps_read(Pcpstream *stream, void *buf, size_t readbytes) { } else if(stream->armor == 1) { /* z85 encoding has already been determined, therefore the cache - is now filled, use it then */ + is now filled, use it then */ got = ps_read_cached(stream, buf, readbytes); // fprintf(stderr, "%ld = ps_read_cached(stream, buf, readbytes);\n", got); } @@ -395,49 +395,49 @@ size_t ps_read_decode(Pcpstream *stream) { while(buffer_size(z) < stream->blocksize) { buffer_clear(line); if(ps_readline(stream, line) >= 0) { - //fprintf(stderr, "got: <%s>\n", buffer_get_str(line)); - if(z85_isbegin(line) && stream->have_begin == 0) { - /* begin header encountered */ - stream->have_begin = 1; /* otherwise ignore it */ - continue; - } - else if(z85_isend(line)) { - /* end header encountered */ - break; - } - else if(z85_isempty(line)) { - /* ignore empty lines */ - continue; - } - else { - /* regular z85 encoded content */ - // fprintf(stderr, "regular\n"); - // fprintf(stderr, " %ld + %ld > %ld\n", buffer_size(z), buffer_size(line), stream->blocksize); - if(buffer_size(z) + buffer_size(line) > stream->blocksize) { - /* we've got more than needed. - put what we need into z and the remainder - into the save buffer for further reading. */ - /* fprintf(stderr, "overflow %ld + %ld > %ld\n", - buffer_size(z), buffer_size(line), stream->blocksize); - */ - buffer_get_chunk_tobuf(line, z, stream->blocksize - buffer_size(z)); - buffer_get_chunk_tobuf(line, stream->save, buffer_left(line)); - if(!ps_left(stream)) { - /* only add the newline if there's no more to follow */ - buffer_add8(stream->save, '\n'); - } - break; - } - else { - /* not enough yet, store it and go on */ - buffer_add_buf(z, line); - } - } + //fprintf(stderr, "got: <%s>\n", buffer_get_str(line)); + if(z85_isbegin(line) && stream->have_begin == 0) { + /* begin header encountered */ + stream->have_begin = 1; /* otherwise ignore it */ + continue; + } + else if(z85_isend(line)) { + /* end header encountered */ + break; + } + else if(z85_isempty(line)) { + /* ignore empty lines */ + continue; + } + else { + /* regular z85 encoded content */ + // fprintf(stderr, "regular\n"); + // fprintf(stderr, " %ld + %ld > %ld\n", buffer_size(z), buffer_size(line), stream->blocksize); + if(buffer_size(z) + buffer_size(line) > stream->blocksize) { + /* we've got more than needed. + put what we need into z and the remainder + into the save buffer for further reading. */ + /* fprintf(stderr, "overflow %ld + %ld > %ld\n", + buffer_size(z), buffer_size(line), stream->blocksize); + */ + buffer_get_chunk_tobuf(line, z, stream->blocksize - buffer_size(z)); + buffer_get_chunk_tobuf(line, stream->save, buffer_left(line)); + if(!ps_left(stream)) { + /* only add the newline if there's no more to follow */ + buffer_add8(stream->save, '\n'); + } + break; + } + else { + /* not enough yet, store it and go on */ + buffer_add_buf(z, line); + } + } } else { - // fprintf(stderr, " ps_read_next readline returned 0\n"); - /* eof or err */ - break; + // fprintf(stderr, " ps_read_next readline returned 0\n"); + /* eof or err */ + break; } } } @@ -503,15 +503,15 @@ size_t ps_write(Pcpstream *stream, void *buf, size_t writebytes) { buffer_add_buf(tmp, stream->cache); while (buffer_left(tmp) > stream->blocksize) { - /* iterate over tmp blockwise, encode each block, write it out until there's a rest */ - buffer_clear(stream->cache); - buffer_get_chunk_tobuf(tmp, stream->cache, stream->blocksize); - ps_write_encode(stream, z); + /* iterate over tmp blockwise, encode each block, write it out until there's a rest */ + buffer_clear(stream->cache); + buffer_get_chunk_tobuf(tmp, stream->cache, stream->blocksize); + ps_write_encode(stream, z); } /* now, z contains a couple of z85 encoded blocks, tmp contains the - remainder of the write buffer, store the rest in the cache and - go on as nothing did happen */ + remainder of the write buffer, store the rest in the cache and + go on as nothing did happen */ buffer_clear(stream->cache); buffer_add(stream->cache, buffer_get_remainder(tmp), buffer_left(tmp)); buffer_free(tmp); @@ -523,14 +523,14 @@ size_t ps_write(Pcpstream *stream, void *buf, size_t writebytes) { void *aside = NULL; size_t overlap = (buffer_size(stream->cache) + writebytes) - stream->blocksize; if(overlap > 0) { - /* yes, store the overlap, put the left part into the cache */ - aside = ucmalloc(overlap); - memcpy(aside, buf + (writebytes - overlap), overlap); /* FIXME: check if this works */ - buffer_add(stream->cache, buf, writebytes - overlap); + /* yes, store the overlap, put the left part into the cache */ + aside = ucmalloc(overlap); + memcpy(aside, buf + (writebytes - overlap), overlap); /* FIXME: check if this works */ + buffer_add(stream->cache, buf, writebytes - overlap); } else { - /* cache+buf == blocksize */ - buffer_add(stream->cache, buf, writebytes); + /* cache+buf == blocksize */ + buffer_add(stream->cache, buf, writebytes); } /* encode the cache into z */ @@ -538,10 +538,10 @@ size_t ps_write(Pcpstream *stream, void *buf, size_t writebytes) { buffer_clear(stream->cache); if(aside != NULL) { - /* there is an overlapping rest, put it into the cache - the caller needs to call ps_finish() to put it out */ - buffer_add(stream->cache, aside, overlap); - free(aside); + /* there is an overlapping rest, put it into the cache + the caller needs to call ps_finish() to put it out */ + buffer_add(stream->cache, aside, overlap); + free(aside); } } } @@ -645,7 +645,7 @@ void ps_close(Pcpstream *stream) { if(stream->cache != NULL) { if(stream->is_output == 1) { if(buffer_left(stream->cache) != 0) - buffer_info(stream->cache); + buffer_info(stream->cache); assert(buffer_left(stream->cache) == 0); /* there's something left in the cache, call ps_finish() */ } buffer_free(stream->cache); diff --git a/libpcp/platform.c b/libpcp/platform.c index e4aa381..09bc711 100644 --- a/libpcp/platform.c +++ b/libpcp/platform.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -54,9 +54,9 @@ int vasprintf(char **ret, const char *format, va_list args) { if (buffer != NULL) { count = vsnprintf(buffer, count + 1, format, copy); if (count < 0) - free(buffer); + free(buffer); else - *ret = buffer; + *ret = buffer; } } va_end(copy); /* Each va_start() or va_copy() needs a va_end() */ @@ -92,11 +92,11 @@ strnstr(const char *s, const char *find, size_t slen) len = strlen(find); do { do { - if (slen-- < 1 || (sc = *s++) == '\0') - return (NULL); + if (slen-- < 1 || (sc = *s++) == '\0') + return (NULL); } while (sc != c); if (len > slen) - return (NULL); + return (NULL); } while (strncmp(s, find, len) != 0); s--; } diff --git a/libpcp/readpass.c b/libpcp/readpass.c index d830c0f..a28f472 100644 --- a/libpcp/readpass.c +++ b/libpcp/readpass.c @@ -43,127 +43,127 @@ */ int pcp_readpass(PCPCTX *ptx, char ** passwd, const char * prompt, - const char * confirmprompt, int devtty, char *readfromfile) + const char * confirmprompt, int devtty, char *readfromfile) { - FILE * readfrom; - char passbuf[MAXPASSLEN]; - char confpassbuf[MAXPASSLEN]; - struct termios term, term_old; - int usingtty; + FILE * readfrom; + char passbuf[MAXPASSLEN]; + char confpassbuf[MAXPASSLEN]; + struct termios term, term_old; + int usingtty; - /* - * If devtty != 0, try to open /dev/tty; if that fails, or if devtty - * is zero, we'll read the password from stdin instead. - * - * Added by tlinden: however, if readfromfile is defined, we'll - * read the password from there, but if it is '-' we'll use stdin - * as well. - */ - if ((devtty == 0) || ((readfrom = fopen("/dev/tty", "r")) == NULL)) { - if(readfromfile != NULL) { - // FIXME: check if readfromfile is executable, - // if yes, call askextpass(tobewritten) and - // read from the returned fd somehow - if(readfromfile[0] == '-') { - readfrom = stdin; - } - else { - if((readfrom = fopen(readfromfile, "r")) == NULL) { - fatal(ptx, "Could not open password file '%s'\n", readfromfile); - goto err1; - } - } - } - else { - readfrom = stdin; - } - } + /* + * If devtty != 0, try to open /dev/tty; if that fails, or if devtty + * is zero, we'll read the password from stdin instead. + * + * Added by tlinden: however, if readfromfile is defined, we'll + * read the password from there, but if it is '-' we'll use stdin + * as well. + */ + if ((devtty == 0) || ((readfrom = fopen("/dev/tty", "r")) == NULL)) { + if(readfromfile != NULL) { + // FIXME: check if readfromfile is executable, + // if yes, call askextpass(tobewritten) and + // read from the returned fd somehow + if(readfromfile[0] == '-') { + readfrom = stdin; + } + else { + if((readfrom = fopen(readfromfile, "r")) == NULL) { + fatal(ptx, "Could not open password file '%s'\n", readfromfile); + goto err1; + } + } + } + else { + readfrom = stdin; + } + } - /* If we're reading from a terminal, try to disable echo. */ - if ((usingtty = isatty(fileno(readfrom))) != 0) { - if (tcgetattr(fileno(readfrom), &term_old)) { - fatal(ptx, "Cannot read terminal settings\n"); - goto err1; - } - memcpy(&term, &term_old, sizeof(struct termios)); - term.c_lflag = (term.c_lflag & ~ECHO) | ECHONL; - if (tcsetattr(fileno(readfrom), TCSANOW, &term)) { - fatal(ptx, "Cannot set terminal settings\n"); - goto err1; - } - } + /* If we're reading from a terminal, try to disable echo. */ + if ((usingtty = isatty(fileno(readfrom))) != 0) { + if (tcgetattr(fileno(readfrom), &term_old)) { + fatal(ptx, "Cannot read terminal settings\n"); + goto err1; + } + memcpy(&term, &term_old, sizeof(struct termios)); + term.c_lflag = (term.c_lflag & ~ECHO) | ECHONL; + if (tcsetattr(fileno(readfrom), TCSANOW, &term)) { + fatal(ptx, "Cannot set terminal settings\n"); + goto err1; + } + } retry: - /* If we have a terminal, prompt the user to enter the password. */ - if (usingtty) - fprintf(stderr, "%s: ", prompt); - - /* Read the password. */ - if (fgets(passbuf, MAXPASSLEN, readfrom) == NULL) { - fatal(ptx, "Cannot read password\n"); - goto err2; - } + /* If we have a terminal, prompt the user to enter the password. */ + if (usingtty) + fprintf(stderr, "%s: ", prompt); + + /* Read the password. */ + if (fgets(passbuf, MAXPASSLEN, readfrom) == NULL) { + fatal(ptx, "Cannot read password\n"); + goto err2; + } - /* Confirm the password if necessary. */ - if (confirmprompt != NULL) { - if (usingtty) - fprintf(stderr, "%s: ", confirmprompt); - if (fgets(confpassbuf, MAXPASSLEN, readfrom) == NULL) { - fatal(ptx, "Cannot read password\n"); - goto err2; - } - if (strcmp(passbuf, confpassbuf)) { - fprintf(stderr, - "Passwords mismatch, please try again\n"); - goto retry; - } - } + /* Confirm the password if necessary. */ + if (confirmprompt != NULL) { + if (usingtty) + fprintf(stderr, "%s: ", confirmprompt); + if (fgets(confpassbuf, MAXPASSLEN, readfrom) == NULL) { + fatal(ptx, "Cannot read password\n"); + goto err2; + } + if (strcmp(passbuf, confpassbuf)) { + fprintf(stderr, + "Passwords mismatch, please try again\n"); + goto retry; + } + } - /* Terminate the string at the first "\r" or "\n" (if any). */ - passbuf[strcspn(passbuf, "\r\n")] = '\0'; + /* Terminate the string at the first "\r" or "\n" (if any). */ + passbuf[strcspn(passbuf, "\r\n")] = '\0'; - /* enforce no empty passwords */ - if (strnlen(passbuf, MAXPASSLEN) == 0) { - fprintf(stderr, - "Empty password not allowed, please try again\n"); - goto retry; - } - - /* If we changed terminal settings, reset them. */ - if (usingtty) - tcsetattr(fileno(readfrom), TCSANOW, &term_old); + /* enforce no empty passwords */ + if (strnlen(passbuf, MAXPASSLEN) == 0) { + fprintf(stderr, + "Empty password not allowed, please try again\n"); + goto retry; + } + + /* If we changed terminal settings, reset them. */ + if (usingtty) + tcsetattr(fileno(readfrom), TCSANOW, &term_old); + + /* Close /dev/tty if we opened it. + if readfromfile is defined and set to -, disable stdin */ + if (readfrom != stdin) { + fclose(readfrom); + } + + /* Copy the password out. */ + char *p = smalloc(strlen(passbuf) + 1); + memcpy(p, passbuf, strlen(passbuf) + 1 ); + *passwd = p; - /* Close /dev/tty if we opened it. - if readfromfile is defined and set to -, disable stdin */ - if (readfrom != stdin) { - fclose(readfrom); - } + /* Zero any stored passwords. */ + memset(passbuf, 0, MAXPASSLEN); + memset(confpassbuf, 0, MAXPASSLEN); - /* Copy the password out. */ - char *p = smalloc(strlen(passbuf) + 1); - memcpy(p, passbuf, strlen(passbuf) + 1 ); - *passwd = p; - - /* Zero any stored passwords. */ - memset(passbuf, 0, MAXPASSLEN); - memset(confpassbuf, 0, MAXPASSLEN); - - /* Success! */ - return (0); + /* Success! */ + return (0); err2: - /* Reset terminal settings if necessary. */ - if (usingtty) - tcsetattr(fileno(readfrom), TCSAFLUSH, &term_old); + /* Reset terminal settings if necessary. */ + if (usingtty) + tcsetattr(fileno(readfrom), TCSAFLUSH, &term_old); err1: - /* Close /dev/tty if we opened it. */ - if (readfrom != stdin) - fclose(readfrom); + /* Close /dev/tty if we opened it. */ + if (readfrom != stdin) + fclose(readfrom); - /* Failure! */ - return (-1); + /* Failure! */ + return (-1); } diff --git a/libpcp/scrypt.c b/libpcp/scrypt.c index 8c7e5ef..1d19a1f 100644 --- a/libpcp/scrypt.c +++ b/libpcp/scrypt.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,8 +30,8 @@ byte* pcp_scrypt(PCPCTX *ptx, char *passwd, size_t passwdlen, byte *nonce, size_ nonce, noncelen, NULL, 0); int status = crypto_pwhash_scryptsalsa208sha256(dk, 64, passwd, passwdlen, salt, - crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE, - crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE); + crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE, + crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE); ucfree(salt, crypto_pwhash_scryptsalsa208sha256_SALTBYTES); if (status == 0) { diff --git a/libpcp/util.c b/libpcp/util.c index 92f6aab..2f798c7 100644 --- a/libpcp/util.c +++ b/libpcp/util.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T. von Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -69,7 +69,7 @@ void _dump(char *n, byte *d, size_t s) { if(i % 36 == 35 && i > 0) { fprintf(stderr, "\n"); for(c=0; cisnew == 1) { if(pcpvault_create(ptx, vault) != 0) { - pcpvault_close(ptx, vault); - return NULL; + pcpvault_close(ptx, vault); + return NULL; } } else { if(pcpvault_fetchall(ptx, vault) != 0) { - errno = 0; /* weird, something sets it to ENOENT and it's not me */ - pcpvault_close(ptx, vault); - return NULL; + errno = 0; /* weird, something sets it to ENOENT and it's not me */ + pcpvault_close(ptx, vault); + return NULL; } } } @@ -57,7 +57,7 @@ vault_t *pcpvault_new(PCPCTX *ptx, char *filename, int is_tmp) { b = arc4random(); snprintf(vault->filename, 1024, "%s-%08x%08x", filename, a, b); if (stat (vault->filename, &stat_buf) != 0) - break; + break; } unlink(vault->filename); vault->size = 0; @@ -226,25 +226,25 @@ int pcpvault_writeall(PCPCTX *ptx, vault_t *vault) { pcp_key_t *k = NULL; Buffer *blob = buffer_new(PCP_RAW_PUBKEYSIZE, "bs"); pcphash_iterate(ptx, k) { - pcp_seckeyblob(blob, k); - if(pcpvault_additem(ptx, tmp, buffer_get(blob), PCP_RAW_KEYSIZE, PCP_KEY_TYPE_SECRET) != 0) { - buffer_free(blob); - goto errwa; - } - buffer_clear(blob); + pcp_seckeyblob(blob, k); + if(pcpvault_additem(ptx, 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(ptx, p) { - pcp_pubkeyblob(blob, p); - if(pcpvault_additem(ptx, tmp, buffer_get(blob), PCP_RAW_PUBKEYSIZE, PCP_KEY_TYPE_PUBLIC) != 0) { - buffer_free(blob); - goto errwa; - } - buffer_clear(blob); + pcp_pubkeyblob(blob, p); + if(pcpvault_additem(ptx, tmp, buffer_get(blob), PCP_RAW_PUBKEYSIZE, PCP_KEY_TYPE_PUBLIC) != 0) { + buffer_free(blob); + goto errwa; + } + buffer_clear(blob); } pcpvault_update_checksum(ptx, tmp); if(pcpvault_copy(ptx, tmp, vault) == 0) { - pcpvault_unlink(tmp); + pcpvault_unlink(tmp); } pcpvault_free(tmp); buffer_free(blob); @@ -337,7 +337,7 @@ int pcpvault_copy(PCPCTX *ptx, vault_t *tmp, vault_t *vault) { vault->fd = freopen(vault->filename, "wb+", vault->fd); if(fwrite(in, tmpsize, 1, vault->fd) != 1) { fatal(ptx, "Failed to copy %s to %s (write) [keeping %s]\n", - tmp->filename, vault->filename, tmp->filename); + tmp->filename, vault->filename, tmp->filename); ucfree(in, tmpsize); return 1; } @@ -345,7 +345,7 @@ int pcpvault_copy(PCPCTX *ptx, vault_t *tmp, vault_t *vault) { if(fflush(vault->fd) != 0) { fatal(ptx, "Failed to copy %s to %s (flush) [keeping %s]\n", - tmp->filename, vault->filename, tmp->filename); + tmp->filename, vault->filename, tmp->filename); return 1; } @@ -372,7 +372,7 @@ int pcpvault_close(PCPCTX *ptx, vault_t *vault) { if(vault != NULL) { if(vault->fd) { if(vault->unsafed == 1) { - pcpvault_writeall(ptx, vault); + pcpvault_writeall(ptx, vault); } fclose(vault->fd); } @@ -437,7 +437,7 @@ int pcpvault_fetchall(PCPCTX *ptx, vault_t *vault) { got = fread(header, 1, sizeof(vault_header_t), vault->fd); if(got < sizeof(vault_header_t)) { fatal(ptx, "empty or invalid vault header size (got %ld, expected %ld)\n", - got, sizeof(vault_header_t)); + got, sizeof(vault_header_t)); goto err; } vh2native(header); @@ -456,59 +456,59 @@ int pcpvault_fetchall(PCPCTX *ptx, vault_t *vault) { for(;;) { readpos = ftell(vault->fd); if(vault->size - readpos >= sizeof(vault_item_header_t)) { - /* an item header follows */ - got = fread(item, sizeof(vault_item_header_t), 1, vault->fd); - ih2native(item); + /* an item header follows */ + got = fread(item, sizeof(vault_item_header_t), 1, vault->fd); + ih2native(item); - if(item->size > 0) { - /* item is valid */ - readpos = ftell(vault->fd); - bytesleft = vault->size - readpos; - if(bytesleft >= ksize) { - /* a key follows */ - if(item->type == PCP_KEY_TYPE_MAINSECRET || - item->type == PCP_KEY_TYPE_SECRET) { - /* read a secret key */ - key = ucmalloc(sizeof(pcp_key_t)); - got = fread(key, PCP_RAW_KEYSIZE, 1, vault->fd); - key2native(key); - pcphash_add(ptx, (void *)key, item->type); - } - else if(item->type == PCP_KEY_TYPE_PUBLIC) { - /* read a public key */ - pubkey = ucmalloc(sizeof(pcp_pubkey_t)); - got = fread(pubkey, PCP_RAW_PUBKEYSIZE, 1, vault->fd); - pubkey2native(pubkey); - pcphash_add(ptx, (void *)pubkey, item->type); - } - else if(item->type == PCP_KEYSIG_NATIVE || item->type == PCP_KEYSIG_PBP) { - Buffer *rawks = buffer_new(256, "keysig"); - buffer_fd_read(rawks, vault->fd, item->size); - pcp_keysig_t *s = pcp_keysig_new(rawks); - pcphash_add(ptx, (void *)s, item->type); - buffer_free(rawks); - } - else { - fatal(ptx, "Failed to read vault - invalid key type: %02X! at %d\n", - item->type, readpos); - goto err; - } - } - else { - fatal(ptx, "Failed to read vault - that's no pcp key at %d (size %ld)!\n", - readpos, bytesleft); - goto err; - } - } - else { - fatal(ptx, "Failed to read vault - invalid key item header size at %d!\n", - readpos); - goto err; - } + if(item->size > 0) { + /* item is valid */ + readpos = ftell(vault->fd); + bytesleft = vault->size - readpos; + if(bytesleft >= ksize) { + /* a key follows */ + if(item->type == PCP_KEY_TYPE_MAINSECRET || + item->type == PCP_KEY_TYPE_SECRET) { + /* read a secret key */ + key = ucmalloc(sizeof(pcp_key_t)); + got = fread(key, PCP_RAW_KEYSIZE, 1, vault->fd); + key2native(key); + pcphash_add(ptx, (void *)key, item->type); + } + else if(item->type == PCP_KEY_TYPE_PUBLIC) { + /* read a public key */ + pubkey = ucmalloc(sizeof(pcp_pubkey_t)); + got = fread(pubkey, PCP_RAW_PUBKEYSIZE, 1, vault->fd); + pubkey2native(pubkey); + pcphash_add(ptx, (void *)pubkey, item->type); + } + else if(item->type == PCP_KEYSIG_NATIVE || item->type == PCP_KEYSIG_PBP) { + Buffer *rawks = buffer_new(256, "keysig"); + buffer_fd_read(rawks, vault->fd, item->size); + pcp_keysig_t *s = pcp_keysig_new(rawks); + pcphash_add(ptx, (void *)s, item->type); + buffer_free(rawks); + } + else { + fatal(ptx, "Failed to read vault - invalid key type: %02X! at %d\n", + item->type, readpos); + goto err; + } + } + else { + fatal(ptx, "Failed to read vault - that's no pcp key at %d (size %ld)!\n", + readpos, bytesleft); + goto err; + } + } + else { + fatal(ptx, "Failed to read vault - invalid key item header size at %d!\n", + readpos); + goto err; + } } else { - /* no more items */ - break; + /* no more items */ + break; } } } diff --git a/libpcp/z85.c b/libpcp/z85.c index e7446e9..aa347ee 100755 --- a/libpcp/z85.c +++ b/libpcp/z85.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2014 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -54,8 +54,8 @@ uint8_t is_utf8(const byte *bytes) { ) || (// straight 3-byte ((0xE1 <= bytes[0] && bytes[0] <= 0xEC) || - bytes[0] == 0xEE || - bytes[0] == 0xEF) && + bytes[0] == 0xEE || + bytes[0] == 0xEF) && (0x80 <= bytes[1] && bytes[1] <= 0xBF) && (0x80 <= bytes[2] && bytes[2] <= 0xBF) ) || @@ -107,25 +107,25 @@ size_t _buffer_is_binary(byte *buf, size_t len) { /* check for utf8 */ wide[0] = buf[pos]; for(i=1; i<3; i++) { - /* check for 2, 3 or 4 byte utf8 char */ - if(pos+i < len) { - /* only if there's enough space of course */ - wide[i] = buf[pos+i]; - if(is_utf8(wide) > 1) { - pos += i; /* jump over the utf we already found */ - utf = 1; - break; - } - } - else - break; + /* check for 2, 3 or 4 byte utf8 char */ + if(pos+i < len) { + /* only if there's enough space of course */ + wide[i] = buf[pos+i]; + if(is_utf8(wide) > 1) { + pos += i; /* jump over the utf we already found */ + utf = 1; + break; + } + } + else + break; } memset(wide, 0, 4); if(utf == 1) { - /* it's a utf8 char, continue checking, reset wide */ - utf = 0; - continue; + /* it's a utf8 char, continue checking, reset wide */ + utf = 0; + continue; } break; /* if we reach this, then it's binary and not utf8, stop checking */ } @@ -256,12 +256,12 @@ char *pcp_z85_encode(byte *raw, size_t srclen, size_t *dstlen, int doblock) { while(*z != '\0') { if(pos >= 71) { - *B++ = '\r'; - *B++ = '\n'; - pos = 1; + *B++ = '\r'; + *B++ = '\n'; + pos = 1; } else { - pos++; + pos++; } *B++ = *z++; } @@ -331,27 +331,27 @@ char *pcp_readz85string(PCPCTX *ptx, unsigned char *input, size_t bufsize) { else if(input[i] == '\n') { /* a line is complete */ if(z85_isbegin(line) && begin == 0) { - /* a begin header, reset whatever we've got so far in z buffer */ - begin = 1; - buffer_clear(line); - buffer_clear(z); - continue; + /* a begin header, reset whatever we've got so far in z buffer */ + begin = 1; + buffer_clear(line); + buffer_clear(z); + continue; } else if(z85_isend(line)){ - /* an end header */ - buffer_clear(line); - end = 1; - break; + /* an end header */ + buffer_clear(line); + end = 1; + break; } else if(z85_isempty(line) || z85_iscomment(line)) { - /* a comment */ - buffer_clear(line); - continue; + /* a comment */ + buffer_clear(line); + continue; } else { - /* regular z85 encoded content */ - buffer_add_buf(z, line); - buffer_clear(line); + /* regular z85 encoded content */ + buffer_add_buf(z, line); + buffer_clear(line); } } else { @@ -469,7 +469,7 @@ int z85_isbegin(Buffer *buf) { blen = strlen(begin); if(blen <= len) if(_findoffset(line+buf->offset, len, (char *)begin, blen) >= 0) - isb = i; /* i = ENUM ZBEGINS */ + isb = i; /* i = ENUM ZBEGINS */ } free(line); diff --git a/src/encryption.c b/src/encryption.c index 8bf155f..9c48cf4 100644 --- a/src/encryption.c +++ b/src/encryption.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2015 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -66,12 +66,12 @@ int pcpdecrypt(char *id, int useid, char *infile, char *outfile, char *passwd, i char *passphrase; if(passwd == NULL) { - pcp_readpass(ptx, &passphrase, - "Enter passphrase for symetric decryption", NULL, 1, NULL); + pcp_readpass(ptx, &passphrase, + "Enter passphrase for symetric decryption", NULL, 1, NULL); } else { - passphrase = smalloc(strlen(passwd)+1); - memcpy(passphrase, passwd, strlen(passwd) + 1); + passphrase = smalloc(strlen(passwd)+1); + memcpy(passphrase, passwd, strlen(passwd) + 1); } symkey = pcp_scrypt(ptx, passphrase, strlen(passphrase), salt, 90); @@ -79,48 +79,48 @@ int pcpdecrypt(char *id, int useid, char *infile, char *outfile, char *passwd, i free(salt); } else if(head == PCP_ASYM_CIPHER || head == PCP_ASYM_CIPHER_SIG - || head == PCP_ASYM_CIPHER_ANON || head == PCP_ASYM_CIPHER_ANON_SIG) { + || head == PCP_ASYM_CIPHER_ANON || head == PCP_ASYM_CIPHER_ANON_SIG) { /* asymetric mode */ if(useid) { - secret = pcphash_keyexists(ptx, id); - if(secret == NULL) { - fatal(ptx, "Could not find a secret key with id 0x%s in vault %s!\n", - id, vault->filename); - goto errde3; - } + secret = pcphash_keyexists(ptx, id); + if(secret == NULL) { + fatal(ptx, "Could not find a secret key with id 0x%s in vault %s!\n", + id, vault->filename); + goto errde3; + } } else { - secret = pcp_find_primary_secret(); - if(secret == NULL) { - fatal(ptx, "Could not find a secret key in vault %s!\n", id, vault->filename); - goto errde3; - } + secret = pcp_find_primary_secret(); + if(secret == NULL) { + fatal(ptx, "Could not find a secret key in vault %s!\n", id, vault->filename); + goto errde3; + } } char *passphrase; if(passwd == NULL) { - pcp_readpass(ptx, &passphrase, - "Enter passphrase to decrypt your secret key", NULL, 1, NULL); + pcp_readpass(ptx, &passphrase, + "Enter passphrase to decrypt your secret key", NULL, 1, NULL); } else { - passphrase = smalloc(strlen(passwd)+1); - memcpy(passphrase, passwd, strlen(passwd)+1); + passphrase = smalloc(strlen(passwd)+1); + memcpy(passphrase, passwd, strlen(passwd)+1); } secret = pcpkey_decrypt(ptx, secret, passphrase); sfree(passphrase); if(secret == NULL) - goto errde3; + goto errde3; if(head == PCP_ASYM_CIPHER_ANON) - anon = 1; + anon = 1; if(head == PCP_ASYM_CIPHER_SIG) - verify = 1; + verify = 1; if(head == PCP_ASYM_CIPHER_ANON_SIG) { - anon = 1; - verify = 1; + anon = 1; + verify = 1; } } else { @@ -164,7 +164,7 @@ int pcpdecrypt(char *id, int useid, char *infile, char *outfile, char *passwd, i int pcpencrypt(char *id, char *infile, char *outfile, char *passwd, - plist_t *recipient, int signcrypt, int armor, int anon) { + plist_t *recipient, int signcrypt, int armor, int anon) { FILE *in = NULL; FILE *out = NULL; pcp_pubkey_t *pubhash = NULL; /* FIXME: add free() */ @@ -201,15 +201,15 @@ int pcpencrypt(char *id, char *infile, char *outfile, char *passwd, /* self-encryption: look if its a secret one */ pcp_key_t *s = pcphash_keyexists(ptx, id); if(s != NULL) { - tmp = pcpkey_pub_from_secret(s); - pub = ucmalloc(sizeof(pcp_pubkey_t)); - memcpy(pub, tmp, sizeof(pcp_pubkey_t)); - HASH_ADD_STR( pubhash, id, pub); + tmp = pcpkey_pub_from_secret(s); + pub = ucmalloc(sizeof(pcp_pubkey_t)); + memcpy(pub, tmp, sizeof(pcp_pubkey_t)); + HASH_ADD_STR( pubhash, id, pub); } else { - fatal(ptx, "Could not find a public key with id 0x%s in vault %s!\n", - id, vault->filename); - goto erren3; + fatal(ptx, "Could not find a public key with id 0x%s in vault %s!\n", + id, vault->filename); + goto erren3; } } else { @@ -227,15 +227,15 @@ int pcpencrypt(char *id, char *infile, char *outfile, char *passwd, pcphash_iteratepub(ptx, tmp) { rec = recipient->first; while (rec != NULL) { - _lc(rec->value); - if(strnstr(tmp->mail, rec->value, 255) != NULL - || strnstr(tmp->owner, rec->value, 255) != NULL) { - pub = ucmalloc(sizeof(pcp_pubkey_t)); - memcpy(pub, tmp, sizeof(pcp_pubkey_t)); - HASH_ADD_STR( pubhash, id, pub); - /* fprintf(stderr, " => found a matching key %s\n", tmp->id); */ - } - rec = rec->next; + _lc(rec->value); + if(strnstr(tmp->mail, rec->value, 255) != NULL + || strnstr(tmp->owner, rec->value, 255) != NULL) { + pub = ucmalloc(sizeof(pcp_pubkey_t)); + memcpy(pub, tmp, sizeof(pcp_pubkey_t)); + HASH_ADD_STR( pubhash, id, pub); + /* fprintf(stderr, " => found a matching key %s\n", tmp->id); */ + } + rec = rec->next; } } @@ -243,10 +243,10 @@ int pcpencrypt(char *id, char *infile, char *outfile, char *passwd, rec = recipient->first; while (rec != NULL) { if(strnstr("__self__", rec->value, 13) != NULL) { - pcp_key_t *s = pcp_find_primary_secret(); - pcp_pubkey_t *p = pcpkey_pub_from_secret(s); - HASH_ADD_STR( pubhash, id, p); - break; + pcp_key_t *s = pcp_find_primary_secret(); + pcp_pubkey_t *p = pcpkey_pub_from_secret(s); + HASH_ADD_STR( pubhash, id, p); + break; } rec = rec->next; } @@ -264,22 +264,22 @@ int pcpencrypt(char *id, char *infile, char *outfile, char *passwd, secret = pcp_find_primary_secret(); if(secret == NULL) { fatal(ptx, "Could not find a secret key in vault %s!\n", id, vault->filename); - goto erren2; + goto erren2; } char *passphrase; if(passwd == NULL) { - pcp_readpass(ptx, &passphrase, - "Enter passphrase to decrypt your secret key", NULL, 1, NULL); + pcp_readpass(ptx, &passphrase, + "Enter passphrase to decrypt your secret key", NULL, 1, NULL); } else { - passphrase = smalloc(strlen(passwd)+1); - memcpy(passphrase, passwd, strlen(passwd)+1); + passphrase = smalloc(strlen(passwd)+1); + memcpy(passphrase, passwd, strlen(passwd)+1); } secret = pcpkey_decrypt(ptx, secret, passphrase); sfree(passphrase); if(secret == NULL) - goto erren2; + goto erren2; signsecret = secret; } @@ -341,7 +341,7 @@ int pcpencrypt(char *id, char *infile, char *outfile, char *passwd, fprintf(stderr, "Encrypted %"FMT_SIZE_T" bytes for:\n", (SIZE_T_CAST)clen); pcp_pubkey_t *cur, *t; HASH_ITER(hh, pubhash, cur, t) { - fprintf(stderr, " 0x%s - %s <%s>\n", cur->id, cur->owner, cur->mail); + fprintf(stderr, " 0x%s - %s <%s>\n", cur->id, cur->owner, cur->mail); } } if(signcrypt) @@ -381,8 +381,8 @@ void pcpchecksum(char **files, int filenum, char *key) { } else { if((in = fopen(files[i], "rb")) == NULL) { - fatal(ptx, "Could not open input file %s\n", files[i]); - break; + fatal(ptx, "Could not open input file %s\n", files[i]); + break; } } Pcpstream *pin = ps_new_file(in); diff --git a/src/keymgmt.c b/src/keymgmt.c index 09043e3..3fba381 100644 --- a/src/keymgmt.c +++ b/src/keymgmt.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013-2015 T.v.Dein. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -78,8 +78,8 @@ void pcp_keygen(char *passwd) { char *passphrase; if(passwd == NULL) { pcp_readpass(ptx, &passphrase, - "Enter passphrase for key encryption", - "Enter the passphrase again", 1, NULL); + "Enter passphrase for key encryption", + "Enter the passphrase again", 1, NULL); } else { passphrase = passwd; @@ -91,7 +91,7 @@ void pcp_keygen(char *passwd) { fprintf(stderr, "WARNING: you are using a weak passphrase (entropy: %lf)!\n", ent); char *yes = pcp_getstdin("Are you sure to use it [yes|NO]?"); if(strncmp(yes, "yes", 1024) != 0) { - goto errkg1; + goto errkg1; } } key = pcpkey_encrypt(ptx, k, passphrase); @@ -167,7 +167,7 @@ char *pcp_normalize_id(char *keyid) { if(keyid[0] == '0' && keyid[1] == 'x' && len == 18) { int i; for(i=0; i<16; ++i) { - id[i] = keyid[i+2]; + id[i] = keyid[i+2]; } id[16] = 0; } @@ -238,18 +238,18 @@ void pcp_exportsecret(char *keyid, int useid, char *outfile, int armor, char *pa if(passwd == NULL) { char *passphrase; pcp_readpass(ptx, &passphrase, - "Enter passphrase to decrypt your secret key", NULL, 1, NULL); + "Enter passphrase to decrypt your secret key", NULL, 1, NULL); key = pcpkey_decrypt(ptx, key, passphrase); if(key == NULL) { - sfree(passphrase); - goto errexpse1; + sfree(passphrase); + goto errexpse1; } sfree(passphrase); } else { key = pcpkey_decrypt(ptx, key, passwd); if(key == NULL) { - goto errexpse1; + goto errexpse1; } } @@ -262,20 +262,20 @@ void pcp_exportsecret(char *keyid, int useid, char *outfile, int armor, char *pa char *passphrase; pcp_readpass(ptx, &passphrase, "Enter passphrase to encrypt the exported secret key", - "Repeat passphrase", 1, NULL); + "Repeat passphrase", 1, NULL); exported_sk = pcp_export_secret(ptx, key, passphrase); sfree(passphrase); } if(exported_sk != NULL) { if(armor == 1) { - size_t zlen; - char *z85 = pcp_z85_encode(buffer_get(exported_sk), buffer_size(exported_sk), &zlen, 1); - fprintf(out, "%s\r\n%s\r\n%s\r\n", EXP_SK_HEADER, z85, EXP_SK_FOOTER); - free(z85); + size_t zlen; + char *z85 = pcp_z85_encode(buffer_get(exported_sk), buffer_size(exported_sk), &zlen, 1); + fprintf(out, "%s\r\n%s\r\n%s\r\n", EXP_SK_HEADER, z85, EXP_SK_FOOTER); + free(z85); } else { - fwrite(buffer_get(exported_sk), 1, buffer_size(exported_sk), out); + fwrite(buffer_get(exported_sk), 1, buffer_size(exported_sk), out); } buffer_free(exported_sk); fprintf(stderr, "secret key exported.\n"); @@ -318,13 +318,13 @@ void pcp_exportpublic(char *keyid, char *passwd, char *outfile, int format, int /* ok, so, then look for a secret key with that id */ sk = pcphash_keyexists(ptx, keyid); if(sk == NULL) { - fatal(ptx, "Could not find a key with id 0x%s in vault %s!\n", - keyid, vault->filename); - goto errpcpexpu1; + fatal(ptx, "Could not find a key with id 0x%s in vault %s!\n", + keyid, vault->filename); + goto errpcpexpu1; } else { - /* ok, so it's our own key */ - is_foreign = 0; + /* ok, so it's our own key */ + is_foreign = 0; } } else { @@ -351,7 +351,7 @@ void pcp_exportpublic(char *keyid, char *passwd, char *outfile, int format, int else { char *passphrase; pcp_readpass(ptx, &passphrase, - "Enter passphrase to decrypt your secret key", NULL, 1, NULL); + "Enter passphrase to decrypt your secret key", NULL, 1, NULL); sk = pcpkey_decrypt(ptx, sk, passphrase); sfree(passphrase); } @@ -365,16 +365,16 @@ void pcp_exportpublic(char *keyid, char *passwd, char *outfile, int format, int if(is_foreign == 0) { exported_pk = pcp_export_rfc_pub(ptx, sk); if(exported_pk != NULL) { - if(armor == 1) { - size_t zlen; - char *z85 = pcp_z85_encode(buffer_get(exported_pk), buffer_size(exported_pk), &zlen, 1); - fprintf(out, "%s\r\n%s\r\n%s\r\n", EXP_PK_HEADER, z85, EXP_PK_FOOTER); - free(z85); - } - else - fwrite(buffer_get(exported_pk), 1, buffer_size(exported_pk), out); - buffer_free(exported_pk); - fprintf(stderr, "public key exported.\n"); + if(armor == 1) { + size_t zlen; + char *z85 = pcp_z85_encode(buffer_get(exported_pk), buffer_size(exported_pk), &zlen, 1); + fprintf(out, "%s\r\n%s\r\n%s\r\n", EXP_PK_HEADER, z85, EXP_PK_FOOTER); + free(z85); + } + else + fwrite(buffer_get(exported_pk), 1, buffer_size(exported_pk), out); + buffer_free(exported_pk); + fprintf(stderr, "public key exported.\n"); } } else { @@ -387,13 +387,13 @@ void pcp_exportpublic(char *keyid, char *passwd, char *outfile, int format, int if(is_foreign == 0) { exported_pk = pcp_export_pbp_pub(sk); if(exported_pk != NULL) { - /* PBP format requires armoring always */ - size_t zlen; - char *z85pbp = pcp_z85_encode(buffer_get(exported_pk), buffer_size(exported_pk), &zlen, 1); - fprintf(out, "%s", z85pbp); - free(z85pbp); - buffer_free(exported_pk); - fprintf(stderr, "public key exported in PBP format.\n"); + /* PBP format requires armoring always */ + size_t zlen; + char *z85pbp = pcp_z85_encode(buffer_get(exported_pk), buffer_size(exported_pk), &zlen, 1); + fprintf(out, "%s", z85pbp); + free(z85pbp); + buffer_free(exported_pk); + fprintf(stderr, "public key exported in PBP format.\n"); } } else { @@ -446,63 +446,63 @@ void pcpedit_key(char *keyid) { fprintf(stderr, "Current owner: %s\n", key->owner); char *owner = pcp_getstdin(" enter new name or press enter to keep current"); if(strlen(owner) > 0) - memcpy(key->owner, owner, strlen(owner) + 1); + memcpy(key->owner, owner, strlen(owner) + 1); fprintf(stderr, "Current mail: %s\n", key->mail); char *mail = pcp_getstdin(" enter new email or press enter to keep current"); if(strlen(mail) > 0) - memcpy(key->mail, mail, strlen(mail) + 1); + memcpy(key->mail, mail, strlen(mail) + 1); free(owner); free(mail); if(key->type != PCP_KEY_TYPE_MAINSECRET) { - pcp_key_t *other = NULL; - uint8_t haveprimary = 0; - pcphash_iterate(ptx, other) { - if(other->type == PCP_KEY_TYPE_MAINSECRET) { - haveprimary = 1; - break; - } - } + pcp_key_t *other = NULL; + uint8_t haveprimary = 0; + pcphash_iterate(ptx, other) { + if(other->type == PCP_KEY_TYPE_MAINSECRET) { + haveprimary = 1; + break; + } + } - char *yes = NULL; + char *yes = NULL; if(! haveprimary) { - fprintf(stderr, "There is currently no primary secret in your vault,\n"); - yes = pcp_getstdin("want to make this one the primary [yes|NO]?"); - } - else { - fprintf(stderr, "The key %s is currently the primary secret,\n", other->id); - yes = pcp_getstdin("want to make this one the primary instead [yes|NO]?"); - } + fprintf(stderr, "There is currently no primary secret in your vault,\n"); + yes = pcp_getstdin("want to make this one the primary [yes|NO]?"); + } + else { + fprintf(stderr, "The key %s is currently the primary secret,\n", other->id); + yes = pcp_getstdin("want to make this one the primary instead [yes|NO]?"); + } - if(strncmp(yes, "yes", 1024) == 0) { - key->type = PCP_KEY_TYPE_MAINSECRET; - if(haveprimary) { - fprintf(stderr, "other type: %d\n", other->type); - other->type = PCP_KEY_TYPE_SECRET; - fprintf(stderr, " new type: %d\n", other->type); - } - } - free(yes); + if(strncmp(yes, "yes", 1024) == 0) { + key->type = PCP_KEY_TYPE_MAINSECRET; + if(haveprimary) { + fprintf(stderr, "other type: %d\n", other->type); + other->type = PCP_KEY_TYPE_SECRET; + fprintf(stderr, " new type: %d\n", other->type); + } + } + free(yes); } char *passphrase; pcp_readpass(ptx, &passphrase, - "Enter new passphrase for key encryption (press enter to keep current)", - "Enter the passphrase again", 1, NULL); + "Enter new passphrase for key encryption (press enter to keep current)", + "Enter the passphrase again", 1, NULL); if(strnlen(passphrase, 1024) > 0) { - key = pcpkey_encrypt(ptx, key, passphrase); - sfree(passphrase); + key = pcpkey_encrypt(ptx, key, passphrase); + sfree(passphrase); } if(key != NULL) { - if(debug) - pcp_dumpkey(key); + if(debug) + pcp_dumpkey(key); - vault->unsafed = 1; /* will be safed automatically */ - fprintf(stderr, "Key %s changed.\n", key->id); + vault->unsafed = 1; /* will be safed automatically */ + fprintf(stderr, "Key %s changed.\n", key->id); } } } @@ -564,26 +564,26 @@ int pcp_import (vault_t *vault, FILE *in, char *passwd) { fatals_ifany(ptx); char *yes = pcp_getstdin("WARNING: signature doesn't verify, import anyway [yes|NO]?"); if(strncmp(yes, "yes", 1024) != 0) { - free(yes); - goto errimp2; + free(yes); + goto errimp2; } free(yes); } if(pcp_sanitycheck_pub(ptx, pub) == 0) { if(pcpvault_addkey(ptx, vault, (void *)pub, PCP_KEY_TYPE_PUBLIC) == 0) { - fprintf(stderr, "key 0x%s added to %s.\n", pub->id, vault->filename); - /* avoid double free */ - success = 0; + fprintf(stderr, "key 0x%s added to %s.\n", pub->id, vault->filename); + /* avoid double free */ + success = 0; } else - goto errimp2; + goto errimp2; if(keysig != NULL) { - if(pcpvault_addkey(ptx, vault, keysig, keysig->type) != 0) { - /* FIXME: remove pubkey if storing the keysig failed */ - goto errimp2; - } + if(pcpvault_addkey(ptx, vault, keysig, keysig->type) != 0) { + /* FIXME: remove pubkey if storing the keysig failed */ + goto errimp2; + } } } else @@ -599,7 +599,7 @@ int pcp_import (vault_t *vault, FILE *in, char *passwd) { else { char *passphrase; pcp_readpass(ptx, &passphrase, - "Enter passphrase to decrypt the secret key file", NULL, 1, NULL); + "Enter passphrase to decrypt the secret key file", NULL, 1, NULL); sk = pcp_import_secret(ptx, buf, bufsize, passphrase); sfree(passphrase); } @@ -624,33 +624,33 @@ int pcp_import (vault_t *vault, FILE *in, char *passwd) { else { char *passphrase; pcp_readpass(ptx, &passphrase, - "Enter passphrase for key encryption", - "Enter the passphrase again", 1, NULL); + "Enter passphrase for key encryption", + "Enter the passphrase again", 1, NULL); if(strnlen(passphrase, 1024) > 0) { - /* encrypt the key */ - sk = pcpkey_encrypt(ptx, sk, passphrase); - sfree(passphrase); + /* encrypt the key */ + sk = pcpkey_encrypt(ptx, sk, passphrase); + sfree(passphrase); } else { - /* ask for confirmation if we shall store it in the clear */ - char *yes = pcp_getstdin( - "WARNING: secret key will be stored unencrypted. Are you sure [yes|NO]?"); - if(strncmp(yes, "yes", 1024) != 0) { - free(yes); - goto errimp1; - } - free(yes); + /* ask for confirmation if we shall store it in the clear */ + char *yes = pcp_getstdin( + "WARNING: secret key will be stored unencrypted. Are you sure [yes|NO]?"); + if(strncmp(yes, "yes", 1024) != 0) { + free(yes); + goto errimp1; + } + free(yes); } } if(sk != NULL) { /* store it to the vault if we got it til here */ if(pcp_sanitycheck_key(ptx, sk) == 0) { - if(pcp_storekey(sk) == 0) { - pcpkey_printshortinfo(sk); - success = 0; - } + if(pcp_storekey(sk) == 0) { + pcpkey_printshortinfo(sk); + success = 0; + } } } } diff --git a/src/keyprint.c b/src/keyprint.c index 16ce0b4..b1c05e6 100644 --- a/src/keyprint.c +++ b/src/keyprint.c @@ -1,7 +1,7 @@ /* This file is part of Pretty Curved Privacy (pcp1). - Copyright (C) 2013 T.Linden. + Copyright (C) 2013-2016 T.v.Dein. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -92,13 +92,13 @@ void pcptext_key(char *keyid) { pcp_pubkey_t *p = pcphash_pubkeyexists(ptx, keyid); if(p != NULL) { if(debug) { - pcp_dumppubkey(p); - pcp_keysig_t *s = pcphash_keysigexists(ptx, keyid); - if(s != NULL) { - printf("\n"); - pcp_dumpkeysig(s); - } - printf("\n"); + pcp_dumppubkey(p); + pcp_keysig_t *s = pcphash_keysigexists(ptx, keyid); + if(s != NULL) { + printf("\n"); + pcp_dumpkeysig(s); + } + printf("\n"); } pcppubkey_print(p, stdout); } @@ -119,11 +119,11 @@ void pcptext_vault(vault_t *vault) { checksum = _bin2hex(vault->checksum, LSHA); jout = json_pack("{sssisssisi}", - "keyvaultfile", vault->filename, - "version", vault->version, - "checksum", checksum, - "secretkeys", pcphash_count(ptx), - "publickey", pcphash_countpub(ptx)); + "keyvaultfile" , vault->filename, + "version" , vault->version, + "checksum" , checksum, + "secretkeys" , pcphash_count(ptx), + "publickey" , pcphash_countpub(ptx)); jkeys = json_array(); @@ -174,11 +174,11 @@ void pcpkey_printlineinfo(pcp_key_t *key) { time_t t = (time_t)key->ctime; c = localtime(&t); printf("0x%s %s %04d-%02d-%02dT%02d:%02d:%02d %s <%s>\n", - key->id, - (key->type == PCP_KEY_TYPE_MAINSECRET) ? "primary secret" : "secret ", - c->tm_year+1900, c->tm_mon+1, c->tm_mday, - c->tm_hour, c->tm_min, c->tm_sec, - key->owner, key->mail); + key->id, + (key->type == PCP_KEY_TYPE_MAINSECRET) ? "primary secret" : "secret ", + c->tm_year+1900, c->tm_mon+1, c->tm_mday, + c->tm_hour, c->tm_min, c->tm_sec, + key->owner, key->mail); if(ptx->verbose) { printf(" "); @@ -186,14 +186,14 @@ void pcpkey_printlineinfo(pcp_key_t *key) { int i, y; for(i=0; isecret[0] == '\0') ? "yes" : " no", - key->serial, (int)key->version); + (key->secret[0] == '\0') ? "yes" : " no", + key->serial, (int)key->version); printf("\n"); } } @@ -203,11 +203,11 @@ void pcppubkey_printlineinfo(pcp_pubkey_t *key) { time_t t = (time_t)key->ctime; c = localtime(&t); printf("0x%s %s %04d-%02d-%02dT%02d:%02d:%02d %s <%s>\n", - key->id, - (key->valid == 1) ? "valid public " : "public ", - c->tm_year+1900, c->tm_mon+1, c->tm_mday, - c->tm_hour, c->tm_min, c->tm_sec, - key->owner, key->mail); + key->id, + (key->valid == 1) ? "valid public " : "public ", + c->tm_year+1900, c->tm_mon+1, c->tm_mday, + c->tm_hour, c->tm_min, c->tm_sec, + key->owner, key->mail); if(ptx->verbose) { printf(" "); @@ -215,23 +215,23 @@ void pcppubkey_printlineinfo(pcp_pubkey_t *key) { int i, y; for(i=0; ivalid == 1) ? "yes" : " no", - key->serial, (int)key->version); + (key->valid == 1) ? "yes" : " no", + key->serial, (int)key->version); pcp_keysig_t *sig = pcphash_keysigexists(ptx, key->id); if(sig != NULL) { printf("signature fingerprint:\n "); byte *checksum = sig->checksum; for(i=0; itm_year+1900, c->tm_mon+1, c->tm_mday, - c->tm_hour, c->tm_min, c->tm_sec); + c->tm_year+1900, c->tm_mon+1, c->tm_mday, + c->tm_hour, c->tm_min, c->tm_sec); byte *hash = pcppubkey_getchecksum(key); fprintf(out, " Checksum: "); @@ -298,10 +298,10 @@ void pcppubkey_print(pcp_pubkey_t *key, FILE* out) { size_t rlen = strlen(r); for (i=0; itm_year+1900, c->tm_mon+1, c->tm_mday, - c->tm_hour, c->tm_min, c->tm_sec); + c->tm_year+1900, c->tm_mon+1, c->tm_mday, + c->tm_hour, c->tm_min, c->tm_sec); fprintf(out, " Serial Number: 0x%08X\n", key->serial); fprintf(out, " Key Version: 0x%08X\n", key->version); @@ -359,10 +359,10 @@ void pcpkey_print(pcp_key_t *key, FILE* out) { size_t rlen = strlen(r); for (i=0; iverbose = 1; /* no break by purpose, turn on -l */ case 'l': - mode += PCP_MODE_LISTKEYS; - usevault = 1; - break; + mode += PCP_MODE_LISTKEYS; + usevault = 1; + break; case 's': - mode += PCP_MODE_EXPORT_SECRET; - usevault = 1; - break; + mode += PCP_MODE_EXPORT_SECRET; + usevault = 1; + break; case 'p': - mode += PCP_MODE_EXPORT_PUBLIC; - usevault = 1; - break; + mode += PCP_MODE_EXPORT_PUBLIC; + usevault = 1; + break; case 'K': - mode += PCP_MODE_IMPORT; - usevault = 1; - break; + mode += PCP_MODE_IMPORT; + usevault = 1; + break; case 'R': - mode += PCP_MODE_DELETE_KEY; - usevault = 1; - break; + mode += PCP_MODE_DELETE_KEY; + usevault = 1; + break; case 't': - mode += PCP_MODE_TEXT; - usevault = 0; - break; + mode += PCP_MODE_TEXT; + usevault = 0; + break; case 'E': - mode += PCP_MODE_EDIT; - usevault = 1; - break; + mode += PCP_MODE_EDIT; + usevault = 1; + break; case 'e': - mode += PCP_MODE_ENCRYPT; - usevault = 1; - break; + mode += PCP_MODE_ENCRYPT; + usevault = 1; + break; case 'm': - mode += PCP_MODE_ENCRYPT_ME; - break; + mode += PCP_MODE_ENCRYPT_ME; + break; case 'd': - mode += PCP_MODE_DECRYPT; - usevault = 1; - break; + mode += PCP_MODE_DECRYPT; + usevault = 1; + break; case 'z': case 'a': - armor = 1; - break; + armor = 1; + break; case 'Z': - armor = 2; - break; + armor = 2; + break; case 'A': - anon = 1; - break; + anon = 1; + break; case 'F': - if(strncmp(optarg, "pbp", 3) == 0) { - exportformat = EXP_FORMAT_PBP; - } - else if(strncmp(optarg, "pcp", 3) == 0) { - exportformat = EXP_FORMAT_NATIVE; - } - else { - fprintf(stderr, "WARN: Unknown export format specified, using native\n"); - exportformat = EXP_FORMAT_NATIVE; - } - break; + if(strncmp(optarg, "pbp", 3) == 0) { + exportformat = EXP_FORMAT_PBP; + } + else if(strncmp(optarg, "pcp", 3) == 0) { + exportformat = EXP_FORMAT_NATIVE; + } + else { + fprintf(stderr, "WARN: Unknown export format specified, using native\n"); + exportformat = EXP_FORMAT_NATIVE; + } + break; case 'j': #ifdef HAVE_JSON - ptx->json = 1; + ptx->json = 1; #else - fprintf(stderr, "WARN: -j set, but no JSON support compiled in. Recompile with --with-json\n"); + fprintf(stderr, "WARN: -j set, but no JSON support compiled in. Recompile with --with-json\n"); #endif - break; + break; case 'g': - mode += PCP_MODE_SIGN; - usevault = 1; - break; + mode += PCP_MODE_SIGN; + usevault = 1; + break; case 'c': - mode += PCP_MODE_VERIFY; - usevault = 1; - break; + mode += PCP_MODE_VERIFY; + usevault = 1; + break; case 'C': - mode += PCP_MODE_CHECKSUM; - break; + mode += PCP_MODE_CHECKSUM; + break; case 'f': - sigfile = ucmalloc(strlen(optarg)+1); - strncpy(sigfile, optarg, strlen(optarg)+1); - detach = 1; - break; + sigfile = ucmalloc(strlen(optarg)+1); + strncpy(sigfile, optarg, strlen(optarg)+1); + detach = 1; + break; case 'V': - strncpy(vaultfile, optarg, 1024); - break; + strncpy(vaultfile, optarg, 1024); + break; case 'O': - if(strncmp(optarg, "-", 2) > 0) { - outfile = ucmalloc(strlen(optarg)+1); - strncpy(outfile, optarg, strlen(optarg)+1); - } - break; + if(strncmp(optarg, "-", 2) > 0) { + outfile = ucmalloc(strlen(optarg)+1); + strncpy(outfile, optarg, strlen(optarg)+1); + } + break; case 'I': - if(strncmp(optarg, "-", 2) > 0) { - infile = ucmalloc(strlen(optarg)+1); - strncpy(infile, optarg, strlen(optarg)+1); - } - break; + if(strncmp(optarg, "-", 2) > 0) { + infile = ucmalloc(strlen(optarg)+1); + strncpy(infile, optarg, strlen(optarg)+1); + } + break; case 'X': - xpassfile = ucmalloc(strlen(optarg)+1); - strncpy(xpassfile, optarg, strlen(optarg)+1); - xpf = 1; - break; + xpassfile = ucmalloc(strlen(optarg)+1); + strncpy(xpassfile, optarg, strlen(optarg)+1); + xpf = 1; + break; case 'i': - keyid = ucmalloc(19); - strncpy(keyid, optarg, 19); - useid = 1; - break; + keyid = ucmalloc(19); + strncpy(keyid, optarg, 19); + useid = 1; + break; case 'x': - xpass = smalloc(strlen(optarg)+1); - strncpy(xpass, optarg, strlen(optarg)+1); - break; + xpass = smalloc(strlen(optarg)+1); + strncpy(xpass, optarg, strlen(optarg)+1); + break; case LONG_EXTPASS: - askpass = malloc(strlen(optarg)+1); - strncpy(askpass, optarg, strlen(optarg)+1); - break; + askpass = malloc(strlen(optarg)+1); + strncpy(askpass, optarg, strlen(optarg)+1); + break; case 'r': - p_add(&recipient, optarg); - userec = 1; - break; + p_add(&recipient, optarg); + userec = 1; + break; case 'M': - p_add_me(&recipient); - userec = 1; - break; - + p_add_me(&recipient); + userec = 1; + break; case 'D': - debug = 1; - break; + debug = 1; + break; case '0': - version(); + version(); case 'v': - ptx->verbose = 1; - break; + ptx->verbose = 1; + break; case 'h': - usage(0); + usage(0); default: - usage(1); + usage(1); } } @@ -350,65 +349,65 @@ int main (int argc, char **argv) { switch (mode) { case PCP_MODE_DECRYPT: if(infile == NULL) { - infile = extra; - useex = 1; + infile = extra; + useex = 1; } break; case PCP_MODE_ENCRYPT: if(infile == NULL) { - infile = extra; - useex = 1; + infile = extra; + useex = 1; } else if(userec == 0 && useid == 0) { - userec = 1; - int i; - for (i=0; i 3) { - /* expected fail */ - ret = TRUE; + /* expected fail */ + ret = TRUE; } else { - /* expected ok */ - ret = FALSE; + /* expected ok */ + ret = FALSE; } } else { if(mode > 3) { - /* expected fail */ - ret = FALSE; + /* expected fail */ + ret = FALSE; } else { - /* expected ok */ - ret = TRUE; + /* expected ok */ + ret = TRUE; } } } @@ -143,7 +143,7 @@ int main(int argc, char **argv) { if(mode <= 3 && memcmp(back, clear, 256) != 0) { ret = FALSE; if(ptx->pcp_errset == 0) { - fatal(ptx, "decoded content doesn't match\n"); + fatal(ptx, "decoded content doesn't match\n"); } } } diff --git a/tests/unittests.cfg b/tests/unittests.cfg index cc854a6..b7d94dc 100644 --- a/tests/unittests.cfg +++ b/tests/unittests.cfg @@ -103,7 +103,7 @@ include keys.cfg Dexter Morgan dxmorg@florida.cops.gov EOF - expect = /Generated new secret key/ + expect = /Generated new secret key/ @@ -113,7 +113,7 @@ Dexter Morgan dxmorg@florida.cops.gov no EOF - expect = /weak passphrase/ + expect = /weak passphrase/