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 #if 0 /// UNNEEDED by elogind
98 char *getusername_malloc(void) {
105 return uid_to_name(getuid());
110 const char **username,
111 uid_t *uid, gid_t *gid,
113 const char **shell) {
121 /* We enforce some special rules for uid=0: in order to avoid
122 * NSS lookups for root we hardcode its data. */
124 if (streq(*username, "root") || streq(*username, "0")) {
142 if (parse_uid(*username, &u) >= 0) {
146 /* If there are multiple users with the same id, make
147 * sure to leave $USER to the configured value instead
148 * of the first occurrence in the database. However if
149 * the uid was configured by a numeric uid, then let's
150 * pick the real username from /etc/passwd. */
152 *username = p->pw_name;
155 p = getpwnam(*username);
159 return errno > 0 ? -errno : -ESRCH;
162 if (!uid_is_valid(p->pw_uid))
169 if (!gid_is_valid(p->pw_gid))
179 *shell = p->pw_shell;
184 #if 0 /// UNNEEDED by elogind
185 int get_user_creds_clean(
186 const char **username,
187 uid_t *uid, gid_t *gid,
189 const char **shell) {
193 /* Like get_user_creds(), but resets home/shell to NULL if they don't contain anything relevant. */
195 r = get_user_creds(username, uid, gid, home, shell);
200 (isempty(*shell) || PATH_IN_SET(*shell,
204 "/usr/sbin/nologin")))
208 (isempty(*home) || path_equal(*home, "/")))
214 int get_group_creds(const char **groupname, gid_t *gid) {
220 /* We enforce some special rules for gid=0: in order to avoid
221 * NSS lookups for root we hardcode its data. */
223 if (streq(*groupname, "root") || streq(*groupname, "0")) {
232 if (parse_gid(*groupname, &id) >= 0) {
237 *groupname = g->gr_name;
240 g = getgrnam(*groupname);
244 return errno > 0 ? -errno : -ESRCH;
247 if (!gid_is_valid(g->gr_gid))
257 char* uid_to_name(uid_t uid) {
261 /* Shortcut things to avoid NSS lookups */
263 return strdup("root");
265 if (uid_is_valid(uid)) {
268 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
273 struct passwd pwbuf, *pw = NULL;
274 _cleanup_free_ char *buf = NULL;
276 buf = malloc(bufsize);
280 r = getpwuid_r(uid, &pwbuf, buf, (size_t) bufsize, &pw);
282 return strdup(pw->pw_name);
290 if (asprintf(&ret, UID_FMT, uid) < 0)
296 char* gid_to_name(gid_t gid) {
301 return strdup("root");
303 if (gid_is_valid(gid)) {
306 bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
311 struct group grbuf, *gr = NULL;
312 _cleanup_free_ char *buf = NULL;
314 buf = malloc(bufsize);
318 r = getgrgid_r(gid, &grbuf, buf, (size_t) bufsize, &gr);
320 return strdup(gr->gr_name);
328 if (asprintf(&ret, GID_FMT, gid) < 0)
334 #if 0 /// UNNEEDED by elogind
335 int in_gid(gid_t gid) {
337 int ngroups_max, r, i;
342 if (getegid() == gid)
345 if (!gid_is_valid(gid))
348 ngroups_max = sysconf(_SC_NGROUPS_MAX);
349 assert(ngroups_max > 0);
351 gids = alloca(sizeof(gid_t) * ngroups_max);
353 r = getgroups(ngroups_max, gids);
357 for (i = 0; i < r; i++)
364 int in_group(const char *name) {
368 r = get_group_creds(&name, &gid);
375 int get_home_dir(char **_h) {
383 /* Take the user specified one */
384 e = secure_getenv("HOME");
385 if (e && path_is_absolute(e)) {
394 /* Hardcode home directory for root to avoid NSS */
405 /* Check the database... */
409 return errno > 0 ? -errno : -ESRCH;
411 if (!path_is_absolute(p->pw_dir))
414 h = strdup(p->pw_dir);
422 int get_shell(char **_s) {
430 /* Take the user specified one */
441 /* Hardcode home directory for root to avoid NSS */
444 s = strdup("/bin/sh");
452 /* Check the database... */
456 return errno > 0 ? -errno : -ESRCH;
458 if (!path_is_absolute(p->pw_shell))
461 s = strdup(p->pw_shell);
470 int reset_uid_gid(void) {
473 r = maybe_setgroups(0, NULL);
477 if (setresgid(0, 0, 0) < 0)
480 if (setresuid(0, 0, 0) < 0)
486 #if 0 /// UNNEEDED by elogind
487 int take_etc_passwd_lock(const char *root) {
489 struct flock flock = {
491 .l_whence = SEEK_SET,
499 /* This is roughly the same as lckpwdf(), but not as awful. We
500 * don't want to use alarm() and signals, hence we implement
501 * our own trivial version of this.
503 * Note that shadow-utils also takes per-database locks in
504 * addition to lckpwdf(). However, we don't given that they
505 * are redundant as they invoke lckpwdf() first and keep
506 * it during everything they do. The per-database locks are
507 * awfully racy, and thus we just won't do them. */
510 path = prefix_roota(root, "/etc/.pwd.lock");
512 path = "/etc/.pwd.lock";
514 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
518 r = fcntl(fd, F_SETLKW, &flock);
528 bool valid_user_group_name(const char *u) {
532 /* Checks if the specified name is a valid user/group name. Also see POSIX IEEE Std 1003.1-2008, 2016 Edition,
533 * 3.437. We are a bit stricter here however. Specifically we deviate from POSIX rules:
535 * - We don't allow any dots (this would break chown syntax which permits dots as user/group name separator)
536 * - We require that names fit into the appropriate utmp field
537 * - We don't allow empty user names
539 * Note that other systems are even more restrictive, and don't permit underscores or uppercase characters.
545 if (!(u[0] >= 'a' && u[0] <= 'z') &&
546 !(u[0] >= 'A' && u[0] <= 'Z') &&
550 for (i = u+1; *i; i++) {
551 if (!(*i >= 'a' && *i <= 'z') &&
552 !(*i >= 'A' && *i <= 'Z') &&
553 !(*i >= '0' && *i <= '9') &&
559 sz = sysconf(_SC_LOGIN_NAME_MAX);
562 if ((size_t) (i-u) > (size_t) sz)
565 if ((size_t) (i-u) > UT_NAMESIZE - 1)
571 bool valid_user_group_name_or_id(const char *u) {
573 /* Similar as above, but is also fine with numeric UID/GID specifications, as long as they are in the right
574 * range, and not the invalid user ids. */
579 if (valid_user_group_name(u))
582 return parse_uid(u, NULL) >= 0;
585 bool valid_gecos(const char *d) {
590 if (!utf8_is_valid(d))
593 if (string_has_cc(d, NULL))
596 /* Colons are used as field separators, and hence not OK */
603 bool valid_home(const char *p) {
608 if (!utf8_is_valid(p))
611 if (string_has_cc(p, NULL))
614 if (!path_is_absolute(p))
617 if (!path_is_safe(p))
620 /* Colons are used as field separators, and hence not OK */
627 int maybe_setgroups(size_t size, const gid_t *list) {
630 /* Check if setgroups is allowed before we try to drop all the auxiliary groups */
631 if (size == 0) { /* Dropping all aux groups? */
632 _cleanup_free_ char *setgroups_content = NULL;
635 r = read_one_line_file("/proc/self/setgroups", &setgroups_content);
637 /* Old kernels don't have /proc/self/setgroups, so assume we can use setgroups */
638 can_setgroups = true;
642 can_setgroups = streq(setgroups_content, "allow");
644 if (!can_setgroups) {
645 log_debug("Skipping setgroups(), /proc/self/setgroups is set to 'deny'");
650 if (setgroups(size, list) < 0)