Annotation of embedaddon/sudo/plugins/sudoers/set_perms.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (c) 1994-1996,1998-2011 Todd C. Miller <Todd.Miller@courtesan.com>
3: *
4: * Permission to use, copy, modify, and distribute this software for any
5: * purpose with or without fee is hereby granted, provided that the above
6: * copyright notice and this permission notice appear in all copies.
7: *
8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15: *
16: * Sponsored in part by the Defense Advanced Research Projects
17: * Agency (DARPA) and Air Force Research Laboratory, Air Force
18: * Materiel Command, USAF, under agreement number F39502-99-1-0512.
19: */
20:
21: #include <config.h>
22:
23: #include <sys/types.h>
24: #include <sys/param.h>
25: #include <sys/stat.h>
26: #include <stdio.h>
27: #ifdef STDC_HEADERS
28: # include <stdlib.h>
29: # include <stddef.h>
30: #else
31: # ifdef HAVE_STDLIB_H
32: # include <stdlib.h>
33: # endif
34: #endif /* STDC_HEADERS */
35: #ifdef HAVE_STRING_H
36: # include <string.h>
37: #endif /* HAVE_STRING_H */
38: #ifdef HAVE_STRINGS_H
39: # include <strings.h>
40: #endif /* HAVE_STRINGS_H */
41: #ifdef HAVE_UNISTD_H
42: # include <unistd.h>
43: #endif /* HAVE_UNISTD_H */
44: #include <pwd.h>
45: #include <errno.h>
46: #include <grp.h>
47:
48: #include "sudoers.h"
49:
50: /*
51: * Prototypes
52: */
53: static struct group_list *runas_setgroups(void);
54:
55: /*
56: * We keep track of the current permisstions and use a stack to restore
57: * the old permissions. A depth of 16 is overkill.
58: */
59: struct perm_state {
60: uid_t ruid;
61: uid_t euid;
62: #ifdef HAVE_SETRESUID
63: uid_t suid;
64: #endif
65: gid_t rgid;
66: gid_t egid;
67: #ifdef HAVE_SETRESUID
68: gid_t sgid;
69: #endif
70: struct group_list *grlist;
71: };
72:
73: #define PERM_STACK_MAX 16
74: static struct perm_state perm_stack[PERM_STACK_MAX];
75: static int perm_stack_depth = 0;
76:
77: #undef ID
78: #define ID(x) (state->x == ostate->x ? -1 : state->x)
79: #undef OID
80: #define OID(x) (ostate->x == state->x ? -1 : ostate->x)
81:
82: void
83: rewind_perms(void)
84: {
85: while (perm_stack_depth > 1)
86: restore_perms();
87: grlist_delref(perm_stack[0].grlist);
88: }
89:
90: #ifdef HAVE_SETRESUID
91:
92: /*
93: * Set real and effective and saved uids and gids based on perm.
94: * We always retain a saved uid of 0 unless we are headed for an exec().
95: * We only flip the effective gid since it only changes for PERM_SUDOERS.
96: * This version of set_perms() works fine with the "stay_setuid" option.
97: */
98: int
99: set_perms(int perm)
100: {
101: struct perm_state *state, *ostate = NULL;
102: const char *errstr;
103: int noexit;
104:
105: noexit = ISSET(perm, PERM_NOEXIT);
106: CLR(perm, PERM_MASK);
107:
108: if (perm_stack_depth == PERM_STACK_MAX) {
109: errstr = _("perm stack overflow");
110: errno = EINVAL;
111: goto bad;
112: }
113:
114: state = &perm_stack[perm_stack_depth];
115: if (perm != PERM_INITIAL) {
116: if (perm_stack_depth == 0) {
117: errstr = _("perm stack underflow");
118: errno = EINVAL;
119: goto bad;
120: }
121: ostate = &perm_stack[perm_stack_depth - 1];
122: if (memcmp(state, ostate, sizeof(*state)) == 0)
123: goto done;
124: }
125:
126: switch (perm) {
127: case PERM_INITIAL:
128: /* Stash initial state */
129: #ifdef HAVE_GETRESUID
130: if (getresuid(&state->ruid, &state->euid, &state->suid)) {
131: errstr = "getresuid";
132: goto bad;
133:
134: }
135: if (getresgid(&state->rgid, &state->egid, &state->sgid)) {
136: errstr = "getresgid";
137: goto bad;
138: }
139: #else
140: state->ruid = getuid();
141: state->euid = geteuid();
142: state->suid = state->euid; /* in case we are setuid */
143:
144: state->rgid = getgid();
145: state->egid = getegid();
146: state->sgid = state->egid; /* in case we are setgid */
147: #endif
148: state->grlist = user_group_list;
149: grlist_addref(state->grlist);
150: break;
151:
152: case PERM_ROOT:
153: state->ruid = ROOT_UID;
154: state->euid = ROOT_UID;
155: state->suid = ROOT_UID;
156: if (setresuid(ID(ruid), ID(euid), ID(suid))) {
157: errstr = "setresuid(ROOT_UID, ROOT_UID, ROOT_UID)";
158: goto bad;
159: }
160: state->rgid = -1;
161: state->egid = -1;
162: state->sgid = -1;
163: state->grlist = ostate->grlist;
164: grlist_addref(state->grlist);
165: break;
166:
167: case PERM_USER:
168: state->rgid = -1;
169: state->egid = user_gid;
170: state->sgid = -1;
171: if (setresgid(-1, ID(egid), -1)) {
172: errstr = "setresgid(-1, user_gid, -1)";
173: goto bad;
174: }
175: state->grlist = user_group_list;
176: grlist_addref(state->grlist);
177: if (state->grlist != ostate->grlist) {
178: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
179: errstr = "setgroups()";
180: goto bad;
181: }
182: }
183: state->ruid = user_uid;
184: state->euid = user_uid;
185: state->suid = ROOT_UID;
186: if (setresuid(ID(ruid), ID(euid), ID(suid))) {
187: errstr = "setresuid(user_uid, user_uid, ROOT_UID)";
188: goto bad;
189: }
190: break;
191:
192: case PERM_FULL_USER:
193: /* headed for exec() */
194: state->rgid = user_gid;
195: state->egid = user_gid;
196: state->sgid = user_gid;
197: if (setresgid(ID(rgid), ID(egid), ID(sgid))) {
198: errstr = "setresgid(user_gid, user_gid, user_gid)";
199: goto bad;
200: }
201: state->grlist = user_group_list;
202: grlist_addref(state->grlist);
203: if (state->grlist != ostate->grlist) {
204: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
205: errstr = "setgroups()";
206: goto bad;
207: }
208: }
209: state->ruid = user_uid;
210: state->euid = user_uid;
211: state->suid = user_uid;
212: if (setresuid(ID(ruid), ID(euid), ID(suid))) {
213: errstr = "setresuid(user_uid, user_uid, user_uid)";
214: goto bad;
215: }
216: break;
217:
218: case PERM_RUNAS:
219: state->rgid = -1;
220: state->egid = runas_gr ? runas_gr->gr_gid : runas_pw->pw_gid;
221: state->sgid = -1;
222: if (setresgid(-1, ID(egid), -1)) {
223: errstr = _("unable to change to runas gid");
224: goto bad;
225: }
226: state->grlist = runas_setgroups();
227: state->ruid = -1;
228: state->euid = runas_pw ? runas_pw->pw_uid : user_uid;
229: state->suid = -1;
230: if (setresuid(-1, ID(euid), -1)) {
231: errstr = _("unable to change to runas uid");
232: goto bad;
233: }
234: break;
235:
236: case PERM_SUDOERS:
237: state->grlist = ostate->grlist;
238: grlist_addref(state->grlist);
239:
240: /* assumes euid == ROOT_UID, ruid == user */
241: state->rgid = -1;
242: state->egid = sudoers_gid;
243: state->sgid = -1;
244: if (setresgid(-1, ID(egid), -1))
245: error(1, _("unable to change to sudoers gid"));
246:
247: state->ruid = ROOT_UID;
248: /*
249: * If sudoers_uid == ROOT_UID and sudoers_mode is group readable
250: * we use a non-zero uid in order to avoid NFS lossage.
251: * Using uid 1 is a bit bogus but should work on all OS's.
252: */
253: if (sudoers_uid == ROOT_UID && (sudoers_mode & 040))
254: state->euid = 1;
255: else
256: state->euid = sudoers_uid;
257: state->suid = ROOT_UID;
258: if (setresuid(ID(ruid), ID(euid), ID(suid))) {
259: errstr = "setresuid(ROOT_UID, SUDOERS_UID, ROOT_UID)";
260: goto bad;
261: }
262: break;
263:
264: case PERM_TIMESTAMP:
265: state->grlist = ostate->grlist;
266: grlist_addref(state->grlist);
267: state->rgid = -1;
268: state->egid = -1;
269: state->sgid = -1;
270: state->ruid = ROOT_UID;
271: state->euid = timestamp_uid;
272: state->suid = ROOT_UID;
273: if (setresuid(ID(ruid), ID(euid), ID(suid))) {
274: errstr = "setresuid(ROOT_UID, timestamp_uid, ROOT_UID)";
275: goto bad;
276: }
277: break;
278: }
279:
280: done:
281: perm_stack_depth++;
282: return 1;
283: bad:
284: /* XXX - better warnings inline */
285: warningx("%s: %s", errstr,
286: errno == EAGAIN ? _("too many processes") : strerror(errno));
287: if (noexit)
288: return 0;
289: exit(1);
290: }
291:
292: void
293: restore_perms(void)
294: {
295: struct perm_state *state, *ostate;
296:
297: if (perm_stack_depth < 2)
298: return;
299:
300: state = &perm_stack[perm_stack_depth - 1];
301: ostate = &perm_stack[perm_stack_depth - 2];
302: perm_stack_depth--;
303:
304: /* XXX - more cases here where euid != ruid */
305: if (OID(euid) == ROOT_UID && state->euid != ROOT_UID) {
306: if (setresuid(-1, ROOT_UID, -1)) {
307: warning("setresuid() [%d, %d, %d] -> [%d, %d, %d]",
308: (int)state->ruid, (int)state->euid, (int)state->suid,
309: -1, ROOT_UID, -1);
310: goto bad;
311: }
312: }
313: if (setresuid(OID(ruid), OID(euid), OID(suid))) {
314: warning("setresuid() [%d, %d, %d] -> [%d, %d, %d]",
315: (int)state->ruid, (int)state->euid, (int)state->suid,
316: (int)OID(ruid), (int)OID(euid), (int)OID(suid));
317: goto bad;
318: }
319: if (setresgid(OID(rgid), OID(egid), OID(sgid))) {
320: warning("setresgid() [%d, %d, %d] -> [%d, %d, %d]",
321: (int)state->rgid, (int)state->egid, (int)state->sgid,
322: (int)OID(rgid), (int)OID(egid), (int)OID(sgid));
323: goto bad;
324: }
325: if (state->grlist != ostate->grlist) {
326: if (sudo_setgroups(ostate->grlist->ngids, ostate->grlist->gids)) {
327: warning("setgroups()");
328: goto bad;
329: }
330: }
331: grlist_delref(state->grlist);
332: return;
333:
334: bad:
335: exit(1);
336: }
337:
338: #else
339: # ifdef HAVE_SETREUID
340:
341: /*
342: * Set real and effective uids and gids based on perm.
343: * We always retain a real or effective uid of ROOT_UID unless
344: * we are headed for an exec().
345: * This version of set_perms() works fine with the "stay_setuid" option.
346: */
347: int
348: set_perms(int perm)
349: {
350: struct perm_state *state, *ostate = NULL;
351: const char *errstr;
352: int noexit;
353:
354: noexit = ISSET(perm, PERM_NOEXIT);
355: CLR(perm, PERM_MASK);
356:
357: if (perm_stack_depth == PERM_STACK_MAX) {
358: errstr = _("perm stack overflow");
359: errno = EINVAL;
360: goto bad;
361: }
362:
363: state = &perm_stack[perm_stack_depth];
364: if (perm != PERM_INITIAL) {
365: if (perm_stack_depth == 0) {
366: errstr = _("perm stack underflow");
367: errno = EINVAL;
368: goto bad;
369: }
370: ostate = &perm_stack[perm_stack_depth - 1];
371: if (memcmp(state, ostate, sizeof(*state)) == 0)
372: goto done;
373: }
374:
375: switch (perm) {
376: case PERM_INITIAL:
377: /* Stash initial state */
378: state->ruid = getuid();
379: state->euid = geteuid();
380: state->rgid = getgid();
381: state->egid = getegid();
382: state->grlist = user_group_list;
383: grlist_addref(state->grlist);
384: break;
385:
386: case PERM_ROOT:
387: /*
388: * setreuid(0, 0) may fail on some systems
389: * when the euid is not already 0.
390: */
391: if (setreuid(-1, ROOT_UID)) {
392: errstr = "setreuid(-1, ROOT_UID)";
393: goto bad;
394: }
395: if (setuid(ROOT_UID)) {
396: errstr = "setuid(ROOT_UID)";
397: goto bad;
398: }
399: state->ruid = ROOT_UID;
400: state->euid = ROOT_UID;
401: state->rgid = -1;
402: state->egid = -1;
403: state->grlist = ostate->grlist;
404: grlist_addref(state->grlist);
405: break;
406:
407: case PERM_USER:
408: state->rgid = -1;
409: state->egid = user_gid;
410: if (setregid(-1, ID(egid))) {
411: errstr = "setregid(-1, user_gid)";
412: goto bad;
413: }
414: state->grlist = user_group_list;
415: grlist_addref(state->grlist);
416: if (state->grlist != ostate->grlist) {
417: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
418: errstr = "setgroups()";
419: goto bad;
420: }
421: }
422: state->ruid = ROOT_UID;
423: state->euid = user_uid;
424: if (setreuid(ID(ruid), ID(euid))) {
425: errstr = "setreuid(ROOT_UID, user_uid)";
426: goto bad;
427: }
428: break;
429:
430: case PERM_FULL_USER:
431: /* headed for exec() */
432: state->rgid = user_gid;
433: state->egid = user_gid;
434: if (setregid(ID(rgid), ID(egid))) {
435: errstr = "setregid(user_gid, user_gid)";
436: goto bad;
437: }
438: state->grlist = user_group_list;
439: grlist_addref(state->grlist);
440: if (state->grlist != ostate->grlist) {
441: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
442: errstr = "setgroups()";
443: goto bad;
444: }
445: }
446: state->ruid = user_uid;
447: state->euid = user_uid;
448: if (setreuid(ID(ruid), ID(euid))) {
449: errstr = "setreuid(user_uid, user_uid)";
450: goto bad;
451: }
452: break;
453:
454: case PERM_RUNAS:
455: state->rgid = -1;
456: state->egid = runas_gr ? runas_gr->gr_gid : runas_pw->pw_gid;
457: if (setregid(ID(rgid), ID(egid))) {
458: errstr = _("unable to change to runas gid");
459: goto bad;
460: }
461: state->grlist = runas_setgroups();
462: state->ruid = ROOT_UID;
463: state->euid = runas_pw ? runas_pw->pw_uid : user_uid;
464: if (setreuid(ID(ruid), ID(euid))) {
465: errstr = _("unable to change to runas uid");
466: goto bad;
467: }
468: break;
469:
470: case PERM_SUDOERS:
471: state->grlist = ostate->grlist;
472: grlist_addref(state->grlist);
473:
474: /* assume euid == ROOT_UID, ruid == user */
475: state->rgid = -1;
476: state->egid = sudoers_gid;
477: if (setregid(-1, ID(egid)))
478: error(1, _("unable to change to sudoers gid"));
479:
480: state->ruid = ROOT_UID;
481: /*
482: * If sudoers_uid == ROOT_UID and sudoers_mode is group readable
483: * we use a non-zero uid in order to avoid NFS lossage.
484: * Using uid 1 is a bit bogus but should work on all OS's.
485: */
486: if (sudoers_uid == ROOT_UID && (sudoers_mode & 040))
487: state->euid = 1;
488: else
489: state->euid = sudoers_uid;
490: if (setreuid(ID(ruid), ID(euid))) {
491: errstr = "setreuid(ROOT_UID, SUDOERS_UID)";
492: goto bad;
493: }
494: break;
495:
496: case PERM_TIMESTAMP:
497: state->grlist = ostate->grlist;
498: grlist_addref(state->grlist);
499: state->rgid = -1;
500: state->egid = -1;
501: state->ruid = ROOT_UID;
502: state->euid = timestamp_uid;
503: if (setreuid(ID(ruid), ID(euid))) {
504: errstr = "setreuid(ROOT_UID, timestamp_uid)";
505: goto bad;
506: }
507: break;
508: }
509:
510: done:
511: perm_stack_depth++;
512: return 1;
513: bad:
514: /* XXX - better warnings inline */
515: warningx("%s: %s", errstr,
516: errno == EAGAIN ? _("too many processes") : strerror(errno));
517: if (noexit)
518: return 0;
519: exit(1);
520: }
521:
522: void
523: restore_perms(void)
524: {
525: struct perm_state *state, *ostate;
526:
527: if (perm_stack_depth < 2)
528: return;
529:
530: state = &perm_stack[perm_stack_depth - 1];
531: ostate = &perm_stack[perm_stack_depth - 2];
532: perm_stack_depth--;
533:
534: /*
535: * When changing euid to ROOT_UID, setreuid() may fail even if
536: * the ruid is ROOT_UID so call setuid() first.
537: */
538: if (OID(euid) == ROOT_UID) {
539: /* setuid() may not set the saved ID unless the euid is ROOT_UID */
540: if (ID(euid) != ROOT_UID)
541: (void)setreuid(-1, ROOT_UID);
542: if (setuid(ROOT_UID)) {
543: warning("setuid() [%d, %d] -> %d)", (int)state->ruid,
544: (int)state->euid, ROOT_UID);
545: goto bad;
546: }
547: }
548: if (setreuid(OID(ruid), OID(euid))) {
549: warning("setreuid() [%d, %d] -> [%d, %d]", (int)state->ruid,
550: (int)state->euid, (int)OID(ruid), (int)OID(euid));
551: goto bad;
552: }
553: if (setregid(OID(rgid), OID(egid))) {
554: warning("setregid() [%d, %d] -> [%d, %d]", (int)state->rgid,
555: (int)state->egid, (int)OID(rgid), (int)OID(egid));
556: goto bad;
557: }
558: if (state->grlist != ostate->grlist) {
559: if (sudo_setgroups(ostate->grlist->ngids, ostate->grlist->gids)) {
560: warning("setgroups()");
561: goto bad;
562: }
563: }
564: grlist_delref(state->grlist);
565: return;
566:
567: bad:
568: exit(1);
569: }
570:
571: # else /* !HAVE_SETRESUID && !HAVE_SETREUID */
572: # ifdef HAVE_SETEUID
573:
574: /*
575: * Set real and effective uids and gids based on perm.
576: * We always retain a real or effective uid of ROOT_UID unless
577: * we are headed for an exec().
578: * This version of set_perms() works fine with the "stay_setuid" option.
579: */
580: int
581: set_perms(int perm)
582: {
583: struct perm_state *state, *ostate = NULL;
584: const char *errstr;
585: int noexit;
586:
587: noexit = ISSET(perm, PERM_NOEXIT);
588: CLR(perm, PERM_MASK);
589:
590: if (perm_stack_depth == PERM_STACK_MAX) {
591: errstr = _("perm stack overflow");
592: errno = EINVAL;
593: goto bad;
594: }
595:
596: state = &perm_stack[perm_stack_depth];
597: if (perm != PERM_INITIAL) {
598: if (perm_stack_depth == 0) {
599: errstr = _("perm stack underflow");
600: errno = EINVAL;
601: goto bad;
602: }
603: ostate = &perm_stack[perm_stack_depth - 1];
604: if (memcmp(state, ostate, sizeof(*state)) == 0)
605: goto done;
606: }
607:
608: /*
609: * Since we only have setuid() and seteuid() and semantics
610: * for these calls differ on various systems, we set
611: * real and effective uids to ROOT_UID initially to be safe.
612: */
613: if (perm != PERM_INITIAL) {
614: if (seteuid(ROOT_UID)) {
615: errstr = "seteuid(ROOT_UID)";
616: goto bad;
617: }
618: if (setuid(ROOT_UID)) {
619: errstr = "setuid(ROOT_UID)";
620: goto bad;
621: }
622: }
623:
624: switch (perm) {
625: case PERM_INITIAL:
626: /* Stash initial state */
627: state->ruid = getuid();
628: state->euid = geteuid();
629: state->rgid = getgid();
630: state->egid = getegid();
631: state->grlist = user_group_list;
632: grlist_addref(state->grlist);
633: break;
634:
635: case PERM_ROOT:
636: /* We already set ruid/euid above. */
637: state->ruid = ROOT_UID;
638: state->euid = ROOT_UID;
639: state->rgid = -1;
640: state->egid = -1;
641: state->grlist = ostate->grlist;
642: grlist_addref(state->grlist);
643: break;
644:
645: case PERM_USER:
646: state->egid = user_gid;
647: if (setegid(ID(egid))) {
648: errstr = "setegid(user_gid)";
649: goto bad;
650: }
651: state->grlist = user_group_list;
652: grlist_addref(state->grlist);
653: if (state->grlist != ostate->grlist) {
654: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
655: errstr = "setgroups()";
656: goto bad;
657: }
658: }
659: state->rgid = -1;
660: state->ruid = ROOT_UID;
661: state->euid = user_uid;
662: if (seteuid(ID(euid))) {
663: errstr = "seteuid(user_uid)";
664: goto bad;
665: }
666: break;
667:
668: case PERM_FULL_USER:
669: /* headed for exec() */
670: state->rgid = user_gid;
671: state->egid = user_gid;
672: if (setgid(user_gid)) {
673: errstr = "setgid(user_gid)";
674: goto bad;
675: }
676: state->grlist = user_group_list;
677: grlist_addref(state->grlist);
678: if (state->grlist != ostate->grlist) {
679: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
680: errstr = "setgroups()";
681: goto bad;
682: }
683: }
684: state->ruid = user_uid;
685: state->euid = user_uid;
686: if (setuid(user_uid)) {
687: errstr = "setuid(user_uid)";
688: goto bad;
689: }
690: break;
691:
692: case PERM_RUNAS:
693: state->rgid = -1;
694: state->egid = runas_gr ? runas_gr->gr_gid : runas_pw->pw_gid;
695: if (setegid(ID(egid))) {
696: errstr = _("unable to change to runas gid");
697: goto bad;
698: }
699: state->grlist = runas_setgroups();
700: state->ruid = -1;
701: state->euid = runas_pw ? runas_pw->pw_uid : user_uid;
702: if (seteuid(ID(euid))) {
703: errstr = _("unable to change to runas uid");
704: goto bad;
705: }
706: break;
707:
708: case PERM_SUDOERS:
709: state->grlist = ostate->grlist;
710: grlist_addref(state->grlist);
711:
712: /* assume euid == ROOT_UID, ruid == user */
713: state->rgid = -1;
714: state->egid = sudoers_gid;
715: if (setegid(ID(egid)))
716: error(1, _("unable to change to sudoers gid"));
717:
718: state->ruid = ROOT_UID;
719: /*
720: * If sudoers_uid == ROOT_UID and sudoers_mode is group readable
721: * we use a non-zero uid in order to avoid NFS lossage.
722: * Using uid 1 is a bit bogus but should work on all OS's.
723: */
724: if (sudoers_uid == ROOT_UID && (sudoers_mode & 040))
725: state->euid = 1;
726: else
727: state->euid = sudoers_uid;
728: if (seteuid(ID(euid))) {
729: errstr = "seteuid(SUDOERS_UID)";
730: goto bad;
731: }
732: break;
733:
734: case PERM_TIMESTAMP:
735: state->grlist = ostate->grlist;
736: grlist_addref(state->grlist);
737: state->rgid = -1;
738: state->egid = -1;
739: state->ruid = ROOT_UID;
740: state->euid = timestamp_uid;
741: if (seteuid(ID(euid))) {
742: errstr = "seteuid(timestamp_uid)";
743: goto bad;
744: }
745: break;
746: }
747:
748: done:
749: perm_stack_depth++;
750: return 1;
751: bad:
752: /* XXX - better warnings inline */
753: warningx("%s: %s", errstr,
754: errno == EAGAIN ? _("too many processes") : strerror(errno));
755: if (noexit)
756: return 0;
757: exit(1);
758: }
759:
760: void
761: restore_perms(void)
762: {
763: struct perm_state *state, *ostate;
764:
765: if (perm_stack_depth < 2)
766: return;
767:
768: state = &perm_stack[perm_stack_depth - 1];
769: ostate = &perm_stack[perm_stack_depth - 2];
770: perm_stack_depth--;
771:
772: /*
773: * Since we only have setuid() and seteuid() and semantics
774: * for these calls differ on various systems, we set
775: * real and effective uids to ROOT_UID initially to be safe.
776: */
777: if (seteuid(ROOT_UID)) {
778: errstr = "seteuid(ROOT_UID)";
779: goto bad;
780: }
781: if (setuid(ROOT_UID)) {
782: errstr = "setuid(ROOT_UID)";
783: goto bad;
784: }
785:
786: if (setegid(OID(egid))) {
787: warning("setegid(%d)", (int)OID(egid));
788: goto bad;
789: }
790: if (state->grlist != ostate->grlist) {
791: if (sudo_setgroups(ostate->grlist->ngids, ostate->grlist->gids)) {
792: warning("setgroups()");
793: goto bad;
794: }
795: }
796: if (seteuid(OID(euid))) {
797: warning("seteuid(%d)", (int)OID(euid));
798: goto bad;
799: }
800: grlist_delref(state->grlist);
801: return;
802:
803: bad:
804: exit(1);
805: }
806:
807: # else /* !HAVE_SETRESUID && !HAVE_SETREUID && !HAVE_SETEUID */
808:
809: /*
810: * Set uids and gids based on perm via setuid() and setgid().
811: * NOTE: does not support the "stay_setuid" or timestampowner options.
812: * Also, sudoers_uid and sudoers_gid are not used.
813: */
814: int
815: set_perms(int perm)
816: {
817: struct perm_state *state, *ostate = NULL;
818: const char *errstr;
819: int noexit;
820:
821: noexit = ISSET(perm, PERM_NOEXIT);
822: CLR(perm, PERM_MASK);
823:
824: if (perm_stack_depth == PERM_STACK_MAX) {
825: errstr = _("perm stack overflow");
826: errno = EINVAL;
827: goto bad;
828: }
829:
830: state = &perm_stack[perm_stack_depth];
831: if (perm != PERM_INITIAL) {
832: if (perm_stack_depth == 0) {
833: errstr = _("perm stack underflow");
834: errno = EINVAL;
835: goto bad;
836: }
837: ostate = &perm_stack[perm_stack_depth - 1];
838: if (memcmp(state, ostate, sizeof(*state)) == 0)
839: goto done;
840: }
841:
842: switch (perm) {
843: case PERM_INITIAL:
844: /* Stash initial state */
845: state->ruid = getuid();
846: state->rgid = getgid();
847: state->grlist = user_group_list;
848: grlist_addref(state->grlist);
849: break;
850:
851: case PERM_ROOT:
852: state->ruid = ROOT_UID;
853: state->rgid = -1;
854: state->grlist = ostate->grlist;
855: grlist_addref(state->grlist);
856: if (setuid(ROOT_UID)) {
857: errstr = "setuid(ROOT_UID)";
858: goto bad;
859: }
860: break;
861:
862: case PERM_FULL_USER:
863: state->rgid = user_gid;
864: (void) setgid(user_gid);
865: state->grlist = user_group_list;
866: grlist_addref(state->grlist);
867: if (state->grlist != ostate->grlist) {
868: if (sudo_setgroups(state->grlist->ngids, state->grlist->gids)) {
869: errstr = "setgroups()";
870: goto bad;
871: }
872: }
873: state->ruid = user_uid;
874: if (setuid(user_uid)) {
875: errstr = "setuid(user_uid)";
876: goto bad;
877: }
878: break;
879:
880: case PERM_USER:
881: case PERM_SUDOERS:
882: case PERM_RUNAS:
883: case PERM_TIMESTAMP:
884: /* Unsupported since we can't set euid. */
885: break;
886: }
887:
888: done:
889: perm_stack_depth++;
890: return 1;
891: bad:
892: /* XXX - better warnings inline */
893: warningx("%s: %s", errstr,
894: errno == EAGAIN ? _("too many processes") : strerror(errno));
895: if (noexit)
896: return 0;
897: exit(1);
898: }
899:
900: void
901: restore_perms(void)
902: {
903: struct perm_state *state, *ostate;
904:
905: if (perm_stack_depth < 2)
906: return;
907:
908: state = &perm_stack[perm_stack_depth - 1];
909: ostate = &perm_stack[perm_stack_depth - 2];
910: perm_stack_depth--;
911:
912: if (OID(rgid) != -1 && setgid(ostate->rgid)) {
913: warning("setgid(%d)", (int)ostate->rgid);
914: goto bad;
915: }
916: if (state->grlist != ostate->grlist) {
917: if (sudo_setgroups(ostate->grlist->ngids, ostate->grlist->gids)) {
918: warning("setgroups()");
919: goto bad;
920: }
921: }
922: grlist_delref(state->grlist);
923: if (OID(ruid) != -1 && setuid(ostate->ruid)) {
924: warning("setuid(%d)", (int)ostate->ruid);
925: goto bad;
926: }
927: return;
928:
929: bad:
930: exit(1);
931: }
932: # endif /* HAVE_SETEUID */
933: # endif /* HAVE_SETREUID */
934: #endif /* HAVE_SETRESUID */
935:
936: static struct group_list *
937: runas_setgroups(void)
938: {
939: struct passwd *pw;
940: struct group_list *grlist;
941:
942: if (def_preserve_groups) {
943: grlist_addref(user_group_list);
944: return user_group_list;
945: }
946:
947: pw = runas_pw ? runas_pw : sudo_user.pw;
948: #ifdef HAVE_SETAUTHDB
949: aix_setauthdb(pw->pw_name);
950: #endif
951: grlist = get_group_list(pw);
952: #ifdef HAVE_SETAUTHDB
953: aix_restoreauthdb();
954: #endif
955: if (sudo_setgroups(grlist->ngids, grlist->gids) < 0)
956: log_error(USE_ERRNO|MSG_ONLY, _("unable to set runas group vector"));
957: return grlist;
958: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to set_perms.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers