newgrp.tproj/newgrp.c

   1 /*-
   2  * Copyright (c) 2002 Tim J. Robbins.
   3  * 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 AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * newgrp -- change to a new group
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD: src/usr.bin/newgrp/newgrp.c,v 1.2 2003/10/30 15:14:34 harti Exp $");
  33
  34 #include <sys/types.h>
  35
  36 #include <err.h>
  37 #include <errno.h>
  38 #include <grp.h>
  39 #include <libgen.h>
  40 #include <limits.h>
  41 #ifndef __APPLE__
  42 #include <login_cap.h>
  43 #endif /* !__APPLE__ */
  44 #include <pwd.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49 #ifdef __APPLE__
  50 #include <paths.h>
  51 #endif /* __APPLE__ */
  52 static void      addgroup(const char *grpname);
  53 static void      doshell(void);
  54 static int       inarray(gid_t, const gid_t[], int);
  55 static void      loginshell(void);
  56 static void      restoregrps(void);
  57 static void      usage(void);
  58
  59 static struct passwd *pwd;
  60 static uid_t euid;
  61
  62 extern char **environ;
  63
  64 /* Manipulate effective user ID. */
  65 #define PRIV_START do {                         \
  66                 if (seteuid(euid) < 0)          \
  67                         err(1, "seteuid");      \
  68         } while (0)
  69 #define PRIV_END do {                           \
  70                 if (seteuid(getuid()) < 0)      \
  71                         err(1, "seteuid");      \
  72         } while (0)
  73
  74 int
  75 main(int argc, char *argv[])
  76 {
  77         int ch, login;
  78
  79         euid = geteuid();
  80         if (seteuid(getuid()) < 0)
  81                 err(1, "seteuid");
  82
  83         if ((pwd = getpwuid(getuid())) == NULL)
  84                 errx(1, "unknown user");
  85
  86         login = 0;
  87         while ((ch = getopt(argc, argv, "-l")) != -1) {
  88                 switch (ch) {
  89                 case '-':               /* Obsolescent */
  90                 case 'l':
  91                         login = 1;
  92                         break;
  93                 default:
  94                         usage();
  95                 }
  96         }
  97         argc -= optind;
  98         argv += optind;
  99
 100         switch (argc) {
 101         case 0:
 102                 restoregrps();
 103                 break;
 104         case 1:
 105                 addgroup(*argv);
 106                 break;
 107         default:
 108                 usage();
 109         }
 110
 111         if (seteuid(euid) < 0)
 112                 err(1, "seteuid");
 113         if (setuid(getuid()) < 0)
 114                 err(1, "setuid");
 115
 116         if (login)
 117                 loginshell();
 118         else
 119                 doshell();
 120
 121         /*NOTREACHED*/
 122         exit(1);
 123 }
 124
 125 static void
 126 usage(void)
 127 {
 128
 129         fprintf(stderr, "usage: newgrp [-l] [group]\n");
 130         exit(1);
 131 }
 132
 133 static void
 134 restoregrps(void)
 135 {
 136         int initres, setres;
 137
 138         PRIV_START;
 139         initres = initgroups(pwd->pw_name, pwd->pw_gid);
 140         setres = setgid(pwd->pw_gid);
 141         PRIV_END;
 142
 143         if (initres < 0)
 144                 warn("initgroups");
 145         if (setres < 0)
 146                 warn("setgroups");
 147 }
 148
 149 static void
 150 addgroup(const char *grpname)
 151 {
 152         gid_t grps[NGROUPS_MAX];
 153         long lgid;
 154         int dbmember, i, ngrps;
 155         gid_t egid;
 156         struct group *grp;
 157         char *ep, *pass;
 158         char **p;
 159
 160         egid = getegid();
 161
 162         /* Try it as a group name, then a group id. */
 163         if ((grp = getgrnam(grpname)) == NULL)
 164                 if ((lgid = strtol(grpname, &ep, 10)) <= 0 || *ep != '\0' ||
 165                     (grp = getgrgid((gid_t)lgid)) == NULL ) {
 166                         warnx("%s: bad group name", grpname);
 167                         return;
 168                 }
 169
 170         /*
 171          * If the user is not a member of the requested group and the group
 172          * has a password, prompt and check it.
 173          */
 174         dbmember = 0;
 175         if (pwd->pw_gid == grp->gr_gid)
 176                 dbmember = 1;
 177         for (p = grp->gr_mem; *p != NULL; p++)
 178                 if (strcmp(*p, pwd->pw_name) == 0) {
 179                         dbmember = 1;
 180                         break;
 181                 }
 182         if (!dbmember && *grp->gr_passwd != '\0' && getuid() != 0) {
 183                 pass = getpass("Password:");
 184                 if (pass == NULL ||
 185                     strcmp(grp->gr_passwd, crypt(pass, grp->gr_passwd)) != 0) {
 186                         fprintf(stderr, "Sorry\n");
 187                         return;
 188                 }
 189         }
 190
 191         if ((ngrps = getgroups(NGROUPS_MAX, (gid_t *)grps)) < 0) {
 192                 warn("getgroups");
 193                 return;
 194         }
 195
 196         /* Remove requested gid from supp. list if it exists. */
 197         if (grp->gr_gid != egid && inarray(grp->gr_gid, grps, ngrps)) {
 198                 for (i = 0; i < ngrps; i++)
 199                         if (grps[i] == grp->gr_gid)
 200                                 break;
 201                 ngrps--;
 202                 memmove(&grps[i], &grps[i + 1], (ngrps - i) * sizeof(gid_t));
 203                 PRIV_START;
 204                 if (setgroups(ngrps, (const gid_t *)grps) < 0) {
 205                         PRIV_END;
 206                         warn("setgroups");
 207                         return;
 208                 }
 209                 PRIV_END;
 210         }
 211
 212         PRIV_START;
 213         if (setgid(grp->gr_gid)) {
 214                 PRIV_END;
 215                 warn("setgid");
 216                 return;
 217         }
 218         PRIV_END;
 219         grps[0] = grp->gr_gid;
 220
 221         /* Add old effective gid to supp. list if it does not exist. */
 222         if (egid != grp->gr_gid && !inarray(egid, grps, ngrps)) {
 223                 if (ngrps == NGROUPS_MAX)
 224                         warnx("too many groups");
 225                 else {
 226                         grps[ngrps++] = egid;
 227                         PRIV_START;
 228                         if (setgroups(ngrps, (const gid_t *)grps)) {
 229                                 PRIV_END;
 230                                 warn("setgroups");
 231                                 return;
 232                         }
 233                         PRIV_END;
 234                 }
 235         }
 236
 237 }
 238
 239 static int
 240 inarray(gid_t gid, const gid_t grps[], int ngrps)
 241 {
 242         int i;
 243
 244         for (i = 0; i < ngrps; i++)
 245                 if (grps[i] == gid)
 246                         return (1);
 247         return (0);
 248 }
 249
 250 /*
 251  * Set the environment to what would be expected if the user logged in
 252  * again; this performs the same steps as su(1)'s -l option.
 253  */
 254 static void
 255 loginshell(void)
 256 {
 257         char *args[2], **cleanenv, *term, *ticket;
 258         const char *shell;
 259 #ifndef __APPLE__
 260         login_cap_t *lc;
 261 #endif /* !__APPLE__ */
 262         shell = pwd->pw_shell;
 263         if (*shell == '\0')
 264                 shell = _PATH_BSHELL;
 265         if (chdir(pwd->pw_dir) < 0) {
 266                 warn("%s", pwd->pw_dir);
 267                 chdir("/");
 268         }
 269
 270         term = getenv("TERM");
 271         ticket = getenv("KRBTKFILE");
 272
 273         if ((cleanenv = calloc(20, sizeof(char *))) == NULL)
 274                 err(1, "calloc");
 275         *cleanenv = NULL;
 276         environ = cleanenv;
 277 #ifndef __APPLE__
 278         lc = login_getpwclass(pwd);
 279         setusercontext(lc, pwd, pwd->pw_uid,
 280             LOGIN_SETPATH|LOGIN_SETUMASK|LOGIN_SETENV);
 281         login_close(lc);
 282 #endif /* !__APPLE__ */
 283         setenv("USER", pwd->pw_name, 1);
 284         setenv("SHELL", shell, 1);
 285         setenv("HOME", pwd->pw_dir, 1);
 286         if (term != NULL)
 287                 setenv("TERM", term, 1);
 288         if (ticket != NULL)
 289                 setenv("KRBTKFILE", ticket, 1);
 290
 291         if (asprintf(args, "-%s", basename(shell)) < 0)
 292                 err(1, "asprintf");
 293         args[1] = NULL;
 294
 295         execv(shell, args);
 296         err(1, "%s", shell);
 297 }
 298
 299 static void
 300 doshell(void)
 301 {
 302         const char *shell;
 303
 304         shell = pwd->pw_shell;
 305         if (*shell == '\0')
 306                 shell = _PATH_BSHELL;
 307         execl(shell, basename(shell), (char *)NULL);
 308         err(1, "%s", shell);
 309 }