1 /* $OpenBSD: auth2-pubkeyfile.c,v 1.3 2022/07/01 03:52:57 djm Exp $ */
2 /*
3  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
4  * Copyright (c) 2010 Damien Miller.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include "includes.h"
28 
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 
32 #include <stdlib.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <pwd.h>
36 #include <stdio.h>
37 #include <stdarg.h>
38 #include <string.h>
39 #include <time.h>
40 #include <unistd.h>
41 
42 #include "ssh.h"
43 #include "log.h"
44 #include "misc.h"
45 #include "compat.h"
46 #include "sshkey.h"
47 #include "digest.h"
48 #include "hostfile.h"
49 #include "auth.h"
50 #include "auth-options.h"
51 #include "authfile.h"
52 #include "match.h"
53 #include "ssherr.h"
54 
55 int
56 auth_authorise_keyopts(struct passwd *pw, struct sshauthopt *opts,
57     int allow_cert_authority, const char *remote_ip, const char *remote_host,
58     const char *loc)
59 {
60 	time_t now = time(NULL);
61 	char buf[64];
62 
63 	/*
64 	 * Check keys/principals file expiry time.
65 	 * NB. validity interval in certificate is handled elsewhere.
66 	 */
67 	if (opts->valid_before && now > 0 &&
68 	    opts->valid_before < (uint64_t)now) {
69 		format_absolute_time(opts->valid_before, buf, sizeof(buf));
70 		debug("%s: entry expired at %s", loc, buf);
71 		auth_debug_add("%s: entry expired at %s", loc, buf);
72 		return -1;
73 	}
74 	/* Consistency checks */
75 	if (opts->cert_principals != NULL && !opts->cert_authority) {
76 		debug("%s: principals on non-CA key", loc);
77 		auth_debug_add("%s: principals on non-CA key", loc);
78 		/* deny access */
79 		return -1;
80 	}
81 	/* cert-authority flag isn't valid in authorized_principals files */
82 	if (!allow_cert_authority && opts->cert_authority) {
83 		debug("%s: cert-authority flag invalid here", loc);
84 		auth_debug_add("%s: cert-authority flag invalid here", loc);
85 		/* deny access */
86 		return -1;
87 	}
88 
89 	/* Perform from= checks */
90 	if (opts->required_from_host_keys != NULL) {
91 		switch (match_host_and_ip(remote_host, remote_ip,
92 		    opts->required_from_host_keys )) {
93 		case 1:
94 			/* Host name matches. */
95 			break;
96 		case -1:
97 		default:
98 			debug("%s: invalid from criteria", loc);
99 			auth_debug_add("%s: invalid from criteria", loc);
100 			/* FALLTHROUGH */
101 		case 0:
102 			logit("%s: Authentication tried for %.100s with "
103 			    "correct key but not from a permitted "
104 			    "host (host=%.200s, ip=%.200s, required=%.200s).",
105 			    loc, pw->pw_name, remote_host, remote_ip,
106 			    opts->required_from_host_keys);
107 			auth_debug_add("%s: Your host '%.200s' is not "
108 			    "permitted to use this key for login.",
109 			    loc, remote_host);
110 			/* deny access */
111 			return -1;
112 		}
113 	}
114 	/* Check source-address restriction from certificate */
115 	if (opts->required_from_host_cert != NULL) {
116 		switch (addr_match_cidr_list(remote_ip,
117 		    opts->required_from_host_cert)) {
118 		case 1:
119 			/* accepted */
120 			break;
121 		case -1:
122 		default:
123 			/* invalid */
124 			error("%s: Certificate source-address invalid", loc);
125 			/* FALLTHROUGH */
126 		case 0:
127 			logit("%s: Authentication tried for %.100s with valid "
128 			    "certificate but not from a permitted source "
129 			    "address (%.200s).", loc, pw->pw_name, remote_ip);
130 			auth_debug_add("%s: Your address '%.200s' is not "
131 			    "permitted to use this certificate for login.",
132 			    loc, remote_ip);
133 			return -1;
134 		}
135 	}
136 	/*
137 	 *
138 	 * XXX this is spammy. We should report remotely only for keys
139 	 *     that are successful in actual auth attempts, and not PK_OK
140 	 *     tests.
141 	 */
142 	auth_log_authopts(loc, opts, 1);
143 
144 	return 0;
145 }
146 
147 static int
148 match_principals_option(const char *principal_list, struct sshkey_cert *cert)
149 {
150 	char *result;
151 	u_int i;
152 
153 	/* XXX percent_expand() sequences for authorized_principals? */
154 
155 	for (i = 0; i < cert->nprincipals; i++) {
156 		if ((result = match_list(cert->principals[i],
157 		    principal_list, NULL)) != NULL) {
158 			debug3("matched principal from key options \"%.100s\"",
159 			    result);
160 			free(result);
161 			return 1;
162 		}
163 	}
164 	return 0;
165 }
166 
167 /*
168  * Process a single authorized_principals format line. Returns 0 and sets
169  * authoptsp is principal is authorised, -1 otherwise. "loc" is used as a
170  * log preamble for file/line information.
171  */
172 int
173 auth_check_principals_line(char *cp, const struct sshkey_cert *cert,
174     const char *loc, struct sshauthopt **authoptsp)
175 {
176 	u_int i, found = 0;
177 	char *ep, *line_opts;
178 	const char *reason = NULL;
179 	struct sshauthopt *opts = NULL;
180 
181 	if (authoptsp != NULL)
182 		*authoptsp = NULL;
183 
184 	/* Trim trailing whitespace. */
185 	ep = cp + strlen(cp) - 1;
186 	while (ep > cp && (*ep == '\n' || *ep == ' ' || *ep == '\t'))
187 		*ep-- = '\0';
188 
189 	/*
190 	 * If the line has internal whitespace then assume it has
191 	 * key options.
192 	 */
193 	line_opts = NULL;
194 	if ((ep = strrchr(cp, ' ')) != NULL ||
195 	    (ep = strrchr(cp, '\t')) != NULL) {
196 		for (; *ep == ' ' || *ep == '\t'; ep++)
197 			;
198 		line_opts = cp;
199 		cp = ep;
200 	}
201 	if ((opts = sshauthopt_parse(line_opts, &reason)) == NULL) {
202 		debug("%s: bad principals options: %s", loc, reason);
203 		auth_debug_add("%s: bad principals options: %s", loc, reason);
204 		return -1;
205 	}
206 	/* Check principals in cert against those on line */
207 	for (i = 0; i < cert->nprincipals; i++) {
208 		if (strcmp(cp, cert->principals[i]) != 0)
209 			continue;
210 		debug3("%s: matched principal \"%.100s\"",
211 		    loc, cert->principals[i]);
212 		found = 1;
213 	}
214 	if (found && authoptsp != NULL) {
215 		*authoptsp = opts;
216 		opts = NULL;
217 	}
218 	sshauthopt_free(opts);
219 	return found ? 0 : -1;
220 }
221 
222 int
223 auth_process_principals(FILE *f, const char *file,
224     const struct sshkey_cert *cert, struct sshauthopt **authoptsp)
225 {
226 	char loc[256], *line = NULL, *cp, *ep;
227 	size_t linesize = 0;
228 	u_long linenum = 0, nonblank = 0;
229 	u_int found_principal = 0;
230 
231 	if (authoptsp != NULL)
232 		*authoptsp = NULL;
233 
234 	while (getline(&line, &linesize, f) != -1) {
235 		linenum++;
236 		/* Always consume entire input */
237 		if (found_principal)
238 			continue;
239 
240 		/* Skip leading whitespace. */
241 		for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
242 			;
243 		/* Skip blank and comment lines. */
244 		if ((ep = strchr(cp, '#')) != NULL)
245 			*ep = '\0';
246 		if (!*cp || *cp == '\n')
247 			continue;
248 
249 		nonblank++;
250 		snprintf(loc, sizeof(loc), "%.200s:%lu", file, linenum);
251 		if (auth_check_principals_line(cp, cert, loc, authoptsp) == 0)
252 			found_principal = 1;
253 	}
254 	debug2_f("%s: processed %lu/%lu lines", file, nonblank, linenum);
255 	free(line);
256 	return found_principal;
257 }
258 
259 /*
260  * Check a single line of an authorized_keys-format file. Returns 0 if key
261  * matches, -1 otherwise. Will return key/cert options via *authoptsp
262  * on success. "loc" is used as file/line location in log messages.
263  */
264 int
265 auth_check_authkey_line(struct passwd *pw, struct sshkey *key,
266     char *cp, const char *remote_ip, const char *remote_host, const char *loc,
267     struct sshauthopt **authoptsp)
268 {
269 	int want_keytype = sshkey_is_cert(key) ? KEY_UNSPEC : key->type;
270 	struct sshkey *found = NULL;
271 	struct sshauthopt *keyopts = NULL, *certopts = NULL, *finalopts = NULL;
272 	char *key_options = NULL, *fp = NULL;
273 	const char *reason = NULL;
274 	int ret = -1;
275 
276 	if (authoptsp != NULL)
277 		*authoptsp = NULL;
278 
279 	if ((found = sshkey_new(want_keytype)) == NULL) {
280 		debug3_f("keytype %d failed", want_keytype);
281 		goto out;
282 	}
283 
284 	/* XXX djm: peek at key type in line and skip if unwanted */
285 
286 	if (sshkey_read(found, &cp) != 0) {
287 		/* no key?  check for options */
288 		debug2("%s: check options: '%s'", loc, cp);
289 		key_options = cp;
290 		if (sshkey_advance_past_options(&cp) != 0) {
291 			reason = "invalid key option string";
292 			goto fail_reason;
293 		}
294 		skip_space(&cp);
295 		if (sshkey_read(found, &cp) != 0) {
296 			/* still no key?  advance to next line*/
297 			debug2("%s: advance: '%s'", loc, cp);
298 			goto out;
299 		}
300 	}
301 	/* Parse key options now; we need to know if this is a CA key */
302 	if ((keyopts = sshauthopt_parse(key_options, &reason)) == NULL) {
303 		debug("%s: bad key options: %s", loc, reason);
304 		auth_debug_add("%s: bad key options: %s", loc, reason);
305 		goto out;
306 	}
307 	/* Ignore keys that don't match or incorrectly marked as CAs */
308 	if (sshkey_is_cert(key)) {
309 		/* Certificate; check signature key against CA */
310 		if (!sshkey_equal(found, key->cert->signature_key) ||
311 		    !keyopts->cert_authority)
312 			goto out;
313 	} else {
314 		/* Plain key: check it against key found in file */
315 		if (!sshkey_equal(found, key) || keyopts->cert_authority)
316 			goto out;
317 	}
318 
319 	/* We have a candidate key, perform authorisation checks */
320 	if ((fp = sshkey_fingerprint(found,
321 	    SSH_FP_HASH_DEFAULT, SSH_FP_DEFAULT)) == NULL)
322 		fatal_f("fingerprint failed");
323 
324 	debug("%s: matching %s found: %s %s", loc,
325 	    sshkey_is_cert(key) ? "CA" : "key", sshkey_type(found), fp);
326 
327 	if (auth_authorise_keyopts(pw, keyopts,
328 	    sshkey_is_cert(key), remote_ip, remote_host, loc) != 0) {
329 		reason = "Refused by key options";
330 		goto fail_reason;
331 	}
332 	/* That's all we need for plain keys. */
333 	if (!sshkey_is_cert(key)) {
334 		verbose("Accepted key %s %s found at %s",
335 		    sshkey_type(found), fp, loc);
336 		finalopts = keyopts;
337 		keyopts = NULL;
338 		goto success;
339 	}
340 
341 	/*
342 	 * Additional authorisation for certificates.
343 	 */
344 
345 	/* Parse and check options present in certificate */
346 	if ((certopts = sshauthopt_from_cert(key)) == NULL) {
347 		reason = "Invalid certificate options";
348 		goto fail_reason;
349 	}
350 	if (auth_authorise_keyopts(pw, certopts, 0,
351 	    remote_ip, remote_host, loc) != 0) {
352 		reason = "Refused by certificate options";
353 		goto fail_reason;
354 	}
355 	if ((finalopts = sshauthopt_merge(keyopts, certopts, &reason)) == NULL)
356 		goto fail_reason;
357 
358 	/*
359 	 * If the user has specified a list of principals as
360 	 * a key option, then prefer that list to matching
361 	 * their username in the certificate principals list.
362 	 */
363 	if (keyopts->cert_principals != NULL &&
364 	    !match_principals_option(keyopts->cert_principals, key->cert)) {
365 		reason = "Certificate does not contain an authorized principal";
366 		goto fail_reason;
367 	}
368 	if (sshkey_cert_check_authority_now(key, 0, 0, 0,
369 	    keyopts->cert_principals == NULL ? pw->pw_name : NULL,
370 	    &reason) != 0)
371 		goto fail_reason;
372 
373 	verbose("Accepted certificate ID \"%s\" (serial %llu) "
374 	    "signed by CA %s %s found at %s",
375 	    key->cert->key_id,
376 	    (unsigned long long)key->cert->serial,
377 	    sshkey_type(found), fp, loc);
378 
379  success:
380 	if (finalopts == NULL)
381 		fatal_f("internal error: missing options");
382 	if (authoptsp != NULL) {
383 		*authoptsp = finalopts;
384 		finalopts = NULL;
385 	}
386 	/* success */
387 	ret = 0;
388 	goto out;
389 
390  fail_reason:
391 	error("%s", reason);
392 	auth_debug_add("%s", reason);
393  out:
394 	free(fp);
395 	sshauthopt_free(keyopts);
396 	sshauthopt_free(certopts);
397 	sshauthopt_free(finalopts);
398 	sshkey_free(found);
399 	return ret;
400 }
401 
402 /*
403  * Checks whether key is allowed in authorized_keys-format file,
404  * returns 1 if the key is allowed or 0 otherwise.
405  */
406 int
407 auth_check_authkeys_file(struct passwd *pw, FILE *f, char *file,
408     struct sshkey *key, const char *remote_ip,
409     const char *remote_host, struct sshauthopt **authoptsp)
410 {
411 	char *cp, *line = NULL, loc[256];
412 	size_t linesize = 0;
413 	int found_key = 0;
414 	u_long linenum = 0, nonblank = 0;
415 
416 	if (authoptsp != NULL)
417 		*authoptsp = NULL;
418 
419 	while (getline(&line, &linesize, f) != -1) {
420 		linenum++;
421 		/* Always consume entire file */
422 		if (found_key)
423 			continue;
424 
425 		/* Skip leading whitespace, empty and comment lines. */
426 		cp = line;
427 		skip_space(&cp);
428 		if (!*cp || *cp == '\n' || *cp == '#')
429 			continue;
430 
431 		nonblank++;
432 		snprintf(loc, sizeof(loc), "%.200s:%lu", file, linenum);
433 		if (auth_check_authkey_line(pw, key, cp,
434 		    remote_ip, remote_host, loc, authoptsp) == 0)
435 			found_key = 1;
436 	}
437 	free(line);
438 	debug2_f("%s: processed %lu/%lu lines", file, nonblank, linenum);
439 	return found_key;
440 }
441 
442 static FILE *
443 auth_openfile(const char *file, struct passwd *pw, int strict_modes,
444     int log_missing, char *file_type)
445 {
446 	char line[1024];
447 	struct stat st;
448 	int fd;
449 	FILE *f;
450 
451 	if ((fd = open(file, O_RDONLY|O_NONBLOCK)) == -1) {
452 		if (errno != ENOENT) {
453 			logit("Could not open user '%s' %s '%s': %s",
454 			    pw->pw_name, file_type, file, strerror(errno));
455 		} else if (log_missing) {
456 			debug("Could not open user '%s' %s '%s': %s",
457 			    pw->pw_name, file_type, file, strerror(errno));
458 		}
459 		return NULL;
460 	}
461 
462 	if (fstat(fd, &st) == -1) {
463 		close(fd);
464 		return NULL;
465 	}
466 	if (!S_ISREG(st.st_mode)) {
467 		logit("User '%s' %s '%s' is not a regular file",
468 		    pw->pw_name, file_type, file);
469 		close(fd);
470 		return NULL;
471 	}
472 	unset_nonblock(fd);
473 	if ((f = fdopen(fd, "r")) == NULL) {
474 		close(fd);
475 		return NULL;
476 	}
477 	if (strict_modes &&
478 	    safe_path_fd(fileno(f), file, pw, line, sizeof(line)) != 0) {
479 		fclose(f);
480 		logit("Authentication refused: %s", line);
481 		auth_debug_add("Ignored %s: %s", file_type, line);
482 		return NULL;
483 	}
484 
485 	return f;
486 }
487 
488 
489 FILE *
490 auth_openkeyfile(const char *file, struct passwd *pw, int strict_modes)
491 {
492 	return auth_openfile(file, pw, strict_modes, 1, "authorized keys");
493 }
494 
495 FILE *
496 auth_openprincipals(const char *file, struct passwd *pw, int strict_modes)
497 {
498 	return auth_openfile(file, pw, strict_modes, 0,
499 	    "authorized principals");
500 }
501 
502