Merge branch 'vendor/OPENSSH'
[dragonfly.git] / crypto / openssh / authfile.c
1 /* $OpenBSD: authfile.c,v 1.107 2014/06/24 01:13:21 djm Exp $ */
2 /*
3  * Copyright (c) 2000, 2013 Markus Friedl.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "includes.h"
27
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/param.h>
31 #include <sys/uio.h>
32
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <stdio.h>
36 #include <stdarg.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40
41 #include "cipher.h"
42 #include "key.h"
43 #include "ssh.h"
44 #include "log.h"
45 #include "authfile.h"
46 #include "rsa.h"
47 #include "misc.h"
48 #include "atomicio.h"
49 #include "sshbuf.h"
50 #include "ssherr.h"
51 #include "pathnames.h"
52
53 #define MAX_KEY_FILE_SIZE       (1024 * 1024)
54
55 /* Save a key blob to a file */
56 static int
57 sshkey_save_private_blob(struct sshbuf *keybuf, const char *filename)
58 {
59         int fd, oerrno;
60
61         if ((fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600)) < 0)
62                 return SSH_ERR_SYSTEM_ERROR;
63         if (atomicio(vwrite, fd, (u_char *)sshbuf_ptr(keybuf),
64             sshbuf_len(keybuf)) != sshbuf_len(keybuf)) {
65                 oerrno = errno;
66                 close(fd);
67                 unlink(filename);
68                 errno = oerrno;
69                 return SSH_ERR_SYSTEM_ERROR;
70         }
71         close(fd);
72         return 0;
73 }
74
75 int
76 sshkey_save_private(struct sshkey *key, const char *filename,
77     const char *passphrase, const char *comment,
78     int force_new_format, const char *new_format_cipher, int new_format_rounds)
79 {
80         struct sshbuf *keyblob = NULL;
81         int r;
82
83         if ((keyblob = sshbuf_new()) == NULL)
84                 return SSH_ERR_ALLOC_FAIL;
85         if ((r = sshkey_private_to_fileblob(key, keyblob, passphrase, comment,
86             force_new_format, new_format_cipher, new_format_rounds)) != 0)
87                 goto out;
88         if ((r = sshkey_save_private_blob(keyblob, filename)) != 0)
89                 goto out;
90         r = 0;
91  out:
92         sshbuf_free(keyblob);
93         return r;
94 }
95
96 /* Load a key from a fd into a buffer */
97 int
98 sshkey_load_file(int fd, const char *filename, struct sshbuf *blob)
99 {
100         u_char buf[1024];
101         size_t len;
102         struct stat st;
103         int r;
104
105         if (fstat(fd, &st) < 0)
106                 return SSH_ERR_SYSTEM_ERROR;
107         if ((st.st_mode & (S_IFSOCK|S_IFCHR|S_IFIFO)) == 0 &&
108             st.st_size > MAX_KEY_FILE_SIZE)
109                 return SSH_ERR_INVALID_FORMAT;
110         for (;;) {
111                 if ((len = atomicio(read, fd, buf, sizeof(buf))) == 0) {
112                         if (errno == EPIPE)
113                                 break;
114                         r = SSH_ERR_SYSTEM_ERROR;
115                         goto out;
116                 }
117                 if ((r = sshbuf_put(blob, buf, len)) != 0)
118                         goto out;
119                 if (sshbuf_len(blob) > MAX_KEY_FILE_SIZE) {
120                         r = SSH_ERR_INVALID_FORMAT;
121                         goto out;
122                 }
123         }
124         if ((st.st_mode & (S_IFSOCK|S_IFCHR|S_IFIFO)) == 0 &&
125             st.st_size != (off_t)sshbuf_len(blob)) {
126                 r = SSH_ERR_FILE_CHANGED;
127                 goto out;
128         }
129         r = 0;
130
131  out:
132         explicit_bzero(buf, sizeof(buf));
133         if (r != 0)
134                 sshbuf_reset(blob);
135         return r;
136 }
137
138 #ifdef WITH_SSH1
139 /*
140  * Loads the public part of the ssh v1 key file.  Returns NULL if an error was
141  * encountered (the file does not exist or is not readable), and the key
142  * otherwise.
143  */
144 static int
145 sshkey_load_public_rsa1(int fd, const char *filename,
146     struct sshkey **keyp, char **commentp)
147 {
148         struct sshbuf *b = NULL;
149         int r;
150
151         *keyp = NULL;
152         if (commentp != NULL)
153                 *commentp = NULL;
154
155         if ((b = sshbuf_new()) == NULL)
156                 return SSH_ERR_ALLOC_FAIL;
157         if ((r = sshkey_load_file(fd, filename, b)) != 0)
158                 goto out;
159         if ((r = sshkey_parse_public_rsa1_fileblob(b, keyp, commentp)) != 0)
160                 goto out;
161         r = 0;
162  out:
163         sshbuf_free(b);
164         return r;
165 }
166 #endif /* WITH_SSH1 */
167
168 #ifdef WITH_OPENSSL
169 /* XXX Deprecate? */
170 int
171 sshkey_load_private_pem(int fd, int type, const char *passphrase,
172     struct sshkey **keyp, char **commentp)
173 {
174         struct sshbuf *buffer = NULL;
175         int r;
176
177         *keyp = NULL;
178         if (commentp != NULL)
179                 *commentp = NULL;
180
181         if ((buffer = sshbuf_new()) == NULL)
182                 return SSH_ERR_ALLOC_FAIL;
183         if ((r = sshkey_load_file(fd, NULL, buffer)) != 0)
184                 goto out;
185         if ((r = sshkey_parse_private_pem_fileblob(buffer, type, passphrase,
186             keyp, commentp)) != 0)
187                 goto out;
188         r = 0;
189  out:
190         sshbuf_free(buffer);
191         return r;
192 }
193 #endif /* WITH_OPENSSL */
194
195 /* XXX remove error() calls from here? */
196 int
197 sshkey_perm_ok(int fd, const char *filename)
198 {
199         struct stat st;
200
201         if (fstat(fd, &st) < 0)
202                 return SSH_ERR_SYSTEM_ERROR;
203         /*
204          * if a key owned by the user is accessed, then we check the
205          * permissions of the file. if the key owned by a different user,
206          * then we don't care.
207          */
208 #ifdef HAVE_CYGWIN
209         if (check_ntsec(filename))
210 #endif
211         if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) {
212                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
213                 error("@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @");
214                 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
215                 error("Permissions 0%3.3o for '%s' are too open.",
216                     (u_int)st.st_mode & 0777, filename);
217                 error("It is recommended that your private key files are NOT accessible by others.");
218                 error("This private key will be ignored.");
219                 return SSH_ERR_KEY_BAD_PERMISSIONS;
220         }
221         return 0;
222 }
223
224 /* XXX kill perm_ok now that we have SSH_ERR_KEY_BAD_PERMISSIONS? */
225 int
226 sshkey_load_private_type(int type, const char *filename, const char *passphrase,
227     struct sshkey **keyp, char **commentp, int *perm_ok)
228 {
229         int fd, r;
230         struct sshbuf *buffer = NULL;
231
232         *keyp = NULL;
233         if (commentp != NULL)
234                 *commentp = NULL;
235
236         if ((fd = open(filename, O_RDONLY)) < 0) {
237                 if (perm_ok != NULL)
238                         *perm_ok = 0;
239                 return SSH_ERR_SYSTEM_ERROR;
240         }
241         if (sshkey_perm_ok(fd, filename) != 0) {
242                 if (perm_ok != NULL)
243                         *perm_ok = 0;
244                 r = SSH_ERR_KEY_BAD_PERMISSIONS;
245                 goto out;
246         }
247         if (perm_ok != NULL)
248                 *perm_ok = 1;
249
250         if ((buffer = sshbuf_new()) == NULL) {
251                 r = SSH_ERR_ALLOC_FAIL;
252                 goto out;
253         }
254         if ((r = sshkey_load_file(fd, filename, buffer)) != 0)
255                 goto out;
256         if ((r = sshkey_parse_private_fileblob_type(buffer, type, passphrase,
257             keyp, commentp)) != 0)
258                 goto out;
259         r = 0;
260  out:
261         close(fd);
262         if (buffer != NULL)
263                 sshbuf_free(buffer);
264         return r;
265 }
266
267 /* XXX this is almost identical to sshkey_load_private_type() */
268 int
269 sshkey_load_private(const char *filename, const char *passphrase,
270     struct sshkey **keyp, char **commentp)
271 {
272         struct sshbuf *buffer = NULL;
273         int r, fd;
274
275         *keyp = NULL;
276         if (commentp != NULL)
277                 *commentp = NULL;
278
279         if ((fd = open(filename, O_RDONLY)) < 0)
280                 return SSH_ERR_SYSTEM_ERROR;
281         if (sshkey_perm_ok(fd, filename) != 0) {
282                 r = SSH_ERR_KEY_BAD_PERMISSIONS;
283                 goto out;
284         }
285
286         if ((buffer = sshbuf_new()) == NULL) {
287                 r = SSH_ERR_ALLOC_FAIL;
288                 goto out;
289         }
290         if ((r = sshkey_load_file(fd, filename, buffer)) != 0 ||
291             (r = sshkey_parse_private_fileblob(buffer, passphrase, filename,
292             keyp, commentp)) != 0)
293                 goto out;
294         r = 0;
295  out:
296         close(fd);
297         if (buffer != NULL)
298                 sshbuf_free(buffer);
299         return r;
300 }
301
302 static int
303 sshkey_try_load_public(struct sshkey *k, const char *filename, char **commentp)
304 {
305         FILE *f;
306         char line[SSH_MAX_PUBKEY_BYTES];
307         char *cp;
308         u_long linenum = 0;
309         int r;
310
311         if (commentp != NULL)
312                 *commentp = NULL;
313         if ((f = fopen(filename, "r")) == NULL)
314                 return SSH_ERR_SYSTEM_ERROR;
315         while (read_keyfile_line(f, filename, line, sizeof(line),
316                     &linenum) != -1) {
317                 cp = line;
318                 switch (*cp) {
319                 case '#':
320                 case '\n':
321                 case '\0':
322                         continue;
323                 }
324                 /* Abort loading if this looks like a private key */
325                 if (strncmp(cp, "-----BEGIN", 10) == 0 ||
326                     strcmp(cp, "SSH PRIVATE KEY FILE") == 0)
327                         break;
328                 /* Skip leading whitespace. */
329                 for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
330                         ;
331                 if (*cp) {
332                         if ((r = sshkey_read(k, &cp)) == 0) {
333                                 cp[strcspn(cp, "\r\n")] = '\0';
334                                 if (commentp) {
335                                         *commentp = strdup(*cp ?
336                                             cp : filename);
337                                         if (*commentp == NULL)
338                                                 r = SSH_ERR_ALLOC_FAIL;
339                                 }
340                                 fclose(f);
341                                 return r;
342                         }
343                 }
344         }
345         fclose(f);
346         return SSH_ERR_INVALID_FORMAT;
347 }
348
349 /* load public key from ssh v1 private or any pubkey file */
350 int
351 sshkey_load_public(const char *filename, struct sshkey **keyp, char **commentp)
352 {
353         struct sshkey *pub = NULL;
354         char file[MAXPATHLEN];
355         int r, fd;
356
357         if (keyp != NULL)
358                 *keyp = NULL;
359         if (commentp != NULL)
360                 *commentp = NULL;
361
362         if ((fd = open(filename, O_RDONLY)) < 0)
363                 goto skip;
364 #ifdef WITH_SSH1
365         /* try rsa1 private key */
366         r = sshkey_load_public_rsa1(fd, filename, keyp, commentp);
367         close(fd);
368         switch (r) {
369         case SSH_ERR_INTERNAL_ERROR:
370         case SSH_ERR_ALLOC_FAIL:
371         case SSH_ERR_INVALID_ARGUMENT:
372         case SSH_ERR_SYSTEM_ERROR:
373         case 0:
374                 return r;
375         }
376 #endif /* WITH_SSH1 */
377
378         /* try ssh2 public key */
379         if ((pub = sshkey_new(KEY_UNSPEC)) == NULL)
380                 return SSH_ERR_ALLOC_FAIL;
381         if ((r = sshkey_try_load_public(pub, filename, commentp)) == 0) {
382                 if (keyp != NULL)
383                         *keyp = pub;
384                 return 0;
385         }
386         sshkey_free(pub);
387
388 #ifdef WITH_SSH1
389         /* try rsa1 public key */
390         if ((pub = sshkey_new(KEY_RSA1)) == NULL)
391                 return SSH_ERR_ALLOC_FAIL;
392         if ((r = sshkey_try_load_public(pub, filename, commentp)) == 0) {
393                 if (keyp != NULL)
394                         *keyp = pub;
395                 return 0;
396         }
397         sshkey_free(pub);
398 #endif /* WITH_SSH1 */
399
400  skip:
401         /* try .pub suffix */
402         if ((pub = sshkey_new(KEY_UNSPEC)) == NULL)
403                 return SSH_ERR_ALLOC_FAIL;
404         r = SSH_ERR_ALLOC_FAIL; /* in case strlcpy or strlcat fail */
405         if ((strlcpy(file, filename, sizeof file) < sizeof(file)) &&
406             (strlcat(file, ".pub", sizeof file) < sizeof(file)) &&
407             (r = sshkey_try_load_public(pub, file, commentp)) == 0) {
408                 if (keyp != NULL)
409                         *keyp = pub;
410                 return 0;
411         }
412         sshkey_free(pub);
413         return r;
414 }
415
416 char *
417 blacklist_filename(const Key *key)
418 {
419         char *name;
420
421         xasprintf(&name, "%s.%s-%u",
422             _PATH_BLACKLIST, key_type(key), key_size(key));
423         return name;
424 }
425
426 /* Scan a blacklist of known-vulnerable keys. */
427 int
428 blacklisted_key(Key *key)
429 {
430         char *blacklist_file;
431         int fd = -1;
432         char *dgst_hex = NULL;
433         char *dgst_packed = NULL, *p;
434         int i;
435         size_t line_len;
436         struct stat st;
437         char buf[256];
438         off_t start, lower, upper;
439         int ret = 0;
440
441         blacklist_file = blacklist_filename(key);
442         debug("Checking blacklist file %s", blacklist_file);
443         fd = open(blacklist_file, O_RDONLY);
444         if (fd < 0)
445                 goto out;
446
447         dgst_hex = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
448         /* Remove all colons */
449         dgst_packed = xcalloc(1, strlen(dgst_hex) + 1);
450         for (i = 0, p = dgst_packed; dgst_hex[i]; i++)
451                 if (dgst_hex[i] != ':')
452                         *p++ = dgst_hex[i];
453         /* Only compare least-significant 80 bits (to keep the blacklist
454          * size down)
455          */
456         line_len = strlen(dgst_packed + 12);
457         if (line_len > 32)
458                 goto out;
459
460         /* Skip leading comments */
461         start = 0;
462         for (;;) {
463                 ssize_t r;
464                 char *newline;
465
466                 r = atomicio(read, fd, buf, 256);
467                 if (r <= 0)
468                         goto out;
469                 if (buf[0] != '#')
470                         break;
471
472                 newline = memchr(buf, '\n', 256);
473                 if (!newline)
474                         goto out;
475                 start += newline + 1 - buf;
476                 if (lseek(fd, start, SEEK_SET) < 0)
477                         goto out;
478         }
479
480         /* Initialise binary search record numbers */
481         if (fstat(fd, &st) < 0)
482                 goto out;
483         lower = 0;
484         upper = (st.st_size - start) / (line_len + 1);
485
486         while (lower != upper) {
487                 off_t cur;
488                 char buf[32];
489                 int cmp;
490
491                 cur = lower + (upper - lower) / 2;
492
493                 /* Read this line and compare to digest; this is
494                  * overflow-safe since cur < max(off_t) / (line_len + 1) */
495                 if (lseek(fd, start + cur * (line_len + 1), SEEK_SET) < 0)
496                         break;
497                 if (atomicio(read, fd, buf, line_len) != line_len)
498                         break;
499                 cmp = memcmp(buf, dgst_packed + 12, line_len);
500                 if (cmp < 0) {
501                         if (cur == lower)
502                                 break;
503                         lower = cur;
504                 } else if (cmp > 0) {
505                         if (cur == upper)
506                                 break;
507                         upper = cur;
508                 } else {
509                         debug("Found %s in blacklist", dgst_hex);
510                         ret = 1;
511                         break;
512                 }
513         }
514
515 out:
516         if (dgst_packed)
517                 xfree(dgst_packed);
518         if (dgst_hex)
519                 xfree(dgst_hex);
520         if (fd >= 0)
521                 close(fd);
522         xfree(blacklist_file);
523         return ret;
524 }
525
526 /* Load the certificate associated with the named private key */
527 int
528 sshkey_load_cert(const char *filename, struct sshkey **keyp)
529 {
530         struct sshkey *pub = NULL;
531         char *file = NULL;
532         int r = SSH_ERR_INTERNAL_ERROR;
533
534         *keyp = NULL;
535
536         if (asprintf(&file, "%s-cert.pub", filename) == -1)
537                 return SSH_ERR_ALLOC_FAIL;
538
539         if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) {
540                 goto out;
541         }
542         if ((r = sshkey_try_load_public(pub, file, NULL)) != 0)
543                 goto out;
544
545         *keyp = pub;
546         pub = NULL;
547         r = 0;
548
549  out:
550         if (file != NULL)
551                 free(file);
552         if (pub != NULL)
553                 sshkey_free(pub);
554         return r;
555 }
556
557 /* Load private key and certificate */
558 int
559 sshkey_load_private_cert(int type, const char *filename, const char *passphrase,
560     struct sshkey **keyp, int *perm_ok)
561 {
562         struct sshkey *key = NULL, *cert = NULL;
563         int r;
564
565         *keyp = NULL;
566
567         switch (type) {
568 #ifdef WITH_OPENSSL
569         case KEY_RSA:
570         case KEY_DSA:
571         case KEY_ECDSA:
572         case KEY_ED25519:
573 #endif /* WITH_OPENSSL */
574         case KEY_UNSPEC:
575                 break;
576         default:
577                 return SSH_ERR_KEY_TYPE_UNKNOWN;
578         }
579
580         if ((r = sshkey_load_private_type(type, filename,
581             passphrase, &key, NULL, perm_ok)) != 0 ||
582             (r = sshkey_load_cert(filename, &cert)) != 0)
583                 goto out;
584
585         /* Make sure the private key matches the certificate */
586         if (sshkey_equal_public(key, cert) == 0) {
587                 r = SSH_ERR_KEY_CERT_MISMATCH;
588                 goto out;
589         }
590
591         if ((r = sshkey_to_certified(key, sshkey_cert_is_legacy(cert))) != 0 ||
592             (r = sshkey_cert_copy(cert, key)) != 0)
593                 goto out;
594         r = 0;
595         *keyp = key;
596         key = NULL;
597  out:
598         if (key != NULL)
599                 sshkey_free(key);
600         if (cert != NULL)
601                 sshkey_free(cert);
602         return r;
603 }
604
605 /*
606  * Returns success if the specified "key" is listed in the file "filename",
607  * SSH_ERR_KEY_NOT_FOUND: if the key is not listed or another error.
608  * If strict_type is set then the key type must match exactly,
609  * otherwise a comparison that ignores certficiate data is performed.
610  */
611 int
612 sshkey_in_file(struct sshkey *key, const char *filename, int strict_type)
613 {
614         FILE *f;
615         char line[SSH_MAX_PUBKEY_BYTES];
616         char *cp;
617         u_long linenum = 0;
618         int r = 0;
619         struct sshkey *pub = NULL;
620         int (*sshkey_compare)(const struct sshkey *, const struct sshkey *) =
621             strict_type ?  sshkey_equal : sshkey_equal_public;
622
623         if ((f = fopen(filename, "r")) == NULL) {
624                 if (errno == ENOENT)
625                         return SSH_ERR_KEY_NOT_FOUND;
626                 else
627                         return SSH_ERR_SYSTEM_ERROR;
628         }
629
630         while (read_keyfile_line(f, filename, line, sizeof(line),
631             &linenum) != -1) {
632                 cp = line;
633
634                 /* Skip leading whitespace. */
635                 for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
636                         ;
637
638                 /* Skip comments and empty lines */
639                 switch (*cp) {
640                 case '#':
641                 case '\n':
642                 case '\0':
643                         continue;
644                 }
645
646                 if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) {
647                         r = SSH_ERR_ALLOC_FAIL;
648                         goto out;
649                 }
650                 if ((r = sshkey_read(pub, &cp)) != 0)
651                         goto out;
652                 if (sshkey_compare(key, pub)) {
653                         r = 0;
654                         goto out;
655                 }
656                 sshkey_free(pub);
657                 pub = NULL;
658         }
659         r = SSH_ERR_KEY_NOT_FOUND;
660  out:
661         if (pub != NULL)
662                 sshkey_free(pub);
663         fclose(f);
664         return r;
665 }
666