1 /* $OpenBSD: authfile.c,v 1.149 2026/02/14 00:18:34 jsg 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
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdio.h>
34 #include <stdarg.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38
39 #include "log.h"
40 #include "authfile.h"
41 #include "sshkey.h"
42 #include "sshbuf.h"
43 #include "ssherr.h"
44 #include "krl.h"
45
46 /* Save a key blob to a file */
47 static int
sshkey_save_private_blob(struct sshbuf * keybuf,const char * filename)48 sshkey_save_private_blob(struct sshbuf *keybuf, const char *filename)
49 {
50 int r;
51 mode_t omask;
52
53 omask = umask(077);
54 r = sshbuf_write_file(filename, keybuf);
55 umask(omask);
56 return r;
57 }
58
59 int
sshkey_save_private(struct sshkey * key,const char * filename,const char * passphrase,const char * comment,int format,const char * openssh_format_cipher,int openssh_format_rounds)60 sshkey_save_private(struct sshkey *key, const char *filename,
61 const char *passphrase, const char *comment,
62 int format, const char *openssh_format_cipher, int openssh_format_rounds)
63 {
64 struct sshbuf *keyblob = NULL;
65 int r;
66
67 if ((keyblob = sshbuf_new()) == NULL)
68 return SSH_ERR_ALLOC_FAIL;
69 if ((r = sshkey_private_to_fileblob(key, keyblob, passphrase, comment,
70 format, openssh_format_cipher, openssh_format_rounds)) != 0)
71 goto out;
72 if ((r = sshkey_save_private_blob(keyblob, filename)) != 0)
73 goto out;
74 r = 0;
75 out:
76 sshbuf_free(keyblob);
77 return r;
78 }
79
80 /* XXX remove error() calls from here? */
81 int
sshkey_perm_ok(int fd,const char * filename)82 sshkey_perm_ok(int fd, const char *filename)
83 {
84 struct stat st;
85
86 if (fstat(fd, &st) == -1)
87 return SSH_ERR_SYSTEM_ERROR;
88 /*
89 * if a key owned by the user is accessed, then we check the
90 * permissions of the file. if the key owned by a different user,
91 * then we don't care.
92 */
93 #ifdef HAVE_CYGWIN
94 if (check_ntsec(filename))
95 #endif
96 if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) {
97 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
98 error("@ WARNING: UNPROTECTED PRIVATE KEY FILE! @");
99 error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
100 error("Permissions 0%3.3o for '%s' are too open.",
101 (u_int)st.st_mode & 0777, filename);
102 error("It is required that your private key files are NOT accessible by others.");
103 error("This private key will be ignored.");
104 return SSH_ERR_KEY_BAD_PERMISSIONS;
105 }
106 return 0;
107 }
108
109 int
sshkey_load_private_type(int type,const char * filename,const char * passphrase,struct sshkey ** keyp,char ** commentp)110 sshkey_load_private_type(int type, const char *filename, const char *passphrase,
111 struct sshkey **keyp, char **commentp)
112 {
113 int fd, r;
114
115 if (keyp != NULL)
116 *keyp = NULL;
117 if (commentp != NULL)
118 *commentp = NULL;
119
120 if ((fd = open(filename, O_RDONLY)) == -1)
121 return SSH_ERR_SYSTEM_ERROR;
122
123 r = sshkey_perm_ok(fd, filename);
124 if (r != 0)
125 goto out;
126
127 r = sshkey_load_private_type_fd(fd, type, passphrase, keyp, commentp);
128 out:
129 close(fd);
130 return r;
131 }
132
133 int
sshkey_load_private(const char * filename,const char * passphrase,struct sshkey ** keyp,char ** commentp)134 sshkey_load_private(const char *filename, const char *passphrase,
135 struct sshkey **keyp, char **commentp)
136 {
137 return sshkey_load_private_type(KEY_UNSPEC, filename, passphrase,
138 keyp, commentp);
139 }
140
141 int
sshkey_load_private_type_fd(int fd,int type,const char * passphrase,struct sshkey ** keyp,char ** commentp)142 sshkey_load_private_type_fd(int fd, int type, const char *passphrase,
143 struct sshkey **keyp, char **commentp)
144 {
145 struct sshbuf *buffer = NULL;
146 int r;
147
148 if (keyp != NULL)
149 *keyp = NULL;
150 if ((r = sshbuf_load_fd(fd, &buffer)) != 0 ||
151 (r = sshkey_parse_private_fileblob_type(buffer, type,
152 passphrase, keyp, commentp)) != 0)
153 goto out;
154
155 /* success */
156 r = 0;
157 out:
158 sshbuf_free(buffer);
159 return r;
160 }
161
162 /* Load a pubkey from the unencrypted envelope of a new-format private key */
163 static int
sshkey_load_pubkey_from_private(const char * filename,struct sshkey ** pubkeyp)164 sshkey_load_pubkey_from_private(const char *filename, struct sshkey **pubkeyp)
165 {
166 struct sshbuf *buffer = NULL;
167 struct sshkey *pubkey = NULL;
168 int r, fd;
169
170 if (pubkeyp != NULL)
171 *pubkeyp = NULL;
172
173 if ((fd = open(filename, O_RDONLY)) == -1)
174 return SSH_ERR_SYSTEM_ERROR;
175 if ((r = sshbuf_load_fd(fd, &buffer)) != 0 ||
176 (r = sshkey_parse_pubkey_from_private_fileblob_type(buffer,
177 KEY_UNSPEC, &pubkey)) != 0)
178 goto out;
179 /* success */
180 if (pubkeyp != NULL) {
181 *pubkeyp = pubkey;
182 pubkey = NULL;
183 }
184 r = 0;
185 out:
186 close(fd);
187 sshbuf_free(buffer);
188 sshkey_free(pubkey);
189 return r;
190 }
191
192 static int
sshkey_try_load_public(struct sshkey ** kp,const char * filename,char ** commentp)193 sshkey_try_load_public(struct sshkey **kp, const char *filename,
194 char **commentp)
195 {
196 FILE *f;
197 char *line = NULL, *cp;
198 size_t linesize = 0;
199 int r;
200 struct sshkey *k = NULL;
201
202 if (kp == NULL)
203 return SSH_ERR_INVALID_ARGUMENT;
204 *kp = NULL;
205 if (commentp != NULL)
206 *commentp = NULL;
207 if ((f = fopen(filename, "r")) == NULL)
208 return SSH_ERR_SYSTEM_ERROR;
209 if ((k = sshkey_new(KEY_UNSPEC)) == NULL) {
210 fclose(f);
211 return SSH_ERR_ALLOC_FAIL;
212 }
213 while (getline(&line, &linesize, f) != -1) {
214 cp = line;
215 switch (*cp) {
216 case '#':
217 case '\n':
218 case '\0':
219 continue;
220 }
221 /* Abort loading if this looks like a private key */
222 if (strncmp(cp, "-----BEGIN", 10) == 0 ||
223 strcmp(cp, "SSH PRIVATE KEY FILE") == 0)
224 break;
225 /* Skip leading whitespace. */
226 for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
227 ;
228 if (*cp) {
229 if ((r = sshkey_read(k, &cp)) == 0) {
230 cp[strcspn(cp, "\r\n")] = '\0';
231 if (commentp) {
232 *commentp = strdup(*cp ?
233 cp : filename);
234 if (*commentp == NULL)
235 r = SSH_ERR_ALLOC_FAIL;
236 }
237 /* success */
238 *kp = k;
239 free(line);
240 fclose(f);
241 return r;
242 }
243 }
244 }
245 free(k);
246 free(line);
247 fclose(f);
248 return SSH_ERR_INVALID_FORMAT;
249 }
250
251 /* load public key from any pubkey file */
252 int
sshkey_load_public(const char * filename,struct sshkey ** keyp,char ** commentp)253 sshkey_load_public(const char *filename, struct sshkey **keyp, char **commentp)
254 {
255 char *pubfile = NULL;
256 int r, oerrno;
257
258 if (keyp != NULL)
259 *keyp = NULL;
260 if (commentp != NULL)
261 *commentp = NULL;
262
263 if ((r = sshkey_try_load_public(keyp, filename, commentp)) == 0)
264 goto out;
265
266 /* try .pub suffix */
267 if (asprintf(&pubfile, "%s.pub", filename) == -1)
268 return SSH_ERR_ALLOC_FAIL;
269 if ((r = sshkey_try_load_public(keyp, pubfile, commentp)) == 0)
270 goto out;
271
272 /* finally, try to extract public key from private key file */
273 if ((r = sshkey_load_pubkey_from_private(filename, keyp)) == 0)
274 goto out;
275
276 /* Pretend we couldn't find the key */
277 r = SSH_ERR_SYSTEM_ERROR;
278 errno = ENOENT;
279
280 out:
281 oerrno = errno;
282 free(pubfile);
283 errno = oerrno;
284 return r;
285 }
286
287 /* Load the certificate associated with the named private key */
288 int
sshkey_load_cert(const char * filename,struct sshkey ** keyp)289 sshkey_load_cert(const char *filename, struct sshkey **keyp)
290 {
291 struct sshkey *pub = NULL;
292 char *file = NULL;
293 int r = SSH_ERR_INTERNAL_ERROR;
294
295 if (keyp != NULL)
296 *keyp = NULL;
297
298 if (asprintf(&file, "%s-cert.pub", filename) == -1)
299 return SSH_ERR_ALLOC_FAIL;
300
301 r = sshkey_try_load_public(keyp, file, NULL);
302 free(file);
303 sshkey_free(pub);
304 return r;
305 }
306
307 /* Load private key and certificate */
308 int
sshkey_load_private_cert(int type,const char * filename,const char * passphrase,struct sshkey ** keyp)309 sshkey_load_private_cert(int type, const char *filename, const char *passphrase,
310 struct sshkey **keyp)
311 {
312 struct sshkey *key = NULL, *cert = NULL;
313 int r;
314
315 if (keyp != NULL)
316 *keyp = NULL;
317
318 switch (type) {
319 #ifdef WITH_OPENSSL
320 case KEY_RSA:
321 case KEY_ECDSA:
322 #endif /* WITH_OPENSSL */
323 case KEY_ED25519:
324 case KEY_UNSPEC:
325 break;
326 default:
327 return SSH_ERR_KEY_TYPE_UNKNOWN;
328 }
329
330 if ((r = sshkey_load_private_type(type, filename,
331 passphrase, &key, NULL)) != 0 ||
332 (r = sshkey_load_cert(filename, &cert)) != 0)
333 goto out;
334
335 /* Make sure the private key matches the certificate */
336 if (sshkey_equal_public(key, cert) == 0) {
337 r = SSH_ERR_KEY_CERT_MISMATCH;
338 goto out;
339 }
340
341 if ((r = sshkey_to_certified(key)) != 0 ||
342 (r = sshkey_cert_copy(cert, key)) != 0)
343 goto out;
344 r = 0;
345 if (keyp != NULL) {
346 *keyp = key;
347 key = NULL;
348 }
349 out:
350 sshkey_free(key);
351 sshkey_free(cert);
352 return r;
353 }
354
355 /*
356 * Returns success if the specified "key" is listed in the file "filename",
357 * SSH_ERR_KEY_NOT_FOUND: if the key is not listed or another error.
358 * If "strict_type" is set then the key type must match exactly,
359 * otherwise a comparison that ignores certificate data is performed.
360 * If "check_ca" is set and "key" is a certificate, then its CA key is
361 * also checked and sshkey_in_file() will return success if either is found.
362 */
363 int
sshkey_in_file(struct sshkey * key,const char * filename,int strict_type,int check_ca)364 sshkey_in_file(struct sshkey *key, const char *filename, int strict_type,
365 int check_ca)
366 {
367 FILE *f;
368 char *line = NULL, *cp;
369 size_t linesize = 0;
370 int r = 0;
371 struct sshkey *pub = NULL;
372
373 int (*sshkey_compare)(const struct sshkey *, const struct sshkey *) =
374 strict_type ? sshkey_equal : sshkey_equal_public;
375
376 if ((f = fopen(filename, "r")) == NULL)
377 return SSH_ERR_SYSTEM_ERROR;
378
379 while (getline(&line, &linesize, f) != -1) {
380 sshkey_free(pub);
381 pub = NULL;
382 cp = line;
383
384 /* Skip leading whitespace. */
385 for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
386 ;
387
388 /* Skip comments and empty lines */
389 switch (*cp) {
390 case '#':
391 case '\n':
392 case '\0':
393 continue;
394 }
395
396 if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) {
397 r = SSH_ERR_ALLOC_FAIL;
398 goto out;
399 }
400 switch (r = sshkey_read(pub, &cp)) {
401 case 0:
402 break;
403 case SSH_ERR_KEY_LENGTH:
404 continue;
405 default:
406 goto out;
407 }
408 if (sshkey_compare(key, pub) ||
409 (check_ca && sshkey_is_cert(key) &&
410 sshkey_compare(key->cert->signature_key, pub))) {
411 r = 0;
412 goto out;
413 }
414 }
415 r = SSH_ERR_KEY_NOT_FOUND;
416 out:
417 free(line);
418 sshkey_free(pub);
419 fclose(f);
420 return r;
421 }
422
423 /*
424 * Checks whether the specified key is revoked, returning 0 if not,
425 * SSH_ERR_KEY_REVOKED if it is or another error code if something
426 * unexpected happened.
427 * This will check both the key and, if it is a certificate, its CA key too.
428 * "revoked_keys_file" may be a KRL or a one-per-line list of public keys.
429 */
430 int
sshkey_check_revoked(struct sshkey * key,const char * revoked_keys_file)431 sshkey_check_revoked(struct sshkey *key, const char *revoked_keys_file)
432 {
433 int r;
434
435 r = ssh_krl_file_contains_key(revoked_keys_file, key);
436 /* If this was not a KRL to begin with then continue below */
437 if (r != SSH_ERR_KRL_BAD_MAGIC)
438 return r;
439
440 /*
441 * If the file is not a KRL or we can't handle KRLs then attempt to
442 * parse the file as a flat list of keys.
443 */
444 switch ((r = sshkey_in_file(key, revoked_keys_file, 0, 1))) {
445 case 0:
446 /* Key found => revoked */
447 return SSH_ERR_KEY_REVOKED;
448 case SSH_ERR_KEY_NOT_FOUND:
449 /* Key not found => not revoked */
450 return 0;
451 default:
452 /* Some other error occurred */
453 return r;
454 }
455 }
456
457 /*
458 * Advanced *cpp past the end of key options, defined as the first unquoted
459 * whitespace character. Returns 0 on success or -1 on failure (e.g.
460 * unterminated quotes).
461 */
462 int
sshkey_advance_past_options(char ** cpp)463 sshkey_advance_past_options(char **cpp)
464 {
465 char *cp = *cpp;
466 int quoted = 0;
467
468 for (; *cp && (quoted || (*cp != ' ' && *cp != '\t')); cp++) {
469 if (*cp == '\\' && cp[1] == '"')
470 cp++; /* Skip both */
471 else if (*cp == '"')
472 quoted = !quoted;
473 }
474 *cpp = cp;
475 /* return failure for unterminated quotes */
476 return (*cp == '\0' && quoted) ? -1 : 0;
477 }
478
479 /* Save a public key */
480 int
sshkey_save_public(const struct sshkey * key,const char * path,const char * comment)481 sshkey_save_public(const struct sshkey *key, const char *path,
482 const char *comment)
483 {
484 int fd, oerrno;
485 FILE *f = NULL;
486 int r = SSH_ERR_INTERNAL_ERROR;
487
488 if ((fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
489 return SSH_ERR_SYSTEM_ERROR;
490 if ((f = fdopen(fd, "w")) == NULL) {
491 r = SSH_ERR_SYSTEM_ERROR;
492 close(fd);
493 goto fail;
494 }
495 if ((r = sshkey_write(key, f)) != 0)
496 goto fail;
497 fprintf(f, " %s\n", comment);
498 if (ferror(f)) {
499 r = SSH_ERR_SYSTEM_ERROR;
500 goto fail;
501 }
502 if (fclose(f) != 0) {
503 r = SSH_ERR_SYSTEM_ERROR;
504 f = NULL;
505 fail:
506 if (f != NULL) {
507 oerrno = errno;
508 fclose(f);
509 errno = oerrno;
510 }
511 return r;
512 }
513 return 0;
514 }
515