194 lines
6.6 KiB
C
194 lines
6.6 KiB
C
#include "crypt.h"
|
|
|
|
#include <string.h>
|
|
|
|
int crypt_key_gen(crypt_key_t *const k) {
|
|
if (crypto_kx_keypair(k->kx_pub, k->kx_sec) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
if (crypto_sign_keypair(k->sign_pub, k->sign_sec) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
k->hasSecKey = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int crypt_key_from_hex(crypt_key_t *const k, const char phex[CRYPT_PKEY_HEXLEN], const char shex[CRYPT_SKEY_HEXLEN]) {
|
|
if (sodium_hex2bin(k->kx_pub, CRYPT_KX_PKEY_LEN, phex, CRYPT_KX_PKEY_LEN * 2, NULL, NULL, NULL) == -1)
|
|
return -1;
|
|
if (sodium_hex2bin(k->kx_sec, CRYPT_KX_SKEY_LEN, shex, CRYPT_KX_SKEY_LEN * 2, NULL, NULL, NULL) == -1)
|
|
return -1;
|
|
if (sodium_hex2bin(k->sign_pub, CRYPT_SIGN_PKEY_LEN, phex+(CRYPT_KX_PKEY_LEN * 2), CRYPT_SIGN_PKEY_LEN * 2, NULL, NULL, NULL) == -1)
|
|
return -1;
|
|
if (sodium_hex2bin(k->sign_sec, CRYPT_SIGN_SKEY_LEN, shex+(CRYPT_KX_SKEY_LEN * 2), CRYPT_SIGN_SKEY_LEN * 2, NULL, NULL, NULL) == -1)
|
|
return -1;
|
|
|
|
k->hasSecKey = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int crypt_key_from_hex_public(crypt_key_t *const k, const char phex[CRYPT_PKEY_HEXLEN]) {
|
|
if (sodium_hex2bin(k->kx_pub, CRYPT_KX_PKEY_LEN, phex, CRYPT_KX_PKEY_LEN * 2, NULL, NULL, NULL) == -1)
|
|
return -1;
|
|
if (sodium_hex2bin(k->sign_pub, CRYPT_SIGN_PKEY_LEN, phex+(CRYPT_KX_PKEY_LEN * 2), CRYPT_SIGN_PKEY_LEN * 2, NULL, NULL, NULL) == -1)
|
|
return -1;
|
|
|
|
k->hasSecKey = false;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void crypt_key_destroy(crypt_key_t *const k) {
|
|
sodium_memzero(k->kx_pub, CRYPT_KX_PKEY_LEN);
|
|
sodium_memzero(k->kx_sec, CRYPT_KX_SKEY_LEN);
|
|
sodium_memzero(k->sign_pub, CRYPT_SIGN_PKEY_LEN);
|
|
sodium_memzero(k->sign_sec, CRYPT_SIGN_SKEY_LEN);
|
|
}
|
|
|
|
int crypt_key_export_public(const crypt_key_t *const k, char hex[CRYPT_PKEY_HEXLEN]) {
|
|
if (sodium_bin2hex(hex, CRYPT_KX_PKEY_LEN * 2 + 1, k->kx_pub, CRYPT_KX_PKEY_LEN) == NULL)
|
|
return -1;
|
|
if (sodium_bin2hex(hex+(CRYPT_KX_PKEY_LEN * 2), CRYPT_SIGN_PKEY_LEN * 2 + 1, k->sign_pub, CRYPT_SIGN_PKEY_LEN) == NULL)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int crypt_key_export_secret(const crypt_key_t *const k, char hex[CRYPT_SKEY_HEXLEN]) {
|
|
if (!k->hasSecKey)
|
|
return -1;
|
|
|
|
if (sodium_bin2hex(hex, CRYPT_KX_SKEY_LEN * 2 + 1, k->kx_sec, CRYPT_KX_SKEY_LEN) == NULL)
|
|
return -1;
|
|
if (sodium_bin2hex(hex+(CRYPT_KX_SKEY_LEN * 2), CRYPT_SIGN_SKEY_LEN * 2 + 1, k->sign_sec, CRYPT_SIGN_SKEY_LEN) == NULL)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int crypt_load_key(crypt_key_t *const k, FILE *const pub, FILE *const sec) {
|
|
if (pub == NULL || sec == NULL)
|
|
return -1;
|
|
|
|
char phex[CRYPT_PKEY_HEXLEN], shex[CRYPT_SKEY_HEXLEN];
|
|
|
|
if (fread(phex, sizeof(phex[0]), CRYPT_PKEY_HEXLEN, pub) != CRYPT_PKEY_HEXLEN)
|
|
return -1;
|
|
if (fread(shex, sizeof(shex[0]), CRYPT_SKEY_HEXLEN, sec) != CRYPT_SKEY_HEXLEN)
|
|
return -1;
|
|
|
|
return crypt_key_from_hex(k, phex, shex);
|
|
}
|
|
|
|
int crypt_store_key(const crypt_key_t *const k, FILE *const pub, FILE *const sec) {
|
|
if (!k->hasSecKey || pub == NULL || sec == NULL)
|
|
return -1;
|
|
|
|
char phex[CRYPT_PKEY_HEXLEN], shex[CRYPT_SKEY_HEXLEN];
|
|
|
|
if (crypt_key_export_public(k, phex) == -1)
|
|
return -1;
|
|
if (crypt_key_export_secret(k, shex) == -1)
|
|
return -1;
|
|
|
|
if (fwrite(phex, sizeof(phex[0]), CRYPT_PKEY_HEXLEN, pub) != CRYPT_PKEY_HEXLEN)
|
|
return -1;
|
|
if (fwrite(shex, sizeof(shex[0]), CRYPT_SKEY_HEXLEN, sec) != CRYPT_SKEY_HEXLEN)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned char *crypt_hello(const crypt_key_t *const own) {
|
|
unsigned char *hello = (unsigned char *)malloc(CRYPT_HELLO_LEN * sizeof(unsigned char));
|
|
|
|
if (crypt_key_export_public(own, (char *const)hello) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
if (crypto_sign_detached(hello+CRYPT_PKEY_HEXLEN, NULL, (const unsigned char *)hello, CRYPT_PKEY_HEXLEN, own->sign_sec) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
randombytes_buf(hello+CRYPT_PKEY_HEXLEN+CRYPT_SIGN_LEN, CRYPT_NONCEHALF_LEN);
|
|
|
|
return hello;
|
|
}
|
|
|
|
int crypt_hello_verify(const unsigned char *const hello, crypt_key_t *const remote) {
|
|
if (crypt_key_from_hex_public(remote, (const char *const)hello) == -1)
|
|
return -1;
|
|
|
|
if (crypto_sign_verify_detached(hello+CRYPT_PKEY_HEXLEN, (const unsigned char *const)hello, CRYPT_PKEY_HEXLEN, remote->sign_pub))
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned char *crypt_hello_get_nonce(const unsigned char *const own_hello, const unsigned char *const remote_hello, bool is_client) {
|
|
unsigned char *nonce = (unsigned char *)malloc(CRYPT_NONCE_LEN * sizeof(unsigned char));
|
|
if (nonce == NULL)
|
|
return NULL;
|
|
|
|
const unsigned char *first = NULL, *second = NULL;
|
|
|
|
first = (is_client ? own_hello : remote_hello) + CRYPT_PKEY_HEXLEN+CRYPT_SIGN_LEN;
|
|
second = (is_client ? remote_hello : own_hello) + CRYPT_PKEY_HEXLEN+CRYPT_SIGN_LEN;
|
|
|
|
memcpy(nonce, first, CRYPT_NONCEHALF_LEN);
|
|
memcpy(nonce+CRYPT_NONCEHALF_LEN, second, CRYPT_NONCEHALF_LEN);
|
|
|
|
return nonce;
|
|
}
|
|
|
|
int crypt_session_init(crypt_session_t *const s, const crypt_key_t *const own, crypt_key_t *const remote, const unsigned char *const nonce, bool is_client) {
|
|
if (is_client) {
|
|
if (crypto_kx_client_session_keys(s->rx, s->tx, own->kx_pub, own->kx_sec, remote->kx_pub) != 0) {
|
|
fprintf(stderr, "Failed to instantiate a client session.\n");
|
|
return -1;
|
|
}
|
|
} else {
|
|
if (crypto_kx_server_session_keys(s->rx, s->tx, own->kx_pub, own->kx_sec, remote->kx_pub) != 0) {
|
|
fprintf(stderr, "Failed to instantiate a server session.\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
s->remote_key = remote;
|
|
|
|
memcpy(s->nonce, nonce, CRYPT_NONCE_LEN);
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned char *crypt_session_encrypt(crypt_session_t *const s, const unsigned char *const m, unsigned long long mlen, unsigned long long *clen) {
|
|
unsigned char *c = (unsigned char *)malloc((mlen + crypto_aead_aegis256_ABYTES) * sizeof(unsigned char));
|
|
|
|
if (crypto_aead_aegis256_encrypt(c, clen, m, mlen, NULL, 0, NULL, s->nonce, s->tx) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
unsigned char *crypt_session_decrypt(crypt_session_t *const s, const unsigned char *const c, unsigned long long clen, unsigned long long *mlen) {
|
|
unsigned char *m = (unsigned char *)malloc((clen - crypto_aead_aegis256_ABYTES) * sizeof(unsigned char));
|
|
|
|
if (crypto_aead_aegis256_decrypt(m, mlen, NULL, c, clen, NULL, 0, s->nonce, s->rx) != 0) {
|
|
free(m);
|
|
return NULL;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
void crypt_session_destroy(crypt_session_t *const s) {
|
|
sodium_memzero(s->rx, CRYPT_SESS_KEY_LEN);
|
|
sodium_memzero(s->tx, CRYPT_SESS_KEY_LEN);
|
|
sodium_memzero(s->nonce, CRYPT_NONCE_LEN);
|
|
crypt_key_destroy(s->remote_key);
|
|
} |