diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c index a500e80..726130a 100644 --- a/pclsync/pcryptofolder.c +++ b/pclsync/pcryptofolder.c @@ -1337,6 +1337,7 @@ int pcryptofolder_unlock(const char *password) { } } + // load the public key debug(D_NOTICE, "trying to load public key"); pubkey = prsa_load_public(rsapub, rsapublen); if (pubkey == PRSA_INVALID) { @@ -1349,8 +1350,7 @@ int pcryptofolder_unlock(const char *password) { } debug(D_NOTICE, "successfully loaded public key"); - // generate the symmetric key based on the given password and the downloaded - // private key + // decode the private key debug(D_NOTICE, "generating symmetric key"); aeskey = psymkey_generate(password, PAES_KEY_SIZE + PAES_BLOCK_SIZE, salt, saltlen, iterations); enc = pcrypto_ctr_encdec_create(aeskey); @@ -1359,9 +1359,9 @@ int pcryptofolder_unlock(const char *password) { memcpy(rsaprivdec, rsapriv, rsaprivlen); pcrypto_ctr_encdec_encode(enc, rsaprivdec, rsaprivlen, 0); pcrypto_ctr_encdec_free(enc); - debug(D_NOTICE, "successfully generated symmetric key"); - + debug(D_NOTICE, "successfully decoded private key"); + // load the decoded private key debug(D_NOTICE, "trying to load private key"); privkey = prsa_load_private(rsaprivdec, rsaprivlen); pssl_cleanup(rsaprivdec, rsaprivlen); diff --git a/pclsync/plibs.h b/pclsync/plibs.h index aca3c17..ed9d289 100644 --- a/pclsync/plibs.h +++ b/pclsync/plibs.h @@ -71,10 +71,6 @@ #undef assert #endif -#define PSYNC_SSL_DEBUG_LEVEL \ - 0 /* Please make sure this setting is always set to 0 for release builds !!! \ - Possible values are in the range [0, 5] */ - #define debug(level, ...) \ do { \ if (level <= DEBUG_LEVEL) \ diff --git a/pclsync/prpc.c b/pclsync/prpc.c index c35d607..213f263 100644 --- a/pclsync/prpc.c +++ b/pclsync/prpc.c @@ -55,7 +55,7 @@ int overlays_running = 1; int callbacks_running = 1; -void psync_overlay_main_loop() { +void prpc_proc() { struct sockaddr_un addr; int fd, cl; @@ -89,7 +89,7 @@ void psync_overlay_main_loop() { // handle the request in a new thread prun_thread1("Pipe request handle routine", - psync_overlay_handle_request, // thread proc + prpc_proc_handle, // thread proc (LPVOID)&cl // thread parameter ); } @@ -97,7 +97,7 @@ void psync_overlay_main_loop() { return; } -void psync_overlay_handle_request(void *lpvParam) { +void prpc_proc_handle(void *lpvParam) { int *sockfd; // pcloud socket file descriptor int rc; // bytes read / written per iteration int readbytes; // total bytes read from request @@ -134,7 +134,7 @@ void psync_overlay_handle_request(void *lpvParam) { request = (rpc_message_t *)rqbuf; response = (rpc_message_t *)malloc(POVERLAY_BUFSIZE); if (request) { - psync_overlay_get_response(request, response); + prpc_get_response(request, response); ssize_t total_size = sizeof(uint32_t) + sizeof(uint64_t) + response->length; ssize_t bytes_written = write(*sockfd, response, total_size); @@ -168,14 +168,14 @@ static int callbacks_size = 15; static const int calbacks_lower_band = 20; // registers an overlay callback for a given message type. -int psync_overlay_register_callback(int msgtype, poverlay_callback callback) { +int prpc_cb_register(int msgtype, poverlay_callback callback) { poverlay_callback *callbacks_old = callbacks; int callbacks_size_old = callbacks_size; if (msgtype < calbacks_lower_band) return -1; if (msgtype > (calbacks_lower_band + callbacks_size)) { callbacks_size = msgtype - calbacks_lower_band + 1; - psync_overlay_init_callbacks(); + prpc_cb_init(); memcpy(callbacks, callbacks_old, callbacks_size_old * sizeof(poverlay_callback)); psync_free(callbacks_old); @@ -184,7 +184,7 @@ int psync_overlay_register_callback(int msgtype, poverlay_callback callback) { return 0; } -void psync_overlay_init_callbacks() { +void prpc_cb_init() { callbacks = (poverlay_callback *)psync_malloc(sizeof(poverlay_callback) * callbacks_size); memset(callbacks, 0, sizeof(poverlay_callback) * callbacks_size); @@ -254,8 +254,7 @@ static void psync_overlay_get_overlay_response(rpc_message_t *request, } } -void psync_overlay_get_response(rpc_message_t *request, - rpc_message_t *response) { +void prpc_get_response(rpc_message_t *request, rpc_message_t *response) { const char *dbgmsg; // debug messages size_t value_avail; // space available to store value (flexible array) @@ -297,9 +296,9 @@ void psync_overlay_get_response(rpc_message_t *request, } } -void psync_overlay_stop_overlays() { overlays_running = 0; } -void psync_overlay_start_overlays() { overlays_running = 1; } -void psync_overlay_stop_overlay_callbacks() { callbacks_running = 0; } -void psync_overlay_start_overlay_callbacks() { callbacks_running = 1; } -int psync_overlay_overlays_running() { return overlays_running; } -int psync_overlay_callbacks_running() { return callbacks_running; } +void prpc_stop() { overlays_running = 0; } +void prpc_start() { overlays_running = 1; } +void prpc_cb_stop() { callbacks_running = 0; } +void prpc_cb_start() { callbacks_running = 1; } +int prpc_started() { return overlays_running; } +int prpc_cb_started() { return callbacks_running; } diff --git a/pclsync/prpc.h b/pclsync/prpc.h index 154c627..f7a81a7 100644 --- a/pclsync/prpc.h +++ b/pclsync/prpc.h @@ -33,6 +33,10 @@ #ifndef POVERLAY_H #define POVERLAY_H +#ifdef __cplusplus +extern "C" { +#endif + #ifndef VOID #define VOID void #endif @@ -56,17 +60,21 @@ typedef struct _rpc_message_t { char value[]; } rpc_message_t; -void psync_overlay_main_loop(VOID); -void psync_overlay_handle_request(LPVOID); -void psync_overlay_get_response(rpc_message_t*, rpc_message_t*); -void psync_overlay_stop_overlays(); -void psync_overlay_start_overlays(); -void psync_overlay_stop_overlay_callbacks(); -void psync_overlay_start_overlay_callbacks(); -int psync_overlay_overlays_running(); -int psync_overlay_callbacks_running(); +void prpc_proc(VOID); +void prpc_proc_handle(LPVOID); +void prpc_get_response(rpc_message_t*, rpc_message_t*); +void prpc_stop(); +void prpc_start(); +void prpc_cb_stop(); +void prpc_cb_start(); +int prpc_started(); +int prpc_cb_started(); -void psync_overlay_init_callbacks(); -int psync_overlay_register_callback(int, poverlay_callback); +void prpc_cb_init(); +int prpc_cb_register(int, poverlay_callback); + +#ifdef __cplusplus +} +#endif #endif // POVERLAY_H diff --git a/pclsync/pshm.c b/pclsync/pshm.c index 1ebe478..bdfa85a 100644 --- a/pclsync/pshm.c +++ b/pclsync/pshm.c @@ -21,6 +21,7 @@ key_t pshm_get_key() { return (key_t)-1; } snprintf(path, sizeof(path), "%s/.pcloud/data.db", home); + psync_free(home); return ftok(path, 'A'); } diff --git a/pclsync/pssl.c b/pclsync/pssl.c index 7bdc875..88c631e 100644 --- a/pclsync/pssl.c +++ b/pclsync/pssl.c @@ -216,6 +216,13 @@ static void set_errno(pssl_connection_t *conn, int err) { } } +static void log_ssl_err(int loglevel, int errnum, const char *fmt, ...) { + char ebuf[100]; + mbedtls_strerror(errnum, ebuf, sizeof(ebuf)); + debug(D_ERROR, "%s", fmt); +} + + void paes_2blk_encode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst) { mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT, src, dst); mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT, src + PAES_BLOCK_SIZE, @@ -403,6 +410,35 @@ pssl_rsaprivkey_t prsa_load_private(const unsigned char *keydata, size_t keylen) } } +pssl_rsaprivkey_t prsa_load_private2(const unsigned char *keydata, size_t keylen, pssl_symkey_t *symkey) { + mbedtls_pk_context pkctx; + mbedtls_rsa_context *rsactx; + int ret; + mbedtls_pk_init(&pkctx); + + ret = mbedtls_pk_parse_key(&pkctx, keydata, keylen, symkey->key, symkey->keylen, mbedtls_ctr_drbg_random, &psync_mbed_rng.rnd); + if (unlikely(ret)) { + char ebuf[100]; + mbedtls_strerror(ret, ebuf, sizeof(ebuf)); + debug(D_WARNING, "failed to parse private key: %s (-0x%04x)", ebuf, (unsigned int) -ret); + return PRSA_INVALID; + } + + rsactx = psync_new(mbedtls_rsa_context); + mbedtls_rsa_init(rsactx); + mbedtls_rsa_set_padding(rsactx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + ret = mbedtls_rsa_copy(rsactx, mbedtls_pk_rsa(pkctx)); + mbedtls_pk_free(&pkctx); + if (unlikely(ret)) { + debug(D_WARNING, "rsa_copy failed with code %d", ret); + mbedtls_rsa_free(rsactx); + psync_free(rsactx); + return PRSA_INVALID; + } else { + return rsactx; + } +} + pssl_rsapubkey_t prsa_load_public(const unsigned char *keydata, size_t keylen) { mbedtls_pk_context ctx; mbedtls_rsa_context *rsa; @@ -503,7 +539,7 @@ int pssl_finish(pssl_connection_t *sslconn, const char *hostname) { save_session(conn); return PSSL_SUCCESS; } else { - debug(D_ERROR, "handshake failed, return code was %d", ret); + log_ssl_err(D_WARNING, ret, "handshake failed: %s (-0x%04x)", (unsigned int) -ret); } set_errno(conn, ret); if (likely_log(ret == MBEDTLS_ERR_SSL_WANT_READ || @@ -537,7 +573,7 @@ int pssl_init() { mbedtls_ctr_drbg_init(&psync_mbed_rng.rnd); if ((result = mbedtls_ctr_drbg_seed(&psync_mbed_rng.rnd, mbedtls_entropy_func, &psync_mbed_entropy, NULL, 0))) { - debug(D_ERROR, "mbedtls_ctr_drbg_seed failed with return code %d", result); + log_ssl_err(D_ERROR, result, "mbedtls_ctr_drbg_seed failed with return code %d", result); return PRINT_RETURN(-1); } @@ -547,8 +583,7 @@ int pssl_init() { (unsigned char *)psync_ssl_trusted_certs[i], 1 + strlen(psync_ssl_trusted_certs[i])); if (result) { - debug(D_ERROR, "failed to load certificate %lu, got result %d", - (unsigned long)i, result); + log_ssl_err(D_ERROR, result, "failed to load certificate %lu, got result %d", (unsigned long)i, result); } } @@ -578,8 +613,7 @@ int pssl_open(int sock, pssl_connection_t **sslconn, const char *hostname) { if ((ret = mbedtls_ssl_config_defaults(&conn->cfg, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT)) != 0) { - debug(D_ERROR, - "Failed to set SSL config defaults: mbedtls_ssl_config_defaults returned %d", ret); + log_ssl_err(D_ERROR, ret, "Failed to set SSL config defaults"); goto err0; } diff --git a/pclsync/pssl.h b/pclsync/pssl.h index eee1b42..839b528 100644 --- a/pclsync/pssl.h +++ b/pclsync/pssl.h @@ -64,6 +64,9 @@ #define PSYMKEY_INVALID NULL #define PSYMKEY_INVALID_ENC NULL +// set to 0 for release; valid range [0..5] +#define PSSL_DEBUG_LEVEL 5 + // FIXME: fucking macros... #define psync_sha1(data, datalen, checksum) \ mbedtls_sha1(data, datalen, checksum) @@ -146,6 +149,7 @@ pssl_context_t prsa_generate(int bits); pssl_rsaprivkey_t prsa_get_private(pssl_context_t rsa); pssl_rsapubkey_t prsa_get_public(pssl_context_t rsa); pssl_rsaprivkey_t prsa_load_private(const unsigned char *keydata, size_t keylen); +pssl_rsaprivkey_t prsa_load_private2(const unsigned char *keydata, size_t keylen, pssl_symkey_t *symkey); pssl_rsapubkey_t prsa_load_public(const unsigned char *keydata, size_t keylen); pssl_signature_t prsa_signature(pssl_rsaprivkey_t rsa, const unsigned char *data); diff --git a/pclsync/psynclib.c b/pclsync/psynclib.c index 5a1a3e5..ddb4ed5 100644 --- a/pclsync/psynclib.c +++ b/pclsync/psynclib.c @@ -228,16 +228,6 @@ static void ssl_debug_cb(void *ctx, int level, const char *msg, int TODO1, TODO1); // trying to figure out what these are... } -void psync_set_ssl_debug_callback(psync_ssl_debug_callback_t cb) { - if (cb) { - pssl_log_level(PSYNC_SSL_DEBUG_LEVEL); - pssl_debug_cb(cb, NULL); - } else { - pssl_log_level(0); - pssl_debug_cb(NULL, NULL); - } -} - void psync_set_apiserver(const char *binapi, uint32_t locationid) { if (binapi) { psync_apipool_set_server(binapi); @@ -299,10 +289,12 @@ int psync_init() { pthread_mutex_unlock(&psync_libstate_mutex); } - prun_thread("Overlay main thread", psync_overlay_main_loop); - psync_overlay_init_callbacks(); - if (PSYNC_SSL_DEBUG_LEVEL) - psync_set_ssl_debug_callback(ssl_debug_cb); + prun_thread("rpc main thread", prpc_proc); + prpc_cb_init(); + if (PSSL_DEBUG_LEVEL) { + pssl_log_level(PSSL_DEBUG_LEVEL); + pssl_debug_cb(ssl_debug_cb, NULL); + } return 0; } diff --git a/pclsync/psynclib.h b/pclsync/psynclib.h index d427790..b9f1d2c 100644 --- a/pclsync/psynclib.h +++ b/pclsync/psynclib.h @@ -1618,12 +1618,6 @@ typedef int (*poverlay_callback)(const char *); * synchronize. */ -int psync_overlay_register_callback(int id, poverlay_callback callback); -void psync_overlay_stop_overlays(); -void psync_overlay_start_overlays(); -void psync_overlay_stop_overlay_callbacks(); -void psync_overlay_start_overlay_callbacks(); - int psync_setlanguage(const char *language, char **err); // Update crypto status information from userinfo. diff --git a/pclsync_lib.cpp b/pclsync_lib.cpp index 6285602..0c270c5 100644 --- a/pclsync_lib.cpp +++ b/pclsync_lib.cpp @@ -459,12 +459,12 @@ int clib::pclsync_lib::init() { psync_free(username_old); } - psync_overlay_register_callback(STARTCRYPTO, &clib::pclsync_lib::start_crypto); - psync_overlay_register_callback(STOPCRYPTO, &clib::pclsync_lib::stop_crypto); - psync_overlay_register_callback(FINALIZE, &clib::pclsync_lib::finalize); - psync_overlay_register_callback(LISTSYNC, &clib::pclsync_lib::list_sync_folders); - psync_overlay_register_callback(ADDSYNC, &clib::pclsync_lib::add_sync_folder); - psync_overlay_register_callback(STOPSYNC, &clib::pclsync_lib::remove_sync_folder); + prpc_cb_register(STARTCRYPTO, &clib::pclsync_lib::start_crypto); + prpc_cb_register(STOPCRYPTO, &clib::pclsync_lib::stop_crypto); + prpc_cb_register(FINALIZE, &clib::pclsync_lib::finalize); + prpc_cb_register(LISTSYNC, &clib::pclsync_lib::list_sync_folders); + prpc_cb_register(ADDSYNC, &clib::pclsync_lib::add_sync_folder); + prpc_cb_register(STOPSYNC, &clib::pclsync_lib::remove_sync_folder); return 0; }