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