?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4: Use the Unicode version of InternetReadFileEx.
[wine.git] / server / token.c
blobc235ece4865dab9aeb350723d9571d1dfb173987
1 /*
2 * Tokens
3 *
4 * Copyright (C) 1998 Alexandre Julliard
5 * Copyright (C) 2003 Mike McCormack
6 * Copyright (C) 2005 Robert Shearman
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24
25 #include <assert.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <unistd.h>
30
31 #include "ntstatus.h"
32 #define WIN32_NO_STATUS
33 #include "windef.h"
34 #include "winternl.h"
35
36 #include "handle.h"
37 #include "thread.h"
38 #include "process.h"
39 #include "request.h"
40 #include "security.h"
41
42 #include "wine/unicode.h"
43
44 #define MAX_SUBAUTH_COUNT 1
45
46 const LUID SeIncreaseQuotaPrivilege = { 5, 0 };
47 const LUID SeSecurityPrivilege = { 8, 0 };
48 const LUID SeTakeOwnershipPrivilege = { 9, 0 };
49 const LUID SeLoadDriverPrivilege = { 10, 0 };
50 const LUID SeSystemProfilePrivilege = { 11, 0 };
51 const LUID SeSystemtimePrivilege = { 12, 0 };
52 const LUID SeProfileSingleProcessPrivilege = { 13, 0 };
53 const LUID SeIncreaseBasePriorityPrivilege = { 14, 0 };
54 const LUID SeCreatePagefilePrivilege = { 15, 0 };
55 const LUID SeBackupPrivilege = { 17, 0 };
56 const LUID SeRestorePrivilege = { 18, 0 };
57 const LUID SeShutdownPrivilege = { 19, 0 };
58 const LUID SeDebugPrivilege = { 20, 0 };
59 const LUID SeSystemEnvironmentPrivilege = { 22, 0 };
60 const LUID SeChangeNotifyPrivilege = { 23, 0 };
61 const LUID SeRemoteShutdownPrivilege = { 24, 0 };
62 const LUID SeUndockPrivilege = { 25, 0 };
63 const LUID SeManageVolumePrivilege = { 28, 0 };
64 const LUID SeImpersonatePrivilege = { 29, 0 };
65 const LUID SeCreateGlobalPrivilege = { 30, 0 };
66
67 static const SID world_sid = { SID_REVISION, 1, { SECURITY_WORLD_SID_AUTHORITY }, { SECURITY_WORLD_RID } };
68 static const SID local_sid = { SID_REVISION, 1, { SECURITY_LOCAL_SID_AUTHORITY }, { SECURITY_LOCAL_RID } };
69 static const SID interactive_sid = { SID_REVISION, 1, { SECURITY_NT_AUTHORITY }, { SECURITY_INTERACTIVE_RID } };
70 static const SID anonymous_logon_sid = { SID_REVISION, 1, { SECURITY_NT_AUTHORITY }, { SECURITY_ANONYMOUS_LOGON_RID } };
71 static const SID authenticated_user_sid = { SID_REVISION, 1, { SECURITY_NT_AUTHORITY }, { SECURITY_AUTHENTICATED_USER_RID } };
72 static const SID local_system_sid = { SID_REVISION, 1, { SECURITY_NT_AUTHORITY }, { SECURITY_LOCAL_SYSTEM_RID } };
73 static const struct /* same fields as struct SID */
74 {
75 BYTE Revision;
76 BYTE SubAuthorityCount;
77 SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
78 DWORD SubAuthority[5];
79 } local_user_sid = { SID_REVISION, 5, { SECURITY_NT_AUTHORITY }, { SECURITY_NT_NON_UNIQUE, 0, 0, 0, 1000 } };
80 static const struct /* same fields as struct SID */
81 {
82 BYTE Revision;
83 BYTE SubAuthorityCount;
84 SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
85 DWORD SubAuthority[2];
86 } builtin_admins_sid = { SID_REVISION, 2, { SECURITY_NT_AUTHORITY }, { SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS } };
87 static const struct /* same fields as struct SID */
88 {
89 BYTE Revision;
90 BYTE SubAuthorityCount;
91 SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
92 DWORD SubAuthority[2];
93 } builtin_users_sid = { SID_REVISION, 2, { SECURITY_NT_AUTHORITY }, { SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_USERS } };
94
95 const PSID security_world_sid = (PSID)&world_sid;
96 static const PSID security_local_sid = (PSID)&local_sid;
97 static const PSID security_interactive_sid = (PSID)&interactive_sid;
98 static const PSID security_authenticated_user_sid = (PSID)&authenticated_user_sid;
99 const PSID security_local_system_sid = (PSID)&local_system_sid;
100 const PSID security_local_user_sid = (PSID)&local_user_sid;
101 const PSID security_builtin_admins_sid = (PSID)&builtin_admins_sid;
102 const PSID security_builtin_users_sid = (PSID)&builtin_users_sid;
103
104 static luid_t prev_luid_value = { 1000, 0 };
105
106 struct token
107 {
108 struct object obj; /* object header */
109 luid_t token_id; /* system-unique id of token */
110 luid_t modified_id; /* new id allocated every time token is modified */
111 struct list privileges; /* privileges available to the token */
112 struct list groups; /* groups that the user of this token belongs to (sid_and_attributes) */
113 SID *user; /* SID of user this token represents */
114 SID *primary_group; /* SID of user's primary group */
115 unsigned primary; /* is this a primary or impersonation token? */
116 ACL *default_dacl; /* the default DACL to assign to objects created by this user */
117 TOKEN_SOURCE source; /* source of the token */
118 int impersonation_level; /* impersonation level this token is capable of if non-primary token */
119 };
120
121 struct privilege
122 {
123 struct list entry;
124 LUID luid;
125 unsigned enabled : 1; /* is the privilege currently enabled? */
126 unsigned def : 1; /* is the privilege enabled by default? */
127 };
128
129 struct group
130 {
131 struct list entry;
132 unsigned enabled : 1; /* is the sid currently enabled? */
133 unsigned def : 1; /* is the sid enabled by default? */
134 unsigned logon : 1; /* is this a logon sid? */
135 unsigned mandatory: 1; /* is this sid always enabled? */
136 unsigned owner : 1; /* can this sid be an owner of an object? */
137 unsigned resource : 1; /* is this a domain-local group? */
138 unsigned deny_only: 1; /* is this a sid that should be use for denying only? */
139 SID sid;
140 };
141
142 static void token_dump( struct object *obj, int verbose );
143 static unsigned int token_map_access( struct object *obj, unsigned int access );
144 static void token_destroy( struct object *obj );
145
146 static const struct object_ops token_ops =
147 {
148 sizeof(struct token), /* size */
149 token_dump, /* dump */
150 no_get_type, /* get_type */
151 no_add_queue, /* add_queue */
152 NULL, /* remove_queue */
153 NULL, /* signaled */
154 NULL, /* satisfied */
155 no_signal, /* signal */
156 no_get_fd, /* get_fd */
157 token_map_access, /* map_access */
158 default_get_sd, /* get_sd */
159 default_set_sd, /* set_sd */
160 no_lookup_name, /* lookup_name */
161 no_open_file, /* open_file */
162 no_close_handle, /* close_handle */
163 token_destroy /* destroy */
164 };
165
166
167 static void token_dump( struct object *obj, int verbose )
168 {
169 fprintf( stderr, "Security token\n" );
170 /* FIXME: dump token members */
171 }
172
173 static unsigned int token_map_access( struct object *obj, unsigned int access )
174 {
175 if (access & GENERIC_READ) access |= TOKEN_READ;
176 if (access & GENERIC_WRITE) access |= TOKEN_WRITE;
177 if (access & GENERIC_EXECUTE) access |= STANDARD_RIGHTS_EXECUTE;
178 if (access & GENERIC_ALL) access |= TOKEN_ALL_ACCESS;
179 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
180 }
181
182 static SID *security_sid_alloc( const SID_IDENTIFIER_AUTHORITY *idauthority, int subauthcount, const unsigned int subauth[] )
183 {
184 int i;
185 SID *sid = mem_alloc( FIELD_OFFSET(SID, SubAuthority[subauthcount]) );
186 if (!sid) return NULL;
187 sid->Revision = SID_REVISION;
188 sid->SubAuthorityCount = subauthcount;
189 sid->IdentifierAuthority = *idauthority;
190 for (i = 0; i < subauthcount; i++)
191 sid->SubAuthority[i] = subauth[i];
192 return sid;
193 }
194
195 void security_set_thread_token( struct thread *thread, obj_handle_t handle )
196 {
197 if (!handle)
198 {
199 if (thread->token)
200 release_object( thread->token );
201 thread->token = NULL;
202 }
203 else
204 {
205 struct token *token = (struct token *)get_handle_obj( current->process,
206 handle,
207 TOKEN_IMPERSONATE,
208 &token_ops );
209 if (token)
210 {
211 if (thread->token)
212 release_object( thread->token );
213 thread->token = token;
214 }
215 }
216 }
217
218 const SID *security_unix_uid_to_sid( uid_t uid )
219 {
220 /* very simple mapping: either the current user or not the current user */
221 if (uid == getuid())
222 return (const SID *)&local_user_sid;
223 else
224 return &anonymous_logon_sid;
225 }
226
227 static int acl_is_valid( const ACL *acl, data_size_t size )
228 {
229 ULONG i;
230 const ACE_HEADER *ace;
231
232 if (size < sizeof(ACL))
233 return FALSE;
234
235 size = min(size, MAX_ACL_LEN);
236
237 size -= sizeof(ACL);
238
239 ace = (const ACE_HEADER *)(acl + 1);
240 for (i = 0; i < acl->AceCount; i++)
241 {
242 const SID *sid;
243 data_size_t sid_size;
244
245 if (size < sizeof(ACE_HEADER))
246 return FALSE;
247 if (size < ace->AceSize)
248 return FALSE;
249 size -= ace->AceSize;
250 switch (ace->AceType)
251 {
252 case ACCESS_DENIED_ACE_TYPE:
253 sid = (const SID *)&((const ACCESS_DENIED_ACE *)ace)->SidStart;
254 sid_size = ace->AceSize - FIELD_OFFSET(ACCESS_DENIED_ACE, SidStart);
255 break;
256 case ACCESS_ALLOWED_ACE_TYPE:
257 sid = (const SID *)&((const ACCESS_ALLOWED_ACE *)ace)->SidStart;
258 sid_size = ace->AceSize - FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart);
259 break;
260 case SYSTEM_AUDIT_ACE_TYPE:
261 sid = (const SID *)&((const SYSTEM_AUDIT_ACE *)ace)->SidStart;
262 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_AUDIT_ACE, SidStart);
263 break;
264 case SYSTEM_ALARM_ACE_TYPE:
265 sid = (const SID *)&((const SYSTEM_ALARM_ACE *)ace)->SidStart;
266 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_ALARM_ACE, SidStart);
267 break;
268 case SYSTEM_MANDATORY_LABEL_ACE_TYPE:
269 sid = (const SID *)&((const SYSTEM_MANDATORY_LABEL_ACE *)ace)->SidStart;
270 sid_size = ace->AceSize - FIELD_OFFSET(SYSTEM_MANDATORY_LABEL_ACE, SidStart);
271 break;
272 default:
273 return FALSE;
274 }
275 if (sid_size < FIELD_OFFSET(SID, SubAuthority[0]) || sid_size < security_sid_len( sid ))
276 return FALSE;
277 ace = ace_next( ace );
278 }
279 return TRUE;
280 }
281
282 /* checks whether all members of a security descriptor fit inside the size
283 * of memory specified */
284 int sd_is_valid( const struct security_descriptor *sd, data_size_t size )
285 {
286 size_t offset = sizeof(struct security_descriptor);
287 const SID *group;
288 const SID *owner;
289 const ACL *sacl;
290 const ACL *dacl;
291 int dummy;
292
293 if (size < offset)
294 return FALSE;
295
296 if ((sd->owner_len >= FIELD_OFFSET(SID, SubAuthority[255])) ||
297 (offset + sd->owner_len > size))
298 return FALSE;
299 owner = sd_get_owner( sd );
300 if (owner)
301 {
302 size_t needed_size = security_sid_len( owner );
303 if ((sd->owner_len < sizeof(SID)) || (needed_size > sd->owner_len))
304 return FALSE;
305 }
306 offset += sd->owner_len;
307
308 if ((sd->group_len >= FIELD_OFFSET(SID, SubAuthority[255])) ||
309 (offset + sd->group_len > size))
310 return FALSE;
311 group = sd_get_group( sd );
312 if (group)
313 {
314 size_t needed_size = security_sid_len( group );
315 if ((sd->group_len < sizeof(SID)) || (needed_size > sd->group_len))
316 return FALSE;
317 }
318 offset += sd->group_len;
319
320 if ((sd->sacl_len >= MAX_ACL_LEN) || (offset + sd->sacl_len > size))
321 return FALSE;
322 sacl = sd_get_sacl( sd, &dummy );
323 if (sacl && !acl_is_valid( sacl, sd->sacl_len ))
324 return FALSE;
325 offset += sd->sacl_len;
326
327 if ((sd->dacl_len >= MAX_ACL_LEN) || (offset + sd->dacl_len > size))
328 return FALSE;
329 dacl = sd_get_dacl( sd, &dummy );
330 if (dacl && !acl_is_valid( dacl, sd->dacl_len ))
331 return FALSE;
332 offset += sd->dacl_len;
333
334 return TRUE;
335 }
336
337 /* determines whether an object_attributes struct is valid in a buffer
338 * and calls set_error appropriately */
339 int objattr_is_valid( const struct object_attributes *objattr, data_size_t size )
340 {
341 if ((size < sizeof(*objattr)) || (size - sizeof(*objattr) < objattr->sd_len) ||
342 (size - sizeof(*objattr) - objattr->sd_len < objattr->name_len))
343 {
344 set_error( STATUS_ACCESS_VIOLATION );
345 return FALSE;
346 }
347
348 if (objattr->sd_len)
349 {
350 const struct security_descriptor *sd = (const struct security_descriptor *)(objattr + 1);
351 if (!sd_is_valid( sd, objattr->sd_len ))
352 {
353 set_error( STATUS_INVALID_SECURITY_DESCR );
354 return FALSE;
355 }
356 }
357
358 return TRUE;
359 }
360
361 /* maps from generic rights to specific rights as given by a mapping */
362 static inline void map_generic_mask(unsigned int *mask, const GENERIC_MAPPING *mapping)
363 {
364 if (*mask & GENERIC_READ) *mask |= mapping->GenericRead;
365 if (*mask & GENERIC_WRITE) *mask |= mapping->GenericWrite;
366 if (*mask & GENERIC_EXECUTE) *mask |= mapping->GenericExecute;
367 if (*mask & GENERIC_ALL) *mask |= mapping->GenericAll;
368 *mask &= 0x0FFFFFFF;
369 }
370
371 static inline int is_equal_luid( const LUID *luid1, const LUID *luid2 )
372 {
373 return (luid1->LowPart == luid2->LowPart && luid1->HighPart == luid2->HighPart);
374 }
375
376 static inline void allocate_luid( luid_t *luid )
377 {
378 prev_luid_value.low_part++;
379 *luid = prev_luid_value;
380 }
381
382 DECL_HANDLER( allocate_locally_unique_id )
383 {
384 allocate_luid( &reply->luid );
385 }
386
387 static inline void luid_and_attr_from_privilege( LUID_AND_ATTRIBUTES *out, const struct privilege *in)
388 {
389 out->Luid = in->luid;
390 out->Attributes =
391 (in->enabled ? SE_PRIVILEGE_ENABLED : 0) |
392 (in->def ? SE_PRIVILEGE_ENABLED_BY_DEFAULT : 0);
393 }
394
395 static struct privilege *privilege_add( struct token *token, const LUID *luid, int enabled )
396 {
397 struct privilege *privilege = mem_alloc( sizeof(*privilege) );
398 if (privilege)
399 {
400 privilege->luid = *luid;
401 privilege->def = privilege->enabled = (enabled != 0);
402 list_add_tail( &token->privileges, &privilege->entry );
403 }
404 return privilege;
405 }
406
407 static inline void privilege_remove( struct privilege *privilege )
408 {
409 list_remove( &privilege->entry );
410 free( privilege );
411 }
412
413 static void token_destroy( struct object *obj )
414 {
415 struct token* token;
416 struct list *cursor, *cursor_next;
417
418 assert( obj->ops == &token_ops );
419 token = (struct token *)obj;
420
421 free( token->user );
422
423 LIST_FOR_EACH_SAFE( cursor, cursor_next, &token->privileges )
424 {
425 struct privilege *privilege = LIST_ENTRY( cursor, struct privilege, entry );
426 privilege_remove( privilege );
427 }
428
429 LIST_FOR_EACH_SAFE( cursor, cursor_next, &token->groups )
430 {
431 struct group *group = LIST_ENTRY( cursor, struct group, entry );
432 list_remove( &group->entry );
433 free( group );
434 }
435
436 free( token->default_dacl );
437 }
438
439 /* creates a new token.
440 * groups may be NULL if group_count is 0.
441 * privs may be NULL if priv_count is 0.
442 * default_dacl may be NULL, indicating that all objects created by the user
443 * are unsecured.
444 * modified_id may be NULL, indicating that a new modified_id luid should be
445 * allocated.
446 */
447 static struct token *create_token( unsigned primary, const SID *user,
448 const SID_AND_ATTRIBUTES *groups, unsigned int group_count,
449 const LUID_AND_ATTRIBUTES *privs, unsigned int priv_count,
450 const ACL *default_dacl, TOKEN_SOURCE source,
451 const luid_t *modified_id,
452 int impersonation_level )
453 {
454 struct token *token = alloc_object( &token_ops );
455 if (token)
456 {
457 unsigned int i;
458
459 allocate_luid( &token->token_id );
460 if (modified_id)
461 token->modified_id = *modified_id;
462 else
463 allocate_luid( &token->modified_id );
464 list_init( &token->privileges );
465 list_init( &token->groups );
466 token->primary = primary;
467 /* primary tokens don't have impersonation levels */
468 if (primary)
469 token->impersonation_level = -1;
470 else
471 token->impersonation_level = impersonation_level;
472 token->default_dacl = NULL;
473 token->primary_group = NULL;
474
475 /* copy user */
476 token->user = memdup( user, security_sid_len( user ));
477 if (!token->user)
478 {
479 release_object( token );
480 return NULL;
481 }
482
483 /* copy groups */
484 for (i = 0; i < group_count; i++)
485 {
486 size_t size = FIELD_OFFSET( struct group, sid.SubAuthority[((const SID *)groups[i].Sid)->SubAuthorityCount] );
487 struct group *group = mem_alloc( size );
488
489 if (!group)
490 {
491 release_object( token );
492 return NULL;
493 }
494 memcpy( &group->sid, groups[i].Sid, security_sid_len( groups[i].Sid ));
495 group->enabled = TRUE;
496 group->def = TRUE;
497 group->logon = (groups[i].Attributes & SE_GROUP_LOGON_ID) != 0;
498 group->mandatory = (groups[i].Attributes & SE_GROUP_MANDATORY) != 0;
499 group->owner = (groups[i].Attributes & SE_GROUP_OWNER) != 0;
500 group->resource = FALSE;
501 group->deny_only = FALSE;
502 list_add_tail( &token->groups, &group->entry );
503 /* Use first owner capable group as an owner */
504 if (!token->primary_group && group->owner)
505 token->primary_group = &group->sid;
506 }
507
508 /* copy privileges */
509 for (i = 0; i < priv_count; i++)
510 {
511 /* note: we don't check uniqueness: the caller must make sure
512 * privs doesn't contain any duplicate luids */
513 if (!privilege_add( token, &privs[i].Luid,
514 privs[i].Attributes & SE_PRIVILEGE_ENABLED ))
515 {
516 release_object( token );
517 return NULL;
518 }
519 }
520
521 if (default_dacl)
522 {
523 token->default_dacl = memdup( default_dacl, default_dacl->AclSize );
524 if (!token->default_dacl)
525 {
526 release_object( token );
527 return NULL;
528 }
529 }
530
531 token->source = source;
532 }
533 return token;
534 }
535
536 struct token *token_duplicate( struct token *src_token, unsigned primary,
537 int impersonation_level )
538 {
539 const luid_t *modified_id =
540 primary || (impersonation_level == src_token->impersonation_level) ?
541 &src_token->modified_id : NULL;
542 struct token *token = NULL;
543 struct privilege *privilege;
544 struct group *group;
545
546 if (!primary &&
547 (impersonation_level < SecurityAnonymous ||
548 impersonation_level > SecurityDelegation ||
549 (!src_token->primary && (impersonation_level > src_token->impersonation_level))))
550 {
551 set_error( STATUS_BAD_IMPERSONATION_LEVEL );
552 return NULL;
553 }
554
555 token = create_token( primary, src_token->user, NULL, 0,
556 NULL, 0, src_token->default_dacl,
557 src_token->source, modified_id,
558 impersonation_level );
559 if (!token) return token;
560
561 /* copy groups */
562 LIST_FOR_EACH_ENTRY( group, &src_token->groups, struct group, entry )
563 {
564 size_t size = FIELD_OFFSET( struct group, sid.SubAuthority[group->sid.SubAuthorityCount] );
565 struct group *newgroup = mem_alloc( size );
566 if (!newgroup)
567 {
568 release_object( token );
569 return NULL;
570 }
571 memcpy( newgroup, group, size );
572 list_add_tail( &token->groups, &newgroup->entry );
573 }
574 token->primary_group = src_token->primary_group;
575 assert( token->primary_group );
576
577 /* copy privileges */
578 LIST_FOR_EACH_ENTRY( privilege, &src_token->privileges, struct privilege, entry )
579 if (!privilege_add( token, &privilege->luid, privilege->enabled ))
580 {
581 release_object( token );
582 return NULL;
583 }
584
585 return token;
586 }
587
588 static ACL *create_default_dacl( const SID *user )
589 {
590 ACCESS_ALLOWED_ACE *aaa;
591 ACL *default_dacl;
592 SID *sid;
593 size_t default_dacl_size = sizeof(ACL) +
594 2*(sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) +
595 sizeof(local_system_sid) +
596 security_sid_len( user );
597
598 default_dacl = mem_alloc( default_dacl_size );
599 if (!default_dacl) return NULL;
600
601 default_dacl->AclRevision = ACL_REVISION;
602 default_dacl->Sbz1 = 0;
603 default_dacl->AclSize = default_dacl_size;
604 default_dacl->AceCount = 2;
605 default_dacl->Sbz2 = 0;
606
607 /* GENERIC_ALL for Local System */
608 aaa = (ACCESS_ALLOWED_ACE *)(default_dacl + 1);
609 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
610 aaa->Header.AceFlags = 0;
611 aaa->Header.AceSize = (sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) +
612 sizeof(local_system_sid);
613 aaa->Mask = GENERIC_ALL;
614 sid = (SID *)&aaa->SidStart;
615 memcpy( sid, &local_system_sid, sizeof(local_system_sid) );
616
617 /* GENERIC_ALL for specified user */
618 aaa = (ACCESS_ALLOWED_ACE *)((char *)aaa + aaa->Header.AceSize);
619 aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
620 aaa->Header.AceFlags = 0;
621 aaa->Header.AceSize = (sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD)) + security_sid_len( user );
622 aaa->Mask = GENERIC_ALL;
623 sid = (SID *)&aaa->SidStart;
624 memcpy( sid, user, security_sid_len( user ));
625
626 return default_dacl;
627 }
628
629 struct sid_data
630 {
631 SID_IDENTIFIER_AUTHORITY idauth;
632 int count;
633 unsigned int subauth[MAX_SUBAUTH_COUNT];
634 };
635
636 struct token *token_create_admin( void )
637 {
638 struct token *token = NULL;
639 static const SID_IDENTIFIER_AUTHORITY nt_authority = { SECURITY_NT_AUTHORITY };
640 static const unsigned int alias_admins_subauth[] = { SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS };
641 static const unsigned int alias_users_subauth[] = { SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_USERS };
642 /* on Windows, this value changes every time the user logs on */
643 static const unsigned int logon_subauth[] = { SECURITY_LOGON_IDS_RID, 0, 1 /* FIXME: should be randomly generated when tokens are inherited by new processes */ };
644 PSID alias_admins_sid;
645 PSID alias_users_sid;
646 PSID logon_sid;
647 const SID *user_sid = security_unix_uid_to_sid( getuid() );
648 ACL *default_dacl = create_default_dacl( user_sid );
649
650 alias_admins_sid = security_sid_alloc( &nt_authority, sizeof(alias_admins_subauth)/sizeof(alias_admins_subauth[0]),
651 alias_admins_subauth );
652 alias_users_sid = security_sid_alloc( &nt_authority, sizeof(alias_users_subauth)/sizeof(alias_users_subauth[0]),
653 alias_users_subauth );
654 logon_sid = security_sid_alloc( &nt_authority, sizeof(logon_subauth)/sizeof(logon_subauth[0]),
655 logon_subauth );
656
657 if (alias_admins_sid && alias_users_sid && logon_sid && default_dacl)
658 {
659 const LUID_AND_ATTRIBUTES admin_privs[] =
660 {
661 { SeChangeNotifyPrivilege , SE_PRIVILEGE_ENABLED },
662 { SeSecurityPrivilege , 0 },
663 { SeBackupPrivilege , 0 },
664 { SeRestorePrivilege , 0 },
665 { SeSystemtimePrivilege , 0 },
666 { SeShutdownPrivilege , 0 },
667 { SeRemoteShutdownPrivilege , 0 },
668 { SeTakeOwnershipPrivilege , 0 },
669 { SeDebugPrivilege , 0 },
670 { SeSystemEnvironmentPrivilege , 0 },
671 { SeSystemProfilePrivilege , 0 },
672 { SeProfileSingleProcessPrivilege, 0 },
673 { SeIncreaseBasePriorityPrivilege, 0 },
674 { SeLoadDriverPrivilege , SE_PRIVILEGE_ENABLED },
675 { SeCreatePagefilePrivilege , 0 },
676 { SeIncreaseQuotaPrivilege , 0 },
677 { SeUndockPrivilege , 0 },
678 { SeManageVolumePrivilege , 0 },
679 { SeImpersonatePrivilege , SE_PRIVILEGE_ENABLED },
680 { SeCreateGlobalPrivilege , SE_PRIVILEGE_ENABLED },
681 };
682 /* note: we don't include non-builtin groups here for the user -
683 * telling us these is the job of a client-side program */
684 const SID_AND_ATTRIBUTES admin_groups[] =
685 {
686 { security_world_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY },
687 { security_local_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY },
688 { security_interactive_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY },
689 { security_authenticated_user_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY },
690 { alias_admins_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY|SE_GROUP_OWNER },
691 { alias_users_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY },
692 { logon_sid, SE_GROUP_ENABLED|SE_GROUP_ENABLED_BY_DEFAULT|SE_GROUP_MANDATORY|SE_GROUP_LOGON_ID },
693 };
694 static const TOKEN_SOURCE admin_source = {"SeMgr", {0, 0}};
695 token = create_token( TRUE, user_sid, admin_groups, sizeof(admin_groups)/sizeof(admin_groups[0]),
696 admin_privs, sizeof(admin_privs)/sizeof(admin_privs[0]), default_dacl,
697 admin_source, NULL, -1 );
698 /* we really need a primary group */
699 assert( token->primary_group );
700 }
701
702 free( logon_sid );
703 free( alias_admins_sid );
704 free( alias_users_sid );
705 free( default_dacl );
706
707 return token;
708 }
709
710 static struct privilege *token_find_privilege( struct token *token, const LUID *luid, int enabled_only )
711 {
712 struct privilege *privilege;
713 LIST_FOR_EACH_ENTRY( privilege, &token->privileges, struct privilege, entry )
714 {
715 if (is_equal_luid( luid, &privilege->luid ))
716 {
717 if (enabled_only && !privilege->enabled)
718 return NULL;
719 return privilege;
720 }
721 }
722 return NULL;
723 }
724
725 static unsigned int token_adjust_privileges( struct token *token, const LUID_AND_ATTRIBUTES *privs,
726 unsigned int count, LUID_AND_ATTRIBUTES *mod_privs,
727 unsigned int mod_privs_count )
728 {
729 unsigned int i, modified_count = 0;
730
731 /* mark as modified */
732 allocate_luid( &token->modified_id );
733
734 for (i = 0; i < count; i++)
735 {
736 struct privilege *privilege =
737 token_find_privilege( token, &privs[i].Luid, FALSE );
738 if (!privilege)
739 {
740 set_error( STATUS_NOT_ALL_ASSIGNED );
741 continue;
742 }
743
744 if (privs[i].Attributes & SE_PRIVILEGE_REMOVED)
745 privilege_remove( privilege );
746 else
747 {
748 /* save previous state for caller */
749 if (mod_privs_count)
750 {
751 luid_and_attr_from_privilege(mod_privs, privilege);
752 mod_privs++;
753 mod_privs_count--;
754 modified_count++;
755 }
756
757 if (privs[i].Attributes & SE_PRIVILEGE_ENABLED)
758 privilege->enabled = TRUE;
759 else
760 privilege->enabled = FALSE;
761 }
762 }
763 return modified_count;
764 }
765
766 static void token_disable_privileges( struct token *token )
767 {
768 struct privilege *privilege;
769
770 /* mark as modified */
771 allocate_luid( &token->modified_id );
772
773 LIST_FOR_EACH_ENTRY( privilege, &token->privileges, struct privilege, entry )
774 privilege->enabled = FALSE;
775 }
776
777 int token_check_privileges( struct token *token, int all_required,
778 const LUID_AND_ATTRIBUTES *reqprivs,
779 unsigned int count, LUID_AND_ATTRIBUTES *usedprivs)
780 {
781 unsigned int i, enabled_count = 0;
782
783 for (i = 0; i < count; i++)
784 {
785 struct privilege *privilege =
786 token_find_privilege( token, &reqprivs[i].Luid, TRUE );
787
788 if (usedprivs)
789 usedprivs[i] = reqprivs[i];
790
791 if (privilege && privilege->enabled)
792 {
793 enabled_count++;
794 if (usedprivs)
795 usedprivs[i].Attributes |= SE_PRIVILEGE_USED_FOR_ACCESS;
796 }
797 }
798
799 if (all_required)
800 return (enabled_count == count);
801 else
802 return (enabled_count > 0);
803 }
804
805 int token_sid_present( struct token *token, const SID *sid, int deny )
806 {
807 struct group *group;
808
809 if (security_equal_sid( token->user, sid )) return TRUE;
810
811 LIST_FOR_EACH_ENTRY( group, &token->groups, struct group, entry )
812 {
813 if (!group->enabled) continue;
814 if (group->deny_only && !deny) continue;
815
816 if (security_equal_sid( &group->sid, sid )) return TRUE;
817 }
818
819 return FALSE;
820 }
821
822 /* Checks access to a security descriptor. 'sd' must have been validated by
823 * caller. It returns STATUS_SUCCESS if call succeeded or an error indicating
824 * the reason. 'status' parameter will indicate if access is granted or denied.
825 *
826 * If both returned value and 'status' are STATUS_SUCCESS then access is granted.
827 */
828 static unsigned int token_access_check( struct token *token,
829 const struct security_descriptor *sd,
830 unsigned int desired_access,
831 LUID_AND_ATTRIBUTES *privs,
832 unsigned int *priv_count,
833 const GENERIC_MAPPING *mapping,
834 unsigned int *granted_access,
835 unsigned int *status )
836 {
837 unsigned int current_access = 0;
838 unsigned int denied_access = 0;
839 ULONG i;
840 const ACL *dacl;
841 int dacl_present;
842 const ACE_HEADER *ace;
843 const SID *owner;
844
845 /* assume no access rights */
846 *granted_access = 0;
847
848 /* fail if desired_access contains generic rights */
849 if (desired_access & (GENERIC_READ|GENERIC_WRITE|GENERIC_EXECUTE|GENERIC_ALL))
850 {
851 *priv_count = 0;
852 return STATUS_GENERIC_NOT_MAPPED;
853 }
854
855 dacl = sd_get_dacl( sd, &dacl_present );
856 owner = sd_get_owner( sd );
857 if (!owner || !sd_get_group( sd ))
858 {
859 *priv_count = 0;
860 return STATUS_INVALID_SECURITY_DESCR;
861 }
862
863 /* 1: Grant desired access if the object is unprotected */
864 if (!dacl_present || !dacl)
865 {
866 *priv_count = 0;
867 *granted_access = desired_access;
868 return *status = STATUS_SUCCESS;
869 }
870
871 /* 2: Check if caller wants access to system security part. Note: access
872 * is only granted if specifically asked for */
873 if (desired_access & ACCESS_SYSTEM_SECURITY)
874 {
875 const LUID_AND_ATTRIBUTES security_priv = { SeSecurityPrivilege, 0 };
876 LUID_AND_ATTRIBUTES retpriv = security_priv;
877 if (token_check_privileges( token, TRUE, &security_priv, 1, &retpriv ))
878 {
879 if (priv_count)
880 {
881 /* assumes that there will only be one privilege to return */
882 if (*priv_count >= 1)
883 {
884 *priv_count = 1;
885 *privs = retpriv;
886 }
887 else
888 {
889 *priv_count = 1;
890 return STATUS_BUFFER_TOO_SMALL;
891 }
892 }
893 current_access |= ACCESS_SYSTEM_SECURITY;
894 if (desired_access == current_access)
895 {
896 *granted_access = current_access;
897 return *status = STATUS_SUCCESS;
898 }
899 }
900 else
901 {
902 *priv_count = 0;
903 *status = STATUS_PRIVILEGE_NOT_HELD;
904 return STATUS_SUCCESS;
905 }
906 }
907 else if (priv_count) *priv_count = 0;
908
909 /* 3: Check whether the token is the owner */
910 /* NOTE: SeTakeOwnershipPrivilege is not checked for here - it is instead
911 * checked when a "set owner" call is made, overriding the access rights
912 * determined here. */
913 if (token_sid_present( token, owner, FALSE ))
914 {
915 current_access |= (READ_CONTROL | WRITE_DAC);
916 if (desired_access == current_access)
917 {
918 *granted_access = current_access;
919 return *status = STATUS_SUCCESS;
920 }
921 }
922
923 /* 4: Grant rights according to the DACL */
924 ace = (const ACE_HEADER *)(dacl + 1);
925 for (i = 0; i < dacl->AceCount; i++, ace = ace_next( ace ))
926 {
927 const ACCESS_ALLOWED_ACE *aa_ace;
928 const ACCESS_DENIED_ACE *ad_ace;
929 const SID *sid;
930
931 if (ace->AceFlags & INHERIT_ONLY_ACE)
932 continue;
933
934 switch (ace->AceType)
935 {
936 case ACCESS_DENIED_ACE_TYPE:
937 ad_ace = (const ACCESS_DENIED_ACE *)ace;
938 sid = (const SID *)&ad_ace->SidStart;
939 if (token_sid_present( token, sid, TRUE ))
940 {
941 unsigned int access = ad_ace->Mask;
942 map_generic_mask(&access, mapping);
943 if (desired_access & MAXIMUM_ALLOWED)
944 denied_access |= access;
945 else
946 {
947 denied_access |= (access & ~current_access);
948 if (desired_access & access) goto done;
949 }
950 }
951 break;
952 case ACCESS_ALLOWED_ACE_TYPE:
953 aa_ace = (const ACCESS_ALLOWED_ACE *)ace;
954 sid = (const SID *)&aa_ace->SidStart;
955 if (token_sid_present( token, sid, FALSE ))
956 {
957 unsigned int access = aa_ace->Mask;
958 map_generic_mask(&access, mapping);
959 if (desired_access & MAXIMUM_ALLOWED)
960 current_access |= access;
961 else
962 current_access |= (access & ~denied_access);
963 }
964 break;
965 }
966
967 /* don't bother carrying on checking if we've already got all of
968 * rights we need */
969 if (desired_access == *granted_access)
970 break;
971 }
972
973 done:
974 if (desired_access & MAXIMUM_ALLOWED)
975 *granted_access = current_access & ~denied_access;
976 else
977 if ((current_access & desired_access) == desired_access)
978 *granted_access = current_access & desired_access;
979 else
980 *granted_access = 0;
981
982 *status = *granted_access ? STATUS_SUCCESS : STATUS_ACCESS_DENIED;
983 return STATUS_SUCCESS;
984 }
985
986 const ACL *token_get_default_dacl( struct token *token )
987 {
988 return token->default_dacl;
989 }
990
991 const SID *token_get_user( struct token *token )
992 {
993 return token->user;
994 }
995
996 const SID *token_get_primary_group( struct token *token )
997 {
998 return token->primary_group;
999 }
1000
1001 int check_object_access(struct object *obj, unsigned int *access)
1002 {
1003 GENERIC_MAPPING mapping;
1004 struct token *token = current->token ? current->token : current->process->token;
1005 LUID_AND_ATTRIBUTES priv;
1006 unsigned int status, priv_count = 1;
1007 int res;
1008
1009 mapping.GenericAll = obj->ops->map_access( obj, GENERIC_ALL );
1010
1011 if (!obj->sd)
1012 {
1013 if (*access & MAXIMUM_ALLOWED)
1014 *access = mapping.GenericAll;
1015 return TRUE;
1016 }
1017
1018 mapping.GenericRead = obj->ops->map_access( obj, GENERIC_READ );
1019 mapping.GenericWrite = obj->ops->map_access( obj, GENERIC_WRITE );
1020 mapping.GenericExecute = obj->ops->map_access( obj, GENERIC_EXECUTE );
1021
1022 res = token_access_check( token, obj->sd, *access, &priv, &priv_count,
1023 &mapping, access, &status ) == STATUS_SUCCESS &&
1024 status == STATUS_SUCCESS;
1025
1026 if (!res) set_error( STATUS_ACCESS_DENIED );
1027 return res;
1028 }
1029
1030
1031 /* open a security token */
1032 DECL_HANDLER(open_token)
1033 {
1034 if (req->flags & OPEN_TOKEN_THREAD)
1035 {
1036 struct thread *thread = get_thread_from_handle( req->handle, 0 );
1037 if (thread)
1038 {
1039 if (thread->token)
1040 {
1041 if (!thread->token->primary && thread->token->impersonation_level <= SecurityAnonymous)
1042 set_error( STATUS_CANT_OPEN_ANONYMOUS );
1043 else
1044 reply->token = alloc_handle( current->process, thread->token,
1045 req->access, req->attributes );
1046 }
1047 else
1048 set_error( STATUS_NO_TOKEN );
1049 release_object( thread );
1050 }
1051 }
1052 else
1053 {
1054 struct process *process = get_process_from_handle( req->handle, 0 );
1055 if (process)
1056 {
1057 if (process->token)
1058 reply->token = alloc_handle( current->process, process->token, req->access,
1059 req->attributes );
1060 else
1061 set_error( STATUS_NO_TOKEN );
1062 release_object( process );
1063 }
1064 }
1065 }
1066
1067 /* adjust the privileges held by a token */
1068 DECL_HANDLER(adjust_token_privileges)
1069 {
1070 struct token *token;
1071 unsigned int access = TOKEN_ADJUST_PRIVILEGES;
1072
1073 if (req->get_modified_state) access |= TOKEN_QUERY;
1074
1075 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1076 access, &token_ops )))
1077 {
1078 const LUID_AND_ATTRIBUTES *privs = get_req_data();
1079 LUID_AND_ATTRIBUTES *modified_privs = NULL;
1080 unsigned int priv_count = get_req_data_size() / sizeof(LUID_AND_ATTRIBUTES);
1081 unsigned int modified_priv_count = 0;
1082
1083 if (req->get_modified_state && !req->disable_all)
1084 {
1085 unsigned int i;
1086 /* count modified privs */
1087 for (i = 0; i < priv_count; i++)
1088 {
1089 struct privilege *privilege =
1090 token_find_privilege( token, &privs[i].Luid, FALSE );
1091 if (privilege && req->get_modified_state)
1092 modified_priv_count++;
1093 }
1094 reply->len = modified_priv_count;
1095 modified_priv_count = min( modified_priv_count, get_reply_max_size() / sizeof(*modified_privs) );
1096 if (modified_priv_count)
1097 modified_privs = set_reply_data_size( modified_priv_count * sizeof(*modified_privs) );
1098 }
1099 reply->len = modified_priv_count * sizeof(*modified_privs);
1100
1101 if (req->disable_all)
1102 token_disable_privileges( token );
1103 else
1104 modified_priv_count = token_adjust_privileges( token, privs,
1105 priv_count, modified_privs, modified_priv_count );
1106
1107 release_object( token );
1108 }
1109 }
1110
1111 /* retrieves the list of privileges that may be held be the token */
1112 DECL_HANDLER(get_token_privileges)
1113 {
1114 struct token *token;
1115
1116 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1117 TOKEN_QUERY,
1118 &token_ops )))
1119 {
1120 int priv_count = 0;
1121 LUID_AND_ATTRIBUTES *privs;
1122 struct privilege *privilege;
1123
1124 LIST_FOR_EACH_ENTRY( privilege, &token->privileges, struct privilege, entry )
1125 priv_count++;
1126
1127 reply->len = priv_count * sizeof(*privs);
1128 if (reply->len <= get_reply_max_size())
1129 {
1130 privs = set_reply_data_size( priv_count * sizeof(*privs) );
1131 if (privs)
1132 {
1133 int i = 0;
1134 LIST_FOR_EACH_ENTRY( privilege, &token->privileges, struct privilege, entry )
1135 {
1136 luid_and_attr_from_privilege( &privs[i], privilege );
1137 i++;
1138 }
1139 }
1140 }
1141 else
1142 set_error(STATUS_BUFFER_TOO_SMALL);
1143
1144 release_object( token );
1145 }
1146 }
1147
1148 /* creates a duplicate of the token */
1149 DECL_HANDLER(duplicate_token)
1150 {
1151 struct token *src_token;
1152
1153 if ((src_token = (struct token *)get_handle_obj( current->process, req->handle,
1154 TOKEN_DUPLICATE,
1155 &token_ops )))
1156 {
1157 struct token *token = token_duplicate( src_token, req->primary, req->impersonation_level );
1158 if (token)
1159 {
1160 reply->new_handle = alloc_handle( current->process, token, req->access, req->attributes);
1161 release_object( token );
1162 }
1163 release_object( src_token );
1164 }
1165 }
1166
1167 /* checks the specified privileges are held by the token */
1168 DECL_HANDLER(check_token_privileges)
1169 {
1170 struct token *token;
1171
1172 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1173 TOKEN_QUERY,
1174 &token_ops )))
1175 {
1176 unsigned int count = get_req_data_size() / sizeof(LUID_AND_ATTRIBUTES);
1177
1178 if (!token->primary && token->impersonation_level <= SecurityAnonymous)
1179 set_error( STATUS_BAD_IMPERSONATION_LEVEL );
1180 else if (get_reply_max_size() >= count * sizeof(LUID_AND_ATTRIBUTES))
1181 {
1182 LUID_AND_ATTRIBUTES *usedprivs = set_reply_data_size( count * sizeof(*usedprivs) );
1183 reply->has_privileges = token_check_privileges( token, req->all_required, get_req_data(), count, usedprivs );
1184 }
1185 else
1186 set_error( STATUS_BUFFER_OVERFLOW );
1187 release_object( token );
1188 }
1189 }
1190
1191 /* checks that a user represented by a token is allowed to access an object
1192 * represented by a security descriptor */
1193 DECL_HANDLER(access_check)
1194 {
1195 data_size_t sd_size = get_req_data_size();
1196 const struct security_descriptor *sd = get_req_data();
1197 struct token *token;
1198
1199 if (!sd_is_valid( sd, sd_size ))
1200 {
1201 set_error( STATUS_ACCESS_VIOLATION );
1202 return;
1203 }
1204
1205 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1206 TOKEN_QUERY,
1207 &token_ops )))
1208 {
1209 GENERIC_MAPPING mapping;
1210 unsigned int status;
1211 LUID_AND_ATTRIBUTES priv;
1212 unsigned int priv_count = 1;
1213
1214 memset(&priv, 0, sizeof(priv));
1215
1216 /* only impersonation tokens may be used with this function */
1217 if (token->primary)
1218 {
1219 set_error( STATUS_NO_IMPERSONATION_TOKEN );
1220 release_object( token );
1221 return;
1222 }
1223 /* anonymous impersonation tokens can't be used */
1224 if (token->impersonation_level <= SecurityAnonymous)
1225 {
1226 set_error( STATUS_BAD_IMPERSONATION_LEVEL );
1227 release_object( token );
1228 return;
1229 }
1230
1231 mapping.GenericRead = req->mapping_read;
1232 mapping.GenericWrite = req->mapping_write;
1233 mapping.GenericExecute = req->mapping_execute;
1234 mapping.GenericAll = req->mapping_all;
1235
1236 status = token_access_check(
1237 token, sd, req->desired_access, &priv, &priv_count, &mapping,
1238 &reply->access_granted, &reply->access_status );
1239
1240 reply->privileges_len = priv_count*sizeof(LUID_AND_ATTRIBUTES);
1241
1242 if ((priv_count > 0) && (reply->privileges_len <= get_reply_max_size()))
1243 {
1244 LUID_AND_ATTRIBUTES *privs = set_reply_data_size( priv_count * sizeof(*privs) );
1245 memcpy( privs, &priv, sizeof(priv) );
1246 }
1247
1248 set_error( status );
1249 release_object( token );
1250 }
1251 }
1252
1253 /* retrieves the SID of the user that the token represents */
1254 DECL_HANDLER(get_token_sid)
1255 {
1256 struct token *token;
1257
1258 reply->sid_len = 0;
1259
1260 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1261 TOKEN_QUERY,
1262 &token_ops )))
1263 {
1264 const SID *sid = NULL;
1265
1266 switch (req->which_sid)
1267 {
1268 case TokenUser:
1269 assert(token->user);
1270 sid = token->user;
1271 break;
1272 case TokenPrimaryGroup:
1273 sid = token->primary_group;
1274 break;
1275 case TokenOwner:
1276 {
1277 struct group *group;
1278 LIST_FOR_EACH_ENTRY( group, &token->groups, struct group, entry )
1279 {
1280 if (group->owner)
1281 {
1282 sid = &group->sid;
1283 break;
1284 }
1285 }
1286 break;
1287 }
1288 default:
1289 set_error( STATUS_INVALID_PARAMETER );
1290 break;
1291 }
1292
1293 if (sid)
1294 {
1295 reply->sid_len = security_sid_len( sid );
1296 if (reply->sid_len <= get_reply_max_size()) set_reply_data( sid, reply->sid_len );
1297 else set_error( STATUS_BUFFER_TOO_SMALL );
1298 }
1299 release_object( token );
1300 }
1301 }
1302
1303 /* retrieves the groups that the user represented by the token belongs to */
1304 DECL_HANDLER(get_token_groups)
1305 {
1306 struct token *token;
1307
1308 reply->user_len = 0;
1309
1310 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1311 TOKEN_QUERY,
1312 &token_ops )))
1313 {
1314 size_t size_needed = sizeof(struct token_groups);
1315 size_t sid_size = 0;
1316 unsigned int group_count = 0;
1317 const struct group *group;
1318
1319 LIST_FOR_EACH_ENTRY( group, &token->groups, const struct group, entry )
1320 {
1321 group_count++;
1322 sid_size += security_sid_len( &group->sid );
1323 }
1324 size_needed += sid_size;
1325 /* attributes size */
1326 size_needed += sizeof(unsigned int) * group_count;
1327
1328 /* reply buffer contains size_needed bytes formatted as:
1329
1330 unsigned int count;
1331 unsigned int attrib[count];
1332 char sid_data[];
1333
1334 user_len includes extra data needed for TOKEN_GROUPS representation,
1335 required caller buffer size calculated here to avoid extra server call */
1336 reply->user_len = FIELD_OFFSET( TOKEN_GROUPS, Groups[group_count] ) + sid_size;
1337
1338 if (reply->user_len <= get_reply_max_size())
1339 {
1340 struct token_groups *tg = set_reply_data_size( size_needed );
1341 if (tg)
1342 {
1343 unsigned int *attr_ptr = (unsigned int *)(tg + 1);
1344 SID *sid_ptr = (SID *)(attr_ptr + group_count);
1345
1346 tg->count = group_count;
1347
1348 LIST_FOR_EACH_ENTRY( group, &token->groups, const struct group, entry )
1349 {
1350
1351 *attr_ptr = 0;
1352 if (group->mandatory) *attr_ptr |= SE_GROUP_MANDATORY;
1353 if (group->def) *attr_ptr |= SE_GROUP_ENABLED_BY_DEFAULT;
1354 if (group->enabled) *attr_ptr |= SE_GROUP_ENABLED;
1355 if (group->owner) *attr_ptr |= SE_GROUP_OWNER;
1356 if (group->deny_only) *attr_ptr |= SE_GROUP_USE_FOR_DENY_ONLY;
1357 if (group->resource) *attr_ptr |= SE_GROUP_RESOURCE;
1358 if (group->logon) *attr_ptr |= SE_GROUP_LOGON_ID;
1359
1360 memcpy(sid_ptr, &group->sid, security_sid_len( &group->sid ));
1361
1362 sid_ptr = (SID *)((char *)sid_ptr + security_sid_len( &group->sid ));
1363 attr_ptr++;
1364 }
1365 }
1366 }
1367 else set_error( STATUS_BUFFER_TOO_SMALL );
1368
1369 release_object( token );
1370 }
1371 }
1372
1373 DECL_HANDLER(get_token_impersonation_level)
1374 {
1375 struct token *token;
1376
1377 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1378 TOKEN_QUERY,
1379 &token_ops )))
1380 {
1381 if (token->primary)
1382 set_error( STATUS_INVALID_PARAMETER );
1383 else
1384 reply->impersonation_level = token->impersonation_level;
1385
1386 release_object( token );
1387 }
1388 }
1389
1390 DECL_HANDLER(get_token_statistics)
1391 {
1392 struct token *token;
1393
1394 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1395 TOKEN_QUERY,
1396 &token_ops )))
1397 {
1398 reply->token_id = token->token_id;
1399 reply->modified_id = token->modified_id;
1400 reply->primary = token->primary;
1401 reply->impersonation_level = token->impersonation_level;
1402 reply->group_count = list_count( &token->groups );
1403 reply->privilege_count = list_count( &token->privileges );
1404
1405 release_object( token );
1406 }
1407 }
1408
1409 DECL_HANDLER(get_token_default_dacl)
1410 {
1411 struct token *token;
1412
1413 reply->acl_len = 0;
1414
1415 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1416 TOKEN_QUERY,
1417 &token_ops )))
1418 {
1419 if (token->default_dacl)
1420 reply->acl_len = token->default_dacl->AclSize;
1421
1422 if (reply->acl_len <= get_reply_max_size())
1423 {
1424 ACL *acl_reply = set_reply_data_size( reply->acl_len );
1425 if (acl_reply)
1426 memcpy( acl_reply, token->default_dacl, reply->acl_len );
1427 }
1428 else set_error( STATUS_BUFFER_TOO_SMALL );
1429
1430 release_object( token );
1431 }
1432 }
1433
1434 DECL_HANDLER(set_token_default_dacl)
1435 {
1436 struct token *token;
1437
1438 if ((token = (struct token *)get_handle_obj( current->process, req->handle,
1439 TOKEN_ADJUST_DEFAULT,
1440 &token_ops )))
1441 {
1442 const ACL *acl = get_req_data();
1443 unsigned int acl_size = get_req_data_size();
1444
1445 free( token->default_dacl );
1446 token->default_dacl = NULL;
1447
1448 if (acl_size)
1449 token->default_dacl = memdup( acl, acl_size );
1450
1451 release_object( token );
1452 }
1453 }
Windows API implementation