cleanup

pclsync/pcrypto.c

@@ -197,7 +197,7 @@ void pcrypto_ctr_encdec_free(
   psync_free(enc);
 }
 
-void pcrypto_ctr_encdec_decode(
+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;

pclsync/pcrypto.h

@@ -84,7 +84,7 @@ typedef pcrypto_encdec_iv_t *pcrypto_sector_encdec_t;
 #define PSYNC_CRYPTO_INVALID_REVISIONID ((uint32_t)-1)
 
 pcrypto_ctr_encdec_t pcrypto_ctr_encdec_create(psync_symmetric_key_t key);
-void pcrypto_ctr_encdec_decode(pcrypto_ctr_encdec_t enc, void *data, size_t datalen, uint64_t dataoffset);
+void pcrypto_ctr_encdec_encode(pcrypto_ctr_encdec_t enc, void *data, size_t datalen, uint64_t dataoffset);
 void pcrypto_ctr_encdec_free(pcrypto_ctr_encdec_t enc);
 int pcrypto_decode_sec(pcrypto_sector_encdec_t enc, const unsigned char *data, size_t datalen, unsigned char *out, const pcrypto_sector_auth_t auth, uint64_t sectorid);
 unsigned char * pcrypto_decode_text(pcrypto_textdec_t enc, const unsigned char *data, size_t datalen);

pclsync/pcryptofolder.c

@@ -428,7 +428,7 @@ int pcryptofolder_setup(const char *password, const char *hint) {
     return PSYNC_CRYPTO_SETUP_KEYGEN_FAILED;
   }
   debug(D_NOTICE, "encoding private key");
-  pcrypto_ctr_encdec_decode(enc, rsaprivatebin->data,
+  pcrypto_ctr_encdec_encode(enc, rsaprivatebin->data,
                                                 rsaprivatebin->datalen, 0);
   pcrypto_ctr_encdec_free(enc);
   debug(D_NOTICE, "encoded private key, uploading keys");
@@ -598,7 +598,7 @@ retry:
       debug(D_WARNING, "downloading key failed, error %d", ret);
       return ret;
     } else
-      debug(D_NOTICE, "dowloaded keys");
+      debug(D_NOTICE, "downloaded keys");
   } else {
     debug(D_NOTICE, "got keys from the database");
     assert(rowcnt == 4);
@@ -625,7 +625,7 @@ retry:
   psync_ssl_free_symmetric_key(aeskey);
   rsaprivdec = (unsigned char *)pmemlock_malloc(rsaprivlen);
   memcpy(rsaprivdec, rsapriv, rsaprivlen);
-  pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen, 0);
+  pcrypto_ctr_encdec_encode(enc, rsaprivdec, rsaprivlen, 0);
   pcrypto_ctr_encdec_free(enc);
   debug(D_NOTICE, "successfully generated symmetric key");
 
@@ -1885,7 +1885,7 @@ int psync_pcloud_crypto_reencode_key(
       goto err_nm_1;
     }
     memcpy(rsaprivdec, rsapriv_struct->key, rsaprivlen);
-    pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen,
+    pcrypto_ctr_encdec_encode(enc, rsaprivdec, rsaprivlen,
                                                   0);
     pcrypto_ctr_encdec_free(enc);
     newpriv = (unsigned char *)psync_malloc(offsetof(priv_key_ver1, key) +
@@ -1907,7 +1907,7 @@ int psync_pcloud_crypto_reencode_key(
     if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
       goto err_nm_1;
     memcpy(rsapriv_struct->key, rsaprivdec, rsaprivlen);
-    pcrypto_ctr_encdec_decode(enc, rsapriv_struct->key,
+    pcrypto_ctr_encdec_encode(enc, rsapriv_struct->key,
                                                   rsaprivlen, 0);
     pcrypto_ctr_encdec_free(enc);
     newprivlen = offsetof(priv_key_ver1, key) + rsaprivlen;
@@ -1994,7 +1994,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
   if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
     goto err_nm_1;
   memcpy(rsapriv_struct->key, rsapriv->data, rsaprivlen);
-  pcrypto_ctr_encdec_decode(enc, rsapriv_struct->key,
+  pcrypto_ctr_encdec_encode(enc, rsapriv_struct->key,
                                                 rsaprivlen, 0);
   pcrypto_ctr_encdec_free(enc);
   rsaprivlen += offsetof(priv_key_ver1, key);

pclsync/pp2p.c

@@ -404,7 +404,7 @@ static void psync_p2p_tcphandler(void *ptr) {
       rd = sizeof(buff);
     if (unlikely_log(pfile_read(fd, buff, rd) != rd))
       break;
-    pcrypto_ctr_encdec_decode(encoder, buff, rd, off);
+    pcrypto_ctr_encdec_encode(encoder, buff, rd, off);
     if (unlikely_log(socket_write_all(sock, buff, rd)))
       break;
     off += rd;
@@ -701,7 +701,7 @@ static int psync_p2p_download(int sock, psync_fileid_t fileid,
       rd = fsize - off;
     if (unlikely_log(socket_read_all(sock, buff, rd)))
       goto err0;
-    pcrypto_ctr_encdec_decode(decoder, buff, rd, off);
+    pcrypto_ctr_encdec_encode(decoder, buff, rd, off);
     if (unlikely_log(pfile_write(fd, buff, rd) != rd))
       goto err0;
     psync_hash_update(&hashctx, buff, rd);

pclsync/pssl.c

@@ -736,7 +736,6 @@ psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata,
     psync_free(rsactx);
     return PSYNC_INVALID_RSA;
   } else {
-    mbedtls_rsa_set_padding(rsactx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
     return rsactx;
   }
 }

pclsync/rpcclient.c

@@ -117,13 +117,13 @@ static int write_request(int fd, int msgtype, const char *value, char **out,
 
   *ret = 0; // Initialize ret to 0
 
-  len = strlen(value);
-  size = sizeof(rpc_message_t) + len + 1;
+  len = strlen(value) + 1;
+  size = sizeof(rpc_message_t) + len;
   buf = (char *)malloc(size);
   request = (rpc_message_t *)buf;
   memset(request, 0, size);
   request->type = msgtype;
-  strncpy(request->value, value, len + 1);
+  strncpy(request->value, value, len);
   request->length = size;
   bytes_written = 0;
   curbuf = (char *)request;