X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=crypt.c;h=b8a587cd0e55114f1ced030d5284adcd2d4a96b4;hb=0ebb7e2b2e8599d5aea81fee2c2bbbed90af6f65;hp=8986d0e7a5bc5bbab4a011fc93b8410fd758ea1a;hpb=d09716570fc81b71d6ad3d5f543b5f8acf1a5e33;p=paraslash.git diff --git a/crypt.c b/crypt.c index 8986d0e7..b8a587cd 100644 --- a/crypt.c +++ b/crypt.c @@ -1,41 +1,30 @@ -/* - * Copyright (C) 2005-2011 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2005 Andre Noll , see file COPYING. */ /** \file crypt.c Openssl-based encryption/decryption routines. */ #include -#include #include #include #include #include -#include #include +#include +#include +#include #include "para.h" #include "error.h" #include "string.h" #include "crypt.h" #include "fd.h" +#include "crypt_backend.h" +#include "base64.h" +#include "portable_io.h" struct asymmetric_key { RSA *rsa; }; -/** - * Fill a buffer with random content. - * - * \param buf The buffer to fill. - * \param num The size of \a buf in bytes. - * - * This function puts \a num cryptographically strong pseudo-random bytes into - * buf. If libssl can not guarantee an unpredictable byte sequence (for example - * because the PRNG has not been seeded with enough randomness) the function - * logs an error message and calls exit(). - */ void get_random_bytes_or_die(unsigned char *buf, int num) { unsigned long err; @@ -48,13 +37,10 @@ void get_random_bytes_or_die(unsigned char *buf, int num) exit(EXIT_FAILURE); } -/** - * Seed pseudo random number generators. - * - * This function reads 64 bytes from /dev/urandom and adds them to the SSL - * PRNG. It also seeds the PRNG used by random() with a random seed obtained - * from SSL. If /dev/random could not be read, an error message is logged and - * the function calls exit(). +/* + * Read 64 bytes from /dev/urandom and add them to the SSL PRNG. Seed the PRNG + * used by random(3) with a random seed obtained from SSL. If /dev/urandom is + * not readable, the function calls exit(). * * \sa RAND_load_file(3), \ref get_random_bytes_or_die(), srandom(3), * random(3), \ref para_random(). @@ -71,81 +57,135 @@ void init_random_seed_or_die(void) srandom(seed); } -static int check_key_file(const char *file, int private) +static int get_private_key(const char *path, RSA **rsa) { - struct stat st; + EVP_PKEY *pkey; + BIO *bio = BIO_new(BIO_s_file()); - if (stat(file, &st) != 0) - return -ERRNO_TO_PARA_ERROR(errno); - if (private != LOAD_PRIVATE_KEY) - return 0; - if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) - return -E_KEY_PERM; - return 1; + *rsa = NULL; + if (!bio) + return -E_PRIVATE_KEY; + if (BIO_read_filename(bio, path) <= 0) + goto bio_free; + pkey = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL); + if (!pkey) + goto bio_free; + *rsa = EVP_PKEY_get1_RSA(pkey); + EVP_PKEY_free(pkey); +bio_free: + BIO_free(bio); + return *rsa? RSA_size(*rsa) : -E_PRIVATE_KEY; } -static EVP_PKEY *load_key(const char *file, int private) +/* + * The public key loading functions below were inspired by corresponding code + * of openssh-5.2p1, Copyright (c) 1995 Tatu Ylonen , Espoo, + * Finland. However, not much of the original code remains. + */ + +static int read_bignum(const unsigned char *buf, size_t len, BIGNUM **result) { - BIO *key; - EVP_PKEY *pkey = NULL; - int ret = check_key_file(file, private); + const unsigned char *p = buf, *end = buf + len; + uint32_t bnsize; + BIGNUM *bn; - if (ret < 0) { - PARA_ERROR_LOG("%s\n", para_strerror(-ret)); - return NULL; - } - key = BIO_new(BIO_s_file()); - if (!key) - return NULL; - if (BIO_read_filename(key, file) > 0) { - if (private == LOAD_PRIVATE_KEY) - pkey = PEM_read_bio_PrivateKey(key, NULL, NULL, NULL); - else - pkey = PEM_read_bio_PUBKEY(key, NULL, NULL, NULL); - } - BIO_free(key); - return pkey; + if (p + 4 < p) + return -E_BIGNUM; + if (p + 4 > end) + return -E_BIGNUM; + bnsize = read_u32_be(p); + PARA_DEBUG_LOG("bnsize: %u\n", bnsize); + p += 4; + if (p + bnsize < p) + return -E_BIGNUM; + if (p + bnsize > end) + return -E_BIGNUM; + if (bnsize > 8192) + return -E_BIGNUM; + bn = BN_bin2bn(p, bnsize, NULL); + if (!bn) + return -E_BIGNUM; + *result = bn; + return bnsize + 4; } -/** - * Read an asymmetric key from a file. - * - * \param key_file The file containing the key. - * \param private if non-zero, read the private key, otherwise the public key. - * \param result The key structure is returned here. - * - * \return The size of the key on success, negative on errors. - * - * \sa openssl(1), rsa(1). - */ -int get_asymmetric_key(const char *key_file, int private, - struct asymmetric_key **result) +static int read_rsa_bignums(const unsigned char *blob, int blen, RSA **result) { - struct asymmetric_key *key; + int ret; RSA *rsa; - EVP_PKEY *pkey = load_key(key_file, private); + BIGNUM *n, *e; + const unsigned char *p = blob, *end = blob + blen; - if (!pkey) - return (private == LOAD_PRIVATE_KEY)? -E_PRIVATE_KEY - : -E_PUBLIC_KEY; - rsa = EVP_PKEY_get1_RSA(pkey); - EVP_PKEY_free(pkey); + rsa = RSA_new(); if (!rsa) - return -E_RSA; + return -E_BIGNUM; + ret = read_bignum(p, end - p, &e); + if (ret < 0) + goto fail; + p += ret; + ret = read_bignum(p, end - p, &n); + if (ret < 0) + goto fail; +#ifdef HAVE_RSA_SET0_KEY + RSA_set0_key(rsa, n, e, NULL); +#else + rsa->n = n; + rsa->e = e; +#endif + *result = rsa; + return 1; +fail: + RSA_free(rsa); + return ret; +} + +int get_public_key(const char *key_file, struct asymmetric_key **result) +{ + struct asymmetric_key *key = NULL; + void *map = NULL; + unsigned char *blob = NULL; + size_t map_size, encoded_size, decoded_size; + int ret, ret2; + char *cp; + key = para_malloc(sizeof(*key)); - key->rsa = rsa; - *result = key; - return RSA_size(rsa); + ret = mmap_full_file(key_file, O_RDONLY, &map, &map_size, NULL); + if (ret < 0) + goto out; + ret = is_ssh_rsa_key(map, map_size); + if (!ret) { + ret = -E_SSH_PARSE; + goto out_unmap; + } + cp = map + ret; + encoded_size = map_size - ret; + PARA_INFO_LOG("decoding public rsa-ssh key %s\n", key_file); + ret = uudecode(cp, encoded_size, (char **)&blob, &decoded_size); + if (ret < 0) + goto out_unmap; + ret = check_ssh_key_header(blob, decoded_size); + if (ret < 0) + goto out_unmap; + ret = read_rsa_bignums(blob + ret, decoded_size - ret, &key->rsa); + if (ret < 0) + goto out_unmap; + ret = RSA_size(key->rsa); +out_unmap: + ret2 = para_munmap(map, map_size); + if (ret >= 0 && ret2 < 0) + ret = ret2; +out: + if (ret < 0) { + free(key); + *result = NULL; + PARA_ERROR_LOG("key %s: %s\n", key_file, para_strerror(-ret)); + } else + *result = key; + free(blob); + return ret; } -/** - * Deallocate an asymmetric key structure. - * - * \param key Pointer to the key structure to free. - * - * This must be called for any key obtained by get_asymmetric_key(). - */ -void free_asymmetric_key(struct asymmetric_key *key) +void free_public_key(struct asymmetric_key *key) { if (!key) return; @@ -153,31 +193,23 @@ void free_asymmetric_key(struct asymmetric_key *key) free(key); } -/** - * Decrypt a buffer using a private key. - * - * \param key_file Full path of the key. - * \param outbuf The output buffer. - * \param inbuf The encrypted input buffer. - * \param inlen The length of \a inbuf in bytes. - * - * The \a outbuf must be large enough to hold at least \a rsa_inlen bytes. - * - * \return The size of the recovered plaintext on success, negative on errors. - * - * \sa RSA_private_decrypt(3) - **/ int priv_decrypt(const char *key_file, unsigned char *outbuf, unsigned char *inbuf, int inlen) { struct asymmetric_key *priv; int ret; + ret = check_private_key_file(key_file); + if (ret < 0) + return ret; if (inlen < 0) return -E_RSA; - ret = get_asymmetric_key(key_file, LOAD_PRIVATE_KEY, &priv); - if (ret < 0) + priv = para_malloc(sizeof(*priv)); + ret = get_private_key(key_file, &priv->rsa); + if (ret < 0) { + free(priv); return ret; + } /* * RSA is vulnerable to timing attacks. Generate a random blinding * factor to protect against this kind of attack. @@ -191,22 +223,11 @@ int priv_decrypt(const char *key_file, unsigned char *outbuf, if (ret <= 0) ret = -E_DECRYPT; out: - free_asymmetric_key(priv); + RSA_free(priv->rsa); + free(priv); return ret; } -/** - * Encrypt a buffer using an RSA key - * - * \param pub: The public key. - * \param inbuf The input buffer. - * \param len The length of \a inbuf. - * \param outbuf The output buffer. - * - * \return The size of the encrypted data on success, negative on errors. - * - * \sa RSA_public_encrypt(3) - */ int pub_encrypt(struct asymmetric_key *pub, unsigned char *inbuf, unsigned len, unsigned char *outbuf) { @@ -219,118 +240,57 @@ int pub_encrypt(struct asymmetric_key *pub, unsigned char *inbuf, return ret < 0? -E_ENCRYPT : ret; } -#define RC4_ALIGN 8 +struct stream_cipher { + EVP_CIPHER_CTX *aes; +}; -/** - * Encrypt and send a buffer. - * - * \param rc4c The rc4 crypt context. - * \param buf The buffer to send. - * \param len The size of \a buf in bytes. - * - * \return The return value of the underyling call to write_all(). - * - * \sa \ref write_all(), RC4(3). - */ -int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len) +struct stream_cipher *sc_new(const unsigned char *data, int len) { - int ret; - unsigned char *tmp; - static unsigned char remainder[RC4_ALIGN]; - size_t l1 = ROUND_DOWN(len, RC4_ALIGN), l2 = ROUND_UP(len, RC4_ALIGN); + struct stream_cipher *sc = para_malloc(sizeof(*sc)); - assert(len); - tmp = para_malloc(l2); - RC4(&rc4c->send_key, l1, (const unsigned char *)buf, tmp); - if (len > l1) { - memcpy(remainder, buf + l1, len - l1); - RC4(&rc4c->send_key, len - l1, remainder, tmp + l1); - } - ret = write_all(rc4c->fd, (char *)tmp, &len); - free(tmp); - return ret; + assert(len >= 2 * AES_CRT128_BLOCK_SIZE); + sc->aes = EVP_CIPHER_CTX_new(); + EVP_EncryptInit_ex(sc->aes, EVP_aes_128_ctr(), NULL, data, + data + AES_CRT128_BLOCK_SIZE); + return sc; } -/** - * Encrypt and send a \p NULL-terminated buffer. - * - * \param rc4c The rc4 crypt context. - * \param buf The buffer to send. - * - * \return The return value of the underyling call to rc4_send_bin_buffer(). - */ -int rc4_send_buffer(struct rc4_context *rc4c, const char *buf) +void sc_free(struct stream_cipher *sc) { - return rc4_send_bin_buffer(rc4c, buf, strlen(buf)); + if (!sc) + return; + EVP_CIPHER_CTX_free(sc->aes); + free(sc); } -/** - * Format, encrypt and send a buffer. - * - * \param rc4c The rc4 crypt context. - * \param fmt A format string. - * - * \return The return value of the underyling call to rc4_send_buffer(). - */ -__printf_2_3 int rc4_send_va_buffer(struct rc4_context *rc4c, const char *fmt, ...) +static void aes_ctr128_crypt(EVP_CIPHER_CTX *ctx, struct iovec *src, + struct iovec *dst) { - char *msg; - int ret; + int ret, inlen = src->iov_len, outlen, tmplen; - PARA_VSPRINTF(fmt, msg); - ret = rc4_send_buffer(rc4c, msg); - free(msg); - return ret; + *dst = (typeof(*dst)) { + /* Add one for the terminating zero byte. */ + .iov_base = para_malloc(inlen + 1), + .iov_len = inlen + }; + ret = EVP_EncryptUpdate(ctx, dst->iov_base, &outlen, src->iov_base, inlen); + assert(ret != 0); + ret = EVP_EncryptFinal_ex(ctx, dst->iov_base + outlen, &tmplen); + assert(ret != 0); + outlen += tmplen; + ((char *)dst->iov_base)[outlen] = '\0'; + dst->iov_len = outlen; } -/** - * Receive a buffer and decrypt it. - * - * \param rc4c The rc4 crypt context. - * \param buf The buffer to write the decrypted data to. - * \param size The size of \a buf. - * - * \return The number of bytes received on success, negative on errors, zero if - * the peer has performed an orderly shutdown. - * - * \sa recv(2), RC4(3). - */ -int rc4_recv_bin_buffer(struct rc4_context *rc4c, char *buf, size_t size) +void sc_crypt(struct stream_cipher *sc, struct iovec *src, struct iovec *dst) { - unsigned char *tmp = para_malloc(size); - ssize_t ret = recv(rc4c->fd, tmp, size, 0); - - if (ret > 0) - RC4(&rc4c->recv_key, ret, tmp, (unsigned char *)buf); - else if (ret < 0) - ret = -ERRNO_TO_PARA_ERROR(errno); - free(tmp); - return ret; + return aes_ctr128_crypt(sc->aes, src, dst); } -/** - * Receive a buffer, decrypt it and write terminating NULL byte. - * - * \param rc4c The rc4 crypt context. - * \param buf The buffer to write the decrypted data to. - * \param size The size of \a buf. - * - * Read at most \a size - 1 bytes from file descriptor given by \a rc4c, - * decrypt the received data and write a NULL byte at the end of the decrypted - * data. - * - * \return The return value of the underlying call to \ref - * rc4_recv_bin_buffer(). - */ -int rc4_recv_buffer(struct rc4_context *rc4c, char *buf, size_t size) +void hash_function(const char *data, unsigned long len, unsigned char *hash) { - int n; - - assert(size); - n = rc4_recv_bin_buffer(rc4c, buf, size - 1); - if (n >= 0) - buf[n] = '\0'; - else - *buf = '\0'; - return n; + SHA_CTX c; + SHA1_Init(&c); + SHA1_Update(&c, data, len); + SHA1_Final(hash, &c); }