uidswap.c

   1 /* $OpenBSD: uidswap.c,v 1.29 2006/06/08 14:45:49 markus Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * Code for uid-swapping.
   7  *
   8  * As far as I am concerned, the code I have written for this software
   9  * can be used freely for any purpose.  Any derived versions of this
  10  * software must be clearly marked as such, and if the derived work is
  11  * incompatible with the protocol description in the RFC file, it must be
  12  * called by a name other than "ssh" or "Secure Shell".
  13  */
  14
  15 #include "includes.h"
  16
  17 #include <grp.h>
  18
  19 #include "log.h"
  20 #include "uidswap.h"
  21 #include "xmalloc.h"
  22
  23 /*
  24  * Note: all these functions must work in all of the following cases:
  25  *    1. euid=0, ruid=0
  26  *    2. euid=0, ruid!=0
  27  *    3. euid!=0, ruid!=0
  28  * Additionally, they must work regardless of whether the system has
  29  * POSIX saved uids or not.
  30  */
  31
  32 #if defined(_POSIX_SAVED_IDS) && !defined(BROKEN_SAVED_UIDS)
  33 /* Lets assume that posix saved ids also work with seteuid, even though that
  34    is not part of the posix specification. */
  35 #define SAVED_IDS_WORK_WITH_SETEUID
  36 /* Saved effective uid. */
  37 static uid_t    saved_euid = 0;
  38 static gid_t    saved_egid = 0;
  39 #endif
  40
  41 /* Saved effective uid. */
  42 static int      privileged = 0;
  43 static int      temporarily_use_uid_effective = 0;
  44 static gid_t    *saved_egroups = NULL, *user_groups = NULL;
  45 static int      saved_egroupslen = -1, user_groupslen = -1;
  46
  47 /*
  48  * Temporarily changes to the given uid.  If the effective user
  49  * id is not root, this does nothing.  This call cannot be nested.
  50  */
  51 void
  52 temporarily_use_uid(struct passwd *pw)
  53 {
  54         /* Save the current euid, and egroups. */
  55 #ifdef SAVED_IDS_WORK_WITH_SETEUID
  56         saved_euid = geteuid();
  57         saved_egid = getegid();
  58         debug("temporarily_use_uid: %u/%u (e=%u/%u)",
  59             (u_int)pw->pw_uid, (u_int)pw->pw_gid,
  60             (u_int)saved_euid, (u_int)saved_egid);
  61 #ifndef HAVE_CYGWIN
  62         if (saved_euid != 0) {
  63                 privileged = 0;
  64                 return;
  65         }
  66 #endif
  67 #else
  68         if (geteuid() != 0) {
  69                 privileged = 0;
  70                 return;
  71         }
  72 #endif /* SAVED_IDS_WORK_WITH_SETEUID */
  73
  74         privileged = 1;
  75         temporarily_use_uid_effective = 1;
  76
  77         saved_egroupslen = getgroups(0, NULL);
  78         if (saved_egroupslen < 0)
  79                 fatal("getgroups: %.100s", strerror(errno));
  80         if (saved_egroupslen > 0) {
  81                 saved_egroups = xrealloc(saved_egroups,
  82                     saved_egroupslen, sizeof(gid_t));
  83                 if (getgroups(saved_egroupslen, saved_egroups) < 0)
  84                         fatal("getgroups: %.100s", strerror(errno));
  85         } else { /* saved_egroupslen == 0 */
  86                 if (saved_egroups != NULL)
  87                         xfree(saved_egroups);
  88         }
  89
  90         /* set and save the user's groups */
  91         if (user_groupslen == -1) {
  92                 if (initgroups(pw->pw_name, pw->pw_gid) < 0)
  93                         fatal("initgroups: %s: %.100s", pw->pw_name,
  94                             strerror(errno));
  95
  96                 user_groupslen = getgroups(0, NULL);
  97                 if (user_groupslen < 0)
  98                         fatal("getgroups: %.100s", strerror(errno));
  99                 if (user_groupslen > 0) {
 100                         user_groups = xrealloc(user_groups,
 101                             user_groupslen, sizeof(gid_t));
 102                         if (getgroups(user_groupslen, user_groups) < 0)
 103                                 fatal("getgroups: %.100s", strerror(errno));
 104                 } else { /* user_groupslen == 0 */
 105                         if (user_groups)
 106                                 xfree(user_groups);
 107                 }
 108         }
 109         /* Set the effective uid to the given (unprivileged) uid. */
 110         if (setgroups(user_groupslen, user_groups) < 0)
 111                 fatal("setgroups: %.100s", strerror(errno));
 112 #ifndef SAVED_IDS_WORK_WITH_SETEUID
 113         /* Propagate the privileged gid to all of our gids. */
 114         if (setgid(getegid()) < 0)
 115                 debug("setgid %u: %.100s", (u_int) getegid(), strerror(errno));
 116         /* Propagate the privileged uid to all of our uids. */
 117         if (setuid(geteuid()) < 0)
 118                 debug("setuid %u: %.100s", (u_int) geteuid(), strerror(errno));
 119 #endif /* SAVED_IDS_WORK_WITH_SETEUID */
 120         if (setegid(pw->pw_gid) < 0)
 121                 fatal("setegid %u: %.100s", (u_int)pw->pw_gid,
 122                     strerror(errno));
 123         if (seteuid(pw->pw_uid) == -1)
 124                 fatal("seteuid %u: %.100s", (u_int)pw->pw_uid,
 125                     strerror(errno));
 126 }
 127
 128 void
 129 permanently_drop_suid(uid_t uid)
 130 {
 131         uid_t old_uid = getuid();
 132
 133         debug("permanently_drop_suid: %u", (u_int)uid);
 134 #if defined(HAVE_SETRESUID) && !defined(BROKEN_SETRESUID)
 135         if (setresuid(uid, uid, uid) < 0)
 136                 fatal("setresuid %u: %.100s", (u_int)uid, strerror(errno));
 137 #elif defined(HAVE_SETREUID) && !defined(BROKEN_SETREUID)
 138         if (setreuid(uid, uid) < 0)
 139                 fatal("setreuid %u: %.100s", (u_int)uid, strerror(errno));
 140 #else
 141 # ifndef SETEUID_BREAKS_SETUID
 142         if (seteuid(uid) < 0)
 143                 fatal("seteuid %u: %.100s", (u_int)uid, strerror(errno));
 144 # endif
 145         if (setuid(uid) < 0)
 146                 fatal("setuid %u: %.100s", (u_int)uid, strerror(errno));
 147 #endif
 148
 149 #ifndef HAVE_CYGWIN
 150         /* Try restoration of UID if changed (test clearing of saved uid) */
 151         if (old_uid != uid &&
 152             (setuid(old_uid) != -1 || seteuid(old_uid) != -1))
 153                 fatal("%s: was able to restore old [e]uid", __func__);
 154 #endif
 155
 156         /* Verify UID drop was successful */
 157         if (getuid() != uid || geteuid() != uid) {
 158                 fatal("%s: euid incorrect uid:%u euid:%u (should be %u)",
 159                     __func__, (u_int)getuid(), (u_int)geteuid(), (u_int)uid);
 160         }
 161 }
 162
 163 /*
 164  * Restores to the original (privileged) uid.
 165  */
 166 void
 167 restore_uid(void)
 168 {
 169         /* it's a no-op unless privileged */
 170         if (!privileged) {
 171                 debug("restore_uid: (unprivileged)");
 172                 return;
 173         }
 174         if (!temporarily_use_uid_effective)
 175                 fatal("restore_uid: temporarily_use_uid not effective");
 176
 177 #ifdef SAVED_IDS_WORK_WITH_SETEUID
 178         debug("restore_uid: %u/%u", (u_int)saved_euid, (u_int)saved_egid);
 179         /* Set the effective uid back to the saved privileged uid. */
 180         if (seteuid(saved_euid) < 0)
 181                 fatal("seteuid %u: %.100s", (u_int)saved_euid, strerror(errno));
 182         if (setegid(saved_egid) < 0)
 183                 fatal("setegid %u: %.100s", (u_int)saved_egid, strerror(errno));
 184 #else /* SAVED_IDS_WORK_WITH_SETEUID */
 185         /*
 186          * We are unable to restore the real uid to its unprivileged value.
 187          * Propagate the real uid (usually more privileged) to effective uid
 188          * as well.
 189          */
 190         setuid(getuid());
 191         setgid(getgid());
 192 #endif /* SAVED_IDS_WORK_WITH_SETEUID */
 193
 194         if (setgroups(saved_egroupslen, saved_egroups) < 0)
 195                 fatal("setgroups: %.100s", strerror(errno));
 196         temporarily_use_uid_effective = 0;
 197 }
 198
 199 /*
 200  * Permanently sets all uids to the given uid.  This cannot be
 201  * called while temporarily_use_uid is effective.
 202  */
 203 void
 204 permanently_set_uid(struct passwd *pw)
 205 {
 206         uid_t old_uid = getuid();
 207         gid_t old_gid = getgid();
 208
 209         if (pw == NULL)
 210                 fatal("permanently_set_uid: no user given");
 211         if (temporarily_use_uid_effective)
 212                 fatal("permanently_set_uid: temporarily_use_uid effective");
 213         debug("permanently_set_uid: %u/%u", (u_int)pw->pw_uid,
 214             (u_int)pw->pw_gid);
 215
 216 #if defined(HAVE_SETRESGID) && !defined(BROKEN_SETRESGID)
 217         if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) < 0)
 218                 fatal("setresgid %u: %.100s", (u_int)pw->pw_gid, strerror(errno));
 219 #elif defined(HAVE_SETREGID) && !defined(BROKEN_SETREGID)
 220         if (setregid(pw->pw_gid, pw->pw_gid) < 0)
 221                 fatal("setregid %u: %.100s", (u_int)pw->pw_gid, strerror(errno));
 222 #else
 223         if (setegid(pw->pw_gid) < 0)
 224                 fatal("setegid %u: %.100s", (u_int)pw->pw_gid, strerror(errno));
 225         if (setgid(pw->pw_gid) < 0)
 226                 fatal("setgid %u: %.100s", (u_int)pw->pw_gid, strerror(errno));
 227 #endif
 228
 229 #if defined(HAVE_SETRESUID) && !defined(BROKEN_SETRESUID)
 230         if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) < 0)
 231                 fatal("setresuid %u: %.100s", (u_int)pw->pw_uid, strerror(errno));
 232 #elif defined(HAVE_SETREUID) && !defined(BROKEN_SETREUID)
 233         if (setreuid(pw->pw_uid, pw->pw_uid) < 0)
 234                 fatal("setreuid %u: %.100s", (u_int)pw->pw_uid, strerror(errno));
 235 #else
 236 # ifndef SETEUID_BREAKS_SETUID
 237         if (seteuid(pw->pw_uid) < 0)
 238                 fatal("seteuid %u: %.100s", (u_int)pw->pw_uid, strerror(errno));
 239 # endif
 240         if (setuid(pw->pw_uid) < 0)
 241                 fatal("setuid %u: %.100s", (u_int)pw->pw_uid, strerror(errno));
 242 #endif
 243
 244 #ifndef HAVE_CYGWIN
 245         /* Try restoration of GID if changed (test clearing of saved gid) */
 246         if (old_gid != pw->pw_gid && pw->pw_uid != 0 &&
 247             (setgid(old_gid) != -1 || setegid(old_gid) != -1))
 248                 fatal("%s: was able to restore old [e]gid", __func__);
 249 #endif
 250
 251         /* Verify GID drop was successful */
 252         if (getgid() != pw->pw_gid || getegid() != pw->pw_gid) {
 253                 fatal("%s: egid incorrect gid:%u egid:%u (should be %u)",
 254                     __func__, (u_int)getgid(), (u_int)getegid(),
 255                     (u_int)pw->pw_gid);
 256         }
 257
 258 #ifndef HAVE_CYGWIN
 259         /* Try restoration of UID if changed (test clearing of saved uid) */
 260         if (old_uid != pw->pw_uid &&
 261             (setuid(old_uid) != -1 || seteuid(old_uid) != -1))
 262                 fatal("%s: was able to restore old [e]uid", __func__);
 263 #endif
 264
 265         /* Verify UID drop was successful */
 266         if (getuid() != pw->pw_uid || geteuid() != pw->pw_uid) {
 267                 fatal("%s: euid incorrect uid:%u euid:%u (should be %u)",
 268                     __func__, (u_int)getuid(), (u_int)geteuid(),
 269                     (u_int)pw->pw_uid);
 270         }
 271 }