2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
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 3 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, see <http://www.gnu.org/licenses/>.
22 /* what user is current? */
23 extern struct current_user current_user
;
25 /****************************************************************************
26 Become the guest user without changing the security context stack.
27 ****************************************************************************/
29 bool change_to_guest(void)
31 static struct passwd
*pass
=NULL
;
34 /* Don't need to free() this as its stored in a static */
35 pass
= getpwnam_alloc(talloc_autofree_context(), lp_guestaccount());
41 /* MWW: From AIX FAQ patch to WU-ftpd: call initgroups before
43 initgroups(pass
->pw_name
, pass
->pw_gid
);
46 set_sec_ctx(pass
->pw_uid
, pass
->pw_gid
, 0, NULL
, NULL
);
48 current_user
.conn
= NULL
;
49 current_user
.vuid
= UID_FIELD_INVALID
;
57 /*******************************************************************
58 Check if a username is OK.
60 This sets up conn->server_info with a copy related to this vuser that
61 later code can then mess with.
62 ********************************************************************/
64 static bool check_user_ok(connection_struct
*conn
, uint16_t vuid
,
65 struct auth_serversupplied_info
*server_info
,
69 struct vuid_cache_entry
*ent
= NULL
;
73 for (i
=0; i
<VUID_CACHE_SIZE
; i
++) {
74 ent
= &conn
->vuid_cache
.array
[i
];
75 if (ent
->vuid
== vuid
) {
76 conn
->server_info
= ent
->server_info
;
77 conn
->read_only
= ent
->read_only
;
78 conn
->admin_user
= ent
->admin_user
;
83 if (!user_ok_token(server_info
->unix_name
,
84 pdb_get_domain(server_info
->sam_account
),
85 server_info
->ptok
, snum
))
88 readonly_share
= is_share_read_only_for_token(
89 server_info
->unix_name
,
90 pdb_get_domain(server_info
->sam_account
),
91 server_info
->ptok
, snum
);
93 if (!readonly_share
&&
94 !share_access_check(server_info
->ptok
, lp_servicename(snum
),
96 /* smb.conf allows r/w, but the security descriptor denies
97 * write. Fall back to looking at readonly. */
98 readonly_share
= True
;
99 DEBUG(5,("falling back to read-only access-evaluation due to "
100 "security descriptor\n"));
103 if (!share_access_check(server_info
->ptok
, lp_servicename(snum
),
105 FILE_READ_DATA
: FILE_WRITE_DATA
)) {
109 admin_user
= token_contains_name_in_list(
110 server_info
->unix_name
,
111 pdb_get_domain(server_info
->sam_account
),
112 NULL
, server_info
->ptok
, lp_admin_users(snum
));
114 ent
= &conn
->vuid_cache
.array
[conn
->vuid_cache
.next_entry
];
116 conn
->vuid_cache
.next_entry
=
117 (conn
->vuid_cache
.next_entry
+ 1) % VUID_CACHE_SIZE
;
119 TALLOC_FREE(ent
->server_info
);
122 * If force_user was set, all server_info's are based on the same
123 * username-based faked one.
126 ent
->server_info
= copy_serverinfo(
127 conn
, conn
->force_user
? conn
->server_info
: server_info
);
129 if (ent
->server_info
== NULL
) {
130 ent
->vuid
= UID_FIELD_INVALID
;
135 ent
->read_only
= readonly_share
;
136 ent
->admin_user
= admin_user
;
138 conn
->read_only
= ent
->read_only
;
139 conn
->admin_user
= ent
->admin_user
;
140 conn
->server_info
= ent
->server_info
;
145 /****************************************************************************
146 Clear a vuid out of the connection's vuid cache
147 ****************************************************************************/
149 void conn_clear_vuid_cache(connection_struct
*conn
, uint16_t vuid
)
153 for (i
=0; i
<VUID_CACHE_SIZE
; i
++) {
154 struct vuid_cache_entry
*ent
;
156 ent
= &conn
->vuid_cache
.array
[i
];
158 if (ent
->vuid
== vuid
) {
159 ent
->vuid
= UID_FIELD_INVALID
;
160 TALLOC_FREE(ent
->server_info
);
161 ent
->read_only
= False
;
162 ent
->admin_user
= False
;
167 /****************************************************************************
168 Become the user of a connection number without changing the security context
169 stack, but modify the current_user entries.
170 ****************************************************************************/
172 bool change_to_user(connection_struct
*conn
, uint16 vuid
)
174 user_struct
*vuser
= get_valid_user_struct(vuid
);
180 gid_t
*group_list
= NULL
;
183 DEBUG(2,("change_to_user: Connection not open\n"));
188 * We need a separate check in security=share mode due to vuid
189 * always being UID_FIELD_INVALID. If we don't do this then
190 * in share mode security we are *always* changing uid's between
191 * SMB's - this hurts performance - Badly.
194 if((lp_security() == SEC_SHARE
) && (current_user
.conn
== conn
) &&
195 (current_user
.ut
.uid
== conn
->server_info
->utok
.uid
)) {
196 DEBUG(4,("change_to_user: Skipping user change - already "
199 } else if ((current_user
.conn
== conn
) &&
200 (vuser
!= NULL
) && (current_user
.vuid
== vuid
) &&
201 (current_user
.ut
.uid
== vuser
->server_info
->utok
.uid
)) {
202 DEBUG(4,("change_to_user: Skipping user change - already "
209 if ((vuser
) && !check_user_ok(conn
, vuid
, vuser
->server_info
, snum
)) {
210 DEBUG(2,("change_to_user: SMB user %s (unix user %s, vuid %d) "
211 "not permitted access to share %s.\n",
212 vuser
->server_info
->sanitized_username
,
213 vuser
->server_info
->unix_name
, vuid
,
214 lp_servicename(snum
)));
219 * conn->server_info is now correctly set up with a copy we can mess
220 * with for force_group etc.
223 if (conn
->force_user
) /* security = share sets this too */ {
224 uid
= conn
->server_info
->utok
.uid
;
225 gid
= conn
->server_info
->utok
.gid
;
226 group_list
= conn
->server_info
->utok
.groups
;
227 num_groups
= conn
->server_info
->utok
.ngroups
;
229 uid
= conn
->admin_user
? 0 : vuser
->server_info
->utok
.uid
;
230 gid
= conn
->server_info
->utok
.gid
;
231 num_groups
= conn
->server_info
->utok
.ngroups
;
232 group_list
= conn
->server_info
->utok
.groups
;
234 DEBUG(2,("change_to_user: Invalid vuid used %d in accessing "
235 "share %s.\n",vuid
, lp_servicename(snum
) ));
240 * See if we should force group for this service.
241 * If so this overrides any group set in the force
245 if((group_c
= *lp_force_group(snum
))) {
250 * Only force group if the user is a member of
251 * the service group. Check the group memberships for
252 * this user (we already have this) to
253 * see if we should force the group.
257 for (i
= 0; i
< num_groups
; i
++) {
259 == conn
->server_info
->utok
.gid
) {
260 gid
= conn
->server_info
->utok
.gid
;
261 gid_to_sid(&conn
->server_info
->ptok
262 ->user_sids
[1], gid
);
267 gid
= conn
->server_info
->utok
.gid
;
268 gid_to_sid(&conn
->server_info
->ptok
->user_sids
[1],
273 /* Now set current_user since we will immediately also call
276 current_user
.ut
.ngroups
= num_groups
;
277 current_user
.ut
.groups
= group_list
;
279 set_sec_ctx(uid
, gid
, current_user
.ut
.ngroups
, current_user
.ut
.groups
,
280 conn
->server_info
->ptok
);
282 current_user
.conn
= conn
;
283 current_user
.vuid
= vuid
;
285 DEBUG(5,("change_to_user uid=(%d,%d) gid=(%d,%d)\n",
286 (int)getuid(),(int)geteuid(),(int)getgid(),(int)getegid()));
291 /****************************************************************************
292 Go back to being root without changing the security context stack,
293 but modify the current_user entries.
294 ****************************************************************************/
296 bool change_to_root_user(void)
300 DEBUG(5,("change_to_root_user: now uid=(%d,%d) gid=(%d,%d)\n",
301 (int)getuid(),(int)geteuid(),(int)getgid(),(int)getegid()));
303 current_user
.conn
= NULL
;
304 current_user
.vuid
= UID_FIELD_INVALID
;
309 /****************************************************************************
310 Become the user of an authenticated connected named pipe.
311 When this is called we are currently running as the connection
312 user. Doesn't modify current_user.
313 ****************************************************************************/
315 bool become_authenticated_pipe_user(pipes_struct
*p
)
320 set_sec_ctx(p
->pipe_user
.ut
.uid
, p
->pipe_user
.ut
.gid
,
321 p
->pipe_user
.ut
.ngroups
, p
->pipe_user
.ut
.groups
,
322 p
->pipe_user
.nt_user_token
);
327 /****************************************************************************
328 Unbecome the user of an authenticated connected named pipe.
329 When this is called we are running as the authenticated pipe
330 user and need to go back to being the connection user. Doesn't modify
332 ****************************************************************************/
334 bool unbecome_authenticated_pipe_user(void)
336 return pop_sec_ctx();
339 /****************************************************************************
340 Utility functions used by become_xxx/unbecome_xxx.
341 ****************************************************************************/
344 connection_struct
*conn
;
348 /* A stack of current_user connection contexts. */
350 static struct conn_ctx conn_ctx_stack
[MAX_SEC_CTX_DEPTH
];
351 static int conn_ctx_stack_ndx
;
353 static void push_conn_ctx(void)
355 struct conn_ctx
*ctx_p
;
357 /* Check we don't overflow our stack */
359 if (conn_ctx_stack_ndx
== MAX_SEC_CTX_DEPTH
) {
360 DEBUG(0, ("Connection context stack overflow!\n"));
361 smb_panic("Connection context stack overflow!\n");
364 /* Store previous user context */
365 ctx_p
= &conn_ctx_stack
[conn_ctx_stack_ndx
];
367 ctx_p
->conn
= current_user
.conn
;
368 ctx_p
->vuid
= current_user
.vuid
;
370 DEBUG(3, ("push_conn_ctx(%u) : conn_ctx_stack_ndx = %d\n",
371 (unsigned int)ctx_p
->vuid
, conn_ctx_stack_ndx
));
373 conn_ctx_stack_ndx
++;
376 static void pop_conn_ctx(void)
378 struct conn_ctx
*ctx_p
;
380 /* Check for stack underflow. */
382 if (conn_ctx_stack_ndx
== 0) {
383 DEBUG(0, ("Connection context stack underflow!\n"));
384 smb_panic("Connection context stack underflow!\n");
387 conn_ctx_stack_ndx
--;
388 ctx_p
= &conn_ctx_stack
[conn_ctx_stack_ndx
];
390 current_user
.conn
= ctx_p
->conn
;
391 current_user
.vuid
= ctx_p
->vuid
;
394 ctx_p
->vuid
= UID_FIELD_INVALID
;
397 /****************************************************************************
398 Temporarily become a root user. Must match with unbecome_root(). Saves and
399 restores the connection context.
400 ****************************************************************************/
402 void become_root(void)
405 * no good way to handle push_sec_ctx() failing without changing
406 * the prototype of become_root()
408 if (!push_sec_ctx()) {
409 smb_panic("become_root: push_sec_ctx failed");
415 /* Unbecome the root user */
417 void unbecome_root(void)
423 /****************************************************************************
424 Push the current security context then force a change via change_to_user().
425 Saves and restores the connection context.
426 ****************************************************************************/
428 bool become_user(connection_struct
*conn
, uint16 vuid
)
435 if (!change_to_user(conn
, vuid
)) {
444 bool unbecome_user(void)