git.oblomov.eu Git - wine/blob - server/token.c

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