1 /* $OpenBSD: authfile.c,v 1.122 2016/11/25 23:24:45 djm Exp $ */
3 * Copyright (c) 2000, 2013 Markus Friedl. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
28 #include <sys/types.h>
53 #define MAX_KEY_FILE_SIZE (1024 * 1024)
55 /* Save a key blob to a file */
57 sshkey_save_private_blob(struct sshbuf *keybuf, const char *filename)
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)) {
69 return SSH_ERR_SYSTEM_ERROR;
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)
80 struct sshbuf *keyblob = NULL;
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)
88 if ((r = sshkey_save_private_blob(keyblob, filename)) != 0)
96 /* Load a key from a fd into a buffer */
98 sshkey_load_file(int fd, struct sshbuf *blob)
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;
111 * Pre-allocate the buffer used for the key contents and clamp its
112 * maximum size. This ensures that key contents are never leaked via
113 * implicit realloc() in the sshbuf code.
115 if ((st.st_mode & S_IFREG) == 0 || st.st_size <= 0) {
116 st.st_size = 64*1024; /* 64k should be enough for anyone :) */
119 if ((r = sshbuf_allocate(blob, st.st_size)) != 0 ||
120 (dontmax && (r = sshbuf_set_max_size(blob, st.st_size)) != 0))
123 if ((len = atomicio(read, fd, buf, sizeof(buf))) == 0) {
126 r = SSH_ERR_SYSTEM_ERROR;
129 if ((r = sshbuf_put(blob, buf, len)) != 0)
131 if (sshbuf_len(blob) > MAX_KEY_FILE_SIZE) {
132 r = SSH_ERR_INVALID_FORMAT;
136 if ((st.st_mode & (S_IFSOCK|S_IFCHR|S_IFIFO)) == 0 &&
137 st.st_size != (off_t)sshbuf_len(blob)) {
138 r = SSH_ERR_FILE_CHANGED;
144 explicit_bzero(buf, sizeof(buf));
152 * Loads the public part of the ssh v1 key file. Returns NULL if an error was
153 * encountered (the file does not exist or is not readable), and the key
157 sshkey_load_public_rsa1(int fd, struct sshkey **keyp, char **commentp)
159 struct sshbuf *b = NULL;
164 if (commentp != NULL)
167 if ((b = sshbuf_new()) == NULL)
168 return SSH_ERR_ALLOC_FAIL;
169 if ((r = sshkey_load_file(fd, b)) != 0)
171 if ((r = sshkey_parse_public_rsa1_fileblob(b, keyp, commentp)) != 0)
178 #endif /* WITH_SSH1 */
180 /* XXX remove error() calls from here? */
182 sshkey_perm_ok(int fd, const char *filename)
186 if (fstat(fd, &st) < 0)
187 return SSH_ERR_SYSTEM_ERROR;
189 * if a key owned by the user is accessed, then we check the
190 * permissions of the file. if the key owned by a different user,
191 * then we don't care.
194 if (check_ntsec(filename))
196 if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) {
197 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
198 error("@ WARNING: UNPROTECTED PRIVATE KEY FILE! @");
199 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
200 error("Permissions 0%3.3o for '%s' are too open.",
201 (u_int)st.st_mode & 0777, filename);
202 error("It is required that your private key files are NOT accessible by others.");
203 error("This private key will be ignored.");
204 return SSH_ERR_KEY_BAD_PERMISSIONS;
209 /* XXX kill perm_ok now that we have SSH_ERR_KEY_BAD_PERMISSIONS? */
211 sshkey_load_private_type(int type, const char *filename, const char *passphrase,
212 struct sshkey **keyp, char **commentp, int *perm_ok)
218 if (commentp != NULL)
221 if ((fd = open(filename, O_RDONLY)) < 0) {
224 return SSH_ERR_SYSTEM_ERROR;
226 if (sshkey_perm_ok(fd, filename) != 0) {
229 r = SSH_ERR_KEY_BAD_PERMISSIONS;
235 r = sshkey_load_private_type_fd(fd, type, passphrase, keyp, commentp);
242 sshkey_load_private_type_fd(int fd, int type, const char *passphrase,
243 struct sshkey **keyp, char **commentp)
245 struct sshbuf *buffer = NULL;
250 if ((buffer = sshbuf_new()) == NULL) {
251 r = SSH_ERR_ALLOC_FAIL;
254 if ((r = sshkey_load_file(fd, buffer)) != 0 ||
255 (r = sshkey_parse_private_fileblob_type(buffer, type,
256 passphrase, keyp, commentp)) != 0)
266 /* XXX this is almost identical to sshkey_load_private_type() */
268 sshkey_load_private(const char *filename, const char *passphrase,
269 struct sshkey **keyp, char **commentp)
271 struct sshbuf *buffer = NULL;
276 if (commentp != NULL)
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;
286 if ((buffer = sshbuf_new()) == NULL) {
287 r = SSH_ERR_ALLOC_FAIL;
290 if ((r = sshkey_load_file(fd, buffer)) != 0 ||
291 (r = sshkey_parse_private_fileblob(buffer, passphrase, keyp,
302 sshkey_try_load_public(struct sshkey *k, const char *filename, char **commentp)
305 char line[SSH_MAX_PUBKEY_BYTES];
310 if (commentp != NULL)
312 if ((f = fopen(filename, "r")) == NULL)
313 return SSH_ERR_SYSTEM_ERROR;
314 while (read_keyfile_line(f, filename, line, sizeof(line),
323 /* Abort loading if this looks like a private key */
324 if (strncmp(cp, "-----BEGIN", 10) == 0 ||
325 strcmp(cp, "SSH PRIVATE KEY FILE") == 0)
327 /* Skip leading whitespace. */
328 for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
331 if ((r = sshkey_read(k, &cp)) == 0) {
332 cp[strcspn(cp, "\r\n")] = '\0';
334 *commentp = strdup(*cp ?
336 if (*commentp == NULL)
337 r = SSH_ERR_ALLOC_FAIL;
345 return SSH_ERR_INVALID_FORMAT;
348 /* load public key from ssh v1 private or any pubkey file */
350 sshkey_load_public(const char *filename, struct sshkey **keyp, char **commentp)
352 struct sshkey *pub = NULL;
358 if (commentp != NULL)
361 /* XXX should load file once and attempt to parse each format */
363 if ((fd = open(filename, O_RDONLY)) < 0)
366 /* try rsa1 private key */
367 r = sshkey_load_public_rsa1(fd, keyp, commentp);
370 case SSH_ERR_INTERNAL_ERROR:
371 case SSH_ERR_ALLOC_FAIL:
372 case SSH_ERR_INVALID_ARGUMENT:
373 case SSH_ERR_SYSTEM_ERROR:
377 #else /* WITH_SSH1 */
379 #endif /* WITH_SSH1 */
381 /* try ssh2 public key */
382 if ((pub = sshkey_new(KEY_UNSPEC)) == NULL)
383 return SSH_ERR_ALLOC_FAIL;
384 if ((r = sshkey_try_load_public(pub, filename, commentp)) == 0) {
392 /* try rsa1 public key */
393 if ((pub = sshkey_new(KEY_RSA1)) == NULL)
394 return SSH_ERR_ALLOC_FAIL;
395 if ((r = sshkey_try_load_public(pub, filename, commentp)) == 0) {
401 #endif /* WITH_SSH1 */
404 /* try .pub suffix */
405 if ((pub = sshkey_new(KEY_UNSPEC)) == NULL)
406 return SSH_ERR_ALLOC_FAIL;
407 r = SSH_ERR_ALLOC_FAIL; /* in case strlcpy or strlcat fail */
408 if ((strlcpy(file, filename, sizeof file) < sizeof(file)) &&
409 (strlcat(file, ".pub", sizeof file) < sizeof(file)) &&
410 (r = sshkey_try_load_public(pub, file, commentp)) == 0) {
420 /* Load the certificate associated with the named private key */
422 sshkey_load_cert(const char *filename, struct sshkey **keyp)
424 struct sshkey *pub = NULL;
426 int r = SSH_ERR_INTERNAL_ERROR;
431 if (asprintf(&file, "%s-cert.pub", filename) == -1)
432 return SSH_ERR_ALLOC_FAIL;
434 if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) {
437 if ((r = sshkey_try_load_public(pub, file, NULL)) != 0)
451 /* Load private key and certificate */
453 sshkey_load_private_cert(int type, const char *filename, const char *passphrase,
454 struct sshkey **keyp, int *perm_ok)
456 struct sshkey *key = NULL, *cert = NULL;
467 #endif /* WITH_OPENSSL */
472 return SSH_ERR_KEY_TYPE_UNKNOWN;
475 if ((r = sshkey_load_private_type(type, filename,
476 passphrase, &key, NULL, perm_ok)) != 0 ||
477 (r = sshkey_load_cert(filename, &cert)) != 0)
480 /* Make sure the private key matches the certificate */
481 if (sshkey_equal_public(key, cert) == 0) {
482 r = SSH_ERR_KEY_CERT_MISMATCH;
486 if ((r = sshkey_to_certified(key)) != 0 ||
487 (r = sshkey_cert_copy(cert, key)) != 0)
501 * Returns success if the specified "key" is listed in the file "filename",
502 * SSH_ERR_KEY_NOT_FOUND: if the key is not listed or another error.
503 * If "strict_type" is set then the key type must match exactly,
504 * otherwise a comparison that ignores certficiate data is performed.
505 * If "check_ca" is set and "key" is a certificate, then its CA key is
506 * also checked and sshkey_in_file() will return success if either is found.
509 sshkey_in_file(struct sshkey *key, const char *filename, int strict_type,
513 char line[SSH_MAX_PUBKEY_BYTES];
517 struct sshkey *pub = NULL;
518 int (*sshkey_compare)(const struct sshkey *, const struct sshkey *) =
519 strict_type ? sshkey_equal : sshkey_equal_public;
521 if ((f = fopen(filename, "r")) == NULL)
522 return SSH_ERR_SYSTEM_ERROR;
524 while (read_keyfile_line(f, filename, line, sizeof(line),
528 /* Skip leading whitespace. */
529 for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
532 /* Skip comments and empty lines */
540 if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) {
541 r = SSH_ERR_ALLOC_FAIL;
544 if ((r = sshkey_read(pub, &cp)) != 0)
546 if (sshkey_compare(key, pub) ||
547 (check_ca && sshkey_is_cert(key) &&
548 sshkey_compare(key->cert->signature_key, pub))) {
555 r = SSH_ERR_KEY_NOT_FOUND;
563 * Checks whether the specified key is revoked, returning 0 if not,
564 * SSH_ERR_KEY_REVOKED if it is or another error code if something
565 * unexpected happened.
566 * This will check both the key and, if it is a certificate, its CA key too.
567 * "revoked_keys_file" may be a KRL or a one-per-line list of public keys.
570 sshkey_check_revoked(struct sshkey *key, const char *revoked_keys_file)
574 r = ssh_krl_file_contains_key(revoked_keys_file, key);
575 /* If this was not a KRL to begin with then continue below */
576 if (r != SSH_ERR_KRL_BAD_MAGIC)
580 * If the file is not a KRL or we can't handle KRLs then attempt to
581 * parse the file as a flat list of keys.
583 switch ((r = sshkey_in_file(key, revoked_keys_file, 0, 1))) {
585 /* Key found => revoked */
586 return SSH_ERR_KEY_REVOKED;
587 case SSH_ERR_KEY_NOT_FOUND:
588 /* Key not found => not revoked */
591 /* Some other error occurred */