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

pssl namespace

This commit is contained in:
Levi Neely 2025-03-04 14:58:25 +01:00
parent c6a0165c64
commit f25a393ee2
11 changed files with 308 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
pclsync/pcrypto.c
View File

@ -68,7 +68,7 @@ static void psync_hmac_sha512_init(psync_hmac_sha512_ctx *ctx,
}
psync_sha512_init(&ctx->sha1ctx);
psync_sha512_update(&ctx->sha1ctx, keyxor, PSYNC_SHA512_BLOCK_LEN);
psync_ssl_memclean(keyxor, PSYNC_SHA512_BLOCK_LEN);
pssl_memclean(keyxor, PSYNC_SHA512_BLOCK_LEN);
}
static void psync_hmac_sha512_update(psync_hmac_sha512_ctx *ctx,
@ -81,7 +81,7 @@ static void psync_hmac_sha512_final(unsigned char *result,
psync_sha512_final(ctx->final + PSYNC_SHA512_BLOCK_LEN, &ctx->sha1ctx);
psync_sha512(ctx->final, PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN,
result);
psync_ssl_memclean(ctx->final,
pssl_memclean(ctx->final,
PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN);
}
@ -107,8 +107,8 @@ static void psync_hmac_sha512(const unsigned char *msg, size_t msglen,
psync_sha512_update(&sha1ctx, msg, msglen);
psync_sha512_final(final + PSYNC_SHA512_BLOCK_LEN, &sha1ctx);
psync_sha512(final, PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN, result);
psync_ssl_memclean(keyxor, PSYNC_SHA512_BLOCK_LEN);
psync_ssl_memclean(final, PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN);
pssl_memclean(keyxor, PSYNC_SHA512_BLOCK_LEN);
pssl_memclean(final, PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN);
}
#define ALIGN_A256_BS(n) \
@ -165,7 +165,7 @@ psync_symmetric_key_t pcrypto_key_len(size_t len) {
key = (psync_symmetric_key_t)pmemlock_malloc(
offsetof(psync_symmetric_key_struct_t, key) + len);
key->keylen = len;
psync_ssl_rand_strong(key->key, len);
pssl_rand_strong(key->key, len);
return key;
}
@ -181,7 +181,7 @@ pcrypto_ctr_encdec_create(psync_symmetric_key_t key) {
if (unlikely_log(key->keylen <
PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = psync_ssl_aes256_create_encoder(key);
enc = pssl_enc_create(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = psync_new(pcrypto_key_t);
@ -192,8 +192,8 @@ pcrypto_ctr_encdec_create(psync_symmetric_key_t key) {
void pcrypto_ctr_encdec_free(
pcrypto_ctr_encdec_t enc) {
psync_ssl_aes256_free_encoder(enc->encoder);
psync_ssl_memclean(enc->iv, PSYNC_AES256_BLOCK_SIZE);
pssl_enc_free(enc->encoder);
pssl_memclean(enc->iv, PSYNC_AES256_BLOCK_SIZE);
psync_free(enc);
}
@ -211,7 +211,7 @@ void pcrypto_ctr_encdec_encode(
dataoffset %= PSYNC_AES256_BLOCK_SIZE;
if (dataoffset) {
copy_iv_and_xor_with_counter(aessrc, enc->iv, counter);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
blocksrem = PSYNC_AES256_BLOCK_SIZE - dataoffset;
xor_cnt_inplace(data, aesdst + dataoffset, blocksrem);
datalen -= blocksrem;
@ -223,7 +223,7 @@ void pcrypto_ctr_encdec_encode(
if (IS_WORD_ALIGNED(data)) {
while (blocksrem) {
copy_iv_and_xor_with_counter(aessrc, enc->iv, counter);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
xor16_aligned_inplace(data, aesdst);
blocksrem--;
counter++;
@ -232,7 +232,7 @@ void pcrypto_ctr_encdec_encode(
} else {
while (blocksrem) {
copy_iv_and_xor_with_counter(aessrc, enc->iv, counter);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
xor16_unaligned_inplace(data, aesdst);
blocksrem--;
counter++;
@ -241,7 +241,7 @@ void pcrypto_ctr_encdec_encode(
}
if (datalen) {
copy_iv_and_xor_with_counter(aessrc, enc->iv, counter);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
xor_cnt_inplace(data, aesdst, datalen);
}
}
@ -295,7 +295,7 @@ void pcrypto_encode_text(pcrypto_textenc_t enc,
copy_pad(aessrc, PSYNC_AES256_BLOCK_SIZE, &txt, &txtlen);
assert(enc->ivlen >= PSYNC_AES256_BLOCK_SIZE);
xor16_aligned_inplace(aessrc, enc->iv);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
return;
}
@ -306,13 +306,13 @@ void pcrypto_encode_text(pcrypto_textenc_t enc,
txt += PSYNC_AES256_BLOCK_SIZE;
txtlen -= PSYNC_AES256_BLOCK_SIZE;
xor16_aligned_inplace(aessrc, hmac);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
do {
copy_pad(aessrc, PSYNC_AES256_BLOCK_SIZE, &txt, &txtlen);
xor16_aligned_inplace(aessrc, aesdst);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
} while (txtlen);
@ -334,7 +334,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
datalen /= PSYNC_AES256_BLOCK_SIZE;
if (datalen == 1) {
copy_unaligned(aessrc, data);
psync_aes256_decode_block(enc->encoder, aessrc, aesdst);
pssl_dec_blk(enc->encoder, aessrc, aesdst);
assert(enc->ivlen >= PSYNC_AES256_BLOCK_SIZE);
xor16_aligned_inplace(aesdst, enc->iv);
copy_aligned(outptr, aesdst);
@ -353,28 +353,28 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
}
if (IS_WORD_ALIGNED(data)) {
copy_aligned(aessrc, data);
psync_aes256_decode_block(enc->encoder, aessrc, aesdst);
pssl_dec_blk(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
while (--datalen) {
xorptr = data;
data += PSYNC_AES256_BLOCK_SIZE;
copy_aligned(aessrc, data);
psync_aes256_decode_block(enc->encoder, aessrc, aesdst);
pssl_dec_blk(enc->encoder, aessrc, aesdst);
xor16_aligned_inplace(aesdst, xorptr);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
}
} else {
copy_unaligned(aessrc, data);
psync_aes256_decode_block(enc->encoder, aessrc, aesdst);
pssl_dec_blk(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
while (--datalen) {
xorptr = data;
data += PSYNC_AES256_BLOCK_SIZE;
copy_unaligned(aessrc, data);
psync_aes256_decode_block(enc->encoder, aessrc, aesdst);
pssl_dec_blk(enc->encoder, aessrc, aesdst);
xor16_unaligned_inplace(aesdst, xorptr);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
@ -404,7 +404,7 @@ pcrypto_textenc_create(psync_symmetric_key_t key) {
if (unlikely_log(key->keylen <
PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = psync_ssl_aes256_create_encoder(key);
enc = pssl_enc_create(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = (pcrypto_textenc_t)pmemlock_malloc(
@ -418,8 +418,8 @@ pcrypto_textenc_create(psync_symmetric_key_t key) {
void pcrypto_textenc_free(
pcrypto_textenc_t enc) {
psync_ssl_aes256_free_encoder(enc->encoder);
psync_ssl_memclean(enc->iv, enc->ivlen);
pssl_enc_free(enc->encoder);
pssl_memclean(enc->iv, enc->ivlen);
pmemlock_free(enc);
}
@ -430,7 +430,7 @@ pcrypto_textdec_create(psync_symmetric_key_t key) {
if (unlikely_log(key->keylen <
PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = psync_ssl_aes256_create_decoder(key);
enc = pssl_dec_create(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = (pcrypto_textenc_t)pmemlock_malloc(
@ -444,8 +444,8 @@ pcrypto_textdec_create(psync_symmetric_key_t key) {
void pcrypto_textdec_free(
pcrypto_textdec_t enc) {
psync_ssl_aes256_free_encoder(enc->encoder);
psync_ssl_memclean(enc->iv, enc->ivlen);
pssl_enc_free(enc->encoder);
pssl_memclean(enc->iv, enc->ivlen);
pmemlock_free(enc);
}
@ -456,12 +456,12 @@ pcrypto_sec_encdec_create(psync_symmetric_key_t key) {
pcrypto_sector_encdec_t ret;
if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = psync_ssl_aes256_create_encoder(key);
enc = pssl_enc_create(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
dec = psync_ssl_aes256_create_decoder(key);
dec = pssl_dec_create(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER)) {
psync_ssl_aes256_free_encoder(enc);
pssl_enc_free(enc);
return PSYNC_CRYPTO_INVALID_ENCODER;
}
ret = (pcrypto_sector_encdec_t)pmemlock_malloc(
@ -476,9 +476,9 @@ pcrypto_sec_encdec_create(psync_symmetric_key_t key) {
void pcrypto_sec_encdec_free(
pcrypto_sector_encdec_t enc) {
psync_ssl_aes256_free_encoder(enc->encoder);
psync_ssl_aes256_free_decoder(enc->decoder);
psync_ssl_memclean(enc->iv, enc->ivlen);
pssl_enc_free(enc->encoder);
pssl_dec_free(enc->decoder);
pssl_memclean(enc->iv, enc->ivlen);
pmemlock_free(enc);
}
@ -504,7 +504,7 @@ void pcrypto_encode_sec(
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
assert(PSYNC_CRYPTO_AUTH_SIZE == 2 * PSYNC_AES256_BLOCK_SIZE);
psync_ssl_rand_weak(rnd, PSYNC_AES256_BLOCK_SIZE);
pssl_rand_weak(rnd, PSYNC_AES256_BLOCK_SIZE);
psync_hmac_sha512_init(&ctx, enc->iv, enc->ivlen);
psync_hmac_sha512_update(&ctx, data, datalen);
psync_hmac_sha512_update(&ctx, &sectorid, sizeof(sectorid));
@ -515,7 +515,7 @@ void pcrypto_encode_sec(
xor_cnt_inplace(aessrc, data, datalen);
memcpy(out, rnd, datalen);
memcpy(aesdst, hmacsha1bin, PSYNC_AES256_BLOCK_SIZE);
psync_aes256_encode_2blocks_consec(enc->encoder, aessrc, aessrc);
pssl_enc_2blk(enc->encoder, aessrc, aessrc);
memcpy(authout, aessrc, PSYNC_AES256_BLOCK_SIZE * 2);
return;
}
@ -529,13 +529,13 @@ void pcrypto_encode_sec(
PSYNC_AES256_BLOCK_SIZE);
memcpy(aessrc + PSYNC_AES256_BLOCK_SIZE + PSYNC_AES256_BLOCK_SIZE / 2,
rnd + PSYNC_AES256_BLOCK_SIZE / 2, PSYNC_AES256_BLOCK_SIZE / 2);
psync_aes256_encode_2blocks_consec(enc->encoder, aessrc, aessrc);
pssl_enc_2blk(enc->encoder, aessrc, aessrc);
memcpy(authout, aessrc, PSYNC_AES256_BLOCK_SIZE * 2);
memcpy(aessrc, hmacsha1bin, PSYNC_AES256_BLOCK_SIZE);
if (IS_WORD_ALIGNED(data) && IS_WORD_ALIGNED(out))
while (datalen) {
xor16_aligned_inplace(aessrc, data);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
copy_aligned(out, aesdst);
datalen -= PSYNC_AES256_BLOCK_SIZE;
data += PSYNC_AES256_BLOCK_SIZE;
@ -547,7 +547,7 @@ void pcrypto_encode_sec(
else
while (datalen) {
xor16_unaligned_inplace(aessrc, data);
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
copy_unaligned(out, aesdst);
datalen -= PSYNC_AES256_BLOCK_SIZE;
data += PSYNC_AES256_BLOCK_SIZE;
@ -559,10 +559,10 @@ void pcrypto_encode_sec(
if (unlikely(needsteal)) {
xor16_unaligned_inplace(aessrc, data);
data += PSYNC_AES256_BLOCK_SIZE;
psync_aes256_encode_block(enc->encoder, aessrc, aesdst);
pssl_enc_blk(enc->encoder, aessrc, aesdst);
memcpy(out + PSYNC_AES256_BLOCK_SIZE, aesdst, needsteal);
xor_cnt_inplace(aesdst, data, needsteal);
psync_aes256_encode_block(enc->encoder, aesdst, aessrc);
pssl_enc_blk(enc->encoder, aesdst, aessrc);
copy_unaligned(out, aessrc);
}
}
@ -582,7 +582,7 @@ int pcrypto_decode_sec(
aesxor = aessrc + PSYNC_AES256_BLOCK_SIZE * 8;
hmac = aessrc + PSYNC_AES256_BLOCK_SIZE * 12;
memcpy(aessrc, auth, PSYNC_AES256_BLOCK_SIZE * 2);
psync_aes256_decode_2blocks_consec(enc->decoder, aessrc, hmac);
pssl_dec_2blk(enc->decoder, aessrc, hmac);
oout = out;
odatalen = datalen;
if (unlikely(datalen < PSYNC_AES256_BLOCK_SIZE)) {
@ -605,7 +605,7 @@ int pcrypto_decode_sec(
memcpy(aessrc, data, PSYNC_AES256_BLOCK_SIZE * 4);
memcpy(aesxor + PSYNC_AES256_BLOCK_SIZE, aessrc,
PSYNC_AES256_BLOCK_SIZE * 3);
psync_aes256_decode_4blocks_consec_xor(enc->decoder, aessrc, aesdst,
pssl_dec_4blk_xor(enc->decoder, aessrc, aesdst,
aesxor);
memcpy(out, aesdst, PSYNC_AES256_BLOCK_SIZE * 4);
memcpy(aesxor, aessrc + PSYNC_AES256_BLOCK_SIZE * 3,
@ -616,7 +616,7 @@ int pcrypto_decode_sec(
}
while (datalen) {
copy_unaligned(aessrc, data);
psync_aes256_decode_block(enc->decoder, aessrc, aesdst);
pssl_dec_blk(enc->decoder, aessrc, aesdst);
xor16_aligned_inplace(aesdst, aesxor);
copy_unaligned(out, aesdst);
data += PSYNC_AES256_BLOCK_SIZE;
@ -628,14 +628,14 @@ int pcrypto_decode_sec(
}
if (unlikely(needsteal)) {
copy_unaligned(aessrc, data);
psync_aes256_decode_block(enc->decoder, aessrc, aesdst);
pssl_dec_blk(enc->decoder, aessrc, aesdst);
xor_cnt_inplace(aesdst, data + PSYNC_AES256_BLOCK_SIZE, needsteal);
// can be done with less memcpy's, but this version supports inline
// decoding (e.g. data==out)
memcpy(aessrc, data + PSYNC_AES256_BLOCK_SIZE, needsteal);
memcpy(out + PSYNC_AES256_BLOCK_SIZE, aesdst, needsteal);
memcpy(aesdst, aessrc, needsteal);
psync_aes256_decode_block(enc->decoder, aesdst, aessrc);
pssl_dec_blk(enc->decoder, aesdst, aessrc);
xor16_aligned_inplace(aessrc, aesxor);
copy_unaligned(out, aessrc);
}
@ -657,6 +657,6 @@ void pcrypto_sign_sec(
aesdst = ALIGN_PTR_A256_BS(buff);
aessrc = aesdst + PSYNC_AES256_BLOCK_SIZE * 2;
psync_hmac_sha512(data, datalen, enc->iv, enc->ivlen, aessrc);
psync_aes256_encode_2blocks_consec(enc->encoder, aessrc, aesdst);
pssl_enc_2blk(enc->encoder, aessrc, aesdst);
memcpy(authout, aesdst, PSYNC_AES256_BLOCK_SIZE * 2);
}

198
pclsync/pcryptofolder.c
View File

@ -379,51 +379,51 @@ int pcryptofolder_setup(const char *password, const char *hint) {
time_t cryptoexpires;
int ret;
debug(D_NOTICE, "generating salt");
psync_ssl_rand_strong(salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
pssl_rand_strong(salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
debug(D_NOTICE, "generating AES key from password and setting up encoder");
aeskey = psync_ssl_gen_symmetric_key_from_pass(
aeskey = pssl_gen_symkey_pass(
password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt,
PSYNC_CRYPTO_PBKDF2_SALT_LEN, PSYNC_CRYPTO_PASS_TO_KEY_ITERATIONS);
enc = pcrypto_ctr_encdec_create(aeskey);
psync_ssl_free_symmetric_key(aeskey);
pssl_symkey_free(aeskey);
if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER)) {
debug(D_WARNING, "psync_crypto_aes256_ctr_encoder_decoder_create failed");
return PSYNC_CRYPTO_SETUP_KEYGEN_FAILED;
}
debug(D_NOTICE, "generating %d bit RSA key", (int)PSYNC_CRYPTO_RSA_SIZE);
rsa = psync_ssl_gen_rsa(PSYNC_CRYPTO_RSA_SIZE);
rsa = pssl_rsa_gen(PSYNC_CRYPTO_RSA_SIZE);
if (unlikely(rsa == PSYNC_INVALID_RSA)) {
debug(D_WARNING, "RSA key generation failed");
pcrypto_ctr_encdec_free(enc);
return PSYNC_CRYPTO_SETUP_KEYGEN_FAILED;
} else
debug(D_NOTICE, "RSA key generated");
rsaprivate = psync_ssl_rsa_get_private(rsa);
rsapublic = psync_ssl_rsa_get_public(rsa);
psync_ssl_free_rsa(rsa);
rsaprivate = pssl_rsa_get_priv(rsa);
rsapublic = pssl_rsa_get_pub(rsa);
pssl_rsa_free(rsa);
if (unlikely(rsaprivate == PSYNC_INVALID_RSA ||
rsapublic == PSYNC_INVALID_RSA)) {
debug(D_WARNING,
"psync_ssl_rsa_get_private or psync_ssl_rsa_get_public failed");
if (rsaprivate != PSYNC_INVALID_RSA)
psync_ssl_rsa_free_private(rsaprivate);
pssl_rsa_free_priv(rsaprivate);
if (rsapublic != PSYNC_INVALID_RSA)
psync_ssl_rsa_free_public(rsapublic);
pssl_rsa_free_pub(rsapublic);
pcrypto_ctr_encdec_free(enc);
return PSYNC_CRYPTO_SETUP_KEYGEN_FAILED;
}
rsaprivatebin = psync_ssl_rsa_private_to_binary(rsaprivate);
rsapublicbin = psync_ssl_rsa_public_to_binary(rsapublic);
psync_ssl_rsa_free_private(rsaprivate);
psync_ssl_rsa_free_public(rsapublic);
rsaprivatebin = pssl_rsa_priv_bin(rsaprivate);
rsapublicbin = pssl_rsa_bin_pub(rsapublic);
pssl_rsa_free_priv(rsaprivate);
pssl_rsa_free_pub(rsapublic);
if (unlikely(rsaprivatebin == PSYNC_INVALID_BIN_RSA ||
rsapublic == PSYNC_INVALID_BIN_RSA)) {
debug(D_WARNING, "psync_ssl_rsa_private_to_binary or "
"psync_ssl_rsa_public_to_binary failed");
if (rsaprivatebin != PSYNC_INVALID_BIN_RSA)
psync_ssl_rsa_free_binary(rsaprivatebin);
pssl_rsa_bin_free(rsaprivatebin);
if (rsapublicbin != PSYNC_INVALID_BIN_RSA)
psync_ssl_rsa_free_binary(rsapublicbin);
pssl_rsa_bin_free(rsapublicbin);
pcrypto_ctr_encdec_free(enc);
return PSYNC_CRYPTO_SETUP_KEYGEN_FAILED;
}
@ -438,8 +438,8 @@ int pcryptofolder_setup(const char *password, const char *hint) {
privatesha1);
if (unlikely(ret != PSYNC_CRYPTO_SETUP_SUCCESS)) {
debug(D_WARNING, "keys upload failed with error %d", ret);
psync_ssl_rsa_free_binary(rsaprivatebin);
psync_ssl_rsa_free_binary(rsapublicbin);
pssl_rsa_bin_free(rsaprivatebin);
pssl_rsa_bin_free(rsapublicbin);
return ret;
}
debug(D_NOTICE, "keys uploaded");
@ -448,8 +448,8 @@ int pcryptofolder_setup(const char *password, const char *hint) {
rsapublicbin->datalen, salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN,
PSYNC_CRYPTO_PASS_TO_KEY_ITERATIONS, cryptoexpires, publicsha1,
privatesha1, 0);
psync_ssl_rsa_free_binary(rsaprivatebin);
psync_ssl_rsa_free_binary(rsapublicbin);
pssl_rsa_bin_free(rsaprivatebin);
pssl_rsa_bin_free(rsapublicbin);
return PSYNC_CRYPTO_SETUP_SUCCESS;
}
@ -502,14 +502,14 @@ static int crypto_keys_match() {
key = (psync_symmetric_key_t)psync_malloc(
offsetof(psync_symmetric_key_struct_t, key) + 64);
key->keylen = 64;
psync_ssl_rand_weak(key->key, key->keylen);
enckey = psync_ssl_rsa_encrypt_symmetric_key(crypto_pubkey, key);
pssl_rand_weak(key->key, key->keylen);
enckey = pssl_symkey_encrypt(crypto_pubkey, key);
if (enckey == PSYNC_INVALID_ENC_SYM_KEY) {
psync_free(key);
return 0;
}
deckey = psync_ssl_rsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
deckey = pssl_symkey_decrypt_lock(&crypto_privkey, &enckey);
psync_free(enckey);
if (deckey == PSYNC_INVALID_SYM_KEY) {
@ -518,7 +518,7 @@ static int crypto_keys_match() {
}
res = key->keylen == deckey->keylen &&
!memcmp(key->key, deckey->key, key->keylen);
psync_ssl_free_symmetric_key(deckey);
pssl_symkey_free(deckey);
psync_free(key);
if (res)
debug(D_NOTICE, "encrypt/decrypt operation succeeded");
@ -605,7 +605,7 @@ retry:
}
debug(D_NOTICE, "trying to load public key");
crypto_pubkey = psync_ssl_rsa_load_public(rsapub, rsapublen);
crypto_pubkey = pssl_rsa_load_pub(rsapub, rsapublen);
if (crypto_pubkey == PSYNC_INVALID_RSA) {
pthread_rwlock_unlock(&crypto_lock);
debug(D_WARNING, "could not load public key");
@ -618,11 +618,11 @@ retry:
debug(D_NOTICE, "generating symmetric key");
aeskey = psync_ssl_gen_symmetric_key_from_pass(
aeskey = pssl_gen_symkey_pass(
password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen,
iterations);
enc = pcrypto_ctr_encdec_create(aeskey);
psync_ssl_free_symmetric_key(aeskey);
pssl_symkey_free(aeskey);
rsaprivdec = (unsigned char *)pmemlock_malloc(rsaprivlen);
memcpy(rsaprivdec, rsapriv, rsaprivlen);
pcrypto_ctr_encdec_encode(enc, rsaprivdec, rsaprivlen, 0);
@ -631,12 +631,12 @@ retry:
debug(D_NOTICE, "trying to load private key");
crypto_privkey = psync_ssl_rsa_load_private(rsaprivdec, rsaprivlen);
psync_ssl_memclean(rsaprivdec, rsaprivlen);
crypto_privkey = pssl_rsa_load_priv(rsaprivdec, rsaprivlen);
pssl_memclean(rsaprivdec, rsaprivlen);
pmemlock_free(rsaprivdec);
if (crypto_privkey == PSYNC_INVALID_RSA) {
debug(D_NOTICE, "failed to load private key");
psync_ssl_rsa_free_public(crypto_pubkey);
pssl_rsa_free_pub(crypto_pubkey);
crypto_pubkey = PSYNC_INVALID_RSA;
pthread_rwlock_unlock(&crypto_lock);
psync_free(rsapriv);
@ -648,9 +648,9 @@ retry:
debug(D_NOTICE, "verify matching public and private key");
if (!crypto_keys_match()) {
psync_ssl_rsa_free_public(crypto_pubkey);
pssl_rsa_free_pub(crypto_pubkey);
crypto_pubkey = PSYNC_INVALID_RSA;
psync_ssl_rsa_free_private(crypto_privkey);
pssl_rsa_free_priv(crypto_privkey);
crypto_privkey = PSYNC_INVALID_RSA;
pthread_rwlock_unlock(&crypto_lock);
debug(D_ERROR, "keys don't match");
@ -696,9 +696,9 @@ int pcryptofolder_lock() {
return PRINT_RETURN_CONST(PSYNC_CRYPTO_STOP_NOT_STARTED);
}
crypto_started_l = 0;
psync_ssl_rsa_free_public(crypto_pubkey);
pssl_rsa_free_pub(crypto_pubkey);
crypto_pubkey = PSYNC_INVALID_RSA;
psync_ssl_rsa_free_private(crypto_privkey);
pssl_rsa_free_priv(crypto_privkey);
crypto_privkey = PSYNC_INVALID_RSA;
pthread_rwlock_unlock(&crypto_lock);
debug(D_NOTICE, "stopped crypto");
@ -792,7 +792,7 @@ static void save_folder_key_to_db(psync_folderid_t folderid,
// will deadlock
insert_folder_key_task *t;
t = psync_new(insert_folder_key_task);
t->key = psync_ssl_copy_encrypted_symmetric_key(enckey);
t->key = pssl_symkey_copy(enckey);
t->id = folderid;
prun_thread1("save folder key to db task", save_folder_key_task, t);
}
@ -821,7 +821,7 @@ static void save_file_key_to_db(psync_fileid_t fileid, uint64_t hash,
psync_encrypted_symmetric_key_t enckey) {
insert_file_key_task *t;
t = psync_new(insert_file_key_task);
t->key = psync_ssl_copy_encrypted_symmetric_key(enckey);
t->key = pssl_symkey_copy(enckey);
t->id = fileid;
t->hash = hash;
prun_thread1("save file key to db task", save_file_key_task, t);
@ -875,7 +875,7 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) {
if (!key)
return (psync_encrypted_symmetric_key_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
ret = psync_ssl_alloc_encrypted_symmetric_key(keylen);
ret = pssl_alloc_symkey(keylen);
memcpy(ret->data, key, keylen);
psync_free(key);
save_folder_key_to_db(folderid, ret);
@ -929,7 +929,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) {
if (!key)
return (psync_encrypted_symmetric_key_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
ret = psync_ssl_alloc_encrypted_symmetric_key(keylen);
ret = pssl_alloc_symkey(keylen);
memcpy(ret->data, key, keylen);
psync_free(key);
save_file_key_to_db(fileid, result, ret);
@ -948,7 +948,7 @@ psync_crypto_get_folder_enc_key(psync_folderid_t folderid) {
psync_sql_bind_uint(res, 1, folderid);
if ((row = psync_sql_fetch_row(res))) {
ckey = psync_get_lstring(row[0], &ckeylen);
enckey = psync_ssl_alloc_encrypted_symmetric_key(ckeylen);
enckey = pssl_alloc_symkey(ckeylen);
memcpy(enckey->data, ckey, ckeylen);
psync_sql_free_result(res);
return enckey;
@ -971,7 +971,7 @@ psync_crypto_get_file_enc_key(psync_fileid_t fileid, uint64_t hash,
psync_sql_bind_uint(res, 2, hash);
if ((row = psync_sql_fetch_row(res))) {
ckey = psync_get_lstring(row[0], &ckeylen);
enckey = psync_ssl_alloc_encrypted_symmetric_key(ckeylen);
enckey = pssl_alloc_symkey(ckeylen);
memcpy(enckey->data, ckey, ckeylen);
psync_sql_free_result(res);
return enckey;
@ -999,7 +999,7 @@ psync_crypto_get_folder_symkey_locked(psync_folderid_t folderid) {
if (psync_crypto_is_error(enckey))
return (psync_symmetric_key_t)enckey;
symkey = psync_ssl_rsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
symkey = pssl_symkey_decrypt_lock(&crypto_privkey, &enckey);
psync_free(enckey);
if (symkey == PSYNC_INVALID_SYM_KEY)
@ -1028,7 +1028,7 @@ psync_crypto_get_file_symkey_locked(psync_fileid_t fileid, uint64_t hash,
(psync_encrypted_symmetric_key_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER)
return (psync_symmetric_key_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER;
symkey = psync_ssl_rsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
symkey = pssl_symkey_decrypt_lock(&crypto_privkey, &enckey);
psync_free(enckey);
if (unlikely_log(symkey == PSYNC_INVALID_SYM_KEY))
@ -1038,7 +1038,7 @@ psync_crypto_get_file_symkey_locked(psync_fileid_t fileid, uint64_t hash,
}
static void psync_crypto_release_symkey_ptr(void *ptr) {
psync_ssl_free_symmetric_key((psync_symmetric_key_t)ptr);
pssl_symkey_free((psync_symmetric_key_t)ptr);
}
static void
@ -1097,12 +1097,12 @@ psync_crypto_get_folder_encoder_locked(psync_folderid_t folderid) {
realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1);
psync_crypto_release_folder_symkey_locked(folderid, symkey);
enc = pcrypto_textenc_create(realkey);
psync_ssl_free_symmetric_key(realkey);
pssl_symkey_free(realkey);
return enc;
default:
debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type);
def1:
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
return (pcrypto_textenc_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
}
@ -1139,12 +1139,12 @@ psync_crypto_get_folder_decoder_locked(psync_folderid_t folderid) {
realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1);
psync_crypto_release_folder_symkey_locked(folderid, symkey);
dec = pcrypto_textdec_create(realkey);
psync_ssl_free_symmetric_key(realkey);
pssl_symkey_free(realkey);
return dec;
default:
debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type);
def1:
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
return (pcrypto_textdec_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
}
@ -1173,7 +1173,7 @@ psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) {
enckey = psync_base64_decode(b64enckey, b64enckeylen, &enckeylen);
psync_sql_free_result(res);
if (enckey) {
symkey = psync_ssl_rsa_decrypt_data(crypto_privkey, enckey, enckeylen);
symkey = pssl_rsa_decrypt(crypto_privkey, enckey, enckeylen);
psync_free(enckey);
} else
symkey = PSYNC_INVALID_SYM_KEY;
@ -1194,14 +1194,14 @@ psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) {
goto def1;
}
realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1);
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
enc = pcrypto_textenc_create(realkey);
psync_ssl_free_symmetric_key(realkey);
pssl_symkey_free(realkey);
return enc;
default:
debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type);
def1:
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
return (pcrypto_textenc_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
}
@ -1230,7 +1230,7 @@ psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) {
enckey = psync_base64_decode(b64enckey, b64enckeylen, &enckeylen);
psync_sql_free_result(res);
if (enckey) {
symkey = psync_ssl_rsa_decrypt_data(crypto_privkey, enckey, enckeylen);
symkey = pssl_rsa_decrypt(crypto_privkey, enckey, enckeylen);
psync_free(enckey);
if (symkey == PSYNC_INVALID_SYM_KEY)
@ -1256,14 +1256,14 @@ psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) {
goto def1;
}
realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1);
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
dec = pcrypto_textdec_create(realkey);
psync_ssl_free_symmetric_key(realkey);
pssl_symkey_free(realkey);
return dec;
default:
debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type);
def1:
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
return (pcrypto_textdec_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
}
@ -1428,12 +1428,12 @@ psync_crypto_get_file_encoder_locked(psync_fileid_t fileid, uint64_t hash,
realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1);
psync_crypto_release_file_symkey_locked(fileid, hash, symkey);
enc = pcrypto_sec_encdec_create(realkey);
psync_ssl_free_symmetric_key(realkey);
pssl_symkey_free(realkey);
return enc;
default:
debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type);
def1:
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
return (pcrypto_sector_encdec_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
}
@ -1467,7 +1467,7 @@ psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid,
enckey = psync_base64_decode(b64enckey, b64enckeylen, &enckeylen);
psync_sql_free_result(res);
if (enckey) {
symkey = psync_ssl_rsa_decrypt_data(crypto_privkey, enckey, enckeylen);
symkey = pssl_rsa_decrypt(crypto_privkey, enckey, enckeylen);
psync_free(enckey);
} else
@ -1485,14 +1485,14 @@ psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid,
goto def1;
}
realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1);
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
enc = pcrypto_sec_encdec_create(realkey);
psync_ssl_free_symmetric_key(realkey);
pssl_symkey_free(realkey);
return enc;
default:
debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type);
def1:
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
return (pcrypto_sector_encdec_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
}
@ -1554,7 +1554,7 @@ pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid,
if (!key)
return (pcrypto_sector_encdec_t)err_to_ptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
esym = psync_ssl_alloc_encrypted_symmetric_key(keylen);
esym = pssl_alloc_symkey(keylen);
memcpy(esym->data, key, keylen);
psync_free(key);
hash = papi_find_result2(res, "hash", PARAM_NUM)->num;
@ -1567,7 +1567,7 @@ pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid,
// save_file_key_to_db runs thread to save to db, that's why we insert
// decrypted key to cache, so psync_crypto_get_file_encoder_locked finds
// it
symkey = psync_ssl_rsa_decrypt_symm_key_lock(&crypto_privkey, &esym);
symkey = pssl_symkey_decrypt_lock(&crypto_privkey, &esym);
psync_crypto_release_file_symkey_locked(fileid, hash, symkey);
enc = psync_crypto_get_file_encoder_locked(fileid, hash, 0);
@ -1738,21 +1738,21 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) {
return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED));
sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC;
sym.flags = flags;
psync_ssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
psync_ssl_rand_strong(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
pssl_rand_strong(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pthread_rwlock_rdlock(&crypto_lock);
if (!crypto_started_l) {
pthread_rwlock_unlock(&crypto_lock);
return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED));
}
encsym = psync_ssl_rsa_encrypt_data(crypto_pubkey, (unsigned char *)&sym,
encsym = pssl_rsa_encrypt(crypto_pubkey, (unsigned char *)&sym,
sizeof(sym));
pthread_rwlock_unlock(&crypto_lock);
if (encsym == PSYNC_INVALID_ENC_SYM_KEY) {
debug(D_ERROR, "RSA encryption failed");
return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR));
}
psync_ssl_memclean(&sym, sizeof(sym));
pssl_memclean(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
psync_free(encsym);
return ret;
@ -1767,14 +1767,14 @@ char *pcryptofolder_filencoder_key_newplain(
return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED));
sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC;
sym.flags = flags;
psync_ssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
psync_ssl_rand_strong(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
pssl_rand_strong(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pthread_rwlock_rdlock(&crypto_lock);
if (!crypto_started_l) {
pthread_rwlock_unlock(&crypto_lock);
return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED));
}
encsym = psync_ssl_rsa_encrypt_data(crypto_pubkey, (unsigned char *)&sym,
encsym = pssl_rsa_encrypt(crypto_pubkey, (unsigned char *)&sym,
sizeof(sym));
pthread_rwlock_unlock(&crypto_lock);
if (encsym == PSYNC_INVALID_ENC_SYM_KEY) {
@ -1782,7 +1782,7 @@ char *pcryptofolder_filencoder_key_newplain(
return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR));
}
*deckey = psync_crypto_sym_key_ver1_to_sym_key(&sym);
psync_ssl_memclean(&sym, sizeof(sym));
pssl_memclean(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
psync_free(encsym);
return ret;
@ -1801,16 +1801,16 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name,
ename = NULL;
sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC;
sym.flags = PSYNC_CRYPTO_SYM_FLAG_ISDIR;
psync_ssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
psync_ssl_rand_strong(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
pssl_rand_strong(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pthread_rwlock_rdlock(&crypto_lock);
if (!crypto_started_l) {
pthread_rwlock_unlock(&crypto_lock);
return set_err(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED), err);
}
encsym = psync_ssl_rsa_encrypt_data(crypto_pubkey, (unsigned char *)&sym,
encsym = pssl_rsa_encrypt(crypto_pubkey, (unsigned char *)&sym,
sizeof(sym));
psync_ssl_memclean(&sym, sizeof(sym));
pssl_memclean(&sym, sizeof(sym));
ret = get_name_for_folder_locked(folderid, name, &ename, err);
pthread_rwlock_unlock(&crypto_lock);
if (ret) {
@ -1849,7 +1849,7 @@ int psync_pcloud_crypto_reencode_key(
case PSYNC_CRYPTO_PUB_TYPE_RSA4096:
if (offsetof(pub_key_ver1, key) >= rsapublen)
goto err_bk_0;
pub = psync_ssl_rsa_load_public(rsapub + offsetof(pub_key_ver1, key),
pub = pssl_rsa_load_pub(rsapub + offsetof(pub_key_ver1, key),
rsapublen - offsetof(pub_key_ver1, key));
if (pub == PSYNC_INVALID_RSA)
goto err_bk_0;
@ -1869,14 +1869,14 @@ int psync_pcloud_crypto_reencode_key(
if (offsetof(priv_key_ver1, key) >= rsaprivlen)
goto err_bk_1;
rsapriv_struct = (priv_key_ver1 *)rsapriv;
aeskey = psync_ssl_gen_symmetric_key_from_pass(
aeskey = pssl_gen_symkey_pass(
oldpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE,
rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000);
if (unlikely(aeskey == PSYNC_INVALID_SYM_KEY))
goto err_nm_1;
rsaprivlen -= offsetof(priv_key_ver1, key);
enc = pcrypto_ctr_encdec_create(aeskey);
psync_ssl_free_symmetric_key(aeskey);
pssl_symkey_free(aeskey);
if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
goto err_nm_1;
rsaprivdec = (unsigned char *)psync_malloc(rsaprivlen);
@ -1895,15 +1895,15 @@ int psync_pcloud_crypto_reencode_key(
rsapriv_struct = (priv_key_ver1 *)newpriv;
rsapriv_struct->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT;
rsapriv_struct->flags = flags;
psync_ssl_rand_weak(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
aeskey = psync_ssl_gen_symmetric_key_from_pass(
pssl_rand_weak(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
aeskey = pssl_gen_symkey_pass(
newpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE,
rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000);
if (unlikely(aeskey == PSYNC_INVALID_SYM_KEY))
goto err_nm_1;
// rsaprivlen-=offsetof(priv_key_ver1, key);
enc = pcrypto_ctr_encdec_create(aeskey);
psync_ssl_free_symmetric_key(aeskey);
pssl_symkey_free(aeskey);
if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
goto err_nm_1;
memcpy(rsapriv_struct->key, rsaprivdec, rsaprivlen);
@ -1911,8 +1911,8 @@ int psync_pcloud_crypto_reencode_key(
rsaprivlen, 0);
pcrypto_ctr_encdec_free(enc);
newprivlen = offsetof(priv_key_ver1, key) + rsaprivlen;
priv = psync_ssl_rsa_load_private(rsaprivdec, rsaprivlen);
psync_ssl_memclean(rsaprivdec, rsaprivlen);
priv = pssl_rsa_load_priv(rsaprivdec, rsaprivlen);
pssl_memclean(rsaprivdec, rsaprivlen);
psync_free(rsaprivdec);
if (unlikely(priv == PSYNC_INVALID_RSA))
goto err_ph_1;
@ -1925,19 +1925,19 @@ int psync_pcloud_crypto_reencode_key(
if (!crypto_keys_match(pub, priv))
goto err_ph_2;
psync_sha256(newpriv, newprivlen, newprivsha);
rsasign = psync_ssl_rsa_sign_sha256_hash(priv, newprivsha);
rsasign = pssl_sha256_sign(priv, newprivsha);
if (psync_crypto_is_error(rsasign)) {
psync_free(newpriv);
psync_ssl_rsa_free_public(pub);
psync_ssl_rsa_free_private(priv);
pssl_rsa_free_pub(pub);
pssl_rsa_free_priv(priv);
return psync_crypto_to_error(rsasign);
}
*privenc = (char *)psync_base64_encode(newpriv, newprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
psync_free(rsasign);
psync_free(newpriv);
psync_ssl_rsa_free_public(pub);
psync_ssl_rsa_free_private(priv);
pssl_rsa_free_pub(pub);
pssl_rsa_free_priv(priv);
if (!*privenc || !*sign) {
psync_free(*privenc);
@ -1947,18 +1947,18 @@ int psync_pcloud_crypto_reencode_key(
return PSYNC_CRYPTO_SUCCESS;
err_bk_1:
psync_ssl_rsa_free_public(pub);
pssl_rsa_free_pub(pub);
err_bk_0:
return PSYNC_CRYPTO_BAD_KEY;
err_nm_1:
psync_free(newpriv);
psync_ssl_rsa_free_public(pub);
pssl_rsa_free_pub(pub);
return PERROR_NO_MEMORY;
err_ph_2:
psync_ssl_rsa_free_private(priv);
pssl_rsa_free_priv(priv);
err_ph_1:
psync_free(newpriv);
psync_ssl_rsa_free_public(pub);
pssl_rsa_free_pub(pub);
return PSYNC_CRYPTO_BAD_PASSPHRASE;
}
@ -1972,7 +1972,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
size_t rsaprivlen, dummy;
unsigned char newprivsha[PSYNC_SHA256_DIGEST_LEN];
psync_rsa_signature_t rsasign;
rsapriv = psync_ssl_rsa_private_to_binary(crypto_privkey);
rsapriv = pssl_rsa_priv_bin(crypto_privkey);
if (rsapriv == PSYNC_INVALID_RSA)
goto err_nm_0;
rsaprivlen = rsapriv->datalen;
@ -1983,14 +1983,14 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
rsapriv_struct = (priv_key_ver1 *)newpriv;
rsapriv_struct->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT;
rsapriv_struct->flags = flags;
psync_ssl_rand_weak(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
aeskey = psync_ssl_gen_symmetric_key_from_pass(
pssl_rand_weak(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
aeskey = pssl_gen_symkey_pass(
newpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE,
rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000);
if (unlikely(aeskey == PSYNC_INVALID_SYM_KEY))
goto err_nm_1;
enc = pcrypto_ctr_encdec_create(aeskey);
psync_ssl_free_symmetric_key(aeskey);
pssl_symkey_free(aeskey);
if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
goto err_nm_1;
memcpy(rsapriv_struct->key, rsapriv->data, rsaprivlen);
@ -2000,17 +2000,17 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
rsaprivlen += offsetof(priv_key_ver1, key);
psync_sha256(newpriv, rsaprivlen, newprivsha);
rsasign = psync_ssl_rsa_sign_sha256_hash(crypto_privkey, newprivsha);
rsasign = pssl_sha256_sign(crypto_privkey, newprivsha);
if (psync_crypto_is_error(rsasign)) {
psync_free(newpriv);
psync_ssl_rsa_free_binary(rsapriv);
pssl_rsa_bin_free(rsapriv);
return psync_crypto_to_error(rsasign);
}
*privenc = (char *)psync_base64_encode(newpriv, rsaprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
psync_free(rsasign);
psync_free(newpriv);
psync_ssl_rsa_free_binary(rsapriv);
pssl_rsa_bin_free(rsapriv);
if (!*privenc || !*sign) {
psync_free(*privenc);
@ -2022,7 +2022,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
err_nm_1:
psync_free(newpriv);
psync_ssl_rsa_free_binary(rsapriv);
pssl_rsa_bin_free(rsapriv);
err_nm_0:
return PERROR_NO_MEMORY;
}

2
pclsync/pdiff.c
View File

@ -328,7 +328,7 @@ static psock_t *get_connected_socket() {
psync_sql_res *q;
unsigned char deviceidbin[16];
char deviceidhex[32 + 2];
psync_ssl_rand_strong(deviceidbin, sizeof(deviceidbin));
pssl_rand_strong(deviceidbin, sizeof(deviceidbin));
psync_binhex(deviceidhex, deviceidbin, sizeof(deviceidbin));
deviceidhex[sizeof(deviceidbin) * 2] = 0;
q = psync_sql_prep_statement(

8
pclsync/pfs.c
View File

@ -1468,7 +1468,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
goto ex0;
}
encoder = pcrypto_sec_encdec_create(symkey);
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
if (unlikely_log(encoder == PSYNC_CRYPTO_INVALID_ENCODER)) {
psync_free(encsymkey);
ret = -ENOMEM;
@ -1639,7 +1639,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
return -psync_fs_crypto_err_to_errno(psync_crypto_to_error(encsymkey));
}
encoder = pcrypto_sec_encdec_create(symkey);
psync_ssl_free_symmetric_key(symkey);
pssl_symkey_free(symkey);
if (unlikely_log(encoder == PSYNC_CRYPTO_INVALID_ENCODER)) {
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
@ -3367,7 +3367,7 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
pfolder_path_sep(folderid, "/", NULL);
if (path == PSYNC_INVALID_PATH)
return;
psync_ssl_rand_weak(rndbuff, sizeof(rndbuff));
pssl_rand_weak(rndbuff, sizeof(rndbuff));
psync_binhex(rndhex, rndbuff, sizeof(rndbuff));
rndhex[2 * sizeof(rndbuff)] = 0;
pthread_mutex_lock(&start_mutex);
@ -3565,7 +3565,7 @@ static void psync_fs_init_once() {
#if psync_fs_need_per_folder_refresh_const()
unsigned char rndbuff[16];
char rndhex[34];
psync_ssl_rand_weak(rndbuff, sizeof(rndbuff));
pssl_rand_weak(rndbuff, sizeof(rndbuff));
psync_binhex(rndhex, rndbuff, sizeof(rndbuff));
rndhex[2 * sizeof(rndbuff)] = 0;
psync_fake_prefix = psync_strcat(".refresh", rndhex, NULL);

38
pclsync/pp2p.c
View File

@ -221,7 +221,7 @@ static void psync_p2p_check(const packet_check *packet) {
else
return;
resp.port = tcpport;
psync_ssl_rand_weak(resp.rand, sizeof(resp.rand));
pssl_rand_weak(resp.rand, sizeof(resp.rand));
memcpy(hashsource, hashhex, PSYNC_HASH_DIGEST_HEXLEN);
memcpy(hashsource + PSYNC_HASH_DIGEST_HEXLEN, resp.rand, sizeof(resp.rand));
psync_hash(hashsource, PSYNC_HASH_BLOCK_SIZE, hashbin);
@ -361,7 +361,7 @@ static void psync_p2p_tcphandler(void *ptr) {
goto err0;
}
psync_free(token);
pubrsa = psync_ssl_rsa_load_public(binpubrsa->data, binpubrsa->datalen);
pubrsa = pssl_rsa_load_pub(binpubrsa->data, binpubrsa->datalen);
psync_free(binpubrsa);
if (unlikely_log(pubrsa == PSYNC_INVALID_RSA))
goto err0;
@ -377,9 +377,9 @@ static void psync_p2p_tcphandler(void *ptr) {
goto err0;
}
aeskey = pcrypto_key();
encaeskey = psync_ssl_rsa_encrypt_symmetric_key(pubrsa, aeskey);
encaeskey = pssl_symkey_encrypt(pubrsa, aeskey);
encoder = pcrypto_ctr_encdec_create(aeskey);
psync_ssl_free_symmetric_key(aeskey);
pssl_symkey_free(aeskey);
keylen = encaeskey->datalen;
enctype = P2P_ENCTYPE_RSA_AES;
if (unlikely_log(encaeskey == PSYNC_INVALID_ENC_SYM_KEY) ||
@ -550,7 +550,7 @@ static void psync_p2p_wake() {
void pp2p_init() {
unsigned char computerbin[PSYNC_HASH_DIGEST_LEN];
psync_ssl_rand_weak(computerbin, PSYNC_HASH_DIGEST_LEN);
pssl_rand_weak(computerbin, PSYNC_HASH_DIGEST_LEN);
psync_binhex(computername, computerbin, PSYNC_HASH_DIGEST_LEN);
ptimer_exception_handler(psync_p2p_wake);
if (!psync_setting_get_bool(_PS(p2psync)))
@ -574,17 +574,17 @@ static int psync_p2p_check_rsa() {
psync_rsa_publickey_t rsapub;
psync_binary_rsa_key_t rsapubbin;
debug(D_NOTICE, "generating %ubit RSA key", PSYNC_P2P_RSA_SIZE);
rsa = psync_ssl_gen_rsa(PSYNC_P2P_RSA_SIZE);
rsa = pssl_rsa_gen(PSYNC_P2P_RSA_SIZE);
debug(D_NOTICE, "key generated");
if (unlikely_log(rsa == PSYNC_INVALID_RSA))
goto rete;
rsapriv = psync_ssl_rsa_get_private(rsa);
rsapub = psync_ssl_rsa_get_public(rsa);
rsapriv = pssl_rsa_get_priv(rsa);
rsapub = pssl_rsa_get_pub(rsa);
if (likely_log(rsapub != PSYNC_INVALID_RSA))
rsapubbin = psync_ssl_rsa_public_to_binary(rsapub);
rsapubbin = pssl_rsa_bin_pub(rsapub);
else
rsapubbin = PSYNC_INVALID_BIN_RSA;
psync_ssl_free_rsa(rsa);
pssl_rsa_free(rsa);
if (likely_log(rsapriv != PSYNC_INVALID_RSA &&
rsapub != PSYNC_INVALID_RSA &&
rsapubbin != PSYNC_INVALID_BIN_RSA)) {
@ -594,11 +594,11 @@ static int psync_p2p_check_rsa() {
goto ret0;
} else {
if (rsapriv != PSYNC_INVALID_RSA)
psync_ssl_rsa_free_private(rsapriv);
pssl_rsa_free_priv(rsapriv);
if (rsapub != PSYNC_INVALID_RSA)
psync_ssl_rsa_free_public(rsapub);
pssl_rsa_free_pub(rsapub);
if (rsapubbin != PSYNC_INVALID_BIN_RSA)
psync_ssl_rsa_free_binary(rsapubbin);
pssl_rsa_bin_free(rsapubbin);
goto rete;
}
}
@ -672,18 +672,18 @@ static int psync_p2p_download(int sock, psync_fileid_t fileid,
debug(D_ERROR, "too long key - %u bytes", (unsigned)keylen);
return PSYNC_NET_PERMFAIL;
}
ekey = psync_ssl_alloc_encrypted_symmetric_key(keylen);
ekey = pssl_alloc_symkey(keylen);
if (unlikely_log(socket_read_all(sock, ekey->data, keylen)) ||
unlikely_log((key = psync_ssl_rsa_decrypt_symm_key_lock(
unlikely_log((key = pssl_symkey_decrypt_lock(
&privkey, &ekey)) == PSYNC_INVALID_SYM_KEY)) {
// unlikely_log((key=psync_ssl_rsa_decrypt_symmetric_key(&psync_rsa_private,
// unlikely_log((key=pssl_symkey_decrypt(&psync_rsa_private,
// &ekey))==PSYNC_INVALID_SYM_KEY)){
psync_free(ekey);
return PSYNC_NET_TEMPFAIL;
}
psync_free(ekey);
decoder = pcrypto_ctr_encdec_create(key);
psync_ssl_free_symmetric_key(key);
pssl_symkey_free(key);
if (decoder == PSYNC_CRYPTO_INVALID_ENCODER)
return PSYNC_NET_PERMFAIL;
fd = pfile_open(filename, O_WRONLY, O_CREAT | O_TRUNC);
@ -754,7 +754,7 @@ int pp2p_check_download(psync_fileid_t fileid,
pct1.type = P2P_CHECK;
memcpy(pct1.hashstart, filehashhex, PSYNC_P2P_HEXHASH_BYTES);
pct1.filesize = fsize;
psync_ssl_rand_weak(pct1.rand, sizeof(pct1.rand));
pssl_rand_weak(pct1.rand, sizeof(pct1.rand));
memcpy(hashsource, filehashhex, PSYNC_HASH_DIGEST_HEXLEN);
memcpy(hashsource + PSYNC_HASH_DIGEST_HEXLEN, pct1.rand, sizeof(pct1.rand));
psync_hash(hashsource, PSYNC_HASH_BLOCK_SIZE, hashbin);
@ -841,7 +841,7 @@ int pp2p_check_download(psync_fileid_t fileid,
goto err_perm2;
else if (bresp == P2P_RESP_WAIT) {
uint32_t rnd;
psync_ssl_rand_weak((unsigned char *)&rnd, sizeof(rnd));
pssl_rand_weak((unsigned char *)&rnd, sizeof(rnd));
rnd &= 0x7ff;
psys_sleep_milliseconds(PSYNC_P2P_SLEEP_WAIT_DOWNLOAD + rnd);
goto err_temp2;

4
pclsync/ppassword.c
View File

@ -351,8 +351,8 @@ uint64_t ppassword_score(const char *cpassword) {
ldpwd[nlen] = lpwd[nlen];
}
num = score_variants(password, lpwd, ldpwd, plen);
psync_ssl_memclean(lpwd, plen);
psync_ssl_memclean(ldpwd, plen);
pssl_memclean(lpwd, plen);
pssl_memclean(ldpwd, plen);
psync_free(lpwd);
psync_free(ldpwd);
mul_score(num);

4
pclsync/ppathstatus.c
View File

@ -216,7 +216,7 @@ void ppathstatus_reload_syncs() {
void ppathstatus_clear_cache() {
uint64_t ndrv_hash_seed, nsync_hash_seed;
do {
psync_ssl_rand_strong((unsigned char *)&ndrv_hash_seed,
pssl_rand_strong((unsigned char *)&ndrv_hash_seed,
sizeof(ndrv_hash_seed));
} while (unlikely(!ndrv_hash_seed));
nsync_hash_seed = 0x49916a8e891d1dafULL * ndrv_hash_seed;
@ -229,7 +229,7 @@ void ppathstatus_clear_cache() {
void ppathstatus_clear_sync_cache() {
uint64_t nsync_hash_seed;
do {
psync_ssl_rand_strong((unsigned char *)&nsync_hash_seed,
pssl_rand_strong((unsigned char *)&nsync_hash_seed,
sizeof(nsync_hash_seed));
} while (unlikely(nsync_hash_seed == drv_hash_seed));
psync_sql_lock();

44
pclsync/psock.c
View File

@ -384,7 +384,7 @@ int psock_try_write_buffer(psock_t *sock) {
continue;
}
if (sock->ssl) {
cw = psync_ssl_write(sock->ssl, b->buff + b->roffset,
cw = pssl_write(sock->ssl, b->buff + b->roffset,
b->woffset - b->roffset);
if (cw == PSYNC_SSL_FAIL) {
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
@ -431,7 +431,7 @@ int psock_try_write_buffer_thread(psock_t *sock) {
int psock_readable(psock_t *sock) {
psock_try_write_buffer(sock);
if (sock->ssl && psync_ssl_pendingdata(sock->ssl))
if (sock->ssl && pssl_pending(sock->ssl))
return 1;
else if (wait_readable(sock->sock, 0, 0))
return 0;
@ -466,13 +466,13 @@ psock_t *psock_connect(const char *host, int unsigned port, int ssl) {
}
if (ssl) {
ssl = psync_ssl_connect(sock, &sslc, host);
ssl = pssl_connect(sock, &sslc, host);
while (ssl == PSYNC_SSL_NEED_FINISH) {
if (wait_ssl_ready(sock)) {
psync_ssl_free(sslc);
pssl_free(sslc);
break;
}
ssl = psync_ssl_connect_finish(sslc, host);
ssl = pssl_connect_finish(sslc, host);
}
if (unlikely_log(ssl != PSYNC_SSL_SUCCESS)) {
close(sock);
@ -495,9 +495,9 @@ int psock_wait_write_timeout(int sock) {
void psock_close(psock_t *sock) {
if (sock->ssl)
while (psync_ssl_shutdown(sock->ssl) == PSYNC_SSL_NEED_FINISH)
while (pssl_shutdown(sock->ssl) == PSYNC_SSL_NEED_FINISH)
if (wait_ssl_ready(sock->sock)) {
psync_ssl_free(sock->ssl);
pssl_free(sock->ssl);
break;
}
psock_clear_write_buffered(sock);
@ -507,7 +507,7 @@ void psock_close(psock_t *sock) {
void psock_close_bad(psock_t *sock) {
if (sock->ssl)
psync_ssl_free(sock->ssl);
pssl_free(sock->ssl);
psock_clear_write_buffered(sock);
close(sock->sock);
psync_free(sock);
@ -576,7 +576,7 @@ int psock_pendingdata(psock_t *sock) {
if (sock->pending)
return 1;
if (sock->ssl)
return psync_ssl_pendingdata(sock->ssl);
return pssl_pending(sock->ssl);
else
return 0;
}
@ -590,7 +590,7 @@ int psock_pendingdata_buf(psock_t *sock) {
return -1;
#endif
if (sock->ssl)
ret += psync_ssl_pendingdata(sock->ssl);
ret += pssl_pending(sock->ssl);
return ret;
}
@ -605,13 +605,13 @@ int psock_pendingdata_buf_thread(psock_t *sock) {
static int psync_socket_read_ssl(psock_t *sock, void *buff, int num) {
int r;
psock_try_write_buffer(sock);
if (!psync_ssl_pendingdata(sock->ssl) && !sock->pending &&
if (!pssl_pending(sock->ssl) && !sock->pending &&
psock_wait_read_timeout(sock->sock))
return -1;
sock->pending = 0;
while (1) {
psock_try_write_buffer(sock);
r = psync_ssl_read(sock->ssl, buff, num);
r = pssl_read(sock->ssl, buff, num);
if (r == PSYNC_SSL_FAIL) {
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
psync_ssl_errno == PSYNC_SSL_ERR_WANT_WRITE)) {
@ -661,7 +661,7 @@ int psock_read(psock_t *sock, void *buff, int num) {
static int psync_socket_read_noblock_ssl(psock_t *sock, void *buff, int num) {
int r;
r = psync_ssl_read(sock->ssl, buff, num);
r = pssl_read(sock->ssl, buff, num);
if (r == PSYNC_SSL_FAIL) {
sock->pending = 0;
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
@ -701,14 +701,14 @@ static int psync_socket_read_ssl_thread(psock_t *sock, void *buff, int num) {
pthread_mutex_lock(&mutex);
psock_try_write_buffer(sock);
pthread_mutex_unlock(&mutex);
if (!psync_ssl_pendingdata(sock->ssl) && !sock->pending &&
if (!pssl_pending(sock->ssl) && !sock->pending &&
psock_wait_read_timeout(sock->sock))
return -1;
sock->pending = 0;
while (1) {
pthread_mutex_lock(&mutex);
psock_try_write_buffer(sock);
r = psync_ssl_read(sock->ssl, buff, num);
r = pssl_read(sock->ssl, buff, num);
pthread_mutex_unlock(&mutex);
if (r == PSYNC_SSL_FAIL) {
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
@ -800,7 +800,7 @@ int psock_write(psock_t *sock, const void *buff, int num) {
if (psock_wait_write_timeout(sock->sock))
return -1;
if (sock->ssl) {
r = psync_ssl_write(sock->ssl, buff, num);
r = pssl_write(sock->ssl, buff, num);
if (r == PSYNC_SSL_FAIL) {
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
psync_ssl_errno == PSYNC_SSL_ERR_WANT_WRITE))
@ -826,7 +826,7 @@ static int psync_socket_readall_ssl(psock_t *sock, void *buff, int num) {
psock_try_write_buffer(sock);
if (!psync_ssl_pendingdata(sock->ssl) && !sock->pending &&
if (!pssl_pending(sock->ssl) && !sock->pending &&
psock_wait_read_timeout(sock->sock)) {
return -1;
}
@ -836,7 +836,7 @@ static int psync_socket_readall_ssl(psock_t *sock, void *buff, int num) {
while (br < num) {
psock_try_write_buffer(sock);
r = psync_ssl_read(sock->ssl, (char *)buff + br, num - br);
r = pssl_read(sock->ssl, (char *)buff + br, num - br);
if (r == PSYNC_SSL_FAIL) {
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
@ -895,7 +895,7 @@ static int psync_socket_writeall_ssl(psock_t *sock, const void *buff, int num) {
int br, r;
br = 0;
while (br < num) {
r = psync_ssl_write(sock->ssl, (char *)buff + br, num - br);
r = pssl_write(sock->ssl, (char *)buff + br, num - br);
if (r == PSYNC_SSL_FAIL) {
if (psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
psync_ssl_errno == PSYNC_SSL_ERR_WANT_WRITE) {
@ -948,7 +948,7 @@ static int psync_socket_readall_ssl_thread(psock_t *sock, void *buff, int num) {
br = 0;
pthread_mutex_lock(&mutex);
psock_try_write_buffer(sock);
r = psync_ssl_pendingdata(sock->ssl);
r = pssl_pending(sock->ssl);
pthread_mutex_unlock(&mutex);
if (!r && !sock->pending && psock_wait_read_timeout(sock->sock))
return -1;
@ -956,7 +956,7 @@ static int psync_socket_readall_ssl_thread(psock_t *sock, void *buff, int num) {
while (br < num) {
pthread_mutex_lock(&mutex);
psock_try_write_buffer(sock);
r = psync_ssl_read(sock->ssl, (char *)buff + br, num - br);
r = pssl_read(sock->ssl, (char *)buff + br, num - br);
pthread_mutex_unlock(&mutex);
if (r == PSYNC_SSL_FAIL) {
if (likely_log(psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||
@ -1022,7 +1022,7 @@ static int psync_socket_writeall_ssl_thread(psock_t *sock, const void *buff,
if (sock->buffer)
r = psync_socket_write_to_buf(sock, buff, num);
else
r = psync_ssl_write(sock->ssl, (char *)buff + br, num - br);
r = pssl_write(sock->ssl, (char *)buff + br, num - br);
pthread_mutex_unlock(&mutex);
if (r == PSYNC_SSL_FAIL) {
if (psync_ssl_errno == PSYNC_SSL_ERR_WANT_READ ||

124
pclsync/pssl.c
View File

@ -98,7 +98,7 @@ static const int psync_mbed_ciphersuite[] = {
0};
static void psync_ssl_free_psync_encrypted_data_t(psync_encrypted_data_t e) {
psync_ssl_memclean(e->data, e->datalen);
pssl_memclean(e->data, e->datalen);
pmemlock_free(e);
}
@ -215,11 +215,11 @@ static int psync_ssl_check_peer_public_key(ssl_connection_t *conn) {
return -1;
}
void psync_ssl_set_log_threshold(int threshold) {
void pssl_set_log_threshold(int threshold) {
mbedtls_debug_set_threshold(threshold);
}
void psync_ssl_set_debug_callback(psync_ssl_debug_callback_t cb, void *ctx) {
void pssl_set_debug_cb(psync_ssl_debug_callback_t cb, void *ctx) {
debug_cb = cb;
debug_ctx = ctx;
}
@ -234,23 +234,23 @@ int ctr_drbg_random_locked(void *p_rng, unsigned char *output, size_t output_len
return ret;
}
void psync_ssl_rsa_free_binary(psync_binary_rsa_key_t bin) {
void pssl_rsa_bin_free(psync_binary_rsa_key_t bin) {
psync_ssl_free_psync_encrypted_data_t(bin);
}
void psync_ssl_free_symmetric_key(psync_symmetric_key_t key) {
psync_ssl_memclean(key->key, key->keylen);
void pssl_symkey_free(psync_symmetric_key_t key) {
pssl_memclean(key->key, key->keylen);
pmemlock_free(key);
}
psync_encrypted_symmetric_key_t psync_ssl_alloc_encrypted_symmetric_key(size_t len) {
psync_encrypted_symmetric_key_t pssl_alloc_symkey(size_t len) {
psync_encrypted_symmetric_key_t ret;
ret = psync_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
ret->datalen = len;
return ret;
}
psync_encrypted_symmetric_key_t psync_ssl_copy_encrypted_symmetric_key(psync_encrypted_symmetric_key_t src) {
psync_encrypted_symmetric_key_t pssl_symkey_copy(psync_encrypted_symmetric_key_t src) {
psync_encrypted_symmetric_key_t ret;
ret = psync_malloc(offsetof(psync_encrypted_data_struct_t, data) +
src->datalen);
@ -259,13 +259,13 @@ psync_encrypted_symmetric_key_t psync_ssl_copy_encrypted_symmetric_key(psync_enc
return ret;
}
psync_symmetric_key_t psync_ssl_rsa_decrypt_symm_key_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey) {
psync_symmetric_key_t pssl_symkey_decrypt_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey) {
psync_symmetric_key_t sym_key;
debug(D_NOTICE, "Get RSA decrypt key lock.");
pthread_mutex_lock(&rsa_decr_mutex);
sym_key = psync_ssl_rsa_decrypt_symmetric_key(*rsa, *enckey);
sym_key = pssl_symkey_decrypt(*rsa, *enckey);
pthread_mutex_unlock(&rsa_decr_mutex);
debug(D_NOTICE, "RSA decrypt key Lock released.");
@ -273,7 +273,7 @@ psync_symmetric_key_t psync_ssl_rsa_decrypt_symm_key_lock(psync_rsa_privatekey_t
return sym_key;
}
int psync_ssl_init() {
int pssl_init() {
unsigned char seed[PSYNC_LHASH_DIGEST_LEN];
unsigned long i;
int result;
@ -306,13 +306,13 @@ int psync_ssl_init() {
return 0;
}
void psync_ssl_memclean(void *ptr, size_t len) {
void pssl_memclean(void *ptr, size_t len) {
volatile unsigned char *p = ptr;
while (len--)
*p++ = 0;
}
int psync_ssl_connect(int sock, void **sslconn, const char *hostname) {
int pssl_connect(int sock, void **sslconn, const char *hostname) {
ssl_connection_t *conn;
mbedtls_ssl_session *sess;
int ret;
@ -404,7 +404,7 @@ err0:
return PRINT_RETURN_CONST(PSYNC_SSL_FAIL);
}
int psync_ssl_connect_finish(void *sslconn, const char *hostname) {
int pssl_connect_finish(void *sslconn, const char *hostname) {
ssl_connection_t *conn;
int ret;
@ -429,7 +429,7 @@ fail:
return PRINT_RETURN_CONST(PSYNC_SSL_FAIL);
}
int psync_ssl_shutdown(void *sslconn) {
int pssl_shutdown(void *sslconn) {
ssl_connection_t *conn;
int ret;
conn = (ssl_connection_t *)sslconn;
@ -448,18 +448,18 @@ noshutdown:
return PSYNC_SSL_SUCCESS;
}
void psync_ssl_free(void *sslconn) {
void pssl_free(void *sslconn) {
ssl_connection_t *conn;
conn = (ssl_connection_t *)sslconn;
mbedtls_ssl_free(&conn->ssl);
psync_free(conn);
}
int psync_ssl_pendingdata(void *sslconn) {
int pssl_pending(void *sslconn) {
return mbedtls_ssl_get_bytes_avail(&((ssl_connection_t *)sslconn)->ssl);
}
int psync_ssl_read(void *sslconn, void *buf, int num) {
int pssl_read(void *sslconn, void *buf, int num) {
ssl_connection_t *conn;
int res;
conn = (ssl_connection_t *)sslconn;
@ -470,7 +470,7 @@ int psync_ssl_read(void *sslconn, void *buf, int num) {
return PSYNC_SSL_FAIL;
}
int psync_ssl_write(void *sslconn, const void *buf, int num) {
int pssl_write(void *sslconn, const void *buf, int num) {
ssl_connection_t *conn;
int res;
conn = (ssl_connection_t *)sslconn;
@ -481,7 +481,7 @@ int psync_ssl_write(void *sslconn, const void *buf, int num) {
return PSYNC_SSL_FAIL;
}
void psync_ssl_rand_strong(unsigned char *buf, int num) {
void pssl_rand_strong(unsigned char *buf, int num) {
// FIXME: causing segfault
if (unlikely(ctr_drbg_random_locked(&psync_mbed_rng, buf, num))) {
debug(D_CRITICAL, "could not generate %d random bytes, exiting", num);
@ -489,11 +489,11 @@ void psync_ssl_rand_strong(unsigned char *buf, int num) {
}
}
void psync_ssl_rand_weak(unsigned char *buf, int num) {
psync_ssl_rand_strong(buf, num);
void pssl_rand_weak(unsigned char *buf, int num) {
pssl_rand_strong(buf, num);
}
psync_rsa_t psync_ssl_gen_rsa(int bits) {
psync_rsa_t pssl_rsa_gen(int bits) {
mbedtls_rsa_context *ctx;
ctx = psync_new(mbedtls_rsa_context);
mbedtls_rsa_init(ctx);
@ -507,27 +507,27 @@ psync_rsa_t psync_ssl_gen_rsa(int bits) {
return ctx;
}
void psync_ssl_free_rsa(psync_rsa_t rsa) {
void pssl_rsa_free(psync_rsa_t rsa) {
mbedtls_rsa_free(rsa);
psync_free(rsa);
}
psync_rsa_publickey_t psync_ssl_rsa_get_public(psync_rsa_t rsa) {
psync_rsa_publickey_t pssl_rsa_get_pub(psync_rsa_t rsa) {
psync_binary_rsa_key_t bin;
psync_rsa_publickey_t ret;
bin = psync_ssl_rsa_public_to_binary(rsa);
bin = pssl_rsa_bin_pub(rsa);
if (bin == PSYNC_INVALID_BIN_RSA)
return PSYNC_INVALID_RSA;
ret = psync_ssl_rsa_load_public(bin->data, bin->datalen);
psync_ssl_rsa_free_binary(bin);
ret = pssl_rsa_load_pub(bin->data, bin->datalen);
pssl_rsa_bin_free(bin);
return ret;
}
void psync_ssl_rsa_free_public(psync_rsa_publickey_t key) {
psync_ssl_free_rsa(key);
void pssl_rsa_free_pub(psync_rsa_publickey_t key) {
pssl_rsa_free(key);
}
psync_rsa_privatekey_t psync_ssl_rsa_get_private(psync_rsa_t rsa) {
psync_rsa_privatekey_t pssl_rsa_get_priv(psync_rsa_t rsa) {
mbedtls_rsa_context *ctx;
ctx = psync_new(mbedtls_rsa_context);
mbedtls_rsa_init(ctx);
@ -540,11 +540,11 @@ psync_rsa_privatekey_t psync_ssl_rsa_get_private(psync_rsa_t rsa) {
return ctx;
}
void psync_ssl_rsa_free_private(psync_rsa_privatekey_t key) {
psync_ssl_free_rsa(key);
void pssl_rsa_free_priv(psync_rsa_privatekey_t key) {
pssl_rsa_free(key);
}
psync_binary_rsa_key_t psync_ssl_rsa_public_to_binary(psync_rsa_publickey_t rsa) {
psync_binary_rsa_key_t pssl_rsa_bin_pub(psync_rsa_publickey_t rsa) {
unsigned char buff[4096], *p;
mbedtls_pk_context ctx;
psync_binary_rsa_key_t ret;
@ -565,7 +565,7 @@ psync_binary_rsa_key_t psync_ssl_rsa_public_to_binary(psync_rsa_publickey_t rsa)
return ret;
}
psync_binary_rsa_key_t psync_ssl_rsa_private_to_binary(psync_rsa_privatekey_t rsa) {
psync_binary_rsa_key_t pssl_rsa_priv_bin(psync_rsa_privatekey_t rsa) {
unsigned char buff[4096];
mbedtls_pk_context ctx;
psync_binary_rsa_key_t ret;
@ -582,11 +582,11 @@ psync_binary_rsa_key_t psync_ssl_rsa_private_to_binary(psync_rsa_privatekey_t rs
pmemlock_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
ret->datalen = len;
memcpy(ret->data, buff + sizeof(buff) - len, len);
psync_ssl_memclean(buff + sizeof(buff) - len, len);
pssl_memclean(buff + sizeof(buff) - len, len);
return ret;
}
psync_rsa_publickey_t psync_ssl_rsa_load_public(const unsigned char *keydata, size_t keylen) {
psync_rsa_publickey_t pssl_rsa_load_pub(const unsigned char *keydata, size_t keylen) {
mbedtls_pk_context ctx;
mbedtls_rsa_context *rsa;
int ret;
@ -614,15 +614,17 @@ psync_rsa_publickey_t psync_ssl_rsa_load_public(const unsigned char *keydata, si
}
}
psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata, size_t keylen) {
psync_rsa_privatekey_t pssl_rsa_load_priv(const unsigned char *keydata, size_t keylen) {
mbedtls_pk_context pkctx;
mbedtls_rsa_context *rsactx;
int ret;
mbedtls_pk_init(&pkctx);
ret = mbedtls_pk_parse_key(&pkctx, keydata, keylen, NULL, 0, mbedtls_ctr_drbg_random, &psync_mbed_rng.rnd);
if (unlikely(ret)) {
debug(D_WARNING, "failed to parse private key with code %d", 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 PSYNC_INVALID_RSA;
}
@ -641,7 +643,7 @@ psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata,
}
}
psync_symmetric_key_t psync_ssl_gen_symmetric_key_from_pass(const char *password, size_t keylen, const unsigned char *salt, size_t saltlen, size_t iterations) {
psync_symmetric_key_t pssl_gen_symkey_pass(const char *password, size_t keylen, const unsigned char *salt, size_t saltlen, size_t iterations) {
psync_symmetric_key_t key = (psync_symmetric_key_t)pmemlock_malloc(
keylen + offsetof(psync_symmetric_key_struct_t, key));
mbedtls_md_context_t ctx;
@ -657,7 +659,7 @@ psync_symmetric_key_t psync_ssl_gen_symmetric_key_from_pass(const char *password
return key;
}
char *psync_ssl_derive_password_from_passphrase(const char *username, const char *passphrase) {
char *pssl_derive_pwd(const char *username, const char *passphrase) {
unsigned char *usercopy;
unsigned char usersha512[PSYNC_SHA512_DIGEST_LEN], passwordbin[32];
mbedtls_md_context_t ctx;
@ -683,7 +685,7 @@ char *psync_ssl_derive_password_from_passphrase(const char *username, const char
return (char *)usercopy;
}
psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen) {
psync_encrypted_symmetric_key_t pssl_rsa_encrypt(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen) {
psync_encrypted_symmetric_key_t ret;
int code;
size_t rsalen;
@ -706,7 +708,7 @@ psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_data(psync_rsa_publickey_t
return ret;
}
psync_symmetric_key_t psync_ssl_rsa_decrypt_data(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen) {
psync_symmetric_key_t pssl_rsa_decrypt(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen) {
unsigned char buff[2048];
psync_symmetric_key_t ret;
size_t len;
@ -718,19 +720,19 @@ psync_symmetric_key_t psync_ssl_rsa_decrypt_data(psync_rsa_privatekey_t rsa, con
offsetof(psync_symmetric_key_struct_t, key) + len);
ret->keylen = len;
memcpy(ret->key, buff, len);
psync_ssl_memclean(buff, len);
pssl_memclean(buff, len);
return ret;
}
psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_symmetric_key(psync_rsa_publickey_t rsa, const psync_symmetric_key_t key) {
return psync_ssl_rsa_encrypt_data(rsa, key->key, key->keylen);
psync_encrypted_symmetric_key_t pssl_symkey_encrypt(psync_rsa_publickey_t rsa, const psync_symmetric_key_t key) {
return pssl_rsa_encrypt(rsa, key->key, key->keylen);
}
psync_symmetric_key_t psync_ssl_rsa_decrypt_symmetric_key(psync_rsa_privatekey_t rsa, const psync_encrypted_symmetric_key_t enckey) {
return psync_ssl_rsa_decrypt_data(rsa, enckey->data, enckey->datalen);
psync_symmetric_key_t pssl_symkey_decrypt(psync_rsa_privatekey_t rsa, const psync_encrypted_symmetric_key_t enckey) {
return pssl_rsa_decrypt(rsa, enckey->data, enckey->datalen);
}
psync_aes256_encoder psync_ssl_aes256_create_encoder(psync_symmetric_key_t key) {
psync_aes256_encoder pssl_enc_create(psync_symmetric_key_t key) {
mbedtls_aes_context *aes;
assert(key->keylen >= PSYNC_AES256_KEY_SIZE);
aes = psync_new(mbedtls_aes_context);
@ -738,12 +740,12 @@ psync_aes256_encoder psync_ssl_aes256_create_encoder(psync_symmetric_key_t key)
return aes;
}
void psync_ssl_aes256_free_encoder(psync_aes256_encoder aes) {
psync_ssl_memclean(aes, sizeof(mbedtls_aes_context));
void pssl_enc_free(psync_aes256_encoder aes) {
pssl_memclean(aes, sizeof(mbedtls_aes_context));
psync_free(aes);
}
psync_aes256_encoder psync_ssl_aes256_create_decoder(psync_symmetric_key_t key) {
psync_aes256_encoder pssl_dec_create(psync_symmetric_key_t key) {
mbedtls_aes_context *aes;
assert(key->keylen >= PSYNC_AES256_KEY_SIZE);
aes = psync_new(mbedtls_aes_context);
@ -751,12 +753,12 @@ psync_aes256_encoder psync_ssl_aes256_create_decoder(psync_symmetric_key_t key)
return aes;
}
void psync_ssl_aes256_free_decoder(psync_aes256_encoder aes) {
psync_ssl_memclean(aes, sizeof(mbedtls_aes_context));
void pssl_dec_free(psync_aes256_encoder aes) {
pssl_memclean(aes, sizeof(mbedtls_aes_context));
psync_free(aes);
}
psync_rsa_signature_t psync_ssl_rsa_sign_sha256_hash(psync_rsa_privatekey_t rsa, const unsigned char *data) {
psync_rsa_signature_t pssl_sha256_sign(psync_rsa_privatekey_t rsa, const unsigned char *data) {
psync_rsa_signature_t ret;
int padding, hash_id;
size_t rsalen;
@ -796,27 +798,27 @@ void psync_aes256_decode_4blocks_consec_xor_sw(psync_aes256_decoder enc, const u
((unsigned long *)dst)[i] ^= ((unsigned long *)bxor)[i];
}
void psync_aes256_encode_block(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst) {
void pssl_enc_blk(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst) {
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT, src, dst);
}
void psync_aes256_decode_block(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) {
void pssl_dec_blk(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) {
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src, dst);
}
void psync_aes256_encode_2blocks_consec(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) {
void pssl_enc_2blk(psync_aes256_decoder 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 psync_aes256_decode_2blocks_consec(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst) {
void pssl_dec_2blk(psync_aes256_decoder 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 psync_aes256_decode_4blocks_consec_xor(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor) {
void pssl_dec_4blk_xor(psync_aes256_decoder 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,

90
pclsync/pssl.h
View File

@ -95,7 +95,7 @@ extern PSYNC_THREAD int psync_ssl_errno;
#define PSYNC_SSL_FAIL -1
#define PSYNC_SSL_SUCCESS 0
#define psync_ssl_alloc_binary_rsa psync_ssl_alloc_encrypted_symmetric_key
#define psync_ssl_alloc_binary_rsa pssl_alloc_symkey
typedef struct {
size_t datalen;
@ -118,49 +118,49 @@ typedef psync_encrypted_data_t psync_rsa_signature_t;
typedef void (*psync_ssl_debug_callback_t)(void *ctx, int level, const char *msg, int, const char *);
void psync_ssl_set_log_threshold(int threshold);
void psync_ssl_set_debug_callback(psync_ssl_debug_callback_t cb, void *ctx);
int psync_ssl_init();
void psync_ssl_memclean(void *ptr, size_t len);
int psync_ssl_connect(int sock, void **sslconn, const char *hostname);
int psync_ssl_connect_finish(void *sslconn, const char *hostname);
void psync_ssl_free(void *sslconn);
int psync_ssl_shutdown(void *sslconn);
int psync_ssl_pendingdata(void *sslconn);
int psync_ssl_read(void *sslconn, void *buf, int num);
int psync_ssl_write(void *sslconn, const void *buf, int num);
void psync_ssl_rand_strong(unsigned char *buf, int num);
void psync_ssl_rand_weak(unsigned char *buf, int num);
psync_rsa_t psync_ssl_gen_rsa(int bits);
void psync_ssl_free_rsa(psync_rsa_t rsa);
psync_rsa_publickey_t psync_ssl_rsa_get_public(psync_rsa_t rsa);
void psync_ssl_rsa_free_public(psync_rsa_publickey_t key);
psync_rsa_privatekey_t psync_ssl_rsa_get_private(psync_rsa_t rsa);
void psync_ssl_rsa_free_private(psync_rsa_privatekey_t key);
psync_binary_rsa_key_t psync_ssl_rsa_public_to_binary(psync_rsa_publickey_t rsa);
psync_binary_rsa_key_t psync_ssl_rsa_private_to_binary(psync_rsa_privatekey_t rsa);
psync_rsa_publickey_t psync_ssl_rsa_load_public(const unsigned char *keydata, size_t keylen);
psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata, size_t keylen);
void psync_ssl_rsa_free_binary(psync_binary_rsa_key_t bin);
psync_symmetric_key_t psync_ssl_gen_symmetric_key_from_pass(const char *password, size_t keylen, const unsigned char *salt, size_t saltlen, size_t iterations);
char *psync_ssl_derive_password_from_passphrase(const char *username, const char *passphrase);
psync_encrypted_symmetric_key_t psync_ssl_alloc_encrypted_symmetric_key(size_t len);
psync_encrypted_symmetric_key_t psync_ssl_copy_encrypted_symmetric_key(psync_encrypted_symmetric_key_t src);
void psync_ssl_free_symmetric_key(psync_symmetric_key_t key);
psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen);
psync_symmetric_key_t psync_ssl_rsa_decrypt_data(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen);
psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_symmetric_key(psync_rsa_publickey_t rsa, const psync_symmetric_key_t key);
psync_symmetric_key_t psync_ssl_rsa_decrypt_symmetric_key(psync_rsa_privatekey_t rsa, const psync_encrypted_symmetric_key_t enckey);
psync_aes256_encoder psync_ssl_aes256_create_encoder(psync_symmetric_key_t key);
void psync_ssl_aes256_free_encoder(psync_aes256_encoder aes);
psync_aes256_encoder psync_ssl_aes256_create_decoder(psync_symmetric_key_t key);
void psync_ssl_aes256_free_decoder(psync_aes256_encoder aes);
psync_rsa_signature_t psync_ssl_rsa_sign_sha256_hash(psync_rsa_privatekey_t rsa, const unsigned char *data);
psync_symmetric_key_t psync_ssl_rsa_decrypt_symm_key_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey);
void psync_aes256_encode_block(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst);
void psync_aes256_decode_block(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst);
void psync_aes256_encode_2blocks_consec(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst);
void psync_aes256_decode_2blocks_consec(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst);
void psync_aes256_decode_4blocks_consec_xor(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor);
void pssl_set_log_threshold(int threshold);
void pssl_set_debug_cb(psync_ssl_debug_callback_t cb, void *ctx);
int pssl_init();
void pssl_memclean(void *ptr, size_t len);
int pssl_connect(int sock, void **sslconn, const char *hostname);
int pssl_connect_finish(void *sslconn, const char *hostname);
void pssl_free(void *sslconn);
int pssl_shutdown(void *sslconn);
int pssl_pending(void *sslconn);
int pssl_read(void *sslconn, void *buf, int num);
int pssl_write(void *sslconn, const void *buf, int num);
void pssl_rand_strong(unsigned char *buf, int num);
void pssl_rand_weak(unsigned char *buf, int num);
psync_rsa_t pssl_rsa_gen(int bits);
void pssl_rsa_free(psync_rsa_t rsa);
psync_rsa_publickey_t pssl_rsa_get_pub(psync_rsa_t rsa);
void pssl_rsa_free_pub(psync_rsa_publickey_t key);
psync_rsa_privatekey_t pssl_rsa_get_priv(psync_rsa_t rsa);
void pssl_rsa_free_priv(psync_rsa_privatekey_t key);
psync_binary_rsa_key_t pssl_rsa_bin_pub(psync_rsa_publickey_t rsa);
psync_binary_rsa_key_t pssl_rsa_priv_bin(psync_rsa_privatekey_t rsa);
psync_rsa_publickey_t pssl_rsa_load_pub(const unsigned char *keydata, size_t keylen);
psync_rsa_privatekey_t pssl_rsa_load_priv(const unsigned char *keydata, size_t keylen);
void pssl_rsa_bin_free(psync_binary_rsa_key_t bin);
psync_symmetric_key_t pssl_gen_symkey_pass(const char *password, size_t keylen, const unsigned char *salt, size_t saltlen, size_t iterations);
char *pssl_derive_pwd(const char *username, const char *passphrase);
psync_encrypted_symmetric_key_t pssl_alloc_symkey(size_t len);
psync_encrypted_symmetric_key_t pssl_symkey_copy(psync_encrypted_symmetric_key_t src);
void pssl_symkey_free(psync_symmetric_key_t key);
psync_encrypted_symmetric_key_t pssl_rsa_encrypt(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen);
psync_symmetric_key_t pssl_rsa_decrypt(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen);
psync_encrypted_symmetric_key_t pssl_symkey_encrypt(psync_rsa_publickey_t rsa, const psync_symmetric_key_t key);
psync_symmetric_key_t pssl_symkey_decrypt(psync_rsa_privatekey_t rsa, const psync_encrypted_symmetric_key_t enckey);
psync_aes256_encoder pssl_enc_create(psync_symmetric_key_t key);
void pssl_enc_free(psync_aes256_encoder aes);
psync_aes256_encoder pssl_dec_create(psync_symmetric_key_t key);
void pssl_dec_free(psync_aes256_encoder aes);
psync_rsa_signature_t pssl_sha256_sign(psync_rsa_privatekey_t rsa, const unsigned char *data);
psync_symmetric_key_t pssl_symkey_decrypt_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey);
void pssl_enc_blk(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst);
void pssl_dec_blk(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst);
void pssl_enc_2blk(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst);
void pssl_dec_2blk(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst);
void pssl_dec_4blk_xor(psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, unsigned char *bxor);
#endif

12
pclsync/psynclib.c
View File

@ -230,11 +230,11 @@ static void ssl_debug_cb(void *ctx, int level, const char *msg, int TODO1,
void psync_set_ssl_debug_callback(psync_ssl_debug_callback_t cb) {
if (cb) {
psync_ssl_set_log_threshold(PSYNC_SSL_DEBUG_LEVEL);
psync_ssl_set_debug_callback(cb, NULL);
pssl_set_log_threshold(PSYNC_SSL_DEBUG_LEVEL);
pssl_set_debug_cb(cb, NULL);
} else {
psync_ssl_set_log_threshold(0);
psync_ssl_set_debug_callback(NULL, NULL);
pssl_set_log_threshold(0);
pssl_set_debug_cb(NULL, NULL);
}
}
@ -283,7 +283,7 @@ int psync_init() {
}
psync_sql_statement("UPDATE task SET inprogress=0 WHERE inprogress=1");
ptimer_init();
if (unlikely_log(psync_ssl_init())) {
if (unlikely_log(pssl_init())) {
if (IS_DEBUG)
pthread_mutex_unlock(&psync_libstate_mutex);
return_error(PERROR_SSL_INIT_FAILED);
@ -2182,7 +2182,7 @@ int psync_password_quality10000(const char *password) {
char *psync_derive_password_from_passphrase(const char *username,
const char *passphrase) {
return psync_ssl_derive_password_from_passphrase(username, passphrase);
return pssl_derive_pwd(username, passphrase);
}
int psync_crypto_setup(const char *password, const char *hint) {