Levi Neely
GitHub
parent
eb04ac246a
commit
826c2e3edf
|
|
@ -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
|
||||
|
|
|
|||
4
Makefile
4
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
|
||||
|
|
|
|||
68
README.md
68
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 <mbedtls/#include <mbedtls3/' {} +
|
||||
make clean all
|
||||
```
|
||||
|
||||
You should now have a working `pcloudcc` on your system!
|
||||
|
||||
## Security Notice
|
||||
|
||||
|
|
@ -23,27 +54,11 @@ Props to [@tieum](https://github.com/tieum), [@ebouda333](https://github.com/ebo
|
|||
```
|
||||
docker run --network host --rm -ti fathyb/carbonyl https://my.pcloud.com
|
||||
```
|
||||
|
||||
**SOCKS proxy over SSH** *Requires TCP port forwarding over SSH*. Log in to the remote host using the command `ssh -D <port>` to enable a SOCKS proxy on `localhost:<port>`. Configure your local web browser to use `localhost:<port>` 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 <targethost>`) 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!`
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@
|
|||
#include <mbedtls/ctr_drbg.h>
|
||||
#include <mbedtls/debug.h>
|
||||
#include <mbedtls/entropy.h>
|
||||
#include <mbedtls/pk.h>
|
||||
#include <mbedtls/pkcs5.h>
|
||||
#include <mbedtls/sha1.h>
|
||||
#include <mbedtls/sha256.h>
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
530
pclsync/pssl.c
530
pclsync/pssl.c
|
|
@ -31,6 +31,7 @@
|
|||
|
||||
#include <errno.h>
|
||||
#include <ctype.h>
|
||||
#include <mbedtls/asn1.h>
|
||||
#include <mbedtls/ctr_drbg.h>
|
||||
#include <mbedtls/debug.h>
|
||||
#include <mbedtls/entropy.h>
|
||||
|
|
@ -38,6 +39,7 @@
|
|||
#include <mbedtls/md.h>
|
||||
#include <mbedtls/net_sockets.h>
|
||||
#include <mbedtls/pkcs5.h>
|
||||
#include <mbedtls/rsa.h>
|
||||
#include <mbedtls/sha256.h>
|
||||
#include <mbedtls/ssl.h>
|
||||
#include <pthread.h>
|
||||
|
|
@ -61,44 +63,14 @@
|
|||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
// 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
|
||||
|
|
|
|||
153
pclsync/pssl.h
153
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
|
||||
|
|
|
|||
Loading…
Reference in New Issue