diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index cfce995..c0617d2 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -9,9 +9,13 @@ on: jobs: build: runs-on: ubuntu-latest + container: + image: debian:trixie steps: - uses: actions/checkout@v4 - - name: make - run: sudo apt-get update && sudo apt-get install -y libreadline-dev libudev-dev libfuse-dev libsqlite3-dev zlib1g-dev libboost-dev libboost-system-dev libboost-program-options-dev libmbedtls-dev + - name: Install dependencies + run: | + apt-get update + apt-get install -y build-essential libreadline-dev libudev-dev libfuse-dev libsqlite3-dev zlib1g-dev libboost-dev libboost-system-dev libboost-program-options-dev libmbedtls-dev - name: make run: make diff --git a/Makefile b/Makefile index d625673..af39293 100644 --- a/Makefile +++ b/Makefile @@ -2,12 +2,12 @@ CC := gcc CXX := g++ AR := ar COMMONFLAGS = -fsanitize=address -CFLAGS = -fPIC $(COMMONFLAGS) -I./pclsync -I/usr/include -I/usr/include/mbedtls2 +CFLAGS = -fPIC $(COMMONFLAGS) -I./pclsync -I/usr/include ifneq (,$(filter clang%,$(CC))) CFLAGS += -Wthread-safety endif CXXFLAGS = $(CFLAGS) -LIBLDFLAGS = $(COMMONFLAGS) -lreadline -lpthread -ludev -lsqlite3 -lz -l:libmbedtls.so.14 -l:libmbedx509.so.1 -l:libmbedcrypto.so.7 +LIBLDFLAGS = $(COMMONFLAGS) -lreadline -lpthread -ludev -lsqlite3 -lz -lmbedtls -lmbedx509 -lmbedcrypto EXECLDFLAGS = $(COMMONFLAGS) -lboost_program_options -lfuse SCAN := 0 diff --git a/README.md b/README.md index 4799103..de0d9cd 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,41 @@ # pCloud Console Client (undead) -This is a simple **linux** console client for pCloud cloud storage, derived from the console-client developed by pCloud. +`pcloudcc` is simple **linux** console client for pCloud cloud storage derived from the console-client developed by pCloud. This version is independently maintained by me, whose only affiliation with pCloud is as a user of their services. Due credit goes to Anton Titov, Ivan Stoev, and pCloud. -## Braaaaaains (Fork, please) +## mbedtls 3.x Migration Notice -This version of pcloudcc is independently maintained by me, whose only affiliation with pCloud is as a user of their services. As of June 2024, the console-client repo (https://github.com/pcloudcom/console-client) seems to have been inactive for several years. This was an attractive alternative for myself and other like-minded weirdos who don't enjoy unneeded GUIs, and it is a shame to see it abandoned. +`pcloudcc` now uses `mbedtls` version 3.x. This may already be included in your distribution, and if it is, you can ignore this section. If you're unlucky enough that your distribution still ships with `mbedtls` 2.x *(looking at you, Debian...)*, then try the following instructions. This has been tested on debian bookworm, **but you may have to adjust for your own distribution -- the command sequence below uses `apt` to install known build dependencies.** + +Without further ado, the first step is to build and install the `mbedtls` 3.x library on your host machine, hopefully without breaking the distribution version. Review the following commands, then copy and paste them into a terminal to run them. + +``` +sudo apt install python3 python3-pip python3-venv +mkdir -p $HOME/src; cd $HOME/src +git clone https://github.com/Mbed-TLS/mbedtls/ +cd mbedtls +git checkout tags/v3.6.2 +git submodule update --init +python3 -m venv ./venv +source ./venv/bin/activate +python3 -m pip install -r scripts/basic.requirements.txt +make +sudo make install +sudo ln -s /usr/local/include/mbedtls/ /usr/local/include/mbedtls3 +``` + +The symbolic link at the end resolves the ambiguity between `/usr/include/mbedtls` and `/usr/local/include/mbedtls`. Now, we need to make some edits to the Makefile and the source files to ensure that the build uses the correct `mbedtls` headers and libraries. We'll do this with `sed`, then run `make` as usual. + +``` +# run from the source root directory (e.g., pcloudcc-lneely) + +sed -i 's/-lmbedtls/-l:libmbedtls.a/;s/-lmbedcrypto/-l:libmbedcrypto.a/;s/-lmbedx509/-l:libmbedx509.a/' Makefile +sed -i '5s/$/ -I\/usr\/local\/include/' Makefile +sed -i '10s/$/ -L\/usr\/local\/lib\//' Makefile +find . -type f -name "*.[ch]" -exec sed -i 's/#include ` to enable a SOCKS proxy on `localhost:`. Configure your local web browser to use `localhost:` as its proxy, then log in to pcloud.com and validate the device. *Do not forget to remove the proxy from your browser configuration when done.* -### Untested Workarounds - -Fundamentally, the workaround is to log in to pcloud.com using a web browser from the target device. Therefore the following (untested) workarounds may also work. - -**SSH/X11 forwarding**. *Requires web browser, X11 forwarding over SSH on host. Requires X11 client on local machine.*. If a sufficiently capable web browser and X11 forwarding are available on the host, login to SSH with X11 forwarding enabled (`ssh -X `) and run the web browser from the SSH session to log in and validate the device. - -**Remote Desktop / VNC**. *Requires a sufficiently capable web browser and RDP/VNC capabilities on host*. Run the web browser in a remote desktop session to log in and validate the device. - ## Supported Distributions & Packages -pcloudcc-lneely seeks to support as many Linux distributions as possible and has been tested on recent versions of Fedora, Debian, Ubuntu, Arch, and Artix. - -I use Artix and maintain an [AUR](https://aur.archlinux.org/packages/pcloudcc-lneely) package. I do not plan on providing or maintaining any other packages, but encourage anyone interested in doing so for their own distributions. - -## Due Credit -- Anton Titov -- Ivan Stoev -- pCloud +I aim to support as many distributions as possible, and maintain an [AUR](https://aur.archlinux.org/packages/pcloudcc-lneely) package. I do not plan on providing or maintaining any other packages, but encourage anyone interested in doing so for their own distributions. ## Dependencies - zlib (-lz) @@ -52,7 +67,7 @@ I use Artix and maintain an [AUR](https://aur.archlinux.org/packages/pcloudcc-ln - udev (-ludev) - libfuse (-lfuse) - libsqlite (-lsqlite3) -- libmbedtls (-l:libmbedtls.so.14, -l:libmbedx509.so.1, -l:libmbedcrypto.so.7) +- libmbedtls (3.x) ## Building @@ -60,9 +75,7 @@ I use Artix and maintain an [AUR](https://aur.archlinux.org/packages/pcloudcc-ln make ``` -It's really that easy. Use `make install` to install, and `make uninstall` to uninstall. Specify `DESTDIR` if desired (see **Make Options**). - -## Make Options +### Build Options ``` make BUILD=debug # include debug symbols, ASan instrumentation. (default: release) @@ -88,8 +101,11 @@ database. Verify that file system starts and mounts normally after the > pcloudcc -u example@myemail.com -p -s +Optionally specify your own mount point. -### Registration +> pcloudcc -u example@myemail.com -p -s -m /path/to/mountpoint + +### Registration (UNTESTED) If you don't have existing user use -n switch to register new user: @@ -127,7 +143,7 @@ Command Reference: ``` **Note**. Command line arguments that include special characters (e.g., the - `crypto start` password or paths with spaces) must now be quoted or + `crypto start` password or paths with spaces) must be quoted or escaped. In other words, instead of: `startcrypto Str0ng p4$$word 4 great jUSTicE!` diff --git a/dev/container-build.sh b/dev/container-build.sh index 43e5802..865701a 100755 --- a/dev/container-build.sh +++ b/dev/container-build.sh @@ -33,7 +33,7 @@ show_help() { echo echo "Options:" echo " -i, --image IMAGE Specify the base image (default: debian)" - echo " -t, --tag TAG Specify the tag for the base image (default: latest)" + echo " -t, --tag TAG Specify the tag for the base image (default: trixie)" echo " -n, --name NAME Specify the name for the container (default: debian-build)" echo " -l, --list List supported distributions" echo " -h, --help Display this help message" @@ -51,7 +51,7 @@ show_help() { # Default values IMAGE="debian" -TAG="latest" +TAG="trixie" NAME="debian-build" # Parse command line arguments diff --git a/pclsync/pcrypto.c b/pclsync/pcrypto.c index 3529667..73fa4f2 100644 --- a/pclsync/pcrypto.c +++ b/pclsync/pcrypto.c @@ -174,16 +174,16 @@ psync_symmetric_key_t pcrypto_key() { PSYNC_AES256_BLOCK_SIZE); } -pcrypto_ctr_encdec_t -pcrypto_ctr_encdec_create(psync_symmetric_key_t key) { +pcrypto_ctr_encdec_t pcrypto_ctr_encdec_create(psync_symmetric_key_t key) { psync_aes256_encoder enc; pcrypto_ctr_encdec_t ret; - if (unlikely_log(key->keylen < - PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE)) + if (unlikely_log(key->keylen < PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE)) { return PSYNC_CRYPTO_INVALID_ENCODER; + } enc = psync_ssl_aes256_create_encoder(key); - if (unlikely_log(enc == PSYNC_INVALID_ENCODER)) + if (unlikely_log(enc == PSYNC_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); @@ -504,7 +504,7 @@ void pcrypto_encode_sec( aessrc = ALIGN_PTR_A256_BS(buff); aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE; assert(PSYNC_CRYPTO_AUTH_SIZE == 2 * PSYNC_AES256_BLOCK_SIZE); - psync_ssl_rand_weak(rnd, PSYNC_AES256_BLOCK_SIZE); + psync_ssl_rand_strong(rnd, PSYNC_AES256_BLOCK_SIZE); psync_hmac_sha512_init(&ctx, enc->iv, enc->ivlen); psync_hmac_sha512_update(&ctx, data, datalen); psync_hmac_sha512_update(&ctx, §orid, sizeof(sectorid)); diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c index 02f6980..a40fe3c 100644 --- a/pclsync/pcryptofolder.c +++ b/pclsync/pcryptofolder.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -211,10 +212,7 @@ static void load_str_to(const psync_variant *v, unsigned char **ptr, *len = l; } -static int download_keys( - unsigned char **rsapriv, size_t *rsaprivlen, unsigned char **rsapub, - size_t *rsapublen, unsigned char **salt, size_t *saltlen, - size_t *iterations, char *publicsha1, char *privatesha1, uint32_t *flags) { +static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned char **rsapub, size_t *rsapublen, unsigned char **salt, size_t *saltlen, size_t *iterations, char *publicsha1, char *privatesha1, uint32_t *flags) { binparam params[] = {PAPI_STR("auth", psync_my_auth)}; psock_t *api; binresult *res; @@ -503,7 +501,7 @@ static int crypto_keys_match() { key = (psync_symmetric_key_t)psync_malloc( offsetof(psync_symmetric_key_struct_t, key) + 64); key->keylen = 64; - psync_ssl_rand_weak(key->key, key->keylen); + psync_ssl_rand_strong(key->key, key->keylen); enckey = psync_ssl_rsa_encrypt_symmetric_key(crypto_pubkey, key); if (enckey == PSYNC_INVALID_ENC_SYM_KEY) { psync_free(key); @@ -619,11 +617,8 @@ int pcryptofolder_unlock(const char *password) { } debug(D_NOTICE, "successfully loaded public key"); - debug(D_NOTICE, "generating symmetric key"); - aeskey = psync_ssl_gen_symmetric_key_from_pass( - password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen, - iterations); + aeskey = psync_ssl_gen_symmetric_key_from_pass(password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen, iterations); enc = pcrypto_ctr_encdec_create(aeskey); psync_ssl_free_symmetric_key(aeskey); rsaprivdec = (unsigned char *)pmemlock_malloc(rsaprivlen); @@ -1848,7 +1843,7 @@ int psync_pcloud_crypto_reencode_key( rsapriv_struct = (priv_key_ver1 *)newpriv; rsapriv_struct->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT; rsapriv_struct->flags = flags; - psync_ssl_rand_weak(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN); + psync_ssl_rand_strong(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN); aeskey = psync_ssl_gen_symmetric_key_from_pass( newpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000); @@ -1936,7 +1931,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags, rsapriv_struct = (priv_key_ver1 *)newpriv; rsapriv_struct->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT; rsapriv_struct->flags = flags; - psync_ssl_rand_weak(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN); + psync_ssl_rand_strong(rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN); aeskey = psync_ssl_gen_symmetric_key_from_pass( newpassphrase, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, rsapriv_struct->salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, 20000); diff --git a/pclsync/pfs.c b/pclsync/pfs.c index 1dfafc4..54fe7f6 100644 --- a/pclsync/pfs.c +++ b/pclsync/pfs.c @@ -3367,7 +3367,7 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) { pfolder_path_sep(folderid, "/", NULL); if (path == PSYNC_INVALID_PATH) return; - psync_ssl_rand_weak(rndbuff, sizeof(rndbuff)); + psync_ssl_rand_strong(rndbuff, sizeof(rndbuff)); psync_binhex(rndhex, rndbuff, sizeof(rndbuff)); rndhex[2 * sizeof(rndbuff)] = 0; pthread_mutex_lock(&start_mutex); @@ -3565,7 +3565,7 @@ static void psync_fs_init_once() { #if psync_fs_need_per_folder_refresh_const() unsigned char rndbuff[16]; char rndhex[34]; - psync_ssl_rand_weak(rndbuff, sizeof(rndbuff)); + psync_ssl_rand_strong(rndbuff, sizeof(rndbuff)); psync_binhex(rndhex, rndbuff, sizeof(rndbuff)); rndhex[2 * sizeof(rndbuff)] = 0; psync_fake_prefix = psync_strcat(".refresh", rndhex, NULL); diff --git a/pclsync/pp2p.c b/pclsync/pp2p.c index 3e9dbb9..c09682f 100644 --- a/pclsync/pp2p.c +++ b/pclsync/pp2p.c @@ -221,7 +221,7 @@ static void psync_p2p_check(const packet_check *packet) { else return; resp.port = tcpport; - psync_ssl_rand_weak(resp.rand, sizeof(resp.rand)); + psync_ssl_rand_strong(resp.rand, sizeof(resp.rand)); memcpy(hashsource, hashhex, PSYNC_HASH_DIGEST_HEXLEN); memcpy(hashsource + PSYNC_HASH_DIGEST_HEXLEN, resp.rand, sizeof(resp.rand)); psync_hash(hashsource, PSYNC_HASH_BLOCK_SIZE, hashbin); @@ -550,7 +550,7 @@ static void psync_p2p_wake() { void pp2p_init() { unsigned char computerbin[PSYNC_HASH_DIGEST_LEN]; - psync_ssl_rand_weak(computerbin, PSYNC_HASH_DIGEST_LEN); + psync_ssl_rand_strong(computerbin, PSYNC_HASH_DIGEST_LEN); psync_binhex(computername, computerbin, PSYNC_HASH_DIGEST_LEN); ptimer_exception_handler(psync_p2p_wake); if (!psync_setting_get_bool(_PS(p2psync))) @@ -754,7 +754,7 @@ int pp2p_check_download(psync_fileid_t fileid, pct1.type = P2P_CHECK; memcpy(pct1.hashstart, filehashhex, PSYNC_P2P_HEXHASH_BYTES); pct1.filesize = fsize; - psync_ssl_rand_weak(pct1.rand, sizeof(pct1.rand)); + psync_ssl_rand_strong(pct1.rand, sizeof(pct1.rand)); memcpy(hashsource, filehashhex, PSYNC_HASH_DIGEST_HEXLEN); memcpy(hashsource + PSYNC_HASH_DIGEST_HEXLEN, pct1.rand, sizeof(pct1.rand)); psync_hash(hashsource, PSYNC_HASH_BLOCK_SIZE, hashbin); @@ -841,7 +841,7 @@ int pp2p_check_download(psync_fileid_t fileid, goto err_perm2; else if (bresp == P2P_RESP_WAIT) { uint32_t rnd; - psync_ssl_rand_weak((unsigned char *)&rnd, sizeof(rnd)); + psync_ssl_rand_strong((unsigned char *)&rnd, sizeof(rnd)); rnd &= 0x7ff; psys_sleep_milliseconds(PSYNC_P2P_SLEEP_WAIT_DOWNLOAD + rnd); goto err_temp2; diff --git a/pclsync/pssl.c b/pclsync/pssl.c index c930995..d00e499 100644 --- a/pclsync/pssl.c +++ b/pclsync/pssl.c @@ -31,6 +31,7 @@ #include #include +#include #include #include #include @@ -38,6 +39,7 @@ #include #include #include +#include #include #include #include @@ -61,44 +63,14 @@ #include #include -// HACK: This function is duplicated from -// mbedtls-2.1.14/library/pkparse.c, because it is needed to properly -// parse the RSA keys returned by the pcloud server; see the fallback -// code in psync_ssl_rsa_load_public. -// -// IMO this duplication beats the hell out of maintaining the full -// mbedtls library in the pcloudcc source tree just to apply a tiny -// patch. -static int pk_get_rsapubkey(unsigned char **p, const unsigned char *end, - mbedtls_rsa_context *rsa) { - int ret; - size_t len; - - if ((ret = mbedtls_asn1_get_tag( - p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) != - 0) - return (MBEDTLS_ERR_PK_INVALID_PUBKEY + ret); - - if (*p + len != end) - return (MBEDTLS_ERR_PK_INVALID_PUBKEY + MBEDTLS_ERR_ASN1_LENGTH_MISMATCH); - - if ((ret = mbedtls_asn1_get_mpi(p, end, &rsa->N)) != 0 || - (ret = mbedtls_asn1_get_mpi(p, end, &rsa->E)) != 0) - return (MBEDTLS_ERR_PK_INVALID_PUBKEY + ret); - - if (*p != end) - return (MBEDTLS_ERR_PK_INVALID_PUBKEY + MBEDTLS_ERR_ASN1_LENGTH_MISMATCH); - - ret = mbedtls_rsa_check_pubkey(rsa); - if (ret != 0) - return (MBEDTLS_ERR_PK_INVALID_PUBKEY); - - rsa->len = mbedtls_mpi_size(&rsa->N); - return 0; -} - static pthread_mutex_t rsa_decr_mutex = PTHREAD_MUTEX_INITIALIZER; +static void ssl_debug(int loglevel, int errnum, const char *msg) { + char ebuf[100]; + mbedtls_strerror(errnum, ebuf, sizeof(ebuf)); + debug(loglevel, "%s: %s (-0x%04x)", msg, ebuf, (unsigned int)-errnum); +} + static void psync_ssl_free_psync_encrypted_data_t(psync_encrypted_data_t e) { psync_ssl_memclean(e->data, e->datalen); pmemlock_free(e); @@ -203,8 +175,7 @@ void pssl_debug_cb(psync_ssl_debug_callback_t cb, void *ctx) { debug_ctx = ctx; } -int ctr_drbg_random_locked(void *p_rng, unsigned char *output, - size_t output_len) { +int rng_get(void *p_rng, unsigned char *output, size_t output_len) { ctr_drbg_context_locked *rng; int ret; rng = (ctr_drbg_context_locked *)p_rng; @@ -214,6 +185,7 @@ int ctr_drbg_random_locked(void *p_rng, unsigned char *output, return ret; } + #if defined(PSYNC_AES_HW_GCC) static int detect_aes_hw() { uint32_t eax, ecx; @@ -226,18 +198,6 @@ static int detect_aes_hw() { debug(D_NOTICE, "hardware AES support not detected"); return ecx; } -#elif defined(PSYNC_AES_HW_MSC) -static int detect_aes_hw() { - int info[4]; - int ret; - __cpuid(info, 1); - ret = (info[2] >> 25) & 1; - if (ret) - debug(D_NOTICE, "hardware AES support detected"); - else - debug(D_NOTICE, "hardware AES support not detected"); - return ret; -} #endif int psync_ssl_init() { @@ -263,6 +223,7 @@ int psync_ssl_init() { debug(D_ERROR, "mbedtls_ctr_drbg_seed failed with return code %d", result); return PRINT_RETURN(-1); } + mbedtls_x509_crt_init(&psync_mbed_trusted_certs_x509); for (i = 0; i < ARRAY_SIZE(psync_ssl_trusted_certs); i++) { @@ -385,7 +346,7 @@ static int chcek_peer_pubkey(ssl_connection_t *conn) { debug(D_WARNING, "pk_write_pubkey_der returned error %d", i); return -1; } - mbedtls_sha256_ret(buff + sizeof(buff) - i, i, sigbin, 0); + mbedtls_sha256(buff + sizeof(buff) - i, i, sigbin, 0); psync_binhex(sighex, sigbin, 32); sighex[64] = 0; for (i = 0; i < ARRAY_SIZE(psync_ssl_trusted_pk_sha256); i++) @@ -419,17 +380,18 @@ int psync_ssl_connect(int sock, void **sslconn, ret); goto err0; } + + mbedtls_ssl_conf_max_tls_version(&conn->cfg, MBEDTLS_SSL_VERSION_TLS1_2); + mbedtls_ssl_conf_min_tls_version(&conn->cfg, MBEDTLS_SSL_VERSION_TLS1_2); + mbedtls_ssl_conf_endpoint(&conn->cfg, MBEDTLS_SSL_IS_CLIENT); mbedtls_ssl_conf_dbg(&conn->cfg, debug_cb, debug_ctx); mbedtls_ssl_conf_authmode(&conn->cfg, MBEDTLS_SSL_VERIFY_REQUIRED); - mbedtls_ssl_conf_min_version(&conn->cfg, MBEDTLS_SSL_MAJOR_VERSION_3, - MBEDTLS_SSL_MINOR_VERSION_3); mbedtls_ssl_conf_ca_chain(&conn->cfg, &psync_mbed_trusted_certs_x509, NULL); mbedtls_ssl_conf_ciphersuites(&conn->cfg, psync_mbed_ciphersuite); - mbedtls_ssl_conf_rng(&conn->cfg, ctr_drbg_random_locked, &psync_mbed_rng); + mbedtls_ssl_conf_rng(&conn->cfg, rng_get, &psync_mbed_rng); - mbedtls_ssl_set_bio(&conn->ssl, &conn->srv, mbed_write, mbed_read, - NULL); + mbedtls_ssl_set_bio(&conn->ssl, &conn->srv, mbed_write, mbed_read, NULL); mbedtls_ssl_set_hostname(&conn->ssl, hostname); mbedtls_ssl_setup(&conn->ssl, &conn->cfg); // attach config to ssl @@ -455,8 +417,7 @@ int psync_ssl_connect(int sock, void **sslconn, } set_error(conn, ret); - if (likely_log(ret == MBEDTLS_ERR_SSL_WANT_READ || - ret == MBEDTLS_ERR_SSL_WANT_WRITE)) { + if (likely_log(ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE)) { *sslconn = conn; return PSYNC_SSL_NEED_FINISH; } @@ -546,21 +507,19 @@ int psync_ssl_write(void *sslconn, const void *buf, int num) { void psync_ssl_rand_strong(unsigned char *buf, int num) { // FIXME: causing segfault - if (unlikely(ctr_drbg_random_locked(&psync_mbed_rng, buf, num))) { + if (unlikely(rng_get(&psync_mbed_rng, buf, num))) { debug(D_CRITICAL, "could not generate %d random bytes, exiting", num); abort(); } } -void psync_ssl_rand_weak(unsigned char *buf, int num) { - psync_ssl_rand_strong(buf, num); -} - psync_rsa_t psync_ssl_gen_rsa(int bits) { mbedtls_rsa_context *ctx; ctx = psync_new(mbedtls_rsa_context); - mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); - if (mbedtls_rsa_gen_key(ctx, ctr_drbg_random_locked, &psync_mbed_rng, bits, + mbedtls_rsa_init(ctx); + mbedtls_rsa_set_padding(ctx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + + if (mbedtls_rsa_gen_key(ctx, rng_get, &psync_mbed_rng, bits, 65537)) { mbedtls_rsa_free(ctx); psync_free(ctx); @@ -592,7 +551,9 @@ void psync_ssl_rsa_free_public(psync_rsa_publickey_t key) { psync_rsa_privatekey_t psync_ssl_rsa_get_private(psync_rsa_t rsa) { mbedtls_rsa_context *ctx; ctx = psync_new(mbedtls_rsa_context); - mbedtls_rsa_init(ctx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + mbedtls_rsa_init(ctx); + mbedtls_rsa_set_padding(ctx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + if (unlikely(mbedtls_rsa_copy(ctx, rsa))) { mbedtls_rsa_free(ctx); psync_free(ctx); @@ -655,46 +616,15 @@ psync_rsa_publickey_t psync_ssl_rsa_load_public(const unsigned char *keydata, mbedtls_rsa_context *rsa; int ret; - debug(D_NOTICE, "Public key data (first 16 bytes): %02x %02x %02x %02x ...", - keydata[0], keydata[1], keydata[2], keydata[3]); - mbedtls_pk_init(&ctx); if (unlikely(ret = mbedtls_pk_parse_public_key(&ctx, keydata, keylen))) { - debug(D_WARNING, - "pk_parse_public_key failed with code %d (-0x%04x); resorting to " - "mbedtls 1.x RSA fallback", - ret, -ret); - - // this code comes from the mbedtls-1.3.10.patch that was applied - // to the vanilla version. - // - // TODO: fixme - - if (ret != 0) { - mbedtls_pk_setup(&ctx, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)); - unsigned char *p = (unsigned char *)keydata; - ret = pk_get_rsapubkey(&p, p + keylen, mbedtls_pk_rsa(ctx)); - if (ret != 0) - mbedtls_pk_free(&ctx); - } - - if (ret != 0) { - char error_buf[100]; - mbedtls_strerror(ret, error_buf, sizeof(error_buf)); - debug(D_WARNING, "Error details: %s", error_buf); - return PSYNC_INVALID_RSA; - } - } - - if (mbedtls_pk_get_type(&ctx) != MBEDTLS_PK_RSA) { - debug(D_WARNING, "Parsed key is not RSA"); - mbedtls_pk_free(&ctx); + debug(D_WARNING, "pk_parse_public_key failed with code %d (-0x%04x); resorting to " "mbedtls 1.x RSA fallback", ret, -ret); return PSYNC_INVALID_RSA; } - rsa = psync_new(mbedtls_rsa_context); - mbedtls_rsa_init(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + mbedtls_rsa_init(rsa); + mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); ret = mbedtls_rsa_copy(rsa, mbedtls_pk_rsa(ctx)); mbedtls_pk_free(&ctx); if (unlikely(ret)) { @@ -708,18 +638,50 @@ psync_rsa_publickey_t psync_ssl_rsa_load_public(const unsigned char *keydata, } } -psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata, - size_t keylen) { +// mbedtls 3.x: mbedtls_pk_parse_key rejects keys with trailing garbage. This +// function gets the actual key length from the ASN.1 header, trims any bytes +// that exceed that length, and writes the trimmed key and length to keydata +// and keylen. +static unsigned char* trim_der_key(const unsigned char *keydata, size_t *keylen) { + size_t len, header_size, correct_len; + unsigned char tag; + unsigned char *p = (unsigned char *)keydata; + const unsigned char *end; + int ret; + unsigned char *trimmed; + + end = keydata + *keylen; + ret = mbedtls_asn1_get_tag(&p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE); + if (ret != 0) { + return NULL; + } + header_size = p - keydata; + correct_len = header_size + len; + trimmed = malloc(correct_len); + if (!trimmed) return NULL; + + memcpy(trimmed, keydata, correct_len); + *keylen = correct_len; + + return trimmed; +} + +psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata, size_t keylen) { mbedtls_pk_context ctx; mbedtls_rsa_context *rsa; int ret; + + trim_der_key(keydata, &keylen); + mbedtls_pk_init(&ctx); - if (unlikely(ret = mbedtls_pk_parse_key(&ctx, keydata, keylen, NULL, 0))) { - debug(D_WARNING, "pk_parse_key failed with code %d", ret); + ret = mbedtls_pk_parse_key(&ctx, keydata, keylen, NULL, 0, rng_get, &psync_mbed_rng); + if(unlikely(ret)) { + ssl_debug(D_WARNING, ret, "pk_parse_key failed"); return PSYNC_INVALID_RSA; } rsa = psync_new(mbedtls_rsa_context); - mbedtls_rsa_init(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + mbedtls_rsa_init(rsa); + mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); ret = mbedtls_rsa_copy(rsa, mbedtls_pk_rsa(ctx)); mbedtls_pk_free(&ctx); if (unlikely(ret)) { @@ -753,9 +715,11 @@ psync_ssl_gen_symmetric_key_from_pass(const char *password, size_t keylen, mbedtls_md_init(&ctx); mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA512), 1); key->keylen = keylen; - mbedtls_pkcs5_pbkdf2_hmac(&ctx, (const unsigned char *)password, - strlen(password), salt, saltlen, iterations, keylen, - key->key); + 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 *)password, + strlen(password), salt, saltlen, iterations, keylen, + key->key); mbedtls_md_free(&ctx); return key; } @@ -777,9 +741,10 @@ char *psync_ssl_derive_password_from_passphrase(const char *username, psync_free(usercopy); mbedtls_md_init(&ctx); mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA512), 1); - mbedtls_pkcs5_pbkdf2_hmac( - &ctx, (const unsigned char *)passphrase, strlen(passphrase), usersha512, - PSYNC_SHA512_DIGEST_LEN, 5000, sizeof(passwordbin), passwordbin); + 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); mbedtls_md_free(&ctx); usercopy = psync_base64_encode(passwordbin, sizeof(passwordbin), &userlen); return (char *)usercopy; @@ -790,19 +755,21 @@ psync_ssl_rsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen) { psync_encrypted_symmetric_key_t ret; int code; + size_t rsalen = mbedtls_rsa_get_len(rsa); + ret = (psync_encrypted_symmetric_key_t)psync_malloc( - offsetof(psync_encrypted_data_struct_t, data) + rsa->len); + offsetof(psync_encrypted_data_struct_t, data) + rsalen); if ((code = mbedtls_rsa_rsaes_oaep_encrypt( - rsa, ctr_drbg_random_locked, &psync_mbed_rng, MBEDTLS_RSA_PUBLIC, + rsa, rng_get, &psync_mbed_rng, NULL, 0, datalen, data, ret->data))) { psync_free(ret); debug( D_WARNING, "rsa_rsaes_oaep_encrypt failed with error=%d, datalen=%lu, rsasize=%d", - code, (unsigned long)datalen, (int)rsa->len); + code, (unsigned long)datalen, (int)rsalen); return PSYNC_INVALID_ENC_SYM_KEY; } - ret->datalen = rsa->len; + ret->datalen = rsalen; debug(D_NOTICE, "datalen=%lu", (unsigned long)ret->datalen); return ret; } @@ -813,8 +780,8 @@ psync_symmetric_key_t psync_ssl_rsa_decrypt_data(psync_rsa_privatekey_t rsa, unsigned char buff[2048]; psync_symmetric_key_t ret; size_t len; - if (mbedtls_rsa_rsaes_oaep_decrypt(rsa, ctr_drbg_random_locked, - &psync_mbed_rng, MBEDTLS_RSA_PRIVATE, NULL, + if (mbedtls_rsa_rsaes_oaep_decrypt(rsa, rng_get, + &psync_mbed_rng, NULL, 0, &len, data, buff, sizeof(buff))) return PSYNC_INVALID_SYM_KEY; ret = (psync_symmetric_key_t)pmemlock_malloc( @@ -869,16 +836,18 @@ psync_ssl_rsa_sign_sha256_hash(psync_rsa_privatekey_t rsa, const unsigned char *data) { psync_rsa_signature_t ret; int padding, hash_id; + size_t rsalen = mbedtls_rsa_get_len(rsa); + ret = (psync_rsa_signature_t)psync_malloc( - offsetof(psync_symmetric_key_struct_t, key) + rsa->len); + offsetof(psync_symmetric_key_struct_t, key) + rsalen); if (!ret) return (psync_rsa_signature_t)(void *)PERROR_NO_MEMORY; - ret->datalen = rsa->len; - padding = rsa->padding; - hash_id = rsa->hash_id; + ret->datalen = rsalen; + padding = mbedtls_rsa_get_padding_mode(rsa); + hash_id = mbedtls_rsa_get_md_alg(rsa); mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA256); - if (mbedtls_rsa_rsassa_pss_sign(rsa, ctr_drbg_random_locked, &psync_mbed_rng, - MBEDTLS_RSA_PRIVATE, MBEDTLS_MD_SHA256, + if (mbedtls_rsa_rsassa_pss_sign(rsa, rng_get, &psync_mbed_rng, + MBEDTLS_MD_SHA256, PSYNC_SHA256_DIGEST_LEN, data, ret->data)) { free(ret); mbedtls_rsa_set_padding(rsa, padding, hash_id); @@ -887,318 +856,3 @@ psync_ssl_rsa_sign_sha256_hash(psync_rsa_privatekey_t rsa, mbedtls_rsa_set_padding(rsa, padding, hash_id); return ret; } - -#if defined(PSYNC_AES_HW_GCC) - -#define SSE2FUNC __attribute__((__target__("sse2"))) - -#define AESDEC ".byte 0x66,0x0F,0x38,0xDE," -#define AESDECLAST ".byte 0x66,0x0F,0x38,0xDF," -#define AESENC ".byte 0x66,0x0F,0x38,0xDC," -#define AESENCLAST ".byte 0x66,0x0F,0x38,0xDD," - -#define xmm0_xmm1 "0xC8" -#define xmm0_xmm2 "0xD0" -#define xmm0_xmm3 "0xD8" -#define xmm0_xmm4 "0xE0" -#define xmm0_xmm5 "0xE8" -// #define xmm1_xmm0 "0xC1" // unused, may be important later -#define xmm1_xmm2 "0xD1" -#define xmm1_xmm3 "0xD9" -#define xmm1_xmm4 "0xE1" -#define xmm1_xmm5 "0xE9" - -SSE2FUNC void psync_aes256_encode_block_hw(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst) { - asm("movdqu (%0), %%xmm0\n" - "lea 16(%0), %0\n" - "movdqa (%1), %%xmm1\n" - "dec %3\n" - "pxor %%xmm0, %%xmm1\n" - "movdqu (%0), %%xmm0\n" - "1:\n" - "lea 16(%0), %0\n" - "dec %3\n" AESENC xmm0_xmm1 "\n" - "movdqu (%0), %%xmm0\n" - "jnz 1b\n" AESENCLAST xmm0_xmm1 "\n" - "movdqa %%xmm1, (%2)\n" - : - : "r"(enc->rk), "r"(src), "r"(dst), "r"(enc->nr) - : "memory", "cc", "xmm0", "xmm1"); -} - -SSE2FUNC void psync_aes256_decode_block_hw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst) { - asm("movdqu (%0), %%xmm0\n" - "lea 16(%0), %0\n" - "movdqa (%1), %%xmm1\n" - "dec %3\n" - "pxor %%xmm0, %%xmm1\n" - "movdqu (%0), %%xmm0\n" - "1:\n" - "lea 16(%0), %0\n" - "dec %3\n" AESDEC xmm0_xmm1 "\n" - "movdqu (%0), %%xmm0\n" - "jnz 1b\n" AESDECLAST xmm0_xmm1 "\n" - "movdqa %%xmm1, (%2)\n" - : - : "r"(enc->rk), "r"(src), "r"(dst), "r"(enc->nr) - : "memory", "cc", "xmm0", "xmm1"); -} - -SSE2FUNC void psync_aes256_encode_2blocks_consec_hw(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst) { - asm("movdqu (%0), %%xmm0\n" - "movdqa (%1), %%xmm1\n" - "dec %3\n" - "movdqa 16(%1), %%xmm2\n" - "lea 16(%0), %0\n" - "xorps %%xmm0, %%xmm1\n" - "pxor %%xmm0, %%xmm2\n" - "movdqu (%0), %%xmm0\n" - "1:\n" - "lea 16(%0), %0\n" AESENC xmm0_xmm1 "\n" - "dec %3\n" AESENC xmm0_xmm2 "\n" - "movdqu (%0), %%xmm0\n" - "jnz 1b\n" AESENCLAST xmm0_xmm1 "\n" AESENCLAST xmm0_xmm2 "\n" - "movdqa %%xmm1, (%2)\n" - "movdqa %%xmm2, 16(%2)\n" - : - : "r"(enc->rk), "r"(src), "r"(dst), "r"(enc->nr) - : "memory", "cc", "xmm0", "xmm1", "xmm2"); -} - -SSE2FUNC void psync_aes256_decode_2blocks_consec_hw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst) { - asm("movdqu (%0), %%xmm0\n" - "movdqa (%1), %%xmm1\n" - "dec %3\n" - "movdqa 16(%1), %%xmm2\n" - "lea 16(%0), %0\n" - "xorps %%xmm0, %%xmm1\n" - "pxor %%xmm0, %%xmm2\n" - "movdqu (%0), %%xmm0\n" - "1:\n" - "lea 16(%0), %0\n" AESDEC xmm0_xmm1 "\n" - "dec %3\n" AESDEC xmm0_xmm2 "\n" - "movdqu (%0), %%xmm0\n" - "jnz 1b\n" AESDECLAST xmm0_xmm1 "\n" AESDECLAST xmm0_xmm2 "\n" - "movdqa %%xmm1, (%2)\n" - "movdqa %%xmm2, 16(%2)\n" - : - : "r"(enc->rk), "r"(src), "r"(dst), "r"(enc->nr) - : "memory", "cc", "xmm0", "xmm1", "xmm2"); -} - -SSE2FUNC void psync_aes256_decode_4blocks_consec_xor_hw( - psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, - unsigned char *bxor) { - asm("movdqu (%0), %%xmm0\n" - "shr %4\n" - "movdqa (%1), %%xmm2\n" - "dec %4\n" - "movdqa 16(%1), %%xmm3\n" - "xorps %%xmm0, %%xmm2\n" - "movdqa 32(%1), %%xmm4\n" - "xorps %%xmm0, %%xmm3\n" - "movdqa 48(%1), %%xmm5\n" - "pxor %%xmm0, %%xmm4\n" - "movdqu 16(%0), %%xmm1\n" - "pxor %%xmm0, %%xmm5\n" - "1:\n" - "lea 32(%0), %0\n" - "dec %4\n" AESDEC xmm1_xmm2 "\n" - "movdqu (%0), %%xmm0\n" AESDEC xmm1_xmm3 "\n" AESDEC xmm1_xmm4 - "\n" AESDEC xmm1_xmm5 "\n" AESDEC xmm0_xmm2 "\n" - "movdqu 16(%0), %%xmm1\n" AESDEC xmm0_xmm3 "\n" AESDEC xmm0_xmm4 - "\n" AESDEC xmm0_xmm5 "\n" - "jnz 1b\n" AESDEC xmm1_xmm2 "\n" - "movdqu 32(%0), %%xmm0\n" AESDEC xmm1_xmm3 "\n" AESDEC xmm1_xmm4 - "\n" AESDEC xmm1_xmm5 "\n" AESDECLAST xmm0_xmm2 "\n" AESDECLAST xmm0_xmm3 - "\n" AESDECLAST xmm0_xmm4 "\n" - "pxor (%3), %%xmm2\n" AESDECLAST xmm0_xmm5 "\n" - "pxor 16(%3), %%xmm3\n" - "movdqa %%xmm2, (%2)\n" - "pxor 32(%3), %%xmm4\n" - "movdqa %%xmm3, 16(%2)\n" - "pxor 48(%3), %%xmm5\n" - "movdqa %%xmm4, 32(%2)\n" - "movdqa %%xmm5, 48(%2)\n" - : - : "r"(enc->rk), "r"(src), "r"(dst), "r"(bxor), "r"(enc->nr) - : "memory", "cc", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5"); -} - -#elif defined(PSYNC_AES_HW_MSC) - -void psync_aes256_encode_block_hw(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst) { - __m128i r0, r1; - unsigned char *key; - unsigned cnt; - key = (unsigned char *)enc->rk; - r0 = _mm_loadu_si128((__m128i *)key); - r1 = _mm_load_si128((__m128i *)src); - cnt = enc->nr - 1; - key += 16; - r1 = _mm_xor_si128(r0, r1); - r0 = _mm_loadu_si128((__m128i *)key); - do { - key += 16; - r1 = _mm_aesenc_si128(r1, r0); - r0 = _mm_loadu_si128((__m128i *)key); - } while (--cnt); - r1 = _mm_aesenclast_si128(r1, r0); - _mm_store_si128((__m128i *)dst, r1); -} - -void psync_aes256_decode_block_hw(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst) { - __m128i r0, r1; - unsigned char *key; - unsigned cnt; - key = (unsigned char *)enc->rk; - r0 = _mm_loadu_si128((__m128i *)key); - r1 = _mm_load_si128((__m128i *)src); - cnt = enc->nr - 1; - key += 16; - r1 = _mm_xor_si128(r0, r1); - r0 = _mm_loadu_si128((__m128i *)key); - do { - key += 16; - r1 = _mm_aesdec_si128(r1, r0); - r0 = _mm_loadu_si128((__m128i *)key); - } while (--cnt); - r1 = _mm_aesdeclast_si128(r1, r0); - _mm_store_si128((__m128i *)dst, r1); -} - -void psync_aes256_encode_2blocks_consec_hw(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst) { - __m128i r0, r1, r2; - unsigned char *key; - unsigned cnt; - key = (unsigned char *)enc->rk; - r0 = _mm_loadu_si128((__m128i *)key); - r1 = _mm_load_si128((__m128i *)src); - r2 = _mm_load_si128((__m128i *)(src + 16)); - cnt = enc->nr - 1; - key += 16; - r1 = _mm_xor_si128(r0, r1); - r2 = _mm_xor_si128(r0, r2); - r0 = _mm_loadu_si128((__m128i *)key); - do { - key += 16; - r1 = _mm_aesenc_si128(r1, r0); - r2 = _mm_aesenc_si128(r2, r0); - r0 = _mm_loadu_si128((__m128i *)key); - } while (--cnt); - r1 = _mm_aesenclast_si128(r1, r0); - r2 = _mm_aesenclast_si128(r2, r0); - _mm_store_si128((__m128i *)dst, r1); - _mm_store_si128((__m128i *)(dst + 16), r2); -} - -void psync_aes256_decode_2blocks_consec_hw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst) { - __m128i r0, r1, r2; - unsigned char *key; - unsigned cnt; - key = (unsigned char *)enc->rk; - r0 = _mm_loadu_si128((__m128i *)key); - r1 = _mm_load_si128((__m128i *)src); - r2 = _mm_load_si128((__m128i *)(src + 16)); - cnt = enc->nr - 1; - key += 16; - r1 = _mm_xor_si128(r0, r1); - r2 = _mm_xor_si128(r0, r2); - r0 = _mm_loadu_si128((__m128i *)key); - do { - key += 16; - r1 = _mm_aesdec_si128(r1, r0); - r2 = _mm_aesdec_si128(r2, r0); - r0 = _mm_loadu_si128((__m128i *)key); - } while (--cnt); - r1 = _mm_aesdeclast_si128(r1, r0); - r2 = _mm_aesdeclast_si128(r2, r0); - _mm_store_si128((__m128i *)dst, r1); - _mm_store_si128((__m128i *)(dst + 16), r2); -} - -void psync_aes256_decode_4blocks_consec_xor_hw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst, - unsigned char *bxor) { - __m128i r0, r1, r2, r3, r4; - unsigned char *key; - unsigned cnt; - key = (unsigned char *)enc->rk; - r0 = _mm_loadu_si128((__m128i *)key); - r1 = _mm_load_si128((__m128i *)src); - r2 = _mm_load_si128((__m128i *)(src + 16)); - r3 = _mm_load_si128((__m128i *)(src + 32)); - r4 = _mm_load_si128((__m128i *)(src + 48)); - cnt = enc->nr - 1; - key += 16; - r1 = _mm_xor_si128(r0, r1); - r2 = _mm_xor_si128(r0, r2); - r3 = _mm_xor_si128(r0, r3); - r4 = _mm_xor_si128(r0, r4); - r0 = _mm_loadu_si128((__m128i *)key); - do { - key += 16; - r1 = _mm_aesdec_si128(r1, r0); - r2 = _mm_aesdec_si128(r2, r0); - r3 = _mm_aesdec_si128(r3, r0); - r4 = _mm_aesdec_si128(r4, r0); - r0 = _mm_loadu_si128((__m128i *)key); - } while (--cnt); - r1 = _mm_aesdeclast_si128(r1, r0); - r2 = _mm_aesdeclast_si128(r2, r0); - r3 = _mm_aesdeclast_si128(r3, r0); - r4 = _mm_aesdeclast_si128(r4, r0); - r0 = _mm_load_si128((__m128i *)bxor); - r1 = _mm_xor_si128(r0, r1); - r0 = _mm_load_si128((__m128i *)(bxor + 16)); - _mm_store_si128((__m128i *)dst, r1); - r2 = _mm_xor_si128(r0, r2); - r0 = _mm_load_si128((__m128i *)(bxor + 32)); - _mm_store_si128((__m128i *)(dst + 16), r2); - r3 = _mm_xor_si128(r0, r3); - r0 = _mm_load_si128((__m128i *)(bxor + 48)); - _mm_store_si128((__m128i *)(dst + 32), r3); - r4 = _mm_xor_si128(r0, r4); - _mm_store_si128((__m128i *)(dst + 48), r4); -} - -#endif - -#if defined(PSYNC_AES_HW) - -void psync_aes256_decode_4blocks_consec_xor_sw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst, - unsigned char *bxor) { - unsigned long i; - mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src, dst); - mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src + PSYNC_AES256_BLOCK_SIZE, - dst + PSYNC_AES256_BLOCK_SIZE); - mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, - src + PSYNC_AES256_BLOCK_SIZE * 2, - dst + PSYNC_AES256_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++) - ((unsigned long *)dst)[i] ^= ((unsigned long *)bxor)[i]; -} - -#endif diff --git a/pclsync/pssl.h b/pclsync/pssl.h index cf336b7..14b50c8 100644 --- a/pclsync/pssl.h +++ b/pclsync/pssl.h @@ -50,28 +50,28 @@ #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_ret(data, datalen, checksum) -#define psync_sha1_init(pctx) mbedtls_sha1_starts_ret(pctx) -#define psync_sha1_update(pctx, data, datalen) mbedtls_sha1_update_ret(pctx, (const unsigned char *)data, datalen) -#define psync_sha1_final(checksum, pctx) mbedtls_sha1_finish_ret(pctx, checksum) +#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_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_ret(data, datalen, checksum, 0) -#define psync_sha256_init(pctx) mbedtls_sha256_starts_ret(pctx, 0) -#define psync_sha256_update(pctx, data, datalen) mbedtls_sha256_update_ret(pctx, (const unsigned char *)data, datalen) -#define psync_sha256_final(checksum, pctx) mbedtls_sha256_finish_ret(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_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_ret(data, datalen, checksum, 0) -#define psync_sha512_init(pctx) mbedtls_sha512_starts_ret(pctx, 0) -#define psync_sha512_update(pctx, data, datalen) mbedtls_sha512_update_ret(pctx, (const unsigned char *)data, datalen) -#define psync_sha512_final(checksum, pctx) mbedtls_sha512_finish_ret(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) typedef mbedtls_rsa_context *psync_rsa_t; typedef mbedtls_rsa_context *psync_rsa_publickey_t; @@ -95,88 +95,8 @@ void pssl_debug_cb(psync_ssl_debug_callback_t cb, void *ctx); (defined(__amd64__) || defined(__x86_64__) || defined(__i386__)) #define PSYNC_AES_HW #define PSYNC_AES_HW_GCC -#elif defined(_MSC_VER) -#define PSYNC_AES_HW -#define PSYNC_AES_HW_MSC #endif -#if defined(PSYNC_AES_HW) -extern int psync_ssl_hw_aes; - -void psync_aes256_encode_block_hw(psync_aes256_encoder enc, - const unsigned char *src, unsigned char *dst); -void psync_aes256_decode_block_hw(psync_aes256_decoder enc, - const unsigned char *src, unsigned char *dst); -void psync_aes256_encode_2blocks_consec_hw(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst); -void psync_aes256_decode_2blocks_consec_hw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst); -void psync_aes256_decode_4blocks_consec_xor_hw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst, - unsigned char *bxor); -void psync_aes256_decode_4blocks_consec_xor_sw(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst, - unsigned char *bxor); - -static inline void psync_aes256_encode_block(psync_aes256_encoder enc, - const unsigned char *src, - unsigned char *dst) { - if (likely(psync_ssl_hw_aes)) - psync_aes256_encode_block_hw(enc, src, dst); - else - mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_ENCRYPT, src, dst); -} - -static inline void psync_aes256_decode_block(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst) { - if (likely(psync_ssl_hw_aes)) - psync_aes256_decode_block_hw(enc, src, dst); - else - mbedtls_aes_crypt_ecb(enc, MBEDTLS_AES_DECRYPT, src, dst); -} - -static inline void psync_aes256_encode_2blocks_consec(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst) { - if (likely(psync_ssl_hw_aes)) - psync_aes256_encode_2blocks_consec_hw(enc, src, dst); - else { - 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); - } -} - -static inline void psync_aes256_decode_2blocks_consec(psync_aes256_decoder enc, - const unsigned char *src, - unsigned char *dst) { - if (likely(psync_ssl_hw_aes)) - psync_aes256_decode_2blocks_consec_hw(enc, src, dst); - else { - 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); - } -} - -static inline void psync_aes256_decode_4blocks_consec_xor( - psync_aes256_decoder enc, const unsigned char *src, unsigned char *dst, - unsigned char *bxor) { - if (psync_ssl_hw_aes) - psync_aes256_decode_4blocks_consec_xor_hw(enc, src, dst, bxor); - else - psync_aes256_decode_4blocks_consec_xor_sw(enc, src, dst, bxor); -} - -#else - static inline void psync_aes256_encode_block(psync_aes256_encoder enc, const unsigned char *src, unsigned char *dst) { @@ -222,7 +142,6 @@ static inline void psync_aes256_decode_4blocks_consec_xor( ((unsigned long *)dst)[i] ^= ((unsigned long *)bxor)[i]; } -#endif extern PSYNC_THREAD int psync_ssl_errno; @@ -263,7 +182,6 @@ int psync_ssl_read(void *sslconn, void *buf, int num); int psync_ssl_write(void *sslconn, const void *buf, int num); void psync_ssl_rand_strong(unsigned char *buf, int num); -void psync_ssl_rand_weak(unsigned char *buf, int num); psync_rsa_t psync_ssl_gen_rsa(int bits); void psync_ssl_free_rsa(psync_rsa_t rsa); @@ -271,48 +189,29 @@ psync_rsa_publickey_t psync_ssl_rsa_get_public(psync_rsa_t rsa); void psync_ssl_rsa_free_public(psync_rsa_publickey_t key); psync_rsa_privatekey_t psync_ssl_rsa_get_private(psync_rsa_t rsa); void psync_ssl_rsa_free_private(psync_rsa_privatekey_t key); -psync_binary_rsa_key_t -psync_ssl_rsa_public_to_binary(psync_rsa_publickey_t rsa); -psync_binary_rsa_key_t -psync_ssl_rsa_private_to_binary(psync_rsa_privatekey_t rsa); +psync_binary_rsa_key_t psync_ssl_rsa_public_to_binary(psync_rsa_publickey_t rsa); +psync_binary_rsa_key_t psync_ssl_rsa_private_to_binary(psync_rsa_privatekey_t rsa); psync_rsa_publickey_t psync_ssl_rsa_load_public(const unsigned char *keydata, size_t keylen); psync_rsa_privatekey_t psync_ssl_rsa_load_private(const unsigned char *keydata, size_t keylen); -psync_rsa_publickey_t -psync_ssl_rsa_binary_to_public(psync_binary_rsa_key_t bin); -psync_rsa_privatekey_t -psync_ssl_rsa_binary_to_private(psync_binary_rsa_key_t bin); +psync_rsa_publickey_t psync_ssl_rsa_binary_to_public(psync_binary_rsa_key_t bin); +psync_rsa_privatekey_t psync_ssl_rsa_binary_to_private(psync_binary_rsa_key_t bin); void psync_ssl_rsa_free_binary(psync_binary_rsa_key_t bin); -psync_symmetric_key_t -psync_ssl_gen_symmetric_key_from_pass(const char *password, size_t keylen, - const unsigned char *salt, size_t saltlen, - size_t iterations); -char *psync_ssl_derive_password_from_passphrase(const char *username, - const char *passphrase); -psync_encrypted_symmetric_key_t -psync_ssl_alloc_encrypted_symmetric_key(size_t len); -psync_encrypted_symmetric_key_t -psync_ssl_copy_encrypted_symmetric_key(psync_encrypted_symmetric_key_t src); +psync_symmetric_key_t psync_ssl_gen_symmetric_key_from_pass(const char *password, size_t keylen, const unsigned char *salt, size_t saltlen, size_t iterations); +char *psync_ssl_derive_password_from_passphrase(const char *username, const char *passphrase); +psync_encrypted_symmetric_key_t psync_ssl_alloc_encrypted_symmetric_key(size_t len); +psync_encrypted_symmetric_key_t psync_ssl_copy_encrypted_symmetric_key(psync_encrypted_symmetric_key_t src); void psync_ssl_free_symmetric_key(psync_symmetric_key_t key); -psync_encrypted_symmetric_key_t -psync_ssl_rsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data, - size_t datalen); -psync_symmetric_key_t psync_ssl_rsa_decrypt_data(psync_rsa_privatekey_t rsa, - const unsigned char *data, - size_t datalen); -psync_encrypted_symmetric_key_t -psync_ssl_rsa_encrypt_symmetric_key(psync_rsa_publickey_t rsa, - const psync_symmetric_key_t key); -psync_symmetric_key_t psync_ssl_rsa_decrypt_symmetric_key( - psync_rsa_privatekey_t rsa, const psync_encrypted_symmetric_key_t enckey); +psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data, size_t datalen); +psync_symmetric_key_t psync_ssl_rsa_decrypt_data(psync_rsa_privatekey_t rsa, const unsigned char *data, size_t datalen); +psync_encrypted_symmetric_key_t psync_ssl_rsa_encrypt_symmetric_key(psync_rsa_publickey_t rsa, const psync_symmetric_key_t key); +psync_symmetric_key_t psync_ssl_rsa_decrypt_symmetric_key(psync_rsa_privatekey_t rsa, const psync_encrypted_symmetric_key_t enckey); psync_aes256_encoder psync_ssl_aes256_create_encoder(psync_symmetric_key_t key); void psync_ssl_aes256_free_encoder(psync_aes256_encoder aes); psync_aes256_encoder psync_ssl_aes256_create_decoder(psync_symmetric_key_t key); void psync_ssl_aes256_free_decoder(psync_aes256_encoder aes); -psync_rsa_signature_t psync_ssl_rsa_sign_sha256_hash(psync_rsa_privatekey_t rsa, - const unsigned char *data); -psync_symmetric_key_t psync_ssl_rsa_decrypt_symm_key_lock( - psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey); +psync_rsa_signature_t psync_ssl_rsa_sign_sha256_hash(psync_rsa_privatekey_t rsa, const unsigned char *data); +psync_symmetric_key_t psync_ssl_rsa_decrypt_symm_key_lock(psync_rsa_privatekey_t *rsa, const psync_encrypted_symmetric_key_t *enckey); #endif