From 27f6e313dce3e3d486e09ec3da62217ae5f52162 Mon Sep 17 00:00:00 2001 From: Levi Neely <141506390+lneely@users.noreply.github.com> Date: Tue, 4 Mar 2025 17:29:20 +0100 Subject: [PATCH] type name clarification --- pclsync/pcrypto.c | 10 ++--- pclsync/pcrypto.h | 8 ++-- pclsync/pcryptofolder.c | 84 ++++++++++++++++++++--------------------- pclsync/pp2p.c | 22 +++++------ pclsync/pssl.c | 76 ++++++++++++++++++------------------- pclsync/pssl.h | 68 ++++++++++++++++----------------- 6 files changed, 134 insertions(+), 134 deletions(-) diff --git a/pclsync/pcrypto.c b/pclsync/pcrypto.c index 64bfa18..f081a61 100644 --- a/pclsync/pcrypto.c +++ b/pclsync/pcrypto.c @@ -176,7 +176,7 @@ pssl_symkey_t *pcrypto_key() { pcrypto_ctr_encdec_t pcrypto_ctr_encdec_create(pssl_symkey_t *key) { - psync_aes256_encoder enc; + pssl_encoder_t enc; pcrypto_ctr_encdec_t ret; if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE)) @@ -399,7 +399,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc, pcrypto_textenc_t pcrypto_textenc_create(pssl_symkey_t *key) { - psync_aes256_encoder enc; + pssl_encoder_t enc; pcrypto_textenc_t ret; if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE)) @@ -425,7 +425,7 @@ void pcrypto_textenc_free( pcrypto_textdec_t pcrypto_textdec_create(pssl_symkey_t *key) { - psync_aes256_encoder enc; + pssl_encoder_t enc; pcrypto_textenc_t ret; if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE)) @@ -451,8 +451,8 @@ void pcrypto_textdec_free( pcrypto_sector_encdec_t pcrypto_sec_encdec_create(pssl_symkey_t *key) { - psync_aes256_encoder enc; - psync_aes256_decoder dec; + pssl_encoder_t enc; + pssl_decoder_t dec; pcrypto_sector_encdec_t ret; if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE)) return PSYNC_CRYPTO_INVALID_ENCODER; diff --git a/pclsync/pcrypto.h b/pclsync/pcrypto.h index f5784cb..bbecbdf 100644 --- a/pclsync/pcrypto.h +++ b/pclsync/pcrypto.h @@ -50,7 +50,7 @@ typedef struct { typedef unsigned char pcrypto_sector_auth_t[PSYNC_CRYPTO_AUTH_SIZE]; typedef struct { - psync_aes256_encoder encoder; + pssl_encoder_t encoder; union { long unsigned __aligner; unsigned char iv[PSYNC_AES256_BLOCK_SIZE]; @@ -60,7 +60,7 @@ typedef struct { typedef pcrypto_key_t *pcrypto_ctr_encdec_t; typedef struct { - psync_aes256_encoder encoder; + pssl_encoder_t encoder; unsigned long ivlen; unsigned char iv[]; } pcrypto_key_iv_t; @@ -69,8 +69,8 @@ typedef pcrypto_key_iv_t *pcrypto_textenc_t; typedef pcrypto_key_iv_t *pcrypto_textdec_t; typedef struct { - psync_aes256_encoder encoder; - psync_aes256_decoder decoder; + pssl_encoder_t encoder; + pssl_decoder_t decoder; unsigned long ivlen; unsigned char iv[]; } pcrypto_encdec_iv_t; diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c index 84562ab..80fef6a 100644 --- a/pclsync/pcryptofolder.c +++ b/pclsync/pcryptofolder.c @@ -69,8 +69,8 @@ static const char *crypto_errors[] = {"Success.", "Folder is not encrypted."}; static uint32_t crypto_started_l = 0; -static psync_rsa_publickey_t crypto_pubkey = PSYNC_INVALID_RSA; -static psync_rsa_privatekey_t crypto_privkey = PSYNC_INVALID_RSA; +static pssl_rsapubkey_t crypto_pubkey = PSYNC_INVALID_RSA; +static pssl_rsaprivkey_t crypto_privkey = PSYNC_INVALID_RSA; static pthread_rwlock_t crypto_lock = PTHREAD_RWLOCK_INITIALIZER; static uint32_t crypto_started_un = 0; @@ -372,10 +372,10 @@ int pcryptofolder_setup(const char *password, const char *hint) { privatesha1[PSYNC_SHA1_DIGEST_HEXLEN + 2]; pssl_symkey_t *aeskey; pcrypto_ctr_encdec_t enc; - psync_rsa_t rsa; - psync_rsa_privatekey_t rsaprivate; - psync_rsa_publickey_t rsapublic; - psync_binary_rsa_key_t rsaprivatebin, rsapublicbin; + pssl_context_t rsa; + pssl_rsaprivkey_t rsaprivate; + pssl_rsapubkey_t rsapublic; + pssl_rsabinkey_t rsaprivatebin, rsapublicbin; time_t cryptoexpires; int ret; debug(D_NOTICE, "generating salt"); @@ -496,7 +496,7 @@ int pcryptofolder_get_hint(char **hint) { static int crypto_keys_match() { pssl_symkey_t *key, *deckey; - psync_encrypted_symmetric_key_t enckey; + pssl_enc_symkey_t enckey; int res; debug(D_NOTICE, "trying encrypt/decrypt operation with loaded keys"); key = (pssl_symkey_t *)psync_malloc( @@ -769,7 +769,7 @@ static void set_crypto_err_msg(const binresult *res) { } typedef struct { - psync_encrypted_symmetric_key_t key; + pssl_enc_symkey_t key; psync_folderid_t id; } insert_folder_key_task; @@ -787,7 +787,7 @@ static void save_folder_key_task(void *ptr) { } static void save_folder_key_to_db(psync_folderid_t folderid, - psync_encrypted_symmetric_key_t enckey) { + pssl_enc_symkey_t enckey) { // we are likely holding (few) read locks on the database, so executing here // will deadlock insert_folder_key_task *t; @@ -798,7 +798,7 @@ static void save_folder_key_to_db(psync_folderid_t folderid, } typedef struct { - psync_encrypted_symmetric_key_t key; + pssl_enc_symkey_t key; psync_fileid_t id; uint64_t hash; } insert_file_key_task; @@ -818,7 +818,7 @@ static void save_file_key_task(void *ptr) { } static void save_file_key_to_db(psync_fileid_t fileid, uint64_t hash, - psync_encrypted_symmetric_key_t enckey) { + pssl_enc_symkey_t enckey) { insert_file_key_task *t; t = psync_new(insert_file_key_task); t->key = psymkey_copy(enckey); @@ -827,7 +827,7 @@ static void save_file_key_to_db(psync_fileid_t fileid, uint64_t hash, prun_thread1("save file key to db task", save_file_key_task, t); } -static psync_encrypted_symmetric_key_t +static pssl_enc_symkey_t psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { binparam params[] = {PAPI_STR("auth", psync_my_auth), PAPI_NUM("folderid", folderid)}; @@ -836,7 +836,7 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { const binresult *b64key; uint64_t result; unsigned char *key; - psync_encrypted_symmetric_key_t ret; + pssl_enc_symkey_t ret; size_t keylen; int tries; tries = 0; @@ -844,13 +844,13 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { while (1) { api = psync_apipool_get(); if (!api) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); res = papi_send2(api, "crypto_getfolderkey", params); if (unlikely_log(!res)) { psync_apipool_release_bad(api); if (++tries > 5) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); } else { psync_apipool_release(api); @@ -865,7 +865,7 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { set_crypto_err_msg(res); psync_free(res); psync_process_api_error(result); - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL)); } b64key = papi_find_result2(res, "key", PARAM_STR); @@ -873,7 +873,7 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { &keylen); psync_free(res); if (!key) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); ret = psymkey_alloc(keylen); memcpy(ret->data, key, keylen); @@ -882,7 +882,7 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { return ret; } -static psync_encrypted_symmetric_key_t +static pssl_enc_symkey_t psync_crypto_download_file_enc_key(psync_fileid_t fileid) { binparam params[] = {PAPI_STR("auth", psync_my_auth), PAPI_NUM("fileid", fileid)}; psock_t *api; @@ -890,7 +890,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { const binresult *b64key; uint64_t result; unsigned char *key; - psync_encrypted_symmetric_key_t ret; + pssl_enc_symkey_t ret; size_t keylen; int tries; tries = 0; @@ -898,13 +898,13 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { while (1) { api = psync_apipool_get(); if (!api) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); res = papi_send2(api, "crypto_getfilekey", params); if (unlikely_log(!res)) { psync_apipool_release_bad(api); if (++tries > 5) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); } else { psync_apipool_release(api); @@ -918,7 +918,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { crypto_api_errno = result; set_crypto_err_msg(res); psync_free(res); - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL)); } result = papi_find_result2(res, "hash", PARAM_NUM)->num; @@ -927,7 +927,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { &keylen); psync_free(res); if (!key) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (pssl_enc_symkey_t)err_to_ptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); ret = psymkey_alloc(keylen); memcpy(ret->data, key, keylen); @@ -936,9 +936,9 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { return ret; } -static psync_encrypted_symmetric_key_t +static pssl_enc_symkey_t psync_crypto_get_folder_enc_key(psync_folderid_t folderid) { - psync_encrypted_symmetric_key_t enckey; + pssl_enc_symkey_t enckey; psync_sql_res *res; psync_variant_row row; const char *ckey; @@ -957,10 +957,10 @@ psync_crypto_get_folder_enc_key(psync_folderid_t folderid) { return psync_crypto_download_folder_enc_key(folderid); } -static psync_encrypted_symmetric_key_t +static pssl_enc_symkey_t psync_crypto_get_file_enc_key(psync_fileid_t fileid, uint64_t hash, int nonetwork) { - psync_encrypted_symmetric_key_t enckey; + pssl_enc_symkey_t enckey; psync_sql_res *res; psync_variant_row row; const char *ckey; @@ -981,7 +981,7 @@ psync_crypto_get_file_enc_key(psync_fileid_t fileid, uint64_t hash, debug(D_NOTICE, "delaying key download for file %lu", (unsigned long)fileid); return ( - psync_encrypted_symmetric_key_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER; + pssl_enc_symkey_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER; } else return psync_crypto_download_file_enc_key(fileid); } @@ -989,7 +989,7 @@ psync_crypto_get_file_enc_key(psync_fileid_t fileid, uint64_t hash, static pssl_symkey_t *psync_crypto_get_folder_symkey_locked(psync_folderid_t folderid) { char buff[16]; - psync_encrypted_symmetric_key_t enckey; + pssl_enc_symkey_t enckey; pssl_symkey_t *symkey; psync_get_string_id(buff, "FKEY", folderid); symkey = (pssl_symkey_t *)pcache_get(buff); @@ -1012,7 +1012,7 @@ static pssl_symkey_t *psync_crypto_get_file_symkey_locked(psync_fileid_t fileid, uint64_t hash, int nonetwork) { char buff[32]; - psync_encrypted_symmetric_key_t enckey; + pssl_enc_symkey_t enckey; pssl_symkey_t *symkey; psync_get_string_id2(buff, "DKEY", fileid, hash); symkey = (pssl_symkey_t *)pcache_get(buff); @@ -1025,7 +1025,7 @@ static pssl_symkey_t return (pssl_symkey_t *)enckey; if (nonetwork && enckey == - (psync_encrypted_symmetric_key_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER) + (pssl_enc_symkey_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER) return (pssl_symkey_t *)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER; symkey = psymkey_decrypt_lock(&crypto_privkey, &enckey); @@ -1543,7 +1543,7 @@ pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid, binresult *res) { const binresult *b64key; unsigned char *key; - psync_encrypted_symmetric_key_t esym; + pssl_enc_symkey_t esym; pssl_symkey_t *symkey; pcrypto_sector_encdec_t enc; uint64_t hash; @@ -1666,7 +1666,7 @@ static int get_name_for_folder_locked(psync_folderid_t folderid, int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name, const char **err, const char *b64key, size_t b64keylen, - psync_encrypted_symmetric_key_t encsym, + pssl_enc_symkey_t encsym, psync_folderid_t *newfolderid) { binparam params[] = {PAPI_STR("auth", psync_my_auth), PAPI_NUM("folderid", folderid), @@ -1718,7 +1718,7 @@ int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name, char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid, uint64_t hash, size_t *keylen) { - psync_encrypted_symmetric_key_t encsym; + pssl_enc_symkey_t encsym; char *ret; if (fileid < 0) return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_FILE_NOT_FOUND)); @@ -1731,7 +1731,7 @@ char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid, } char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) { - psync_encrypted_symmetric_key_t encsym; + pssl_enc_symkey_t encsym; sym_key_ver1 sym; char *ret; if (!crypto_started_un) @@ -1760,7 +1760,7 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) { char *pcryptofolder_filencoder_key_newplain( uint32_t flags, size_t *keylen, pssl_symkey_t **deckey) { - psync_encrypted_symmetric_key_t encsym; + pssl_enc_symkey_t encsym; sym_key_ver1 sym; char *ret; if (!crypto_started_un) @@ -1791,7 +1791,7 @@ char *pcryptofolder_filencoder_key_newplain( int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name, const char **err, psync_folderid_t *newfolderid) { sym_key_ver1 sym; - psync_encrypted_symmetric_key_t encsym; + pssl_enc_symkey_t encsym; unsigned char *b64encsym; size_t b64encsymlen; char *ename; @@ -1836,11 +1836,11 @@ int psync_pcloud_crypto_reencode_key( const unsigned char *rsapub, size_t rsapublen, const unsigned char *rsapriv, size_t rsaprivlen, const char *oldpassphrase, const char *newpassphrase, uint32_t flags, char **privenc, char **sign) { - psync_rsa_publickey_t pub; - psync_rsa_privatekey_t priv; + pssl_rsapubkey_t pub; + pssl_rsaprivkey_t priv; unsigned char *newpriv; unsigned char newprivsha[PSYNC_SHA256_DIGEST_LEN]; - psync_rsa_signature_t rsasign; + pssl_signature_t rsasign; size_t newprivlen, dummy; if (unlikely(rsapublen <= sizeof(uint32_t) || rsaprivlen <= sizeof(uint32_t))) goto err_bk_0; @@ -1966,12 +1966,12 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags, char **privenc, char **sign) { unsigned char *newpriv; priv_key_ver1 *rsapriv_struct; - psync_binary_rsa_key_t rsapriv; + pssl_rsabinkey_t rsapriv; pcrypto_ctr_encdec_t enc; pssl_symkey_t *aeskey; size_t rsaprivlen, dummy; unsigned char newprivsha[PSYNC_SHA256_DIGEST_LEN]; - psync_rsa_signature_t rsasign; + pssl_signature_t rsasign; rsapriv = prsa_binary_private(crypto_privkey); if (rsapriv == PSYNC_INVALID_RSA) goto err_nm_0; diff --git a/pclsync/pp2p.c b/pclsync/pp2p.c index 6f087fe..b1e3199 100644 --- a/pclsync/pp2p.c +++ b/pclsync/pp2p.c @@ -116,9 +116,9 @@ static const uint32_t requiredstatuses[] = { static struct sockaddr_storage paddr; static socklen_t paddrlen; -static psync_rsa_publickey_t pubkey = PSYNC_INVALID_RSA; -static psync_rsa_privatekey_t privkey = PSYNC_INVALID_RSA; -static psync_binary_rsa_key_t pubkeybin = PSYNC_INVALID_BIN_RSA; +static pssl_rsapubkey_t pubkey = PSYNC_INVALID_RSA; +static pssl_rsaprivkey_t privkey = PSYNC_INVALID_RSA; +static pssl_rsabinkey_t pubkeybin = PSYNC_INVALID_BIN_RSA; PSYNC_PURE static const char *get_addr(void *addr) { if (((struct sockaddr_in *)addr)->sin_family == AF_INET) @@ -319,10 +319,10 @@ static int check_token(char *token, uint32_t tlen, unsigned char *key, static void psync_p2p_tcphandler(void *ptr) { packet_get packet; psync_fileid_t localfileid; - psync_binary_rsa_key_t binpubrsa; - psync_rsa_publickey_t pubrsa; + pssl_rsabinkey_t binpubrsa; + pssl_rsapubkey_t pubrsa; pssl_symkey_t *aeskey; - psync_encrypted_symmetric_key_t encaeskey; + pssl_enc_symkey_t encaeskey; pcrypto_ctr_encdec_t encoder; char *token, *localpath; uint64_t off; @@ -570,10 +570,10 @@ static int psync_p2p_check_rsa() { static pthread_mutex_t rsa_lock = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&rsa_lock); if (privkey == PSYNC_INVALID_RSA) { - psync_rsa_t rsa; - psync_rsa_privatekey_t rsapriv; - psync_rsa_publickey_t rsapub; - psync_binary_rsa_key_t rsapubbin; + pssl_context_t rsa; + pssl_rsaprivkey_t rsapriv; + pssl_rsapubkey_t rsapub; + pssl_rsabinkey_t rsapubbin; debug(D_NOTICE, "generating %ubit RSA key", PSYNC_P2P_RSA_SIZE); rsa = prsa_generate(PSYNC_P2P_RSA_SIZE); debug(D_NOTICE, "key generated"); @@ -652,7 +652,7 @@ static int psync_p2p_download(int sock, psync_fileid_t fileid, const char *filename) { uint32_t keylen = 0, enctype = 0; pssl_symkey_t *key; - psync_encrypted_symmetric_key_t ekey; + pssl_enc_symkey_t ekey; pcrypto_ctr_encdec_t decoder; psync_hash_ctx hashctx; uint64_t off; diff --git a/pclsync/pssl.c b/pclsync/pssl.c index 2d048df..ee43251 100644 --- a/pclsync/pssl.c +++ b/pclsync/pssl.c @@ -216,19 +216,19 @@ static void set_errno(ssl_connection_t *conn, int err) { } } -void paes_2blk_encode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) { +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 + PSYNC_AES256_BLOCK_SIZE, dst + PSYNC_AES256_BLOCK_SIZE); } -void paes_2blk_decode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) { +void paes_2blk_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst) { mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src, dst); mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src + PSYNC_AES256_BLOCK_SIZE, dst + PSYNC_AES256_BLOCK_SIZE); } -void paes_4blk_xor_decode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor) { +void paes_4blk_xor_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor) { unsigned long i; mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src, dst); mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src + PSYNC_AES256_BLOCK_SIZE, @@ -243,15 +243,15 @@ void paes_4blk_xor_decode(psync_aes256_decoder enc, const unsigned char *src, un ((unsigned long *)dst)[i] ^= ((unsigned long *)bxor)[i]; } -void paes_blk_encode(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst) { +void paes_blk_encode(pssl_encoder_t enc, const unsigned char *src, unsigned char *dst) { mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT, src, dst); } -void paes_blk_decode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) { +void paes_blk_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst) { mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src, dst); } -psync_aes256_encoder paes_decoder_create(pssl_symkey_t *key) { +pssl_encoder_t paes_decoder_create(pssl_symkey_t *key) { mbedtls_aes_context *aes; assert(key->keylen >= PSYNC_AES256_KEY_SIZE); aes = psync_new(mbedtls_aes_context); @@ -259,12 +259,12 @@ psync_aes256_encoder paes_decoder_create(pssl_symkey_t *key) { return aes; } -void paes_decoder_free(psync_aes256_encoder aes) { +void paes_decoder_free(pssl_encoder_t aes) { pssl_cleanup(aes, sizeof(mbedtls_aes_context)); psync_free(aes); } -psync_aes256_encoder paes_encoder_create(pssl_symkey_t *key) { +pssl_encoder_t paes_encoder_create(pssl_symkey_t *key) { mbedtls_aes_context *aes; assert(key->keylen >= PSYNC_AES256_KEY_SIZE); aes = psync_new(mbedtls_aes_context); @@ -272,19 +272,19 @@ psync_aes256_encoder paes_encoder_create(pssl_symkey_t *key) { return aes; } -void paes_encoder_free(psync_aes256_encoder aes) { +void paes_encoder_free(pssl_encoder_t aes) { pssl_cleanup(aes, sizeof(mbedtls_aes_context)); psync_free(aes); } -void prsa_binary_free(psync_binary_rsa_key_t bin) { +void prsa_binary_free(pssl_rsabinkey_t bin) { encdata_free(bin); } -psync_binary_rsa_key_t prsa_binary_private(psync_rsa_privatekey_t rsa) { +pssl_rsabinkey_t prsa_binary_private(pssl_rsaprivkey_t rsa) { unsigned char buff[4096]; mbedtls_pk_context ctx; - psync_binary_rsa_key_t ret; + pssl_rsabinkey_t ret; int len; mbedtls_pk_init(&ctx); if (mbedtls_pk_setup(&ctx, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) || @@ -302,10 +302,10 @@ psync_binary_rsa_key_t prsa_binary_private(psync_rsa_privatekey_t rsa) { return ret; } -psync_binary_rsa_key_t prsa_binary_public(psync_rsa_publickey_t rsa) { +pssl_rsabinkey_t prsa_binary_public(pssl_rsapubkey_t rsa) { unsigned char buff[4096], *p; mbedtls_pk_context ctx; - psync_binary_rsa_key_t ret; + pssl_rsabinkey_t ret; int len; mbedtls_pk_init(&ctx); if (mbedtls_pk_setup(&ctx, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) || @@ -323,20 +323,20 @@ psync_binary_rsa_key_t prsa_binary_public(psync_rsa_publickey_t rsa) { return ret; } -void prsa_free(psync_rsa_t rsa) { +void prsa_free(pssl_context_t rsa) { mbedtls_rsa_free(rsa); psync_free(rsa); } -void prsa_free_private(psync_rsa_privatekey_t key) { +void prsa_free_private(pssl_rsaprivkey_t key) { prsa_free(key); } -void prsa_free_public(psync_rsa_publickey_t key) { +void prsa_free_public(pssl_rsapubkey_t key) { prsa_free(key); } -psync_rsa_t prsa_generate(int bits) { +pssl_context_t prsa_generate(int bits) { mbedtls_rsa_context *ctx; ctx = psync_new(mbedtls_rsa_context); mbedtls_rsa_init(ctx); @@ -350,7 +350,7 @@ psync_rsa_t prsa_generate(int bits) { return ctx; } -psync_rsa_privatekey_t prsa_get_private(psync_rsa_t rsa) { +pssl_rsaprivkey_t prsa_get_private(pssl_context_t rsa) { mbedtls_rsa_context *ctx; ctx = psync_new(mbedtls_rsa_context); mbedtls_rsa_init(ctx); @@ -363,9 +363,9 @@ psync_rsa_privatekey_t prsa_get_private(psync_rsa_t rsa) { return ctx; } -psync_rsa_publickey_t prsa_get_public(psync_rsa_t rsa) { - psync_binary_rsa_key_t bin; - psync_rsa_publickey_t ret; +pssl_rsapubkey_t prsa_get_public(pssl_context_t rsa) { + pssl_rsabinkey_t bin; + pssl_rsapubkey_t ret; bin = prsa_binary_public(rsa); if (bin == PSYNC_INVALID_BIN_RSA) return PSYNC_INVALID_RSA; @@ -374,7 +374,7 @@ psync_rsa_publickey_t prsa_get_public(psync_rsa_t rsa) { return ret; } -psync_rsa_privatekey_t prsa_load_private(const unsigned char *keydata, size_t keylen) { +pssl_rsaprivkey_t prsa_load_private(const unsigned char *keydata, size_t keylen) { mbedtls_pk_context pkctx; mbedtls_rsa_context *rsactx; int ret; @@ -403,7 +403,7 @@ psync_rsa_privatekey_t prsa_load_private(const unsigned char *keydata, size_t ke } } -psync_rsa_publickey_t prsa_load_public(const unsigned char *keydata, size_t keylen) { +pssl_rsapubkey_t prsa_load_public(const unsigned char *keydata, size_t keylen) { mbedtls_pk_context ctx; mbedtls_rsa_context *rsa; int ret; @@ -431,16 +431,16 @@ psync_rsa_publickey_t prsa_load_public(const unsigned char *keydata, size_t keyl } } -psync_rsa_signature_t prsa_signature(psync_rsa_privatekey_t rsa, const unsigned char *data) { - psync_rsa_signature_t ret; +pssl_signature_t prsa_signature(pssl_rsaprivkey_t rsa, const unsigned char *data) { + pssl_signature_t ret; int padding, hash_id; size_t rsalen; rsalen = mbedtls_rsa_get_len(rsa); - ret = (psync_rsa_signature_t)psync_malloc( + ret = (pssl_signature_t)psync_malloc( offsetof(pssl_symkey_t, key) + rsalen); if (!ret) - return (psync_rsa_signature_t)(void *)PERROR_NO_MEMORY; + return (pssl_signature_t)(void *)PERROR_NO_MEMORY; ret->datalen = rsalen; padding = mbedtls_rsa_get_padding_mode(rsa); hash_id = mbedtls_rsa_get_md_alg(rsa); @@ -450,7 +450,7 @@ psync_rsa_signature_t prsa_signature(psync_rsa_privatekey_t rsa, const unsigned PSYNC_SHA256_DIGEST_LEN, data, ret->data)) { free(ret); mbedtls_rsa_set_padding(rsa, padding, hash_id); - return (psync_rsa_signature_t)(void *)PSYNC_CRYPTO_NOT_STARTED; + return (pssl_signature_t)(void *)PSYNC_CRYPTO_NOT_STARTED; } mbedtls_rsa_set_padding(rsa, padding, hash_id); return ret; @@ -680,15 +680,15 @@ int pssl_write(ssl_connection_t *sslconn, const void *buf, int num) { return PSYNC_SSL_FAIL; } -psync_encrypted_symmetric_key_t psymkey_alloc(size_t len) { - psync_encrypted_symmetric_key_t ret; +pssl_enc_symkey_t psymkey_alloc(size_t len) { + pssl_enc_symkey_t ret; ret = psync_malloc(offsetof(pssl_enc_data_t, data) + len); ret->datalen = len; return ret; } -psync_encrypted_symmetric_key_t psymkey_copy(psync_encrypted_symmetric_key_t src) { - psync_encrypted_symmetric_key_t ret; +pssl_enc_symkey_t psymkey_copy(pssl_enc_symkey_t src) { + pssl_enc_symkey_t ret; ret = psync_malloc(offsetof(pssl_enc_data_t, data) + src->datalen); ret->datalen = src->datalen; @@ -696,7 +696,7 @@ psync_encrypted_symmetric_key_t psymkey_copy(psync_encrypted_symmetric_key_t src return ret; } -pssl_symkey_t *psymkey_decrypt(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen) { +pssl_symkey_t *psymkey_decrypt(pssl_rsaprivkey_t rsa, const unsigned char *data, size_t datalen) { unsigned char buff[2048]; pssl_symkey_t *ret; size_t len; @@ -712,7 +712,7 @@ pssl_symkey_t *psymkey_decrypt(psync_rsa_privatekey_t rsa, const unsigned char * return ret; } -pssl_symkey_t *psymkey_decrypt_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey) { +pssl_symkey_t *psymkey_decrypt_lock(pssl_rsaprivkey_t *rsa, const pssl_enc_symkey_t *enckey) { pssl_symkey_t *sym_key; debug(D_NOTICE, "Get RSA decrypt key lock."); @@ -752,13 +752,13 @@ char *psymkey_derive_passphrase(const char *username, const char *passphrase) { return (char *)usercopy; } -psync_encrypted_symmetric_key_t psymkey_encrypt(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen) { - psync_encrypted_symmetric_key_t ret; +pssl_enc_symkey_t psymkey_encrypt(pssl_rsapubkey_t rsa, const unsigned char *data, size_t datalen) { + pssl_enc_symkey_t ret; int code; size_t rsalen; rsalen = mbedtls_rsa_get_len(rsa); - ret = (psync_encrypted_symmetric_key_t)psync_malloc( + ret = (pssl_enc_symkey_t)psync_malloc( offsetof(pssl_enc_data_t, data) + rsalen); if ((code = mbedtls_rsa_rsaes_oaep_encrypt( rsa, drbg_random_safe, &psync_mbed_rng, diff --git a/pclsync/pssl.h b/pclsync/pssl.h index a55b63d..7282dd1 100644 --- a/pclsync/pssl.h +++ b/pclsync/pssl.h @@ -107,14 +107,14 @@ typedef struct { unsigned char key[]; } pssl_symkey_t; -typedef mbedtls_rsa_context *psync_rsa_t; -typedef mbedtls_rsa_context *psync_rsa_publickey_t; -typedef mbedtls_rsa_context *psync_rsa_privatekey_t; -typedef mbedtls_aes_context *psync_aes256_encoder; -typedef mbedtls_aes_context *psync_aes256_decoder; -typedef pssl_enc_data_t *psync_encrypted_symmetric_key_t; -typedef pssl_enc_data_t *psync_binary_rsa_key_t; -typedef pssl_enc_data_t *psync_rsa_signature_t; +typedef mbedtls_rsa_context *pssl_context_t; +typedef mbedtls_rsa_context *pssl_rsapubkey_t; +typedef mbedtls_rsa_context *pssl_rsaprivkey_t; +typedef mbedtls_aes_context *pssl_encoder_t; +typedef mbedtls_aes_context *pssl_decoder_t; +typedef pssl_enc_data_t *pssl_enc_symkey_t; +typedef pssl_enc_data_t *pssl_rsabinkey_t; +typedef pssl_enc_data_t *pssl_signature_t; typedef struct { mbedtls_net_context srv; @@ -128,29 +128,29 @@ typedef struct { typedef void (*psync_ssl_debug_callback_t)(void *ctx, int level, const char *msg, int, const char *); // AES -void paes_2blk_decode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst); -void paes_2blk_encode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst); -void paes_4blk_xor_decode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor); -void paes_blk_decode(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst); -void paes_blk_encode(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst); -psync_aes256_encoder paes_decoder_create(pssl_symkey_t *key); -void paes_decoder_free(psync_aes256_encoder aes); -psync_aes256_encoder paes_encoder_create(pssl_symkey_t *key); -void paes_encoder_free(psync_aes256_encoder aes); +void paes_2blk_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst); +void paes_2blk_encode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst); +void paes_4blk_xor_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor); +void paes_blk_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char *dst); +void paes_blk_encode(pssl_encoder_t enc, const unsigned char *src, unsigned char *dst); +pssl_encoder_t paes_decoder_create(pssl_symkey_t *key); +void paes_decoder_free(pssl_encoder_t aes); +pssl_encoder_t paes_encoder_create(pssl_symkey_t *key); +void paes_encoder_free(pssl_encoder_t aes); // RSA -void prsa_binary_free(psync_binary_rsa_key_t bin); -psync_binary_rsa_key_t prsa_binary_private(psync_rsa_privatekey_t rsa); -psync_binary_rsa_key_t prsa_binary_public(psync_rsa_publickey_t rsa); -void prsa_free(psync_rsa_t rsa); -void prsa_free_private(psync_rsa_privatekey_t key); -void prsa_free_public(psync_rsa_publickey_t key); -psync_rsa_t prsa_generate(int bits); -psync_rsa_privatekey_t prsa_get_private(psync_rsa_t rsa); -psync_rsa_publickey_t prsa_get_public(psync_rsa_t rsa); -psync_rsa_privatekey_t prsa_load_private(const unsigned char *keydata, size_t keylen); -psync_rsa_publickey_t prsa_load_public(const unsigned char *keydata, size_t keylen); -psync_rsa_signature_t prsa_signature(psync_rsa_privatekey_t rsa, const unsigned char *data); +void prsa_binary_free(pssl_rsabinkey_t bin); +pssl_rsabinkey_t prsa_binary_private(pssl_rsaprivkey_t rsa); +pssl_rsabinkey_t prsa_binary_public(pssl_rsapubkey_t rsa); +void prsa_free(pssl_context_t rsa); +void prsa_free_private(pssl_rsaprivkey_t key); +void prsa_free_public(pssl_rsapubkey_t key); +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_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); // SSL int pssl_bytes_left(ssl_connection_t *sslconn); @@ -166,12 +166,12 @@ void pssl_random(unsigned char *buf, int num); int pssl_read(ssl_connection_t *sslconn, void *buf, int num); int pssl_write(ssl_connection_t *sslconn, const void *buf, int num); -psync_encrypted_symmetric_key_t psymkey_alloc(size_t len); -psync_encrypted_symmetric_key_t psymkey_copy(psync_encrypted_symmetric_key_t src); -pssl_symkey_t *psymkey_decrypt(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen); -pssl_symkey_t *psymkey_decrypt_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey); +pssl_enc_symkey_t psymkey_alloc(size_t len); +pssl_enc_symkey_t psymkey_copy(pssl_enc_symkey_t src); +pssl_symkey_t *psymkey_decrypt(pssl_rsaprivkey_t rsa, const unsigned char *data, size_t datalen); +pssl_symkey_t *psymkey_decrypt_lock(pssl_rsaprivkey_t *rsa, const pssl_enc_symkey_t *enckey); char *psymkey_derive_passphrase(const char *username, const char *passphrase); -psync_encrypted_symmetric_key_t psymkey_encrypt(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen); +pssl_enc_symkey_t psymkey_encrypt(pssl_rsapubkey_t rsa, const unsigned char *data, size_t datalen); void psymkey_free(pssl_symkey_t *key); pssl_symkey_t *psymkey_generate_passphrase(const char *password, size_t keylen, const unsigned char *salt, size_t saltlen, size_t iterations);