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
;
34 /* A stack of security contexts. We include the current context as being
35 the first one, so there is room for another MAX_SEC_CTX_DEPTH more. */
37 static struct sec_ctx sec_ctx_stack
[MAX_SEC_CTX_DEPTH
+ 1];
38 static int sec_ctx_stack_ndx
;
40 /****************************************************************************
41 Become the specified uid.
42 ****************************************************************************/
44 static BOOL
become_uid(uid_t uid
)
46 /* Check for dodgy uid values */
48 if (uid
== (uid_t
)-1 ||
49 ((sizeof(uid_t
) == 2) && (uid
== (uid_t
)65535))) {
53 DEBUG(1,("WARNING: using uid %d is a security risk\n",
59 /* Set effective user id */
61 set_effective_uid(uid
);
63 DO_PROFILE_INC(uid_changes
);
67 /****************************************************************************
68 Become the specified gid.
69 ****************************************************************************/
71 static BOOL
become_gid(gid_t gid
)
73 /* Check for dodgy gid values */
75 if (gid
== (gid_t
)-1 || ((sizeof(gid_t
) == 2) &&
76 (gid
== (gid_t
)65535))) {
80 DEBUG(1,("WARNING: using gid %d is a security risk\n",
86 /* Set effective group id */
88 set_effective_gid(gid
);
92 /****************************************************************************
93 Become the specified uid and gid.
94 ****************************************************************************/
96 static BOOL
become_id(uid_t uid
, gid_t gid
)
98 return become_gid(gid
) && become_uid(uid
);
101 /****************************************************************************
102 Drop back to root privileges in order to change to another user.
103 ****************************************************************************/
105 static void gain_root(void)
107 if (non_root_mode()) {
111 if (geteuid() != 0) {
112 set_effective_uid(0);
114 if (geteuid() != 0) {
116 ("Warning: You appear to have a trapdoor "
121 if (getegid() != 0) {
122 set_effective_gid(0);
124 if (getegid() != 0) {
126 ("Warning: You appear to have a trapdoor "
132 /****************************************************************************
133 Get the list of current groups.
134 ****************************************************************************/
136 int get_current_groups(gid_t gid
, int *p_ngroups
, gid_t
**p_groups
)
141 gid_t
*groups
= NULL
;
146 /* this looks a little strange, but is needed to cope with
147 systems that put the current egid in the group list
148 returned from getgroups() (tridge) */
150 set_effective_gid(gid
);
153 ngroups
= sys_getgroups(0,&grp
);
158 if((groups
= (gid_t
*)malloc(sizeof(gid_t
)*(ngroups
+1))) == NULL
) {
159 DEBUG(0,("setup_groups malloc fail !\n"));
163 if ((ngroups
= sys_getgroups(ngroups
,groups
)) == -1) {
169 (*p_ngroups
) = ngroups
;
170 (*p_groups
) = groups
;
172 DEBUG( 3, ( "get_current_groups: user is in %u groups: ", ngroups
));
173 for (i
= 0; i
< ngroups
; i
++ ) {
174 DEBUG( 3, ( "%s%d", (i
? ", " : ""), (int)groups
[i
] ) );
176 DEBUG( 3, ( "\n" ) );
186 /****************************************************************************
187 Initialize the groups a user belongs to.
188 ****************************************************************************/
190 BOOL
initialise_groups(char *user
, uid_t uid
, gid_t gid
)
192 struct sec_ctx
*prev_ctx_p
;
195 if (non_root_mode()) {
201 /* Call initgroups() to get user groups */
203 if (winbind_initgroups(user
,gid
) == -1) {
204 DEBUG(0,("Unable to initgroups. Error was %s\n", strerror(errno
) ));
206 if (gid
< 0 || gid
> 32767 || uid
< 0 || uid
> 32767) {
207 DEBUG(0,("This is probably a problem with the account %s\n", user
));
214 /* Store groups in previous user's security context. This will
215 always work as the become_root() call increments the stack
218 prev_ctx_p
= &sec_ctx_stack
[sec_ctx_stack_ndx
- 1];
220 SAFE_FREE(prev_ctx_p
->groups
);
221 prev_ctx_p
->ngroups
= 0;
223 get_current_groups(gid
, &prev_ctx_p
->ngroups
, &prev_ctx_p
->groups
);
231 /****************************************************************************
232 Create a new security context on the stack. It is the same as the old
233 one. User changes are done using the set_sec_ctx() function.
234 ****************************************************************************/
236 BOOL
push_sec_ctx(void)
238 struct sec_ctx
*ctx_p
;
240 /* Check we don't overflow our stack */
242 if (sec_ctx_stack_ndx
== MAX_SEC_CTX_DEPTH
) {
243 DEBUG(0, ("Security context stack overflow!\n"));
244 smb_panic("Security context stack overflow!\n");
247 /* Store previous user context */
251 ctx_p
= &sec_ctx_stack
[sec_ctx_stack_ndx
];
253 ctx_p
->uid
= geteuid();
254 ctx_p
->gid
= getegid();
256 DEBUG(3, ("push_sec_ctx(%u, %u) : sec_ctx_stack_ndx = %d\n",
257 (unsigned int)ctx_p
->uid
, (unsigned int)ctx_p
->gid
, sec_ctx_stack_ndx
));
259 ctx_p
->token
= dup_nt_token(sec_ctx_stack
[sec_ctx_stack_ndx
-1].token
);
260 if (! ctx_p
->token
) {
261 DEBUG(0, ("Out of memory on dup_nt_token() in push_sec_ctx()\n"));
265 ctx_p
->ngroups
= sys_getgroups(0, NULL
);
267 if (ctx_p
->ngroups
!= 0) {
268 if (!(ctx_p
->groups
= malloc(ctx_p
->ngroups
* sizeof(gid_t
)))) {
269 DEBUG(0, ("Out of memory on malloc() in push_sec_ctx()\n"));
270 delete_nt_token(&ctx_p
->token
);
274 sys_getgroups(ctx_p
->ngroups
, ctx_p
->groups
);
276 ctx_p
->groups
= NULL
;
279 init_privilege(&ctx_p
->privs
);
280 if (! NT_STATUS_IS_OK(dup_priv_set(ctx_p
->privs
, sec_ctx_stack
[sec_ctx_stack_ndx
-1].privs
))) {
281 DEBUG(0, ("Out of memory on dup_priv_set() in push_sec_ctx()\n"));
282 delete_nt_token(&ctx_p
->token
);
283 destroy_privilege(&ctx_p
->privs
);
290 /****************************************************************************
291 Set the current security context to a given user.
292 ****************************************************************************/
294 void set_sec_ctx(uid_t uid
, gid_t gid
, int ngroups
, gid_t
*groups
, NT_USER_TOKEN
*token
, PRIVILEGE_SET
*privs
)
296 struct sec_ctx
*ctx_p
= &sec_ctx_stack
[sec_ctx_stack_ndx
];
298 /* Set the security context */
300 DEBUG(3, ("setting sec ctx (%u, %u) - sec_ctx_stack_ndx = %d\n",
301 (unsigned int)uid
, (unsigned int)gid
, sec_ctx_stack_ndx
));
303 debug_nt_user_token(DBGC_CLASS
, 5, token
);
304 debug_unix_user_token(DBGC_CLASS
, 5, uid
, gid
, ngroups
, groups
);
308 #ifdef HAVE_SETGROUPS
309 sys_setgroups(ngroups
, groups
);
312 ctx_p
->ngroups
= ngroups
;
314 SAFE_FREE(ctx_p
->groups
);
315 if (token
&& (token
== ctx_p
->token
))
316 smb_panic("DUPLICATE_TOKEN");
318 delete_nt_token(&ctx_p
->token
);
320 reset_privilege(ctx_p
->privs
);
322 init_privilege(&ctx_p
->privs
);
324 ctx_p
->groups
= memdup(groups
, sizeof(gid_t
) * ngroups
);
325 ctx_p
->token
= dup_nt_token(token
);
326 dup_priv_set(ctx_p
->privs
, privs
);
333 /* Update current_user stuff */
335 current_user
.uid
= uid
;
336 current_user
.gid
= gid
;
337 current_user
.ngroups
= ngroups
;
338 current_user
.groups
= groups
;
339 current_user
.nt_user_token
= ctx_p
->token
;
340 current_user
.privs
= ctx_p
->privs
;
343 /****************************************************************************
345 ****************************************************************************/
347 void set_root_sec_ctx(void)
349 /* May need to worry about supplementary groups at some stage */
351 set_sec_ctx(0, 0, 0, NULL
, NULL
, NULL
);
354 /****************************************************************************
355 Pop a security context from the stack.
356 ****************************************************************************/
358 BOOL
pop_sec_ctx(void)
360 struct sec_ctx
*ctx_p
;
361 struct sec_ctx
*prev_ctx_p
;
363 /* Check for stack underflow */
365 if (sec_ctx_stack_ndx
== 0) {
366 DEBUG(0, ("Security context stack underflow!\n"));
367 smb_panic("Security context stack underflow!\n");
370 ctx_p
= &sec_ctx_stack
[sec_ctx_stack_ndx
];
372 /* Clear previous user info */
374 ctx_p
->uid
= (uid_t
)-1;
375 ctx_p
->gid
= (gid_t
)-1;
377 SAFE_FREE(ctx_p
->groups
);
380 delete_nt_token(&ctx_p
->token
);
381 destroy_privilege(&ctx_p
->privs
);
383 /* Pop back previous user */
389 prev_ctx_p
= &sec_ctx_stack
[sec_ctx_stack_ndx
];
391 #ifdef HAVE_SETGROUPS
392 sys_setgroups(prev_ctx_p
->ngroups
, prev_ctx_p
->groups
);
395 become_id(prev_ctx_p
->uid
, prev_ctx_p
->gid
);
397 /* Update current_user stuff */
399 current_user
.uid
= prev_ctx_p
->uid
;
400 current_user
.gid
= prev_ctx_p
->gid
;
401 current_user
.ngroups
= prev_ctx_p
->ngroups
;
402 current_user
.groups
= prev_ctx_p
->groups
;
403 current_user
.nt_user_token
= prev_ctx_p
->token
;
404 current_user
.privs
= prev_ctx_p
->privs
;
406 DEBUG(3, ("pop_sec_ctx (%u, %u) - sec_ctx_stack_ndx = %d\n",
407 (unsigned int)geteuid(), (unsigned int)getegid(), sec_ctx_stack_ndx
));
412 /* Initialise the security context system */
414 void init_sec_ctx(void)
417 struct sec_ctx
*ctx_p
;
419 /* Initialise security context stack */
421 memset(sec_ctx_stack
, 0, sizeof(struct sec_ctx
) * MAX_SEC_CTX_DEPTH
);
423 for (i
= 0; i
< MAX_SEC_CTX_DEPTH
; i
++) {
424 sec_ctx_stack
[i
].uid
= (uid_t
)-1;
425 sec_ctx_stack
[i
].gid
= (gid_t
)-1;
428 /* Initialise first level of stack. It is the current context */
429 ctx_p
= &sec_ctx_stack
[0];
431 ctx_p
->uid
= geteuid();
432 ctx_p
->gid
= getegid();
434 get_current_groups(ctx_p
->gid
, &ctx_p
->ngroups
, &ctx_p
->groups
);
436 ctx_p
->token
= NULL
; /* Maps to guest user. */
439 /* Initialise current_user global */
441 current_user
.uid
= ctx_p
->uid
;
442 current_user
.gid
= ctx_p
->gid
;
443 current_user
.ngroups
= ctx_p
->ngroups
;
444 current_user
.groups
= ctx_p
->groups
;
446 /* The conn and vuid are usually taken care of by other modules.
447 We initialise them here. */
449 current_user
.conn
= NULL
;
450 current_user
.vuid
= UID_FIELD_INVALID
;
451 current_user
.nt_user_token
= NULL
;
452 current_user
.privs
= NULL
;