Annotation of embedaddon/quagga/lib/privs.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Zebra privileges.
! 3: *
! 4: * Copyright (C) 2003 Paul Jakma.
! 5: * Copyright (C) 2005 Sun Microsystems, Inc.
! 6: *
! 7: * This file is part of GNU Zebra.
! 8: *
! 9: * GNU Zebra is free software; you can redistribute it and/or modify it
! 10: * under the terms of the GNU General Public License as published by the
! 11: * Free Software Foundation; either version 2, or (at your option) any
! 12: * later version.
! 13: *
! 14: * GNU Zebra is distributed in the hope that it will be useful, but
! 15: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 16: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 17: * General Public License for more details.
! 18: *
! 19: * You should have received a copy of the GNU General Public License
! 20: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 21: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 22: * 02111-1307, USA.
! 23: */
! 24: #include <zebra.h>
! 25: #include "log.h"
! 26: #include "privs.h"
! 27: #include "memory.h"
! 28:
! 29: #ifdef HAVE_CAPABILITIES
! 30: /* sort out some generic internal types for:
! 31: *
! 32: * privilege values (cap_value_t, priv_t) -> pvalue_t
! 33: * privilege set (..., priv_set_t) -> pset_t
! 34: * privilege working storage (cap_t, ...) -> pstorage_t
! 35: *
! 36: * values we think of as numeric (they're ints really, but we dont know)
! 37: * sets are mostly opaque, to hold a set of privileges, related in some way.
! 38: * storage binds together a set of sets we're interested in.
! 39: * (in reality: cap_value_t and priv_t are ints)
! 40: */
! 41: #ifdef HAVE_LCAPS
! 42: /* Linux doesn't have a 'set' type: a set of related privileges */
! 43: struct _pset {
! 44: int num;
! 45: cap_value_t *caps;
! 46: };
! 47: typedef cap_value_t pvalue_t;
! 48: typedef struct _pset pset_t;
! 49: typedef cap_t pstorage_t;
! 50:
! 51: #elif defined (HAVE_SOLARIS_CAPABILITIES)
! 52: typedef priv_t pvalue_t;
! 53: typedef priv_set_t pset_t;
! 54: typedef priv_set_t *pstorage_t;
! 55: #else /* neither LCAPS nor SOLARIS_CAPABILITIES */
! 56: #error "HAVE_CAPABILITIES defined, but neither LCAPS nor Solaris Capabilties!"
! 57: #endif /* HAVE_LCAPS */
! 58: #endif /* HAVE_CAPABILITIES */
! 59:
! 60: /* the default NULL state we report is RAISED, but could be LOWERED if
! 61: * zprivs_terminate is called and the NULL handler is installed.
! 62: */
! 63: static zebra_privs_current_t zprivs_null_state = ZPRIVS_RAISED;
! 64:
! 65: /* internal privileges state */
! 66: static struct _zprivs_t
! 67: {
! 68: #ifdef HAVE_CAPABILITIES
! 69: pstorage_t caps; /* working storage */
! 70: pset_t *syscaps_p; /* system-type requested permitted caps */
! 71: pset_t *syscaps_i; /* system-type requested inheritable caps */
! 72: #endif /* HAVE_CAPABILITIES */
! 73: uid_t zuid, /* uid to run as */
! 74: zsuid; /* saved uid */
! 75: gid_t zgid; /* gid to run as */
! 76: gid_t vtygrp; /* gid for vty sockets */
! 77: } zprivs_state;
! 78:
! 79: /* externally exported but not directly accessed functions */
! 80: #ifdef HAVE_CAPABILITIES
! 81: int zprivs_change_caps (zebra_privs_ops_t);
! 82: zebra_privs_current_t zprivs_state_caps (void);
! 83: #endif /* HAVE_CAPABILITIES */
! 84: int zprivs_change_uid (zebra_privs_ops_t);
! 85: zebra_privs_current_t zprivs_state_uid (void);
! 86: int zprivs_change_null (zebra_privs_ops_t);
! 87: zebra_privs_current_t zprivs_state_null (void);
! 88:
! 89: #ifdef HAVE_CAPABILITIES
! 90: /* internal capability API */
! 91: static pset_t *zcaps2sys (zebra_capabilities_t *, int);
! 92: static void zprivs_caps_init (struct zebra_privs_t *);
! 93: static void zprivs_caps_terminate (void);
! 94:
! 95: /* Map of Quagga abstract capabilities to system capabilities */
! 96: static struct
! 97: {
! 98: int num;
! 99: pvalue_t *system_caps;
! 100: } cap_map [ZCAP_MAX] =
! 101: {
! 102: #ifdef HAVE_LCAPS /* Quagga -> Linux capabilities mappings */
! 103: [ZCAP_SETID] = { 2, (pvalue_t []) { CAP_SETGID,
! 104: CAP_SETUID }, },
! 105: [ZCAP_BIND] = { 2, (pvalue_t []) { CAP_NET_BIND_SERVICE,
! 106: CAP_NET_BROADCAST }, },
! 107: [ZCAP_NET_ADMIN] = { 1, (pvalue_t []) { CAP_NET_ADMIN }, },
! 108: [ZCAP_NET_RAW] = { 1, (pvalue_t []) { CAP_NET_RAW }, },
! 109: [ZCAP_CHROOT] = { 1, (pvalue_t []) { CAP_SYS_CHROOT, }, },
! 110: [ZCAP_NICE] = { 1, (pvalue_t []) { CAP_SYS_NICE }, },
! 111: [ZCAP_PTRACE] = { 1, (pvalue_t []) { CAP_SYS_PTRACE }, },
! 112: [ZCAP_DAC_OVERRIDE] = { 1, (pvalue_t []) { CAP_DAC_OVERRIDE }, },
! 113: [ZCAP_READ_SEARCH] = { 1, (pvalue_t []) { CAP_DAC_READ_SEARCH }, },
! 114: [ZCAP_SYS_ADMIN] = { 1, (pvalue_t []) { CAP_SYS_ADMIN }, },
! 115: [ZCAP_FOWNER] = { 1, (pvalue_t []) { CAP_FOWNER }, },
! 116: #elif defined(HAVE_SOLARIS_CAPABILITIES) /* HAVE_LCAPS */
! 117: /* Quagga -> Solaris privilege mappings */
! 118: [ZCAP_SETID] = { 1, (pvalue_t []) { PRIV_PROC_SETID }, },
! 119: [ZCAP_BIND] = { 1, (pvalue_t []) { PRIV_NET_PRIVADDR }, },
! 120: /* IP_CONFIG is a subset of NET_CONFIG and is allowed in zones */
! 121: #ifdef PRIV_SYS_IP_CONFIG
! 122: [ZCAP_NET_ADMIN] = { 1, (pvalue_t []) { PRIV_SYS_IP_CONFIG }, },
! 123: #else
! 124: [ZCAP_NET_ADMIN] = { 1, (pvalue_t []) { PRIV_SYS_NET_CONFIG }, },
! 125: #endif
! 126: [ZCAP_NET_RAW] = { 2, (pvalue_t []) { PRIV_NET_RAWACCESS,
! 127: PRIV_NET_ICMPACCESS }, },
! 128: [ZCAP_CHROOT] = { 1, (pvalue_t []) { PRIV_PROC_CHROOT }, },
! 129: [ZCAP_NICE] = { 1, (pvalue_t []) { PRIV_PROC_PRIOCNTL }, },
! 130: [ZCAP_PTRACE] = { 1, (pvalue_t []) { PRIV_PROC_SESSION }, },
! 131: [ZCAP_DAC_OVERRIDE] = { 2, (pvalue_t []) { PRIV_FILE_DAC_EXECUTE,
! 132: PRIV_FILE_DAC_READ,
! 133: PRIV_FILE_DAC_SEARCH,
! 134: PRIV_FILE_DAC_WRITE,
! 135: PRIV_FILE_DAC_SEARCH }, },
! 136: [ZCAP_READ_SEARCH] = { 2, (pvalue_t []) { PRIV_FILE_DAC_SEARCH,
! 137: PRIV_FILE_DAC_READ }, },
! 138: [ZCAP_SYS_ADMIN] = { 1, (pvalue_t []) { PRIV_SYS_ADMIN }, },
! 139: [ZCAP_FOWNER] = { 1, (pvalue_t []) { PRIV_FILE_OWNER }, },
! 140: #endif /* HAVE_SOLARIS_CAPABILITIES */
! 141: };
! 142:
! 143: #ifdef HAVE_LCAPS
! 144: /* Linux forms of capabilities methods */
! 145: /* convert zebras privileges to system capabilities */
! 146: static pset_t *
! 147: zcaps2sys (zebra_capabilities_t *zcaps, int num)
! 148: {
! 149: pset_t *syscaps;
! 150: int i, j = 0, count = 0;
! 151:
! 152: if (!num)
! 153: return NULL;
! 154:
! 155: /* first count up how many system caps we have */
! 156: for (i= 0; i < num; i++)
! 157: count += cap_map[zcaps[i]].num;
! 158:
! 159: if ( (syscaps = XCALLOC (MTYPE_PRIVS, (sizeof(pset_t) * num))) == NULL)
! 160: {
! 161: fprintf (stderr, "%s: could not allocate syscaps!", __func__);
! 162: return NULL;
! 163: }
! 164:
! 165: syscaps->caps = XCALLOC (MTYPE_PRIVS, (sizeof (pvalue_t) * count));
! 166:
! 167: if (!syscaps->caps)
! 168: {
! 169: fprintf (stderr, "%s: could not XCALLOC caps!", __func__);
! 170: return NULL;
! 171: }
! 172:
! 173: /* copy the capabilities over */
! 174: count = 0;
! 175: for (i=0; i < num; i++)
! 176: for (j = 0; j < cap_map[zcaps[i]].num; j++)
! 177: syscaps->caps[count++] = cap_map[zcaps[i]].system_caps[j];
! 178:
! 179: /* iterations above should be exact same as previous count, obviously.. */
! 180: syscaps->num = count;
! 181:
! 182: return syscaps;
! 183: }
! 184:
! 185: /* set or clear the effective capabilities to/from permitted */
! 186: int
! 187: zprivs_change_caps (zebra_privs_ops_t op)
! 188: {
! 189: cap_flag_value_t cflag;
! 190:
! 191: /* should be no possibility of being called without valid caps */
! 192: assert (zprivs_state.syscaps_p && zprivs_state.caps);
! 193: if (! (zprivs_state.syscaps_p && zprivs_state.caps))
! 194: exit (1);
! 195:
! 196: if (op == ZPRIVS_RAISE)
! 197: cflag = CAP_SET;
! 198: else if (op == ZPRIVS_LOWER)
! 199: cflag = CAP_CLEAR;
! 200: else
! 201: return -1;
! 202:
! 203: if ( !cap_set_flag (zprivs_state.caps, CAP_EFFECTIVE,
! 204: zprivs_state.syscaps_p->num,
! 205: zprivs_state.syscaps_p->caps,
! 206: cflag))
! 207: return cap_set_proc (zprivs_state.caps);
! 208: return -1;
! 209: }
! 210:
! 211: zebra_privs_current_t
! 212: zprivs_state_caps (void)
! 213: {
! 214: int i;
! 215: cap_flag_value_t val;
! 216:
! 217: /* should be no possibility of being called without valid caps */
! 218: assert (zprivs_state.syscaps_p && zprivs_state.caps);
! 219: if (! (zprivs_state.syscaps_p && zprivs_state.caps))
! 220: exit (1);
! 221:
! 222: for (i=0; i < zprivs_state.syscaps_p->num; i++)
! 223: {
! 224: if ( cap_get_flag (zprivs_state.caps, zprivs_state.syscaps_p->caps[i],
! 225: CAP_EFFECTIVE, &val) )
! 226: {
! 227: zlog_warn ("zprivs_state_caps: could not cap_get_flag, %s",
! 228: safe_strerror (errno) );
! 229: return ZPRIVS_UNKNOWN;
! 230: }
! 231: if (val == CAP_SET)
! 232: return ZPRIVS_RAISED;
! 233: }
! 234: return ZPRIVS_LOWERED;
! 235: }
! 236:
! 237: static void
! 238: zprivs_caps_init (struct zebra_privs_t *zprivs)
! 239: {
! 240: zprivs_state.syscaps_p = zcaps2sys (zprivs->caps_p, zprivs->cap_num_p);
! 241: zprivs_state.syscaps_i = zcaps2sys (zprivs->caps_i, zprivs->cap_num_i);
! 242:
! 243: /* Tell kernel we want caps maintained across uid changes */
! 244: if ( prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1 )
! 245: {
! 246: fprintf (stderr, "privs_init: could not set PR_SET_KEEPCAPS, %s\n",
! 247: safe_strerror (errno) );
! 248: exit(1);
! 249: }
! 250:
! 251: if ( !zprivs_state.syscaps_p )
! 252: {
! 253: fprintf (stderr, "privs_init: capabilities enabled, "
! 254: "but no capabilities supplied\n");
! 255: }
! 256:
! 257: /* we have caps, we have no need to ever change back the original user */
! 258: if (zprivs_state.zuid)
! 259: {
! 260: if ( setreuid (zprivs_state.zuid, zprivs_state.zuid) )
! 261: {
! 262: fprintf (stderr, "zprivs_init (cap): could not setreuid, %s\n",
! 263: safe_strerror (errno));
! 264: exit (1);
! 265: }
! 266: }
! 267:
! 268: if ( !(zprivs_state.caps = cap_init()) )
! 269: {
! 270: fprintf (stderr, "privs_init: failed to cap_init, %s\n",
! 271: safe_strerror (errno));
! 272: exit (1);
! 273: }
! 274:
! 275: if ( cap_clear (zprivs_state.caps) )
! 276: {
! 277: fprintf (stderr, "privs_init: failed to cap_clear, %s\n",
! 278: safe_strerror (errno));
! 279: exit (1);
! 280: }
! 281:
! 282: /* set permitted caps */
! 283: cap_set_flag(zprivs_state.caps, CAP_PERMITTED,
! 284: zprivs_state.syscaps_p->num,
! 285: zprivs_state.syscaps_p->caps,
! 286: CAP_SET);
! 287:
! 288: /* set inheritable caps, if any */
! 289: if (zprivs_state.syscaps_i && zprivs_state.syscaps_i->num)
! 290: {
! 291: cap_set_flag(zprivs_state.caps, CAP_INHERITABLE,
! 292: zprivs_state.syscaps_i->num,
! 293: zprivs_state.syscaps_i->caps,
! 294: CAP_SET);
! 295: }
! 296:
! 297: /* apply caps. CAP_EFFECTIVE is cleared. we'll raise the caps as
! 298: * and when, and only when, they are needed.
! 299: */
! 300: if ( cap_set_proc (zprivs_state.caps) )
! 301: {
! 302: fprintf (stderr, "privs_init: initial cap_set_proc failed\n");
! 303: exit (1);
! 304: }
! 305:
! 306: /* set methods for the caller to use */
! 307: zprivs->change = zprivs_change_caps;
! 308: zprivs->current_state = zprivs_state_caps;
! 309: }
! 310:
! 311: static void
! 312: zprivs_caps_terminate (void)
! 313: {
! 314: /* clear all capabilities */
! 315: if (zprivs_state.caps)
! 316: cap_clear (zprivs_state.caps);
! 317:
! 318: /* and boom, capabilities are gone forever */
! 319: if ( cap_set_proc (zprivs_state.caps) )
! 320: {
! 321: fprintf (stderr, "privs_terminate: cap_set_proc failed, %s",
! 322: safe_strerror (errno) );
! 323: exit (1);
! 324: }
! 325:
! 326: /* free up private state */
! 327: if (zprivs_state.syscaps_p->num)
! 328: {
! 329: XFREE (MTYPE_PRIVS, zprivs_state.syscaps_p->caps);
! 330: XFREE (MTYPE_PRIVS, zprivs_state.syscaps_p);
! 331: }
! 332:
! 333: if (zprivs_state.syscaps_i && zprivs_state.syscaps_i->num)
! 334: {
! 335: XFREE (MTYPE_PRIVS, zprivs_state.syscaps_i->caps);
! 336: XFREE (MTYPE_PRIVS, zprivs_state.syscaps_i);
! 337: }
! 338:
! 339: cap_free (zprivs_state.caps);
! 340: }
! 341: #elif defined (HAVE_SOLARIS_CAPABILITIES) /* !HAVE_LCAPS */
! 342:
! 343: /* Solaris specific capability/privilege methods
! 344: *
! 345: * Resources:
! 346: * - the 'privileges' man page
! 347: * - http://cvs.opensolaris.org
! 348: * - http://blogs.sun.com/roller/page/gbrunett?entry=privilege_enabling_set_id_programs1
! 349: */
! 350:
! 351: /* convert zebras privileges to system capabilities */
! 352: static pset_t *
! 353: zcaps2sys (zebra_capabilities_t *zcaps, int num)
! 354: {
! 355: pset_t *syscaps;
! 356: int i, j = 0;
! 357:
! 358: if ((syscaps = priv_allocset()) == NULL)
! 359: {
! 360: fprintf (stderr, "%s: could not allocate syscaps!\n", __func__);
! 361: exit (1);
! 362: }
! 363:
! 364: priv_emptyset (syscaps);
! 365:
! 366: for (i=0; i < num; i++)
! 367: for (j = 0; j < cap_map[zcaps[i]].num; j++)
! 368: priv_addset (syscaps, cap_map[zcaps[i]].system_caps[j]);
! 369:
! 370: return syscaps;
! 371: }
! 372:
! 373: /* callback exported to users to RAISE and LOWER effective privileges
! 374: * from nothing to the given permitted set and back down
! 375: */
! 376: int
! 377: zprivs_change_caps (zebra_privs_ops_t op)
! 378: {
! 379:
! 380: /* should be no possibility of being called without valid caps */
! 381: assert (zprivs_state.syscaps_p);
! 382: if (!zprivs_state.syscaps_p)
! 383: {
! 384: fprintf (stderr, "%s: Eek, missing caps!", __func__);
! 385: exit (1);
! 386: }
! 387:
! 388: /* to raise: copy original permitted into our working effective set
! 389: * to lower: just clear the working effective set
! 390: */
! 391: if (op == ZPRIVS_RAISE)
! 392: priv_copyset (zprivs_state.syscaps_p, zprivs_state.caps);
! 393: else if (op == ZPRIVS_LOWER)
! 394: priv_emptyset (zprivs_state.caps);
! 395: else
! 396: return -1;
! 397:
! 398: if (setppriv (PRIV_SET, PRIV_EFFECTIVE, zprivs_state.caps) != 0)
! 399: return -1;
! 400:
! 401: return 0;
! 402: }
! 403:
! 404: /* Retrieve current privilege state, is it RAISED or LOWERED? */
! 405: zebra_privs_current_t
! 406: zprivs_state_caps (void)
! 407: {
! 408: zebra_privs_current_t result;
! 409: pset_t *effective;
! 410:
! 411: if ( (effective = priv_allocset()) == NULL)
! 412: {
! 413: fprintf (stderr, "%s: failed to get priv_allocset! %s\n", __func__,
! 414: safe_strerror (errno));
! 415: return ZPRIVS_UNKNOWN;
! 416: }
! 417:
! 418: if (getppriv (PRIV_EFFECTIVE, effective))
! 419: {
! 420: fprintf (stderr, "%s: failed to get state! %s\n", __func__,
! 421: safe_strerror (errno));
! 422: result = ZPRIVS_UNKNOWN;
! 423: }
! 424: else
! 425: {
! 426: if (priv_isemptyset (effective) == B_TRUE)
! 427: result = ZPRIVS_LOWERED;
! 428: else
! 429: result = ZPRIVS_RAISED;
! 430: }
! 431:
! 432: if (effective)
! 433: priv_freeset (effective);
! 434:
! 435: return result;
! 436: }
! 437:
! 438: static void
! 439: zprivs_caps_init (struct zebra_privs_t *zprivs)
! 440: {
! 441: pset_t *basic;
! 442: pset_t *empty;
! 443:
! 444: /* the specified sets */
! 445: zprivs_state.syscaps_p = zcaps2sys (zprivs->caps_p, zprivs->cap_num_p);
! 446: zprivs_state.syscaps_i = zcaps2sys (zprivs->caps_i, zprivs->cap_num_i);
! 447:
! 448: /* nonsensical to have gotten here but not have capabilities */
! 449: if (!zprivs_state.syscaps_p)
! 450: {
! 451: fprintf (stderr, "%s: capabilities enabled, "
! 452: "but no valid capabilities supplied\n",
! 453: __func__);
! 454: }
! 455:
! 456: /* We retain the basic set in our permitted set, as Linux has no
! 457: * equivalent. The basic set on Linux hence is implicit, always
! 458: * there.
! 459: */
! 460: if ((basic = priv_str_to_set("basic", ",", NULL)) == NULL)
! 461: {
! 462: fprintf (stderr, "%s: couldn't get basic set!\n", __func__);
! 463: exit (1);
! 464: }
! 465:
! 466: /* Add the basic set to the permitted set */
! 467: priv_union (basic, zprivs_state.syscaps_p);
! 468: priv_freeset (basic);
! 469:
! 470: /* we need an empty set for 'effective', potentially for inheritable too */
! 471: if ( (empty = priv_allocset()) == NULL)
! 472: {
! 473: fprintf (stderr, "%s: couldn't get empty set!\n", __func__);
! 474: exit (1);
! 475: }
! 476: priv_emptyset (empty);
! 477:
! 478: /* Hey kernel, we know about privileges!
! 479: * this isn't strictly required, use of setppriv should have same effect
! 480: */
! 481: if (setpflags (PRIV_AWARE, 1))
! 482: {
! 483: fprintf (stderr, "%s: error setting PRIV_AWARE!, %s\n", __func__,
! 484: safe_strerror (errno) );
! 485: exit (1);
! 486: }
! 487:
! 488: /* need either valid or empty sets for both p and i.. */
! 489: assert (zprivs_state.syscaps_i && zprivs_state.syscaps_p);
! 490:
! 491: /* we have caps, we have no need to ever change back the original user
! 492: * change real, effective and saved to the specified user.
! 493: */
! 494: if (zprivs_state.zuid)
! 495: {
! 496: if ( setreuid (zprivs_state.zuid, zprivs_state.zuid) )
! 497: {
! 498: fprintf (stderr, "%s: could not setreuid, %s\n",
! 499: __func__, safe_strerror (errno));
! 500: exit (1);
! 501: }
! 502: }
! 503:
! 504: /* set the permitted set */
! 505: if (setppriv (PRIV_SET, PRIV_PERMITTED, zprivs_state.syscaps_p))
! 506: {
! 507: fprintf (stderr, "%s: error setting permitted set!, %s\n", __func__,
! 508: safe_strerror (errno) );
! 509: exit (1);
! 510: }
! 511:
! 512: /* set the inheritable set */
! 513: if (setppriv (PRIV_SET, PRIV_INHERITABLE, zprivs_state.syscaps_i))
! 514: {
! 515: fprintf (stderr, "%s: error setting inheritable set!, %s\n", __func__,
! 516: safe_strerror (errno) );
! 517: exit (1);
! 518: }
! 519:
! 520: /* now clear the effective set and we're ready to go */
! 521: if (setppriv (PRIV_SET, PRIV_EFFECTIVE, empty))
! 522: {
! 523: fprintf (stderr, "%s: error setting effective set!, %s\n", __func__,
! 524: safe_strerror (errno) );
! 525: exit (1);
! 526: }
! 527:
! 528: /* we'll use this as our working-storage privset */
! 529: zprivs_state.caps = empty;
! 530:
! 531: /* set methods for the caller to use */
! 532: zprivs->change = zprivs_change_caps;
! 533: zprivs->current_state = zprivs_state_caps;
! 534: }
! 535:
! 536: static void
! 537: zprivs_caps_terminate (void)
! 538: {
! 539: assert (zprivs_state.caps);
! 540:
! 541: /* clear all capabilities */
! 542: priv_emptyset (zprivs_state.caps);
! 543: setppriv (PRIV_SET, PRIV_EFFECTIVE, zprivs_state.caps);
! 544: setppriv (PRIV_SET, PRIV_PERMITTED, zprivs_state.caps);
! 545: setppriv (PRIV_SET, PRIV_INHERITABLE, zprivs_state.caps);
! 546:
! 547: /* free up private state */
! 548: if (zprivs_state.syscaps_p)
! 549: priv_freeset (zprivs_state.syscaps_p);
! 550: if (zprivs_state.syscaps_i)
! 551: priv_freeset (zprivs_state.syscaps_i);
! 552:
! 553: priv_freeset (zprivs_state.caps);
! 554: }
! 555: #else /* !HAVE_LCAPS && ! HAVE_SOLARIS_CAPABILITIES */
! 556: #error "Neither Solaris nor Linux capabilities, dazed and confused..."
! 557: #endif /* HAVE_LCAPS */
! 558: #endif /* HAVE_CAPABILITIES */
! 559:
! 560: int
! 561: zprivs_change_uid (zebra_privs_ops_t op)
! 562: {
! 563:
! 564: if (op == ZPRIVS_RAISE)
! 565: return seteuid (zprivs_state.zsuid);
! 566: else if (op == ZPRIVS_LOWER)
! 567: return seteuid (zprivs_state.zuid);
! 568: else
! 569: return -1;
! 570: }
! 571:
! 572: zebra_privs_current_t
! 573: zprivs_state_uid (void)
! 574: {
! 575: return ( (zprivs_state.zuid == geteuid()) ? ZPRIVS_LOWERED : ZPRIVS_RAISED);
! 576: }
! 577:
! 578: int
! 579: zprivs_change_null (zebra_privs_ops_t op)
! 580: {
! 581: return 0;
! 582: }
! 583:
! 584: zebra_privs_current_t
! 585: zprivs_state_null (void)
! 586: {
! 587: return zprivs_null_state;
! 588: }
! 589:
! 590: void
! 591: zprivs_init(struct zebra_privs_t *zprivs)
! 592: {
! 593: struct passwd *pwentry = NULL;
! 594: struct group *grentry = NULL;
! 595:
! 596: if (!zprivs)
! 597: {
! 598: fprintf (stderr, "zprivs_init: called with NULL arg!\n");
! 599: exit (1);
! 600: }
! 601:
! 602: /* NULL privs */
! 603: if (! (zprivs->user || zprivs->group
! 604: || zprivs->cap_num_p || zprivs->cap_num_i) )
! 605: {
! 606: zprivs->change = zprivs_change_null;
! 607: zprivs->current_state = zprivs_state_null;
! 608: return;
! 609: }
! 610:
! 611: if (zprivs->user)
! 612: {
! 613: if ( (pwentry = getpwnam (zprivs->user)) )
! 614: {
! 615: zprivs_state.zuid = pwentry->pw_uid;
! 616: }
! 617: else
! 618: {
! 619: /* cant use log.h here as it depends on vty */
! 620: fprintf (stderr, "privs_init: could not lookup user %s\n",
! 621: zprivs->user);
! 622: exit (1);
! 623: }
! 624: }
! 625:
! 626: grentry = NULL;
! 627:
! 628: if (zprivs->vty_group)
! 629: /* Add the vty_group to the supplementary groups so it can be chowned to */
! 630: {
! 631: if ( (grentry = getgrnam (zprivs->vty_group)) )
! 632: {
! 633: zprivs_state.vtygrp = grentry->gr_gid;
! 634: if ( setgroups (1, &zprivs_state.vtygrp) )
! 635: {
! 636: fprintf (stderr, "privs_init: could not setgroups, %s\n",
! 637: safe_strerror (errno) );
! 638: exit (1);
! 639: }
! 640: }
! 641: else
! 642: {
! 643: fprintf (stderr, "privs_init: could not lookup vty group %s\n",
! 644: zprivs->vty_group);
! 645: exit (1);
! 646: }
! 647: }
! 648:
! 649: if (zprivs->group)
! 650: {
! 651: if ( (grentry = getgrnam (zprivs->group)) )
! 652: {
! 653: zprivs_state.zgid = grentry->gr_gid;
! 654: }
! 655: else
! 656: {
! 657: fprintf (stderr, "privs_init: could not lookup group %s\n",
! 658: zprivs->group);
! 659: exit (1);
! 660: }
! 661: /* change group now, forever. uid we do later */
! 662: if ( setregid (zprivs_state.zgid, zprivs_state.zgid) )
! 663: {
! 664: fprintf (stderr, "zprivs_init: could not setregid, %s\n",
! 665: safe_strerror (errno) );
! 666: exit (1);
! 667: }
! 668: }
! 669:
! 670: #ifdef HAVE_CAPABILITIES
! 671: zprivs_caps_init (zprivs);
! 672: #else /* !HAVE_CAPABILITIES */
! 673: /* we dont have caps. we'll need to maintain rid and saved uid
! 674: * and change euid back to saved uid (who we presume has all neccessary
! 675: * privileges) whenever we are asked to raise our privileges.
! 676: *
! 677: * This is not worth that much security wise, but all we can do.
! 678: */
! 679: zprivs_state.zsuid = geteuid();
! 680: if ( zprivs_state.zuid )
! 681: {
! 682: if ( setreuid (-1, zprivs_state.zuid) )
! 683: {
! 684: fprintf (stderr, "privs_init (uid): could not setreuid, %s\n",
! 685: safe_strerror (errno));
! 686: exit (1);
! 687: }
! 688: }
! 689:
! 690: zprivs->change = zprivs_change_uid;
! 691: zprivs->current_state = zprivs_state_uid;
! 692: #endif /* HAVE_CAPABILITIES */
! 693: }
! 694:
! 695: void
! 696: zprivs_terminate (struct zebra_privs_t *zprivs)
! 697: {
! 698: if (!zprivs)
! 699: {
! 700: fprintf (stderr, "%s: no privs struct given, terminating", __func__);
! 701: exit (0);
! 702: }
! 703:
! 704: #ifdef HAVE_CAPABILITIES
! 705: zprivs_caps_terminate();
! 706: #else /* !HAVE_CAPABILITIES */
! 707: if (zprivs_state.zuid)
! 708: {
! 709: if ( setreuid (zprivs_state.zuid, zprivs_state.zuid) )
! 710: {
! 711: fprintf (stderr, "privs_terminate: could not setreuid, %s",
! 712: safe_strerror (errno) );
! 713: exit (1);
! 714: }
! 715: }
! 716: #endif /* HAVE_LCAPS */
! 717:
! 718: zprivs->change = zprivs_change_null;
! 719: zprivs->current_state = zprivs_state_null;
! 720: zprivs_null_state = ZPRIVS_LOWERED;
! 721: return;
! 722: }
! 723:
! 724: void
! 725: zprivs_get_ids(struct zprivs_ids_t *ids)
! 726: {
! 727:
! 728: ids->uid_priv = getuid();
! 729: (zprivs_state.zuid) ? (ids->uid_normal = zprivs_state.zuid)
! 730: : (ids->uid_normal = -1);
! 731: (zprivs_state.zgid) ? (ids->gid_normal = zprivs_state.zgid)
! 732: : (ids->gid_normal = -1);
! 733: (zprivs_state.vtygrp) ? (ids->gid_vty = zprivs_state.vtygrp)
! 734: : (ids->gid_vty = -1);
! 735:
! 736: return;
! 737: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to privs.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib