Branch data Line data Source code
1 : : /* $OpenBSD: auth.c,v 1.103 2013/05/19 02:42:42 djm Exp $ */
2 : : /*
3 : : * Copyright (c) 2000 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 : :
32 : : #include <netinet/in.h>
33 : :
34 : : #include <errno.h>
35 : : #include <fcntl.h>
36 : : #ifdef HAVE_PATHS_H
37 : : # include <paths.h>
38 : : #endif
39 : : #include <pwd.h>
40 : : #ifdef HAVE_LOGIN_H
41 : : #include <login.h>
42 : : #endif
43 : : #ifdef USE_SHADOW
44 : : #include <shadow.h>
45 : : #endif
46 : : #ifdef HAVE_LIBGEN_H
47 : : #include <libgen.h>
48 : : #endif
49 : : #include <stdarg.h>
50 : : #include <stdio.h>
51 : : #include <string.h>
52 : : #include <unistd.h>
53 : :
54 : : #include "xmalloc.h"
55 : : #include "match.h"
56 : : #include "groupaccess.h"
57 : : #include "log.h"
58 : : #include "buffer.h"
59 : : #include "servconf.h"
60 : : #include "key.h"
61 : : #include "hostfile.h"
62 : : #include "auth.h"
63 : : #include "auth-options.h"
64 : : #include "canohost.h"
65 : : #include "uidswap.h"
66 : : #include "misc.h"
67 : : #include "packet.h"
68 : : #include "loginrec.h"
69 : : #ifdef GSSAPI
70 : : #include "ssh-gss.h"
71 : : #endif
72 : : #include "authfile.h"
73 : : #include "monitor_wrap.h"
74 : : #include "krl.h"
75 : : #include "compat.h"
76 : :
77 : : /* import */
78 : : extern ServerOptions options;
79 : : extern int use_privsep;
80 : : extern Buffer loginmsg;
81 : : extern struct passwd *privsep_pw;
82 : :
83 : : /* Debugging messages */
84 : : Buffer auth_debug;
85 : : int auth_debug_init;
86 : :
87 : : /*
88 : : * Check if the user is allowed to log in via ssh. If user is listed
89 : : * in DenyUsers or one of user's groups is listed in DenyGroups, false
90 : : * will be returned. If AllowUsers isn't empty and user isn't listed
91 : : * there, or if AllowGroups isn't empty and one of user's groups isn't
92 : : * listed there, false will be returned.
93 : : * If the user's shell is not executable, false will be returned.
94 : : * Otherwise true is returned.
95 : : */
96 : : int
97 : 836 : allowed_user(struct passwd * pw)
98 : : {
99 : : struct stat st;
100 : 836 : const char *hostname = NULL, *ipaddr = NULL, *passwd = NULL;
101 : : u_int i;
102 : : #ifdef USE_SHADOW
103 : 836 : struct spwd *spw = NULL;
104 : : #endif
105 : :
106 : : /* Shouldn't be called if pw is NULL, but better safe than sorry... */
107 [ + - ][ + - ]: 836 : if (!pw || !pw->pw_name)
108 : : return 0;
109 : :
110 : : #ifdef USE_SHADOW
111 [ + - ]: 836 : if (!options.use_pam)
112 : 836 : spw = getspnam(pw->pw_name);
113 : : #ifdef HAS_SHADOW_EXPIRE
114 [ + - ][ - + ]: 836 : if (!options.use_pam && spw != NULL && auth_shadow_acctexpired(spw))
[ # # ]
115 : : return 0;
116 : : #endif /* HAS_SHADOW_EXPIRE */
117 : : #endif /* USE_SHADOW */
118 : :
119 : : /* grab passwd field for locked account check */
120 : 836 : passwd = pw->pw_passwd;
121 : : #ifdef USE_SHADOW
122 [ - + ]: 836 : if (spw != NULL)
123 : : #ifdef USE_LIBIAF
124 : : passwd = get_iaf_password(pw);
125 : : #else
126 : 0 : passwd = spw->sp_pwdp;
127 : : #endif /* USE_LIBIAF */
128 : : #endif
129 : :
130 : : /* check for locked account */
131 [ + - ][ + - ]: 836 : if (!options.use_pam && passwd && *passwd) {
[ + - ]
132 : 836 : int locked = 0;
133 : :
134 : : #ifdef LOCKED_PASSWD_STRING
135 : : if (strcmp(passwd, LOCKED_PASSWD_STRING) == 0)
136 : : locked = 1;
137 : : #endif
138 : : #ifdef LOCKED_PASSWD_PREFIX
139 [ - + ]: 836 : if (strncmp(passwd, LOCKED_PASSWD_PREFIX,
140 : : strlen(LOCKED_PASSWD_PREFIX)) == 0)
141 : 0 : locked = 1;
142 : : #endif
143 : : #ifdef LOCKED_PASSWD_SUBSTR
144 : : if (strstr(passwd, LOCKED_PASSWD_SUBSTR))
145 : : locked = 1;
146 : : #endif
147 : : #ifdef USE_LIBIAF
148 : : free((void *) passwd);
149 : : #endif /* USE_LIBIAF */
150 [ - + ]: 836 : if (locked) {
151 : 0 : logit("User %.100s not allowed because account is locked",
152 : : pw->pw_name);
153 : 0 : return 0;
154 : : }
155 : : }
156 : :
157 : : /*
158 : : * Deny if shell does not exist or is not executable unless we
159 : : * are chrooting.
160 : : */
161 [ - + ][ # # ]: 836 : if (options.chroot_directory == NULL ||
162 : 0 : strcasecmp(options.chroot_directory, "none") == 0) {
163 [ + - ]: 836 : char *shell = xstrdup((pw->pw_shell[0] == '\0') ?
164 : : _PATH_BSHELL : pw->pw_shell); /* empty = /bin/sh */
165 : :
166 [ - + ]: 836 : if (stat(shell, &st) != 0) {
167 : 0 : logit("User %.100s not allowed because shell %.100s "
168 : : "does not exist", pw->pw_name, shell);
169 : 0 : free(shell);
170 : 0 : return 0;
171 : : }
172 [ + - ][ - + ]: 836 : if (S_ISREG(st.st_mode) == 0 ||
173 : 836 : (st.st_mode & (S_IXOTH|S_IXUSR|S_IXGRP)) == 0) {
174 : 0 : logit("User %.100s not allowed because shell %.100s "
175 : : "is not executable", pw->pw_name, shell);
176 : 0 : free(shell);
177 : 0 : return 0;
178 : : }
179 : 836 : free(shell);
180 : : }
181 : :
182 [ + - ][ + - ]: 836 : if (options.num_deny_users > 0 || options.num_allow_users > 0 ||
[ + - ]
183 [ - + ]: 836 : options.num_deny_groups > 0 || options.num_allow_groups > 0) {
184 : 0 : hostname = get_canonical_hostname(options.use_dns);
185 : 0 : ipaddr = get_remote_ipaddr();
186 : : }
187 : :
188 : : /* Return false if user is listed in DenyUsers */
189 [ - + ]: 836 : if (options.num_deny_users > 0) {
190 [ # # ]: 0 : for (i = 0; i < options.num_deny_users; i++)
191 [ # # ]: 0 : if (match_user(pw->pw_name, hostname, ipaddr,
192 : 0 : options.deny_users[i])) {
193 : 0 : logit("User %.100s from %.100s not allowed "
194 : : "because listed in DenyUsers",
195 : : pw->pw_name, hostname);
196 : 0 : return 0;
197 : : }
198 : : }
199 : : /* Return false if AllowUsers isn't empty and user isn't listed there */
200 [ - + ]: 836 : if (options.num_allow_users > 0) {
201 [ # # ]: 0 : for (i = 0; i < options.num_allow_users; i++)
202 [ # # ]: 0 : if (match_user(pw->pw_name, hostname, ipaddr,
203 : 0 : options.allow_users[i]))
204 : : break;
205 : : /* i < options.num_allow_users iff we break for loop */
206 [ # # ]: 0 : if (i >= options.num_allow_users) {
207 : 0 : logit("User %.100s from %.100s not allowed because "
208 : : "not listed in AllowUsers", pw->pw_name, hostname);
209 : 0 : return 0;
210 : : }
211 : : }
212 [ + - ][ - + ]: 836 : if (options.num_deny_groups > 0 || options.num_allow_groups > 0) {
213 : : /* Get the user's group access list (primary and supplementary) */
214 [ # # ]: 0 : if (ga_init(pw->pw_name, pw->pw_gid) == 0) {
215 : 0 : logit("User %.100s from %.100s not allowed because "
216 : : "not in any group", pw->pw_name, hostname);
217 : 0 : return 0;
218 : : }
219 : :
220 : : /* Return false if one of user's groups is listed in DenyGroups */
221 [ # # ]: 0 : if (options.num_deny_groups > 0)
222 [ # # ]: 0 : if (ga_match(options.deny_groups,
223 : : options.num_deny_groups)) {
224 : 0 : ga_free();
225 : 0 : logit("User %.100s from %.100s not allowed "
226 : : "because a group is listed in DenyGroups",
227 : : pw->pw_name, hostname);
228 : 0 : return 0;
229 : : }
230 : : /*
231 : : * Return false if AllowGroups isn't empty and one of user's groups
232 : : * isn't listed there
233 : : */
234 [ # # ]: 0 : if (options.num_allow_groups > 0)
235 [ # # ]: 0 : if (!ga_match(options.allow_groups,
236 : : options.num_allow_groups)) {
237 : 0 : ga_free();
238 : 0 : logit("User %.100s from %.100s not allowed "
239 : : "because none of user's groups are listed "
240 : : "in AllowGroups", pw->pw_name, hostname);
241 : 0 : return 0;
242 : : }
243 : 0 : ga_free();
244 : : }
245 : :
246 : : #ifdef CUSTOM_SYS_AUTH_ALLOWED_USER
247 : : if (!sys_auth_allowed_user(pw, &loginmsg))
248 : : return 0;
249 : : #endif
250 : :
251 : : /* We found no reason not to let this user try to log on... */
252 : : return 1;
253 : : }
254 : :
255 : : void
256 : 2234 : auth_info(Authctxt *authctxt, const char *fmt, ...)
257 : : {
258 : : va_list ap;
259 : : int i;
260 : :
261 : 2234 : free(authctxt->info);
262 : 2234 : authctxt->info = NULL;
263 : :
264 : 2234 : va_start(ap, fmt);
265 : 4468 : i = vasprintf(&authctxt->info, fmt, ap);
266 : 2234 : va_end(ap);
267 : :
268 [ + - ][ - + ]: 2234 : if (i < 0 || authctxt->info == NULL)
269 : 0 : fatal("vasprintf failed");
270 : 2234 : }
271 : :
272 : : void
273 : 3392 : auth_log(Authctxt *authctxt, int authenticated, int partial,
274 : : const char *method, const char *submethod)
275 : : {
276 : 3392 : void (*authlog) (const char *fmt,...) = verbose;
277 : : char *authmsg;
278 : :
279 [ + + ][ + + ]: 3392 : if (use_privsep && !mm_is_monitor() && !authctxt->postponed)
[ + + ]
280 : 3392 : return;
281 : :
282 : : /* Raise logging level */
283 [ + + ][ + - ]: 1891 : if (authenticated == 1 ||
284 [ + - ]: 1055 : !authctxt->valid ||
285 [ - + ]: 1055 : authctxt->failures >= options.max_authtries / 2 ||
286 : 1055 : strcmp(method, "password") == 0)
287 : 836 : authlog = logit;
288 : :
289 [ + + ]: 1891 : if (authctxt->postponed)
290 : : authmsg = "Postponed";
291 [ + - ]: 1159 : else if (partial)
292 : : authmsg = "Partial";
293 : : else
294 [ + + ]: 1159 : authmsg = authenticated ? "Accepted" : "Failed";
295 : :
296 [ + + ][ + + ]: 1891 : authlog("%s %s%s%s for %s%.100s from %.200s port %d %s%s%s",
[ + + ][ - + ]
[ - + ][ + - ]
297 : : authmsg,
298 : : method,
299 : : submethod != NULL ? "/" : "", submethod == NULL ? "" : submethod,
300 : 1891 : authctxt->valid ? "" : "invalid user ",
301 : : authctxt->user,
302 : : get_remote_ipaddr(),
303 : : get_remote_port(),
304 : 1891 : compat20 ? "ssh2" : "ssh1",
305 : : authctxt->info != NULL ? ": " : "",
306 : 1891 : authctxt->info != NULL ? authctxt->info : "");
307 : 1891 : free(authctxt->info);
308 : 1891 : authctxt->info = NULL;
309 : :
310 : : #ifdef CUSTOM_FAILED_LOGIN
311 [ + + ][ + + ]: 1891 : if (authenticated == 0 && !authctxt->postponed &&
[ + - ]
312 [ + - ]: 323 : (strcmp(method, "password") == 0 ||
313 [ - + ]: 323 : strncmp(method, "keyboard-interactive", 20) == 0 ||
314 : 323 : strcmp(method, "challenge-response") == 0))
315 : 0 : record_failed_login(authctxt->user,
316 : : get_canonical_hostname(options.use_dns), "ssh");
317 : : # ifdef WITH_AIXAUTHENTICATE
318 : : if (authenticated)
319 : : sys_auth_record_login(authctxt->user,
320 : : get_canonical_hostname(options.use_dns), "ssh", &loginmsg);
321 : : # endif
322 : : #endif
323 : : #ifdef SSH_AUDIT_EVENTS
324 : : if (authenticated == 0 && !authctxt->postponed)
325 : : audit_event(audit_classify_auth(method));
326 : : #endif
327 : : }
328 : :
329 : : /*
330 : : * Check whether root logins are disallowed.
331 : : */
332 : : int
333 : 0 : auth_root_allowed(const char *method)
334 : : {
335 [ # # # # ]: 0 : switch (options.permit_root_login) {
336 : : case PERMIT_YES:
337 : : return 1;
338 : : case PERMIT_NO_PASSWD:
339 [ # # ]: 0 : if (strcmp(method, "password") != 0)
340 : : return 1;
341 : : break;
342 : : case PERMIT_FORCED_ONLY:
343 [ # # ]: 0 : if (forced_command) {
344 : 0 : logit("Root login accepted for forced command.");
345 : 0 : return 1;
346 : : }
347 : : break;
348 : : }
349 : 0 : logit("ROOT LOGIN REFUSED FROM %.200s", get_remote_ipaddr());
350 : 0 : return 0;
351 : : }
352 : :
353 : :
354 : : /*
355 : : * Given a template and a passwd structure, build a filename
356 : : * by substituting % tokenised options. Currently, %% becomes '%',
357 : : * %h becomes the home directory and %u the username.
358 : : *
359 : : * This returns a buffer allocated by xmalloc.
360 : : */
361 : : char *
362 : 1644 : expand_authorized_keys(const char *filename, struct passwd *pw)
363 : : {
364 : : char *file, ret[MAXPATHLEN];
365 : : int i;
366 : :
367 : 1644 : file = percent_expand(filename, "h", pw->pw_dir,
368 : : "u", pw->pw_name, (char *)NULL);
369 : :
370 : : /*
371 : : * Ensure that filename starts anchored. If not, be backward
372 : : * compatible and prepend the '%h/'
373 : : */
374 [ - + ]: 1644 : if (*file == '/')
375 : : return (file);
376 : :
377 : 0 : i = snprintf(ret, sizeof(ret), "%s/%s", pw->pw_dir, file);
378 [ # # ]: 0 : if (i < 0 || (size_t)i >= sizeof(ret))
379 : 0 : fatal("expand_authorized_keys: path too long");
380 : 0 : free(file);
381 : 0 : return (xstrdup(ret));
382 : : }
383 : :
384 : : char *
385 : 176 : authorized_principals_file(struct passwd *pw)
386 : : {
387 [ + + ][ + - ]: 176 : if (options.authorized_principals_file == NULL ||
388 : 100 : strcasecmp(options.authorized_principals_file, "none") == 0)
389 : : return NULL;
390 : 100 : return expand_authorized_keys(options.authorized_principals_file, pw);
391 : : }
392 : :
393 : : /* return ok if key exists in sysfile or userfile */
394 : : HostStatus
395 : 0 : check_key_in_hostfiles(struct passwd *pw, Key *key, const char *host,
396 : : const char *sysfile, const char *userfile)
397 : : {
398 : : char *user_hostfile;
399 : : struct stat st;
400 : : HostStatus host_status;
401 : : struct hostkeys *hostkeys;
402 : : const struct hostkey_entry *found;
403 : :
404 : 0 : hostkeys = init_hostkeys();
405 : 0 : load_hostkeys(hostkeys, host, sysfile);
406 [ # # ]: 0 : if (userfile != NULL) {
407 : 0 : user_hostfile = tilde_expand_filename(userfile, pw->pw_uid);
408 [ # # # # ]: 0 : if (options.strict_modes &&
409 [ # # ]: 0 : (stat(user_hostfile, &st) == 0) &&
410 [ # # ][ # # ]: 0 : ((st.st_uid != 0 && st.st_uid != pw->pw_uid) ||
411 : 0 : (st.st_mode & 022) != 0)) {
412 : 0 : logit("Authentication refused for %.100s: "
413 : : "bad owner or modes for %.200s",
414 : : pw->pw_name, user_hostfile);
415 : 0 : auth_debug_add("Ignored %.200s: bad ownership or modes",
416 : : user_hostfile);
417 : : } else {
418 : 0 : temporarily_use_uid(pw);
419 : 0 : load_hostkeys(hostkeys, host, user_hostfile);
420 : 0 : restore_uid();
421 : : }
422 : 0 : free(user_hostfile);
423 : : }
424 : 0 : host_status = check_key_in_hostkeys(hostkeys, key, &found);
425 [ # # ]: 0 : if (host_status == HOST_REVOKED)
426 : 0 : error("WARNING: revoked key for %s attempted authentication",
427 : 0 : found->host);
428 [ # # ]: 0 : else if (host_status == HOST_OK)
429 : 0 : debug("%s: key for %s found at %s:%ld", __func__,
430 : 0 : found->host, found->file, found->line);
431 : : else
432 : 0 : debug("%s: key for host %s not found", __func__, host);
433 : :
434 : 0 : free_hostkeys(hostkeys);
435 : :
436 : 0 : return host_status;
437 : : }
438 : :
439 : : /*
440 : : * Check a given path for security. This is defined as all components
441 : : * of the path to the file must be owned by either the owner of
442 : : * of the file or root and no directories must be group or world writable.
443 : : *
444 : : * XXX Should any specific check be done for sym links ?
445 : : *
446 : : * Takes a file name, its stat information (preferably from fstat() to
447 : : * avoid races), the uid of the expected owner, their home directory and an
448 : : * error buffer plus max size as arguments.
449 : : *
450 : : * Returns 0 on success and -1 on failure
451 : : */
452 : : int
453 : 0 : auth_secure_path(const char *name, struct stat *stp, const char *pw_dir,
454 : : uid_t uid, char *err, size_t errlen)
455 : : {
456 : : char buf[MAXPATHLEN], homedir[MAXPATHLEN];
457 : : char *cp;
458 : 0 : int comparehome = 0;
459 : : struct stat st;
460 : :
461 [ # # ]: 0 : if (realpath(name, buf) == NULL) {
462 : 0 : snprintf(err, errlen, "realpath %s failed: %s", name,
463 : 0 : strerror(errno));
464 : 0 : return -1;
465 : : }
466 [ # # # # ]: 0 : if (pw_dir != NULL && realpath(pw_dir, homedir) != NULL)
467 : 0 : comparehome = 1;
468 : :
469 [ # # ]: 0 : if (!S_ISREG(stp->st_mode)) {
470 : : snprintf(err, errlen, "%s is not a regular file", buf);
471 : 0 : return -1;
472 : : }
473 [ # # ][ # # ]: 0 : if ((!platform_sys_dir_uid(stp->st_uid) && stp->st_uid != uid) ||
[ # # ]
474 : 0 : (stp->st_mode & 022) != 0) {
475 : : snprintf(err, errlen, "bad ownership or modes for file %s",
476 : : buf);
477 : 0 : return -1;
478 : : }
479 : :
480 : : /* for each component of the canonical path, walking upwards */
481 : : for (;;) {
482 [ # # ]: 0 : if ((cp = dirname(buf)) == NULL) {
483 : : snprintf(err, errlen, "dirname() failed");
484 : 0 : return -1;
485 : : }
486 : 0 : strlcpy(buf, cp, sizeof(buf));
487 : :
488 [ # # # # ]: 0 : if (stat(buf, &st) < 0 ||
489 [ # # ][ # # ]: 0 : (!platform_sys_dir_uid(st.st_uid) && st.st_uid != uid) ||
490 : 0 : (st.st_mode & 022) != 0) {
491 : : snprintf(err, errlen,
492 : : "bad ownership or modes for directory %s", buf);
493 : 0 : return -1;
494 : : }
495 : :
496 : : /* If are past the homedir then we can stop */
497 [ # # ][ # # ]: 0 : if (comparehome && strcmp(homedir, buf) == 0)
498 : : break;
499 : :
500 : : /*
501 : : * dirname should always complete with a "/" path,
502 : : * but we can be paranoid and check for "." too
503 : : */
504 [ # # ][ # # ]: 0 : if ((strcmp("/", buf) == 0) || (strcmp(".", buf) == 0))
[ # # ][ # # ]
505 : : break;
506 : : }
507 : : return 0;
508 : : }
509 : :
510 : : /*
511 : : * Version of secure_path() that accepts an open file descriptor to
512 : : * avoid races.
513 : : *
514 : : * Returns 0 on success and -1 on failure
515 : : */
516 : : static int
517 : 0 : secure_filename(FILE *f, const char *file, struct passwd *pw,
518 : : char *err, size_t errlen)
519 : : {
520 : : struct stat st;
521 : :
522 : : /* check the open file to avoid races */
523 [ # # ]: 0 : if (fstat(fileno(f), &st) < 0) {
524 : 0 : snprintf(err, errlen, "cannot stat file %s: %s",
525 : 0 : file, strerror(errno));
526 : : return -1;
527 : : }
528 : 0 : return auth_secure_path(file, &st, pw->pw_dir, pw->pw_uid, err, errlen);
529 : : }
530 : :
531 : : static FILE *
532 : 1644 : auth_openfile(const char *file, struct passwd *pw, int strict_modes,
533 : : int log_missing, char *file_type)
534 : : {
535 : : char line[1024];
536 : : struct stat st;
537 : : int fd;
538 : : FILE *f;
539 : :
540 [ + + ]: 1644 : if ((fd = open(file, O_RDONLY|O_NONBLOCK)) == -1) {
541 [ - + ][ # # ]: 48 : if (log_missing || errno != ENOENT)
542 : 48 : debug("Could not open %s '%s': %s", file_type, file,
543 : 48 : strerror(errno));
544 : : return NULL;
545 : : }
546 : :
547 [ - + ]: 1596 : if (fstat(fd, &st) < 0) {
548 : 0 : close(fd);
549 : 0 : return NULL;
550 : : }
551 [ + + ]: 1596 : if (!S_ISREG(st.st_mode)) {
552 : 6 : logit("User %s %s %s is not a regular file",
553 : : pw->pw_name, file_type, file);
554 : 6 : close(fd);
555 : 6 : return NULL;
556 : : }
557 : 1590 : unset_nonblock(fd);
558 [ - + ]: 1590 : if ((f = fdopen(fd, "r")) == NULL) {
559 : 0 : close(fd);
560 : 0 : return NULL;
561 : : }
562 [ - + # # ]: 1590 : if (strict_modes &&
563 : 0 : secure_filename(f, file, pw, line, sizeof(line)) != 0) {
564 : 0 : fclose(f);
565 : 0 : logit("Authentication refused: %s", line);
566 : 0 : auth_debug_add("Ignored %s: %s", file_type, line);
567 : 0 : return NULL;
568 : : }
569 : :
570 : 1590 : return f;
571 : : }
572 : :
573 : :
574 : : FILE *
575 : 1544 : auth_openkeyfile(const char *file, struct passwd *pw, int strict_modes)
576 : : {
577 : 1544 : return auth_openfile(file, pw, strict_modes, 1, "authorized keys");
578 : : }
579 : :
580 : : FILE *
581 : 100 : auth_openprincipals(const char *file, struct passwd *pw, int strict_modes)
582 : : {
583 : 100 : return auth_openfile(file, pw, strict_modes, 0,
584 : : "authorized principals");
585 : : }
586 : :
587 : : struct passwd *
588 : 836 : getpwnamallow(const char *user)
589 : : {
590 : : #ifdef HAVE_LOGIN_CAP
591 : : extern login_cap_t *lc;
592 : : #ifdef BSD_AUTH
593 : : auth_session_t *as;
594 : : #endif
595 : : #endif
596 : : struct passwd *pw;
597 : 836 : struct connection_info *ci = get_connection_info(1, options.use_dns);
598 : :
599 : 836 : ci->user = user;
600 : 836 : parse_server_match_config(&options, ci);
601 : :
602 : : #if defined(_AIX) && defined(HAVE_SETAUTHDB)
603 : : aix_setauthdb(user);
604 : : #endif
605 : :
606 : 836 : pw = getpwnam(user);
607 : :
608 : : #if defined(_AIX) && defined(HAVE_SETAUTHDB)
609 : : aix_restoreauthdb();
610 : : #endif
611 : : #ifdef HAVE_CYGWIN
612 : : /*
613 : : * Windows usernames are case-insensitive. To avoid later problems
614 : : * when trying to match the username, the user is only allowed to
615 : : * login if the username is given in the same case as stored in the
616 : : * user database.
617 : : */
618 : : if (pw != NULL && strcmp(user, pw->pw_name) != 0) {
619 : : logit("Login name %.100s does not match stored username %.100s",
620 : : user, pw->pw_name);
621 : : pw = NULL;
622 : : }
623 : : #endif
624 [ - + ]: 836 : if (pw == NULL) {
625 : 0 : logit("Invalid user %.100s from %.100s",
626 : : user, get_remote_ipaddr());
627 : : #ifdef CUSTOM_FAILED_LOGIN
628 : 0 : record_failed_login(user,
629 : : get_canonical_hostname(options.use_dns), "ssh");
630 : : #endif
631 : : #ifdef SSH_AUDIT_EVENTS
632 : : audit_event(SSH_INVALID_USER);
633 : : #endif /* SSH_AUDIT_EVENTS */
634 : 0 : return (NULL);
635 : : }
636 [ + - ]: 836 : if (!allowed_user(pw))
637 : : return (NULL);
638 : : #ifdef HAVE_LOGIN_CAP
639 : : if ((lc = login_getclass(pw->pw_class)) == NULL) {
640 : : debug("unable to get login class: %s", user);
641 : : return (NULL);
642 : : }
643 : : #ifdef BSD_AUTH
644 : : if ((as = auth_open()) == NULL || auth_setpwd(as, pw) != 0 ||
645 : : auth_approval(as, lc, pw->pw_name, "ssh") <= 0) {
646 : : debug("Approval failure for %s", user);
647 : : pw = NULL;
648 : : }
649 : : if (as != NULL)
650 : : auth_close(as);
651 : : #endif
652 : : #endif
653 [ + - ]: 836 : if (pw != NULL)
654 : 836 : return (pwcopy(pw));
655 : : return (NULL);
656 : : }
657 : :
658 : : /* Returns 1 if key is revoked by revoked_keys_file, 0 otherwise */
659 : : int
660 : 2006 : auth_key_is_revoked(Key *key)
661 : : {
662 : : char *key_fp;
663 : :
664 [ + + ]: 2006 : if (options.revoked_keys_file == NULL)
665 : : return 0;
666 [ - - + ]: 160 : switch (ssh_krl_file_contains_key(options.revoked_keys_file, key)) {
667 : : case 0:
668 : : return 0; /* Not revoked */
669 : : case -2:
670 : : break; /* Not a KRL */
671 : : default:
672 : : goto revoked;
673 : : }
674 : 0 : debug3("%s: treating %s as a key list", __func__,
675 : : options.revoked_keys_file);
676 [ # # # # ]: 0 : switch (key_in_file(key, options.revoked_keys_file, 0)) {
677 : : case 0:
678 : : /* key not revoked */
679 : : return 0;
680 : : case -1:
681 : : /* Error opening revoked_keys_file: refuse all keys */
682 : 0 : error("Revoked keys file is unreadable: refusing public key "
683 : : "authentication");
684 : 0 : return 1;
685 : : case 1:
686 : : revoked:
687 : : /* Key revoked */
688 : 0 : key_fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
689 : 0 : error("WARNING: authentication attempt with a revoked "
690 : : "%s key %s ", key_type(key), key_fp);
691 : 0 : free(key_fp);
692 : 0 : return 1;
693 : : }
694 : 0 : fatal("key_in_file returned junk");
695 : : }
696 : :
697 : : void
698 : 124 : auth_debug_add(const char *fmt,...)
699 : : {
700 : : char buf[1024];
701 : : va_list args;
702 : :
703 [ + - ]: 124 : if (!auth_debug_init)
704 : 0 : return;
705 : :
706 : 124 : va_start(args, fmt);
707 : : vsnprintf(buf, sizeof(buf), fmt, args);
708 : 124 : va_end(args);
709 : 124 : buffer_put_cstring(&auth_debug, buf);
710 : : }
711 : :
712 : : void
713 : 810 : auth_debug_send(void)
714 : : {
715 : : char *msg;
716 : :
717 [ + - ]: 810 : if (!auth_debug_init)
718 : 810 : return;
719 [ + + ]: 934 : while (buffer_len(&auth_debug)) {
720 : 124 : msg = buffer_get_string(&auth_debug, NULL);
721 : 124 : packet_send_debug("%s", msg);
722 : 124 : free(msg);
723 : : }
724 : : }
725 : :
726 : : void
727 : 1215 : auth_debug_reset(void)
728 : : {
729 [ - + ]: 1215 : if (auth_debug_init)
730 : 0 : buffer_clear(&auth_debug);
731 : : else {
732 : 1215 : buffer_init(&auth_debug);
733 : 1215 : auth_debug_init = 1;
734 : : }
735 : 1215 : }
736 : :
737 : : struct passwd *
738 : 0 : fakepw(void)
739 : : {
740 : : static struct passwd fake;
741 : :
742 : : memset(&fake, 0, sizeof(fake));
743 : 0 : fake.pw_name = "NOUSER";
744 : 0 : fake.pw_passwd =
745 : : "$2a$06$r3.juUaHZDlIbQaO2dS9FuYxL1W9M81R1Tc92PoSNmzvpEqLkLGrK";
746 : : #ifdef HAVE_STRUCT_PASSWD_PW_GECOS
747 : 0 : fake.pw_gecos = "NOUSER";
748 : : #endif
749 [ # # ]: 0 : fake.pw_uid = privsep_pw == NULL ? (uid_t)-1 : privsep_pw->pw_uid;
750 [ # # ]: 0 : fake.pw_gid = privsep_pw == NULL ? (gid_t)-1 : privsep_pw->pw_gid;
751 : : #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
752 : : fake.pw_class = "";
753 : : #endif
754 : 0 : fake.pw_dir = "/nonexist";
755 : 0 : fake.pw_shell = "/nonexist";
756 : :
757 : 0 : return (&fake);
758 : : }
|
