]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/basic/user-util.c
2 This file is part of systemd.
4 Copyright 2010 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
34 #include "alloc-util.h"
37 #include "format-util.h"
40 #include "parse-util.h"
41 #include "path-util.h"
42 #include "string-util.h"
44 #include "user-util.h"
47 bool uid_is_valid(uid_t uid
) {
49 /* Also see POSIX IEEE Std 1003.1-2008, 2016 Edition, 3.436. */
51 /* Some libc APIs use UID_INVALID as special placeholder */
52 if (uid
== (uid_t
) UINT32_C(0xFFFFFFFF))
55 /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
56 if (uid
== (uid_t
) UINT32_C(0xFFFF))
62 int parse_uid(const char *s
, uid_t
*ret
) {
68 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
69 r
= safe_atou32(s
, &uid
);
73 if (!uid_is_valid(uid
))
74 return -ENXIO
; /* we return ENXIO instead of EINVAL
75 * here, to make it easy to distuingish
76 * invalid numeric uids from invalid
85 char* getlogname_malloc(void) {
89 if (isatty(STDIN_FILENO
) && fstat(STDIN_FILENO
, &st
) >= 0)
94 return uid_to_name(uid
);
97 char *getusername_malloc(void) {
104 return uid_to_name(getuid());
108 const char **username
,
109 uid_t
*uid
, gid_t
*gid
,
111 const char **shell
) {
119 /* We enforce some special rules for uid=0: in order to avoid
120 * NSS lookups for root we hardcode its data. */
122 if (streq(*username
, "root") || streq(*username
, "0")) {
140 if (parse_uid(*username
, &u
) >= 0) {
144 /* If there are multiple users with the same id, make
145 * sure to leave $USER to the configured value instead
146 * of the first occurrence in the database. However if
147 * the uid was configured by a numeric uid, then let's
148 * pick the real username from /etc/passwd. */
150 *username
= p
->pw_name
;
153 p
= getpwnam(*username
);
157 return errno
> 0 ? -errno
: -ESRCH
;
160 if (!uid_is_valid(p
->pw_uid
))
167 if (!gid_is_valid(p
->pw_gid
))
177 *shell
= p
->pw_shell
;
182 int get_user_creds_clean(
183 const char **username
,
184 uid_t
*uid
, gid_t
*gid
,
186 const char **shell
) {
190 /* Like get_user_creds(), but resets home/shell to NULL if they don't contain anything relevant. */
192 r
= get_user_creds(username
, uid
, gid
, home
, shell
);
197 (isempty(*shell
) || PATH_IN_SET(*shell
,
201 "/usr/sbin/nologin")))
205 (isempty(*home
) || path_equal(*home
, "/")))
211 int get_group_creds(const char **groupname
, gid_t
*gid
) {
217 /* We enforce some special rules for gid=0: in order to avoid
218 * NSS lookups for root we hardcode its data. */
220 if (streq(*groupname
, "root") || streq(*groupname
, "0")) {
229 if (parse_gid(*groupname
, &id
) >= 0) {
234 *groupname
= g
->gr_name
;
237 g
= getgrnam(*groupname
);
241 return errno
> 0 ? -errno
: -ESRCH
;
244 if (!gid_is_valid(g
->gr_gid
))
253 char* uid_to_name(uid_t uid
) {
257 /* Shortcut things to avoid NSS lookups */
259 return strdup("root");
261 if (uid_is_valid(uid
)) {
264 bufsize
= sysconf(_SC_GETPW_R_SIZE_MAX
);
269 struct passwd pwbuf
, *pw
= NULL
;
270 _cleanup_free_
char *buf
= NULL
;
272 buf
= malloc(bufsize
);
276 r
= getpwuid_r(uid
, &pwbuf
, buf
, (size_t) bufsize
, &pw
);
278 return strdup(pw
->pw_name
);
286 if (asprintf(&ret
, UID_FMT
, uid
) < 0)
292 char* gid_to_name(gid_t gid
) {
297 return strdup("root");
299 if (gid_is_valid(gid
)) {
302 bufsize
= sysconf(_SC_GETGR_R_SIZE_MAX
);
307 struct group grbuf
, *gr
= NULL
;
308 _cleanup_free_
char *buf
= NULL
;
310 buf
= malloc(bufsize
);
314 r
= getgrgid_r(gid
, &grbuf
, buf
, (size_t) bufsize
, &gr
);
316 return strdup(gr
->gr_name
);
324 if (asprintf(&ret
, GID_FMT
, gid
) < 0)
330 int in_gid(gid_t gid
) {
332 int ngroups_max
, r
, i
;
337 if (getegid() == gid
)
340 if (!gid_is_valid(gid
))
343 ngroups_max
= sysconf(_SC_NGROUPS_MAX
);
344 assert(ngroups_max
> 0);
346 gids
= alloca(sizeof(gid_t
) * ngroups_max
);
348 r
= getgroups(ngroups_max
, gids
);
352 for (i
= 0; i
< r
; i
++)
359 int in_group(const char *name
) {
363 r
= get_group_creds(&name
, &gid
);
370 int get_home_dir(char **_h
) {
378 /* Take the user specified one */
379 e
= secure_getenv("HOME");
380 if (e
&& path_is_absolute(e
)) {
389 /* Hardcode home directory for root to avoid NSS */
400 /* Check the database... */
404 return errno
> 0 ? -errno
: -ESRCH
;
406 if (!path_is_absolute(p
->pw_dir
))
409 h
= strdup(p
->pw_dir
);
417 int get_shell(char **_s
) {
425 /* Take the user specified one */
436 /* Hardcode home directory for root to avoid NSS */
439 s
= strdup("/bin/sh");
447 /* Check the database... */
451 return errno
> 0 ? -errno
: -ESRCH
;
453 if (!path_is_absolute(p
->pw_shell
))
456 s
= strdup(p
->pw_shell
);
464 int reset_uid_gid(void) {
467 r
= maybe_setgroups(0, NULL
);
471 if (setresgid(0, 0, 0) < 0)
474 if (setresuid(0, 0, 0) < 0)
480 int take_etc_passwd_lock(const char *root
) {
482 struct flock flock
= {
484 .l_whence
= SEEK_SET
,
492 /* This is roughly the same as lckpwdf(), but not as awful. We
493 * don't want to use alarm() and signals, hence we implement
494 * our own trivial version of this.
496 * Note that shadow-utils also takes per-database locks in
497 * addition to lckpwdf(). However, we don't given that they
498 * are redundant as they invoke lckpwdf() first and keep
499 * it during everything they do. The per-database locks are
500 * awfully racy, and thus we just won't do them. */
503 path
= prefix_roota(root
, "/etc/.pwd.lock");
505 path
= "/etc/.pwd.lock";
507 fd
= open(path
, O_WRONLY
|O_CREAT
|O_CLOEXEC
|O_NOCTTY
|O_NOFOLLOW
, 0600);
511 r
= fcntl(fd
, F_SETLKW
, &flock
);
520 bool valid_user_group_name(const char *u
) {
524 /* Checks if the specified name is a valid user/group name. Also see POSIX IEEE Std 1003.1-2008, 2016 Edition,
525 * 3.437. We are a bit stricter here however. Specifically we deviate from POSIX rules:
527 * - We don't allow any dots (this would break chown syntax which permits dots as user/group name separator)
528 * - We require that names fit into the appropriate utmp field
529 * - We don't allow empty user names
531 * Note that other systems are even more restrictive, and don't permit underscores or uppercase characters.
537 if (!(u
[0] >= 'a' && u
[0] <= 'z') &&
538 !(u
[0] >= 'A' && u
[0] <= 'Z') &&
542 for (i
= u
+1; *i
; i
++) {
543 if (!(*i
>= 'a' && *i
<= 'z') &&
544 !(*i
>= 'A' && *i
<= 'Z') &&
545 !(*i
>= '0' && *i
<= '9') &&
546 !IN_SET(*i
, '_', '-'))
550 sz
= sysconf(_SC_LOGIN_NAME_MAX
);
553 if ((size_t) (i
-u
) > (size_t) sz
)
556 if ((size_t) (i
-u
) > UT_NAMESIZE
- 1)
562 bool valid_user_group_name_or_id(const char *u
) {
564 /* Similar as above, but is also fine with numeric UID/GID specifications, as long as they are in the right
565 * range, and not the invalid user ids. */
570 if (valid_user_group_name(u
))
573 return parse_uid(u
, NULL
) >= 0;
576 bool valid_gecos(const char *d
) {
581 if (!utf8_is_valid(d
))
584 if (string_has_cc(d
, NULL
))
587 /* Colons are used as field separators, and hence not OK */
594 bool valid_home(const char *p
) {
599 if (!utf8_is_valid(p
))
602 if (string_has_cc(p
, NULL
))
605 if (!path_is_absolute(p
))
608 if (!path_is_safe(p
))
611 /* Colons are used as field separators, and hence not OK */
618 int maybe_setgroups(size_t size
, const gid_t
*list
) {
621 /* Check if setgroups is allowed before we try to drop all the auxiliary groups */
622 if (size
== 0) { /* Dropping all aux groups? */
623 _cleanup_free_
char *setgroups_content
= NULL
;
626 r
= read_one_line_file("/proc/self/setgroups", &setgroups_content
);
628 /* Old kernels don't have /proc/self/setgroups, so assume we can use setgroups */
629 can_setgroups
= true;
633 can_setgroups
= streq(setgroups_content
, "allow");
635 if (!can_setgroups
) {
636 log_debug("Skipping setgroups(), /proc/self/setgroups is set to 'deny'");
641 if (setgroups(size
, list
) < 0)