1 files changed, 138 insertions, 0 deletions

diff --git a/authfile.c b/authfile.c
index 2bd887845..deac28f6a 100644
--- a/authfile.c
+++ b/authfile.c
@@ -68,6 +68,7 @@
 #include "rsa.h"
 #include "misc.h"
 #include "atomicio.h"
+#include "pathnames.h"
 
 /* Version identification string for SSH v1 identity files. */
 static const char authfile_id_string[] =
@@ -814,3 +815,140 @@ key_in_file(Key *key, const char *filename, int strict_type)
         return ret;
 }
 
+/* Scan a blacklist of known-vulnerable keys in blacklist_file. */
+static int
+blacklisted_key_in_file(const Key *key, const char *blacklist_file, char **fp)
+{
+        int fd = -1;
+        char *dgst_hex = NULL;
+        char *dgst_packed = NULL, *p;
+        int i;
+        size_t line_len;
+        struct stat st;
+        char buf[256];
+        off_t start, lower, upper;
+        int ret = 0;
+
+        debug("Checking blacklist file %s", blacklist_file);
+        fd = open(blacklist_file, O_RDONLY);
+        if (fd < 0) {
+                ret = -1;
+                goto out;
+        }
+
+        dgst_hex = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
+        /* Remove all colons */
+        dgst_packed = xcalloc(1, strlen(dgst_hex) + 1);
+        for (i = 0, p = dgst_packed; dgst_hex[i]; i++)
+                if (dgst_hex[i] != ':')
+                        *p++ = dgst_hex[i];
+        /* Only compare least-significant 80 bits (to keep the blacklist
+         * size down)
+         */
+        line_len = strlen(dgst_packed + 12);
+        if (line_len > 32)
+                goto out;
+
+        /* Skip leading comments */
+        start = 0;
+        for (;;) {
+                ssize_t r;
+                char *newline;
+
+                r = atomicio(read, fd, buf, sizeof(buf));
+                if (r <= 0)
+                        goto out;
+                if (buf[0] != '#')
+                        break;
+
+                newline = memchr(buf, '\n', sizeof(buf));
+                if (!newline)
+                        goto out;
+                start += newline + 1 - buf;
+                if (lseek(fd, start, SEEK_SET) < 0)
+                        goto out;
+        }
+
+        /* Initialise binary search record numbers */
+        if (fstat(fd, &st) < 0)
+                goto out;
+        lower = 0;
+        upper = (st.st_size - start) / (line_len + 1);
+
+        while (lower != upper) {
+                off_t cur;
+                int cmp;
+
+                cur = lower + (upper - lower) / 2;
+
+                /* Read this line and compare to digest; this is
+                 * overflow-safe since cur < max(off_t) / (line_len + 1) */
+                if (lseek(fd, start + cur * (line_len + 1), SEEK_SET) < 0)
+                        break;
+                if (atomicio(read, fd, buf, line_len) != line_len)
+                        break;
+                cmp = memcmp(buf, dgst_packed + 12, line_len);
+                if (cmp < 0) {
+                        if (cur == lower)
+                                break;
+                        lower = cur;
+                } else if (cmp > 0) {
+                        if (cur == upper)
+                                break;
+                        upper = cur;
+                } else {
+                        debug("Found %s in blacklist", dgst_hex);
+                        ret = 1;
+                        break;
+                }
+        }
+
+out:
+        if (dgst_packed)
+                xfree(dgst_packed);
+        if (ret != 1 && dgst_hex) {
+                xfree(dgst_hex);
+                dgst_hex = NULL;
+        }
+        if (fp)
+                *fp = dgst_hex;
+        if (fd >= 0)
+                close(fd);
+        return ret;
+}
+
+/*
+ * Scan blacklists of known-vulnerable keys. If a vulnerable key is found,
+ * its fingerprint is returned in *fp, unless fp is NULL.
+ */
+int
+blacklisted_key(const Key *key, char **fp)
+{
+        Key *public;
+        char *blacklist_file;
+        int ret, ret2;
+
+        public = key_demote(key);
+        if (public->type == KEY_RSA1)
+                public->type = KEY_RSA;
+
+        xasprintf(&blacklist_file, "%s.%s-%u",
+            _PATH_BLACKLIST, key_type(public), key_size(public));
+        ret = blacklisted_key_in_file(public, blacklist_file, fp);
+        xfree(blacklist_file);
+        if (ret > 0) {
+                key_free(public);
+                return ret;
+        }
+
+        xasprintf(&blacklist_file, "%s.%s-%u",
+            _PATH_BLACKLIST_CONFIG, key_type(public), key_size(public));
+        ret2 = blacklisted_key_in_file(public, blacklist_file, fp);
+        xfree(blacklist_file);
+        if (ret2 > ret)
+                ret = ret2;
+
+        key_free(public);
+        return ret;
+}
+