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

OMG this code is driving me nuts!!!

This commit is contained in:
Levi Neely 2025-03-04 17:41:22 +01:00
parent 4cc4152223
commit 935319f918
10 changed files with 265 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

284
pclsync/pcrypto.c
View File

@ -48,27 +48,27 @@
#include <string.h>
typedef struct {
psync_sha512_ctx sha1ctx;
unsigned char final[PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN];
pssl_sha512_ctx sha1ctx;
unsigned char final[PSSL_SHA512_BLOCK_LEN + PSSL_SHA512_DIGEST_LEN];
} psync_hmac_sha512_ctx;
static void psync_hmac_sha512_init(psync_hmac_sha512_ctx *ctx,
const unsigned char *key, size_t keylen) {
unsigned char keyxor[PSYNC_SHA512_BLOCK_LEN];
unsigned char keyxor[PSSL_SHA512_BLOCK_LEN];
size_t i;
if (keylen > PSYNC_SHA512_BLOCK_LEN)
keylen = PSYNC_SHA512_BLOCK_LEN;
if (keylen > PSSL_SHA512_BLOCK_LEN)
keylen = PSSL_SHA512_BLOCK_LEN;
for (i = 0; i < keylen; i++) {
keyxor[i] = key[i] ^ 0x36;
ctx->final[i] = key[i] ^ 0x5c;
}
for (; i < PSYNC_SHA512_BLOCK_LEN; i++) {
for (; i < PSSL_SHA512_BLOCK_LEN; i++) {
keyxor[i] = 0x36;
ctx->final[i] = 0x5c;
}
psync_sha512_init(&ctx->sha1ctx);
psync_sha512_update(&ctx->sha1ctx, keyxor, PSYNC_SHA512_BLOCK_LEN);
pssl_cleanup(keyxor, PSYNC_SHA512_BLOCK_LEN);
psync_sha512_update(&ctx->sha1ctx, keyxor, PSSL_SHA512_BLOCK_LEN);
pssl_cleanup(keyxor, PSSL_SHA512_BLOCK_LEN);
}
static void psync_hmac_sha512_update(psync_hmac_sha512_ctx *ctx,
@ -78,42 +78,42 @@ static void psync_hmac_sha512_update(psync_hmac_sha512_ctx *ctx,
static void psync_hmac_sha512_final(unsigned char *result,
psync_hmac_sha512_ctx *ctx) {
psync_sha512_final(ctx->final + PSYNC_SHA512_BLOCK_LEN, &ctx->sha1ctx);
psync_sha512(ctx->final, PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN,
psync_sha512_final(ctx->final + PSSL_SHA512_BLOCK_LEN, &ctx->sha1ctx);
psync_sha512(ctx->final, PSSL_SHA512_BLOCK_LEN + PSSL_SHA512_DIGEST_LEN,
result);
pssl_cleanup(ctx->final,
PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN);
PSSL_SHA512_BLOCK_LEN + PSSL_SHA512_DIGEST_LEN);
}
static void psync_hmac_sha512(const unsigned char *msg, size_t msglen,
const unsigned char *key, size_t keylen,
unsigned char *result) {
psync_sha512_ctx sha1ctx;
unsigned char keyxor[PSYNC_SHA512_BLOCK_LEN],
final[PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN];
pssl_sha512_ctx sha1ctx;
unsigned char keyxor[PSSL_SHA512_BLOCK_LEN],
final[PSSL_SHA512_BLOCK_LEN + PSSL_SHA512_DIGEST_LEN];
size_t i;
if (keylen > PSYNC_SHA512_BLOCK_LEN)
keylen = PSYNC_SHA512_BLOCK_LEN;
if (keylen > PSSL_SHA512_BLOCK_LEN)
keylen = PSSL_SHA512_BLOCK_LEN;
for (i = 0; i < keylen; i++) {
keyxor[i] = key[i] ^ 0x36;
final[i] = key[i] ^ 0x5c;
}
for (; i < PSYNC_SHA512_BLOCK_LEN; i++) {
for (; i < PSSL_SHA512_BLOCK_LEN; i++) {
keyxor[i] = 0x36;
final[i] = 0x5c;
}
psync_sha512_init(&sha1ctx);
psync_sha512_update(&sha1ctx, keyxor, PSYNC_SHA512_BLOCK_LEN);
psync_sha512_update(&sha1ctx, keyxor, PSSL_SHA512_BLOCK_LEN);
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);
pssl_cleanup(keyxor, PSYNC_SHA512_BLOCK_LEN);
pssl_cleanup(final, PSYNC_SHA512_BLOCK_LEN + PSYNC_SHA512_DIGEST_LEN);
psync_sha512_final(final + PSSL_SHA512_BLOCK_LEN, &sha1ctx);
psync_sha512(final, PSSL_SHA512_BLOCK_LEN + PSSL_SHA512_DIGEST_LEN, result);
pssl_cleanup(keyxor, PSSL_SHA512_BLOCK_LEN);
pssl_cleanup(final, PSSL_SHA512_BLOCK_LEN + PSSL_SHA512_DIGEST_LEN);
}
#define ALIGN_A256_BS(n) \
((((n) + PSYNC_AES256_BLOCK_SIZE - 1) / PSYNC_AES256_BLOCK_SIZE) * \
PSYNC_AES256_BLOCK_SIZE)
((((n) + PAES_BLOCK_SIZE - 1) / PAES_BLOCK_SIZE) * \
PAES_BLOCK_SIZE)
#define ALIGN_PTR_A256_BS(ptr) \
((unsigned char *)ALIGN_A256_BS((uintptr_t)(ptr)))
@ -122,7 +122,7 @@ static void psync_hmac_sha512(const unsigned char *msg, size_t msglen,
static void xor16_unaligned_inplace(unsigned char *data,
const unsigned char *key) {
unsigned long i;
for (i = 0; i < PSYNC_AES256_BLOCK_SIZE; i++)
for (i = 0; i < PAES_BLOCK_SIZE; i++)
data[i] ^= key[i];
}
@ -170,8 +170,8 @@ pssl_symkey_t *pcrypto_key_len(size_t len) {
}
pssl_symkey_t *pcrypto_key() {
return pcrypto_key_len(PSYNC_AES256_KEY_SIZE +
PSYNC_AES256_BLOCK_SIZE);
return pcrypto_key_len(PAES_KEY_SIZE +
PAES_BLOCK_SIZE);
}
pcrypto_ctr_encdec_t
@ -179,47 +179,47 @@ pcrypto_ctr_encdec_create(pssl_symkey_t *key) {
pssl_encoder_t enc;
pcrypto_ctr_encdec_t ret;
if (unlikely_log(key->keylen <
PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE))
PAES_KEY_SIZE + PAES_BLOCK_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = paes_encoder_create(key);
if (unlikely_log(enc == PAES_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = psync_new(pcrypto_key_t);
ret->encoder = enc;
memcpy(ret->iv, key->key + PSYNC_AES256_KEY_SIZE, PSYNC_AES256_BLOCK_SIZE);
memcpy(ret->iv, key->key + PAES_KEY_SIZE, PAES_BLOCK_SIZE);
return ret;
}
void pcrypto_ctr_encdec_free(
pcrypto_ctr_encdec_t enc) {
paes_encoder_free(enc->encoder);
pssl_cleanup(enc->iv, PSYNC_AES256_BLOCK_SIZE);
pssl_cleanup(enc->iv, PAES_BLOCK_SIZE);
psync_free(enc);
}
void pcrypto_ctr_encdec_encode(
pcrypto_ctr_encdec_t enc, void *data, size_t datalen,
uint64_t dataoffset) {
unsigned char buff[PSYNC_AES256_BLOCK_SIZE * 3], *aessrc, *aesdst;
unsigned char buff[PAES_BLOCK_SIZE * 3], *aessrc, *aesdst;
uint64_t counter;
size_t blocksrem;
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
counter = dataoffset / PSYNC_AES256_BLOCK_SIZE;
aesdst = aessrc + PAES_BLOCK_SIZE;
counter = dataoffset / PAES_BLOCK_SIZE;
memcpy(aessrc + sizeof(uint64_t), enc->iv + sizeof(uint64_t),
PSYNC_AES256_BLOCK_SIZE - sizeof(uint64_t));
dataoffset %= PSYNC_AES256_BLOCK_SIZE;
PAES_BLOCK_SIZE - sizeof(uint64_t));
dataoffset %= PAES_BLOCK_SIZE;
if (dataoffset) {
copy_iv_and_xor_with_counter(aessrc, enc->iv, counter);
paes_blk_encode(enc->encoder, aessrc, aesdst);
blocksrem = PSYNC_AES256_BLOCK_SIZE - dataoffset;
blocksrem = PAES_BLOCK_SIZE - dataoffset;
xor_cnt_inplace(data, aesdst + dataoffset, blocksrem);
datalen -= blocksrem;
counter++;
data = (char *)data + blocksrem;
}
blocksrem = datalen / PSYNC_AES256_BLOCK_SIZE;
datalen -= blocksrem * PSYNC_AES256_BLOCK_SIZE;
blocksrem = datalen / PAES_BLOCK_SIZE;
datalen -= blocksrem * PAES_BLOCK_SIZE;
if (IS_WORD_ALIGNED(data)) {
while (blocksrem) {
copy_iv_and_xor_with_counter(aessrc, enc->iv, counter);
@ -227,7 +227,7 @@ void pcrypto_ctr_encdec_encode(
xor16_aligned_inplace(data, aesdst);
blocksrem--;
counter++;
data = (char *)data + PSYNC_AES256_BLOCK_SIZE;
data = (char *)data + PAES_BLOCK_SIZE;
}
} else {
while (blocksrem) {
@ -236,7 +236,7 @@ void pcrypto_ctr_encdec_encode(
xor16_unaligned_inplace(data, aesdst);
blocksrem--;
counter++;
data = (char *)data + PSYNC_AES256_BLOCK_SIZE;
data = (char *)data + PAES_BLOCK_SIZE;
}
}
if (datalen) {
@ -247,7 +247,7 @@ void pcrypto_ctr_encdec_encode(
}
static void copy_unaligned(unsigned char *dst, const unsigned char *src) {
memcpy(dst, src, PSYNC_AES256_BLOCK_SIZE);
memcpy(dst, src, PAES_BLOCK_SIZE);
}
static void copy_aligned(unsigned char *dst, const unsigned char *src) {
@ -281,64 +281,64 @@ static void copy_pad(unsigned char *dst, size_t cnt,
void pcrypto_encode_text(pcrypto_textenc_t enc,
const unsigned char *txt, size_t txtlen,
unsigned char **out, size_t *outlen) {
unsigned char buff[PSYNC_AES256_BLOCK_SIZE * 3 + PSYNC_SHA512_DIGEST_LEN],
unsigned char buff[PAES_BLOCK_SIZE * 3 + PSSL_SHA512_DIGEST_LEN],
*aessrc, *aesdst, *outptr, *hmac;
size_t ol;
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
hmac = aessrc + PSYNC_AES256_BLOCK_SIZE * 2;
aesdst = aessrc + PAES_BLOCK_SIZE;
hmac = aessrc + PAES_BLOCK_SIZE * 2;
ol = ALIGN_A256_BS(txtlen);
outptr = psync_new_cnt(unsigned char, ol);
*out = outptr;
*outlen = ol;
if (txtlen <= PSYNC_AES256_BLOCK_SIZE) {
copy_pad(aessrc, PSYNC_AES256_BLOCK_SIZE, &txt, &txtlen);
assert(enc->ivlen >= PSYNC_AES256_BLOCK_SIZE);
if (txtlen <= PAES_BLOCK_SIZE) {
copy_pad(aessrc, PAES_BLOCK_SIZE, &txt, &txtlen);
assert(enc->ivlen >= PAES_BLOCK_SIZE);
xor16_aligned_inplace(aessrc, enc->iv);
paes_blk_encode(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
return;
}
psync_hmac_sha512(txt + PSYNC_AES256_BLOCK_SIZE,
txtlen - PSYNC_AES256_BLOCK_SIZE, enc->iv, enc->ivlen,
psync_hmac_sha512(txt + PAES_BLOCK_SIZE,
txtlen - PAES_BLOCK_SIZE, enc->iv, enc->ivlen,
hmac);
copy_unaligned(aessrc, txt);
txt += PSYNC_AES256_BLOCK_SIZE;
txtlen -= PSYNC_AES256_BLOCK_SIZE;
txt += PAES_BLOCK_SIZE;
txtlen -= PAES_BLOCK_SIZE;
xor16_aligned_inplace(aessrc, hmac);
paes_blk_encode(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
do {
copy_pad(aessrc, PSYNC_AES256_BLOCK_SIZE, &txt, &txtlen);
copy_pad(aessrc, PAES_BLOCK_SIZE, &txt, &txtlen);
xor16_aligned_inplace(aessrc, aesdst);
paes_blk_encode(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
} while (txtlen);
}
unsigned char *
pcrypto_decode_text(pcrypto_textdec_t enc,
const unsigned char *data, size_t datalen) {
unsigned char buff[PSYNC_AES256_BLOCK_SIZE * 2 + PSYNC_SHA512_DIGEST_LEN],
unsigned char buff[PAES_BLOCK_SIZE * 2 + PSSL_SHA512_DIGEST_LEN],
*aessrc, *aesdst, *outptr, *ret;
size_t len;
const unsigned char *xorptr;
if (unlikely_log(datalen % PSYNC_AES256_BLOCK_SIZE || !datalen))
if (unlikely_log(datalen % PAES_BLOCK_SIZE || !datalen))
return NULL;
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
aesdst = aessrc + PAES_BLOCK_SIZE;
outptr = psync_new_cnt(unsigned char, datalen + 1);
ret = outptr;
datalen /= PSYNC_AES256_BLOCK_SIZE;
datalen /= PAES_BLOCK_SIZE;
if (datalen == 1) {
copy_unaligned(aessrc, data);
paes_blk_decode(enc->encoder, aessrc, aesdst);
assert(enc->ivlen >= PSYNC_AES256_BLOCK_SIZE);
assert(enc->ivlen >= PAES_BLOCK_SIZE);
xor16_aligned_inplace(aesdst, enc->iv);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
*outptr = 0;
len = strlen((char *)ret) + 1;
while (ret + len < outptr) {
@ -355,37 +355,37 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
copy_aligned(aessrc, data);
paes_blk_decode(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
while (--datalen) {
xorptr = data;
data += PSYNC_AES256_BLOCK_SIZE;
data += PAES_BLOCK_SIZE;
copy_aligned(aessrc, data);
paes_blk_decode(enc->encoder, aessrc, aesdst);
xor16_aligned_inplace(aesdst, xorptr);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
}
} else {
copy_unaligned(aessrc, data);
paes_blk_decode(enc->encoder, aessrc, aesdst);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
while (--datalen) {
xorptr = data;
data += PSYNC_AES256_BLOCK_SIZE;
data += PAES_BLOCK_SIZE;
copy_unaligned(aessrc, data);
paes_blk_decode(enc->encoder, aessrc, aesdst);
xor16_unaligned_inplace(aesdst, xorptr);
copy_aligned(outptr, aesdst);
outptr += PSYNC_AES256_BLOCK_SIZE;
outptr += PAES_BLOCK_SIZE;
}
}
*outptr = 0;
len = strlen((char *)ret + PSYNC_AES256_BLOCK_SIZE);
psync_hmac_sha512(ret + PSYNC_AES256_BLOCK_SIZE, len, enc->iv, enc->ivlen,
len = strlen((char *)ret + PAES_BLOCK_SIZE);
psync_hmac_sha512(ret + PAES_BLOCK_SIZE, len, enc->iv, enc->ivlen,
aessrc);
xor16_aligned_inplace(ret, aessrc);
len += PSYNC_AES256_BLOCK_SIZE + 1;
len += PAES_BLOCK_SIZE + 1;
while (ret + len < outptr) {
if (unlikely(ret[len] != 0)) {
debug(D_WARNING, "non-zero in the padding found");
@ -402,17 +402,17 @@ pcrypto_textenc_create(pssl_symkey_t *key) {
pssl_encoder_t enc;
pcrypto_textenc_t ret;
if (unlikely_log(key->keylen <
PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE))
PAES_KEY_SIZE + PAES_BLOCK_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = paes_encoder_create(key);
if (unlikely_log(enc == PAES_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = (pcrypto_textenc_t)pmemlock_malloc(
offsetof(pcrypto_key_iv_t, iv) + key->keylen -
PSYNC_AES256_KEY_SIZE);
PAES_KEY_SIZE);
ret->encoder = enc;
ret->ivlen = key->keylen - PSYNC_AES256_KEY_SIZE;
memcpy(ret->iv, key->key + PSYNC_AES256_KEY_SIZE, ret->ivlen);
ret->ivlen = key->keylen - PAES_KEY_SIZE;
memcpy(ret->iv, key->key + PAES_KEY_SIZE, ret->ivlen);
return ret;
}
@ -428,17 +428,17 @@ pcrypto_textdec_create(pssl_symkey_t *key) {
pssl_encoder_t enc;
pcrypto_textenc_t ret;
if (unlikely_log(key->keylen <
PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE))
PAES_KEY_SIZE + PAES_BLOCK_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = paes_decoder_create(key);
if (unlikely_log(enc == PAES_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = (pcrypto_textenc_t)pmemlock_malloc(
offsetof(pcrypto_key_iv_t, iv) + key->keylen -
PSYNC_AES256_KEY_SIZE);
PAES_KEY_SIZE);
ret->encoder = enc;
ret->ivlen = key->keylen - PSYNC_AES256_KEY_SIZE;
memcpy(ret->iv, key->key + PSYNC_AES256_KEY_SIZE, ret->ivlen);
ret->ivlen = key->keylen - PAES_KEY_SIZE;
memcpy(ret->iv, key->key + PAES_KEY_SIZE, ret->ivlen);
return ret;
}
@ -454,7 +454,7 @@ pcrypto_sec_encdec_create(pssl_symkey_t *key) {
pssl_encoder_t enc;
pssl_decoder_t dec;
pcrypto_sector_encdec_t ret;
if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE))
if (unlikely_log(key->keylen < PAES_KEY_SIZE))
return PSYNC_CRYPTO_INVALID_ENCODER;
enc = paes_encoder_create(key);
if (unlikely_log(enc == PAES_INVALID_ENCODER))
@ -466,11 +466,11 @@ pcrypto_sec_encdec_create(pssl_symkey_t *key) {
}
ret = (pcrypto_sector_encdec_t)pmemlock_malloc(
offsetof(pcrypto_encdec_iv_t, iv) + key->keylen -
PSYNC_AES256_KEY_SIZE);
PAES_KEY_SIZE);
ret->encoder = enc;
ret->decoder = dec;
ret->ivlen = key->keylen - PSYNC_AES256_KEY_SIZE;
memcpy(ret->iv, key->key + PSYNC_AES256_KEY_SIZE, ret->ivlen);
ret->ivlen = key->keylen - PAES_KEY_SIZE;
memcpy(ret->iv, key->key + PAES_KEY_SIZE, ret->ivlen);
return ret;
}
@ -497,49 +497,49 @@ void pcrypto_encode_sec(
size_t datalen, unsigned char *out, pcrypto_sector_auth_t authout,
uint64_t sectorid) {
psync_hmac_sha512_ctx ctx;
unsigned char buff[PSYNC_AES256_BLOCK_SIZE * 3],
hmacsha1bin[PSYNC_SHA512_DIGEST_LEN], rnd[PSYNC_AES256_BLOCK_SIZE];
unsigned char buff[PAES_BLOCK_SIZE * 3],
hmacsha1bin[PSSL_SHA512_DIGEST_LEN], rnd[PAES_BLOCK_SIZE];
unsigned char *aessrc, *aesdst, *tmp;
uint32_t needsteal;
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
assert(PSYNC_CRYPTO_AUTH_SIZE == 2 * PSYNC_AES256_BLOCK_SIZE);
pssl_random(rnd, PSYNC_AES256_BLOCK_SIZE);
aesdst = aessrc + PAES_BLOCK_SIZE;
assert(PSYNC_CRYPTO_AUTH_SIZE == 2 * PAES_BLOCK_SIZE);
pssl_random(rnd, PAES_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));
psync_hmac_sha512_update(&ctx, rnd, PSYNC_AES256_BLOCK_SIZE);
psync_hmac_sha512_update(&ctx, rnd, PAES_BLOCK_SIZE);
psync_hmac_sha512_final(hmacsha1bin, &ctx);
if (unlikely(datalen < PSYNC_AES256_BLOCK_SIZE)) {
memcpy(aessrc, rnd, PSYNC_AES256_BLOCK_SIZE);
if (unlikely(datalen < PAES_BLOCK_SIZE)) {
memcpy(aessrc, rnd, PAES_BLOCK_SIZE);
xor_cnt_inplace(aessrc, data, datalen);
memcpy(out, rnd, datalen);
memcpy(aesdst, hmacsha1bin, PSYNC_AES256_BLOCK_SIZE);
memcpy(aesdst, hmacsha1bin, PAES_BLOCK_SIZE);
paes_2blk_encode(enc->encoder, aessrc, aessrc);
memcpy(authout, aessrc, PSYNC_AES256_BLOCK_SIZE * 2);
memcpy(authout, aessrc, PAES_BLOCK_SIZE * 2);
return;
}
if (unlikely(datalen % 16)) {
needsteal = datalen % 16;
datalen -= needsteal + PSYNC_AES256_BLOCK_SIZE;
datalen -= needsteal + PAES_BLOCK_SIZE;
} else
needsteal = 0;
memcpy(aessrc, rnd, PSYNC_AES256_BLOCK_SIZE / 2);
memcpy(aessrc + PSYNC_AES256_BLOCK_SIZE / 2, hmacsha1bin,
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);
memcpy(aessrc, rnd, PAES_BLOCK_SIZE / 2);
memcpy(aessrc + PAES_BLOCK_SIZE / 2, hmacsha1bin,
PAES_BLOCK_SIZE);
memcpy(aessrc + PAES_BLOCK_SIZE + PAES_BLOCK_SIZE / 2,
rnd + PAES_BLOCK_SIZE / 2, PAES_BLOCK_SIZE / 2);
paes_2blk_encode(enc->encoder, aessrc, aessrc);
memcpy(authout, aessrc, PSYNC_AES256_BLOCK_SIZE * 2);
memcpy(aessrc, hmacsha1bin, PSYNC_AES256_BLOCK_SIZE);
memcpy(authout, aessrc, PAES_BLOCK_SIZE * 2);
memcpy(aessrc, hmacsha1bin, PAES_BLOCK_SIZE);
if (IS_WORD_ALIGNED(data) && IS_WORD_ALIGNED(out))
while (datalen) {
xor16_aligned_inplace(aessrc, data);
paes_blk_encode(enc->encoder, aessrc, aesdst);
copy_aligned(out, aesdst);
datalen -= PSYNC_AES256_BLOCK_SIZE;
data += PSYNC_AES256_BLOCK_SIZE;
out += PSYNC_AES256_BLOCK_SIZE;
datalen -= PAES_BLOCK_SIZE;
data += PAES_BLOCK_SIZE;
out += PAES_BLOCK_SIZE;
tmp = aessrc;
aessrc = aesdst;
aesdst = tmp;
@ -549,18 +549,18 @@ void pcrypto_encode_sec(
xor16_unaligned_inplace(aessrc, data);
paes_blk_encode(enc->encoder, aessrc, aesdst);
copy_unaligned(out, aesdst);
datalen -= PSYNC_AES256_BLOCK_SIZE;
data += PSYNC_AES256_BLOCK_SIZE;
out += PSYNC_AES256_BLOCK_SIZE;
datalen -= PAES_BLOCK_SIZE;
data += PAES_BLOCK_SIZE;
out += PAES_BLOCK_SIZE;
tmp = aessrc;
aessrc = aesdst;
aesdst = tmp;
}
if (unlikely(needsteal)) {
xor16_unaligned_inplace(aessrc, data);
data += PSYNC_AES256_BLOCK_SIZE;
data += PAES_BLOCK_SIZE;
paes_blk_encode(enc->encoder, aessrc, aesdst);
memcpy(out + PSYNC_AES256_BLOCK_SIZE, aesdst, needsteal);
memcpy(out + PAES_BLOCK_SIZE, aesdst, needsteal);
xor_cnt_inplace(aesdst, data, needsteal);
paes_blk_encode(enc->encoder, aesdst, aessrc);
copy_unaligned(out, aessrc);
@ -572,20 +572,20 @@ int pcrypto_decode_sec(
size_t datalen, unsigned char *out, const pcrypto_sector_auth_t auth,
uint64_t sectorid) {
psync_hmac_sha512_ctx ctx;
unsigned char buff[PSYNC_AES256_BLOCK_SIZE * 15],
hmacsha1bin[PSYNC_SHA512_DIGEST_LEN];
unsigned char buff[PAES_BLOCK_SIZE * 15],
hmacsha1bin[PSSL_SHA512_DIGEST_LEN];
unsigned char *aessrc, *aesdst, *aesxor, *hmac, *oout, *tmp;
size_t odatalen;
uint32_t needsteal;
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE * 4;
aesxor = aessrc + PSYNC_AES256_BLOCK_SIZE * 8;
hmac = aessrc + PSYNC_AES256_BLOCK_SIZE * 12;
memcpy(aessrc, auth, PSYNC_AES256_BLOCK_SIZE * 2);
aesdst = aessrc + PAES_BLOCK_SIZE * 4;
aesxor = aessrc + PAES_BLOCK_SIZE * 8;
hmac = aessrc + PAES_BLOCK_SIZE * 12;
memcpy(aessrc, auth, PAES_BLOCK_SIZE * 2);
paes_2blk_decode(enc->decoder, aessrc, hmac);
oout = out;
odatalen = datalen;
if (unlikely(datalen < PSYNC_AES256_BLOCK_SIZE)) {
if (unlikely(datalen < PAES_BLOCK_SIZE)) {
xor_cnt_inplace(hmac, data, datalen);
memcpy(aessrc, data, datalen);
memcpy(out, hmac, datalen);
@ -593,35 +593,35 @@ int pcrypto_decode_sec(
} else {
if (unlikely(datalen % 16)) {
needsteal = datalen % 16;
datalen -= needsteal + PSYNC_AES256_BLOCK_SIZE;
datalen -= needsteal + PAES_BLOCK_SIZE;
} else
needsteal = 0;
memcpy(aesxor, hmac + PSYNC_AES256_BLOCK_SIZE / 2, PSYNC_AES256_BLOCK_SIZE);
memcpy(hmac + PSYNC_AES256_BLOCK_SIZE / 2,
hmac + PSYNC_AES256_BLOCK_SIZE + PSYNC_AES256_BLOCK_SIZE / 2,
PSYNC_AES256_BLOCK_SIZE / 2);
memcpy(hmac + PSYNC_AES256_BLOCK_SIZE, aesxor, PSYNC_AES256_BLOCK_SIZE);
while (datalen >= PSYNC_AES256_BLOCK_SIZE * 4) {
memcpy(aessrc, data, PSYNC_AES256_BLOCK_SIZE * 4);
memcpy(aesxor + PSYNC_AES256_BLOCK_SIZE, aessrc,
PSYNC_AES256_BLOCK_SIZE * 3);
memcpy(aesxor, hmac + PAES_BLOCK_SIZE / 2, PAES_BLOCK_SIZE);
memcpy(hmac + PAES_BLOCK_SIZE / 2,
hmac + PAES_BLOCK_SIZE + PAES_BLOCK_SIZE / 2,
PAES_BLOCK_SIZE / 2);
memcpy(hmac + PAES_BLOCK_SIZE, aesxor, PAES_BLOCK_SIZE);
while (datalen >= PAES_BLOCK_SIZE * 4) {
memcpy(aessrc, data, PAES_BLOCK_SIZE * 4);
memcpy(aesxor + PAES_BLOCK_SIZE, aessrc,
PAES_BLOCK_SIZE * 3);
paes_4blk_xor_decode(enc->decoder, aessrc, aesdst,
aesxor);
memcpy(out, aesdst, PSYNC_AES256_BLOCK_SIZE * 4);
memcpy(aesxor, aessrc + PSYNC_AES256_BLOCK_SIZE * 3,
PSYNC_AES256_BLOCK_SIZE);
datalen -= PSYNC_AES256_BLOCK_SIZE * 4;
data += PSYNC_AES256_BLOCK_SIZE * 4;
out += PSYNC_AES256_BLOCK_SIZE * 4;
memcpy(out, aesdst, PAES_BLOCK_SIZE * 4);
memcpy(aesxor, aessrc + PAES_BLOCK_SIZE * 3,
PAES_BLOCK_SIZE);
datalen -= PAES_BLOCK_SIZE * 4;
data += PAES_BLOCK_SIZE * 4;
out += PAES_BLOCK_SIZE * 4;
}
while (datalen) {
copy_unaligned(aessrc, data);
paes_blk_decode(enc->decoder, aessrc, aesdst);
xor16_aligned_inplace(aesdst, aesxor);
copy_unaligned(out, aesdst);
data += PSYNC_AES256_BLOCK_SIZE;
out += PSYNC_AES256_BLOCK_SIZE;
datalen -= PSYNC_AES256_BLOCK_SIZE;
data += PAES_BLOCK_SIZE;
out += PAES_BLOCK_SIZE;
datalen -= PAES_BLOCK_SIZE;
tmp = aesxor;
aesxor = aessrc;
aessrc = tmp;
@ -629,11 +629,11 @@ int pcrypto_decode_sec(
if (unlikely(needsteal)) {
copy_unaligned(aessrc, data);
paes_blk_decode(enc->decoder, aessrc, aesdst);
xor_cnt_inplace(aesdst, data + PSYNC_AES256_BLOCK_SIZE, needsteal);
xor_cnt_inplace(aesdst, data + PAES_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(aessrc, data + PAES_BLOCK_SIZE, needsteal);
memcpy(out + PAES_BLOCK_SIZE, aesdst, needsteal);
memcpy(aesdst, aessrc, needsteal);
paes_blk_decode(enc->decoder, aesdst, aessrc);
xor16_aligned_inplace(aessrc, aesxor);
@ -643,20 +643,20 @@ int pcrypto_decode_sec(
psync_hmac_sha512_init(&ctx, enc->iv, enc->ivlen);
psync_hmac_sha512_update(&ctx, oout, odatalen);
psync_hmac_sha512_update(&ctx, &sectorid, sizeof(sectorid));
psync_hmac_sha512_update(&ctx, hmac, PSYNC_AES256_BLOCK_SIZE);
psync_hmac_sha512_update(&ctx, hmac, PAES_BLOCK_SIZE);
psync_hmac_sha512_final(hmacsha1bin, &ctx);
return -memcmp_const(hmacsha1bin, hmac + PSYNC_AES256_BLOCK_SIZE,
PSYNC_AES256_BLOCK_SIZE);
return -memcmp_const(hmacsha1bin, hmac + PAES_BLOCK_SIZE,
PAES_BLOCK_SIZE);
}
void pcrypto_sign_sec(
pcrypto_sector_encdec_t enc, const unsigned char *data,
size_t datalen, pcrypto_sector_auth_t authout) {
unsigned char buff[PSYNC_AES256_BLOCK_SIZE * 3 + PSYNC_SHA512_DIGEST_LEN];
unsigned char buff[PAES_BLOCK_SIZE * 3 + PSSL_SHA512_DIGEST_LEN];
unsigned char *aessrc, *aesdst;
aesdst = ALIGN_PTR_A256_BS(buff);
aessrc = aesdst + PSYNC_AES256_BLOCK_SIZE * 2;
aessrc = aesdst + PAES_BLOCK_SIZE * 2;
psync_hmac_sha512(data, datalen, enc->iv, enc->ivlen, aessrc);
paes_2blk_encode(enc->encoder, aessrc, aesdst);
memcpy(authout, aesdst, PSYNC_AES256_BLOCK_SIZE * 2);
memcpy(authout, aesdst, PAES_BLOCK_SIZE * 2);
}

4
pclsync/pcrypto.h
View File

@ -34,7 +34,7 @@
#include "pssl.h"
#define PSYNC_CRYPTO_AUTH_SIZE (PSYNC_AES256_BLOCK_SIZE * 2)
#define PSYNC_CRYPTO_AUTH_SIZE (PAES_BLOCK_SIZE * 2)
#define PSYNC_CRYPTO_MAX_HASH_TREE_LEVEL 6
@ -53,7 +53,7 @@ typedef struct {
pssl_encoder_t encoder;
union {
long unsigned __aligner;
unsigned char iv[PSYNC_AES256_BLOCK_SIZE];
unsigned char iv[PAES_BLOCK_SIZE];
};
} pcrypto_key_t;

44
pclsync/pcryptofolder.c
View File

@ -90,7 +90,7 @@ typedef struct {
typedef struct {
uint32_t type;
uint32_t flags;
unsigned char aeskey[PSYNC_AES256_KEY_SIZE];
unsigned char aeskey[PAES_KEY_SIZE];
unsigned char hmackey[PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN];
} sym_key_ver1;
@ -368,8 +368,8 @@ psync_cloud_crypto_setup_upload(const unsigned char *rsapriv, size_t rsaprivlen,
int pcryptofolder_setup(const char *password, const char *hint) {
unsigned char salt[PSYNC_CRYPTO_PBKDF2_SALT_LEN];
char publicsha1[PSYNC_SHA1_DIGEST_HEXLEN + 2],
privatesha1[PSYNC_SHA1_DIGEST_HEXLEN + 2];
char publicsha1[PSSL_SHA1_DIGEST_HEXLEN + 2],
privatesha1[PSSL_SHA1_DIGEST_HEXLEN + 2];
pssl_symkey_t *aeskey;
pcrypto_ctr_encdec_t enc;
pssl_context_t rsa;
@ -382,7 +382,7 @@ int pcryptofolder_setup(const char *password, const char *hint) {
pssl_random(salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
debug(D_NOTICE, "generating AES key from password and setting up encoder");
aeskey = psymkey_generate_passphrase(
password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt,
password, PAES_KEY_SIZE + PAES_BLOCK_SIZE, salt,
PSYNC_CRYPTO_PBKDF2_SALT_LEN, PSYNC_CRYPTO_PASS_TO_KEY_ITERATIONS);
enc = pcrypto_ctr_encdec_create(aeskey);
psymkey_free(aeskey);
@ -526,8 +526,8 @@ static int crypto_keys_match() {
}
int pcryptofolder_unlock(const char *password) {
char publicsha1[PSYNC_SHA1_DIGEST_HEXLEN + 2],
privatesha1[PSYNC_SHA1_DIGEST_HEXLEN + 2];
char publicsha1[PSSL_SHA1_DIGEST_HEXLEN + 2],
privatesha1[PSSL_SHA1_DIGEST_HEXLEN + 2];
psync_sql_res *res;
psync_variant_row row;
const char *id;
@ -619,7 +619,7 @@ retry:
debug(D_NOTICE, "generating symmetric key");
aeskey = psymkey_generate_passphrase(
password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen,
password, PAES_KEY_SIZE + PAES_BLOCK_SIZE, salt, saltlen,
iterations);
enc = pcrypto_ctr_encdec_create(aeskey);
psymkey_free(aeskey);
@ -1063,11 +1063,11 @@ static pssl_symkey_t
*psync_crypto_sym_key_ver1_to_sym_key(sym_key_ver1 *v1) {
pssl_symkey_t *key;
key = (pssl_symkey_t *)pmemlock_malloc(
offsetof(pssl_symkey_t, key) + PSYNC_AES256_KEY_SIZE +
offsetof(pssl_symkey_t, key) + PAES_KEY_SIZE +
PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
key->keylen = PSYNC_AES256_KEY_SIZE + PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN;
memcpy(key->key, v1->aeskey, PSYNC_AES256_KEY_SIZE);
memcpy(key->key + PSYNC_AES256_KEY_SIZE, v1->hmackey,
key->keylen = PAES_KEY_SIZE + PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN;
memcpy(key->key, v1->aeskey, PAES_KEY_SIZE);
memcpy(key->key + PAES_KEY_SIZE, v1->hmackey,
PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
return key;
}
@ -1739,7 +1739,7 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) {
sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC;
sym.flags = flags;
pssl_random(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
pssl_random(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pssl_random(sym.aeskey, PAES_KEY_SIZE);
pthread_rwlock_rdlock(&crypto_lock);
if (!crypto_started_l) {
pthread_rwlock_unlock(&crypto_lock);
@ -1768,7 +1768,7 @@ char *pcryptofolder_filencoder_key_newplain(
sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC;
sym.flags = flags;
pssl_random(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
pssl_random(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pssl_random(sym.aeskey, PAES_KEY_SIZE);
pthread_rwlock_rdlock(&crypto_lock);
if (!crypto_started_l) {
pthread_rwlock_unlock(&crypto_lock);
@ -1802,7 +1802,7 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name,
sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC;
sym.flags = PSYNC_CRYPTO_SYM_FLAG_ISDIR;
pssl_random(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
pssl_random(sym.aeskey, PSYNC_AES256_KEY_SIZE);
pssl_random(sym.aeskey, PAES_KEY_SIZE);
pthread_rwlock_rdlock(&crypto_lock);
if (!crypto_started_l) {
pthread_rwlock_unlock(&crypto_lock);
@ -1839,7 +1839,7 @@ int psync_pcloud_crypto_reencode_key(
pssl_rsapubkey_t pub;
pssl_rsaprivkey_t priv;
unsigned char *newpriv;
unsigned char newprivsha[PSYNC_SHA256_DIGEST_LEN];
unsigned char newprivsha[PSSL_SHA256_DIGEST_LEN];
pssl_signature_t rsasign;
size_t newprivlen, dummy;
if (unlikely(rsapublen <= sizeof(uint32_t) || rsaprivlen <= sizeof(uint32_t)))
@ -1870,7 +1870,7 @@ int psync_pcloud_crypto_reencode_key(
goto err_bk_1;
rsapriv_struct = (priv_key_ver1 *)rsapriv;
aeskey = psymkey_generate_passphrase(
oldpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE,
oldpassphrase, PAES_KEY_SIZE + PAES_BLOCK_SIZE,
rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000);
if (unlikely(aeskey == PSYMKEY_INVALID))
goto err_nm_1;
@ -1897,7 +1897,7 @@ int psync_pcloud_crypto_reencode_key(
rsapriv_struct->flags = flags;
pssl_random(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
aeskey = psymkey_generate_passphrase(
newpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE,
newpassphrase, PAES_KEY_SIZE + PAES_BLOCK_SIZE,
rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000);
if (unlikely(aeskey == PSYMKEY_INVALID))
goto err_nm_1;
@ -1970,7 +1970,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
pcrypto_ctr_encdec_t enc;
pssl_symkey_t *aeskey;
size_t rsaprivlen, dummy;
unsigned char newprivsha[PSYNC_SHA256_DIGEST_LEN];
unsigned char newprivsha[PSSL_SHA256_DIGEST_LEN];
pssl_signature_t rsasign;
rsapriv = prsa_binary_private(crypto_privkey);
if (rsapriv == PRSA_INVALID)
@ -1985,7 +1985,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
rsapriv_struct->flags = flags;
pssl_random(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
aeskey = psymkey_generate_passphrase(
newpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE,
newpassphrase, PAES_KEY_SIZE + PAES_BLOCK_SIZE,
rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000);
if (unlikely(aeskey == PSYMKEY_INVALID))
goto err_nm_1;
@ -2166,8 +2166,8 @@ int pcryptofolder_change_pass_unlocked(const char *newpassphrase,
}
void sha1_hex_null_term(const void *data, size_t len, char *out) {
unsigned char sha1bin[PSYNC_SHA1_DIGEST_LEN];
unsigned char sha1bin[PSSL_SHA1_DIGEST_LEN];
psync_sha1((const unsigned char *)data, len, (unsigned char *)sha1bin);
psync_binhex(out, sha1bin, PSYNC_SHA1_DIGEST_LEN);
out[PSYNC_SHA1_DIGEST_HEXLEN] = 0;
psync_binhex(out, sha1bin, PSSL_SHA1_DIGEST_LEN);
out[PSSL_SHA1_DIGEST_HEXLEN] = 0;
}

14
pclsync/pdiff.c
View File

@ -185,7 +185,7 @@ static binresult *get_userinfo_user_digest(psock_t *sock, const char *username,
PAPI_STR("timeformat", "timestamp"),
PAPI_LSTR("username", username, userlen),
PAPI_LSTR("digest", digest, diglen),
PAPI_LSTR("passworddigest", pwddig, PSYNC_SHA1_DIGEST_HEXLEN),
PAPI_LSTR("passworddigest", pwddig, PSSL_SHA1_DIGEST_HEXLEN),
PAPI_STR("osversion", osversion),
PAPI_STR("appversion", appversion),
PAPI_STR("deviceid", deviceid),
@ -203,13 +203,13 @@ static binresult *get_userinfo_user_pass(psock_t *sock, const char *username,
const char *appversion, const char *deviceid,
const char *devicestring) {
binparam empty_params[] = {PAPI_STR("MS", "sucks")};
psync_sha1_ctx ctx;
pssl_sha1_ctx ctx;
binresult *res, *ret;
const binresult *dig;
unsigned char *uc;
size_t ul, i;
unsigned char sha1bin[PSYNC_SHA1_DIGEST_LEN];
char sha1hex[PSYNC_SHA1_DIGEST_HEXLEN];
unsigned char sha1bin[PSSL_SHA1_DIGEST_LEN];
char sha1hex[PSSL_SHA1_DIGEST_HEXLEN];
res = papi_send2(sock, "getdigest", empty_params);
@ -233,13 +233,13 @@ static binresult *get_userinfo_user_pass(psock_t *sock, const char *username,
psync_sha1(uc, ul, sha1bin);
psync_free(uc);
psync_binhex(sha1hex, sha1bin, PSYNC_SHA1_DIGEST_LEN);
psync_binhex(sha1hex, sha1bin, PSSL_SHA1_DIGEST_LEN);
psync_sha1_init(&ctx);
psync_sha1_update(&ctx, password, strlen(password));
psync_sha1_update(&ctx, sha1hex, PSYNC_SHA1_DIGEST_HEXLEN);
psync_sha1_update(&ctx, sha1hex, PSSL_SHA1_DIGEST_HEXLEN);
psync_sha1_update(&ctx, dig->str, dig->length);
psync_sha1_final(sha1bin, &ctx);
psync_binhex(sha1hex, sha1bin, PSYNC_SHA1_DIGEST_LEN);
psync_binhex(sha1hex, sha1bin, PSSL_SHA1_DIGEST_LEN);
ret = get_userinfo_user_digest(sock, username, ul, sha1hex, dig->str,
dig->length, osversion, appversion, deviceid,

8
pclsync/plocalscan.c
View File

@ -102,7 +102,7 @@ static device_inode_t *ignored_paths = NULL;
static uint32_t ign_paths_cnt = 0;
static uint32_t ign_paths_alloc = 0;
static time_t ign_last_check = 0;
static unsigned char ign_checksum[PSYNC_SHA256_DIGEST_LEN];
static unsigned char ign_checksum[PSSL_SHA256_DIGEST_LEN];
static pthread_mutex_t scan_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t scan_cond = PTHREAD_COND_INITIALIZER;
@ -211,7 +211,7 @@ static void add_ignored_dir(const char *path) {
}
static void reload_ignored_folders() {
unsigned char checkcurr[PSYNC_SHA256_DIGEST_LEN];
unsigned char checkcurr[PSSL_SHA256_DIGEST_LEN];
const char *ign, *start, *end, *next;
char *dir, *home;
size_t ignlen, dirlen, homelen;
@ -221,11 +221,11 @@ static void reload_ignored_folders() {
psync_sha256((const unsigned char *)ign, ignlen, checkcurr);
if (!memcmp(ign_checksum, checkcurr, PSYNC_SHA256_DIGEST_LEN) &&
if (!memcmp(ign_checksum, checkcurr, PSSL_SHA256_DIGEST_LEN) &&
ign_last_check + 3600 < ptimer_time())
return;
memcpy(ign_checksum, checkcurr, PSYNC_SHA256_DIGEST_LEN);
memcpy(ign_checksum, checkcurr, PSSL_SHA256_DIGEST_LEN);
ign_last_check = ptimer_time();
ign_paths_cnt = 0;
next = ign;

18
pclsync/pnetlibs.c
View File

@ -71,7 +71,7 @@ struct _psync_file_lock_t {
};
typedef struct {
unsigned char mbedtls_sha1[PSYNC_SHA1_DIGEST_LEN];
unsigned char mbedtls_sha1[PSSL_SHA1_DIGEST_LEN];
uint32_t adler;
} psync_block_checksum;
@ -1741,7 +1741,7 @@ static int psync_sha1_cmp(const void *p1, const void *p2){
psync_block_checksum **b1=(psync_block_checksum **)p1;
psync_block_checksum **b2=(psync_block_checksum **)p2;
return memcmp((*b1)->mbedtls_sha1, (*b2)->mbedtls_sha1,
PSYNC_SHA1_DIGEST_LEN);
PSSL_SHA1_DIGEST_LEN);
}
static psync_block_checksum
@ -1796,7 +1796,7 @@ psync_net_create_hash(const psync_file_checksums *checksums) {
do {
if (!memcmp(checksums->blocks[i].mbedtls_sha1,
checksums->blocks[h->elements[o] - 1].mbedtls_sha1,
PSYNC_SHA1_DIGEST_LEN)) {
PSSL_SHA1_DIGEST_LEN)) {
checksums->next[i] = h->elements[o];
break;
}
@ -1828,7 +1828,7 @@ static void psync_net_hash_remove(psync_file_checksum_hash *restrict hash,
return;
else if (checksums->blocks[idx - 1].adler == adler &&
!memcmp(checksums->blocks[idx - 1].mbedtls_sha1, mbedtls_sha1,
PSYNC_SHA1_DIGEST_LEN))
PSSL_SHA1_DIGEST_LEN))
break;
else if (++o >= hash->elementcnt)
o = 0;
@ -1910,7 +1910,7 @@ static uint32_t psync_net_hash_has_adler_and_sha1(
return 0;
else if (checksums->blocks[idx - 1].adler == adler &&
!memcmp(checksums->blocks[idx - 1].mbedtls_sha1, mbedtls_sha1,
PSYNC_SHA1_DIGEST_LEN))
PSSL_SHA1_DIGEST_LEN))
return idx;
else if (++o >= hash->elementcnt)
o = 0;
@ -1992,8 +1992,8 @@ static void psync_net_check_file_for_blocks(
ssize_t rd;
int fd;
uint32_t adler, off;
psync_sha1_ctx ctx;
unsigned char sha1bin[PSYNC_SHA1_DIGEST_LEN];
pssl_sha1_ctx ctx;
unsigned char sha1bin[PSSL_SHA1_DIGEST_LEN];
debug(D_NOTICE, "scanning file %s for blocks", name);
fd = pfile_open(name, O_RDONLY, 0);
if (fd == INVALID_HANDLE_VALUE)
@ -2159,8 +2159,8 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
ssize_t rd;
uint32_t adler, blockidx;
int32_t skipbytes;
psync_sha1_ctx ctx;
unsigned char sha1bin[PSYNC_SHA1_DIGEST_LEN];
pssl_sha1_ctx ctx;
unsigned char sha1bin[PSSL_SHA1_DIGEST_LEN];
if (unlikely_log(pfile_seek(fd, off, SEEK_SET) == -1))
return PSYNC_NET_TEMPFAIL;
debug(D_NOTICE, "scanning in range starting %lu, length %lu, blocksize %u",

16
pclsync/psettings.h
View File

@ -187,19 +187,19 @@
#define PSYNC_CHECKSUM "sha1"
#define PSYNC_HASH_BLOCK_SIZE PSYNC_SHA1_BLOCK_LEN
#define PSYNC_HASH_DIGEST_LEN PSYNC_SHA1_DIGEST_LEN
#define PSYNC_HASH_DIGEST_HEXLEN PSYNC_SHA1_DIGEST_HEXLEN
#define psync_hash_ctx psync_sha1_ctx
#define PSYNC_HASH_BLOCK_SIZE PSSL_SHA1_BLOCK_LEN
#define PSYNC_HASH_DIGEST_LEN PSSL_SHA1_DIGEST_LEN
#define PSYNC_HASH_DIGEST_HEXLEN PSSL_SHA1_DIGEST_HEXLEN
#define psync_hash_ctx pssl_sha1_ctx
#define psync_hash psync_sha1
#define psync_hash_init psync_sha1_init
#define psync_hash_update psync_sha1_update
#define psync_hash_final psync_sha1_final
#define PSYNC_LHASH_BLOCK_SIZE PSYNC_SHA512_BLOCK_LEN
#define PSYNC_LHASH_DIGEST_LEN PSYNC_SHA512_DIGEST_LEN
#define PSYNC_LHASH_DIGEST_HEXLEN PSYNC_SHA512_DIGEST_HEXLEN
#define psync_lhash_ctx psync_sha512_ctx
#define PSYNC_LHASH_BLOCK_SIZE PSSL_SHA512_BLOCK_LEN
#define PSYNC_LHASH_DIGEST_LEN PSSL_SHA512_DIGEST_LEN
#define PSYNC_LHASH_DIGEST_HEXLEN PSSL_SHA512_DIGEST_HEXLEN
#define psync_lhash_ctx pssl_sha512_ctx
#define psync_lhash psync_sha512
#define psync_lhash_init psync_sha512_init
#define psync_lhash_update psync_sha512_update

32
pclsync/pssl.c
View File

@ -218,28 +218,28 @@ static void set_errno(pssl_connection_t *conn, int err) {
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);
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT, src + PAES_BLOCK_SIZE,
dst + PAES_BLOCK_SIZE);
}
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);
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src + PAES_BLOCK_SIZE,
dst + PAES_BLOCK_SIZE);
}
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,
dst + PSYNC_AES256_BLOCK_SIZE);
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src + PAES_BLOCK_SIZE,
dst + PAES_BLOCK_SIZE);
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT,
src + PSYNC_AES256_BLOCK_SIZE * 2,
dst + PSYNC_AES256_BLOCK_SIZE * 2);
src + PAES_BLOCK_SIZE * 2,
dst + PAES_BLOCK_SIZE * 2);
mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT,
src + PSYNC_AES256_BLOCK_SIZE * 3,
dst + PSYNC_AES256_BLOCK_SIZE * 3);
for (i = 0; i < PSYNC_AES256_BLOCK_SIZE * 4 / sizeof(unsigned long); i++)
src + PAES_BLOCK_SIZE * 3,
dst + PAES_BLOCK_SIZE * 3);
for (i = 0; i < PAES_BLOCK_SIZE * 4 / sizeof(unsigned long); i++)
((unsigned long *)dst)[i] ^= ((unsigned long *)bxor)[i];
}
@ -253,7 +253,7 @@ void paes_blk_decode(pssl_decoder_t enc, const unsigned char *src, unsigned char
pssl_encoder_t paes_decoder_create(pssl_symkey_t *key) {
mbedtls_aes_context *aes;
assert(key->keylen >= PSYNC_AES256_KEY_SIZE);
assert(key->keylen >= PAES_KEY_SIZE);
aes = psync_new(mbedtls_aes_context);
mbedtls_aes_setkey_dec(aes, key->key, 256);
return aes;
@ -266,7 +266,7 @@ void paes_decoder_free(pssl_encoder_t aes) {
pssl_encoder_t paes_encoder_create(pssl_symkey_t *key) {
mbedtls_aes_context *aes;
assert(key->keylen >= PSYNC_AES256_KEY_SIZE);
assert(key->keylen >= PAES_KEY_SIZE);
aes = psync_new(mbedtls_aes_context);
mbedtls_aes_setkey_enc(aes, key->key, 256);
return aes;
@ -447,7 +447,7 @@ pssl_signature_t prsa_signature(pssl_rsaprivkey_t rsa, const unsigned char *data
mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA256);
if (mbedtls_rsa_rsassa_pss_sign(rsa, drbg_random_safe, &psync_mbed_rng,
MBEDTLS_MD_SHA256,
PSYNC_SHA256_DIGEST_LEN, data, ret->data)) {
PSSL_SHA256_DIGEST_LEN, data, ret->data)) {
free(ret);
mbedtls_rsa_set_padding(rsa, padding, hash_id);
return (pssl_signature_t)(void *)PSYNC_CRYPTO_NOT_STARTED;
@ -728,7 +728,7 @@ pssl_symkey_t *psymkey_decrypt_lock(pssl_rsaprivkey_t *rsa, const pssl_enc_symke
char *psymkey_derive_passphrase(const char *username, const char *passphrase) {
unsigned char *usercopy;
unsigned char usersha512[PSYNC_SHA512_DIGEST_LEN], passwordbin[32];
unsigned char usersha512[PSSL_SHA512_DIGEST_LEN], passwordbin[32];
mbedtls_md_context_t ctx;
size_t userlen, i;
userlen = strlen(username);
@ -746,7 +746,7 @@ char *psymkey_derive_passphrase(const char *username, const char *passphrase) {
const mbedtls_md_info_t *md_info = mbedtls_md_info_from_ctx(&ctx);
mbedtls_md_type_t md_type = mbedtls_md_get_type(md_info);
mbedtls_pkcs5_pbkdf2_hmac_ext(md_type, (const unsigned char *)passphrase, strlen(passphrase), usersha512,
PSYNC_SHA512_DIGEST_LEN, 5000, sizeof(passwordbin), passwordbin);
PSSL_SHA512_DIGEST_LEN, 5000, sizeof(passwordbin), passwordbin);
mbedtls_md_free(&ctx);
usercopy = psync_base64_encode(passwordbin, sizeof(passwordbin), &userlen);
return (char *)usercopy;

86
pclsync/pssl.h
View File

@ -41,49 +41,17 @@
#include "pcompiler.h"
// AES256
#define PSYNC_AES256_BLOCK_SIZE 16
#define PSYNC_AES256_KEY_SIZE 32
// SHA1
#define PSYNC_SHA1_BLOCK_LEN 64
#define PSYNC_SHA1_DIGEST_LEN 20
#define PSYNC_SHA1_DIGEST_HEXLEN 40
#define psync_sha1_ctx mbedtls_sha1_context
#define psync_sha1(data, datalen, checksum) \
mbedtls_sha1(data, datalen, checksum)
#define psync_sha1_init(pctx) mbedtls_sha1_starts(pctx)
#define psync_sha1_update(pctx, data, datalen) \
mbedtls_sha1_update(pctx, (const unsigned char *)data, datalen)
#define psync_sha1_final(checksum, pctx) mbedtls_sha1_finish(pctx, checksum)
// SHA256
#define PSYNC_SHA256_BLOCK_LEN 64
#define PSYNC_SHA256_DIGEST_LEN 32
#define PSYNC_SHA256_DIGEST_HEXLEN 64
#define psync_sha256_ctx mbedtls_sha256_context
#define psync_sha256(data, datalen, checksum) \
mbedtls_sha256(data, datalen, checksum, 0)
#define psync_sha256_init(pctx) mbedtls_sha256_starts(pctx, 0)
#define psync_sha256_update(pctx, data, datalen) \
mbedtls_sha256_update(pctx, (const unsigned char *)data, datalen)
#define psync_sha256_final(checksum, pctx) mbedtls_sha256_finish(pctx, checksum)
// SHA512
#define PSYNC_SHA512_BLOCK_LEN 128
#define PSYNC_SHA512_DIGEST_LEN 64
#define PSYNC_SHA512_DIGEST_HEXLEN 128
#define psync_sha512_ctx mbedtls_sha512_context
#define psync_sha512(data, datalen, checksum) \
mbedtls_sha512(data, datalen, checksum, 0)
#define psync_sha512_init(pctx) mbedtls_sha512_starts(pctx, 0)
#define psync_sha512_update(pctx, data, datalen) \
mbedtls_sha512_update(pctx, (const unsigned char *)data, datalen)
#define psync_sha512_final(checksum, pctx) mbedtls_sha512_finish(pctx, checksum)
// externs
extern PSYNC_THREAD int psync_ssl_errno;
#define PAES_BLOCK_SIZE 16
#define PAES_KEY_SIZE 32
#define PSSL_SHA1_BLOCK_LEN 64
#define PSSL_SHA1_DIGEST_LEN 20
#define PSSL_SHA1_DIGEST_HEXLEN 40
#define PSSL_SHA256_BLOCK_LEN 64
#define PSSL_SHA256_DIGEST_LEN 32
#define PSSL_SHA256_DIGEST_HEXLEN 64
#define PSSL_SHA512_BLOCK_LEN 128
#define PSSL_SHA512_DIGEST_LEN 64
#define PSSL_SHA512_DIGEST_HEXLEN 128
#define PAES_INVALID_ENCODER NULL
#define PRSA_INVALID NULL
#define PRSA_INVALID_BIN_KEY NULL
@ -96,6 +64,31 @@ extern PSYNC_THREAD int psync_ssl_errno;
#define PSYMKEY_INVALID NULL
#define PSYMKEY_INVALID_ENC NULL
// FIXME: fucking macros...
#define psync_sha1(data, datalen, checksum) \
mbedtls_sha1(data, datalen, checksum)
#define psync_sha1_init(pctx) mbedtls_sha1_starts(pctx)
#define psync_sha1_update(pctx, data, datalen) \
mbedtls_sha1_update(pctx, (const unsigned char *)data, datalen)
#define psync_sha1_final(checksum, pctx) mbedtls_sha1_finish(pctx, checksum)
#define psync_sha256(data, datalen, checksum) \
mbedtls_sha256(data, datalen, checksum, 0)
#define psync_sha256_init(pctx) mbedtls_sha256_starts(pctx, 0)
#define psync_sha256_update(pctx, data, datalen) \
mbedtls_sha256_update(pctx, (const unsigned char *)data, datalen)
#define psync_sha256_final(checksum, pctx) mbedtls_sha256_finish(pctx, checksum)
#define psync_sha512(data, datalen, checksum) \
mbedtls_sha512(data, datalen, checksum, 0)
#define psync_sha512_init(pctx) mbedtls_sha512_starts(pctx, 0)
#define psync_sha512_update(pctx, data, datalen) \
mbedtls_sha512_update(pctx, (const unsigned char *)data, datalen)
#define psync_sha512_final(checksum, pctx) mbedtls_sha512_finish(pctx, checksum)
// externs
extern PSYNC_THREAD int psync_ssl_errno;
typedef struct {
mbedtls_net_context srv;
mbedtls_ssl_context ssl;
@ -110,7 +103,6 @@ typedef struct {
unsigned char data[];
} pssl_enc_data_t;
typedef struct {
size_t keylen;
unsigned char key[];
@ -121,6 +113,11 @@ 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 mbedtls_sha1_context pssl_sha1_ctx;
typedef mbedtls_sha256_context pssl_sha256_ctx;
typedef mbedtls_sha512_context pssl_sha512_ctx;
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;
@ -175,5 +172,4 @@ pssl_enc_symkey_t psymkey_encrypt(pssl_rsapubkey_t rsa, const unsigned char *dat
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);
#endif

28
pclsync/ptask.c
View File

@ -97,7 +97,7 @@ typedef struct {
psync_fileid_t fileid;
const char *localpath;
uint64_t size;
char sha1hex[PSYNC_SHA1_DIGEST_HEXLEN];
char sha1hex[PSSL_SHA1_DIGEST_HEXLEN];
psync_async_callback_t cb;
void *cbext;
} download_needed_req_t;
@ -115,7 +115,7 @@ typedef struct {
uint64_t mtime;
uint64_t oldhash;
uint64_t oldmtime;
unsigned char sha1hex[PSYNC_SHA1_DIGEST_HEXLEN];
unsigned char sha1hex[PSSL_SHA1_DIGEST_HEXLEN];
} download_rsp_t;
typedef struct _async_params_t {
@ -152,9 +152,9 @@ typedef struct {
uint64_t size;
uint64_t hash;
unsigned char osize;
unsigned char sha1hex[PSYNC_SHA1_DIGEST_HEXLEN];
unsigned char osha1hex[PSYNC_SHA1_DIGEST_HEXLEN];
psync_sha1_ctx sha1ctx;
unsigned char sha1hex[PSSL_SHA1_DIGEST_HEXLEN];
unsigned char osha1hex[PSSL_SHA1_DIGEST_HEXLEN];
pssl_sha1_ctx sha1ctx;
uint64_t remsize;
int fd;
} download_context_t;
@ -247,7 +247,7 @@ static int download_send_error(stream_t *s, async_params_t *prms,
r.errorflags = errorflags;
r.file.size = fda->size;
r.file.hash = fda->hash;
memcpy(r.file.sha1hex, fda->sha1hex, PSYNC_SHA1_DIGEST_HEXLEN);
memcpy(r.file.sha1hex, fda->sha1hex, PSSL_SHA1_DIGEST_HEXLEN);
s->cb(s->cbext, &r);
debug(D_NOTICE, "closing stream %u", (unsigned)s->streamid);
@ -259,10 +259,10 @@ static int download_send_error(stream_t *s, async_params_t *prms,
}
static int download_checksum(download_context_t *fda) {
unsigned char sha1b[PSYNC_SHA1_DIGEST_LEN], sha1h[PSYNC_SHA1_DIGEST_HEXLEN];
unsigned char sha1b[PSSL_SHA1_DIGEST_LEN], sha1h[PSSL_SHA1_DIGEST_HEXLEN];
psync_sha1_final(sha1b, &fda->sha1ctx);
psync_binhex(sha1h, sha1b, PSYNC_SHA1_DIGEST_LEN);
if (memcmp(sha1h, fda->sha1hex, PSYNC_SHA1_DIGEST_HEXLEN)) {
psync_binhex(sha1h, sha1b, PSSL_SHA1_DIGEST_LEN);
if (memcmp(sha1h, fda->sha1hex, PSSL_SHA1_DIGEST_HEXLEN)) {
debug(D_WARNING,
"checksum verification for file %s failed, expected %40s got %40s",
fda->localpath, (char *)fda->sha1hex, (char *)sha1h);
@ -330,7 +330,7 @@ static int download_process_headers(stream_t *s,
fda = (download_context_t *)(s + 1);
fda->size = r.size;
fda->hash = r.hash;
memcpy(fda->sha1hex, r.sha1hex, PSYNC_SHA1_DIGEST_HEXLEN);
memcpy(fda->sha1hex, r.sha1hex, PSSL_SHA1_DIGEST_HEXLEN);
if (r.error)
return download_send_error(s, prms, fda, r.error + 100, r.errorflags);
debug(D_NOTICE,
@ -343,13 +343,13 @@ static int download_process_headers(stream_t *s,
psync_sql_bind_uint(res, 1, r.hash);
psync_sql_bind_uint(res, 2, r.size);
psync_sql_bind_lstring(res, 3, (const char *)r.sha1hex,
PSYNC_SHA1_DIGEST_HEXLEN);
PSSL_SHA1_DIGEST_HEXLEN);
if (r.oldmtime) {
psync_sql_run(res);
psync_sql_bind_uint(res, 1, r.oldhash);
psync_sql_bind_uint(res, 2, fda->osize);
psync_sql_bind_lstring(res, 3, (const char *)fda->osha1hex,
PSYNC_SHA1_DIGEST_HEXLEN);
PSSL_SHA1_DIGEST_HEXLEN);
psync_sql_run_free(res);
} else
psync_sql_run_free(res);
@ -466,7 +466,7 @@ static int handle_download_nm(async_params_t *prms,
s->cbext = dwl->cbext;
s->process_data = download_process_headers;
fda->osize = dwl->size;
memcpy(fda->osha1hex, dwl->sha1hex, PSYNC_SHA1_DIGEST_HEXLEN);
memcpy(fda->osha1hex, dwl->sha1hex, PSSL_SHA1_DIGEST_HEXLEN);
fda->localpath = dwl->localpath;
fda->fd = INVALID_HANDLE_VALUE;
len = psync_slprintf(
@ -1050,7 +1050,7 @@ int ptask_download_needed_async(psync_fileid_t fileid,
task.request.fileid = fileid;
task.request.localpath = localpath;
task.request.size = size;
memcpy(task.request.sha1hex, sha1hex, PSYNC_SHA1_DIGEST_HEXLEN);
memcpy(task.request.sha1hex, sha1hex, PSSL_SHA1_DIGEST_HEXLEN);
task.request.cb = cb;
task.request.cbext = cbext;
return task_send_async(&task, sizeof(task));