X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=crypt.c;h=5445138d53f6589ebce6645b027531f02b74c860;hp=6f7e611d0364035560819f7659bbb71d62d4f1b1;hb=d87806284b9f6be9aab71ccbf0280d273b57eeb3;hpb=c41a04fb296e068ebfec78bba9678bf15daea896 diff --git a/crypt.c b/crypt.c index 6f7e611d..5445138d 100644 --- a/crypt.c +++ b/crypt.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2011 Andre Noll + * Copyright (C) 2005-2013 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -21,22 +21,12 @@ #include "string.h" #include "crypt.h" #include "fd.h" +#include "crypt_backend.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; @@ -49,13 +39,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 adds them to the SSL PRNG. Seed the PRNG + * used by random() with a random seed obtained from SSL. If /dev/random 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(). @@ -72,19 +59,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; @@ -122,203 +96,12 @@ static int get_openssl_key(const char *key_file, RSA **rsa, int private) return RSA_size(*rsa); } -#define KEY_TYPE_TXT "ssh-rsa" - -/* check if it is an ssh rsa key */ -static size_t is_ssh_rsa_key(char *data, size_t size) -{ - char *cp; - - if (size < strlen(KEY_TYPE_TXT) + 2) - return 0; - cp = memchr(data, ' ', size); - if (cp == NULL) - return 0; - if (strncmp(KEY_TYPE_TXT, data, strlen(KEY_TYPE_TXT))) - return 0; - cp++; - if (cp >= data + size) - return 0; - if (*cp == '\0') - return 0; - return cp - data; -} - -/* - * This base64/uudecode stuff below is taken from openssh-5.2p1, Copyright (c) - * 1996 by Internet Software Consortium. Portions Copyright (c) 1995 by - * International Business Machines, Inc. - */ - -static const char Base64[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -static const char Pad64 = '='; -/* - * Skips all whitespace anywhere. Converts characters, four at a time, starting - * at (or after) src from base - 64 numbers into three 8 bit bytes in the - * target area. it returns the number of data bytes stored at the target, or -1 - * on error. - */ -static int base64_decode(char const *src, unsigned char *target, size_t targsize) -{ - unsigned int tarindex, state; - int ch; - char *pos; - - state = 0; - tarindex = 0; - - while ((ch = *src++) != '\0') { - if (para_isspace(ch)) /* Skip whitespace anywhere. */ - continue; - - if (ch == Pad64) - break; - - pos = strchr(Base64, ch); - if (pos == 0) /* A non-base64 character. */ - return -1; - - switch (state) { - case 0: - if (target) { - if (tarindex >= targsize) - return (-1); - target[tarindex] = (pos - Base64) << 2; - } - state = 1; - break; - case 1: - if (target) { - if (tarindex + 1 >= targsize) - return (-1); - target[tarindex] |= (pos - Base64) >> 4; - target[tarindex+1] = ((pos - Base64) & 0x0f) - << 4 ; - } - tarindex++; - state = 2; - break; - case 2: - if (target) { - if (tarindex + 1 >= targsize) - return (-1); - target[tarindex] |= (pos - Base64) >> 2; - target[tarindex+1] = ((pos - Base64) & 0x03) - << 6; - } - tarindex++; - state = 3; - break; - case 3: - if (target) { - if (tarindex >= targsize) - return (-1); - target[tarindex] |= (pos - Base64); - } - tarindex++; - state = 0; - break; - } - } - - /* - * We are done decoding Base-64 chars. Let's see if we ended - * on a byte boundary, and/or with erroneous trailing characters. - */ - - if (ch == Pad64) { /* We got a pad char. */ - ch = *src++; /* Skip it, get next. */ - switch (state) { - case 0: /* Invalid = in first position */ - case 1: /* Invalid = in second position */ - return (-1); - - case 2: /* Valid, means one byte of info */ - /* Skip any number of spaces. */ - for (; ch != '\0'; ch = *src++) - if (!isspace(ch)) - break; - /* Make sure there is another trailing = sign. */ - if (ch != Pad64) - return (-1); - ch = *src++; /* Skip the = */ - /* Fall through to "single trailing =" case. */ - /* FALLTHROUGH */ - - case 3: /* Valid, means two bytes of info */ - /* - * We know this char is an =. Is there anything but - * whitespace after it? - */ - for (; ch != '\0'; ch = *src++) - if (!isspace(ch)) - return (-1); - - /* - * Now make sure for cases 2 and 3 that the "extra" - * bits that slopped past the last full byte were - * zeros. If we don't check them, they become a - * subliminal channel. - */ - if (target && target[tarindex] != 0) - return (-1); - } - } else { - /* - * We ended by seeing the end of the string. Make sure we - * have no partial bytes lying around. - */ - if (state != 0) - return (-1); - } - - return (tarindex); -} - -static int uudecode(const char *src, unsigned char *target, size_t targsize) -{ - int len; - char *encoded, *p; - - /* copy the 'readonly' source */ - encoded = para_strdup(src); - /* skip whitespace and data */ - for (p = encoded; *p == ' ' || *p == '\t'; p++) - ; - for (; *p != '\0' && *p != ' ' && *p != '\t'; p++) - ; - /* and remove trailing whitespace because base64_decode needs this */ - *p = '\0'; - len = base64_decode(encoded, target, targsize); - free(encoded); - return len >= 0? len : -E_BASE64; -} - /* * 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. */ - -/* - * Can not use the inline functions of portable_io.h here because the byte - * order is different. - */ -static uint32_t read_ssh_u32(const void *vp) -{ - const unsigned char *p = (const unsigned char *)vp; - uint32_t v; - - v = (uint32_t)p[0] << 24; - v |= (uint32_t)p[1] << 16; - v |= (uint32_t)p[2] << 8; - v |= (uint32_t)p[3]; - - return v; -} - static int read_bignum(const unsigned char *buf, size_t len, BIGNUM **result) { const unsigned char *p = buf, *end = buf + len; @@ -350,23 +133,6 @@ 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; - uint32_t rlen; - - *result = NULL; - if (p + 4 > end) - return -E_BIGNUM; - rlen = read_ssh_u32(p); - p += 4; - if (p + rlen < p) - return -E_BIGNUM; - if (p + rlen > end) - return -E_BIGNUM; - if (rlen < strlen(KEY_TYPE_TXT)) - return -E_BIGNUM; - PARA_DEBUG_LOG("type: %s, rlen: %d\n", p, rlen); - if (strncmp((char *)p, KEY_TYPE_TXT, strlen(KEY_TYPE_TXT))) - return -E_BIGNUM; - p += rlen; rsa = RSA_new(); if (!rsa) @@ -381,29 +147,17 @@ static int read_rsa_bignums(const unsigned char *blob, int blen, RSA **result) *result = rsa; return 1; fail: - if (rsa) - RSA_free(rsa); + RSA_free(rsa); return ret; } -/** - * 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) { struct asymmetric_key *key = NULL; void *map = NULL; unsigned char *blob = NULL; - size_t map_size, blob_size; + size_t map_size, blob_size, decoded_size; int ret, ret2; char *cp; @@ -428,23 +182,28 @@ int get_asymmetric_key(const char *key_file, int private, 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; + goto out_unmap; blob_size = 2 * map_size; blob = para_malloc(blob_size); ret = uudecode(cp, blob, blob_size); if (ret < 0) - goto out; - ret = read_rsa_bignums(blob, ret, &key->rsa); + goto out_unmap; + decoded_size = ret; + ret = check_ssh_key_header(blob, decoded_size); if (ret < 0) - goto out; + 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: +out_unmap: ret2 = para_munmap(map, map_size); if (ret >= 0 && ret2 < 0) ret = ret2; +out: if (ret < 0) { free(key); - result = NULL; + *result = NULL; PARA_ERROR_LOG("key %s: %s\n", key_file, para_strerror(-ret)); } else *result = key; @@ -452,13 +211,6 @@ out: 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) { if (!key) @@ -467,20 +219,6 @@ 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) { @@ -509,18 +247,6 @@ out: 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) { @@ -537,14 +263,6 @@ struct stream_cipher { RC4_KEY key; }; -/** - * Allocate and initialize a stream cipher structure. - * - * \param data The key. - * \param len The size of the key. - * - * \return A new stream cipher structure. - */ struct stream_cipher *sc_new(const unsigned char *data, int len) { struct stream_cipher *sc = para_malloc(sizeof(*sc)); @@ -552,11 +270,6 @@ struct stream_cipher *sc_new(const unsigned char *data, int len) return sc; } -/** - * Deallocate a stream cipher structure. - * - * \param sc A stream cipher previously obtained by sc_new(). - */ void sc_free(struct stream_cipher *sc) { free(sc); @@ -569,133 +282,30 @@ void sc_free(struct stream_cipher *sc) */ #define RC4_ALIGN 8 -/** - * Encrypt and send a buffer. - * - * \param scc The 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 sc_send_bin_buffer(struct stream_cipher_context *scc, const char *buf, - size_t len) +void sc_crypt(struct stream_cipher *sc, struct iovec *src, struct iovec *dst) { - 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); - - assert(len); - tmp = para_malloc(l2); - RC4(&scc->send->key, l1, (const unsigned char *)buf, tmp); + size_t len = src->iov_len, l1, l2; + RC4_KEY *key = &sc->key; + + assert(len > 0); + assert(len < ((typeof(src->iov_len))-1) / 2); + l1 = ROUND_DOWN(len, RC4_ALIGN); + l2 = ROUND_UP(len, RC4_ALIGN); + + *dst = (typeof(*dst)) { + /* Add one for the terminating zero byte. */ + .iov_base = para_malloc(l2 + 1), + .iov_len = len + }; + RC4(key, l1, src->iov_base, dst->iov_base); if (len > l1) { - memcpy(remainder, buf + l1, len - l1); - RC4(&scc->send->key, len - l1, remainder, tmp + l1); + unsigned char remainder[RC4_ALIGN] = ""; + memcpy(remainder, src->iov_base + l1, len - l1); + RC4(key, len - l1, remainder, dst->iov_base + l1); } - ret = write_all(scc->fd, (char *)tmp, &len); - free(tmp); - return ret; -} - -/** - * Encrypt and send a \p NULL-terminated buffer. - * - * \param scc The context. - * \param buf The buffer to send. - * - * \return The return value of the underyling call to sc_send_bin_buffer(). - */ -int sc_send_buffer(struct stream_cipher_context *scc, const char *buf) -{ - return sc_send_bin_buffer(scc, buf, strlen(buf)); -} - -/** - * Format, encrypt and send a buffer. - * - * \param scc The context. - * \param fmt A format string. - * - * \return The return value of the underyling call to sc_send_buffer(). - */ -__printf_2_3 int sc_send_va_buffer(struct stream_cipher_context *scc, - const char *fmt, ...) -{ - char *msg; - int ret; - - PARA_VSPRINTF(fmt, msg); - ret = sc_send_buffer(scc, msg); - free(msg); - return ret; -} - -/** - * Receive a buffer and decrypt it. - * - * \param scc The 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 sc_recv_bin_buffer(struct stream_cipher_context *scc, char *buf, - size_t size) -{ - unsigned char *tmp = para_malloc(size); - ssize_t ret = recv(scc->fd, tmp, size, 0); - - if (ret > 0) - RC4(&scc->recv->key, ret, tmp, (unsigned char *)buf); - else if (ret < 0) - ret = -ERRNO_TO_PARA_ERROR(errno); - free(tmp); - return ret; -} - -/** - * Receive a buffer, decrypt it and write terminating NULL byte. - * - * \param scc The 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 scc, 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 - * sc_recv_bin_buffer(). - */ -int sc_recv_buffer(struct stream_cipher_context *scc, char *buf, size_t size) -{ - int n; - - assert(size); - n = sc_recv_bin_buffer(scc, buf, size - 1); - if (n >= 0) - buf[n] = '\0'; - else - *buf = '\0'; - return n; + ((char *)dst->iov_base)[len] = '\0'; } -/** - * Compute the hash of the given input data. - * - * \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. - * - * \a hash must point to an area at least \p HASH_SIZE bytes large. - * - * \sa sha(3), openssl(1). - * */ void hash_function(const char *data, unsigned long len, unsigned char *hash) { SHA_CTX c;