source: branches/samba-3.0/source/smbd/sec_ctx.c@ 710

/* 
   Unix SMB/CIFS implementation.
   uid/user handling
   Copyright (C) Tim Potter 2000
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"

extern struct current_user current_user;

struct sec_ctx {
        UNIX_USER_TOKEN ut;
        NT_USER_TOKEN *token;
};

/* A stack of security contexts.  We include the current context as being
   the first one, so there is room for another MAX_SEC_CTX_DEPTH more. */

static struct sec_ctx sec_ctx_stack[MAX_SEC_CTX_DEPTH + 1];
static int sec_ctx_stack_ndx;

/****************************************************************************
 Become the specified uid.
****************************************************************************/

static BOOL become_uid(uid_t uid)
{
        /* Check for dodgy uid values */

        if (uid == (uid_t)-1 || 
            ((sizeof(uid_t) == 2) && (uid == (uid_t)65535))) {
                static int done;
 
                if (!done) {
                        DEBUG(1,("WARNING: using uid %d is a security risk\n",
                                 (int)uid));
                        done = 1;
                }
        }

        /* Set effective user id */

        set_effective_uid(uid);

        DO_PROFILE_INC(uid_changes);
        return True;
}

/****************************************************************************
 Become the specified gid.
****************************************************************************/

static BOOL become_gid(gid_t gid)
{
        /* Check for dodgy gid values */

        if (gid == (gid_t)-1 || ((sizeof(gid_t) == 2) && 
                                 (gid == (gid_t)65535))) {
                static int done;
                
                if (!done) {
                        DEBUG(1,("WARNING: using gid %d is a security risk\n",
                                 (int)gid));  
                        done = 1;
                }
        }
  
        /* Set effective group id */

        set_effective_gid(gid);
        return True;
}

/****************************************************************************
 Become the specified uid and gid.
****************************************************************************/

static BOOL become_id(uid_t uid, gid_t gid)
{
        return become_gid(gid) && become_uid(uid);
}

/****************************************************************************
 Drop back to root privileges in order to change to another user.
****************************************************************************/

static void gain_root(void)
{
        if (non_root_mode()) {
                return;
        }

        if (geteuid() != 0) {
                set_effective_uid(0);

                if (geteuid() != 0) {
                        DEBUG(0,
                              ("Warning: You appear to have a trapdoor "
                               "uid system\n"));
                }
        }

        if (getegid() != 0) {
                set_effective_gid(0);

                if (getegid() != 0) {
                        DEBUG(0,
                              ("Warning: You appear to have a trapdoor "
                               "gid system\n"));
                }
        }
}

/****************************************************************************
 Get the list of current groups.
****************************************************************************/

static int get_current_groups(gid_t gid, int *p_ngroups, gid_t **p_groups)
{
        int i;
        gid_t grp;
        int ngroups;
        gid_t *groups = NULL;

        (*p_ngroups) = 0;
        (*p_groups) = NULL;

        /* this looks a little strange, but is needed to cope with
           systems that put the current egid in the group list
           returned from getgroups() (tridge) */
        save_re_gid();
        set_effective_gid(gid);
        setgid(gid);

        ngroups = sys_getgroups(0,&grp);
        if (ngroups <= 0) {
                goto fail;
        }

        if((groups = SMB_MALLOC_ARRAY(gid_t, ngroups+1)) == NULL) {
                DEBUG(0,("setup_groups malloc fail !\n"));
                goto fail;
        }

        if ((ngroups = sys_getgroups(ngroups,groups)) == -1) {
                goto fail;
        }

        restore_re_gid();

        (*p_ngroups) = ngroups;
        (*p_groups) = groups;

        DEBUG( 3, ( "get_current_groups: user is in %u groups: ", ngroups));
        for (i = 0; i < ngroups; i++ ) {
                DEBUG( 3, ( "%s%d", (i ? ", " : ""), (int)groups[i] ) );
        }
        DEBUG( 3, ( "\n" ) );

        return ngroups;

fail:
        SAFE_FREE(groups);
        restore_re_gid();
        return -1;
}