crypt: Move implementation-independent code to separate file.
[paraslash.git] / crypt.c
diff --git a/crypt.c b/crypt.c
index 6f7e611..7b602d9 100644 (file)
--- a/crypt.c
+++ b/crypt.c
@@ -7,6 +7,7 @@
 /** \file crypt.c Openssl-based encryption/decryption routines. */
 
 #include <regex.h>
+#include <stdbool.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <openssl/rand.h>
@@ -21,6 +22,7 @@
 #include "string.h"
 #include "crypt.h"
 #include "fd.h"
+#include "crypt_backend.h"
 
 struct asymmetric_key {
        RSA *rsa;
@@ -72,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;
@@ -122,203 +111,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 <ylo@cs.hut.fi>, 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 +148,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)
@@ -403,7 +184,7 @@ int get_asymmetric_key(const char *key_file, int private,
        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;
 
@@ -434,7 +215,11 @@ int get_asymmetric_key(const char *key_file, int private,
        ret = uudecode(cp, blob, blob_size);
        if (ret < 0)
                goto out;
-       ret = read_rsa_bignums(blob, ret, &key->rsa);
+       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);
@@ -600,39 +385,6 @@ int sc_send_bin_buffer(struct stream_cipher_context *scc, const char *buf,
        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.
  *
@@ -659,32 +411,6 @@ int sc_recv_bin_buffer(struct stream_cipher_context *scc, char *buf,
        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;
-}
-
 /**
  * Compute the hash of the given input data.
  *