2 Unix SMB/CIFS implementation.
4 Copyright (C) Tim Potter 2000
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 extern struct current_user current_user;
30 /* A stack of security contexts. We include the current context as being
31 the first one, so there is room for another MAX_SEC_CTX_DEPTH more. */
33 static struct sec_ctx sec_ctx_stack[MAX_SEC_CTX_DEPTH + 1];
34 static int sec_ctx_stack_ndx;
36 /****************************************************************************
37 Become the specified uid.
38 ****************************************************************************/
40 static BOOL become_uid(uid_t uid)
42 /* Check for dodgy uid values */
44 if (uid == (uid_t)-1 ||
45 ((sizeof(uid_t) == 2) && (uid == (uid_t)65535))) {
49 DEBUG(1,("WARNING: using uid %d is a security risk\n",
55 /* Set effective user id */
57 set_effective_uid(uid);
59 DO_PROFILE_INC(uid_changes);
63 /****************************************************************************
64 Become the specified gid.
65 ****************************************************************************/
67 static BOOL become_gid(gid_t gid)
69 /* Check for dodgy gid values */
71 if (gid == (gid_t)-1 || ((sizeof(gid_t) == 2) &&
72 (gid == (gid_t)65535))) {
76 DEBUG(1,("WARNING: using gid %d is a security risk\n",
82 /* Set effective group id */
84 set_effective_gid(gid);
88 /****************************************************************************
89 Become the specified uid and gid.
90 ****************************************************************************/
92 static BOOL become_id(uid_t uid, gid_t gid)
94 return become_gid(gid) && become_uid(uid);
97 /****************************************************************************
98 Drop back to root privileges in order to change to another user.
99 ****************************************************************************/
101 static void gain_root(void)
103 if (non_root_mode()) {
107 if (geteuid() != 0) {
108 set_effective_uid(0);
110 if (geteuid() != 0) {
112 ("Warning: You appear to have a trapdoor "
117 if (getegid() != 0) {
118 set_effective_gid(0);
120 if (getegid() != 0) {
122 ("Warning: You appear to have a trapdoor "
128 /****************************************************************************
129 Get the list of current groups.
130 ****************************************************************************/
132 int get_current_groups(gid_t gid, int *p_ngroups, gid_t **p_groups)
137 gid_t *groups = NULL;
142 /* this looks a little strange, but is needed to cope with
143 systems that put the current egid in the group list
144 returned from getgroups() (tridge) */
146 set_effective_gid(gid);
149 ngroups = sys_getgroups(0,&grp);
154 if((groups = SMB_MALLOC_ARRAY(gid_t, ngroups+1)) == NULL) {
155 DEBUG(0,("setup_groups malloc fail !\n"));
159 if ((ngroups = sys_getgroups(ngroups,groups)) == -1) {
165 (*p_ngroups) = ngroups;
166 (*p_groups) = groups;
168 DEBUG( 3, ( "get_current_groups: user is in %u groups: ", ngroups));
169 for (i = 0; i < ngroups; i++ ) {
170 DEBUG( 3, ( "%s%d", (i ? ", " : ""), (int)groups[i] ) );
172 DEBUG( 3, ( "\n" ) );
182 /****************************************************************************
183 Initialize the groups a user belongs to.
184 ****************************************************************************/
186 BOOL initialise_groups(char *user, uid_t uid, gid_t gid)
188 struct sec_ctx *prev_ctx_p;
191 if (non_root_mode()) {
197 /* Call initgroups() to get user groups */
199 if (winbind_initgroups(user,gid) == -1) {
200 DEBUG(0,("Unable to initgroups. Error was %s\n", strerror(errno) ));
202 if (gid < 0 || gid > 32767 || uid < 0 || uid > 32767) {
203 DEBUG(0,("This is probably a problem with the account %s\n", user));
210 /* Store groups in previous user's security context. This will
211 always work as the become_root() call increments the stack
214 prev_ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx - 1];
216 SAFE_FREE(prev_ctx_p->ut.groups);
217 prev_ctx_p->ut.ngroups = 0;
219 get_current_groups(gid, &prev_ctx_p->ut.ngroups, &prev_ctx_p->ut.groups);
227 /****************************************************************************
228 Create a new security context on the stack. It is the same as the old
229 one. User changes are done using the set_sec_ctx() function.
230 ****************************************************************************/
232 BOOL push_sec_ctx(void)
234 struct sec_ctx *ctx_p;
236 /* Check we don't overflow our stack */
238 if (sec_ctx_stack_ndx == MAX_SEC_CTX_DEPTH) {
239 DEBUG(0, ("Security context stack overflow!\n"));
240 smb_panic("Security context stack overflow!\n");
243 /* Store previous user context */
247 ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx];
249 ctx_p->ut.uid = geteuid();
250 ctx_p->ut.gid = getegid();
252 DEBUG(3, ("push_sec_ctx(%u, %u) : sec_ctx_stack_ndx = %d\n",
253 (unsigned int)ctx_p->ut.uid, (unsigned int)ctx_p->ut.gid, sec_ctx_stack_ndx ));
255 ctx_p->token = dup_nt_token(sec_ctx_stack[sec_ctx_stack_ndx-1].token);
257 ctx_p->ut.ngroups = sys_getgroups(0, NULL);
259 if (ctx_p->ut.ngroups != 0) {
260 if (!(ctx_p->ut.groups = SMB_MALLOC_ARRAY(gid_t, ctx_p->ut.ngroups))) {
261 DEBUG(0, ("Out of memory in push_sec_ctx()\n"));
262 delete_nt_token(&ctx_p->token);
266 sys_getgroups(ctx_p->ut.ngroups, ctx_p->ut.groups);
268 ctx_p->ut.groups = NULL;
274 /****************************************************************************
275 Set the current security context to a given user.
276 ****************************************************************************/
278 void set_sec_ctx(uid_t uid, gid_t gid, int ngroups, gid_t *groups, NT_USER_TOKEN *token)
280 struct sec_ctx *ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx];
282 /* Set the security context */
284 DEBUG(3, ("setting sec ctx (%u, %u) - sec_ctx_stack_ndx = %d\n",
285 (unsigned int)uid, (unsigned int)gid, sec_ctx_stack_ndx));
287 debug_nt_user_token(DBGC_CLASS, 5, token);
288 debug_unix_user_token(DBGC_CLASS, 5, uid, gid, ngroups, groups);
292 #ifdef HAVE_SETGROUPS
293 sys_setgroups(ngroups, groups);
296 ctx_p->ut.ngroups = ngroups;
298 SAFE_FREE(ctx_p->ut.groups);
299 if (token && (token == ctx_p->token))
300 smb_panic("DUPLICATE_TOKEN");
302 delete_nt_token(&ctx_p->token);
304 ctx_p->ut.groups = memdup(groups, sizeof(gid_t) * ngroups);
305 ctx_p->token = dup_nt_token(token);
312 /* Update current_user stuff */
314 current_user.ut.uid = uid;
315 current_user.ut.gid = gid;
316 current_user.ut.ngroups = ngroups;
317 current_user.ut.groups = groups;
318 current_user.nt_user_token = ctx_p->token;
321 /****************************************************************************
323 ****************************************************************************/
325 void set_root_sec_ctx(void)
327 /* May need to worry about supplementary groups at some stage */
329 set_sec_ctx(0, 0, 0, NULL, NULL);
332 /****************************************************************************
333 Pop a security context from the stack.
334 ****************************************************************************/
336 BOOL pop_sec_ctx(void)
338 struct sec_ctx *ctx_p;
339 struct sec_ctx *prev_ctx_p;
341 /* Check for stack underflow */
343 if (sec_ctx_stack_ndx == 0) {
344 DEBUG(0, ("Security context stack underflow!\n"));
345 smb_panic("Security context stack underflow!\n");
348 ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx];
350 /* Clear previous user info */
352 ctx_p->ut.uid = (uid_t)-1;
353 ctx_p->ut.gid = (gid_t)-1;
355 SAFE_FREE(ctx_p->ut.groups);
356 ctx_p->ut.ngroups = 0;
358 delete_nt_token(&ctx_p->token);
360 /* Pop back previous user */
366 prev_ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx];
368 #ifdef HAVE_SETGROUPS
369 sys_setgroups(prev_ctx_p->ut.ngroups, prev_ctx_p->ut.groups);
372 become_id(prev_ctx_p->ut.uid, prev_ctx_p->ut.gid);
374 /* Update current_user stuff */
376 current_user.ut.uid = prev_ctx_p->ut.uid;
377 current_user.ut.gid = prev_ctx_p->ut.gid;
378 current_user.ut.ngroups = prev_ctx_p->ut.ngroups;
379 current_user.ut.groups = prev_ctx_p->ut.groups;
380 current_user.nt_user_token = prev_ctx_p->token;
382 DEBUG(3, ("pop_sec_ctx (%u, %u) - sec_ctx_stack_ndx = %d\n",
383 (unsigned int)geteuid(), (unsigned int)getegid(), sec_ctx_stack_ndx));
388 /* Initialise the security context system */
390 void init_sec_ctx(void)
393 struct sec_ctx *ctx_p;
395 /* Initialise security context stack */
397 memset(sec_ctx_stack, 0, sizeof(struct sec_ctx) * MAX_SEC_CTX_DEPTH);
399 for (i = 0; i < MAX_SEC_CTX_DEPTH; i++) {
400 sec_ctx_stack[i].ut.uid = (uid_t)-1;
401 sec_ctx_stack[i].ut.gid = (gid_t)-1;
404 /* Initialise first level of stack. It is the current context */
405 ctx_p = &sec_ctx_stack[0];
407 ctx_p->ut.uid = geteuid();
408 ctx_p->ut.gid = getegid();
410 get_current_groups(ctx_p->ut.gid, &ctx_p->ut.ngroups, &ctx_p->ut.groups);
412 ctx_p->token = NULL; /* Maps to guest user. */
414 /* Initialise current_user global */
416 current_user.ut.uid = ctx_p->ut.uid;
417 current_user.ut.gid = ctx_p->ut.gid;
418 current_user.ut.ngroups = ctx_p->ut.ngroups;
419 current_user.ut.groups = ctx_p->ut.groups;
421 /* The conn and vuid are usually taken care of by other modules.
422 We initialise them here. */
424 current_user.conn = NULL;
425 current_user.vuid = UID_FIELD_INVALID;
426 current_user.nt_user_token = NULL;