2015-10-25 22:32:30 +01:00
|
|
|
/***
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
2015-11-30 21:43:37 +01:00
|
|
|
#include <alloca.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
2015-10-25 22:32:30 +01:00
|
|
|
#include <grp.h>
|
2015-11-16 22:09:36 +01:00
|
|
|
#include <pwd.h>
|
2015-11-30 21:43:37 +01:00
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2016-07-14 12:23:39 +02:00
|
|
|
#include <utmp.h>
|
2015-10-25 22:32:30 +01:00
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2015-10-26 19:08:09 +01:00
|
|
|
#include "fd-util.h"
|
2016-09-28 18:37:39 +02:00
|
|
|
#include "fileio.h"
|
2016-11-07 16:14:59 +01:00
|
|
|
#include "format-util.h"
|
2015-10-25 22:32:30 +01:00
|
|
|
#include "macro.h"
|
2016-08-25 10:24:10 +02:00
|
|
|
#include "missing.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2015-10-25 22:32:30 +01:00
|
|
|
#include "path-util.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "string-util.h"
|
2016-08-25 10:24:10 +02:00
|
|
|
#include "strv.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "user-util.h"
|
2016-07-14 12:23:39 +02:00
|
|
|
#include "utf8.h"
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
bool uid_is_valid(uid_t uid) {
|
|
|
|
|
|
|
|
/* Some libc APIs use UID_INVALID as special placeholder */
|
2015-10-25 22:37:43 +01:00
|
|
|
if (uid == (uid_t) UINT32_C(0xFFFFFFFF))
|
2015-10-25 22:32:30 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
/* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
|
2015-10-25 22:37:43 +01:00
|
|
|
if (uid == (uid_t) UINT32_C(0xFFFF))
|
2015-10-25 22:32:30 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-25 22:37:43 +01:00
|
|
|
int parse_uid(const char *s, uid_t *ret) {
|
|
|
|
uint32_t uid = 0;
|
2015-10-25 22:32:30 +01:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(s);
|
|
|
|
|
2015-10-25 22:37:43 +01:00
|
|
|
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
|
|
|
|
r = safe_atou32(s, &uid);
|
2015-10-25 22:32:30 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (!uid_is_valid(uid))
|
|
|
|
return -ENXIO; /* we return ENXIO instead of EINVAL
|
|
|
|
* here, to make it easy to distuingish
|
2015-12-25 22:29:09 +01:00
|
|
|
* invalid numeric uids from invalid
|
2015-10-25 22:32:30 +01:00
|
|
|
* strings. */
|
|
|
|
|
2015-10-25 22:37:43 +01:00
|
|
|
if (ret)
|
|
|
|
*ret = uid;
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
char* getlogname_malloc(void) {
|
|
|
|
uid_t uid;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
|
|
|
|
uid = st.st_uid;
|
|
|
|
else
|
|
|
|
uid = getuid();
|
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
return uid_to_name(uid);
|
2015-10-25 22:32:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char *getusername_malloc(void) {
|
|
|
|
const char *e;
|
|
|
|
|
|
|
|
e = getenv("USER");
|
|
|
|
if (e)
|
|
|
|
return strdup(e);
|
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
return uid_to_name(getuid());
|
2015-10-25 22:32:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int get_user_creds(
|
|
|
|
const char **username,
|
|
|
|
uid_t *uid, gid_t *gid,
|
|
|
|
const char **home,
|
|
|
|
const char **shell) {
|
|
|
|
|
|
|
|
struct passwd *p;
|
|
|
|
uid_t u;
|
|
|
|
|
|
|
|
assert(username);
|
|
|
|
assert(*username);
|
|
|
|
|
|
|
|
/* We enforce some special rules for uid=0: in order to avoid
|
|
|
|
* NSS lookups for root we hardcode its data. */
|
|
|
|
|
|
|
|
if (streq(*username, "root") || streq(*username, "0")) {
|
|
|
|
*username = "root";
|
|
|
|
|
|
|
|
if (uid)
|
|
|
|
*uid = 0;
|
|
|
|
|
|
|
|
if (gid)
|
|
|
|
*gid = 0;
|
|
|
|
|
|
|
|
if (home)
|
|
|
|
*home = "/root";
|
|
|
|
|
|
|
|
if (shell)
|
|
|
|
*shell = "/bin/sh";
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parse_uid(*username, &u) >= 0) {
|
|
|
|
errno = 0;
|
|
|
|
p = getpwuid(u);
|
|
|
|
|
|
|
|
/* If there are multiple users with the same id, make
|
|
|
|
* sure to leave $USER to the configured value instead
|
|
|
|
* of the first occurrence in the database. However if
|
|
|
|
* the uid was configured by a numeric uid, then let's
|
|
|
|
* pick the real username from /etc/passwd. */
|
|
|
|
if (p)
|
|
|
|
*username = p->pw_name;
|
|
|
|
} else {
|
|
|
|
errno = 0;
|
|
|
|
p = getpwnam(*username);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!p)
|
|
|
|
return errno > 0 ? -errno : -ESRCH;
|
|
|
|
|
2015-10-26 00:38:21 +01:00
|
|
|
if (uid) {
|
|
|
|
if (!uid_is_valid(p->pw_uid))
|
|
|
|
return -EBADMSG;
|
|
|
|
|
2015-10-25 22:32:30 +01:00
|
|
|
*uid = p->pw_uid;
|
2015-10-26 00:38:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (gid) {
|
|
|
|
if (!gid_is_valid(p->pw_gid))
|
|
|
|
return -EBADMSG;
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
*gid = p->pw_gid;
|
2015-10-26 00:38:21 +01:00
|
|
|
}
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
if (home)
|
|
|
|
*home = p->pw_dir;
|
|
|
|
|
|
|
|
if (shell)
|
|
|
|
*shell = p->pw_shell;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-08-25 10:24:10 +02:00
|
|
|
int get_user_creds_clean(
|
|
|
|
const char **username,
|
|
|
|
uid_t *uid, gid_t *gid,
|
|
|
|
const char **home,
|
|
|
|
const char **shell) {
|
|
|
|
|
|
|
|
int r;
|
|
|
|
|
|
|
|
/* Like get_user_creds(), but resets home/shell to NULL if they don't contain anything relevant. */
|
|
|
|
|
|
|
|
r = get_user_creds(username, uid, gid, home, shell);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (shell &&
|
|
|
|
(isempty(*shell) || PATH_IN_SET(*shell,
|
|
|
|
"/bin/nologin",
|
|
|
|
"/sbin/nologin",
|
|
|
|
"/usr/bin/nologin",
|
|
|
|
"/usr/sbin/nologin")))
|
|
|
|
*shell = NULL;
|
|
|
|
|
|
|
|
if (home &&
|
|
|
|
(isempty(*home) || path_equal(*home, "/")))
|
|
|
|
*home = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-25 22:32:30 +01:00
|
|
|
int get_group_creds(const char **groupname, gid_t *gid) {
|
|
|
|
struct group *g;
|
|
|
|
gid_t id;
|
|
|
|
|
|
|
|
assert(groupname);
|
|
|
|
|
|
|
|
/* We enforce some special rules for gid=0: in order to avoid
|
|
|
|
* NSS lookups for root we hardcode its data. */
|
|
|
|
|
|
|
|
if (streq(*groupname, "root") || streq(*groupname, "0")) {
|
|
|
|
*groupname = "root";
|
|
|
|
|
|
|
|
if (gid)
|
|
|
|
*gid = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parse_gid(*groupname, &id) >= 0) {
|
|
|
|
errno = 0;
|
|
|
|
g = getgrgid(id);
|
|
|
|
|
|
|
|
if (g)
|
|
|
|
*groupname = g->gr_name;
|
|
|
|
} else {
|
|
|
|
errno = 0;
|
|
|
|
g = getgrnam(*groupname);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!g)
|
|
|
|
return errno > 0 ? -errno : -ESRCH;
|
|
|
|
|
2015-10-26 00:38:21 +01:00
|
|
|
if (gid) {
|
|
|
|
if (!gid_is_valid(g->gr_gid))
|
|
|
|
return -EBADMSG;
|
|
|
|
|
2015-10-25 22:32:30 +01:00
|
|
|
*gid = g->gr_gid;
|
2015-10-26 00:38:21 +01:00
|
|
|
}
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
char* uid_to_name(uid_t uid) {
|
2015-10-25 23:20:05 +01:00
|
|
|
char *ret;
|
|
|
|
int r;
|
2015-10-25 22:32:30 +01:00
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
/* Shortcut things to avoid NSS lookups */
|
2015-10-25 22:32:30 +01:00
|
|
|
if (uid == 0)
|
|
|
|
return strdup("root");
|
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
if (uid_is_valid(uid)) {
|
|
|
|
long bufsize;
|
|
|
|
|
|
|
|
bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
|
|
|
|
if (bufsize <= 0)
|
|
|
|
bufsize = 4096;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct passwd pwbuf, *pw = NULL;
|
|
|
|
_cleanup_free_ char *buf = NULL;
|
|
|
|
|
|
|
|
buf = malloc(bufsize);
|
|
|
|
if (!buf)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
r = getpwuid_r(uid, &pwbuf, buf, (size_t) bufsize, &pw);
|
|
|
|
if (r == 0 && pw)
|
|
|
|
return strdup(pw->pw_name);
|
|
|
|
if (r != ERANGE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bufsize *= 2;
|
|
|
|
}
|
|
|
|
}
|
2015-10-25 22:32:30 +01:00
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
if (asprintf(&ret, UID_FMT, uid) < 0)
|
2015-10-25 22:32:30 +01:00
|
|
|
return NULL;
|
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
return ret;
|
2015-10-25 22:32:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char* gid_to_name(gid_t gid) {
|
2015-10-25 23:20:05 +01:00
|
|
|
char *ret;
|
|
|
|
int r;
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
if (gid == 0)
|
|
|
|
return strdup("root");
|
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
if (gid_is_valid(gid)) {
|
|
|
|
long bufsize;
|
|
|
|
|
|
|
|
bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
|
|
|
|
if (bufsize <= 0)
|
|
|
|
bufsize = 4096;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct group grbuf, *gr = NULL;
|
|
|
|
_cleanup_free_ char *buf = NULL;
|
|
|
|
|
|
|
|
buf = malloc(bufsize);
|
|
|
|
if (!buf)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
r = getgrgid_r(gid, &grbuf, buf, (size_t) bufsize, &gr);
|
|
|
|
if (r == 0 && gr)
|
|
|
|
return strdup(gr->gr_name);
|
|
|
|
if (r != ERANGE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bufsize *= 2;
|
|
|
|
}
|
|
|
|
}
|
2015-10-25 22:32:30 +01:00
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
if (asprintf(&ret, GID_FMT, gid) < 0)
|
2015-10-25 22:32:30 +01:00
|
|
|
return NULL;
|
|
|
|
|
2015-10-25 23:20:05 +01:00
|
|
|
return ret;
|
2015-10-25 22:32:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int in_gid(gid_t gid) {
|
|
|
|
gid_t *gids;
|
|
|
|
int ngroups_max, r, i;
|
|
|
|
|
|
|
|
if (getgid() == gid)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (getegid() == gid)
|
|
|
|
return 1;
|
|
|
|
|
2015-10-26 00:38:21 +01:00
|
|
|
if (!gid_is_valid(gid))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-10-25 22:32:30 +01:00
|
|
|
ngroups_max = sysconf(_SC_NGROUPS_MAX);
|
|
|
|
assert(ngroups_max > 0);
|
|
|
|
|
|
|
|
gids = alloca(sizeof(gid_t) * ngroups_max);
|
|
|
|
|
|
|
|
r = getgroups(ngroups_max, gids);
|
|
|
|
if (r < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
for (i = 0; i < r; i++)
|
|
|
|
if (gids[i] == gid)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int in_group(const char *name) {
|
|
|
|
int r;
|
|
|
|
gid_t gid;
|
|
|
|
|
|
|
|
r = get_group_creds(&name, &gid);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return in_gid(gid);
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_home_dir(char **_h) {
|
|
|
|
struct passwd *p;
|
|
|
|
const char *e;
|
|
|
|
char *h;
|
|
|
|
uid_t u;
|
|
|
|
|
|
|
|
assert(_h);
|
|
|
|
|
|
|
|
/* Take the user specified one */
|
|
|
|
e = secure_getenv("HOME");
|
|
|
|
if (e && path_is_absolute(e)) {
|
|
|
|
h = strdup(e);
|
|
|
|
if (!h)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*_h = h;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hardcode home directory for root to avoid NSS */
|
|
|
|
u = getuid();
|
|
|
|
if (u == 0) {
|
|
|
|
h = strdup("/root");
|
|
|
|
if (!h)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*_h = h;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the database... */
|
|
|
|
errno = 0;
|
|
|
|
p = getpwuid(u);
|
|
|
|
if (!p)
|
|
|
|
return errno > 0 ? -errno : -ESRCH;
|
|
|
|
|
|
|
|
if (!path_is_absolute(p->pw_dir))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
h = strdup(p->pw_dir);
|
|
|
|
if (!h)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*_h = h;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_shell(char **_s) {
|
|
|
|
struct passwd *p;
|
|
|
|
const char *e;
|
|
|
|
char *s;
|
|
|
|
uid_t u;
|
|
|
|
|
|
|
|
assert(_s);
|
|
|
|
|
|
|
|
/* Take the user specified one */
|
|
|
|
e = getenv("SHELL");
|
|
|
|
if (e) {
|
|
|
|
s = strdup(e);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*_s = s;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hardcode home directory for root to avoid NSS */
|
|
|
|
u = getuid();
|
|
|
|
if (u == 0) {
|
|
|
|
s = strdup("/bin/sh");
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*_s = s;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the database... */
|
|
|
|
errno = 0;
|
|
|
|
p = getpwuid(u);
|
|
|
|
if (!p)
|
|
|
|
return errno > 0 ? -errno : -ESRCH;
|
|
|
|
|
|
|
|
if (!path_is_absolute(p->pw_shell))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
s = strdup(p->pw_shell);
|
|
|
|
if (!s)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*_s = s;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int reset_uid_gid(void) {
|
2016-10-06 17:54:12 +02:00
|
|
|
int r;
|
2015-10-25 22:32:30 +01:00
|
|
|
|
2016-10-06 17:54:12 +02:00
|
|
|
r = maybe_setgroups(0, NULL);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2015-10-25 22:32:30 +01:00
|
|
|
|
|
|
|
if (setresgid(0, 0, 0) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
if (setresuid(0, 0, 0) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-10-26 19:08:09 +01:00
|
|
|
|
|
|
|
int take_etc_passwd_lock(const char *root) {
|
|
|
|
|
|
|
|
struct flock flock = {
|
|
|
|
.l_type = F_WRLCK,
|
|
|
|
.l_whence = SEEK_SET,
|
|
|
|
.l_start = 0,
|
|
|
|
.l_len = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *path;
|
|
|
|
int fd, r;
|
|
|
|
|
|
|
|
/* This is roughly the same as lckpwdf(), but not as awful. We
|
|
|
|
* don't want to use alarm() and signals, hence we implement
|
|
|
|
* our own trivial version of this.
|
|
|
|
*
|
|
|
|
* Note that shadow-utils also takes per-database locks in
|
|
|
|
* addition to lckpwdf(). However, we don't given that they
|
2016-07-10 14:48:23 +02:00
|
|
|
* are redundant as they invoke lckpwdf() first and keep
|
2015-10-26 19:08:09 +01:00
|
|
|
* it during everything they do. The per-database locks are
|
|
|
|
* awfully racy, and thus we just won't do them. */
|
|
|
|
|
|
|
|
if (root)
|
|
|
|
path = prefix_roota(root, "/etc/.pwd.lock");
|
|
|
|
else
|
|
|
|
path = "/etc/.pwd.lock";
|
|
|
|
|
|
|
|
fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
|
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
r = fcntl(fd, F_SETLKW, &flock);
|
|
|
|
if (r < 0) {
|
|
|
|
safe_close(fd);
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
2016-07-14 12:23:39 +02:00
|
|
|
|
|
|
|
bool valid_user_group_name(const char *u) {
|
|
|
|
const char *i;
|
|
|
|
long sz;
|
|
|
|
|
|
|
|
/* Checks if the specified name is a valid user/group name. */
|
|
|
|
|
|
|
|
if (isempty(u))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(u[0] >= 'a' && u[0] <= 'z') &&
|
|
|
|
!(u[0] >= 'A' && u[0] <= 'Z') &&
|
|
|
|
u[0] != '_')
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (i = u+1; *i; i++) {
|
|
|
|
if (!(*i >= 'a' && *i <= 'z') &&
|
|
|
|
!(*i >= 'A' && *i <= 'Z') &&
|
|
|
|
!(*i >= '0' && *i <= '9') &&
|
|
|
|
*i != '_' &&
|
|
|
|
*i != '-')
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
sz = sysconf(_SC_LOGIN_NAME_MAX);
|
|
|
|
assert_se(sz > 0);
|
|
|
|
|
|
|
|
if ((size_t) (i-u) > (size_t) sz)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ((size_t) (i-u) > UT_NAMESIZE - 1)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool valid_user_group_name_or_id(const char *u) {
|
|
|
|
|
|
|
|
/* Similar as above, but is also fine with numeric UID/GID specifications, as long as they are in the right
|
|
|
|
* range, and not the invalid user ids. */
|
|
|
|
|
|
|
|
if (isempty(u))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (valid_user_group_name(u))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return parse_uid(u, NULL) >= 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool valid_gecos(const char *d) {
|
|
|
|
|
|
|
|
if (!d)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!utf8_is_valid(d))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (string_has_cc(d, NULL))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Colons are used as field separators, and hence not OK */
|
|
|
|
if (strchr(d, ':'))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool valid_home(const char *p) {
|
|
|
|
|
|
|
|
if (isempty(p))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!utf8_is_valid(p))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (string_has_cc(p, NULL))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!path_is_absolute(p))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!path_is_safe(p))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Colons are used as field separators, and hence not OK */
|
|
|
|
if (strchr(p, ':'))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2016-09-28 18:37:39 +02:00
|
|
|
|
|
|
|
int maybe_setgroups(size_t size, const gid_t *list) {
|
2016-10-06 17:54:12 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
/* Check if setgroups is allowed before we try to drop all the auxiliary groups */
|
|
|
|
if (size == 0) { /* Dropping all aux groups? */
|
|
|
|
_cleanup_free_ char *setgroups_content = NULL;
|
|
|
|
bool can_setgroups;
|
|
|
|
|
|
|
|
r = read_one_line_file("/proc/self/setgroups", &setgroups_content);
|
|
|
|
if (r == -ENOENT)
|
|
|
|
/* Old kernels don't have /proc/self/setgroups, so assume we can use setgroups */
|
|
|
|
can_setgroups = true;
|
|
|
|
else if (r < 0)
|
|
|
|
return r;
|
|
|
|
else
|
|
|
|
can_setgroups = streq(setgroups_content, "allow");
|
|
|
|
|
|
|
|
if (!can_setgroups) {
|
|
|
|
log_debug("Skipping setgroups(), /proc/self/setgroups is set to 'deny'");
|
2016-09-28 18:37:39 +02:00
|
|
|
return 0;
|
2016-10-06 17:54:12 +02:00
|
|
|
}
|
2016-09-28 18:37:39 +02:00
|
|
|
}
|
2016-10-06 17:54:12 +02:00
|
|
|
|
|
|
|
if (setgroups(size, list) < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
return 0;
|
2016-09-28 18:37:39 +02:00
|
|
|
}
|