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

type name clarification

This commit is contained in:
Levi Neely 2025-03-04 17:29:20 +01:00
parent 9b2c9ab74a
commit 27f6e313dc
6 changed files with 134 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
pclsync/pcrypto.c
View File

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

8
pclsync/pcrypto.h
View File

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

84
pclsync/pcryptofolder.c
View File

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

22
pclsync/pp2p.c
View File

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

76
pclsync/pssl.c
View File

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

68
pclsync/pssl.h
View File

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