From 935319f918cf66211b395b7ae61ceda44d75f99a Mon Sep 17 00:00:00 2001
From: Levi Neely <141506390+lneely@users.noreply.github.com>
Date: Tue, 4 Mar 2025 17:41:22 +0100
Subject: [PATCH] OMG this code is driving me nuts!!!

---
 pclsync/pcrypto.c       | 284 ++++++++++++++++++++--------------------
 pclsync/pcrypto.h       |   4 +-
 pclsync/pcryptofolder.c |  44 +++----
 pclsync/pdiff.c         |  14 +-
 pclsync/plocalscan.c    |   8 +-
 pclsync/pnetlibs.c      |  18 +--
 pclsync/psettings.h     |  16 +--
 pclsync/pssl.c          |  32 ++---
 pclsync/pssl.h          |  86 ++++++------
 pclsync/ptask.c         |  28 ++--
 10 files changed, 265 insertions(+), 269 deletions(-)

diff --git a/pclsync/pcrypto.c b/pclsync/pcrypto.c
index 99f689a..e0668bf 100644
--- a/pclsync/pcrypto.c
+++ b/pclsync/pcrypto.c
@@ -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);
 }
diff --git a/pclsync/pcrypto.h b/pclsync/pcrypto.h
index bbecbdf..08b6aa7 100644
--- a/pclsync/pcrypto.h
+++ b/pclsync/pcrypto.h
@@ -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;
 
diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c
index f4cdbf2..02e9948 100644
--- a/pclsync/pcryptofolder.c
+++ b/pclsync/pcryptofolder.c
@@ -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;
 }
diff --git a/pclsync/pdiff.c b/pclsync/pdiff.c
index 1922b9d..b183399 100644
--- a/pclsync/pdiff.c
+++ b/pclsync/pdiff.c
@@ -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,
diff --git a/pclsync/plocalscan.c b/pclsync/plocalscan.c
index 5561970..63edb67 100644
--- a/pclsync/plocalscan.c
+++ b/pclsync/plocalscan.c
@@ -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;
diff --git a/pclsync/pnetlibs.c b/pclsync/pnetlibs.c
index f22da0f..1fd6e0d 100644
--- a/pclsync/pnetlibs.c
+++ b/pclsync/pnetlibs.c
@@ -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",
diff --git a/pclsync/psettings.h b/pclsync/psettings.h
index c26c954..bb28bfa 100644
--- a/pclsync/psettings.h
+++ b/pclsync/psettings.h
@@ -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
diff --git a/pclsync/pssl.c b/pclsync/pssl.c
index 74b4cf5..56125dc 100644
--- a/pclsync/pssl.c
+++ b/pclsync/pssl.c
@@ -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;
diff --git a/pclsync/pssl.h b/pclsync/pssl.h
index 9b4e27f..afb806d 100644
--- a/pclsync/pssl.h
+++ b/pclsync/pssl.h
@@ -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
diff --git a/pclsync/ptask.c b/pclsync/ptask.c
index c854fb5..f6d532b 100644
--- a/pclsync/ptask.c
+++ b/pclsync/ptask.c
@@ -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));