X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=crypt.c;h=7b602d995d3deccaba5e2e6ab76f4dec5570c95b;hb=5957ec3c6deb0a5585f979ff470e9a346154ca62;hp=206b93486914aaf7896b0f6109bdd7aa57c235c9;hpb=037059c8a25ce134af1eaa6c3fa8ac96b9f7e0b6;p=paraslash.git diff --git a/crypt.c b/crypt.c index 206b9348..7b602d99 100644 --- a/crypt.c +++ b/crypt.c @@ -7,19 +7,22 @@ /** \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" struct asymmetric_key { RSA *rsa; @@ -71,19 +74,6 @@ void init_random_seed_or_die(void) srandom(seed); } -static int check_key_file(const char *file, int private) -{ - struct stat st; - - 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; -} - static EVP_PKEY *load_key(const char *file, int private) { BIO *key; @@ -107,6 +97,76 @@ static EVP_PKEY *load_key(const char *file, int private) return pkey; } +static int get_openssl_key(const char *key_file, RSA **rsa, int private) +{ + EVP_PKEY *key = load_key(key_file, private); + + if (!key) + return (private == LOAD_PRIVATE_KEY)? -E_PRIVATE_KEY + : -E_PUBLIC_KEY; + *rsa = EVP_PKEY_get1_RSA(key); + EVP_PKEY_free(key); + if (!*rsa) + return -E_RSA; + return RSA_size(*rsa); +} + +/* + * 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) +{ + const unsigned char *p = buf, *end = buf + len; + uint32_t bnsize; + BIGNUM *bn; + + if (p + 4 < p) + return -E_BIGNUM; + if (p + 4 > end) + return -E_BIGNUM; + bnsize = read_ssh_u32(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; +} + +static int read_rsa_bignums(const unsigned char *blob, int blen, RSA **result) +{ + int ret; + RSA *rsa; + const unsigned char *p = blob, *end = blob + blen; + + rsa = RSA_new(); + if (!rsa) + return -E_BIGNUM; + ret = read_bignum(p, end - p, &rsa->e); + if (ret < 0) + goto fail; + p += ret; + ret = read_bignum(p, end - p, &rsa->n); + if (ret < 0) + goto fail; + *result = rsa; + return 1; +fail: + if (rsa) + RSA_free(rsa); + return ret; +} + /** * Read an asymmetric key from a file. * @@ -121,21 +181,60 @@ static EVP_PKEY *load_key(const char *file, int private) int get_asymmetric_key(const char *key_file, int private, struct asymmetric_key **result) { - struct asymmetric_key *key; - RSA *rsa; - EVP_PKEY *pkey = load_key(key_file, private); + struct asymmetric_key *key = NULL; + void *map = NULL; + unsigned char *blob = NULL; + size_t map_size, blob_size, decoded_size; + int ret, ret2; + char *cp; - if (!pkey) - return (private == LOAD_PRIVATE_KEY)? -E_PRIVATE_KEY - : -E_PUBLIC_KEY; - rsa = EVP_PKEY_get1_RSA(pkey); - EVP_PKEY_free(pkey); - if (!rsa) - return -E_RSA; key = para_malloc(sizeof(*key)); - key->rsa = rsa; - *result = key; - return RSA_size(rsa); + if (private) { + ret = get_openssl_key(key_file, &key->rsa, LOAD_PRIVATE_KEY); + goto out; + } + 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 = para_munmap(map, map_size); + map = NULL; + if (ret < 0) + goto out; + ret = get_openssl_key(key_file, &key->rsa, LOAD_PUBLIC_KEY); + goto out; + } + cp = map + ret; + PARA_INFO_LOG("decoding public rsa-ssh key %s\n", key_file); + ret = -ERRNO_TO_PARA_ERROR(EOVERFLOW); + if (map_size > INT_MAX / 4) + goto out; + blob_size = 2 * map_size; + blob = para_malloc(blob_size); + ret = uudecode(cp, blob, blob_size); + if (ret < 0) + goto out; + decoded_size = ret; + ret = check_ssh_key_header(blob, decoded_size); + if (ret < 0) + goto out; + ret = read_rsa_bignums(blob + ret, decoded_size - ret, &key->rsa); + if (ret < 0) + goto out; + ret = RSA_size(key->rsa); +out: + ret2 = para_munmap(map, map_size); + if (ret >= 0 && ret2 < 0) + ret = ret2; + 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; } /** @@ -219,7 +318,6 @@ int pub_encrypt(struct asymmetric_key *pub, unsigned char *inbuf, return ret < 0? -E_ENCRYPT : ret; } -#define RC4_ALIGN 8 struct stream_cipher { RC4_KEY key; }; @@ -232,7 +330,7 @@ struct stream_cipher { * * \return A new stream cipher structure. */ -struct stream_cipher *stream_cipher_new(const unsigned char *data, int len) +struct stream_cipher *sc_new(const unsigned char *data, int len) { struct stream_cipher *sc = para_malloc(sizeof(*sc)); RC4_set_key(&sc->key, len, data); @@ -242,17 +340,24 @@ struct stream_cipher *stream_cipher_new(const unsigned char *data, int len) /** * Deallocate a stream cipher structure. * - * \param sc A stream cipher previously obtained by stream_cipher_new(). + * \param sc A stream cipher previously obtained by sc_new(). */ -void stream_cipher_free(struct stream_cipher *sc) +void sc_free(struct stream_cipher *sc) { free(sc); } +/** + * The RC4() implementation of openssl apparently reads and writes data in + * blocks of 8 bytes. So we have to make sure our buffer sizes are a multiple + * of this. + */ +#define RC4_ALIGN 8 + /** * Encrypt and send a buffer. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param buf The buffer to send. * \param len The size of \a buf in bytes. * @@ -260,7 +365,8 @@ void stream_cipher_free(struct stream_cipher *sc) * * \sa \ref write_all(), RC4(3). */ -int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len) +int sc_send_bin_buffer(struct stream_cipher_context *scc, const char *buf, + size_t len) { int ret; unsigned char *tmp; @@ -269,52 +375,20 @@ int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len) assert(len); tmp = para_malloc(l2); - RC4(&rc4c->send->key, l1, (const unsigned char *)buf, tmp); + RC4(&scc->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); + RC4(&scc->send->key, len - l1, remainder, tmp + l1); } - ret = write_all(rc4c->fd, (char *)tmp, &len); + ret = write_all(scc->fd, (char *)tmp, &len); free(tmp); return ret; } -/** - * 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) -{ - return rc4_send_bin_buffer(rc4c, buf, strlen(buf)); -} - -/** - * 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, ...) -{ - char *msg; - int ret; - - PARA_VSPRINTF(fmt, msg); - ret = rc4_send_buffer(rc4c, msg); - free(msg); - return ret; -} - /** * Receive a buffer and decrypt it. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param buf The buffer to write the decrypted data to. * \param size The size of \a buf. * @@ -323,13 +397,14 @@ __printf_2_3 int rc4_send_va_buffer(struct rc4_context *rc4c, const char *fmt, . * * \sa recv(2), RC4(3). */ -int rc4_recv_bin_buffer(struct rc4_context *rc4c, char *buf, size_t size) +int sc_recv_bin_buffer(struct stream_cipher_context *scc, char *buf, + size_t size) { unsigned char *tmp = para_malloc(size); - ssize_t ret = recv(rc4c->fd, tmp, size, 0); + ssize_t ret = recv(scc->fd, tmp, size, 0); if (ret > 0) - RC4(&rc4c->recv->key, ret, tmp, (unsigned char *)buf); + RC4(&scc->recv->key, ret, tmp, (unsigned char *)buf); else if (ret < 0) ret = -ERRNO_TO_PARA_ERROR(errno); free(tmp); @@ -337,28 +412,20 @@ int rc4_recv_bin_buffer(struct rc4_context *rc4c, char *buf, size_t size) } /** - * Receive a buffer, decrypt it and write terminating NULL byte. + * Compute the hash of the given input data. * - * \param rc4c The rc4 crypt context. - * \param buf The buffer to write the decrypted data to. - * \param size The size of \a buf. + * \param data Pointer to the data to compute the hash value from. + * \param len The length of \a data in bytes. + * \param hash Result pointer. * - * 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. + * \a hash must point to an area at least \p HASH_SIZE bytes large. * - * \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) + * \sa sha(3), openssl(1). + * */ +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); }