* New upstream release (http://www.openssh.org/txt/release-5.9).

  - Introduce sandboxing of the pre-auth privsep child using an optional
    sshd_config(5) "UsePrivilegeSeparation=sandbox" mode that enables
    mandatory restrictions on the syscalls the privsep child can perform.
  - Add new SHA256-based HMAC transport integrity modes from
    http://www.ietf.org/id/draft-dbider-sha2-mac-for-ssh-02.txt.
  - The pre-authentication sshd(8) privilege separation slave process now
    logs via a socket shared with the master process, avoiding the need to
    maintain /dev/log inside the chroot (closes: #75043, #429243,
    #599240).
  - ssh(1) now warns when a server refuses X11 forwarding (closes:
    #504757).
  - sshd_config(5)'s AuthorizedKeysFile now accepts multiple paths,
    separated by whitespace (closes: #76312).  The authorized_keys2
    fallback is deprecated but documented (closes: #560156).
  - ssh(1) and sshd(8): set IPv6 traffic class from IPQoS, as well as IPv4
    ToS/DSCP (closes: #498297).
  - ssh-add(1) now accepts keys piped from standard input.  E.g. "ssh-add
    - < /path/to/key" (closes: #229124).
  - Clean up lost-passphrase text in ssh-keygen(1) (closes: #444691).
  - Say "required" rather than "recommended" in unprotected-private-key
    warning (LP: #663455).

1 files changed, 97 insertions, 62 deletions

diff --git a/authfile.c b/authfile.c
index 2ed250232..e5fe0b801 100644
--- a/authfile.c
+++ b/authfile.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: authfile.c,v 1.87 2010/11/29 18:57:04 markus Exp $ */
+/* $OpenBSD: authfile.c,v 1.92 2011/06/14 22:49:18 markus Exp $ */
 /*
  * Author: Tatu Ylonen <ylo@cs.hut.fi>
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
@@ -70,6 +70,8 @@
 #include "atomicio.h"
 #include "pathnames.h"
 
+#define MAX_KEY_FILE_SIZE       (1024 * 1024)
+
 /* Version identification string for SSH v1 identity files. */
 static const char authfile_id_string[] =
     "SSH PRIVATE KEY FILE FORMAT 1.1\n";
@@ -278,6 +280,7 @@ static Key *
 key_parse_public_rsa1(Buffer *blob, char **commentp)
 {
         Key *pub;
+        Buffer copy;
 
         /* Check that it is at least big enough to contain the ID string. */
         if (buffer_len(blob) < sizeof(authfile_id_string)) {
@@ -294,31 +297,33 @@ key_parse_public_rsa1(Buffer *blob, char **commentp)
                 debug3("Incorrect RSA1 identifier");
                 return NULL;
         }
-        buffer_consume(blob, sizeof(authfile_id_string));
+        buffer_init(&copy);
+        buffer_append(&copy, buffer_ptr(blob), buffer_len(blob));
+        buffer_consume(&copy, sizeof(authfile_id_string));
 
         /* Skip cipher type and reserved data. */
-        (void) buffer_get_char(blob);   /* cipher type */
-        (void) buffer_get_int(blob);            /* reserved */
+        (void) buffer_get_char(&copy);          /* cipher type */
+        (void) buffer_get_int(&copy);           /* reserved */
 
         /* Read the public key from the buffer. */
-        (void) buffer_get_int(blob);
+        (void) buffer_get_int(&copy);
         pub = key_new(KEY_RSA1);
-        buffer_get_bignum(blob, pub->rsa->n);
-        buffer_get_bignum(blob, pub->rsa->e);
+        buffer_get_bignum(&copy, pub->rsa->n);
+        buffer_get_bignum(&copy, pub->rsa->e);
         if (commentp)
-                *commentp = buffer_get_string(blob, NULL);
+                *commentp = buffer_get_string(&copy, NULL);
         /* The encrypted private part is not parsed by this function. */
-        buffer_clear(blob);
+        buffer_free(&copy);
 
         return pub;
 }
 
-/* Load the contents of a key file into a buffer */
-static int
+/* Load a key from a fd into a buffer */
+int
 key_load_file(int fd, const char *filename, Buffer *blob)
 {
-        size_t len, readcount;
-        u_char *cp;
+        u_char buf[1024];
+        size_t len;
         struct stat st;
 
         if (fstat(fd, &st) < 0) {
@@ -326,33 +331,45 @@ key_load_file(int fd, const char *filename, Buffer *blob)
                     filename == NULL ? "" : filename,
                     filename == NULL ? "" : " ",
                     strerror(errno));
-                close(fd);
                 return 0;
         }
-        if (st.st_size > 1*1024*1024) {
+        if ((st.st_mode & (S_IFSOCK|S_IFCHR|S_IFIFO)) == 0 &&
+            st.st_size > MAX_KEY_FILE_SIZE) {
+ toobig:
                 error("%s: key file %.200s%stoo large", __func__,
                     filename == NULL ? "" : filename,
                     filename == NULL ? "" : " ");
-                close(fd);
                 return 0;
         }
-        len = (size_t)st.st_size;               /* truncated */
-        if (0 == len && S_ISFIFO(st.st_mode))
-                len = 8192; /* we will try reading up to 8KiB from a FIFO */
-
         buffer_init(blob);
-        cp = buffer_append_space(blob, len);
-
-        readcount = atomicio(read, fd, cp, len);
-        if (readcount != len && !(readcount > 0 && S_ISFIFO(st.st_mode))) {
-                debug("%s: read from key file %.200s%sfailed: %.100s", __func__,
-                    filename == NULL ? "" : filename,
-                    filename == NULL ? "" : " ",
-                    strerror(errno));
+        for (;;) {
+                if ((len = atomicio(read, fd, buf, sizeof(buf))) == 0) {
+                        if (errno == EPIPE)
+                                break;
+                        debug("%s: read from key file %.200s%sfailed: %.100s",
+                            __func__, filename == NULL ? "" : filename,
+                            filename == NULL ? "" : " ", strerror(errno));
+                        buffer_clear(blob);
+                        bzero(buf, sizeof(buf));
+                        return 0;
+                }
+                buffer_append(blob, buf, len);
+                if (buffer_len(blob) > MAX_KEY_FILE_SIZE) {
+                        buffer_clear(blob);
+                        bzero(buf, sizeof(buf));
+                        goto toobig;
+                }
+        }
+        bzero(buf, sizeof(buf));
+        if ((st.st_mode & (S_IFSOCK|S_IFCHR|S_IFIFO)) == 0 &&
+            st.st_size != buffer_len(blob)) {
+                debug("%s: key file %.200s%schanged size while reading",
+                    __func__, filename == NULL ? "" : filename,
+                    filename == NULL ? "" : " ");
                 buffer_clear(blob);
-                close(fd);
                 return 0;
         }
+
         return 1;
 }
 
@@ -407,6 +424,7 @@ key_parse_private_rsa1(Buffer *blob, const char *passphrase, char **commentp)
         CipherContext ciphercontext;
         Cipher *cipher;
         Key *prv = NULL;
+        Buffer copy;
 
         /* Check that it is at least big enough to contain the ID string. */
         if (buffer_len(blob) < sizeof(authfile_id_string)) {
@@ -423,41 +441,44 @@ key_parse_private_rsa1(Buffer *blob, const char *passphrase, char **commentp)
                 debug3("Incorrect RSA1 identifier");
                 return NULL;
         }
-        buffer_consume(blob, sizeof(authfile_id_string));
+        buffer_init(&copy);
+        buffer_append(&copy, buffer_ptr(blob), buffer_len(blob));
+        buffer_consume(&copy, sizeof(authfile_id_string));
 
         /* Read cipher type. */
-        cipher_type = buffer_get_char(blob);
-        (void) buffer_get_int(blob);    /* Reserved data. */
+        cipher_type = buffer_get_char(&copy);
+        (void) buffer_get_int(&copy);   /* Reserved data. */
 
         /* Read the public key from the buffer. */
-        (void) buffer_get_int(blob);
+        (void) buffer_get_int(&copy);
         prv = key_new_private(KEY_RSA1);
 
-        buffer_get_bignum(blob, prv->rsa->n);
-        buffer_get_bignum(blob, prv->rsa->e);
+        buffer_get_bignum(&copy, prv->rsa->n);
+        buffer_get_bignum(&copy, prv->rsa->e);
         if (commentp)
-                *commentp = buffer_get_string(blob, NULL);
+                *commentp = buffer_get_string(&copy, NULL);
         else
-                (void)buffer_get_string_ptr(blob, NULL);
+                (void)buffer_get_string_ptr(&copy, NULL);
 
         /* Check that it is a supported cipher. */
         cipher = cipher_by_number(cipher_type);
         if (cipher == NULL) {
                 debug("Unsupported RSA1 cipher %d", cipher_type);
+                buffer_free(&copy);
                 goto fail;
         }
         /* Initialize space for decrypted data. */
         buffer_init(&decrypted);
-        cp = buffer_append_space(&decrypted, buffer_len(blob));
+        cp = buffer_append_space(&decrypted, buffer_len(&copy));
 
         /* Rest of the buffer is encrypted.  Decrypt it using the passphrase. */
         cipher_set_key_string(&ciphercontext, cipher, passphrase,
             CIPHER_DECRYPT);
         cipher_crypt(&ciphercontext, cp,
-            buffer_ptr(blob), buffer_len(blob));
+            buffer_ptr(&copy), buffer_len(&copy));
         cipher_cleanup(&ciphercontext);
         memset(&ciphercontext, 0, sizeof(ciphercontext));
-        buffer_clear(blob);
+        buffer_free(&copy);
 
         check1 = buffer_get_char(&decrypted);
         check2 = buffer_get_char(&decrypted);
@@ -610,7 +631,7 @@ key_perm_ok(int fd, const char *filename)
                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
                 error("Permissions 0%3.3o for '%s' are too open.",
                     (u_int)st.st_mode & 0777, filename);
-                error("It is recommended that your private key files are NOT accessible by others.");
+                error("It is required that your private key files are NOT accessible by others.");
                 error("This private key will be ignored.");
                 return 0;
         }
@@ -630,6 +651,7 @@ key_parse_private_type(Buffer *blob, int type, const char *passphrase,
         case KEY_UNSPEC:
                 return key_parse_private_pem(blob, type, passphrase, commentp);
         default:
+                error("%s: cannot parse key type %d", __func__, type);
                 break;
         }
         return NULL;
@@ -674,11 +696,34 @@ key_load_private_type(int type, const char *filename, const char *passphrase,
 }
 
 Key *
+key_parse_private(Buffer *buffer, const char *filename,
+    const char *passphrase, char **commentp)
+{
+        Key *pub, *prv;
+
+        /* it's a SSH v1 key if the public key part is readable */
+        pub = key_parse_public_rsa1(buffer, commentp);
+        if (pub == NULL) {
+                prv = key_parse_private_type(buffer, KEY_UNSPEC,
+                    passphrase, NULL);
+                /* use the filename as a comment for PEM */
+                if (commentp && prv)
+                        *commentp = xstrdup(filename);
+        } else {
+                key_free(pub);
+                /* key_parse_public_rsa1() has already loaded the comment */
+                prv = key_parse_private_type(buffer, KEY_RSA1, passphrase,
+                    NULL);
+        }
+        return prv;
+}
+
+Key *
 key_load_private(const char *filename, const char *passphrase,
     char **commentp)
 {
-        Key *pub, *prv;
-        Buffer buffer, pubcopy;
+        Key *prv;
+        Buffer buffer;
         int fd;
 
         fd = open(filename, O_RDONLY);
@@ -701,23 +746,7 @@ key_load_private(const char *filename, const char *passphrase,
         }
         close(fd);
 
-        buffer_init(&pubcopy);
-        buffer_append(&pubcopy, buffer_ptr(&buffer), buffer_len(&buffer));
-        /* it's a SSH v1 key if the public key part is readable */
-        pub = key_parse_public_rsa1(&pubcopy, commentp);
-        buffer_free(&pubcopy);
-        if (pub == NULL) {
-                prv = key_parse_private_type(&buffer, KEY_UNSPEC,
-                    passphrase, NULL);
-                /* use the filename as a comment for PEM */
-                if (commentp && prv)
-                        *commentp = xstrdup(filename);
-        } else {
-                key_free(pub);
-                /* key_parse_public_rsa1() has already loaded the comment */
-                prv = key_parse_private_type(&buffer, KEY_RSA1, passphrase,
-                    NULL);
-        }
+        prv = key_parse_private(&buffer, filename, passphrase, commentp);
         buffer_free(&buffer);
         return prv;
 }
@@ -741,13 +770,19 @@ key_try_load_public(Key *k, const char *filename, char **commentp)
                         case '\0':
                                 continue;
                         }
+                        /* Abort loading if this looks like a private key */
+                        if (strncmp(cp, "-----BEGIN", 10) == 0)
+                                break;
                         /* Skip leading whitespace. */
                         for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
                                 ;
                         if (*cp) {
                                 if (key_read(k, &cp) == 1) {
-                                        if (commentp)
-                                                *commentp=xstrdup(filename);
+                                        cp[strcspn(cp, "\r\n")] = '\0';
+                                        if (commentp) {
+                                                *commentp = xstrdup(*cp ?
+                                                    cp : filename);
+                                        }
                                         fclose(f);
                                         return 1;
                                 }