common/syscall/gid.c

	gid.c revision ddf7fe95b8ad67aa16deb427a0b78f4dd4ff22b1
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/param.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/cred_impl.h>
#include <sys/errno.h>
#include <sys/proc.h>
#include <sys/debug.h>
#include <sys/policy.h>


int
setgid(gid_t gid)
{
    proc_t *p;
    int error;
    int do_nocd = 0;
    cred_t  *cr, *newcr;
    ksid_t ksid, *ksp;
    zone_t  *zone = crgetzone(CRED());


    if (!VALID_GID(gid, zone))
        return (set_errno(EINVAL));

    if (gid > MAXUID) {
        if (ksid_lookupbygid(zone, gid, &ksid) != 0)
            return (set_errno(EINVAL));
        ksp = &ksid;
    } else {
        ksp = NULL;
    }

    /*
     * Need to pre-allocate the new cred structure before grabbing
     * the p_crlock mutex.  We cannot hold the mutex across the
     * secpolicy functions.
     */
    newcr = cralloc_ksid();
    p = ttoproc(curthread);
    mutex_enter(&p->p_crlock);
retry:
    cr = p->p_cred;
    crhold(cr);
    mutex_exit(&p->p_crlock);


    if ((gid == cr->cr_rgid || gid == cr->cr_sgid) &&
        secpolicy_allow_setid(cr, -1, B_TRUE) != 0) {
        mutex_enter(&p->p_crlock);
        crfree(cr);
        if (cr != p->p_cred)
            goto retry;
        error = 0;
        crcopy_to(cr, newcr);
        p->p_cred = newcr;
        newcr->cr_gid = gid;
        crsetsid(newcr, ksp, KSID_GROUP);
        mutex_exit(&p->p_crlock);
    } else if ((error = secpolicy_allow_setid(cr, -1, B_FALSE)) == 0) {
        mutex_enter(&p->p_crlock);
        crfree(cr);
        if (cr != p->p_cred)
            goto retry;
        /*
         * A privileged process that makes itself look like a
         * set-gid process must be marked to produce no core dump.
         */
        if (cr->cr_gid != gid ||
            cr->cr_rgid != gid ||
            cr->cr_sgid != gid)
            do_nocd = 1;
        crcopy_to(cr, newcr);
        p->p_cred = newcr;
        newcr->cr_gid = gid;
        newcr->cr_rgid = gid;
        newcr->cr_sgid = gid;
        crsetsid(newcr, ksp, KSID_GROUP);
        mutex_exit(&p->p_crlock);
    } else {
        crfree(newcr);
        crfree(cr);
        if (ksp != NULL)
            ksid_rele(ksp);

    }

    if (error == 0) {
        if (do_nocd) {
            mutex_enter(&p->p_lock);
            p->p_flag |= SNOCD;
            mutex_exit(&p->p_lock);
        }
        crset(p, newcr);    /* broadcast to process threads */
        return (0);
    }
    return (set_errno(error));
}

int64_t
getgid(void)
{
    rval_t  r;
    cred_t  *cr;

    cr = curthread->t_cred;
    r.r_val1 = cr->cr_rgid;
    r.r_val2 = cr->cr_gid;
    return (r.r_vals);
}

int
setegid(gid_t gid)
{
    proc_t *p;
    cred_t  *cr, *newcr;
    int error = EPERM;
    int do_nocd = 0;
    ksid_t ksid, *ksp;
    zone_t  *zone = crgetzone(CRED());

    if (!VALID_GID(gid, zone))
        return (set_errno(EINVAL));

    if (gid > MAXUID) {
        if (ksid_lookupbygid(zone, gid, &ksid) != 0)
            return (set_errno(EINVAL));
        ksp = &ksid;
    } else {
        ksp = NULL;
    }
    /*
     * Need to pre-allocate the new cred structure before grabbing
     * the p_crlock mutex.
     */
    newcr = cralloc_ksid();
    p = ttoproc(curthread);
    mutex_enter(&p->p_crlock);
retry:
    crhold(cr = p->p_cred);
    mutex_exit(&p->p_crlock);

    if (gid == cr->cr_rgid || gid == cr->cr_gid || gid == cr->cr_sgid ||
        (error = secpolicy_allow_setid(cr, -1, B_FALSE)) == 0) {
        mutex_enter(&p->p_crlock);
        crfree(cr);
        if (cr != p->p_cred)
            goto retry;
        /*
         * A privileged process that makes itself look like a
         * set-gid process must be marked to produce no core dump.
         */
        if (cr->cr_gid != gid && error == 0)
            do_nocd = 1;
        error = 0;
        crcopy_to(cr, newcr);
        p->p_cred = newcr;
        newcr->cr_gid = gid;
        crsetsid(newcr, ksp, KSID_GROUP);
        mutex_exit(&p->p_crlock);
    } else {
        crfree(newcr);
        crfree(cr);
        if (ksp != NULL)
            ksid_rele(ksp);
    }

    if (error == 0) {
        if (do_nocd) {
            mutex_enter(&p->p_lock);
            p->p_flag |= SNOCD;
            mutex_exit(&p->p_lock);
        }
        crset(p, newcr);    /* broadcast to process threads */
        return (0);
    }
    return (set_errno(error));
}

/*
 * Buy-back from SunOS 4.x
 *
 * Like setgid() and setegid() combined -except- that non-root users
 * can change cr_rgid to cr_gid, and the semantics of cr_sgid are
 * subtly different.
 */
int
setregid(gid_t rgid, gid_t egid)
{
    proc_t *p;
    int error = EPERM;
    int do_nocd = 0;
    cred_t *cr, *newcr;
    ksid_t ksid, *ksp;
    zone_t  *zone = crgetzone(CRED());

    if ((rgid != -1 && !VALID_GID(rgid, zone)) ||
        (egid != -1 && !VALID_GID(egid, zone)))
        return (set_errno(EINVAL));

    if (egid != -1 && egid > MAXUID) {
        if (ksid_lookupbygid(zone, egid, &ksid) != 0)
            return (set_errno(EINVAL));
        ksp = &ksid;
    } else {
        ksp = NULL;
    }
    /*
     * Need to pre-allocate the new cred structure before grabbing
     * the p_crlock mutex.
     */
    newcr = cralloc_ksid();

    p = ttoproc(curthread);
    mutex_enter(&p->p_crlock);
    cr = p->p_cred;

    if ((rgid == -1 ||
        rgid == cr->cr_rgid || rgid == cr->cr_gid || rgid == cr->cr_sgid) &&
        (egid == -1 || egid == cr->cr_rgid || egid == cr->cr_gid ||
        egid == cr->cr_sgid) ||
        (error = secpolicy_allow_setid(cr, -1, B_FALSE)) == 0) {
        crhold(cr);
        crcopy_to(cr, newcr);
        p->p_cred = newcr;

        if (egid != -1) {
            newcr->cr_gid = egid;
            crsetsid(newcr, ksp, KSID_GROUP);
        }
        if (rgid != -1)
            newcr->cr_rgid = rgid;
        /*
         * "If the real gid is being changed, or the effective gid is
         * being changed to a value not equal to the real gid, the
         * saved gid is set to the new effective gid."
         */
        if (rgid != -1 ||
            (egid != -1 && newcr->cr_gid != newcr->cr_rgid))
            newcr->cr_sgid = newcr->cr_gid;
        /*
         * A privileged process that makes itself look like a
         * set-gid process must be marked to produce no core dump.
         */
        if ((cr->cr_gid != newcr->cr_gid ||
            cr->cr_rgid != newcr->cr_rgid ||
            cr->cr_sgid != newcr->cr_sgid) && error == 0)
            do_nocd = 1;
        error = 0;
        crfree(cr);
    }
    mutex_exit(&p->p_crlock);

    if (error == 0) {
        if (do_nocd) {
            mutex_enter(&p->p_lock);
            p->p_flag |= SNOCD;
            mutex_exit(&p->p_lock);
        }
        crset(p, newcr);    /* broadcast to process threads */
        return (0);
    }
    crfree(newcr);
    if (ksp != NULL)
        ksid_rele(ksp);
    return (set_errno(error));
}