?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:kdc: remove unused sdb_entry_ex_to_hdb_entry_ex()
[Samba.git] / source3 / auth / token_util.c
blobf508dfd3a86fbf69aa57e7b289bc77ac4d799b5d
1 /*
2 * Unix SMB/CIFS implementation.
3 * Authentication utility functions
4 * Copyright (C) Andrew Tridgell 1992-1998
5 * Copyright (C) Andrew Bartlett 2001
6 * Copyright (C) Jeremy Allison 2000-2001
7 * Copyright (C) Rafal Szczesniak 2002
8 * Copyright (C) Volker Lendecke 2006
9 * Copyright (C) Michael Adam 2007
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 /* functions moved from auth/auth_util.c to minimize linker deps */
26
27 #include "includes.h"
28 #include "lib/util_unixsids.h"
29 #include "system/passwd.h"
30 #include "auth.h"
31 #include "secrets.h"
32 #include "../lib/util/memcache.h"
33 #include "../librpc/gen_ndr/netlogon.h"
34 #include "../libcli/security/security.h"
35 #include "../lib/util/util_pw.h"
36 #include "passdb.h"
37 #include "lib/privileges.h"
38
39 /****************************************************************************
40 Check for a SID in an struct security_token
41 ****************************************************************************/
42
43 bool nt_token_check_sid ( const struct dom_sid *sid, const struct security_token *token )
44 {
45 if ( !sid || !token )
46 return False;
47
48 return security_token_has_sid(token, sid);
49 }
50
51 bool nt_token_check_domain_rid( struct security_token *token, uint32_t rid )
52 {
53 struct dom_sid domain_sid;
54
55 /* if we are a domain member, the get the domain SID, else for
56 a DC or standalone server, use our own SID */
57
58 if ( lp_server_role() == ROLE_DOMAIN_MEMBER ) {
59 if ( !secrets_fetch_domain_sid( lp_workgroup(),
60 &domain_sid ) ) {
61 DEBUG(1,("nt_token_check_domain_rid: Cannot lookup "
62 "SID for domain [%s]\n", lp_workgroup()));
63 return False;
64 }
65 }
66 else
67 sid_copy( &domain_sid, get_global_sam_sid() );
68
69 sid_append_rid( &domain_sid, rid );
70
71 return nt_token_check_sid( &domain_sid, token );\
72 }
73
74 /******************************************************************************
75 Create a token for the root user to be used internally by smbd.
76 This is similar to running under the context of the LOCAL_SYSTEM account
77 in Windows. This is a read-only token. Do not modify it or free() it.
78 Create a copy if you need to change it.
79 ******************************************************************************/
80
81 NTSTATUS get_root_nt_token( struct security_token **token )
82 {
83 struct security_token *for_cache;
84 struct dom_sid u_sid, g_sid;
85 struct passwd *pw;
86 void *cache_data;
87 NTSTATUS status = NT_STATUS_OK;
88
89 cache_data = memcache_lookup_talloc(
90 NULL, SINGLETON_CACHE_TALLOC,
91 data_blob_string_const_null("root_nt_token"));
92
93 if (cache_data != NULL) {
94 *token = talloc_get_type_abort(
95 cache_data, struct security_token);
96 return NT_STATUS_OK;
97 }
98
99 if ( !(pw = getpwuid(0)) ) {
100 if ( !(pw = getpwnam("root")) ) {
101 DBG_ERR("get_root_nt_token: both getpwuid(0) "
102 "and getpwnam(\"root\") failed!\n");
103 return NT_STATUS_NO_SUCH_USER;
104 }
105 }
106
107 /* get the user and primary group SIDs; although the
108 BUILTIN\Administrators SId is really the one that matters here */
109
110 uid_to_sid(&u_sid, pw->pw_uid);
111 gid_to_sid(&g_sid, pw->pw_gid);
112
113 status = create_local_nt_token(talloc_tos(), &u_sid, False,
114 1, &global_sid_Builtin_Administrators, token);
115 if (!NT_STATUS_IS_OK(status)) {
116 return status;
117 }
118
119 security_token_set_privilege(*token, SEC_PRIV_DISK_OPERATOR);
120
121 for_cache = *token;
122
123 memcache_add_talloc(
124 NULL, SINGLETON_CACHE_TALLOC,
125 data_blob_string_const_null("root_nt_token"), &for_cache);
126
127 return status;
128 }
129
130
131 /*
132 * Add alias SIDs from memberships within the partially created token SID list
133 */
134
135 NTSTATUS add_aliases(const struct dom_sid *domain_sid,
136 struct security_token *token)
137 {
138 uint32_t *aliases;
139 size_t i, num_aliases;
140 NTSTATUS status;
141 TALLOC_CTX *tmp_ctx;
142
143 if (!(tmp_ctx = talloc_init("add_aliases"))) {
144 return NT_STATUS_NO_MEMORY;
145 }
146
147 aliases = NULL;
148 num_aliases = 0;
149
150 status = pdb_enum_alias_memberships(tmp_ctx, domain_sid,
151 token->sids,
152 token->num_sids,
153 &aliases, &num_aliases);
154
155 if (!NT_STATUS_IS_OK(status)) {
156 DEBUG(10, ("pdb_enum_alias_memberships failed: %s\n",
157 nt_errstr(status)));
158 goto done;
159 }
160
161 for (i=0; i<num_aliases; i++) {
162 struct dom_sid alias_sid;
163 sid_compose(&alias_sid, domain_sid, aliases[i]);
164 status = add_sid_to_array_unique(token, &alias_sid,
165 &token->sids,
166 &token->num_sids);
167 if (!NT_STATUS_IS_OK(status)) {
168 DEBUG(0, ("add_sid_to_array failed\n"));
169 goto done;
170 }
171 }
172
173 done:
174 TALLOC_FREE(tmp_ctx);
175 return NT_STATUS_OK;
176 }
177
178 /*******************************************************************
179 *******************************************************************/
180
181 static NTSTATUS add_builtin_administrators(struct security_token *token,
182 const struct dom_sid *dom_sid)
183 {
184 struct dom_sid domadm;
185 NTSTATUS status;
186
187 /* nothing to do if we aren't in a domain */
188
189 if ( !(IS_DC || lp_server_role()==ROLE_DOMAIN_MEMBER) ) {
190 return NT_STATUS_OK;
191 }
192
193 /* Find the Domain Admins SID */
194
195 if ( IS_DC ) {
196 sid_copy( &domadm, get_global_sam_sid() );
197 } else {
198 if (dom_sid == NULL) {
199 return NT_STATUS_INVALID_PARAMETER_MIX;
200 }
201 sid_copy(&domadm, dom_sid);
202 }
203 sid_append_rid( &domadm, DOMAIN_RID_ADMINS );
204
205 /* Add Administrators if the user beloongs to Domain Admins */
206
207 if ( nt_token_check_sid( &domadm, token ) ) {
208 status = add_sid_to_array(token,
209 &global_sid_Builtin_Administrators,
210 &token->sids, &token->num_sids);
211 if (!NT_STATUS_IS_OK(status)) {
212 return status;
213 }
214 }
215
216 return NT_STATUS_OK;
217 }
218
219 static NTSTATUS add_builtin_guests(struct security_token *token,
220 const struct dom_sid *dom_sid)
221 {
222 struct dom_sid tmp_sid;
223 NTSTATUS status;
224
225 /*
226 * First check the local GUEST account.
227 */
228 sid_compose(&tmp_sid, get_global_sam_sid(), DOMAIN_RID_GUEST);
229
230 if (nt_token_check_sid(&tmp_sid, token)) {
231 status = add_sid_to_array_unique(token,
232 &global_sid_Builtin_Guests,
233 &token->sids, &token->num_sids);
234 if (!NT_STATUS_IS_OK(status)) {
235 return status;
236 }
237
238 return NT_STATUS_OK;
239 }
240
241 /*
242 * First check the local GUESTS group.
243 */
244 sid_compose(&tmp_sid, get_global_sam_sid(), DOMAIN_RID_GUESTS);
245
246 if (nt_token_check_sid(&tmp_sid, token)) {
247 status = add_sid_to_array_unique(token,
248 &global_sid_Builtin_Guests,
249 &token->sids, &token->num_sids);
250 if (!NT_STATUS_IS_OK(status)) {
251 return status;
252 }
253
254 return NT_STATUS_OK;
255 }
256
257 if (lp_server_role() != ROLE_DOMAIN_MEMBER) {
258 return NT_STATUS_OK;
259 }
260
261 if (dom_sid == NULL) {
262 return NT_STATUS_INVALID_PARAMETER_MIX;
263 }
264
265 /*
266 * First check the domain GUESTS group.
267 */
268 sid_copy(&tmp_sid, dom_sid);
269 sid_append_rid(&tmp_sid, DOMAIN_RID_GUESTS);
270
271 if (nt_token_check_sid(&tmp_sid, token)) {
272 status = add_sid_to_array_unique(token,
273 &global_sid_Builtin_Guests,
274 &token->sids, &token->num_sids);
275 if (!NT_STATUS_IS_OK(status)) {
276 return status;
277 }
278
279 return NT_STATUS_OK;
280 }
281
282 return NT_STATUS_OK;
283 }
284
285 static NTSTATUS add_local_groups(struct security_token *result,
286 bool is_guest);
287
288 NTSTATUS get_user_sid_info3_and_extra(const struct netr_SamInfo3 *info3,
289 const struct extra_auth_info *extra,
290 struct dom_sid *sid)
291 {
292 /* USER SID */
293 if (info3->base.rid == (uint32_t)(-1)) {
294 /* this is a signal the user was fake and generated,
295 * the actual SID we want to use is stored in the extra
296 * sids */
297 if (is_null_sid(&extra->user_sid)) {
298 /* we couldn't find the user sid, bail out */
299 DEBUG(3, ("Invalid user SID\n"));
300 return NT_STATUS_UNSUCCESSFUL;
301 }
302 sid_copy(sid, &extra->user_sid);
303 } else {
304 sid_copy(sid, info3->base.domain_sid);
305 sid_append_rid(sid, info3->base.rid);
306 }
307 return NT_STATUS_OK;
308 }
309
310 NTSTATUS create_local_nt_token_from_info3(TALLOC_CTX *mem_ctx,
311 bool is_guest,
312 const struct netr_SamInfo3 *info3,
313 const struct extra_auth_info *extra,
314 struct security_token **ntok)
315 {
316 struct security_token *usrtok = NULL;
317 uint32_t session_info_flags = 0;
318 NTSTATUS status;
319 uint32_t i;
320
321 DEBUG(10, ("Create local NT token for %s\n",
322 info3->base.account_name.string));
323
324 usrtok = talloc_zero(mem_ctx, struct security_token);
325 if (!usrtok) {
326 DEBUG(0, ("talloc failed\n"));
327 return NT_STATUS_NO_MEMORY;
328 }
329
330 /* Add the user and primary group sid FIRST */
331 /* check if the user rid is the special "Domain Guests" rid.
332 * If so pick the first sid for the extra sids instead as it
333 * is a local fake account */
334 usrtok->sids = talloc_array(usrtok, struct dom_sid, 2);
335 if (!usrtok->sids) {
336 TALLOC_FREE(usrtok);
337 return NT_STATUS_NO_MEMORY;
338 }
339 usrtok->num_sids = 2;
340
341 status = get_user_sid_info3_and_extra(info3, extra, &usrtok->sids[0]);
342 if (!NT_STATUS_IS_OK(status)) {
343 TALLOC_FREE(usrtok);
344 return status;
345 }
346
347 /* GROUP SID */
348 if (info3->base.primary_gid == (uint32_t)(-1)) {
349 /* this is a signal the user was fake and generated,
350 * the actual SID we want to use is stored in the extra
351 * sids */
352 if (is_null_sid(&extra->pgid_sid)) {
353 /* we couldn't find the user sid, bail out */
354 DEBUG(3, ("Invalid group SID\n"));
355 TALLOC_FREE(usrtok);
356 return NT_STATUS_UNSUCCESSFUL;
357 }
358 sid_copy(&usrtok->sids[1], &extra->pgid_sid);
359 } else {
360 sid_copy(&usrtok->sids[1], info3->base.domain_sid);
361 sid_append_rid(&usrtok->sids[1],
362 info3->base.primary_gid);
363 }
364
365 /* Now the SIDs we got from authentication. These are the ones from
366 * the info3 struct or from the pdb_enum_group_memberships, depending
367 * on who authenticated the user.
368 * Note that we start the for loop at "1" here, we already added the
369 * first group sid as primary above. */
370
371 for (i = 0; i < info3->base.groups.count; i++) {
372 struct dom_sid tmp_sid;
373
374 sid_copy(&tmp_sid, info3->base.domain_sid);
375 sid_append_rid(&tmp_sid, info3->base.groups.rids[i].rid);
376
377 status = add_sid_to_array_unique(usrtok, &tmp_sid,
378 &usrtok->sids,
379 &usrtok->num_sids);
380 if (!NT_STATUS_IS_OK(status)) {
381 DEBUG(3, ("Failed to add SID to nt token\n"));
382 TALLOC_FREE(usrtok);
383 return status;
384 }
385 }
386
387 /* now also add extra sids if they are not the special user/group
388 * sids */
389 for (i = 0; i < info3->sidcount; i++) {
390 status = add_sid_to_array_unique(usrtok,
391 info3->sids[i].sid,
392 &usrtok->sids,
393 &usrtok->num_sids);
394 if (!NT_STATUS_IS_OK(status)) {
395 DEBUG(3, ("Failed to add SID to nt token\n"));
396 TALLOC_FREE(usrtok);
397 return status;
398 }
399 }
400
401 status = add_local_groups(usrtok, is_guest);
402 if (!NT_STATUS_IS_OK(status)) {
403 DEBUG(3, ("Failed to add local groups\n"));
404 TALLOC_FREE(usrtok);
405 return status;
406 }
407
408 session_info_flags |= AUTH_SESSION_INFO_DEFAULT_GROUPS;
409 if (!is_guest) {
410 session_info_flags |= AUTH_SESSION_INFO_AUTHENTICATED;
411 }
412
413 status = finalize_local_nt_token(usrtok, session_info_flags);
414 if (!NT_STATUS_IS_OK(status)) {
415 DEBUG(3, ("Failed to finalize nt token\n"));
416 TALLOC_FREE(usrtok);
417 return status;
418 }
419
420 *ntok = usrtok;
421 return NT_STATUS_OK;
422 }
423
424 /*******************************************************************
425 Create a NT token for the user, expanding local aliases
426 *******************************************************************/
427
428 NTSTATUS create_local_nt_token(TALLOC_CTX *mem_ctx,
429 const struct dom_sid *user_sid,
430 bool is_guest,
431 int num_groupsids,
432 const struct dom_sid *groupsids,
433 struct security_token **token)
434 {
435 struct security_token *result = NULL;
436 int i;
437 NTSTATUS status;
438 uint32_t session_info_flags = 0;
439 struct dom_sid_buf buf;
440
441 DEBUG(10, ("Create local NT token for %s\n",
442 dom_sid_str_buf(user_sid, &buf)));
443
444 if (!(result = talloc_zero(mem_ctx, struct security_token))) {
445 DEBUG(0, ("talloc failed\n"));
446 status = NT_STATUS_NO_MEMORY;
447 goto err;
448 }
449
450 /* Add the user and primary group sid */
451
452 status = add_sid_to_array(result, user_sid,
453 &result->sids, &result->num_sids);
454 if (!NT_STATUS_IS_OK(status)) {
455 goto err;
456 }
457
458 /* For guest, num_groupsids may be zero. */
459 if (num_groupsids) {
460 status = add_sid_to_array(result, &groupsids[0],
461 &result->sids,
462 &result->num_sids);
463 if (!NT_STATUS_IS_OK(status)) {
464 goto err;
465 }
466 }
467
468 /* Now the SIDs we got from authentication. These are the ones from
469 * the info3 struct or from the pdb_enum_group_memberships, depending
470 * on who authenticated the user.
471 * Note that we start the for loop at "1" here, we already added the
472 * first group sid as primary above. */
473
474 for (i=1; i<num_groupsids; i++) {
475 status = add_sid_to_array_unique(result, &groupsids[i],
476 &result->sids,
477 &result->num_sids);
478 if (!NT_STATUS_IS_OK(status)) {
479 goto err;
480 }
481 }
482
483 status = add_local_groups(result, is_guest);
484 if (!NT_STATUS_IS_OK(status)) {
485 goto err;
486 }
487
488 session_info_flags |= AUTH_SESSION_INFO_DEFAULT_GROUPS;
489 if (!is_guest) {
490 session_info_flags |= AUTH_SESSION_INFO_AUTHENTICATED;
491 }
492
493 status = finalize_local_nt_token(result, session_info_flags);
494 if (!NT_STATUS_IS_OK(status)) {
495 goto err;
496 }
497
498 if (is_guest) {
499 /*
500 * It's ugly, but for now it's
501 * needed to add Builtin_Guests
502 * here, the "local" token only
503 * consist of S-1-22-* SIDs
504 * and finalize_local_nt_token()
505 * doesn't have the chance to
506 * to detect it need to
507 * add Builtin_Guests via
508 * add_builtin_guests().
509 */
510 status = add_sid_to_array_unique(result,
511 &global_sid_Builtin_Guests,
512 &result->sids,
513 &result->num_sids);
514 if (!NT_STATUS_IS_OK(status)) {
515 DEBUG(3, ("Failed to add SID to nt token\n"));
516 goto err;
517 }
518 }
519
520 *token = result;
521 return NT_STATUS_SUCCESS;
522
523 err:
524 TALLOC_FREE(result);
525 return status;
526 }
527
528 /***************************************************
529 Merge in any groups from /etc/group.
530 ***************************************************/
531
532 static NTSTATUS add_local_groups(struct security_token *result,
533 bool is_guest)
534 {
535 gid_t *gids = NULL;
536 uint32_t getgroups_num_group_sids = 0;
537 struct passwd *pass = NULL;
538 TALLOC_CTX *tmp_ctx = talloc_stackframe();
539 uint32_t i;
540
541 if (is_guest) {
542 /*
543 * Guest is a special case. It's always
544 * a user that can be looked up, but
545 * result->sids[0] is set to DOMAIN\Guest.
546 * Lookup by account name instead.
547 */
548 pass = Get_Pwnam_alloc(tmp_ctx, lp_guest_account());
549 } else {
550 uid_t uid;
551
552 /* For non-guest result->sids[0] is always the user sid. */
553 if (!sid_to_uid(&result->sids[0], &uid)) {
554 /*
555 * Non-mappable SID like SYSTEM.
556 * Can't be in any /etc/group groups.
557 */
558 TALLOC_FREE(tmp_ctx);
559 return NT_STATUS_OK;
560 }
561
562 pass = getpwuid_alloc(tmp_ctx, uid);
563 if (pass == NULL) {
564 struct dom_sid_buf buf;
565 DBG_ERR("SID %s -> getpwuid(%u) failed, is nsswitch configured?\n",
566 dom_sid_str_buf(&result->sids[0], &buf),
567 (unsigned int)uid);
568 TALLOC_FREE(tmp_ctx);
569 return NT_STATUS_NO_SUCH_USER;
570 }
571 }
572
573 if (!pass) {
574 TALLOC_FREE(tmp_ctx);
575 return NT_STATUS_UNSUCCESSFUL;
576 }
577
578 /*
579 * Now we must get any groups this user has been
580 * added to in /etc/group and merge them in.
581 * This has to be done in every code path
582 * that creates an NT token, as remote users
583 * may have been added to the local /etc/group
584 * database. Tokens created merely from the
585 * info3 structs (via the DC or via the krb5 PAC)
586 * won't have these local groups. Note the
587 * groups added here will only be UNIX groups
588 * (S-1-22-2-XXXX groups) as getgroups_unix_user()
589 * turns off winbindd before calling getgroups().
590 *
591 * NB. This is duplicating work already
592 * done in the 'unix_user:' case of
593 * create_token_from_sid() but won't
594 * do anything other than be inefficient
595 * in that case.
596 */
597
598 if (!getgroups_unix_user(tmp_ctx, pass->pw_name, pass->pw_gid,
599 &gids, &getgroups_num_group_sids)) {
600 DEBUG(1, ("getgroups_unix_user for user %s failed\n",
601 pass->pw_name));
602 TALLOC_FREE(tmp_ctx);
603 return NT_STATUS_UNSUCCESSFUL;
604 }
605
606 for (i=0; i<getgroups_num_group_sids; i++) {
607 NTSTATUS status;
608 struct dom_sid grp_sid;
609 gid_to_sid(&grp_sid, gids[i]);
610
611 status = add_sid_to_array_unique(result,
612 &grp_sid,
613 &result->sids,
614 &result->num_sids);
615 if (!NT_STATUS_IS_OK(status)) {
616 DEBUG(3, ("Failed to add UNIX SID to nt token\n"));
617 TALLOC_FREE(tmp_ctx);
618 return status;
619 }
620 }
621 TALLOC_FREE(tmp_ctx);
622 return NT_STATUS_OK;
623 }
624
625 NTSTATUS finalize_local_nt_token(struct security_token *result,
626 uint32_t session_info_flags)
627 {
628 struct dom_sid _dom_sid = { 0, };
629 struct dom_sid *domain_sid = NULL;
630 NTSTATUS status;
631 struct acct_info *info;
632 bool ok;
633
634 result->privilege_mask = 0;
635 result->rights_mask = 0;
636
637 if (result->num_sids == 0) {
638 return NT_STATUS_INVALID_TOKEN;
639 }
640
641 if (session_info_flags & AUTH_SESSION_INFO_DEFAULT_GROUPS) {
642 status = add_sid_to_array(result, &global_sid_World,
643 &result->sids, &result->num_sids);
644 if (!NT_STATUS_IS_OK(status)) {
645 return status;
646 }
647 status = add_sid_to_array(result, &global_sid_Network,
648 &result->sids, &result->num_sids);
649 if (!NT_STATUS_IS_OK(status)) {
650 return status;
651 }
652 }
653
654 /*
655 * Don't expand nested groups of system, anonymous etc
656 *
657 * Note that they still get SID_WORLD and SID_NETWORK
658 * for now in order let existing tests pass.
659 *
660 * But SYSTEM doesn't get AUTHENTICATED_USERS
661 * and ANONYMOUS doesn't get BUILTIN GUESTS anymore.
662 */
663 if (security_token_is_anonymous(result)) {
664 return NT_STATUS_OK;
665 }
666 if (security_token_is_system(result)) {
667 result->privilege_mask = ~0;
668 return NT_STATUS_OK;
669 }
670
671 if (session_info_flags & AUTH_SESSION_INFO_AUTHENTICATED) {
672 status = add_sid_to_array(result,
673 &global_sid_Authenticated_Users,
674 &result->sids,
675 &result->num_sids);
676 if (!NT_STATUS_IS_OK(status)) {
677 return status;
678 }
679 }
680
681 /* Add in BUILTIN sids */
682
683 become_root();
684 ok = secrets_fetch_domain_sid(lp_workgroup(), &_dom_sid);
685 if (ok) {
686 domain_sid = &_dom_sid;
687 } else {
688 DEBUG(3, ("Failed to fetch domain sid for %s\n",
689 lp_workgroup()));
690 }
691 unbecome_root();
692
693 info = talloc_zero(talloc_tos(), struct acct_info);
694 if (info == NULL) {
695 DEBUG(0, ("talloc failed!\n"));
696 return NT_STATUS_NO_MEMORY;
697 }
698
699 /* Deal with the BUILTIN\Administrators group. If the SID can
700 be resolved then assume that the add_aliasmem( S-1-5-32 )
701 handled it. */
702
703 status = pdb_get_aliasinfo(&global_sid_Builtin_Administrators, info);
704 if (!NT_STATUS_IS_OK(status)) {
705
706 become_root();
707 status = create_builtin_administrators(domain_sid);
708 unbecome_root();
709
710 if (NT_STATUS_EQUAL(status, NT_STATUS_PROTOCOL_UNREACHABLE)) {
711 /* Add BUILTIN\Administrators directly to token. */
712 status = add_builtin_administrators(result, domain_sid);
713 if ( !NT_STATUS_IS_OK(status) ) {
714 DEBUG(3, ("Failed to check for local "
715 "Administrators membership (%s)\n",
716 nt_errstr(status)));
717 }
718 } else if (!NT_STATUS_IS_OK(status)) {
719 DEBUG(2, ("WARNING: Failed to create "
720 "BUILTIN\\Administrators group! Can "
721 "Winbind allocate gids?\n"));
722 }
723 }
724
725 /* Deal with the BUILTIN\Users group. If the SID can
726 be resolved then assume that the add_aliasmem( S-1-5-32 )
727 handled it. */
728
729 status = pdb_get_aliasinfo(&global_sid_Builtin_Users, info);
730 if (!NT_STATUS_IS_OK(status)) {
731
732 become_root();
733 status = create_builtin_users(domain_sid);
734 unbecome_root();
735
736 if (!NT_STATUS_EQUAL(status, NT_STATUS_PROTOCOL_UNREACHABLE) &&
737 !NT_STATUS_IS_OK(status))
738 {
739 DEBUG(2, ("WARNING: Failed to create BUILTIN\\Users group! "
740 "Can Winbind allocate gids?\n"));
741 }
742 }
743
744 /*
745 * Deal with the BUILTIN\Guests group. If the SID can
746 * be resolved then assume that the add_aliasmem( S-1-5-32 )
747 * handled it.
748 */
749 status = pdb_get_aliasinfo(&global_sid_Builtin_Guests, info);
750 if (!NT_STATUS_IS_OK(status)) {
751
752 become_root();
753 status = create_builtin_guests(domain_sid);
754 unbecome_root();
755
756 /*
757 * NT_STATUS_PROTOCOL_UNREACHABLE:
758 * => winbindd is not running.
759 *
760 * NT_STATUS_ACCESS_DENIED:
761 * => no idmap config at all
762 * and wbint_AllocateGid()/winbind_allocate_gid()
763 * failed.
764 *
765 * NT_STATUS_NO_SUCH_GROUP:
766 * => no idmap config at all and
767 * "tdbsam:map builtin = no" means
768 * wbint_Sids2UnixIDs() fails.
769 */
770 if (NT_STATUS_EQUAL(status, NT_STATUS_PROTOCOL_UNREACHABLE) ||
771 NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) ||
772 NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_GROUP)) {
773 /*
774 * Add BUILTIN\Guests directly to token.
775 * But only if the token already indicates
776 * real guest access by:
777 * - local GUEST account
778 * - local GUESTS group
779 * - domain GUESTS group
780 *
781 * Even if a user was authenticated, it
782 * can be member of a guest related group.
783 */
784 status = add_builtin_guests(result, domain_sid);
785 if (!NT_STATUS_IS_OK(status)) {
786 DEBUG(3, ("Failed to check for local "
787 "Guests membership (%s)\n",
788 nt_errstr(status)));
789 /*
790 * This is a hard error.
791 */
792 return status;
793 }
794 } else if (!NT_STATUS_IS_OK(status)) {
795 DEBUG(2, ("Failed to create "
796 "BUILTIN\\Guests group %s! Can "
797 "Winbind allocate gids?\n",
798 nt_errstr(status)));
799 /*
800 * This is a hard error.
801 */
802 return status;
803 }
804 }
805
806 TALLOC_FREE(info);
807
808 /* Deal with local groups */
809
810 if (lp_winbind_nested_groups()) {
811
812 become_root();
813
814 /* Now add the aliases. First the one from our local SAM */
815
816 status = add_aliases(get_global_sam_sid(), result);
817
818 if (!NT_STATUS_IS_OK(status)) {
819 unbecome_root();
820 return status;
821 }
822
823 /* Finally the builtin ones */
824
825 status = add_aliases(&global_sid_Builtin, result);
826
827 if (!NT_STATUS_IS_OK(status)) {
828 unbecome_root();
829 return status;
830 }
831
832 unbecome_root();
833 }
834
835 if (session_info_flags & AUTH_SESSION_INFO_NTLM) {
836 struct dom_sid tmp_sid = { 0, };
837
838 ok = dom_sid_parse(SID_NT_NTLM_AUTHENTICATION, &tmp_sid);
839 if (!ok) {
840 return NT_STATUS_NO_MEMORY;
841 }
842
843 status = add_sid_to_array(result,
844 &tmp_sid,
845 &result->sids,
846 &result->num_sids);
847 if (!NT_STATUS_IS_OK(status)) {
848 return status;
849 }
850 }
851
852 if (session_info_flags & AUTH_SESSION_INFO_SIMPLE_PRIVILEGES) {
853 if (security_token_has_builtin_administrators(result)) {
854 result->privilege_mask = ~0;
855 }
856 } else {
857 /* Add privileges based on current user sids */
858 get_privileges_for_sids(&result->privilege_mask, result->sids,
859 result->num_sids);
860 }
861
862 return NT_STATUS_OK;
863 }
864
865 /****************************************************************************
866 prints a UNIX 'token' to debug output.
867 ****************************************************************************/
868
869 void debug_unix_user_token(int dbg_class, int dbg_lev, uid_t uid, gid_t gid,
870 int n_groups, gid_t *groups)
871 {
872 int i;
873 DEBUGC(dbg_class, dbg_lev,
874 ("UNIX token of user %ld\n", (long int)uid));
875
876 DEBUGADDC(dbg_class, dbg_lev,
877 ("Primary group is %ld and contains %i supplementary "
878 "groups\n", (long int)gid, n_groups));
879 for (i = 0; i < n_groups; i++)
880 DEBUGADDC(dbg_class, dbg_lev, ("Group[%3i]: %ld\n", i,
881 (long int)groups[i]));
882 }
883
884 /*
885 * Create an artificial NT token given just a domain SID.
886 *
887 * We have 3 cases:
888 *
889 * unmapped unix users: Go directly to nss to find the user's group.
890 *
891 * A passdb user: The list of groups is provided by pdb_enum_group_memberships.
892 *
893 * If the user is provided by winbind, the primary gid is set to "domain
894 * users" of the user's domain. For an explanation why this is necessary, see
895 * the thread starting at
896 * http://lists.samba.org/archive/samba-technical/2006-January/044803.html.
897 */
898
899 static NTSTATUS create_token_from_sid(TALLOC_CTX *mem_ctx,
900 const struct dom_sid *user_sid,
901 bool is_guest,
902 uid_t *uid, gid_t *gid,
903 char **found_username,
904 struct security_token **token)
905 {
906 NTSTATUS result = NT_STATUS_NO_SUCH_USER;
907 TALLOC_CTX *tmp_ctx = talloc_stackframe();
908 gid_t *gids;
909 struct dom_sid *group_sids;
910 struct dom_sid tmp_sid;
911 uint32_t num_group_sids;
912 uint32_t num_gids;
913 uint32_t i;
914 uint32_t high, low;
915 bool range_ok;
916 struct dom_sid_buf buf;
917
918 if (sid_check_is_in_our_sam(user_sid)) {
919 bool ret;
920 uint32_t pdb_num_group_sids;
921 /* This is a passdb user, so ask passdb */
922
923 struct samu *sam_acct = NULL;
924
925 if ( !(sam_acct = samu_new( tmp_ctx )) ) {
926 result = NT_STATUS_NO_MEMORY;
927 goto done;
928 }
929
930 become_root();
931 ret = pdb_getsampwsid(sam_acct, user_sid);
932 unbecome_root();
933
934 if (!ret) {
935 DEBUG(1, ("pdb_getsampwsid(%s) failed\n",
936 dom_sid_str_buf(user_sid, &buf)));
937 DEBUGADD(1, ("Fall back to unix user\n"));
938 goto unix_user;
939 }
940
941 result = pdb_enum_group_memberships(tmp_ctx, sam_acct,
942 &group_sids, &gids,
943 &pdb_num_group_sids);
944 if (!NT_STATUS_IS_OK(result)) {
945 DEBUG(1, ("enum_group_memberships failed for %s: "
946 "%s\n",
947 dom_sid_str_buf(user_sid, &buf),
948 nt_errstr(result)));
949 DEBUGADD(1, ("Fall back to unix uid lookup\n"));
950 goto unix_user;
951 }
952 num_group_sids = pdb_num_group_sids;
953
954 /* see the smb_panic() in pdb_default_enum_group_memberships */
955 SMB_ASSERT(num_group_sids > 0);
956
957 /* Ensure we're returning the found_username on the right context. */
958 *found_username = talloc_strdup(mem_ctx,
959 pdb_get_username(sam_acct));
960
961 if (*found_username == NULL) {
962 result = NT_STATUS_NO_MEMORY;
963 goto done;
964 }
965
966 /*
967 * If the SID from lookup_name() was the guest sid, passdb knows
968 * about the mapping of guest sid to lp_guest_account()
969 * username and will return the unix_pw info for a guest
970 * user. Use it if it's there, else lookup the *uid details
971 * using Get_Pwnam_alloc(). See bug #6291 for details. JRA.
972 */
973
974 /* We must always assign the *uid. */
975 if (sam_acct->unix_pw == NULL) {
976 struct passwd *pwd = Get_Pwnam_alloc(sam_acct, *found_username );
977 if (!pwd) {
978 DEBUG(10, ("Get_Pwnam_alloc failed for %s\n",
979 *found_username));
980 result = NT_STATUS_NO_SUCH_USER;
981 goto done;
982 }
983 result = samu_set_unix(sam_acct, pwd );
984 if (!NT_STATUS_IS_OK(result)) {
985 DEBUG(10, ("samu_set_unix failed for %s\n",
986 *found_username));
987 result = NT_STATUS_NO_SUCH_USER;
988 goto done;
989 }
990 }
991 *uid = sam_acct->unix_pw->pw_uid;
992
993 } else if (sid_check_is_in_unix_users(user_sid)) {
994 uint32_t getgroups_num_group_sids;
995 /* This is a unix user not in passdb. We need to ask nss
996 * directly, without consulting passdb */
997
998 struct passwd *pass;
999
1000 /*
1001 * This goto target is used as a fallback for the passdb
1002 * case. The concrete bug report is when passdb gave us an
1003 * unmapped gid.
1004 */
1005
1006 unix_user:
1007
1008 if (!sid_to_uid(user_sid, uid)) {
1009 DEBUG(1, ("unix_user case, sid_to_uid for %s failed\n",
1010 dom_sid_str_buf(user_sid, &buf)));
1011 result = NT_STATUS_NO_SUCH_USER;
1012 goto done;
1013 }
1014
1015 uid_to_unix_users_sid(*uid, &tmp_sid);
1016 user_sid = &tmp_sid;
1017
1018 pass = getpwuid_alloc(tmp_ctx, *uid);
1019 if (pass == NULL) {
1020 DEBUG(1, ("getpwuid(%u) failed\n",
1021 (unsigned int)*uid));
1022 goto done;
1023 }
1024
1025 if (!getgroups_unix_user(tmp_ctx, pass->pw_name, pass->pw_gid,
1026 &gids, &getgroups_num_group_sids)) {
1027 DEBUG(1, ("getgroups_unix_user for user %s failed\n",
1028 pass->pw_name));
1029 goto done;
1030 }
1031 num_group_sids = getgroups_num_group_sids;
1032
1033 group_sids = talloc_array(tmp_ctx, struct dom_sid, num_group_sids);
1034 if (group_sids == NULL) {
1035 DEBUG(1, ("talloc_array failed\n"));
1036 result = NT_STATUS_NO_MEMORY;
1037 goto done;
1038 }
1039
1040 for (i=0; i<num_group_sids; i++) {
1041 gid_to_sid(&group_sids[i], gids[i]);
1042 }
1043
1044 /* In getgroups_unix_user we always set the primary gid */
1045 SMB_ASSERT(num_group_sids > 0);
1046
1047 /* Ensure we're returning the found_username on the right context. */
1048 *found_username = talloc_strdup(mem_ctx, pass->pw_name);
1049 if (*found_username == NULL) {
1050 result = NT_STATUS_NO_MEMORY;
1051 goto done;
1052 }
1053 } else {
1054
1055 /* This user is from winbind, force the primary gid to the
1056 * user's "domain users" group. Under certain circumstances
1057 * (user comes from NT4), this might be a loss of
1058 * information. But we can not rely on winbind getting the
1059 * correct info. AD might prohibit winbind looking up that
1060 * information. */
1061
1062 /* We must always assign the *uid. */
1063 if (!sid_to_uid(user_sid, uid)) {
1064 DEBUG(1, ("winbindd case, sid_to_uid for %s failed\n",
1065 dom_sid_str_buf(user_sid, &buf)));
1066 result = NT_STATUS_NO_SUCH_USER;
1067 goto done;
1068 }
1069
1070 num_group_sids = 1;
1071 group_sids = talloc_array(tmp_ctx, struct dom_sid, num_group_sids);
1072 if (group_sids == NULL) {
1073 DEBUG(1, ("talloc_array failed\n"));
1074 result = NT_STATUS_NO_MEMORY;
1075 goto done;
1076 }
1077
1078 gids = talloc_array(tmp_ctx, gid_t, num_group_sids);
1079 if (gids == NULL) {
1080 result = NT_STATUS_NO_MEMORY;
1081 goto done;
1082 }
1083
1084 sid_copy(&group_sids[0], user_sid);
1085 sid_split_rid(&group_sids[0], NULL);
1086 sid_append_rid(&group_sids[0], DOMAIN_RID_USERS);
1087
1088 if (!sid_to_gid(&group_sids[0], &gids[0])) {
1089 DEBUG(1, ("sid_to_gid(%s) failed\n",
1090 dom_sid_str_buf(&group_sids[0], &buf)));
1091 goto done;
1092 }
1093
1094 *found_username = NULL;
1095 }
1096
1097 *gid = gids[0];
1098
1099 /* Add the "Unix Group" SID for each gid to catch mapped groups
1100 and their Unix equivalent. This is to solve the backwards
1101 compatibility problem of 'valid users = +ntadmin' where
1102 ntadmin has been paired with "Domain Admins" in the group
1103 mapping table. Otherwise smb.conf would need to be changed
1104 to 'valid user = "Domain Admins"'. --jerry */
1105
1106 num_gids = num_group_sids;
1107 range_ok = lp_idmap_default_range(&low, &high);
1108 for ( i=0; i<num_gids; i++ ) {
1109 struct dom_sid unix_group_sid;
1110
1111 /* don't pickup anything managed by Winbind */
1112 if (range_ok && (gids[i] >= low) && (gids[i] <= high)) {
1113 continue;
1114 }
1115
1116 gid_to_unix_groups_sid(gids[i], &unix_group_sid);
1117
1118 result = add_sid_to_array_unique(tmp_ctx, &unix_group_sid,
1119 &group_sids, &num_group_sids);
1120 if (!NT_STATUS_IS_OK(result)) {
1121 goto done;
1122 }
1123 }
1124
1125 /* Ensure we're creating the nt_token on the right context. */
1126 result = create_local_nt_token(mem_ctx, user_sid,
1127 is_guest, num_group_sids, group_sids, token);
1128
1129 if (!NT_STATUS_IS_OK(result)) {
1130 goto done;
1131 }
1132
1133 result = NT_STATUS_OK;
1134 done:
1135 TALLOC_FREE(tmp_ctx);
1136 return result;
1137 }
1138
1139 /*
1140 * Create an artificial NT token given just a username. (Initially intended
1141 * for force user)
1142 *
1143 * We go through lookup_name() to avoid problems we had with 'winbind use
1144 * default domain'.
1145 *
1146 * We have 3 cases:
1147 *
1148 * unmapped unix users: Go directly to nss to find the user's group.
1149 *
1150 * A passdb user: The list of groups is provided by pdb_enum_group_memberships.
1151 *
1152 * If the user is provided by winbind, the primary gid is set to "domain
1153 * users" of the user's domain. For an explanation why this is necessary, see
1154 * the thread starting at
1155 * http://lists.samba.org/archive/samba-technical/2006-January/044803.html.
1156 */
1157
1158 NTSTATUS create_token_from_username(TALLOC_CTX *mem_ctx, const char *username,
1159 bool is_guest,
1160 uid_t *uid, gid_t *gid,
1161 char **found_username,
1162 struct security_token **token)
1163 {
1164 NTSTATUS result = NT_STATUS_NO_SUCH_USER;
1165 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1166 struct dom_sid user_sid;
1167 enum lsa_SidType type;
1168
1169 if (!lookup_name_smbconf(tmp_ctx, username, LOOKUP_NAME_ALL,
1170 NULL, NULL, &user_sid, &type)) {
1171 DEBUG(1, ("lookup_name_smbconf for %s failed\n", username));
1172 goto done;
1173 }
1174
1175 if (type != SID_NAME_USER) {
1176 DEBUG(1, ("%s is a %s, not a user\n", username,
1177 sid_type_lookup(type)));
1178 goto done;
1179 }
1180
1181 result = create_token_from_sid(mem_ctx, &user_sid, is_guest, uid, gid, found_username, token);
1182
1183 if (!NT_STATUS_IS_OK(result)) {
1184 goto done;
1185 }
1186
1187 /*
1188 * If result == NT_STATUS_OK then
1189 * we know we have a valid token. Ensure
1190 * we also have a valid username to match.
1191 */
1192
1193 if (*found_username == NULL) {
1194 *found_username = talloc_strdup(mem_ctx, username);
1195 if (*found_username == NULL) {
1196 result = NT_STATUS_NO_MEMORY;
1197 }
1198 }
1199
1200 done:
1201 TALLOC_FREE(tmp_ctx);
1202 return result;
1203 }
1204
1205 /***************************************************************************
1206 Build upon create_token_from_sid:
1207
1208 Expensive helper function to figure out whether a user given its sid is
1209 member of a particular group.
1210 ***************************************************************************/
1211
1212 bool user_sid_in_group_sid(const struct dom_sid *sid, const struct dom_sid *group_sid)
1213 {
1214 NTSTATUS status;
1215 uid_t uid;
1216 gid_t gid;
1217 char *found_username;
1218 struct security_token *token;
1219 bool result = false;
1220 enum lsa_SidType type;
1221 TALLOC_CTX *mem_ctx = talloc_stackframe();
1222 struct dom_sid_buf buf;
1223
1224 if (!lookup_sid(mem_ctx, sid,
1225 NULL, NULL, &type)) {
1226 DEBUG(1, ("lookup_sid for %s failed\n",
1227 dom_sid_str_buf(sid, &buf)));
1228 goto done;
1229 }
1230
1231 if (type != SID_NAME_USER) {
1232 DEBUG(5, ("%s is a %s, not a user\n",
1233 dom_sid_str_buf(sid, &buf),
1234 sid_type_lookup(type)));
1235 goto done;
1236 }
1237
1238 status = create_token_from_sid(mem_ctx, sid, False,
1239 &uid, &gid, &found_username,
1240 &token);
1241
1242 if (!NT_STATUS_IS_OK(status)) {
1243 DEBUG(10, ("could not create token for %s\n",
1244 dom_sid_str_buf(sid, &buf)));
1245 goto done;
1246 }
1247
1248 result = security_token_has_sid(token, group_sid);
1249
1250 done:
1251 TALLOC_FREE(mem_ctx);
1252 return result;
1253 }
1254
1255 /***************************************************************************
1256 Build upon create_token_from_username:
1257
1258 Expensive helper function to figure out whether a user given its name is
1259 member of a particular group.
1260 ***************************************************************************/
1261
1262 bool user_in_group_sid(const char *username, const struct dom_sid *group_sid)
1263 {
1264 NTSTATUS status;
1265 uid_t uid;
1266 gid_t gid;
1267 char *found_username;
1268 struct security_token *token;
1269 bool result;
1270 TALLOC_CTX *mem_ctx = talloc_stackframe();
1271
1272 status = create_token_from_username(mem_ctx, username, False,
1273 &uid, &gid, &found_username,
1274 &token);
1275
1276 if (!NT_STATUS_IS_OK(status)) {
1277 DEBUG(10, ("could not create token for %s\n", username));
1278 TALLOC_FREE(mem_ctx);
1279 return False;
1280 }
1281
1282 result = security_token_has_sid(token, group_sid);
1283
1284 TALLOC_FREE(mem_ctx);
1285 return result;
1286 }
1287
1288 bool user_in_group(const char *username, const char *groupname)
1289 {
1290 TALLOC_CTX *mem_ctx = talloc_stackframe();
1291 struct dom_sid group_sid;
1292 bool ret;
1293
1294 ret = lookup_name(mem_ctx, groupname, LOOKUP_NAME_ALL,
1295 NULL, NULL, &group_sid, NULL);
1296 TALLOC_FREE(mem_ctx);
1297
1298 if (!ret) {
1299 DEBUG(10, ("lookup_name for (%s) failed.\n", groupname));
1300 return False;
1301 }
1302
1303 return user_in_group_sid(username, &group_sid);
1304 }
1305
1306 /* END */
Samba GIT mirror