lkn
/
pcloudcc-lneely
mirror of https://github.com/lneely/pcloudcc-lneely.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

more cleanup

This commit is contained in:
Levi Neely 2025-03-04 22:15:56 +01:00
parent 2d4f33f5fb
commit 58f09089cd
10 changed files with 94 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pclsync/pcryptofolder.c
View File

@ -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);

4
pclsync/plibs.h
View File

@ -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) \

29
pclsync/prpc.c
View File

@ -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; }

30
pclsync/prpc.h
View File

@ -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

1
pclsync/pshm.c
View File

@ -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');
}

46
pclsync/pssl.c
View File

@ -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;
}

4
pclsync/pssl.h
View File

@ -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);

20
pclsync/psynclib.c
View File

@ -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;
}

6
pclsync/psynclib.h
View File

@ -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.

12
pclsync_lib.cpp
View File

@ -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;
}