git.oblomov.eu Git - wine/blob - dlls/advapi32/tests/security.c

   1 /*
   2  * Unit tests for security functions
   3  *
   4  * Copyright (c) 2004 Mike McCormack
   5  * Copyright (c) 2011 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "aclapi.h"
  31 #include "winnt.h"
  32 #include "sddl.h"
  33 #include "ntsecapi.h"
  34 #include "lmcons.h"
  35
  36 #include "wine/test.h"
  37
  38 /* PROCESS_ALL_ACCESS in Vista+ PSDKs is incompatible with older Windows versions */
  39 #define PROCESS_ALL_ACCESS_NT4 (PROCESS_ALL_ACCESS & ~0xf000)
  40
  41 #ifndef EVENT_QUERY_STATE
  42 #define EVENT_QUERY_STATE 0x0001
  43 #endif
  44
  45 /* copied from Wine winternl.h - not included in the Windows SDK */
  46 typedef enum _OBJECT_INFORMATION_CLASS {
  47     ObjectBasicInformation,
  48     ObjectNameInformation,
  49     ObjectTypeInformation,
  50     ObjectAllInformation,
  51     ObjectDataInformation
  52 } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
  53
  54 typedef struct _OBJECT_BASIC_INFORMATION {
  55     ULONG  Attributes;
  56     ACCESS_MASK  GrantedAccess;
  57     ULONG  HandleCount;
  58     ULONG  PointerCount;
  59     ULONG  PagedPoolUsage;
  60     ULONG  NonPagedPoolUsage;
  61     ULONG  Reserved[3];
  62     ULONG  NameInformationLength;
  63     ULONG  TypeInformationLength;
  64     ULONG  SecurityDescriptorLength;
  65     LARGE_INTEGER  CreateTime;
  66 } OBJECT_BASIC_INFORMATION, *POBJECT_BASIC_INFORMATION;
  67
  68 #define expect_eq(expr, value, type, format) { type ret = expr; ok((value) == ret, #expr " expected " format "  got " format "\n", (value), (ret)); }
  69
  70 static BOOL (WINAPI *pAddAccessAllowedAceEx)(PACL, DWORD, DWORD, DWORD, PSID);
  71 static BOOL (WINAPI *pAddAccessDeniedAceEx)(PACL, DWORD, DWORD, DWORD, PSID);
  72 static BOOL (WINAPI *pAddAuditAccessAceEx)(PACL, DWORD, DWORD, DWORD, PSID, BOOL, BOOL);
  73 static VOID (WINAPI *pBuildTrusteeWithSidA)( PTRUSTEEA pTrustee, PSID pSid );
  74 static VOID (WINAPI *pBuildTrusteeWithNameA)( PTRUSTEEA pTrustee, LPSTR pName );
  75 static VOID (WINAPI *pBuildTrusteeWithObjectsAndNameA)( PTRUSTEEA pTrustee,
  76                                                           POBJECTS_AND_NAME_A pObjName,
  77                                                           SE_OBJECT_TYPE ObjectType,
  78                                                           LPSTR ObjectTypeName,
  79                                                           LPSTR InheritedObjectTypeName,
  80                                                           LPSTR Name );
  81 static VOID (WINAPI *pBuildTrusteeWithObjectsAndSidA)( PTRUSTEEA pTrustee,
  82                                                          POBJECTS_AND_SID pObjSid,
  83                                                          GUID* pObjectGuid,
  84                                                          GUID* pInheritedObjectGuid,
  85                                                          PSID pSid );
  86 static LPSTR (WINAPI *pGetTrusteeNameA)( PTRUSTEEA pTrustee );
  87 static BOOL (WINAPI *pMakeSelfRelativeSD)( PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD );
  88 static BOOL (WINAPI *pConvertSidToStringSidA)( PSID pSid, LPSTR *str );
  89 static BOOL (WINAPI *pConvertStringSidToSidA)( LPCSTR str, PSID pSid );
  90 static BOOL (WINAPI *pCheckTokenMembership)(HANDLE, PSID, PBOOL);
  91 static BOOL (WINAPI *pConvertStringSecurityDescriptorToSecurityDescriptorA)(LPCSTR, DWORD,
  92                                                                             PSECURITY_DESCRIPTOR*, PULONG );
  93 static BOOL (WINAPI *pConvertStringSecurityDescriptorToSecurityDescriptorW)(LPCWSTR, DWORD,
  94                                                                             PSECURITY_DESCRIPTOR*, PULONG );
  95 static BOOL (WINAPI *pConvertSecurityDescriptorToStringSecurityDescriptorA)(PSECURITY_DESCRIPTOR, DWORD,
  96                                                                             SECURITY_INFORMATION, LPSTR *, PULONG );
  97 static BOOL (WINAPI *pGetFileSecurityA)(LPCSTR, SECURITY_INFORMATION,
  98                                           PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
  99 static BOOL (WINAPI *pSetFileSecurityA)(LPCSTR, SECURITY_INFORMATION,
 100                                           PSECURITY_DESCRIPTOR);
 101 static DWORD (WINAPI *pGetNamedSecurityInfoA)(LPSTR, SE_OBJECT_TYPE, SECURITY_INFORMATION,
 102                                               PSID*, PSID*, PACL*, PACL*,
 103                                               PSECURITY_DESCRIPTOR*);
 104 static PDWORD (WINAPI *pGetSidSubAuthority)(PSID, DWORD);
 105 static PUCHAR (WINAPI *pGetSidSubAuthorityCount)(PSID);
 106 static BOOL (WINAPI *pIsValidSid)(PSID);
 107 static DWORD (WINAPI *pRtlAdjustPrivilege)(ULONG,BOOLEAN,BOOLEAN,PBOOLEAN);
 108 static BOOL (WINAPI *pCreateWellKnownSid)(WELL_KNOWN_SID_TYPE,PSID,PSID,DWORD*);
 109 static BOOL (WINAPI *pDuplicateTokenEx)(HANDLE,DWORD,LPSECURITY_ATTRIBUTES,
 110                                         SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
 111
 112 static NTSTATUS (WINAPI *pLsaQueryInformationPolicy)(LSA_HANDLE,POLICY_INFORMATION_CLASS,PVOID*);
 113 static NTSTATUS (WINAPI *pLsaClose)(LSA_HANDLE);
 114 static NTSTATUS (WINAPI *pLsaFreeMemory)(PVOID);
 115 static NTSTATUS (WINAPI *pLsaOpenPolicy)(PLSA_UNICODE_STRING,PLSA_OBJECT_ATTRIBUTES,ACCESS_MASK,PLSA_HANDLE);
 116 static NTSTATUS (WINAPI *pNtQueryObject)(HANDLE,OBJECT_INFORMATION_CLASS,PVOID,ULONG,PULONG);
 117 static DWORD (WINAPI *pSetEntriesInAclW)(ULONG, PEXPLICIT_ACCESSW, PACL, PACL*);
 118 static DWORD (WINAPI *pSetEntriesInAclA)(ULONG, PEXPLICIT_ACCESSA, PACL, PACL*);
 119 static BOOL (WINAPI *pSetSecurityDescriptorControl)(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL,
 120                                                     SECURITY_DESCRIPTOR_CONTROL);
 121 static DWORD (WINAPI *pGetSecurityInfo)(HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION,
 122                                         PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);
 123 static NTSTATUS (WINAPI *pNtAccessCheck)(PSECURITY_DESCRIPTOR, HANDLE, ACCESS_MASK, PGENERIC_MAPPING,
 124                                          PPRIVILEGE_SET, PULONG, PULONG, NTSTATUS*);
 125 static BOOL (WINAPI *pCreateRestrictedToken)(HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD,
 126                                              PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
 127
 128 static HMODULE hmod;
 129 static int     myARGC;
 130 static char**  myARGV;
 131
 132 struct sidRef
 133 {
 134     SID_IDENTIFIER_AUTHORITY auth;
 135     const char *refStr;
 136 };
 137
 138 static void init(void)
 139 {
 140     HMODULE hntdll;
 141
 142     hntdll = GetModuleHandleA("ntdll.dll");
 143     pNtQueryObject = (void *)GetProcAddress( hntdll, "NtQueryObject" );
 144     pNtAccessCheck = (void *)GetProcAddress( hntdll, "NtAccessCheck" );
 145
 146     hmod = GetModuleHandle("advapi32.dll");
 147     pAddAccessAllowedAceEx = (void *)GetProcAddress(hmod, "AddAccessAllowedAceEx");
 148     pAddAccessDeniedAceEx = (void *)GetProcAddress(hmod, "AddAccessDeniedAceEx");
 149     pAddAuditAccessAceEx = (void *)GetProcAddress(hmod, "AddAuditAccessAceEx");
 150     pCheckTokenMembership = (void *)GetProcAddress(hmod, "CheckTokenMembership");
 151     pConvertStringSecurityDescriptorToSecurityDescriptorA =
 152         (void *)GetProcAddress(hmod, "ConvertStringSecurityDescriptorToSecurityDescriptorA" );
 153     pConvertStringSecurityDescriptorToSecurityDescriptorW =
 154         (void *)GetProcAddress(hmod, "ConvertStringSecurityDescriptorToSecurityDescriptorW" );
 155     pConvertSecurityDescriptorToStringSecurityDescriptorA =
 156         (void *)GetProcAddress(hmod, "ConvertSecurityDescriptorToStringSecurityDescriptorA" );
 157     pGetFileSecurityA = (void *)GetProcAddress(hmod, "GetFileSecurityA" );
 158     pSetFileSecurityA = (void *)GetProcAddress(hmod, "SetFileSecurityA" );
 159     pCreateWellKnownSid = (void *)GetProcAddress( hmod, "CreateWellKnownSid" );
 160     pGetNamedSecurityInfoA = (void *)GetProcAddress(hmod, "GetNamedSecurityInfoA");
 161     pGetSidSubAuthority = (void *)GetProcAddress(hmod, "GetSidSubAuthority");
 162     pGetSidSubAuthorityCount = (void *)GetProcAddress(hmod, "GetSidSubAuthorityCount");
 163     pIsValidSid = (void *)GetProcAddress(hmod, "IsValidSid");
 164     pMakeSelfRelativeSD = (void *)GetProcAddress(hmod, "MakeSelfRelativeSD");
 165     pSetEntriesInAclW = (void *)GetProcAddress(hmod, "SetEntriesInAclW");
 166     pSetEntriesInAclA = (void *)GetProcAddress(hmod, "SetEntriesInAclA");
 167     pSetSecurityDescriptorControl = (void *)GetProcAddress(hmod, "SetSecurityDescriptorControl");
 168     pGetSecurityInfo = (void *)GetProcAddress(hmod, "GetSecurityInfo");
 169     pCreateRestrictedToken = (void *)GetProcAddress(hmod, "CreateRestrictedToken");
 170     pConvertSidToStringSidA = (void *)GetProcAddress(hmod, "ConvertSidToStringSidA");
 171     pConvertStringSidToSidA = (void *)GetProcAddress(hmod, "ConvertStringSidToSidA");
 172
 173     myARGC = winetest_get_mainargs( &myARGV );
 174 }
 175
 176 static void test_str_sid(const char *str_sid)
 177 {
 178     PSID psid;
 179     char *temp;
 180
 181     if (pConvertStringSidToSidA(str_sid, &psid))
 182     {
 183         if (pConvertSidToStringSidA(psid, &temp))
 184         {
 185             trace(" %s: %s\n", str_sid, temp);
 186             LocalFree(temp);
 187         }
 188         LocalFree(psid);
 189     }
 190     else
 191     {
 192         if (GetLastError() != ERROR_INVALID_SID)
 193             trace(" %s: couldn't be converted, returned %d\n", str_sid, GetLastError());
 194         else
 195             trace(" %s: couldn't be converted\n", str_sid);
 196     }
 197 }
 198
 199 static void test_sid(void)
 200 {
 201     struct sidRef refs[] = {
 202      { { {0x00,0x00,0x33,0x44,0x55,0x66} }, "S-1-860116326-1" },
 203      { { {0x00,0x00,0x01,0x02,0x03,0x04} }, "S-1-16909060-1"  },
 204      { { {0x00,0x00,0x00,0x01,0x02,0x03} }, "S-1-66051-1"     },
 205      { { {0x00,0x00,0x00,0x00,0x01,0x02} }, "S-1-258-1"       },
 206      { { {0x00,0x00,0x00,0x00,0x00,0x02} }, "S-1-2-1"         },
 207      { { {0x00,0x00,0x00,0x00,0x00,0x0c} }, "S-1-12-1"        },
 208     };
 209     const char noSubAuthStr[] = "S-1-5";
 210     unsigned int i;
 211     PSID psid = NULL;
 212     SID *pisid;
 213     BOOL r;
 214     LPSTR str = NULL;
 215
 216     if( !pConvertSidToStringSidA || !pConvertStringSidToSidA )
 217     {
 218         win_skip("ConvertSidToStringSidA or ConvertStringSidToSidA not available\n");
 219         return;
 220     }
 221
 222     r = pConvertStringSidToSidA( NULL, NULL );
 223     ok( !r, "expected failure with NULL parameters\n" );
 224     if( GetLastError() == ERROR_CALL_NOT_IMPLEMENTED )
 225         return;
 226     ok( GetLastError() == ERROR_INVALID_PARAMETER,
 227      "expected GetLastError() is ERROR_INVALID_PARAMETER, got %d\n",
 228      GetLastError() );
 229
 230     r = pConvertStringSidToSidA( refs[0].refStr, NULL );
 231     ok( !r && GetLastError() == ERROR_INVALID_PARAMETER,
 232      "expected GetLastError() is ERROR_INVALID_PARAMETER, got %d\n",
 233      GetLastError() );
 234
 235     r = pConvertStringSidToSidA( NULL, &str );
 236     ok( !r && GetLastError() == ERROR_INVALID_PARAMETER,
 237      "expected GetLastError() is ERROR_INVALID_PARAMETER, got %d\n",
 238      GetLastError() );
 239
 240     r = pConvertStringSidToSidA( noSubAuthStr, &psid );
 241     ok( !r,
 242      "expected failure with no sub authorities\n" );
 243     ok( GetLastError() == ERROR_INVALID_SID,
 244      "expected GetLastError() is ERROR_INVALID_SID, got %d\n",
 245      GetLastError() );
 246
 247     ok(pConvertStringSidToSidA("S-1-5-21-93476-23408-4576", &psid), "ConvertStringSidToSidA failed\n");
 248     pisid = psid;
 249     ok(pisid->SubAuthorityCount == 4, "Invalid sub authority count - expected 4, got %d\n", pisid->SubAuthorityCount);
 250     ok(pisid->SubAuthority[0] == 21, "Invalid subauthority 0 - expected 21, got %d\n", pisid->SubAuthority[0]);
 251     ok(pisid->SubAuthority[3] == 4576, "Invalid subauthority 0 - expected 4576, got %d\n", pisid->SubAuthority[3]);
 252     LocalFree(str);
 253     LocalFree(psid);
 254
 255     for( i = 0; i < sizeof(refs) / sizeof(refs[0]); i++ )
 256     {
 257         PISID pisid;
 258
 259         r = AllocateAndInitializeSid( &refs[i].auth, 1,1,0,0,0,0,0,0,0,
 260          &psid );
 261         ok( r, "failed to allocate sid\n" );
 262         r = pConvertSidToStringSidA( psid, &str );
 263         ok( r, "failed to convert sid\n" );
 264         if (r)
 265         {
 266             ok( !strcmp( str, refs[i].refStr ),
 267                 "incorrect sid, expected %s, got %s\n", refs[i].refStr, str );
 268             LocalFree( str );
 269         }
 270         if( psid )
 271             FreeSid( psid );
 272
 273         r = pConvertStringSidToSidA( refs[i].refStr, &psid );
 274         ok( r, "failed to parse sid string\n" );
 275         pisid = psid;
 276         ok( pisid &&
 277          !memcmp( pisid->IdentifierAuthority.Value, refs[i].auth.Value,
 278          sizeof(refs[i].auth) ),
 279          "string sid %s didn't parse to expected value\n"
 280          "(got 0x%04x%08x, expected 0x%04x%08x)\n",
 281          refs[i].refStr,
 282          MAKEWORD( pisid->IdentifierAuthority.Value[1],
 283          pisid->IdentifierAuthority.Value[0] ),
 284          MAKELONG( MAKEWORD( pisid->IdentifierAuthority.Value[5],
 285          pisid->IdentifierAuthority.Value[4] ),
 286          MAKEWORD( pisid->IdentifierAuthority.Value[3],
 287          pisid->IdentifierAuthority.Value[2] ) ),
 288          MAKEWORD( refs[i].auth.Value[1], refs[i].auth.Value[0] ),
 289          MAKELONG( MAKEWORD( refs[i].auth.Value[5], refs[i].auth.Value[4] ),
 290          MAKEWORD( refs[i].auth.Value[3], refs[i].auth.Value[2] ) ) );
 291         if( psid )
 292             LocalFree( psid );
 293     }
 294
 295     trace("String SIDs:\n");
 296     test_str_sid("AO");
 297     test_str_sid("RU");
 298     test_str_sid("AN");
 299     test_str_sid("AU");
 300     test_str_sid("BA");
 301     test_str_sid("BG");
 302     test_str_sid("BO");
 303     test_str_sid("BU");
 304     test_str_sid("CA");
 305     test_str_sid("CG");
 306     test_str_sid("CO");
 307     test_str_sid("DA");
 308     test_str_sid("DC");
 309     test_str_sid("DD");
 310     test_str_sid("DG");
 311     test_str_sid("DU");
 312     test_str_sid("EA");
 313     test_str_sid("ED");
 314     test_str_sid("WD");
 315     test_str_sid("PA");
 316     test_str_sid("IU");
 317     test_str_sid("LA");
 318     test_str_sid("LG");
 319     test_str_sid("LS");
 320     test_str_sid("SY");
 321     test_str_sid("NU");
 322     test_str_sid("NO");
 323     test_str_sid("NS");
 324     test_str_sid("PO");
 325     test_str_sid("PS");
 326     test_str_sid("PU");
 327     test_str_sid("RS");
 328     test_str_sid("RD");
 329     test_str_sid("RE");
 330     test_str_sid("RC");
 331     test_str_sid("SA");
 332     test_str_sid("SO");
 333     test_str_sid("SU");
 334 }
 335
 336 static void test_trustee(void)
 337 {
 338     GUID ObjectType = {0x12345678, 0x1234, 0x5678, {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}};
 339     GUID InheritedObjectType = {0x23456789, 0x2345, 0x6786, {0x2, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}};
 340     GUID ZeroGuid;
 341     OBJECTS_AND_NAME_ oan;
 342     OBJECTS_AND_SID oas;
 343     TRUSTEE trustee;
 344     PSID psid;
 345     char szObjectTypeName[] = "ObjectTypeName";
 346     char szInheritedObjectTypeName[] = "InheritedObjectTypeName";
 347     char szTrusteeName[] = "szTrusteeName";
 348     SID_IDENTIFIER_AUTHORITY auth = { {0x11,0x22,0,0,0, 0} };
 349
 350     memset( &ZeroGuid, 0x00, sizeof (ZeroGuid) );
 351
 352     pBuildTrusteeWithSidA = (void *)GetProcAddress( hmod, "BuildTrusteeWithSidA" );
 353     pBuildTrusteeWithNameA = (void *)GetProcAddress( hmod, "BuildTrusteeWithNameA" );
 354     pBuildTrusteeWithObjectsAndNameA = (void *)GetProcAddress (hmod, "BuildTrusteeWithObjectsAndNameA" );
 355     pBuildTrusteeWithObjectsAndSidA = (void *)GetProcAddress (hmod, "BuildTrusteeWithObjectsAndSidA" );
 356     pGetTrusteeNameA = (void *)GetProcAddress (hmod, "GetTrusteeNameA" );
 357     if( !pBuildTrusteeWithSidA || !pBuildTrusteeWithNameA ||
 358         !pBuildTrusteeWithObjectsAndNameA || !pBuildTrusteeWithObjectsAndSidA ||
 359         !pGetTrusteeNameA )
 360         return;
 361
 362     if ( ! AllocateAndInitializeSid( &auth, 1, 42, 0,0,0,0,0,0,0,&psid ) )
 363     {
 364         trace( "failed to init SID\n" );
 365        return;
 366     }
 367
 368     /* test BuildTrusteeWithSidA */
 369     memset( &trustee, 0xff, sizeof trustee );
 370     pBuildTrusteeWithSidA( &trustee, psid );
 371
 372     ok( trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 373     ok( trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE,
 374         "MultipleTrusteeOperation wrong\n");
 375     ok( trustee.TrusteeForm == TRUSTEE_IS_SID, "TrusteeForm wrong\n");
 376     ok( trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 377     ok( trustee.ptstrName == psid, "ptstrName wrong\n" );
 378
 379     /* test BuildTrusteeWithObjectsAndSidA (test 1) */
 380     memset( &trustee, 0xff, sizeof trustee );
 381     memset( &oas, 0xff, sizeof(oas) );
 382     pBuildTrusteeWithObjectsAndSidA(&trustee, &oas, &ObjectType,
 383                                     &InheritedObjectType, psid);
 384
 385     ok(trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 386     ok(trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE, "MultipleTrusteeOperation wrong\n");
 387     ok(trustee.TrusteeForm == TRUSTEE_IS_OBJECTS_AND_SID, "TrusteeForm wrong\n");
 388     ok(trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 389     ok(trustee.ptstrName == (LPSTR)&oas, "ptstrName wrong\n");
 390
 391     ok(oas.ObjectsPresent == (ACE_OBJECT_TYPE_PRESENT | ACE_INHERITED_OBJECT_TYPE_PRESENT), "ObjectsPresent wrong\n");
 392     ok(!memcmp(&oas.ObjectTypeGuid, &ObjectType, sizeof(GUID)), "ObjectTypeGuid wrong\n");
 393     ok(!memcmp(&oas.InheritedObjectTypeGuid, &InheritedObjectType, sizeof(GUID)), "InheritedObjectTypeGuid wrong\n");
 394     ok(oas.pSid == psid, "pSid wrong\n");
 395
 396     /* test GetTrusteeNameA */
 397     ok(pGetTrusteeNameA(&trustee) == (LPSTR)&oas, "GetTrusteeName returned wrong value\n");
 398
 399     /* test BuildTrusteeWithObjectsAndSidA (test 2) */
 400     memset( &trustee, 0xff, sizeof trustee );
 401     memset( &oas, 0xff, sizeof(oas) );
 402     pBuildTrusteeWithObjectsAndSidA(&trustee, &oas, NULL,
 403                                     &InheritedObjectType, psid);
 404
 405     ok(trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 406     ok(trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE, "MultipleTrusteeOperation wrong\n");
 407     ok(trustee.TrusteeForm == TRUSTEE_IS_OBJECTS_AND_SID, "TrusteeForm wrong\n");
 408     ok(trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 409     ok(trustee.ptstrName == (LPSTR)&oas, "ptstrName wrong\n");
 410
 411     ok(oas.ObjectsPresent == ACE_INHERITED_OBJECT_TYPE_PRESENT, "ObjectsPresent wrong\n");
 412     ok(!memcmp(&oas.ObjectTypeGuid, &ZeroGuid, sizeof(GUID)), "ObjectTypeGuid wrong\n");
 413     ok(!memcmp(&oas.InheritedObjectTypeGuid, &InheritedObjectType, sizeof(GUID)), "InheritedObjectTypeGuid wrong\n");
 414     ok(oas.pSid == psid, "pSid wrong\n");
 415
 416     FreeSid( psid );
 417
 418     /* test BuildTrusteeWithNameA */
 419     memset( &trustee, 0xff, sizeof trustee );
 420     pBuildTrusteeWithNameA( &trustee, szTrusteeName );
 421
 422     ok( trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 423     ok( trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE,
 424         "MultipleTrusteeOperation wrong\n");
 425     ok( trustee.TrusteeForm == TRUSTEE_IS_NAME, "TrusteeForm wrong\n");
 426     ok( trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 427     ok( trustee.ptstrName == szTrusteeName, "ptstrName wrong\n" );
 428
 429     /* test BuildTrusteeWithObjectsAndNameA (test 1) */
 430     memset( &trustee, 0xff, sizeof trustee );
 431     memset( &oan, 0xff, sizeof(oan) );
 432     pBuildTrusteeWithObjectsAndNameA(&trustee, &oan, SE_KERNEL_OBJECT, szObjectTypeName,
 433                                      szInheritedObjectTypeName, szTrusteeName);
 434
 435     ok(trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 436     ok(trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE, "MultipleTrusteeOperation wrong\n");
 437     ok(trustee.TrusteeForm == TRUSTEE_IS_OBJECTS_AND_NAME, "TrusteeForm wrong\n");
 438     ok(trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 439     ok(trustee.ptstrName == (LPTSTR)&oan, "ptstrName wrong\n");
 440
 441     ok(oan.ObjectsPresent == (ACE_OBJECT_TYPE_PRESENT | ACE_INHERITED_OBJECT_TYPE_PRESENT), "ObjectsPresent wrong\n");
 442     ok(oan.ObjectType == SE_KERNEL_OBJECT, "ObjectType wrong\n");
 443     ok(oan.InheritedObjectTypeName == szInheritedObjectTypeName, "InheritedObjectTypeName wrong\n");
 444     ok(oan.ptstrName == szTrusteeName, "szTrusteeName wrong\n");
 445
 446     /* test GetTrusteeNameA */
 447     ok(pGetTrusteeNameA(&trustee) == (LPSTR)&oan, "GetTrusteeName returned wrong value\n");
 448
 449     /* test BuildTrusteeWithObjectsAndNameA (test 2) */
 450     memset( &trustee, 0xff, sizeof trustee );
 451     memset( &oan, 0xff, sizeof(oan) );
 452     pBuildTrusteeWithObjectsAndNameA(&trustee, &oan, SE_KERNEL_OBJECT, NULL,
 453                                      szInheritedObjectTypeName, szTrusteeName);
 454
 455     ok(trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 456     ok(trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE, "MultipleTrusteeOperation wrong\n");
 457     ok(trustee.TrusteeForm == TRUSTEE_IS_OBJECTS_AND_NAME, "TrusteeForm wrong\n");
 458     ok(trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 459     ok(trustee.ptstrName == (LPSTR)&oan, "ptstrName wrong\n");
 460
 461     ok(oan.ObjectsPresent == ACE_INHERITED_OBJECT_TYPE_PRESENT, "ObjectsPresent wrong\n");
 462     ok(oan.ObjectType == SE_KERNEL_OBJECT, "ObjectType wrong\n");
 463     ok(oan.InheritedObjectTypeName == szInheritedObjectTypeName, "InheritedObjectTypeName wrong\n");
 464     ok(oan.ptstrName == szTrusteeName, "szTrusteeName wrong\n");
 465
 466     /* test BuildTrusteeWithObjectsAndNameA (test 3) */
 467     memset( &trustee, 0xff, sizeof trustee );
 468     memset( &oan, 0xff, sizeof(oan) );
 469     pBuildTrusteeWithObjectsAndNameA(&trustee, &oan, SE_KERNEL_OBJECT, szObjectTypeName,
 470                                      NULL, szTrusteeName);
 471
 472     ok(trustee.pMultipleTrustee == NULL, "pMultipleTrustee wrong\n");
 473     ok(trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE, "MultipleTrusteeOperation wrong\n");
 474     ok(trustee.TrusteeForm == TRUSTEE_IS_OBJECTS_AND_NAME, "TrusteeForm wrong\n");
 475     ok(trustee.TrusteeType == TRUSTEE_IS_UNKNOWN, "TrusteeType wrong\n");
 476     ok(trustee.ptstrName == (LPTSTR)&oan, "ptstrName wrong\n");
 477
 478     ok(oan.ObjectsPresent == ACE_OBJECT_TYPE_PRESENT, "ObjectsPresent wrong\n");
 479     ok(oan.ObjectType == SE_KERNEL_OBJECT, "ObjectType wrong\n");
 480     ok(oan.InheritedObjectTypeName == NULL, "InheritedObjectTypeName wrong\n");
 481     ok(oan.ptstrName == szTrusteeName, "szTrusteeName wrong\n");
 482 }
 483
 484 /* If the first isn't defined, assume none is */
 485 #ifndef SE_MIN_WELL_KNOWN_PRIVILEGE
 486 #define SE_MIN_WELL_KNOWN_PRIVILEGE       2L
 487 #define SE_CREATE_TOKEN_PRIVILEGE         2L
 488 #define SE_ASSIGNPRIMARYTOKEN_PRIVILEGE   3L
 489 #define SE_LOCK_MEMORY_PRIVILEGE          4L
 490 #define SE_INCREASE_QUOTA_PRIVILEGE       5L
 491 #define SE_MACHINE_ACCOUNT_PRIVILEGE      6L
 492 #define SE_TCB_PRIVILEGE                  7L
 493 #define SE_SECURITY_PRIVILEGE             8L
 494 #define SE_TAKE_OWNERSHIP_PRIVILEGE       9L
 495 #define SE_LOAD_DRIVER_PRIVILEGE         10L
 496 #define SE_SYSTEM_PROFILE_PRIVILEGE      11L
 497 #define SE_SYSTEMTIME_PRIVILEGE          12L
 498 #define SE_PROF_SINGLE_PROCESS_PRIVILEGE 13L
 499 #define SE_INC_BASE_PRIORITY_PRIVILEGE   14L
 500 #define SE_CREATE_PAGEFILE_PRIVILEGE     15L
 501 #define SE_CREATE_PERMANENT_PRIVILEGE    16L
 502 #define SE_BACKUP_PRIVILEGE              17L
 503 #define SE_RESTORE_PRIVILEGE             18L
 504 #define SE_SHUTDOWN_PRIVILEGE            19L
 505 #define SE_DEBUG_PRIVILEGE               20L
 506 #define SE_AUDIT_PRIVILEGE               21L
 507 #define SE_SYSTEM_ENVIRONMENT_PRIVILEGE  22L
 508 #define SE_CHANGE_NOTIFY_PRIVILEGE       23L
 509 #define SE_REMOTE_SHUTDOWN_PRIVILEGE     24L
 510 #define SE_UNDOCK_PRIVILEGE              25L
 511 #define SE_SYNC_AGENT_PRIVILEGE          26L
 512 #define SE_ENABLE_DELEGATION_PRIVILEGE   27L
 513 #define SE_MANAGE_VOLUME_PRIVILEGE       28L
 514 #define SE_IMPERSONATE_PRIVILEGE         29L
 515 #define SE_CREATE_GLOBAL_PRIVILEGE       30L
 516 #define SE_MAX_WELL_KNOWN_PRIVILEGE      SE_CREATE_GLOBAL_PRIVILEGE
 517 #endif /* ndef SE_MIN_WELL_KNOWN_PRIVILEGE */
 518
 519 static void test_allocateLuid(void)
 520 {
 521     BOOL (WINAPI *pAllocateLocallyUniqueId)(PLUID);
 522     LUID luid1, luid2;
 523     BOOL ret;
 524
 525     pAllocateLocallyUniqueId = (void*)GetProcAddress(hmod, "AllocateLocallyUniqueId");
 526     if (!pAllocateLocallyUniqueId) return;
 527
 528     ret = pAllocateLocallyUniqueId(&luid1);
 529     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 530         return;
 531
 532     ok(ret,
 533      "AllocateLocallyUniqueId failed: %d\n", GetLastError());
 534     ret = pAllocateLocallyUniqueId(&luid2);
 535     ok( ret,
 536      "AllocateLocallyUniqueId failed: %d\n", GetLastError());
 537     ok(luid1.LowPart > SE_MAX_WELL_KNOWN_PRIVILEGE || luid1.HighPart != 0,
 538      "AllocateLocallyUniqueId returned a well-known LUID\n");
 539     ok(luid1.LowPart != luid2.LowPart || luid1.HighPart != luid2.HighPart,
 540      "AllocateLocallyUniqueId returned non-unique LUIDs\n");
 541     ret = pAllocateLocallyUniqueId(NULL);
 542     ok( !ret && GetLastError() == ERROR_NOACCESS,
 543      "AllocateLocallyUniqueId(NULL) didn't return ERROR_NOACCESS: %d\n",
 544      GetLastError());
 545 }
 546
 547 static void test_lookupPrivilegeName(void)
 548 {
 549     BOOL (WINAPI *pLookupPrivilegeNameA)(LPCSTR, PLUID, LPSTR, LPDWORD);
 550     char buf[MAX_PATH]; /* arbitrary, seems long enough */
 551     DWORD cchName = sizeof(buf);
 552     LUID luid = { 0, 0 };
 553     LONG i;
 554     BOOL ret;
 555
 556     /* check whether it's available first */
 557     pLookupPrivilegeNameA = (void*)GetProcAddress(hmod, "LookupPrivilegeNameA");
 558     if (!pLookupPrivilegeNameA) return;
 559     luid.LowPart = SE_CREATE_TOKEN_PRIVILEGE;
 560     ret = pLookupPrivilegeNameA(NULL, &luid, buf, &cchName);
 561     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 562         return;
 563
 564     /* check with a short buffer */
 565     cchName = 0;
 566     luid.LowPart = SE_CREATE_TOKEN_PRIVILEGE;
 567     ret = pLookupPrivilegeNameA(NULL, &luid, NULL, &cchName);
 568     ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 569      "LookupPrivilegeNameA didn't fail with ERROR_INSUFFICIENT_BUFFER: %d\n",
 570      GetLastError());
 571     ok(cchName == strlen("SeCreateTokenPrivilege") + 1,
 572      "LookupPrivilegeNameA returned an incorrect required length for\n"
 573      "SeCreateTokenPrivilege (got %d, expected %d)\n", cchName,
 574      lstrlenA("SeCreateTokenPrivilege") + 1);
 575     /* check a known value and its returned length on success */
 576     cchName = sizeof(buf);
 577     ok(pLookupPrivilegeNameA(NULL, &luid, buf, &cchName) &&
 578      cchName == strlen("SeCreateTokenPrivilege"),
 579      "LookupPrivilegeNameA returned an incorrect output length for\n"
 580      "SeCreateTokenPrivilege (got %d, expected %d)\n", cchName,
 581      (int)strlen("SeCreateTokenPrivilege"));
 582     /* check known values */
 583     for (i = SE_MIN_WELL_KNOWN_PRIVILEGE; i <= SE_MAX_WELL_KNOWN_PRIVILEGE; i++)
 584     {
 585         luid.LowPart = i;
 586         cchName = sizeof(buf);
 587         ret = pLookupPrivilegeNameA(NULL, &luid, buf, &cchName);
 588         ok( ret || GetLastError() == ERROR_NO_SUCH_PRIVILEGE,
 589          "LookupPrivilegeNameA(0.%d) failed: %d\n", i, GetLastError());
 590     }
 591     /* check a bogus LUID */
 592     luid.LowPart = 0xdeadbeef;
 593     cchName = sizeof(buf);
 594     ret = pLookupPrivilegeNameA(NULL, &luid, buf, &cchName);
 595     ok( !ret && GetLastError() == ERROR_NO_SUCH_PRIVILEGE,
 596      "LookupPrivilegeNameA didn't fail with ERROR_NO_SUCH_PRIVILEGE: %d\n",
 597      GetLastError());
 598     /* check on a bogus system */
 599     luid.LowPart = SE_CREATE_TOKEN_PRIVILEGE;
 600     cchName = sizeof(buf);
 601     ret = pLookupPrivilegeNameA("b0gu5.Nam3", &luid, buf, &cchName);
 602     ok( !ret && (GetLastError() == RPC_S_SERVER_UNAVAILABLE ||
 603                  GetLastError() == RPC_S_INVALID_NET_ADDR) /* w2k8 */,
 604      "LookupPrivilegeNameA didn't fail with RPC_S_SERVER_UNAVAILABLE or RPC_S_INVALID_NET_ADDR: %d\n",
 605      GetLastError());
 606 }
 607
 608 struct NameToLUID
 609 {
 610     const char *name;
 611     DWORD lowPart;
 612 };
 613
 614 static void test_lookupPrivilegeValue(void)
 615 {
 616     static const struct NameToLUID privs[] = {
 617      { "SeCreateTokenPrivilege", SE_CREATE_TOKEN_PRIVILEGE },
 618      { "SeAssignPrimaryTokenPrivilege", SE_ASSIGNPRIMARYTOKEN_PRIVILEGE },
 619      { "SeLockMemoryPrivilege", SE_LOCK_MEMORY_PRIVILEGE },
 620      { "SeIncreaseQuotaPrivilege", SE_INCREASE_QUOTA_PRIVILEGE },
 621      { "SeMachineAccountPrivilege", SE_MACHINE_ACCOUNT_PRIVILEGE },
 622      { "SeTcbPrivilege", SE_TCB_PRIVILEGE },
 623      { "SeSecurityPrivilege", SE_SECURITY_PRIVILEGE },
 624      { "SeTakeOwnershipPrivilege", SE_TAKE_OWNERSHIP_PRIVILEGE },
 625      { "SeLoadDriverPrivilege", SE_LOAD_DRIVER_PRIVILEGE },
 626      { "SeSystemProfilePrivilege", SE_SYSTEM_PROFILE_PRIVILEGE },
 627      { "SeSystemtimePrivilege", SE_SYSTEMTIME_PRIVILEGE },
 628      { "SeProfileSingleProcessPrivilege", SE_PROF_SINGLE_PROCESS_PRIVILEGE },
 629      { "SeIncreaseBasePriorityPrivilege", SE_INC_BASE_PRIORITY_PRIVILEGE },
 630      { "SeCreatePagefilePrivilege", SE_CREATE_PAGEFILE_PRIVILEGE },
 631      { "SeCreatePermanentPrivilege", SE_CREATE_PERMANENT_PRIVILEGE },
 632      { "SeBackupPrivilege", SE_BACKUP_PRIVILEGE },
 633      { "SeRestorePrivilege", SE_RESTORE_PRIVILEGE },
 634      { "SeShutdownPrivilege", SE_SHUTDOWN_PRIVILEGE },
 635      { "SeDebugPrivilege", SE_DEBUG_PRIVILEGE },
 636      { "SeAuditPrivilege", SE_AUDIT_PRIVILEGE },
 637      { "SeSystemEnvironmentPrivilege", SE_SYSTEM_ENVIRONMENT_PRIVILEGE },
 638      { "SeChangeNotifyPrivilege", SE_CHANGE_NOTIFY_PRIVILEGE },
 639      { "SeRemoteShutdownPrivilege", SE_REMOTE_SHUTDOWN_PRIVILEGE },
 640      { "SeUndockPrivilege", SE_UNDOCK_PRIVILEGE },
 641      { "SeSyncAgentPrivilege", SE_SYNC_AGENT_PRIVILEGE },
 642      { "SeEnableDelegationPrivilege", SE_ENABLE_DELEGATION_PRIVILEGE },
 643      { "SeManageVolumePrivilege", SE_MANAGE_VOLUME_PRIVILEGE },
 644      { "SeImpersonatePrivilege", SE_IMPERSONATE_PRIVILEGE },
 645      { "SeCreateGlobalPrivilege", SE_CREATE_GLOBAL_PRIVILEGE },
 646     };
 647     BOOL (WINAPI *pLookupPrivilegeValueA)(LPCSTR, LPCSTR, PLUID);
 648     unsigned int i;
 649     LUID luid;
 650     BOOL ret;
 651
 652     /* check whether it's available first */
 653     pLookupPrivilegeValueA = (void*)GetProcAddress(hmod, "LookupPrivilegeValueA");
 654     if (!pLookupPrivilegeValueA) return;
 655     ret = pLookupPrivilegeValueA(NULL, "SeCreateTokenPrivilege", &luid);
 656     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 657         return;
 658
 659     /* check a bogus system name */
 660     ret = pLookupPrivilegeValueA("b0gu5.Nam3", "SeCreateTokenPrivilege", &luid);
 661     ok( !ret && (GetLastError() == RPC_S_SERVER_UNAVAILABLE ||
 662                 GetLastError() == RPC_S_INVALID_NET_ADDR) /* w2k8 */,
 663      "LookupPrivilegeValueA didn't fail with RPC_S_SERVER_UNAVAILABLE or RPC_S_INVALID_NET_ADDR: %d\n",
 664      GetLastError());
 665     /* check a NULL string */
 666     ret = pLookupPrivilegeValueA(NULL, 0, &luid);
 667     ok( !ret && GetLastError() == ERROR_NO_SUCH_PRIVILEGE,
 668      "LookupPrivilegeValueA didn't fail with ERROR_NO_SUCH_PRIVILEGE: %d\n",
 669      GetLastError());
 670     /* check a bogus privilege name */
 671     ret = pLookupPrivilegeValueA(NULL, "SeBogusPrivilege", &luid);
 672     ok( !ret && GetLastError() == ERROR_NO_SUCH_PRIVILEGE,
 673      "LookupPrivilegeValueA didn't fail with ERROR_NO_SUCH_PRIVILEGE: %d\n",
 674      GetLastError());
 675     /* check case insensitive */
 676     ret = pLookupPrivilegeValueA(NULL, "sEcREATEtOKENpRIVILEGE", &luid);
 677     ok( ret,
 678      "LookupPrivilegeValueA(NULL, sEcREATEtOKENpRIVILEGE, &luid) failed: %d\n",
 679      GetLastError());
 680     for (i = 0; i < sizeof(privs) / sizeof(privs[0]); i++)
 681     {
 682         /* Not all privileges are implemented on all Windows versions, so
 683          * don't worry if the call fails
 684          */
 685         if (pLookupPrivilegeValueA(NULL, privs[i].name, &luid))
 686         {
 687             ok(luid.LowPart == privs[i].lowPart,
 688              "LookupPrivilegeValueA returned an invalid LUID for %s\n",
 689              privs[i].name);
 690         }
 691     }
 692 }
 693
 694 static void test_luid(void)
 695 {
 696     test_allocateLuid();
 697     test_lookupPrivilegeName();
 698     test_lookupPrivilegeValue();
 699 }
 700
 701 static void test_FileSecurity(void)
 702 {
 703     char wintmpdir [MAX_PATH];
 704     char path [MAX_PATH];
 705     char file [MAX_PATH];
 706     HANDLE fh, token;
 707     DWORD sdSize, retSize, rc, granted, priv_set_len;
 708     PRIVILEGE_SET priv_set;
 709     BOOL status;
 710     BYTE *sd;
 711     GENERIC_MAPPING mapping = { FILE_READ_DATA, FILE_WRITE_DATA, FILE_EXECUTE, FILE_ALL_ACCESS };
 712     const SECURITY_INFORMATION request = OWNER_SECURITY_INFORMATION
 713                                        | GROUP_SECURITY_INFORMATION
 714                                        | DACL_SECURITY_INFORMATION;
 715
 716     if (!pGetFileSecurityA) {
 717         win_skip ("GetFileSecurity is not available\n");
 718         return;
 719     }
 720
 721     if (!pSetFileSecurityA) {
 722         win_skip ("SetFileSecurity is not available\n");
 723         return;
 724     }
 725
 726     if (!GetTempPathA (sizeof (wintmpdir), wintmpdir)) {
 727         win_skip ("GetTempPathA failed\n");
 728         return;
 729     }
 730
 731     /* Create a temporary directory and in it a temporary file */
 732     strcat (strcpy (path, wintmpdir), "rary");
 733     SetLastError(0xdeadbeef);
 734     rc = CreateDirectoryA (path, NULL);
 735     ok (rc || GetLastError() == ERROR_ALREADY_EXISTS, "CreateDirectoryA "
 736         "failed for '%s' with %d\n", path, GetLastError());
 737
 738     strcat (strcpy (file, path), "\\ess");
 739     SetLastError(0xdeadbeef);
 740     fh = CreateFileA (file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 741     ok (fh != INVALID_HANDLE_VALUE, "CreateFileA "
 742         "failed for '%s' with %d\n", file, GetLastError());
 743     CloseHandle (fh);
 744
 745     /* For the temporary file ... */
 746
 747     /* Get size needed */
 748     retSize = 0;
 749     SetLastError(0xdeadbeef);
 750     rc = pGetFileSecurityA (file, request, NULL, 0, &retSize);
 751     if (!rc && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) {
 752         win_skip("GetFileSecurityA is not implemented\n");
 753         goto cleanup;
 754     }
 755     ok (!rc, "GetFileSecurityA "
 756         "was expected to fail for '%s'\n", file);
 757     ok (GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetFileSecurityA "
 758         "returned %d; expected ERROR_INSUFFICIENT_BUFFER\n", GetLastError());
 759     ok (retSize > sizeof (SECURITY_DESCRIPTOR), "GetFileSecurityA returned size %d\n", retSize);
 760
 761     sdSize = retSize;
 762     sd = HeapAlloc (GetProcessHeap (), 0, sdSize);
 763
 764     /* Get security descriptor for real */
 765     retSize = -1;
 766     SetLastError(0xdeadbeef);
 767     rc = pGetFileSecurityA (file, request, sd, sdSize, &retSize);
 768     ok (rc, "GetFileSecurityA "
 769         "was not expected to fail '%s': %d\n", file, GetLastError());
 770     ok (retSize == sdSize ||
 771         broken(retSize == 0), /* NT4 */
 772         "GetFileSecurityA returned size %d; expected %d\n", retSize, sdSize);
 773
 774     /* Use it to set security descriptor */
 775     SetLastError(0xdeadbeef);
 776     rc = pSetFileSecurityA (file, request, sd);
 777     ok (rc, "SetFileSecurityA "
 778         "was not expected to fail '%s': %d\n", file, GetLastError());
 779
 780     HeapFree (GetProcessHeap (), 0, sd);
 781
 782     /* Repeat for the temporary directory ... */
 783
 784     /* Get size needed */
 785     retSize = 0;
 786     SetLastError(0xdeadbeef);
 787     rc = pGetFileSecurityA (path, request, NULL, 0, &retSize);
 788     ok (!rc, "GetFileSecurityA "
 789         "was expected to fail for '%s'\n", path);
 790     ok (GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetFileSecurityA "
 791         "returned %d; expected ERROR_INSUFFICIENT_BUFFER\n", GetLastError());
 792     ok (retSize > sizeof (SECURITY_DESCRIPTOR), "GetFileSecurityA returned size %d\n", retSize);
 793
 794     sdSize = retSize;
 795     sd = HeapAlloc (GetProcessHeap (), 0, sdSize);
 796
 797     /* Get security descriptor for real */
 798     retSize = -1;
 799     SetLastError(0xdeadbeef);
 800     rc = pGetFileSecurityA (path, request, sd, sdSize, &retSize);
 801     ok (rc, "GetFileSecurityA "
 802         "was not expected to fail '%s': %d\n", path, GetLastError());
 803     ok (retSize == sdSize ||
 804         broken(retSize == 0), /* NT4 */
 805         "GetFileSecurityA returned size %d; expected %d\n", retSize, sdSize);
 806
 807     /* Use it to set security descriptor */
 808     SetLastError(0xdeadbeef);
 809     rc = pSetFileSecurityA (path, request, sd);
 810     ok (rc, "SetFileSecurityA "
 811         "was not expected to fail '%s': %d\n", path, GetLastError());
 812     HeapFree (GetProcessHeap (), 0, sd);
 813
 814     /* Old test */
 815     strcpy (wintmpdir, "\\Should not exist");
 816     SetLastError(0xdeadbeef);
 817     rc = pGetFileSecurityA (wintmpdir, OWNER_SECURITY_INFORMATION, NULL, 0, &sdSize);
 818     ok (!rc, "GetFileSecurityA should fail for not existing directories/files\n");
 819     ok (GetLastError() == ERROR_FILE_NOT_FOUND,
 820         "last error ERROR_FILE_NOT_FOUND expected, got %d\n", GetLastError());
 821
 822 cleanup:
 823     /* Remove temporary file and directory */
 824     DeleteFileA(file);
 825     RemoveDirectoryA(path);
 826
 827     /* Test file access permissions for a file with FILE_ATTRIBUTE_ARCHIVE */
 828     SetLastError(0xdeadbeef);
 829     rc = GetTempPath(sizeof(wintmpdir), wintmpdir);
 830     ok(rc, "GetTempPath error %d\n", GetLastError());
 831
 832     SetLastError(0xdeadbeef);
 833     rc = GetTempFileName(wintmpdir, "tmp", 0, file);
 834     ok(rc, "GetTempFileName error %d\n", GetLastError());
 835
 836     rc = GetFileAttributes(file);
 837     rc &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
 838     ok(rc == FILE_ATTRIBUTE_ARCHIVE, "expected FILE_ATTRIBUTE_ARCHIVE got %#x\n", rc);
 839
 840     retSize = 0xdeadbeef;
 841     rc = GetFileSecurity(file, OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION,
 842                          NULL, 0, &sdSize);
 843     ok(!rc, "GetFileSecurity should fail\n");
 844     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 845        "expected ERROR_INSUFFICIENT_BUFFER got %d\n", GetLastError());
 846     ok(sdSize > sizeof(SECURITY_DESCRIPTOR), "got sd size %d\n", sdSize);
 847
 848     sd = HeapAlloc(GetProcessHeap (), 0, sdSize);
 849     retSize = 0xdeadbeef;
 850     SetLastError(0xdeadbeef);
 851     rc = GetFileSecurity(file, OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION,
 852                          sd, sdSize, &retSize);
 853     ok(rc, "GetFileSecurity error %d\n", GetLastError());
 854     ok(retSize == sdSize || broken(retSize == 0) /* NT4 */, "expected %d, got %d\n", sdSize, retSize);
 855
 856     SetLastError(0xdeadbeef);
 857     rc = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &token);
 858     ok(!rc, "OpenThreadToken should fail\n");
 859     ok(GetLastError() == ERROR_NO_TOKEN, "expected ERROR_NO_TOKEN, got %d\n", GetLastError());
 860
 861     SetLastError(0xdeadbeef);
 862     rc = ImpersonateSelf(SecurityIdentification);
 863     ok(rc, "ImpersonateSelf error %d\n", GetLastError());
 864
 865     SetLastError(0xdeadbeef);
 866     rc = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &token);
 867     ok(rc, "OpenThreadToken error %d\n", GetLastError());
 868
 869     SetLastError(0xdeadbeef);
 870     rc = RevertToSelf();
 871     ok(rc, "RevertToSelf error %d\n", GetLastError());
 872
 873     priv_set_len = sizeof(priv_set);
 874     granted = 0xdeadbeef;
 875     status = 0xdeadbeef;
 876     SetLastError(0xdeadbeef);
 877     rc = AccessCheck(sd, token, FILE_READ_DATA, &mapping, &priv_set, &priv_set_len, &granted, &status);
 878     ok(rc, "AccessCheck error %d\n", GetLastError());
 879     ok(status == 1, "expected 1, got %d\n", status);
 880     ok(granted == FILE_READ_DATA, "expected FILE_READ_DATA, got %#x\n", granted);
 881
 882     granted = 0xdeadbeef;
 883     status = 0xdeadbeef;
 884     SetLastError(0xdeadbeef);
 885     rc = AccessCheck(sd, token, FILE_WRITE_DATA, &mapping, &priv_set, &priv_set_len, &granted, &status);
 886     ok(rc, "AccessCheck error %d\n", GetLastError());
 887     ok(status == 1, "expected 1, got %d\n", status);
 888     ok(granted == FILE_WRITE_DATA, "expected FILE_WRITE_DATA, got %#x\n", granted);
 889
 890     granted = 0xdeadbeef;
 891     status = 0xdeadbeef;
 892     SetLastError(0xdeadbeef);
 893     rc = AccessCheck(sd, token, FILE_EXECUTE, &mapping, &priv_set, &priv_set_len, &granted, &status);
 894     ok(rc, "AccessCheck error %d\n", GetLastError());
 895     ok(status == 1, "expected 1, got %d\n", status);
 896     ok(granted == FILE_EXECUTE, "expected FILE_EXECUTE, got %#x\n", granted);
 897
 898     granted = 0xdeadbeef;
 899     status = 0xdeadbeef;
 900     SetLastError(0xdeadbeef);
 901     rc = AccessCheck(sd, token, DELETE, &mapping, &priv_set, &priv_set_len, &granted, &status);
 902     ok(rc, "AccessCheck error %d\n", GetLastError());
 903     ok(status == 1, "expected 1, got %d\n", status);
 904     ok(granted == DELETE, "expected DELETE, got %#x\n", granted);
 905
 906     granted = 0xdeadbeef;
 907     status = 0xdeadbeef;
 908     SetLastError(0xdeadbeef);
 909     rc = AccessCheck(sd, token, FILE_DELETE_CHILD, &mapping, &priv_set, &priv_set_len, &granted, &status);
 910     ok(rc, "AccessCheck error %d\n", GetLastError());
 911     ok(status == 1, "expected 1, got %d\n", status);
 912     ok(granted == FILE_DELETE_CHILD, "expected FILE_DELETE_CHILD, got %#x\n", granted);
 913
 914     granted = 0xdeadbeef;
 915     status = 0xdeadbeef;
 916     SetLastError(0xdeadbeef);
 917     rc = AccessCheck(sd, token, 0x1ff, &mapping, &priv_set, &priv_set_len, &granted, &status);
 918     ok(rc, "AccessCheck error %d\n", GetLastError());
 919     ok(status == 1, "expected 1, got %d\n", status);
 920     ok(granted == 0x1ff, "expected 0x1ff, got %#x\n", granted);
 921
 922     granted = 0xdeadbeef;
 923     status = 0xdeadbeef;
 924     SetLastError(0xdeadbeef);
 925     rc = AccessCheck(sd, token, FILE_ALL_ACCESS, &mapping, &priv_set, &priv_set_len, &granted, &status);
 926     ok(rc, "AccessCheck error %d\n", GetLastError());
 927     ok(status == 1, "expected 1, got %d\n", status);
 928     ok(granted == FILE_ALL_ACCESS, "expected FILE_ALL_ACCESS, got %#x\n", granted);
 929
 930     SetLastError(0xdeadbeef);
 931     rc = AccessCheck(sd, token, 0xffffffff, &mapping, &priv_set, &priv_set_len, &granted, &status);
 932     ok(!rc, "AccessCheck should fail\n");
 933     ok(GetLastError() == ERROR_GENERIC_NOT_MAPPED, "expected ERROR_GENERIC_NOT_MAPPED, got %d\n", GetLastError());
 934
 935     /* Test file access permissions for a file with FILE_ATTRIBUTE_READONLY */
 936     SetLastError(0xdeadbeef);
 937     fh = CreateFile(file, FILE_READ_DATA, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_READONLY, 0);
 938     ok(fh != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
 939     retSize = 0xdeadbeef;
 940     SetLastError(0xdeadbeef);
 941     rc = WriteFile(fh, "1", 1, &retSize, NULL);
 942     ok(!rc, "WriteFile should fail\n");
 943     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 944     ok(retSize == 0, "expected 0, got %d\n", retSize);
 945     CloseHandle(fh);
 946
 947     rc = GetFileAttributes(file);
 948     rc &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
 949 todo_wine
 950     ok(rc == (FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY),
 951        "expected FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY got %#x\n", rc);
 952
 953     SetLastError(0xdeadbeef);
 954     rc = SetFileAttributes(file, FILE_ATTRIBUTE_ARCHIVE);
 955     ok(rc, "SetFileAttributes error %d\n", GetLastError());
 956     SetLastError(0xdeadbeef);
 957     rc = DeleteFile(file);
 958     ok(rc, "DeleteFile error %d\n", GetLastError());
 959
 960     SetLastError(0xdeadbeef);
 961     fh = CreateFile(file, FILE_READ_DATA, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_READONLY, 0);
 962     ok(fh != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
 963     retSize = 0xdeadbeef;
 964     SetLastError(0xdeadbeef);
 965     rc = WriteFile(fh, "1", 1, &retSize, NULL);
 966     ok(!rc, "WriteFile should fail\n");
 967     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 968     ok(retSize == 0, "expected 0, got %d\n", retSize);
 969     CloseHandle(fh);
 970
 971     rc = GetFileAttributes(file);
 972     rc &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
 973     ok(rc == (FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY),
 974        "expected FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY got %#x\n", rc);
 975
 976     retSize = 0xdeadbeef;
 977     SetLastError(0xdeadbeef);
 978     rc = GetFileSecurity(file, OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION,
 979                          sd, sdSize, &retSize);
 980     ok(rc, "GetFileSecurity error %d\n", GetLastError());
 981     ok(retSize == sdSize || broken(retSize == 0) /* NT4 */, "expected %d, got %d\n", sdSize, retSize);
 982
 983     priv_set_len = sizeof(priv_set);
 984     granted = 0xdeadbeef;
 985     status = 0xdeadbeef;
 986     SetLastError(0xdeadbeef);
 987     rc = AccessCheck(sd, token, FILE_READ_DATA, &mapping, &priv_set, &priv_set_len, &granted, &status);
 988     ok(rc, "AccessCheck error %d\n", GetLastError());
 989     ok(status == 1, "expected 1, got %d\n", status);
 990     ok(granted == FILE_READ_DATA, "expected FILE_READ_DATA, got %#x\n", granted);
 991
 992     granted = 0xdeadbeef;
 993     status = 0xdeadbeef;
 994     SetLastError(0xdeadbeef);
 995     rc = AccessCheck(sd, token, FILE_WRITE_DATA, &mapping, &priv_set, &priv_set_len, &granted, &status);
 996     ok(rc, "AccessCheck error %d\n", GetLastError());
 997 todo_wine {
 998     ok(status == 1, "expected 1, got %d\n", status);
 999     ok(granted == FILE_WRITE_DATA, "expected FILE_WRITE_DATA, got %#x\n", granted);
1000 }
1001     granted = 0xdeadbeef;
1002     status = 0xdeadbeef;
1003     SetLastError(0xdeadbeef);
1004     rc = AccessCheck(sd, token, FILE_EXECUTE, &mapping, &priv_set, &priv_set_len, &granted, &status);
1005     ok(rc, "AccessCheck error %d\n", GetLastError());
1006     ok(status == 1, "expected 1, got %d\n", status);
1007     ok(granted == FILE_EXECUTE, "expected FILE_EXECUTE, got %#x\n", granted);
1008
1009     granted = 0xdeadbeef;
1010     status = 0xdeadbeef;
1011     SetLastError(0xdeadbeef);
1012     rc = AccessCheck(sd, token, DELETE, &mapping, &priv_set, &priv_set_len, &granted, &status);
1013     ok(rc, "AccessCheck error %d\n", GetLastError());
1014 todo_wine {
1015     ok(status == 1, "expected 1, got %d\n", status);
1016     ok(granted == DELETE, "expected DELETE, got %#x\n", granted);
1017 }
1018     granted = 0xdeadbeef;
1019     status = 0xdeadbeef;
1020     SetLastError(0xdeadbeef);
1021     rc = AccessCheck(sd, token, FILE_DELETE_CHILD, &mapping, &priv_set, &priv_set_len, &granted, &status);
1022     ok(rc, "AccessCheck error %d\n", GetLastError());
1023 todo_wine {
1024     ok(status == 1, "expected 1, got %d\n", status);
1025     ok(granted == FILE_DELETE_CHILD, "expected FILE_DELETE_CHILD, got %#x\n", granted);
1026 }
1027     granted = 0xdeadbeef;
1028     status = 0xdeadbeef;
1029     SetLastError(0xdeadbeef);
1030     rc = AccessCheck(sd, token, 0x1ff, &mapping, &priv_set, &priv_set_len, &granted, &status);
1031     ok(rc, "AccessCheck error %d\n", GetLastError());
1032 todo_wine {
1033     ok(status == 1, "expected 1, got %d\n", status);
1034     ok(granted == 0x1ff, "expected 0x1ff, got %#x\n", granted);
1035 }
1036     granted = 0xdeadbeef;
1037     status = 0xdeadbeef;
1038     SetLastError(0xdeadbeef);
1039     rc = AccessCheck(sd, token, FILE_ALL_ACCESS, &mapping, &priv_set, &priv_set_len, &granted, &status);
1040     ok(rc, "AccessCheck error %d\n", GetLastError());
1041 todo_wine {
1042     ok(status == 1, "expected 1, got %d\n", status);
1043     ok(granted == FILE_ALL_ACCESS, "expected FILE_ALL_ACCESS, got %#x\n", granted);
1044 }
1045     SetLastError(0xdeadbeef);
1046     rc = DeleteFile(file);
1047     ok(!rc, "DeleteFile should fail\n");
1048     ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
1049     SetLastError(0xdeadbeef);
1050     rc = SetFileAttributes(file, FILE_ATTRIBUTE_ARCHIVE);
1051     ok(rc, "SetFileAttributes error %d\n", GetLastError());
1052     SetLastError(0xdeadbeef);
1053     rc = DeleteFile(file);
1054     ok(rc, "DeleteFile error %d\n", GetLastError());
1055
1056     CloseHandle(token);
1057     HeapFree(GetProcessHeap(), 0, sd);
1058 }
1059
1060 static void test_AccessCheck(void)
1061 {
1062     PSID EveryoneSid = NULL, AdminSid = NULL, UsersSid = NULL;
1063     PACL Acl = NULL;
1064     SECURITY_DESCRIPTOR *SecurityDescriptor = NULL;
1065     SID_IDENTIFIER_AUTHORITY SIDAuthWorld = { SECURITY_WORLD_SID_AUTHORITY };
1066     SID_IDENTIFIER_AUTHORITY SIDAuthNT = { SECURITY_NT_AUTHORITY };
1067     GENERIC_MAPPING Mapping = { KEY_READ, KEY_WRITE, KEY_EXECUTE, KEY_ALL_ACCESS };
1068     ACCESS_MASK Access;
1069     BOOL AccessStatus;
1070     HANDLE Token;
1071     HANDLE ProcessToken;
1072     BOOL ret;
1073     DWORD PrivSetLen;
1074     PRIVILEGE_SET *PrivSet;
1075     BOOL res;
1076     HMODULE NtDllModule;
1077     BOOLEAN Enabled;
1078     DWORD err;
1079     NTSTATUS ntret, ntAccessStatus;
1080
1081     NtDllModule = GetModuleHandle("ntdll.dll");
1082     if (!NtDllModule)
1083     {
1084         skip("not running on NT, skipping test\n");
1085         return;
1086     }
1087     pRtlAdjustPrivilege = (void *)GetProcAddress(NtDllModule, "RtlAdjustPrivilege");
1088     if (!pRtlAdjustPrivilege)
1089     {
1090         win_skip("missing RtlAdjustPrivilege, skipping test\n");
1091         return;
1092     }
1093
1094     Acl = HeapAlloc(GetProcessHeap(), 0, 256);
1095     res = InitializeAcl(Acl, 256, ACL_REVISION);
1096     if(!res && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1097     {
1098         skip("ACLs not implemented - skipping tests\n");
1099         HeapFree(GetProcessHeap(), 0, Acl);
1100         return;
1101     }
1102     ok(res, "InitializeAcl failed with error %d\n", GetLastError());
1103
1104     res = AllocateAndInitializeSid( &SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &EveryoneSid);
1105     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
1106
1107     res = AllocateAndInitializeSid( &SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
1108         DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &AdminSid);
1109     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
1110
1111     res = AllocateAndInitializeSid( &SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
1112         DOMAIN_ALIAS_RID_USERS, 0, 0, 0, 0, 0, 0, &UsersSid);
1113     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
1114
1115     SecurityDescriptor = HeapAlloc(GetProcessHeap(), 0, SECURITY_DESCRIPTOR_MIN_LENGTH);
1116
1117     res = InitializeSecurityDescriptor(SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
1118     ok(res, "InitializeSecurityDescriptor failed with error %d\n", GetLastError());
1119
1120     res = SetSecurityDescriptorDacl(SecurityDescriptor, TRUE, Acl, FALSE);
1121     ok(res, "SetSecurityDescriptorDacl failed with error %d\n", GetLastError());
1122
1123     PrivSetLen = FIELD_OFFSET(PRIVILEGE_SET, Privilege[16]);
1124     PrivSet = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, PrivSetLen);
1125     PrivSet->PrivilegeCount = 16;
1126
1127     res = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE|TOKEN_QUERY, &ProcessToken);
1128     ok(res, "OpenProcessToken failed with error %d\n", GetLastError());
1129
1130     pRtlAdjustPrivilege(SE_SECURITY_PRIVILEGE, FALSE, TRUE, &Enabled);
1131
1132     res = DuplicateToken(ProcessToken, SecurityImpersonation, &Token);
1133     ok(res, "DuplicateToken failed with error %d\n", GetLastError());
1134
1135     /* SD without owner/group */
1136     SetLastError(0xdeadbeef);
1137     Access = AccessStatus = 0x1abe11ed;
1138     ret = AccessCheck(SecurityDescriptor, Token, KEY_QUERY_VALUE, &Mapping,
1139                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1140     err = GetLastError();
1141     ok(!ret && err == ERROR_INVALID_SECURITY_DESCR, "AccessCheck should have "
1142        "failed with ERROR_INVALID_SECURITY_DESCR, instead of %d\n", err);
1143     ok(Access == 0x1abe11ed && AccessStatus == 0x1abe11ed,
1144        "Access and/or AccessStatus were changed!\n");
1145
1146     /* Set owner and group */
1147     res = SetSecurityDescriptorOwner(SecurityDescriptor, AdminSid, FALSE);
1148     ok(res, "SetSecurityDescriptorOwner failed with error %d\n", GetLastError());
1149     res = SetSecurityDescriptorGroup(SecurityDescriptor, UsersSid, TRUE);
1150     ok(res, "SetSecurityDescriptorGroup failed with error %d\n", GetLastError());
1151
1152     /* Generic access mask */
1153     SetLastError(0xdeadbeef);
1154     Access = AccessStatus = 0x1abe11ed;
1155     ret = AccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1156                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1157     err = GetLastError();
1158     ok(!ret && err == ERROR_GENERIC_NOT_MAPPED, "AccessCheck should have failed "
1159        "with ERROR_GENERIC_NOT_MAPPED, instead of %d\n", err);
1160     ok(Access == 0x1abe11ed && AccessStatus == 0x1abe11ed,
1161        "Access and/or AccessStatus were changed!\n");
1162
1163     /* Generic access mask - no privilegeset buffer */
1164     SetLastError(0xdeadbeef);
1165     Access = AccessStatus = 0x1abe11ed;
1166     ret = AccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1167                       NULL, &PrivSetLen, &Access, &AccessStatus);
1168     err = GetLastError();
1169     ok(!ret && err == ERROR_NOACCESS, "AccessCheck should have failed "
1170        "with ERROR_NOACCESS, instead of %d\n", err);
1171     ok(Access == 0x1abe11ed && AccessStatus == 0x1abe11ed,
1172        "Access and/or AccessStatus were changed!\n");
1173
1174     /* Generic access mask - no returnlength */
1175     SetLastError(0xdeadbeef);
1176     Access = AccessStatus = 0x1abe11ed;
1177     ret = AccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1178                       PrivSet, NULL, &Access, &AccessStatus);
1179     err = GetLastError();
1180     ok(!ret && err == ERROR_NOACCESS, "AccessCheck should have failed "
1181        "with ERROR_NOACCESS, instead of %d\n", err);
1182     ok(Access == 0x1abe11ed && AccessStatus == 0x1abe11ed,
1183        "Access and/or AccessStatus were changed!\n");
1184
1185     /* Generic access mask - no privilegeset buffer, no returnlength */
1186     SetLastError(0xdeadbeef);
1187     Access = AccessStatus = 0x1abe11ed;
1188     ret = AccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1189                       NULL, NULL, &Access, &AccessStatus);
1190     err = GetLastError();
1191     ok(!ret && err == ERROR_NOACCESS, "AccessCheck should have failed "
1192        "with ERROR_NOACCESS, instead of %d\n", err);
1193     ok(Access == 0x1abe11ed && AccessStatus == 0x1abe11ed,
1194        "Access and/or AccessStatus were changed!\n");
1195
1196     /* sd with no dacl present */
1197     Access = AccessStatus = 0x1abe11ed;
1198     ret = SetSecurityDescriptorDacl(SecurityDescriptor, FALSE, NULL, FALSE);
1199     ok(ret, "SetSecurityDescriptorDacl failed with error %d\n", GetLastError());
1200     ret = AccessCheck(SecurityDescriptor, Token, KEY_READ, &Mapping,
1201                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1202     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1203     ok(AccessStatus && (Access == KEY_READ),
1204         "AccessCheck failed to grant access with error %d\n",
1205         GetLastError());
1206
1207     /* sd with no dacl present - no privilegeset buffer */
1208     SetLastError(0xdeadbeef);
1209     Access = AccessStatus = 0x1abe11ed;
1210     ret = AccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1211                       NULL, &PrivSetLen, &Access, &AccessStatus);
1212     err = GetLastError();
1213     ok(!ret && err == ERROR_NOACCESS, "AccessCheck should have failed "
1214        "with ERROR_NOACCESS, instead of %d\n", err);
1215     ok(Access == 0x1abe11ed && AccessStatus == 0x1abe11ed,
1216        "Access and/or AccessStatus were changed!\n");
1217
1218     if(pNtAccessCheck)
1219     {
1220        /* Generic access mask - no privilegeset buffer */
1221        SetLastError(0xdeadbeef);
1222        Access = ntAccessStatus = 0x1abe11ed;
1223        ntret = pNtAccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1224                               NULL, &PrivSetLen, &Access, &ntAccessStatus);
1225        err = GetLastError();
1226        ok(ntret == STATUS_ACCESS_VIOLATION,
1227           "NtAccessCheck should have failed with STATUS_ACCESS_VIOLATION, got %x\n", ntret);
1228        ok(err == 0xdeadbeef,
1229           "NtAccessCheck shouldn't set last error, got %d\n", err);
1230        ok(Access == 0x1abe11ed && ntAccessStatus == 0x1abe11ed,
1231           "Access and/or AccessStatus were changed!\n");
1232
1233       /* Generic access mask - no returnlength */
1234       SetLastError(0xdeadbeef);
1235       Access = ntAccessStatus = 0x1abe11ed;
1236       ntret = pNtAccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1237                              PrivSet, NULL, &Access, &ntAccessStatus);
1238       err = GetLastError();
1239       ok(ntret == STATUS_ACCESS_VIOLATION,
1240          "NtAccessCheck should have failed with STATUS_ACCESS_VIOLATION, got %x\n", ntret);
1241       ok(err == 0xdeadbeef,
1242          "NtAccessCheck shouldn't set last error, got %d\n", err);
1243       ok(Access == 0x1abe11ed && ntAccessStatus == 0x1abe11ed,
1244          "Access and/or AccessStatus were changed!\n");
1245
1246       /* Generic access mask - no privilegeset buffer, no returnlength */
1247       SetLastError(0xdeadbeef);
1248       Access = ntAccessStatus = 0x1abe11ed;
1249       ntret = pNtAccessCheck(SecurityDescriptor, Token, GENERIC_READ, &Mapping,
1250                              NULL, NULL, &Access, &ntAccessStatus);
1251       err = GetLastError();
1252       ok(ntret == STATUS_ACCESS_VIOLATION,
1253          "NtAccessCheck should have failed with STATUS_ACCESS_VIOLATION, got %x\n", ntret);
1254       ok(err == 0xdeadbeef,
1255          "NtAccessCheck shouldn't set last error, got %d\n", err);
1256       ok(Access == 0x1abe11ed && ntAccessStatus == 0x1abe11ed,
1257          "Access and/or AccessStatus were changed!\n");
1258     }
1259     else
1260        win_skip("NtAccessCheck unavailable. Skipping.\n");
1261
1262     /* sd with NULL dacl */
1263     Access = AccessStatus = 0x1abe11ed;
1264     ret = SetSecurityDescriptorDacl(SecurityDescriptor, TRUE, NULL, FALSE);
1265     ok(ret, "SetSecurityDescriptorDacl failed with error %d\n", GetLastError());
1266     ret = AccessCheck(SecurityDescriptor, Token, KEY_READ, &Mapping,
1267                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1268     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1269     ok(AccessStatus && (Access == KEY_READ),
1270         "AccessCheck failed to grant access with error %d\n",
1271         GetLastError());
1272
1273     /* sd with blank dacl */
1274     ret = SetSecurityDescriptorDacl(SecurityDescriptor, TRUE, Acl, FALSE);
1275     ok(ret, "SetSecurityDescriptorDacl failed with error %d\n", GetLastError());
1276     ret = AccessCheck(SecurityDescriptor, Token, KEY_READ, &Mapping,
1277                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1278     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1279     err = GetLastError();
1280     ok(!AccessStatus && err == ERROR_ACCESS_DENIED, "AccessCheck should have failed "
1281        "with ERROR_ACCESS_DENIED, instead of %d\n", err);
1282     ok(!Access, "Should have failed to grant any access, got 0x%08x\n", Access);
1283
1284     res = AddAccessAllowedAce(Acl, ACL_REVISION, KEY_READ, EveryoneSid);
1285     ok(res, "AddAccessAllowedAce failed with error %d\n", GetLastError());
1286
1287     res = AddAccessDeniedAce(Acl, ACL_REVISION, KEY_SET_VALUE, AdminSid);
1288     ok(res, "AddAccessDeniedAce failed with error %d\n", GetLastError());
1289
1290     /* sd with dacl */
1291     Access = AccessStatus = 0x1abe11ed;
1292     ret = AccessCheck(SecurityDescriptor, Token, KEY_READ, &Mapping,
1293                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1294     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1295     ok(AccessStatus && (Access == KEY_READ),
1296         "AccessCheck failed to grant access with error %d\n",
1297         GetLastError());
1298
1299     ret = AccessCheck(SecurityDescriptor, Token, MAXIMUM_ALLOWED, &Mapping,
1300                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1301     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1302     ok(AccessStatus,
1303         "AccessCheck failed to grant any access with error %d\n",
1304         GetLastError());
1305     trace("AccessCheck with MAXIMUM_ALLOWED got Access 0x%08x\n", Access);
1306
1307     /* Access denied by SD */
1308     SetLastError(0xdeadbeef);
1309     Access = AccessStatus = 0x1abe11ed;
1310     ret = AccessCheck(SecurityDescriptor, Token, KEY_WRITE, &Mapping,
1311                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1312     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1313     err = GetLastError();
1314     ok(!AccessStatus && err == ERROR_ACCESS_DENIED, "AccessCheck should have failed "
1315        "with ERROR_ACCESS_DENIED, instead of %d\n", err);
1316     ok(!Access, "Should have failed to grant any access, got 0x%08x\n", Access);
1317
1318     SetLastError(0);
1319     PrivSet->PrivilegeCount = 16;
1320     ret = AccessCheck(SecurityDescriptor, Token, ACCESS_SYSTEM_SECURITY, &Mapping,
1321                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1322     ok(ret && !AccessStatus && GetLastError() == ERROR_PRIVILEGE_NOT_HELD,
1323         "AccessCheck should have failed with ERROR_PRIVILEGE_NOT_HELD, instead of %d\n",
1324         GetLastError());
1325
1326     ret = ImpersonateLoggedOnUser(Token);
1327     ok(ret, "ImpersonateLoggedOnUser failed with error %d\n", GetLastError());
1328     ret = pRtlAdjustPrivilege(SE_SECURITY_PRIVILEGE, TRUE, TRUE, &Enabled);
1329     if (!ret)
1330     {
1331         SetLastError(0);
1332         PrivSet->PrivilegeCount = 16;
1333         ret = AccessCheck(SecurityDescriptor, Token, ACCESS_SYSTEM_SECURITY, &Mapping,
1334                           PrivSet, &PrivSetLen, &Access, &AccessStatus);
1335         ok(ret && AccessStatus && GetLastError() == 0,
1336             "AccessCheck should have succeeded, error %d\n",
1337             GetLastError());
1338         ok(Access == ACCESS_SYSTEM_SECURITY,
1339             "Access should be equal to ACCESS_SYSTEM_SECURITY instead of 0x%08x\n",
1340             Access);
1341     }
1342     else
1343         trace("Couldn't get SE_SECURITY_PRIVILEGE (0x%08x), skipping ACCESS_SYSTEM_SECURITY test\n",
1344             ret);
1345     ret = RevertToSelf();
1346     ok(ret, "RevertToSelf failed with error %d\n", GetLastError());
1347
1348     /* test INHERIT_ONLY_ACE */
1349     ret = InitializeAcl(Acl, 256, ACL_REVISION);
1350     ok(ret, "InitializeAcl failed with error %d\n", GetLastError());
1351
1352     /* NT doesn't have AddAccessAllowedAceEx. Skipping this call/test doesn't influence
1353      * the next ones.
1354      */
1355     if (pAddAccessAllowedAceEx)
1356     {
1357         ret = pAddAccessAllowedAceEx(Acl, ACL_REVISION, INHERIT_ONLY_ACE, KEY_READ, EveryoneSid);
1358         ok(ret, "AddAccessAllowedAceEx failed with error %d\n", GetLastError());
1359     }
1360     else
1361         win_skip("AddAccessAllowedAceEx is not available\n");
1362
1363     ret = AccessCheck(SecurityDescriptor, Token, KEY_READ, &Mapping,
1364                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1365     ok(ret, "AccessCheck failed with error %d\n", GetLastError());
1366     err = GetLastError();
1367     ok(!AccessStatus && err == ERROR_ACCESS_DENIED, "AccessCheck should have failed "
1368        "with ERROR_ACCESS_DENIED, instead of %d\n", err);
1369     ok(!Access, "Should have failed to grant any access, got 0x%08x\n", Access);
1370
1371     CloseHandle(Token);
1372
1373     res = DuplicateToken(ProcessToken, SecurityAnonymous, &Token);
1374     ok(res, "DuplicateToken failed with error %d\n", GetLastError());
1375
1376     SetLastError(0xdeadbeef);
1377     ret = AccessCheck(SecurityDescriptor, Token, MAXIMUM_ALLOWED, &Mapping,
1378                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1379     err = GetLastError();
1380     ok(!ret && err == ERROR_BAD_IMPERSONATION_LEVEL, "AccessCheck should have failed "
1381        "with ERROR_BAD_IMPERSONATION_LEVEL, instead of %d\n", err);
1382
1383     CloseHandle(Token);
1384
1385     SetLastError(0xdeadbeef);
1386     ret = AccessCheck(SecurityDescriptor, ProcessToken, KEY_READ, &Mapping,
1387                       PrivSet, &PrivSetLen, &Access, &AccessStatus);
1388     err = GetLastError();
1389     ok(!ret && err == ERROR_NO_IMPERSONATION_TOKEN, "AccessCheck should have failed "
1390        "with ERROR_NO_IMPERSONATION_TOKEN, instead of %d\n", err);
1391
1392     CloseHandle(ProcessToken);
1393
1394     if (EveryoneSid)
1395         FreeSid(EveryoneSid);
1396     if (AdminSid)
1397         FreeSid(AdminSid);
1398     if (UsersSid)
1399         FreeSid(UsersSid);
1400     HeapFree(GetProcessHeap(), 0, Acl);
1401     HeapFree(GetProcessHeap(), 0, SecurityDescriptor);
1402     HeapFree(GetProcessHeap(), 0, PrivSet);
1403 }
1404
1405 /* test GetTokenInformation for the various attributes */
1406 static void test_token_attr(void)
1407 {
1408     HANDLE Token, ImpersonationToken;
1409     DWORD Size, Size2;
1410     TOKEN_PRIVILEGES *Privileges;
1411     TOKEN_GROUPS *Groups;
1412     TOKEN_USER *User;
1413     TOKEN_DEFAULT_DACL *Dacl;
1414     BOOL ret;
1415     DWORD i, GLE;
1416     LPSTR SidString;
1417     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
1418     ACL *acl;
1419
1420     /* cygwin-like use case */
1421     SetLastError(0xdeadbeef);
1422     ret = OpenProcessToken(GetCurrentProcess(), MAXIMUM_ALLOWED, &Token);
1423     if(!ret && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
1424     {
1425         win_skip("OpenProcessToken is not implemented\n");
1426         return;
1427     }
1428     ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
1429     if (ret)
1430     {
1431         DWORD buf[256]; /* GetTokenInformation wants a dword-aligned buffer */
1432         Size = sizeof(buf);
1433         ret = GetTokenInformation(Token, TokenUser,(void*)buf, Size, &Size);
1434         ok(ret, "GetTokenInformation failed with error %d\n", GetLastError());
1435         Size = sizeof(ImpersonationLevel);
1436         ret = GetTokenInformation(Token, TokenImpersonationLevel, &ImpersonationLevel, Size, &Size);
1437         GLE = GetLastError();
1438         ok(!ret && (GLE == ERROR_INVALID_PARAMETER), "GetTokenInformation(TokenImpersonationLevel) on primary token should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GLE);
1439         CloseHandle(Token);
1440     }
1441
1442     if(!pConvertSidToStringSidA)
1443     {
1444         win_skip("ConvertSidToStringSidA is not available\n");
1445         return;
1446     }
1447
1448     SetLastError(0xdeadbeef);
1449     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &Token);
1450     ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
1451
1452     /* groups */
1453     /* insufficient buffer length */
1454     SetLastError(0xdeadbeef);
1455     Size2 = 0;
1456     ret = GetTokenInformation(Token, TokenGroups, NULL, 0, &Size2);
1457     ok(Size2 > 1, "got %d\n", Size2);
1458     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1459         "%d with error %d\n", ret, GetLastError());
1460     Size2 -= 1;
1461     Groups = HeapAlloc(GetProcessHeap(), 0, Size2);
1462     memset(Groups, 0xcc, Size2);
1463     Size = 0;
1464     ret = GetTokenInformation(Token, TokenGroups, Groups, Size2, &Size);
1465     ok(Size > 1, "got %d\n", Size);
1466     ok((!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER) || broken(ret) /* wow64 */,
1467         "%d with error %d\n", ret, GetLastError());
1468     if(!ret)
1469         ok(*((BYTE*)Groups) == 0xcc, "buffer altered\n");
1470
1471     HeapFree(GetProcessHeap(), 0, Groups);
1472
1473     SetLastError(0xdeadbeef);
1474     ret = GetTokenInformation(Token, TokenGroups, NULL, 0, &Size);
1475     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1476         "GetTokenInformation(TokenGroups) %s with error %d\n",
1477         ret ? "succeeded" : "failed", GetLastError());
1478     Groups = HeapAlloc(GetProcessHeap(), 0, Size);
1479     SetLastError(0xdeadbeef);
1480     ret = GetTokenInformation(Token, TokenGroups, Groups, Size, &Size);
1481     ok(ret, "GetTokenInformation(TokenGroups) failed with error %d\n", GetLastError());
1482     ok(GetLastError() == 0xdeadbeef,
1483        "GetTokenInformation shouldn't have set last error to %d\n",
1484        GetLastError());
1485     trace("TokenGroups:\n");
1486     for (i = 0; i < Groups->GroupCount; i++)
1487     {
1488         DWORD NameLength = 255;
1489         TCHAR Name[255];
1490         DWORD DomainLength = 255;
1491         TCHAR Domain[255];
1492         SID_NAME_USE SidNameUse;
1493         Name[0] = '\0';
1494         Domain[0] = '\0';
1495         ret = LookupAccountSid(NULL, Groups->Groups[i].Sid, Name, &NameLength, Domain, &DomainLength, &SidNameUse);
1496         if (ret)
1497         {
1498             pConvertSidToStringSidA(Groups->Groups[i].Sid, &SidString);
1499             trace("%s, %s\\%s use: %d attr: 0x%08x\n", SidString, Domain, Name, SidNameUse, Groups->Groups[i].Attributes);
1500             LocalFree(SidString);
1501         }
1502         else trace("attr: 0x%08x LookupAccountSid failed with error %d\n", Groups->Groups[i].Attributes, GetLastError());
1503     }
1504     HeapFree(GetProcessHeap(), 0, Groups);
1505
1506     /* user */
1507     ret = GetTokenInformation(Token, TokenUser, NULL, 0, &Size);
1508     ok(!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1509         "GetTokenInformation(TokenUser) failed with error %d\n", GetLastError());
1510     User = HeapAlloc(GetProcessHeap(), 0, Size);
1511     ret = GetTokenInformation(Token, TokenUser, User, Size, &Size);
1512     ok(ret,
1513         "GetTokenInformation(TokenUser) failed with error %d\n", GetLastError());
1514
1515     pConvertSidToStringSidA(User->User.Sid, &SidString);
1516     trace("TokenUser: %s attr: 0x%08x\n", SidString, User->User.Attributes);
1517     LocalFree(SidString);
1518     HeapFree(GetProcessHeap(), 0, User);
1519
1520     /* privileges */
1521     ret = GetTokenInformation(Token, TokenPrivileges, NULL, 0, &Size);
1522     ok(!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1523         "GetTokenInformation(TokenPrivileges) failed with error %d\n", GetLastError());
1524     Privileges = HeapAlloc(GetProcessHeap(), 0, Size);
1525     ret = GetTokenInformation(Token, TokenPrivileges, Privileges, Size, &Size);
1526     ok(ret,
1527         "GetTokenInformation(TokenPrivileges) failed with error %d\n", GetLastError());
1528     trace("TokenPrivileges:\n");
1529     for (i = 0; i < Privileges->PrivilegeCount; i++)
1530     {
1531         TCHAR Name[256];
1532         DWORD NameLen = sizeof(Name)/sizeof(Name[0]);
1533         LookupPrivilegeName(NULL, &Privileges->Privileges[i].Luid, Name, &NameLen);
1534         trace("\t%s, 0x%x\n", Name, Privileges->Privileges[i].Attributes);
1535     }
1536     HeapFree(GetProcessHeap(), 0, Privileges);
1537
1538     ret = DuplicateToken(Token, SecurityAnonymous, &ImpersonationToken);
1539     ok(ret, "DuplicateToken failed with error %d\n", GetLastError());
1540
1541     Size = sizeof(ImpersonationLevel);
1542     ret = GetTokenInformation(ImpersonationToken, TokenImpersonationLevel, &ImpersonationLevel, Size, &Size);
1543     ok(ret, "GetTokenInformation(TokenImpersonationLevel) failed with error %d\n", GetLastError());
1544     ok(ImpersonationLevel == SecurityAnonymous, "ImpersonationLevel should have been SecurityAnonymous instead of %d\n", ImpersonationLevel);
1545
1546     CloseHandle(ImpersonationToken);
1547
1548     /* default dacl */
1549     ret = GetTokenInformation(Token, TokenDefaultDacl, NULL, 0, &Size);
1550     ok(!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER),
1551         "GetTokenInformation(TokenDefaultDacl) failed with error %u\n", GetLastError());
1552
1553     Dacl = HeapAlloc(GetProcessHeap(), 0, Size);
1554     ret = GetTokenInformation(Token, TokenDefaultDacl, Dacl, Size, &Size);
1555     ok(ret, "GetTokenInformation(TokenDefaultDacl) failed with error %u\n", GetLastError());
1556
1557     SetLastError(0xdeadbeef);
1558     ret = SetTokenInformation(Token, TokenDefaultDacl, NULL, 0);
1559     GLE = GetLastError();
1560     ok(!ret, "SetTokenInformation(TokenDefaultDacl) succeeded\n");
1561     ok(GLE == ERROR_BAD_LENGTH, "expected ERROR_BAD_LENGTH got %u\n", GLE);
1562
1563     SetLastError(0xdeadbeef);
1564     ret = SetTokenInformation(Token, TokenDefaultDacl, NULL, Size);
1565     GLE = GetLastError();
1566     ok(!ret, "SetTokenInformation(TokenDefaultDacl) succeeded\n");
1567     ok(GLE == ERROR_NOACCESS, "expected ERROR_NOACCESS got %u\n", GLE);
1568
1569     acl = Dacl->DefaultDacl;
1570     Dacl->DefaultDacl = NULL;
1571
1572     ret = SetTokenInformation(Token, TokenDefaultDacl, Dacl, Size);
1573     ok(ret, "SetTokenInformation(TokenDefaultDacl) succeeded\n");
1574
1575     Size2 = 0;
1576     Dacl->DefaultDacl = (ACL *)0xdeadbeef;
1577     ret = GetTokenInformation(Token, TokenDefaultDacl, Dacl, Size, &Size2);
1578     ok(ret, "GetTokenInformation(TokenDefaultDacl) failed with error %u\n", GetLastError());
1579     ok(Dacl->DefaultDacl == NULL, "expected NULL, got %p\n", Dacl->DefaultDacl);
1580     ok(Size2 == sizeof(TOKEN_DEFAULT_DACL) || broken(Size2 == 2*sizeof(TOKEN_DEFAULT_DACL)), /* WoW64 */
1581        "got %u expected sizeof(TOKEN_DEFAULT_DACL)\n", Size2);
1582
1583     Dacl->DefaultDacl = acl;
1584     ret = SetTokenInformation(Token, TokenDefaultDacl, Dacl, Size);
1585     ok(ret, "SetTokenInformation(TokenDefaultDacl) failed with error %u\n", GetLastError());
1586
1587     if (Size2 == sizeof(TOKEN_DEFAULT_DACL)) {
1588         ret = GetTokenInformation(Token, TokenDefaultDacl, Dacl, Size, &Size2);
1589         ok(ret, "GetTokenInformation(TokenDefaultDacl) failed with error %u\n", GetLastError());
1590     } else
1591         win_skip("TOKEN_DEFAULT_DACL size too small on WoW64\n");
1592
1593     HeapFree(GetProcessHeap(), 0, Dacl);
1594     CloseHandle(Token);
1595 }
1596
1597 typedef union _MAX_SID
1598 {
1599     SID sid;
1600     char max[SECURITY_MAX_SID_SIZE];
1601 } MAX_SID;
1602
1603 static void test_sid_str(PSID * sid)
1604 {
1605     char *str_sid;
1606     BOOL ret = pConvertSidToStringSidA(sid, &str_sid);
1607     ok(ret, "ConvertSidToStringSidA() failed: %d\n", GetLastError());
1608     if (ret)
1609     {
1610         char account[MAX_PATH], domain[MAX_PATH];
1611         SID_NAME_USE use;
1612         DWORD acc_size = MAX_PATH;
1613         DWORD dom_size = MAX_PATH;
1614         ret = LookupAccountSid(NULL, sid, account, &acc_size, domain, &dom_size, &use);
1615         ok(ret || (!ret && (GetLastError() == ERROR_NONE_MAPPED)),
1616            "LookupAccountSid(%s) failed: %d\n", str_sid, GetLastError());
1617         if (ret)
1618             trace(" %s %s\\%s %d\n", str_sid, domain, account, use);
1619         else if (GetLastError() == ERROR_NONE_MAPPED)
1620             trace(" %s couldn't be mapped\n", str_sid);
1621         LocalFree(str_sid);
1622     }
1623 }
1624
1625 static const struct well_known_sid_value
1626 {
1627     BOOL without_domain;
1628     const char *sid_string;
1629 } well_known_sid_values[] = {
1630 /*  0 */ {TRUE, "S-1-0-0"},  {TRUE, "S-1-1-0"},  {TRUE, "S-1-2-0"},  {TRUE, "S-1-3-0"},
1631 /*  4 */ {TRUE, "S-1-3-1"},  {TRUE, "S-1-3-2"},  {TRUE, "S-1-3-3"},  {TRUE, "S-1-5"},
1632 /*  8 */ {FALSE, "S-1-5-1"}, {TRUE, "S-1-5-2"},  {TRUE, "S-1-5-3"},  {TRUE, "S-1-5-4"},
1633 /* 12 */ {TRUE, "S-1-5-6"},  {TRUE, "S-1-5-7"},  {TRUE, "S-1-5-8"},  {TRUE, "S-1-5-9"},
1634 /* 16 */ {TRUE, "S-1-5-10"}, {TRUE, "S-1-5-11"}, {TRUE, "S-1-5-12"}, {TRUE, "S-1-5-13"},
1635 /* 20 */ {TRUE, "S-1-5-14"}, {FALSE, NULL},      {TRUE, "S-1-5-18"}, {TRUE, "S-1-5-19"},
1636 /* 24 */ {TRUE, "S-1-5-20"}, {TRUE, "S-1-5-32"},
1637 /* 26 */ {FALSE, "S-1-5-32-544"}, {TRUE, "S-1-5-32-545"}, {TRUE, "S-1-5-32-546"},
1638 /* 29 */ {TRUE, "S-1-5-32-547"},  {TRUE, "S-1-5-32-548"}, {TRUE, "S-1-5-32-549"},
1639 /* 32 */ {TRUE, "S-1-5-32-550"},  {TRUE, "S-1-5-32-551"}, {TRUE, "S-1-5-32-552"},
1640 /* 35 */ {TRUE, "S-1-5-32-554"},  {TRUE, "S-1-5-32-555"}, {TRUE, "S-1-5-32-556"},
1641 /* 38 */ {FALSE, "S-1-5-21-12-23-34-45-56-500"}, {FALSE, "S-1-5-21-12-23-34-45-56-501"},
1642 /* 40 */ {FALSE, "S-1-5-21-12-23-34-45-56-502"}, {FALSE, "S-1-5-21-12-23-34-45-56-512"},
1643 /* 42 */ {FALSE, "S-1-5-21-12-23-34-45-56-513"}, {FALSE, "S-1-5-21-12-23-34-45-56-514"},
1644 /* 44 */ {FALSE, "S-1-5-21-12-23-34-45-56-515"}, {FALSE, "S-1-5-21-12-23-34-45-56-516"},
1645 /* 46 */ {FALSE, "S-1-5-21-12-23-34-45-56-517"}, {FALSE, "S-1-5-21-12-23-34-45-56-518"},
1646 /* 48 */ {FALSE, "S-1-5-21-12-23-34-45-56-519"}, {FALSE, "S-1-5-21-12-23-34-45-56-520"},
1647 /* 50 */ {FALSE, "S-1-5-21-12-23-34-45-56-553"},
1648 /* Added in Windows Server 2003 */
1649 /* 51 */ {TRUE, "S-1-5-64-10"},   {TRUE, "S-1-5-64-21"},   {TRUE, "S-1-5-64-14"},
1650 /* 54 */ {TRUE, "S-1-5-15"},      {TRUE, "S-1-5-1000"},    {FALSE, "S-1-5-32-557"},
1651 /* 57 */ {TRUE, "S-1-5-32-558"},  {TRUE, "S-1-5-32-559"},  {TRUE, "S-1-5-32-560"},
1652 /* 60 */ {TRUE, "S-1-5-32-561"}, {TRUE, "S-1-5-32-562"},
1653 /* Added in Windows Vista: */
1654 /* 62 */ {TRUE, "S-1-5-32-568"},
1655 /* 63 */ {TRUE, "S-1-5-17"},      {FALSE, "S-1-5-32-569"}, {TRUE, "S-1-16-0"},
1656 /* 66 */ {TRUE, "S-1-16-4096"},   {TRUE, "S-1-16-8192"},   {TRUE, "S-1-16-12288"},
1657 /* 69 */ {TRUE, "S-1-16-16384"},  {TRUE, "S-1-5-33"},      {TRUE, "S-1-3-4"},
1658 /* 72 */ {FALSE, "S-1-5-21-12-23-34-45-56-571"},  {FALSE, "S-1-5-21-12-23-34-45-56-572"},
1659 /* 74 */ {TRUE, "S-1-5-22"}, {FALSE, "S-1-5-21-12-23-34-45-56-521"}, {TRUE, "S-1-5-32-573"},
1660 /* 77 */ {FALSE, "S-1-5-21-12-23-34-45-56-498"}, {TRUE, "S-1-5-32-574"}, {TRUE, "S-1-16-8448"}
1661 };
1662
1663 static void test_CreateWellKnownSid(void)
1664 {
1665     SID_IDENTIFIER_AUTHORITY ident = { SECURITY_NT_AUTHORITY };
1666     PSID domainsid, sid;
1667     DWORD size, error;
1668     BOOL ret;
1669     unsigned int i;
1670
1671     if (!pCreateWellKnownSid)
1672     {
1673         win_skip("CreateWellKnownSid not available\n");
1674         return;
1675     }
1676
1677     size = 0;
1678     SetLastError(0xdeadbeef);
1679     ret = pCreateWellKnownSid(WinInteractiveSid, NULL, NULL, &size);
1680     error = GetLastError();
1681     ok(!ret, "CreateWellKnownSid succeeded\n");
1682     ok(error == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %u\n", error);
1683     ok(size, "expected size > 0\n");
1684
1685     SetLastError(0xdeadbeef);
1686     ret = pCreateWellKnownSid(WinInteractiveSid, NULL, NULL, &size);
1687     error = GetLastError();
1688     ok(!ret, "CreateWellKnownSid succeeded\n");
1689     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
1690
1691     sid = HeapAlloc(GetProcessHeap(), 0, size);
1692     ret = pCreateWellKnownSid(WinInteractiveSid, NULL, sid, &size);
1693     ok(ret, "CreateWellKnownSid failed %u\n", GetLastError());
1694     HeapFree(GetProcessHeap(), 0, sid);
1695
1696     /* a domain sid usually have three subauthorities but we test that CreateWellKnownSid doesn't check it */
1697     AllocateAndInitializeSid(&ident, 6, SECURITY_NT_NON_UNIQUE, 12, 23, 34, 45, 56, 0, 0, &domainsid);
1698
1699     for (i = 0; i < sizeof(well_known_sid_values)/sizeof(well_known_sid_values[0]); i++)
1700     {
1701         const struct well_known_sid_value *value = &well_known_sid_values[i];
1702         char sid_buffer[SECURITY_MAX_SID_SIZE];
1703         LPSTR str;
1704         DWORD cb;
1705
1706         if (value->sid_string == NULL)
1707             continue;
1708
1709         if (i > WinAccountRasAndIasServersSid)
1710         {
1711             /* These SIDs aren't implemented by all Windows versions - detect it and break the loop */
1712             cb = sizeof(sid_buffer);
1713             if (!pCreateWellKnownSid(i, domainsid, sid_buffer, &cb))
1714             {
1715                 skip("Well known SIDs starting from %u are not implemented\n", i);
1716                 break;
1717             }
1718         }
1719
1720         cb = sizeof(sid_buffer);
1721         ok(pCreateWellKnownSid(i, value->without_domain ? NULL : domainsid, sid_buffer, &cb), "Couldn't create well known sid %u\n", i);
1722         expect_eq(GetSidLengthRequired(*GetSidSubAuthorityCount(sid_buffer)), cb, DWORD, "%d");
1723         ok(IsValidSid(sid_buffer), "The sid is not valid\n");
1724         ok(pConvertSidToStringSidA(sid_buffer, &str), "Couldn't convert SID to string\n");
1725         ok(strcmp(str, value->sid_string) == 0, "%d: SID mismatch - expected %s, got %s\n", i,
1726             value->sid_string, str);
1727         LocalFree(str);
1728
1729         if (value->without_domain)
1730         {
1731             char buf2[SECURITY_MAX_SID_SIZE];
1732             cb = sizeof(buf2);
1733             ok(pCreateWellKnownSid(i, domainsid, buf2, &cb), "Couldn't create well known sid %u with optional domain\n", i);
1734             expect_eq(GetSidLengthRequired(*GetSidSubAuthorityCount(sid_buffer)), cb, DWORD, "%d");
1735             ok(memcmp(buf2, sid_buffer, cb) == 0, "SID create with domain is different than without (%u)\n", i);
1736         }
1737     }
1738
1739     FreeSid(domainsid);
1740 }
1741
1742 static void test_LookupAccountSid(void)
1743 {
1744     SID_IDENTIFIER_AUTHORITY SIDAuthNT = { SECURITY_NT_AUTHORITY };
1745     CHAR accountA[MAX_PATH], domainA[MAX_PATH], usernameA[MAX_PATH];
1746     DWORD acc_sizeA, dom_sizeA, user_sizeA;
1747     DWORD real_acc_sizeA, real_dom_sizeA;
1748     WCHAR accountW[MAX_PATH], domainW[MAX_PATH];
1749     DWORD acc_sizeW, dom_sizeW;
1750     DWORD real_acc_sizeW, real_dom_sizeW;
1751     PSID pUsersSid = NULL;
1752     SID_NAME_USE use;
1753     BOOL ret;
1754     DWORD error, size, cbti = 0;
1755     MAX_SID  max_sid;
1756     CHAR *str_sidA;
1757     int i;
1758     HANDLE hToken;
1759     PTOKEN_USER ptiUser = NULL;
1760
1761     /* native windows crashes if account size, domain size, or name use is NULL */
1762
1763     ret = AllocateAndInitializeSid(&SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
1764         DOMAIN_ALIAS_RID_USERS, 0, 0, 0, 0, 0, 0, &pUsersSid);
1765     ok(ret || (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED),
1766        "AllocateAndInitializeSid failed with error %d\n", GetLastError());
1767
1768     /* not running on NT so give up */
1769     if (!ret && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
1770         return;
1771
1772     real_acc_sizeA = MAX_PATH;
1773     real_dom_sizeA = MAX_PATH;
1774     ret = LookupAccountSidA(NULL, pUsersSid, accountA, &real_acc_sizeA, domainA, &real_dom_sizeA, &use);
1775     ok(ret, "LookupAccountSidA() Expected TRUE, got FALSE\n");
1776
1777     /* try NULL account */
1778     acc_sizeA = MAX_PATH;
1779     dom_sizeA = MAX_PATH;
1780     ret = LookupAccountSidA(NULL, pUsersSid, NULL, &acc_sizeA, domainA, &dom_sizeA, &use);
1781     ok(ret, "LookupAccountSidA() Expected TRUE, got FALSE\n");
1782
1783     /* try NULL domain */
1784     acc_sizeA = MAX_PATH;
1785     dom_sizeA = MAX_PATH;
1786     ret = LookupAccountSidA(NULL, pUsersSid, accountA, &acc_sizeA, NULL, &dom_sizeA, &use);
1787     ok(ret, "LookupAccountSidA() Expected TRUE, got FALSE\n");
1788
1789     /* try a small account buffer */
1790     acc_sizeA = 1;
1791     dom_sizeA = MAX_PATH;
1792     accountA[0] = 0;
1793     ret = LookupAccountSidA(NULL, pUsersSid, accountA, &acc_sizeA, domainA, &dom_sizeA, &use);
1794     ok(!ret, "LookupAccountSidA() Expected FALSE got TRUE\n");
1795     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1796        "LookupAccountSidA() Expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1797
1798     /* try a 0 sized account buffer */
1799     acc_sizeA = 0;
1800     dom_sizeA = MAX_PATH;
1801     accountA[0] = 0;
1802     LookupAccountSidA(NULL, pUsersSid, accountA, &acc_sizeA, domainA, &dom_sizeA, &use);
1803     /* this can fail or succeed depending on OS version but the size will always be returned */
1804     ok(acc_sizeA == real_acc_sizeA + 1,
1805        "LookupAccountSidA() Expected acc_size = %u, got %u\n",
1806        real_acc_sizeA + 1, acc_sizeA);
1807
1808     /* try a 0 sized account buffer */
1809     acc_sizeA = 0;
1810     dom_sizeA = MAX_PATH;
1811     LookupAccountSidA(NULL, pUsersSid, NULL, &acc_sizeA, domainA, &dom_sizeA, &use);
1812     /* this can fail or succeed depending on OS version but the size will always be returned */
1813     ok(acc_sizeA == real_acc_sizeA + 1,
1814        "LookupAccountSid() Expected acc_size = %u, got %u\n",
1815        real_acc_sizeA + 1, acc_sizeA);
1816
1817     /* try a small domain buffer */
1818     dom_sizeA = 1;
1819     acc_sizeA = MAX_PATH;
1820     accountA[0] = 0;
1821     ret = LookupAccountSidA(NULL, pUsersSid, accountA, &acc_sizeA, domainA, &dom_sizeA, &use);
1822     ok(!ret, "LookupAccountSidA() Expected FALSE got TRUE\n");
1823     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1824        "LookupAccountSidA() Expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1825
1826     /* try a 0 sized domain buffer */
1827     dom_sizeA = 0;
1828     acc_sizeA = MAX_PATH;
1829     accountA[0] = 0;
1830     LookupAccountSidA(NULL, pUsersSid, accountA, &acc_sizeA, domainA, &dom_sizeA, &use);
1831     /* this can fail or succeed depending on OS version but the size will always be returned */
1832     ok(dom_sizeA == real_dom_sizeA + 1,
1833        "LookupAccountSidA() Expected dom_size = %u, got %u\n",
1834        real_dom_sizeA + 1, dom_sizeA);
1835
1836     /* try a 0 sized domain buffer */
1837     dom_sizeA = 0;
1838     acc_sizeA = MAX_PATH;
1839     LookupAccountSidA(NULL, pUsersSid, accountA, &acc_sizeA, NULL, &dom_sizeA, &use);
1840     /* this can fail or succeed depending on OS version but the size will always be returned */
1841     ok(dom_sizeA == real_dom_sizeA + 1,
1842        "LookupAccountSidA() Expected dom_size = %u, got %u\n",
1843        real_dom_sizeA + 1, dom_sizeA);
1844
1845     real_acc_sizeW = MAX_PATH;
1846     real_dom_sizeW = MAX_PATH;
1847     ret = LookupAccountSidW(NULL, pUsersSid, accountW, &real_acc_sizeW, domainW, &real_dom_sizeW, &use);
1848     ok(ret, "LookupAccountSidW() Expected TRUE, got FALSE\n");
1849
1850     /* try an invalid system name */
1851     real_acc_sizeA = MAX_PATH;
1852     real_dom_sizeA = MAX_PATH;
1853     ret = LookupAccountSidA("deepthought", pUsersSid, accountA, &real_acc_sizeA, domainA, &real_dom_sizeA, &use);
1854     ok(!ret, "LookupAccountSidA() Expected FALSE got TRUE\n");
1855     ok(GetLastError() == RPC_S_SERVER_UNAVAILABLE || GetLastError() == RPC_S_INVALID_NET_ADDR /* Vista */,
1856        "LookupAccountSidA() Expected RPC_S_SERVER_UNAVAILABLE or RPC_S_INVALID_NET_ADDR, got %u\n", GetLastError());
1857
1858     /* native windows crashes if domainW or accountW is NULL */
1859
1860     /* try a small account buffer */
1861     acc_sizeW = 1;
1862     dom_sizeW = MAX_PATH;
1863     accountW[0] = 0;
1864     ret = LookupAccountSidW(NULL, pUsersSid, accountW, &acc_sizeW, domainW, &dom_sizeW, &use);
1865     ok(!ret, "LookupAccountSidW() Expected FALSE got TRUE\n");
1866     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1867        "LookupAccountSidW() Expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1868
1869     /* try a 0 sized account buffer */
1870     acc_sizeW = 0;
1871     dom_sizeW = MAX_PATH;
1872     accountW[0] = 0;
1873     LookupAccountSidW(NULL, pUsersSid, accountW, &acc_sizeW, domainW, &dom_sizeW, &use);
1874     /* this can fail or succeed depending on OS version but the size will always be returned */
1875     ok(acc_sizeW == real_acc_sizeW + 1,
1876        "LookupAccountSidW() Expected acc_size = %u, got %u\n",
1877        real_acc_sizeW + 1, acc_sizeW);
1878
1879     /* try a 0 sized account buffer */
1880     acc_sizeW = 0;
1881     dom_sizeW = MAX_PATH;
1882     LookupAccountSidW(NULL, pUsersSid, NULL, &acc_sizeW, domainW, &dom_sizeW, &use);
1883     /* this can fail or succeed depending on OS version but the size will always be returned */
1884     ok(acc_sizeW == real_acc_sizeW + 1,
1885        "LookupAccountSidW() Expected acc_size = %u, got %u\n",
1886        real_acc_sizeW + 1, acc_sizeW);
1887
1888     /* try a small domain buffer */
1889     dom_sizeW = 1;
1890     acc_sizeW = MAX_PATH;
1891     accountW[0] = 0;
1892     ret = LookupAccountSidW(NULL, pUsersSid, accountW, &acc_sizeW, domainW, &dom_sizeW, &use);
1893     ok(!ret, "LookupAccountSidW() Expected FALSE got TRUE\n");
1894     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1895        "LookupAccountSidW() Expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1896
1897     /* try a 0 sized domain buffer */
1898     dom_sizeW = 0;
1899     acc_sizeW = MAX_PATH;
1900     accountW[0] = 0;
1901     LookupAccountSidW(NULL, pUsersSid, accountW, &acc_sizeW, domainW, &dom_sizeW, &use);
1902     /* this can fail or succeed depending on OS version but the size will always be returned */
1903     ok(dom_sizeW == real_dom_sizeW + 1,
1904        "LookupAccountSidW() Expected dom_size = %u, got %u\n",
1905        real_dom_sizeW + 1, dom_sizeW);
1906
1907     /* try a 0 sized domain buffer */
1908     dom_sizeW = 0;
1909     acc_sizeW = MAX_PATH;
1910     LookupAccountSidW(NULL, pUsersSid, accountW, &acc_sizeW, NULL, &dom_sizeW, &use);
1911     /* this can fail or succeed depending on OS version but the size will always be returned */
1912     ok(dom_sizeW == real_dom_sizeW + 1,
1913        "LookupAccountSidW() Expected dom_size = %u, got %u\n",
1914        real_dom_sizeW + 1, dom_sizeW);
1915
1916     acc_sizeW = dom_sizeW = use = 0;
1917     SetLastError(0xdeadbeef);
1918     ret = LookupAccountSidW(NULL, pUsersSid, NULL, &acc_sizeW, NULL, &dom_sizeW, &use);
1919     error = GetLastError();
1920     ok(!ret, "LookupAccountSidW failed %u\n", GetLastError());
1921     ok(error == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %u\n", error);
1922     ok(acc_sizeW, "expected non-zero account size\n");
1923     ok(dom_sizeW, "expected non-zero domain size\n");
1924     ok(!use, "expected zero use %u\n", use);
1925
1926     FreeSid(pUsersSid);
1927
1928     /* Test LookupAccountSid with Sid retrieved from token information.
1929      This assumes this process is running under the account of the current user.*/
1930     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY|TOKEN_DUPLICATE, &hToken);
1931     ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
1932     ret = GetTokenInformation(hToken, TokenUser, NULL, 0, &cbti);
1933     ok(!ret, "GetTokenInformation failed with error %d\n", GetLastError());
1934     ptiUser = HeapAlloc(GetProcessHeap(), 0, cbti);
1935     if (GetTokenInformation(hToken, TokenUser, ptiUser, cbti, &cbti))
1936     {
1937         acc_sizeA = dom_sizeA = MAX_PATH;
1938         ret = LookupAccountSidA(NULL, ptiUser->User.Sid, accountA, &acc_sizeA, domainA, &dom_sizeA, &use);
1939         ok(ret, "LookupAccountSidA() Expected TRUE, got FALSE\n");
1940         user_sizeA = MAX_PATH;
1941         ret = GetUserNameA(usernameA , &user_sizeA);
1942         ok(ret, "GetUserNameA() Expected TRUE, got FALSE\n");
1943         ok(lstrcmpA(usernameA, accountA) == 0, "LookupAccountSidA() Expected account name: %s got: %s\n", usernameA, accountA );
1944     }
1945     HeapFree(GetProcessHeap(), 0, ptiUser);
1946
1947     if (pCreateWellKnownSid && pConvertSidToStringSidA)
1948     {
1949         trace("Well Known SIDs:\n");
1950         for (i = 0; i <= 60; i++)
1951         {
1952             size = SECURITY_MAX_SID_SIZE;
1953             if (pCreateWellKnownSid(i, NULL, &max_sid.sid, &size))
1954             {
1955                 if (pConvertSidToStringSidA(&max_sid.sid, &str_sidA))
1956                 {
1957                     acc_sizeA = MAX_PATH;
1958                     dom_sizeA = MAX_PATH;
1959                     if (LookupAccountSidA(NULL, &max_sid.sid, accountA, &acc_sizeA, domainA, &dom_sizeA, &use))
1960                         trace(" %d: %s %s\\%s %d\n", i, str_sidA, domainA, accountA, use);
1961                     LocalFree(str_sidA);
1962                 }
1963             }
1964             else
1965             {
1966                 if (GetLastError() != ERROR_INVALID_PARAMETER)
1967                     trace(" CreateWellKnownSid(%d) failed: %d\n", i, GetLastError());
1968                 else
1969                     trace(" %d: not supported\n", i);
1970             }
1971         }
1972
1973         pLsaQueryInformationPolicy = (void *)GetProcAddress( hmod, "LsaQueryInformationPolicy");
1974         pLsaOpenPolicy = (void *)GetProcAddress( hmod, "LsaOpenPolicy");
1975         pLsaFreeMemory = (void *)GetProcAddress( hmod, "LsaFreeMemory");
1976         pLsaClose = (void *)GetProcAddress( hmod, "LsaClose");
1977
1978         if (pLsaQueryInformationPolicy && pLsaOpenPolicy && pLsaFreeMemory && pLsaClose)
1979         {
1980             NTSTATUS status;
1981             LSA_HANDLE handle;
1982             LSA_OBJECT_ATTRIBUTES object_attributes;
1983
1984             ZeroMemory(&object_attributes, sizeof(object_attributes));
1985             object_attributes.Length = sizeof(object_attributes);
1986
1987             status = pLsaOpenPolicy( NULL, &object_attributes, POLICY_ALL_ACCESS, &handle);
1988             ok(status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
1989                "LsaOpenPolicy(POLICY_ALL_ACCESS) returned 0x%08x\n", status);
1990
1991             /* try a more restricted access mask if necessary */
1992             if (status == STATUS_ACCESS_DENIED) {
1993                 trace("LsaOpenPolicy(POLICY_ALL_ACCESS) failed, trying POLICY_VIEW_LOCAL_INFORMATION\n");
1994                 status = pLsaOpenPolicy( NULL, &object_attributes, POLICY_VIEW_LOCAL_INFORMATION, &handle);
1995                 ok(status == STATUS_SUCCESS, "LsaOpenPolicy(POLICY_VIEW_LOCAL_INFORMATION) returned 0x%08x\n", status);
1996             }
1997
1998             if (status == STATUS_SUCCESS)
1999             {
2000                 PPOLICY_ACCOUNT_DOMAIN_INFO info;
2001                 status = pLsaQueryInformationPolicy(handle, PolicyAccountDomainInformation, (PVOID*)&info);
2002                 ok(status == STATUS_SUCCESS, "LsaQueryInformationPolicy() failed, returned 0x%08x\n", status);
2003                 if (status == STATUS_SUCCESS)
2004                 {
2005                     ok(info->DomainSid!=0, "LsaQueryInformationPolicy(PolicyAccountDomainInformation) missing SID\n");
2006                     if (info->DomainSid)
2007                     {
2008                         int count = *GetSidSubAuthorityCount(info->DomainSid);
2009                         CopySid(GetSidLengthRequired(count), &max_sid, info->DomainSid);
2010                         test_sid_str((PSID)&max_sid.sid);
2011                         max_sid.sid.SubAuthority[count] = DOMAIN_USER_RID_ADMIN;
2012                         max_sid.sid.SubAuthorityCount = count + 1;
2013                         test_sid_str((PSID)&max_sid.sid);
2014                         max_sid.sid.SubAuthority[count] = DOMAIN_USER_RID_GUEST;
2015                         test_sid_str((PSID)&max_sid.sid);
2016                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_ADMINS;
2017                         test_sid_str((PSID)&max_sid.sid);
2018                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_USERS;
2019                         test_sid_str((PSID)&max_sid.sid);
2020                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_GUESTS;
2021                         test_sid_str((PSID)&max_sid.sid);
2022                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_COMPUTERS;
2023                         test_sid_str((PSID)&max_sid.sid);
2024                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_CONTROLLERS;
2025                         test_sid_str((PSID)&max_sid.sid);
2026                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_CERT_ADMINS;
2027                         test_sid_str((PSID)&max_sid.sid);
2028                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_SCHEMA_ADMINS;
2029                         test_sid_str((PSID)&max_sid.sid);
2030                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_ENTERPRISE_ADMINS;
2031                         test_sid_str((PSID)&max_sid.sid);
2032                         max_sid.sid.SubAuthority[count] = DOMAIN_GROUP_RID_POLICY_ADMINS;
2033                         test_sid_str((PSID)&max_sid.sid);
2034                         max_sid.sid.SubAuthority[count] = DOMAIN_ALIAS_RID_RAS_SERVERS;
2035                         test_sid_str((PSID)&max_sid.sid);
2036                         max_sid.sid.SubAuthority[count] = 1000; /* first user account */
2037                         test_sid_str((PSID)&max_sid.sid);
2038                     }
2039
2040                     pLsaFreeMemory((LPVOID)info);
2041                 }
2042
2043                 status = pLsaClose(handle);
2044                 ok(status == STATUS_SUCCESS, "LsaClose() failed, returned 0x%08x\n", status);
2045             }
2046         }
2047     }
2048 }
2049
2050 static BOOL get_sid_info(PSID psid, LPSTR *user, LPSTR *dom)
2051 {
2052     static CHAR account[UNLEN + 1];
2053     static CHAR domain[UNLEN + 1];
2054     DWORD size, dom_size;
2055     SID_NAME_USE use;
2056
2057     *user = account;
2058     *dom = domain;
2059
2060     size = dom_size = UNLEN + 1;
2061     account[0] = '\0';
2062     domain[0] = '\0';
2063     SetLastError(0xdeadbeef);
2064     return LookupAccountSidA(NULL, psid, account, &size, domain, &dom_size, &use);
2065 }
2066
2067 static void check_wellknown_name(const char* name, WELL_KNOWN_SID_TYPE result)
2068 {
2069     SID_IDENTIFIER_AUTHORITY ident = { SECURITY_NT_AUTHORITY };
2070     PSID domainsid = NULL;
2071     char wk_sid[SECURITY_MAX_SID_SIZE];
2072     DWORD cb;
2073
2074     DWORD sid_size, domain_size;
2075     SID_NAME_USE sid_use;
2076     LPSTR domain, account, sid_domain, wk_domain, wk_account;
2077     PSID psid;
2078     BOOL ret ,ret2;
2079
2080     sid_size = 0;
2081     domain_size = 0;
2082     ret = LookupAccountNameA(NULL, name, NULL, &sid_size, NULL, &domain_size, &sid_use);
2083     ok(!ret, " %s Should have failed to lookup account name\n", name);
2084     psid = HeapAlloc(GetProcessHeap(),0,sid_size);
2085     domain = HeapAlloc(GetProcessHeap(),0,domain_size);
2086     ret = LookupAccountNameA(NULL, name, psid, &sid_size, domain, &domain_size, &sid_use);
2087
2088     if (!result)
2089     {
2090         ok(!ret, " %s Should have failed to lookup account name\n",name);
2091         goto cleanup;
2092     }
2093
2094     AllocateAndInitializeSid(&ident, 6, SECURITY_NT_NON_UNIQUE, 12, 23, 34, 45, 56, 0, 0, &domainsid);
2095     cb = sizeof(wk_sid);
2096     if (!pCreateWellKnownSid(result, domainsid, wk_sid, &cb))
2097     {
2098         win_skip("SID %i is not available on the system\n",result);
2099         goto cleanup;
2100     }
2101
2102     ret2 = get_sid_info(wk_sid, &wk_account, &wk_domain);
2103     if (!ret2 && GetLastError() == ERROR_NONE_MAPPED)
2104     {
2105         win_skip("CreateWellKnownSid() succeeded but the account '%s' is not present (W2K)\n", name);
2106         goto cleanup;
2107     }
2108
2109     get_sid_info(psid, &account, &sid_domain);
2110
2111     ok(ret, "Failed to lookup account name %s\n",name);
2112     ok(sid_size != 0, "sid_size was zero\n");
2113
2114     ok(EqualSid(psid,wk_sid),"(%s) Sids fail to match well known sid!\n",name);
2115
2116     ok(!lstrcmp(account, wk_account), "Expected %s , got %s\n", account, wk_account);
2117     ok(!lstrcmp(domain, wk_domain), "Expected %s, got %s\n", wk_domain, domain);
2118     ok(sid_use == SidTypeWellKnownGroup , "Expected Use (5), got %d\n", sid_use);
2119
2120 cleanup:
2121     FreeSid(domainsid);
2122     HeapFree(GetProcessHeap(),0,psid);
2123     HeapFree(GetProcessHeap(),0,domain);
2124 }
2125
2126 static void test_LookupAccountName(void)
2127 {
2128     DWORD sid_size, domain_size, user_size;
2129     DWORD sid_save, domain_save;
2130     CHAR user_name[UNLEN + 1];
2131     CHAR computer_name[UNLEN + 1];
2132     SID_NAME_USE sid_use;
2133     LPSTR domain, account, sid_dom;
2134     PSID psid;
2135     BOOL ret;
2136
2137     /* native crashes if (assuming all other parameters correct):
2138      *  - peUse is NULL
2139      *  - Sid is NULL and cbSid is > 0
2140      *  - cbSid or cchReferencedDomainName are NULL
2141      *  - ReferencedDomainName is NULL and cchReferencedDomainName is the correct size
2142      */
2143
2144     user_size = UNLEN + 1;
2145     SetLastError(0xdeadbeef);
2146     ret = GetUserNameA(user_name, &user_size);
2147     ok(ret, "Failed to get user name : %d\n", GetLastError());
2148
2149     /* get sizes */
2150     sid_size = 0;
2151     domain_size = 0;
2152     sid_use = 0xcafebabe;
2153     SetLastError(0xdeadbeef);
2154     ret = LookupAccountNameA(NULL, user_name, NULL, &sid_size, NULL, &domain_size, &sid_use);
2155     if(!ret && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
2156     {
2157         win_skip("LookupAccountNameA is not implemented\n");
2158         return;
2159     }
2160     ok(!ret, "Expected 0, got %d\n", ret);
2161     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2162        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2163     ok(sid_size != 0, "Expected non-zero sid size\n");
2164     ok(domain_size != 0, "Expected non-zero domain size\n");
2165     ok(sid_use == 0xcafebabe, "Expected 0xcafebabe, got %d\n", sid_use);
2166
2167     sid_save = sid_size;
2168     domain_save = domain_size;
2169
2170     psid = HeapAlloc(GetProcessHeap(), 0, sid_size);
2171     domain = HeapAlloc(GetProcessHeap(), 0, domain_size);
2172
2173     /* try valid account name */
2174     ret = LookupAccountNameA(NULL, user_name, psid, &sid_size, domain, &domain_size, &sid_use);
2175     get_sid_info(psid, &account, &sid_dom);
2176     ok(ret, "Failed to lookup account name\n");
2177     ok(sid_size == GetLengthSid(psid), "Expected %d, got %d\n", GetLengthSid(psid), sid_size);
2178     ok(!lstrcmp(account, user_name), "Expected %s, got %s\n", user_name, account);
2179     ok(!lstrcmp(domain, sid_dom), "Expected %s, got %s\n", sid_dom, domain);
2180     ok(domain_size == domain_save - 1, "Expected %d, got %d\n", domain_save - 1, domain_size);
2181     ok(strlen(domain) == domain_size, "Expected %d, got %d\n", lstrlen(domain), domain_size);
2182     ok(sid_use == SidTypeUser, "Expected SidTypeUser (%d), got %d\n", SidTypeUser, sid_use);
2183     domain_size = domain_save;
2184     sid_size = sid_save;
2185
2186     if (PRIMARYLANGID(GetSystemDefaultLangID()) != LANG_ENGLISH)
2187     {
2188         skip("Non-English locale (test with hardcoded 'Everyone')\n");
2189     }
2190     else
2191     {
2192         ret = LookupAccountNameA(NULL, "Everyone", psid, &sid_size, domain, &domain_size, &sid_use);
2193         get_sid_info(psid, &account, &sid_dom);
2194         ok(ret, "Failed to lookup account name\n");
2195         ok(sid_size != 0, "sid_size was zero\n");
2196         ok(!lstrcmp(account, "Everyone"), "Expected Everyone, got %s\n", account);
2197         ok(!lstrcmp(domain, sid_dom), "Expected %s, got %s\n", sid_dom, domain);
2198         ok(domain_size == 0, "Expected 0, got %d\n", domain_size);
2199         ok(strlen(domain) == domain_size, "Expected %d, got %d\n", lstrlen(domain), domain_size);
2200         ok(sid_use == SidTypeWellKnownGroup, "Expected SidTypeWellKnownGroup (%d), got %d\n", SidTypeWellKnownGroup, sid_use);
2201         domain_size = domain_save;
2202     }
2203
2204     /* NULL Sid with zero sid size */
2205     SetLastError(0xdeadbeef);
2206     sid_size = 0;
2207     ret = LookupAccountNameA(NULL, user_name, NULL, &sid_size, domain, &domain_size, &sid_use);
2208     ok(!ret, "Expected 0, got %d\n", ret);
2209     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2210        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2211     ok(sid_size == sid_save, "Expected %d, got %d\n", sid_save, sid_size);
2212     ok(domain_size == domain_save, "Expected %d, got %d\n", domain_save, domain_size);
2213
2214     /* try cchReferencedDomainName - 1 */
2215     SetLastError(0xdeadbeef);
2216     domain_size--;
2217     ret = LookupAccountNameA(NULL, user_name, NULL, &sid_size, domain, &domain_size, &sid_use);
2218     ok(!ret, "Expected 0, got %d\n", ret);
2219     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2220        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2221     ok(sid_size == sid_save, "Expected %d, got %d\n", sid_save, sid_size);
2222     ok(domain_size == domain_save, "Expected %d, got %d\n", domain_save, domain_size);
2223
2224     /* NULL ReferencedDomainName with zero domain name size */
2225     SetLastError(0xdeadbeef);
2226     domain_size = 0;
2227     ret = LookupAccountNameA(NULL, user_name, psid, &sid_size, NULL, &domain_size, &sid_use);
2228     ok(!ret, "Expected 0, got %d\n", ret);
2229     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2230        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2231     ok(sid_size == sid_save, "Expected %d, got %d\n", sid_save, sid_size);
2232     ok(domain_size == domain_save, "Expected %d, got %d\n", domain_save, domain_size);
2233
2234     HeapFree(GetProcessHeap(), 0, psid);
2235     HeapFree(GetProcessHeap(), 0, domain);
2236
2237     /* get sizes for NULL account name */
2238     sid_size = 0;
2239     domain_size = 0;
2240     sid_use = 0xcafebabe;
2241     SetLastError(0xdeadbeef);
2242     ret = LookupAccountNameA(NULL, NULL, NULL, &sid_size, NULL, &domain_size, &sid_use);
2243     if (!ret && GetLastError() == ERROR_NONE_MAPPED)
2244         win_skip("NULL account name doesn't work on NT4\n");
2245     else
2246     {
2247         ok(!ret, "Expected 0, got %d\n", ret);
2248         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2249            "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2250         ok(sid_size != 0, "Expected non-zero sid size\n");
2251         ok(domain_size != 0, "Expected non-zero domain size\n");
2252         ok(sid_use == 0xcafebabe, "Expected 0xcafebabe, got %d\n", sid_use);
2253
2254         psid = HeapAlloc(GetProcessHeap(), 0, sid_size);
2255         domain = HeapAlloc(GetProcessHeap(), 0, domain_size);
2256
2257         /* try NULL account name */
2258         ret = LookupAccountNameA(NULL, NULL, psid, &sid_size, domain, &domain_size, &sid_use);
2259         get_sid_info(psid, &account, &sid_dom);
2260         ok(ret, "Failed to lookup account name\n");
2261         /* Using a fixed string will not work on different locales */
2262         ok(!lstrcmp(account, domain),
2263            "Got %s for account and %s for domain, these should be the same\n",
2264            account, domain);
2265         ok(sid_use == SidTypeDomain, "Expected SidTypeDomain (%d), got %d\n", SidTypeDomain, sid_use);
2266
2267         HeapFree(GetProcessHeap(), 0, psid);
2268         HeapFree(GetProcessHeap(), 0, domain);
2269     }
2270
2271     /* try an invalid account name */
2272     SetLastError(0xdeadbeef);
2273     sid_size = 0;
2274     domain_size = 0;
2275     ret = LookupAccountNameA(NULL, "oogabooga", NULL, &sid_size, NULL, &domain_size, &sid_use);
2276     ok(!ret, "Expected 0, got %d\n", ret);
2277     ok(GetLastError() == ERROR_NONE_MAPPED ||
2278        broken(GetLastError() == ERROR_TRUSTED_RELATIONSHIP_FAILURE),
2279        "Expected ERROR_NONE_MAPPED, got %d\n", GetLastError());
2280     ok(sid_size == 0, "Expected 0, got %d\n", sid_size);
2281     ok(domain_size == 0, "Expected 0, got %d\n", domain_size);
2282
2283     /* try an invalid system name */
2284     SetLastError(0xdeadbeef);
2285     sid_size = 0;
2286     domain_size = 0;
2287     ret = LookupAccountNameA("deepthought", NULL, NULL, &sid_size, NULL, &domain_size, &sid_use);
2288     ok(!ret, "Expected 0, got %d\n", ret);
2289     ok(GetLastError() == RPC_S_SERVER_UNAVAILABLE || GetLastError() == RPC_S_INVALID_NET_ADDR /* Vista */,
2290        "Expected RPC_S_SERVER_UNAVAILABLE or RPC_S_INVALID_NET_ADDR, got %d\n", GetLastError());
2291     ok(sid_size == 0, "Expected 0, got %d\n", sid_size);
2292     ok(domain_size == 0, "Expected 0, got %d\n", domain_size);
2293
2294     /* try with the computer name as the account name */
2295     domain_size = sizeof(computer_name);
2296     GetComputerNameA(computer_name, &domain_size);
2297     sid_size = 0;
2298     domain_size = 0;
2299     ret = LookupAccountNameA(NULL, computer_name, NULL, &sid_size, NULL, &domain_size, &sid_use);
2300     ok(!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER ||
2301        GetLastError() == ERROR_NONE_MAPPED /* in a domain */ ||
2302        broken(GetLastError() == ERROR_TRUSTED_DOMAIN_FAILURE) ||
2303        broken(GetLastError() == ERROR_TRUSTED_RELATIONSHIP_FAILURE)),
2304        "LookupAccountNameA failed: %d\n", GetLastError());
2305     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2306     {
2307         psid = HeapAlloc(GetProcessHeap(), 0, sid_size);
2308         domain = HeapAlloc(GetProcessHeap(), 0, domain_size);
2309         ret = LookupAccountNameA(NULL, computer_name, psid, &sid_size, domain, &domain_size, &sid_use);
2310         ok(ret, "LookupAccountNameA failed: %d\n", GetLastError());
2311         ok(sid_use == SidTypeDomain ||
2312            (sid_use == SidTypeUser && ! strcmp(computer_name, user_name)), "expected SidTypeDomain for %s, got %d\n", computer_name, sid_use);
2313         HeapFree(GetProcessHeap(), 0, domain);
2314         HeapFree(GetProcessHeap(), 0, psid);
2315     }
2316
2317     /* Well Known names */
2318     if (!pCreateWellKnownSid)
2319     {
2320         win_skip("CreateWellKnownSid not available\n");
2321         return;
2322     }
2323
2324     if (PRIMARYLANGID(GetSystemDefaultLangID()) != LANG_ENGLISH)
2325     {
2326         skip("Non-English locale (skipping well known name creation tests)\n");
2327         return;
2328     }
2329
2330     check_wellknown_name("LocalService", WinLocalServiceSid);
2331     check_wellknown_name("Local Service", WinLocalServiceSid);
2332     /* 2 spaces */
2333     check_wellknown_name("Local  Service", 0);
2334     check_wellknown_name("NetworkService", WinNetworkServiceSid);
2335     check_wellknown_name("Network Service", WinNetworkServiceSid);
2336
2337     /* example of some names where the spaces are not optional */
2338     check_wellknown_name("Terminal Server User", WinTerminalServerSid);
2339     check_wellknown_name("TerminalServer User", 0);
2340     check_wellknown_name("TerminalServerUser", 0);
2341     check_wellknown_name("Terminal ServerUser", 0);
2342
2343     check_wellknown_name("enterprise domain controllers",WinEnterpriseControllersSid);
2344     check_wellknown_name("enterprisedomain controllers", 0);
2345     check_wellknown_name("enterprise domaincontrollers", 0);
2346     check_wellknown_name("enterprisedomaincontrollers", 0);
2347
2348     /* case insensitivity */
2349     check_wellknown_name("lOCAlServICE", WinLocalServiceSid);
2350
2351     /* fully qualified account names */
2352     check_wellknown_name("NT AUTHORITY\\LocalService", WinLocalServiceSid);
2353     check_wellknown_name("nt authority\\Network Service", WinNetworkServiceSid);
2354     check_wellknown_name("nt authority test\\Network Service", 0);
2355     check_wellknown_name("Dummy\\Network Service", 0);
2356     check_wellknown_name("ntauthority\\Network Service", 0);
2357 }
2358
2359 static void test_security_descriptor(void)
2360 {
2361     SECURITY_DESCRIPTOR sd;
2362     char buf[8192];
2363     DWORD size;
2364     BOOL isDefault, isPresent, ret;
2365     PACL pacl;
2366     PSID psid;
2367
2368     SetLastError(0xdeadbeef);
2369     ret = InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
2370     if (ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2371     {
2372         win_skip("InitializeSecurityDescriptor is not implemented\n");
2373         return;
2374     }
2375
2376     ok(GetSecurityDescriptorOwner(&sd, &psid, &isDefault), "GetSecurityDescriptorOwner failed\n");
2377     expect_eq(psid, NULL, PSID, "%p");
2378     expect_eq(isDefault, FALSE, BOOL, "%d");
2379     sd.Control |= SE_DACL_PRESENT | SE_SACL_PRESENT;
2380
2381     SetLastError(0xdeadbeef);
2382     size = 5;
2383     expect_eq(MakeSelfRelativeSD(&sd, buf, &size), FALSE, BOOL, "%d");
2384     expect_eq(GetLastError(), ERROR_INSUFFICIENT_BUFFER, DWORD, "%u");
2385     ok(size > 5, "Size not increased\n");
2386     if (size <= 8192)
2387     {
2388         expect_eq(MakeSelfRelativeSD(&sd, buf, &size), TRUE, BOOL, "%d");
2389         ok(GetSecurityDescriptorOwner(&sd, &psid, &isDefault), "GetSecurityDescriptorOwner failed\n");
2390         expect_eq(psid, NULL, PSID, "%p");
2391         expect_eq(isDefault, FALSE, BOOL, "%d");
2392         ok(GetSecurityDescriptorGroup(&sd, &psid, &isDefault), "GetSecurityDescriptorGroup failed\n");
2393         expect_eq(psid, NULL, PSID, "%p");
2394         expect_eq(isDefault, FALSE, BOOL, "%d");
2395         ok(GetSecurityDescriptorDacl(&sd, &isPresent, &pacl, &isDefault), "GetSecurityDescriptorDacl failed\n");
2396         expect_eq(isPresent, TRUE, BOOL, "%d");
2397         expect_eq(psid, NULL, PSID, "%p");
2398         expect_eq(isDefault, FALSE, BOOL, "%d");
2399         ok(GetSecurityDescriptorSacl(&sd, &isPresent, &pacl, &isDefault), "GetSecurityDescriptorSacl failed\n");
2400         expect_eq(isPresent, TRUE, BOOL, "%d");
2401         expect_eq(psid, NULL, PSID, "%p");
2402         expect_eq(isDefault, FALSE, BOOL, "%d");
2403     }
2404 }
2405
2406 #define TEST_GRANTED_ACCESS(a,b) test_granted_access(a,b,0,__LINE__)
2407 #define TEST_GRANTED_ACCESS2(a,b,c) test_granted_access(a,b,c,__LINE__)
2408 static void test_granted_access(HANDLE handle, ACCESS_MASK access,
2409                                 ACCESS_MASK alt, int line)
2410 {
2411     OBJECT_BASIC_INFORMATION obj_info;
2412     NTSTATUS status;
2413
2414     if (!pNtQueryObject)
2415     {
2416         skip_(__FILE__, line)("Not NT platform - skipping tests\n");
2417         return;
2418     }
2419
2420     status = pNtQueryObject( handle, ObjectBasicInformation, &obj_info,
2421                              sizeof(obj_info), NULL );
2422     ok_(__FILE__, line)(!status, "NtQueryObject with err: %08x\n", status);
2423     if (alt)
2424         ok_(__FILE__, line)(obj_info.GrantedAccess == access ||
2425             obj_info.GrantedAccess == alt, "Granted access should be 0x%08x "
2426             "or 0x%08x, instead of 0x%08x\n", access, alt, obj_info.GrantedAccess);
2427     else
2428         ok_(__FILE__, line)(obj_info.GrantedAccess == access, "Granted access should "
2429             "be 0x%08x, instead of 0x%08x\n", access, obj_info.GrantedAccess);
2430 }
2431
2432 #define CHECK_SET_SECURITY(o,i,e) \
2433     do{ \
2434         BOOL res; \
2435         DWORD err; \
2436         SetLastError( 0xdeadbeef ); \
2437         res = SetKernelObjectSecurity( o, i, SecurityDescriptor ); \
2438         err = GetLastError(); \
2439         if (e == ERROR_SUCCESS) \
2440             ok(res, "SetKernelObjectSecurity failed with %d\n", err); \
2441         else \
2442             ok(!res && err == e, "SetKernelObjectSecurity should have failed " \
2443                "with %s, instead of %d\n", #e, err); \
2444     }while(0)
2445
2446 static void test_process_security(void)
2447 {
2448     BOOL res;
2449     PTOKEN_OWNER owner;
2450     PTOKEN_PRIMARY_GROUP group;
2451     PSID AdminSid = NULL, UsersSid = NULL;
2452     PACL Acl = NULL;
2453     SECURITY_DESCRIPTOR *SecurityDescriptor = NULL;
2454     char buffer[MAX_PATH];
2455     PROCESS_INFORMATION info;
2456     STARTUPINFOA startup;
2457     SECURITY_ATTRIBUTES psa;
2458     HANDLE token, event;
2459     DWORD size;
2460
2461     Acl = HeapAlloc(GetProcessHeap(), 0, 256);
2462     res = InitializeAcl(Acl, 256, ACL_REVISION);
2463     if (!res && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2464     {
2465         win_skip("ACLs not implemented - skipping tests\n");
2466         HeapFree(GetProcessHeap(), 0, Acl);
2467         return;
2468     }
2469     ok(res, "InitializeAcl failed with error %d\n", GetLastError());
2470
2471     /* get owner from the token we might be running as a user not admin */
2472     res = OpenProcessToken( GetCurrentProcess(), MAXIMUM_ALLOWED, &token );
2473     ok(res, "OpenProcessToken failed with error %d\n", GetLastError());
2474     if (!res)
2475     {
2476         HeapFree(GetProcessHeap(), 0, Acl);
2477         return;
2478     }
2479
2480     res = GetTokenInformation( token, TokenOwner, NULL, 0, &size );
2481     ok(!res, "Expected failure, got %d\n", res);
2482     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2483        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2484
2485     owner = HeapAlloc(GetProcessHeap(), 0, size);
2486     res = GetTokenInformation( token, TokenOwner, owner, size, &size );
2487     ok(res, "GetTokenInformation failed with error %d\n", GetLastError());
2488     AdminSid = ((TOKEN_OWNER*)owner)->Owner;
2489
2490     res = GetTokenInformation( token, TokenPrimaryGroup, NULL, 0, &size );
2491     ok(!res, "Expected failure, got %d\n", res);
2492     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2493        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2494
2495     group = HeapAlloc(GetProcessHeap(), 0, size);
2496     res = GetTokenInformation( token, TokenPrimaryGroup, group, size, &size );
2497     ok(res, "GetTokenInformation failed with error %d\n", GetLastError());
2498     UsersSid = ((TOKEN_PRIMARY_GROUP*)group)->PrimaryGroup;
2499
2500     CloseHandle( token );
2501     if (!res)
2502     {
2503         HeapFree(GetProcessHeap(), 0, group);
2504         HeapFree(GetProcessHeap(), 0, owner);
2505         HeapFree(GetProcessHeap(), 0, Acl);
2506         return;
2507     }
2508
2509     res = AddAccessDeniedAce(Acl, ACL_REVISION, PROCESS_VM_READ, AdminSid);
2510     ok(res, "AddAccessDeniedAce failed with error %d\n", GetLastError());
2511     res = AddAccessAllowedAce(Acl, ACL_REVISION, PROCESS_ALL_ACCESS, AdminSid);
2512     ok(res, "AddAccessAllowedAce failed with error %d\n", GetLastError());
2513
2514     SecurityDescriptor = HeapAlloc(GetProcessHeap(), 0, SECURITY_DESCRIPTOR_MIN_LENGTH);
2515     res = InitializeSecurityDescriptor(SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
2516     ok(res, "InitializeSecurityDescriptor failed with error %d\n", GetLastError());
2517
2518     event = CreateEvent( NULL, TRUE, TRUE, "test_event" );
2519     ok(event != NULL, "CreateEvent %d\n", GetLastError());
2520
2521     SecurityDescriptor->Revision = 0;
2522     CHECK_SET_SECURITY( event, OWNER_SECURITY_INFORMATION, ERROR_UNKNOWN_REVISION );
2523     SecurityDescriptor->Revision = SECURITY_DESCRIPTOR_REVISION;
2524
2525     CHECK_SET_SECURITY( event, OWNER_SECURITY_INFORMATION, ERROR_INVALID_SECURITY_DESCR );
2526     CHECK_SET_SECURITY( event, GROUP_SECURITY_INFORMATION, ERROR_INVALID_SECURITY_DESCR );
2527     CHECK_SET_SECURITY( event, SACL_SECURITY_INFORMATION, ERROR_ACCESS_DENIED );
2528     CHECK_SET_SECURITY( event, DACL_SECURITY_INFORMATION, ERROR_SUCCESS );
2529     /* NULL DACL is valid and means default DACL from token */
2530     SecurityDescriptor->Control |= SE_DACL_PRESENT;
2531     CHECK_SET_SECURITY( event, DACL_SECURITY_INFORMATION, ERROR_SUCCESS );
2532
2533     /* Set owner and group and dacl */
2534     res = SetSecurityDescriptorOwner(SecurityDescriptor, AdminSid, FALSE);
2535     ok(res, "SetSecurityDescriptorOwner failed with error %d\n", GetLastError());
2536     CHECK_SET_SECURITY( event, OWNER_SECURITY_INFORMATION, ERROR_SUCCESS );
2537     res = SetSecurityDescriptorGroup(SecurityDescriptor, UsersSid, FALSE);
2538     ok(res, "SetSecurityDescriptorGroup failed with error %d\n", GetLastError());
2539     CHECK_SET_SECURITY( event, GROUP_SECURITY_INFORMATION, ERROR_SUCCESS );
2540     res = SetSecurityDescriptorDacl(SecurityDescriptor, TRUE, Acl, FALSE);
2541     ok(res, "SetSecurityDescriptorDacl failed with error %d\n", GetLastError());
2542     CHECK_SET_SECURITY( event, DACL_SECURITY_INFORMATION, ERROR_SUCCESS );
2543
2544     sprintf(buffer, "%s tests/security.c test", myARGV[0]);
2545     memset(&startup, 0, sizeof(startup));
2546     startup.cb = sizeof(startup);
2547     startup.dwFlags = STARTF_USESHOWWINDOW;
2548     startup.wShowWindow = SW_SHOWNORMAL;
2549
2550     psa.nLength = sizeof(psa);
2551     psa.lpSecurityDescriptor = SecurityDescriptor;
2552     psa.bInheritHandle = TRUE;
2553
2554     /* Doesn't matter what ACL say we should get full access for ourselves */
2555     res = CreateProcessA( NULL, buffer, &psa, NULL, FALSE, 0, NULL, NULL, &startup, &info );
2556     ok(res, "CreateProcess with err:%d\n", GetLastError());
2557     TEST_GRANTED_ACCESS2( info.hProcess, PROCESS_ALL_ACCESS_NT4,
2558                           STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL );
2559     winetest_wait_child_process( info.hProcess );
2560
2561     CloseHandle( info.hProcess );
2562     CloseHandle( info.hThread );
2563     CloseHandle( event );
2564     HeapFree(GetProcessHeap(), 0, group);
2565     HeapFree(GetProcessHeap(), 0, owner);
2566     HeapFree(GetProcessHeap(), 0, Acl);
2567     HeapFree(GetProcessHeap(), 0, SecurityDescriptor);
2568 }
2569
2570 static void test_process_security_child(void)
2571 {
2572     HANDLE handle, handle1;
2573     BOOL ret;
2574     DWORD err;
2575
2576     handle = OpenProcess( PROCESS_TERMINATE, FALSE, GetCurrentProcessId() );
2577     ok(handle != NULL, "OpenProcess(PROCESS_TERMINATE) with err:%d\n", GetLastError());
2578     TEST_GRANTED_ACCESS( handle, PROCESS_TERMINATE );
2579
2580     ret = DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(),
2581                            &handle1, 0, TRUE, DUPLICATE_SAME_ACCESS );
2582     ok(ret, "duplicating handle err:%d\n", GetLastError());
2583     TEST_GRANTED_ACCESS( handle1, PROCESS_TERMINATE );
2584
2585     CloseHandle( handle1 );
2586
2587     SetLastError( 0xdeadbeef );
2588     ret = DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(),
2589                            &handle1, PROCESS_ALL_ACCESS, TRUE, 0 );
2590     err = GetLastError();
2591     todo_wine
2592     ok(!ret && err == ERROR_ACCESS_DENIED, "duplicating handle should have failed "
2593        "with STATUS_ACCESS_DENIED, instead of err:%d\n", err);
2594
2595     CloseHandle( handle );
2596
2597     /* These two should fail - they are denied by ACL */
2598     handle = OpenProcess( PROCESS_VM_READ, FALSE, GetCurrentProcessId() );
2599     todo_wine
2600     ok(handle == NULL, "OpenProcess(PROCESS_VM_READ) should have failed\n");
2601     handle = OpenProcess( PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId() );
2602     todo_wine
2603     ok(handle == NULL, "OpenProcess(PROCESS_ALL_ACCESS) should have failed\n");
2604
2605     /* Documented privilege elevation */
2606     ret = DuplicateHandle( GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(),
2607                            &handle, 0, TRUE, DUPLICATE_SAME_ACCESS );
2608     ok(ret, "duplicating handle err:%d\n", GetLastError());
2609     TEST_GRANTED_ACCESS2( handle, PROCESS_ALL_ACCESS_NT4,
2610                           STANDARD_RIGHTS_ALL | SPECIFIC_RIGHTS_ALL );
2611
2612     CloseHandle( handle );
2613
2614     /* Same only explicitly asking for all access rights */
2615     ret = DuplicateHandle( GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(),
2616                            &handle, PROCESS_ALL_ACCESS, TRUE, 0 );
2617     ok(ret, "duplicating handle err:%d\n", GetLastError());
2618     TEST_GRANTED_ACCESS2( handle, PROCESS_ALL_ACCESS_NT4,
2619                           PROCESS_ALL_ACCESS | PROCESS_QUERY_LIMITED_INFORMATION );
2620     ret = DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(),
2621                            &handle1, PROCESS_VM_READ, TRUE, 0 );
2622     ok(ret, "duplicating handle err:%d\n", GetLastError());
2623     TEST_GRANTED_ACCESS( handle1, PROCESS_VM_READ );
2624     CloseHandle( handle1 );
2625     CloseHandle( handle );
2626 }
2627
2628 static void test_impersonation_level(void)
2629 {
2630     HANDLE Token, ProcessToken;
2631     HANDLE Token2;
2632     DWORD Size;
2633     TOKEN_PRIVILEGES *Privileges;
2634     TOKEN_USER *User;
2635     PRIVILEGE_SET *PrivilegeSet;
2636     BOOL AccessGranted;
2637     BOOL ret;
2638     HKEY hkey;
2639     DWORD error;
2640
2641     pDuplicateTokenEx = (void *)GetProcAddress(hmod, "DuplicateTokenEx");
2642     if( !pDuplicateTokenEx ) {
2643         win_skip("DuplicateTokenEx is not available\n");
2644         return;
2645     }
2646     SetLastError(0xdeadbeef);
2647     ret = ImpersonateSelf(SecurityAnonymous);
2648     if(!ret && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
2649     {
2650         win_skip("ImpersonateSelf is not implemented\n");
2651         return;
2652     }
2653     ok(ret, "ImpersonateSelf(SecurityAnonymous) failed with error %d\n", GetLastError());
2654     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY_SOURCE | TOKEN_IMPERSONATE | TOKEN_ADJUST_DEFAULT, TRUE, &Token);
2655     ok(!ret, "OpenThreadToken should have failed\n");
2656     error = GetLastError();
2657     ok(error == ERROR_CANT_OPEN_ANONYMOUS, "OpenThreadToken on anonymous token should have returned ERROR_CANT_OPEN_ANONYMOUS instead of %d\n", error);
2658     /* can't perform access check when opening object against an anonymous impersonation token */
2659     todo_wine {
2660     error = RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ, &hkey);
2661     ok(error == ERROR_INVALID_HANDLE || error == ERROR_CANT_OPEN_ANONYMOUS,
2662        "RegOpenKeyEx should have failed with ERROR_INVALID_HANDLE or ERROR_CANT_OPEN_ANONYMOUS instead of %d\n", error);
2663     }
2664     RevertToSelf();
2665
2666     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE, &ProcessToken);
2667     ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
2668
2669     ret = pDuplicateTokenEx(ProcessToken,
2670         TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE, NULL,
2671         SecurityAnonymous, TokenImpersonation, &Token);
2672     ok(ret, "DuplicateTokenEx failed with error %d\n", GetLastError());
2673     /* can't increase the impersonation level */
2674     ret = DuplicateToken(Token, SecurityIdentification, &Token2);
2675     error = GetLastError();
2676     ok(!ret && error == ERROR_BAD_IMPERSONATION_LEVEL,
2677         "Duplicating a token and increasing the impersonation level should have failed with ERROR_BAD_IMPERSONATION_LEVEL instead of %d\n", error);
2678     /* we can query anything from an anonymous token, including the user */
2679     ret = GetTokenInformation(Token, TokenUser, NULL, 0, &Size);
2680     error = GetLastError();
2681     ok(!ret && error == ERROR_INSUFFICIENT_BUFFER, "GetTokenInformation(TokenUser) should have failed with ERROR_INSUFFICIENT_BUFFER instead of %d\n", error);
2682     User = HeapAlloc(GetProcessHeap(), 0, Size);
2683     ret = GetTokenInformation(Token, TokenUser, User, Size, &Size);
2684     ok(ret, "GetTokenInformation(TokenUser) failed with error %d\n", GetLastError());
2685     HeapFree(GetProcessHeap(), 0, User);
2686
2687     /* PrivilegeCheck fails with SecurityAnonymous level */
2688     ret = GetTokenInformation(Token, TokenPrivileges, NULL, 0, &Size);
2689     error = GetLastError();
2690     ok(!ret && error == ERROR_INSUFFICIENT_BUFFER, "GetTokenInformation(TokenPrivileges) should have failed with ERROR_INSUFFICIENT_BUFFER instead of %d\n", error);
2691     Privileges = HeapAlloc(GetProcessHeap(), 0, Size);
2692     ret = GetTokenInformation(Token, TokenPrivileges, Privileges, Size, &Size);
2693     ok(ret, "GetTokenInformation(TokenPrivileges) failed with error %d\n", GetLastError());
2694
2695     PrivilegeSet = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(PRIVILEGE_SET, Privilege[Privileges->PrivilegeCount]));
2696     PrivilegeSet->PrivilegeCount = Privileges->PrivilegeCount;
2697     memcpy(PrivilegeSet->Privilege, Privileges->Privileges, PrivilegeSet->PrivilegeCount * sizeof(PrivilegeSet->Privilege[0]));
2698     PrivilegeSet->Control = PRIVILEGE_SET_ALL_NECESSARY;
2699     HeapFree(GetProcessHeap(), 0, Privileges);
2700
2701     ret = PrivilegeCheck(Token, PrivilegeSet, &AccessGranted);
2702     error = GetLastError();
2703     ok(!ret && error == ERROR_BAD_IMPERSONATION_LEVEL, "PrivilegeCheck for SecurityAnonymous token should have failed with ERROR_BAD_IMPERSONATION_LEVEL instead of %d\n", error);
2704
2705     CloseHandle(Token);
2706
2707     ret = ImpersonateSelf(SecurityIdentification);
2708     ok(ret, "ImpersonateSelf(SecurityIdentification) failed with error %d\n", GetLastError());
2709     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY_SOURCE | TOKEN_IMPERSONATE | TOKEN_ADJUST_DEFAULT, TRUE, &Token);
2710     ok(ret, "OpenThreadToken failed with error %d\n", GetLastError());
2711
2712     /* can't perform access check when opening object against an identification impersonation token */
2713     error = RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ, &hkey);
2714     todo_wine {
2715     ok(error == ERROR_INVALID_HANDLE || error == ERROR_BAD_IMPERSONATION_LEVEL,
2716        "RegOpenKeyEx should have failed with ERROR_INVALID_HANDLE or ERROR_BAD_IMPERSONATION_LEVEL instead of %d\n", error);
2717     }
2718     ret = PrivilegeCheck(Token, PrivilegeSet, &AccessGranted);
2719     ok(ret, "PrivilegeCheck for SecurityIdentification failed with error %d\n", GetLastError());
2720     CloseHandle(Token);
2721     RevertToSelf();
2722
2723     ret = ImpersonateSelf(SecurityImpersonation);
2724     ok(ret, "ImpersonateSelf(SecurityImpersonation) failed with error %d\n", GetLastError());
2725     ret = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY_SOURCE | TOKEN_IMPERSONATE | TOKEN_ADJUST_DEFAULT, TRUE, &Token);
2726     ok(ret, "OpenThreadToken failed with error %d\n", GetLastError());
2727     error = RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ, &hkey);
2728     ok(error == ERROR_SUCCESS, "RegOpenKeyEx should have succeeded instead of failing with %d\n", error);
2729     RegCloseKey(hkey);
2730     ret = PrivilegeCheck(Token, PrivilegeSet, &AccessGranted);
2731     ok(ret, "PrivilegeCheck for SecurityImpersonation failed with error %d\n", GetLastError());
2732     RevertToSelf();
2733
2734     CloseHandle(Token);
2735     CloseHandle(ProcessToken);
2736
2737     HeapFree(GetProcessHeap(), 0, PrivilegeSet);
2738 }
2739
2740 static void test_SetEntriesInAclW(void)
2741 {
2742     DWORD res;
2743     PSID EveryoneSid = NULL, UsersSid = NULL;
2744     PACL OldAcl = NULL, NewAcl;
2745     SID_IDENTIFIER_AUTHORITY SIDAuthWorld = { SECURITY_WORLD_SID_AUTHORITY };
2746     SID_IDENTIFIER_AUTHORITY SIDAuthNT = { SECURITY_NT_AUTHORITY };
2747     EXPLICIT_ACCESSW ExplicitAccess;
2748     static const WCHAR wszEveryone[] = {'E','v','e','r','y','o','n','e',0};
2749     static const WCHAR wszCurrentUser[] = { 'C','U','R','R','E','N','T','_','U','S','E','R','\0'};
2750
2751     if (!pSetEntriesInAclW)
2752     {
2753         win_skip("SetEntriesInAclW is not available\n");
2754         return;
2755     }
2756
2757     NewAcl = (PACL)0xdeadbeef;
2758     res = pSetEntriesInAclW(0, NULL, NULL, &NewAcl);
2759     if(res == ERROR_CALL_NOT_IMPLEMENTED)
2760     {
2761         win_skip("SetEntriesInAclW is not implemented\n");
2762         return;
2763     }
2764     ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2765     ok(NewAcl == NULL ||
2766         broken(NewAcl != NULL), /* NT4 */
2767         "NewAcl=%p, expected NULL\n", NewAcl);
2768     LocalFree(NewAcl);
2769
2770     OldAcl = HeapAlloc(GetProcessHeap(), 0, 256);
2771     res = InitializeAcl(OldAcl, 256, ACL_REVISION);
2772     if(!res && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2773     {
2774         win_skip("ACLs not implemented - skipping tests\n");
2775         HeapFree(GetProcessHeap(), 0, OldAcl);
2776         return;
2777     }
2778     ok(res, "InitializeAcl failed with error %d\n", GetLastError());
2779
2780     res = AllocateAndInitializeSid( &SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &EveryoneSid);
2781     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
2782
2783     res = AllocateAndInitializeSid( &SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
2784         DOMAIN_ALIAS_RID_USERS, 0, 0, 0, 0, 0, 0, &UsersSid);
2785     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
2786
2787     res = AddAccessAllowedAce(OldAcl, ACL_REVISION, KEY_READ, UsersSid);
2788     ok(res, "AddAccessAllowedAce failed with error %d\n", GetLastError());
2789
2790     ExplicitAccess.grfAccessPermissions = KEY_WRITE;
2791     ExplicitAccess.grfAccessMode = GRANT_ACCESS;
2792     ExplicitAccess.grfInheritance = NO_INHERITANCE;
2793     ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
2794     ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_SID;
2795     ExplicitAccess.Trustee.ptstrName = EveryoneSid;
2796     ExplicitAccess.Trustee.MultipleTrusteeOperation = 0xDEADBEEF;
2797     ExplicitAccess.Trustee.pMultipleTrustee = (PVOID)0xDEADBEEF;
2798     res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2799     ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2800     ok(NewAcl != NULL, "returned acl was NULL\n");
2801     LocalFree(NewAcl);
2802
2803     ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_UNKNOWN;
2804     ExplicitAccess.Trustee.pMultipleTrustee = NULL;
2805     ExplicitAccess.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2806     res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2807     ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2808     ok(NewAcl != NULL, "returned acl was NULL\n");
2809     LocalFree(NewAcl);
2810
2811     if (PRIMARYLANGID(GetSystemDefaultLangID()) != LANG_ENGLISH)
2812     {
2813         skip("Non-English locale (test with hardcoded 'Everyone')\n");
2814     }
2815     else
2816     {
2817         ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2818         ExplicitAccess.Trustee.ptstrName = (LPWSTR)wszEveryone;
2819         res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2820         ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2821         ok(NewAcl != NULL, "returned acl was NULL\n");
2822         LocalFree(NewAcl);
2823
2824         ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_BAD_FORM;
2825         res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2826         ok(res == ERROR_INVALID_PARAMETER ||
2827             broken(res == ERROR_NOT_SUPPORTED), /* NT4 */
2828             "SetEntriesInAclW failed: %u\n", res);
2829         ok(NewAcl == NULL ||
2830             broken(NewAcl != NULL), /* NT4 */
2831             "returned acl wasn't NULL: %p\n", NewAcl);
2832
2833         ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2834         ExplicitAccess.Trustee.MultipleTrusteeOperation = TRUSTEE_IS_IMPERSONATE;
2835         res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2836         ok(res == ERROR_INVALID_PARAMETER ||
2837             broken(res == ERROR_NOT_SUPPORTED), /* NT4 */
2838             "SetEntriesInAclW failed: %u\n", res);
2839         ok(NewAcl == NULL ||
2840             broken(NewAcl != NULL), /* NT4 */
2841             "returned acl wasn't NULL: %p\n", NewAcl);
2842
2843         ExplicitAccess.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2844         ExplicitAccess.grfAccessMode = SET_ACCESS;
2845         res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2846         ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2847         ok(NewAcl != NULL, "returned acl was NULL\n");
2848         LocalFree(NewAcl);
2849     }
2850
2851     ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2852     ExplicitAccess.Trustee.ptstrName = (LPWSTR)wszCurrentUser;
2853     res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2854     ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2855     ok(NewAcl != NULL, "returned acl was NULL\n");
2856     LocalFree(NewAcl);
2857
2858     ExplicitAccess.grfAccessMode = REVOKE_ACCESS;
2859     ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_SID;
2860     ExplicitAccess.Trustee.ptstrName = UsersSid;
2861     res = pSetEntriesInAclW(1, &ExplicitAccess, OldAcl, &NewAcl);
2862     ok(res == ERROR_SUCCESS, "SetEntriesInAclW failed: %u\n", res);
2863     ok(NewAcl != NULL, "returned acl was NULL\n");
2864     LocalFree(NewAcl);
2865
2866     FreeSid(UsersSid);
2867     FreeSid(EveryoneSid);
2868     HeapFree(GetProcessHeap(), 0, OldAcl);
2869 }
2870
2871 static void test_SetEntriesInAclA(void)
2872 {
2873     DWORD res;
2874     PSID EveryoneSid = NULL, UsersSid = NULL;
2875     PACL OldAcl = NULL, NewAcl;
2876     SID_IDENTIFIER_AUTHORITY SIDAuthWorld = { SECURITY_WORLD_SID_AUTHORITY };
2877     SID_IDENTIFIER_AUTHORITY SIDAuthNT = { SECURITY_NT_AUTHORITY };
2878     EXPLICIT_ACCESS ExplicitAccess;
2879     static const CHAR szEveryone[] = {'E','v','e','r','y','o','n','e',0};
2880     static const CHAR szCurrentUser[] = { 'C','U','R','R','E','N','T','_','U','S','E','R','\0'};
2881
2882     if (!pSetEntriesInAclA)
2883     {
2884         win_skip("SetEntriesInAclA is not available\n");
2885         return;
2886     }
2887
2888     NewAcl = (PACL)0xdeadbeef;
2889     res = pSetEntriesInAclA(0, NULL, NULL, &NewAcl);
2890     if(res == ERROR_CALL_NOT_IMPLEMENTED)
2891     {
2892         win_skip("SetEntriesInAclA is not implemented\n");
2893         return;
2894     }
2895     ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2896     ok(NewAcl == NULL ||
2897         broken(NewAcl != NULL), /* NT4 */
2898         "NewAcl=%p, expected NULL\n", NewAcl);
2899     LocalFree(NewAcl);
2900
2901     OldAcl = HeapAlloc(GetProcessHeap(), 0, 256);
2902     res = InitializeAcl(OldAcl, 256, ACL_REVISION);
2903     if(!res && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2904     {
2905         win_skip("ACLs not implemented - skipping tests\n");
2906         HeapFree(GetProcessHeap(), 0, OldAcl);
2907         return;
2908     }
2909     ok(res, "InitializeAcl failed with error %d\n", GetLastError());
2910
2911     res = AllocateAndInitializeSid( &SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &EveryoneSid);
2912     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
2913
2914     res = AllocateAndInitializeSid( &SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
2915         DOMAIN_ALIAS_RID_USERS, 0, 0, 0, 0, 0, 0, &UsersSid);
2916     ok(res, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
2917
2918     res = AddAccessAllowedAce(OldAcl, ACL_REVISION, KEY_READ, UsersSid);
2919     ok(res, "AddAccessAllowedAce failed with error %d\n", GetLastError());
2920
2921     ExplicitAccess.grfAccessPermissions = KEY_WRITE;
2922     ExplicitAccess.grfAccessMode = GRANT_ACCESS;
2923     ExplicitAccess.grfInheritance = NO_INHERITANCE;
2924     ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
2925     ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_SID;
2926     ExplicitAccess.Trustee.ptstrName = EveryoneSid;
2927     ExplicitAccess.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2928     ExplicitAccess.Trustee.pMultipleTrustee = NULL;
2929     res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2930     ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2931     ok(NewAcl != NULL, "returned acl was NULL\n");
2932     LocalFree(NewAcl);
2933
2934     ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_UNKNOWN;
2935     ExplicitAccess.Trustee.pMultipleTrustee = NULL;
2936     ExplicitAccess.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2937     res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2938     ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2939     ok(NewAcl != NULL, "returned acl was NULL\n");
2940     LocalFree(NewAcl);
2941
2942     if (PRIMARYLANGID(GetSystemDefaultLangID()) != LANG_ENGLISH)
2943     {
2944         skip("Non-English locale (test with hardcoded 'Everyone')\n");
2945     }
2946     else
2947     {
2948         ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2949         ExplicitAccess.Trustee.ptstrName = (LPSTR)szEveryone;
2950         res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2951         ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2952         ok(NewAcl != NULL, "returned acl was NULL\n");
2953         LocalFree(NewAcl);
2954
2955         ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_BAD_FORM;
2956         res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2957         ok(res == ERROR_INVALID_PARAMETER ||
2958             broken(res == ERROR_NOT_SUPPORTED), /* NT4 */
2959             "SetEntriesInAclA failed: %u\n", res);
2960         ok(NewAcl == NULL ||
2961             broken(NewAcl != NULL), /* NT4 */
2962             "returned acl wasn't NULL: %p\n", NewAcl);
2963
2964         ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2965         ExplicitAccess.Trustee.MultipleTrusteeOperation = TRUSTEE_IS_IMPERSONATE;
2966         res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2967         ok(res == ERROR_INVALID_PARAMETER ||
2968             broken(res == ERROR_NOT_SUPPORTED), /* NT4 */
2969             "SetEntriesInAclA failed: %u\n", res);
2970         ok(NewAcl == NULL ||
2971             broken(NewAcl != NULL), /* NT4 */
2972             "returned acl wasn't NULL: %p\n", NewAcl);
2973
2974         ExplicitAccess.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2975         ExplicitAccess.grfAccessMode = SET_ACCESS;
2976         res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2977         ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2978         ok(NewAcl != NULL, "returned acl was NULL\n");
2979         LocalFree(NewAcl);
2980     }
2981
2982     ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2983     ExplicitAccess.Trustee.ptstrName = (LPSTR)szCurrentUser;
2984     res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2985     ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2986     ok(NewAcl != NULL, "returned acl was NULL\n");
2987     LocalFree(NewAcl);
2988
2989     ExplicitAccess.grfAccessMode = REVOKE_ACCESS;
2990     ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_SID;
2991     ExplicitAccess.Trustee.ptstrName = UsersSid;
2992     res = pSetEntriesInAclA(1, &ExplicitAccess, OldAcl, &NewAcl);
2993     ok(res == ERROR_SUCCESS, "SetEntriesInAclA failed: %u\n", res);
2994     ok(NewAcl != NULL, "returned acl was NULL\n");
2995     LocalFree(NewAcl);
2996
2997     FreeSid(UsersSid);
2998     FreeSid(EveryoneSid);
2999     HeapFree(GetProcessHeap(), 0, OldAcl);
3000 }
3001
3002 static void test_GetNamedSecurityInfoA(void)
3003 {
3004     PSECURITY_DESCRIPTOR pSecDesc;
3005     DWORD revision;
3006     SECURITY_DESCRIPTOR_CONTROL control;
3007     PSID owner;
3008     PSID group;
3009     PACL dacl;
3010     BOOL owner_defaulted;
3011     BOOL group_defaulted;
3012     DWORD error;
3013     BOOL ret, isNT4;
3014     CHAR windows_dir[MAX_PATH];
3015
3016     if (!pGetNamedSecurityInfoA)
3017     {
3018         win_skip("GetNamedSecurityInfoA is not available\n");
3019         return;
3020     }
3021
3022     ret = GetWindowsDirectoryA(windows_dir, MAX_PATH);
3023     ok(ret, "GetWindowsDirectory failed with error %d\n", GetLastError());
3024
3025     SetLastError(0xdeadbeef);
3026     error = pGetNamedSecurityInfoA(windows_dir, SE_FILE_OBJECT,
3027         OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION,
3028         NULL, NULL, NULL, NULL, &pSecDesc);
3029     if (error != ERROR_SUCCESS && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
3030     {
3031         win_skip("GetNamedSecurityInfoA is not implemented\n");
3032         return;
3033     }
3034     ok(!error, "GetNamedSecurityInfo failed with error %d\n", error);
3035
3036     ret = GetSecurityDescriptorControl(pSecDesc, &control, &revision);
3037     ok(ret, "GetSecurityDescriptorControl failed with error %d\n", GetLastError());
3038     ok((control & (SE_SELF_RELATIVE|SE_DACL_PRESENT)) == (SE_SELF_RELATIVE|SE_DACL_PRESENT) ||
3039         broken((control & (SE_SELF_RELATIVE|SE_DACL_PRESENT)) == SE_DACL_PRESENT), /* NT4 */
3040         "control (0x%x) doesn't have (SE_SELF_RELATIVE|SE_DACL_PRESENT) flags set\n", control);
3041     ok(revision == SECURITY_DESCRIPTOR_REVISION1, "revision was %d instead of 1\n", revision);
3042
3043     isNT4 = (control & (SE_SELF_RELATIVE|SE_DACL_PRESENT)) == SE_DACL_PRESENT;
3044
3045     ret = GetSecurityDescriptorOwner(pSecDesc, &owner, &owner_defaulted);
3046     ok(ret, "GetSecurityDescriptorOwner failed with error %d\n", GetLastError());
3047     ok(owner != NULL, "owner should not be NULL\n");
3048
3049     ret = GetSecurityDescriptorGroup(pSecDesc, &group, &group_defaulted);
3050     ok(ret, "GetSecurityDescriptorGroup failed with error %d\n", GetLastError());
3051     ok(group != NULL, "group should not be NULL\n");
3052     LocalFree(pSecDesc);
3053
3054
3055     /* NULL descriptor tests */
3056     if(isNT4)
3057     {
3058         win_skip("NT4 does not support GetNamedSecutityInfo with a NULL descriptor\n");
3059         return;
3060     }
3061
3062     error = pGetNamedSecurityInfoA(windows_dir, SE_FILE_OBJECT,DACL_SECURITY_INFORMATION,
3063         NULL, NULL, NULL, NULL, NULL);
3064     ok(error==ERROR_INVALID_PARAMETER, "GetNamedSecurityInfo failed with error %d\n", error);
3065
3066     error = pGetNamedSecurityInfoA(windows_dir, SE_FILE_OBJECT,DACL_SECURITY_INFORMATION,
3067         NULL, NULL, &dacl, NULL, NULL);
3068     ok(!error, "GetNamedSecurityInfo failed with error %d\n", error);
3069     ok(dacl != NULL, "dacl should not be NULL\n");
3070
3071     error = pGetNamedSecurityInfoA(windows_dir, SE_FILE_OBJECT,OWNER_SECURITY_INFORMATION,
3072         NULL, NULL, &dacl, NULL, NULL);
3073     ok(error==ERROR_INVALID_PARAMETER, "GetNamedSecurityInfo failed with error %d\n", error);
3074 }
3075
3076 static void test_ConvertStringSecurityDescriptor(void)
3077 {
3078     BOOL ret;
3079     PSECURITY_DESCRIPTOR pSD;
3080     static const WCHAR Blank[] = { 0 };
3081     unsigned int i;
3082     static const struct
3083     {
3084         const char *sidstring;
3085         DWORD      revision;
3086         BOOL       ret;
3087         DWORD      GLE;
3088         DWORD      altGLE;
3089     } cssd[] =
3090     {
3091         { "D:(A;;GA;;;WD)",                  0xdeadbeef,      FALSE, ERROR_UNKNOWN_REVISION },
3092         /* test ACE string type */
3093         { "D:(A;;GA;;;WD)",                  SDDL_REVISION_1, TRUE },
3094         { "D:(D;;GA;;;WD)",                  SDDL_REVISION_1, TRUE },
3095         { "ERROR:(D;;GA;;;WD)",              SDDL_REVISION_1, FALSE, ERROR_INVALID_PARAMETER },
3096         /* test ACE string with spaces */
3097         { " D:(D;;GA;;;WD)",                SDDL_REVISION_1, TRUE },
3098         { "D: (D;;GA;;;WD)",                SDDL_REVISION_1, TRUE },
3099         { "D:( D;;GA;;;WD)",                SDDL_REVISION_1, TRUE },
3100         { "D:(D ;;GA;;;WD)",                SDDL_REVISION_1, FALSE, RPC_S_INVALID_STRING_UUID, ERROR_INVALID_ACL }, /* Vista+ */
3101         { "D:(D; ;GA;;;WD)",                SDDL_REVISION_1, TRUE },
3102         { "D:(D;; GA;;;WD)",                SDDL_REVISION_1, TRUE },
3103         { "D:(D;;GA ;;;WD)",                SDDL_REVISION_1, FALSE, ERROR_INVALID_ACL },
3104         { "D:(D;;GA; ;;WD)",                SDDL_REVISION_1, TRUE },
3105         { "D:(D;;GA;; ;WD)",                SDDL_REVISION_1, TRUE },
3106         { "D:(D;;GA;;; WD)",                SDDL_REVISION_1, TRUE },
3107         { "D:(D;;GA;;;WD )",                SDDL_REVISION_1, TRUE },
3108         /* test ACE string access rights */
3109         { "D:(A;;GA;;;WD)",                  SDDL_REVISION_1, TRUE },
3110         { "D:(A;;GRGWGX;;;WD)",              SDDL_REVISION_1, TRUE },
3111         { "D:(A;;RCSDWDWO;;;WD)",            SDDL_REVISION_1, TRUE },
3112         { "D:(A;;RPWPCCDCLCSWLODTCR;;;WD)",  SDDL_REVISION_1, TRUE },
3113         { "D:(A;;FAFRFWFX;;;WD)",            SDDL_REVISION_1, TRUE },
3114         { "D:(A;;KAKRKWKX;;;WD)",            SDDL_REVISION_1, TRUE },
3115         { "D:(A;;0xFFFFFFFF;;;WD)",          SDDL_REVISION_1, TRUE },
3116         { "S:(AU;;0xFFFFFFFF;;;WD)",         SDDL_REVISION_1, TRUE },
3117         /* test ACE string access right error case */
3118         { "D:(A;;ROB;;;WD)",                 SDDL_REVISION_1, FALSE, ERROR_INVALID_ACL },
3119         /* test behaviour with empty strings */
3120         { "",                                SDDL_REVISION_1, TRUE },
3121         /* test ACE string SID */
3122         { "D:(D;;GA;;;S-1-0-0)",             SDDL_REVISION_1, TRUE },
3123         { "D:(D;;GA;;;Nonexistent account)", SDDL_REVISION_1, FALSE, ERROR_INVALID_ACL, ERROR_INVALID_SID } /* W2K */
3124     };
3125
3126     if (!pConvertStringSecurityDescriptorToSecurityDescriptorA)
3127     {
3128         win_skip("ConvertStringSecurityDescriptorToSecurityDescriptor is not available\n");
3129         return;
3130     }
3131
3132     for (i = 0; i < sizeof(cssd)/sizeof(cssd[0]); i++)
3133     {
3134         DWORD GLE;
3135
3136         SetLastError(0xdeadbeef);
3137         ret = pConvertStringSecurityDescriptorToSecurityDescriptorA(
3138             cssd[i].sidstring, cssd[i].revision, &pSD, NULL);
3139         GLE = GetLastError();
3140         ok(ret == cssd[i].ret, "(%02u) Expected %s (%d)\n", i, cssd[i].ret ? "success" : "failure", GLE);
3141         if (!cssd[i].ret)
3142             ok(GLE == cssd[i].GLE ||
3143                (cssd[i].altGLE && GLE == cssd[i].altGLE),
3144                "(%02u) Unexpected last error %d\n", i, GLE);
3145         if (ret)
3146             LocalFree(pSD);
3147     }
3148
3149     /* test behaviour with NULL parameters */
3150     SetLastError(0xdeadbeef);
3151     ret = pConvertStringSecurityDescriptorToSecurityDescriptorA(
3152         NULL, 0xdeadbeef, &pSD, NULL);
3153     todo_wine
3154     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
3155         "ConvertStringSecurityDescriptorToSecurityDescriptor should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
3156         GetLastError());
3157
3158     SetLastError(0xdeadbeef);
3159     ret = pConvertStringSecurityDescriptorToSecurityDescriptorW(
3160         NULL, 0xdeadbeef, &pSD, NULL);
3161     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
3162         "ConvertStringSecurityDescriptorToSecurityDescriptor should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
3163         GetLastError());
3164
3165     SetLastError(0xdeadbeef);
3166     ret = pConvertStringSecurityDescriptorToSecurityDescriptorA(
3167         "D:(A;;ROB;;;WD)", 0xdeadbeef, NULL, NULL);
3168     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
3169         "ConvertStringSecurityDescriptorToSecurityDescriptor should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
3170         GetLastError());
3171
3172     SetLastError(0xdeadbeef);
3173     ret = pConvertStringSecurityDescriptorToSecurityDescriptorA(
3174         "D:(A;;ROB;;;WD)", SDDL_REVISION_1, NULL, NULL);
3175     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
3176         "ConvertStringSecurityDescriptorToSecurityDescriptor should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
3177         GetLastError());
3178
3179     /* test behaviour with empty strings */
3180     SetLastError(0xdeadbeef);
3181     ret = pConvertStringSecurityDescriptorToSecurityDescriptorW(
3182         Blank, SDDL_REVISION_1, &pSD, NULL);
3183     ok(ret, "ConvertStringSecurityDescriptorToSecurityDescriptor failed with error %d\n", GetLastError());
3184     LocalFree(pSD);
3185 }
3186
3187 static void test_ConvertSecurityDescriptorToString(void)
3188 {
3189     SECURITY_DESCRIPTOR desc;
3190     SECURITY_INFORMATION sec_info = OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION|SACL_SECURITY_INFORMATION;
3191     LPSTR string;
3192     DWORD size;
3193     PSID psid, psid2;
3194     PACL pacl;
3195     char sid_buf[256];
3196     char acl_buf[8192];
3197     ULONG len;
3198
3199     if (!pConvertSecurityDescriptorToStringSecurityDescriptorA)
3200     {
3201         win_skip("ConvertSecurityDescriptorToStringSecurityDescriptor is not available\n");
3202         return;
3203     }
3204     if (!pCreateWellKnownSid)
3205     {
3206         win_skip("CreateWellKnownSid is not available\n");
3207         return;
3208     }
3209
3210 /* It seems Windows XP adds an extra character to the length of the string for each ACE in an ACL. We
3211  * don't replicate this feature so we only test len >= strlen+1. */
3212 #define CHECK_RESULT_AND_FREE(exp_str) \
3213     ok(strcmp(string, (exp_str)) == 0, "String mismatch (expected \"%s\", got \"%s\")\n", (exp_str), string); \
3214     ok(len >= (strlen(exp_str) + 1), "Length mismatch (expected %d, got %d)\n", lstrlen(exp_str) + 1, len); \
3215     LocalFree(string);
3216
3217 #define CHECK_ONE_OF_AND_FREE(exp_str1, exp_str2) \
3218     ok(strcmp(string, (exp_str1)) == 0 || strcmp(string, (exp_str2)) == 0, "String mismatch (expected\n\"%s\" or\n\"%s\", got\n\"%s\")\n", (exp_str1), (exp_str2), string); \
3219     ok(len >= (strlen(exp_str1) + 1) || len >= (strlen(exp_str2) + 1), "Length mismatch (expected %d or %d, got %d)\n", lstrlen(exp_str1) + 1, lstrlen(exp_str2) + 1, len); \
3220     LocalFree(string);
3221
3222     InitializeSecurityDescriptor(&desc, SECURITY_DESCRIPTOR_REVISION);
3223     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3224     CHECK_RESULT_AND_FREE("");
3225
3226     size = 4096;
3227     pCreateWellKnownSid(WinLocalSid, NULL, sid_buf, &size);
3228     SetSecurityDescriptorOwner(&desc, sid_buf, FALSE);
3229     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3230     CHECK_RESULT_AND_FREE("O:S-1-2-0");
3231
3232     SetSecurityDescriptorOwner(&desc, sid_buf, TRUE);
3233     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3234     CHECK_RESULT_AND_FREE("O:S-1-2-0");
3235
3236     size = sizeof(sid_buf);
3237     pCreateWellKnownSid(WinLocalSystemSid, NULL, sid_buf, &size);
3238     SetSecurityDescriptorOwner(&desc, sid_buf, TRUE);
3239     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3240     CHECK_RESULT_AND_FREE("O:SY");
3241
3242     pConvertStringSidToSidA("S-1-5-21-93476-23408-4576", &psid);
3243     SetSecurityDescriptorGroup(&desc, psid, TRUE);
3244     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3245     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576");
3246
3247     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, GROUP_SECURITY_INFORMATION, &string, &len), "Conversion failed\n");
3248     CHECK_RESULT_AND_FREE("G:S-1-5-21-93476-23408-4576");
3249
3250     pacl = (PACL)acl_buf;
3251     InitializeAcl(pacl, sizeof(acl_buf), ACL_REVISION);
3252     SetSecurityDescriptorDacl(&desc, TRUE, pacl, TRUE);
3253     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3254     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:");
3255
3256     SetSecurityDescriptorDacl(&desc, TRUE, pacl, FALSE);
3257     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3258     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:");
3259
3260     pConvertStringSidToSidA("S-1-5-6", &psid2);
3261     pAddAccessAllowedAceEx(pacl, ACL_REVISION, NO_PROPAGATE_INHERIT_ACE, 0xf0000000, psid2);
3262     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3263     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:(A;NP;GAGXGWGR;;;SU)");
3264
3265     pAddAccessAllowedAceEx(pacl, ACL_REVISION, INHERIT_ONLY_ACE|INHERITED_ACE, 0x00000003, psid2);
3266     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3267     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)");
3268
3269     pAddAccessDeniedAceEx(pacl, ACL_REVISION, OBJECT_INHERIT_ACE|CONTAINER_INHERIT_ACE, 0xffffffff, psid);
3270     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3271     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)");
3272
3273
3274     pacl = (PACL)acl_buf;
3275     InitializeAcl(pacl, sizeof(acl_buf), ACL_REVISION);
3276     SetSecurityDescriptorSacl(&desc, TRUE, pacl, FALSE);
3277     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3278     CHECK_RESULT_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:S:");
3279
3280     /* fails in win2k */
3281     SetSecurityDescriptorDacl(&desc, TRUE, NULL, FALSE);
3282     pAddAuditAccessAceEx(pacl, ACL_REVISION, VALID_INHERIT_FLAGS, KEY_READ|KEY_WRITE, psid2, TRUE, TRUE);
3283     if (pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len))
3284     {
3285         CHECK_ONE_OF_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:S:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)", /* XP */
3286             "O:SYG:S-1-5-21-93476-23408-4576D:NO_ACCESS_CONTROLS:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)" /* Vista */);
3287     }
3288
3289     /* fails in win2k */
3290     pAddAuditAccessAceEx(pacl, ACL_REVISION, NO_PROPAGATE_INHERIT_ACE, FILE_GENERIC_READ|FILE_GENERIC_WRITE, psid2, TRUE, FALSE);
3291     if (pConvertSecurityDescriptorToStringSecurityDescriptorA(&desc, SDDL_REVISION_1, sec_info, &string, &len))
3292     {
3293         CHECK_ONE_OF_AND_FREE("O:SYG:S-1-5-21-93476-23408-4576D:S:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)(AU;NPSA;0x12019f;;;SU)", /* XP */
3294             "O:SYG:S-1-5-21-93476-23408-4576D:NO_ACCESS_CONTROLS:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)(AU;NPSA;0x12019f;;;SU)" /* Vista */);
3295     }
3296
3297     LocalFree(psid2);
3298     LocalFree(psid);
3299 }
3300
3301 static void test_SetSecurityDescriptorControl (PSECURITY_DESCRIPTOR sec)
3302 {
3303     SECURITY_DESCRIPTOR_CONTROL ref;
3304     SECURITY_DESCRIPTOR_CONTROL test;
3305
3306     SECURITY_DESCRIPTOR_CONTROL const mutable
3307         = SE_DACL_AUTO_INHERIT_REQ | SE_SACL_AUTO_INHERIT_REQ
3308         | SE_DACL_AUTO_INHERITED   | SE_SACL_AUTO_INHERITED
3309         | SE_DACL_PROTECTED        | SE_SACL_PROTECTED
3310         | 0x00000040               | 0x00000080        /* not defined in winnt.h */
3311         ;
3312     SECURITY_DESCRIPTOR_CONTROL const immutable
3313         = SE_OWNER_DEFAULTED       | SE_GROUP_DEFAULTED
3314         | SE_DACL_PRESENT          | SE_DACL_DEFAULTED
3315         | SE_SACL_PRESENT          | SE_SACL_DEFAULTED
3316         | SE_RM_CONTROL_VALID      | SE_SELF_RELATIVE
3317         ;
3318
3319     int     bit;
3320     DWORD   dwRevision;
3321     LPCSTR  fmt = "Expected error %s, got %u\n";
3322
3323     GetSecurityDescriptorControl (sec, &ref, &dwRevision);
3324
3325     /* The mutable bits are mutable regardless of the truth of
3326        SE_DACL_PRESENT and/or SE_SACL_PRESENT */
3327
3328     /* Check call barfs if any bit-of-interest is immutable */
3329     for (bit = 0; bit < 16; ++bit)
3330     {
3331         SECURITY_DESCRIPTOR_CONTROL const bitOfInterest = 1 << bit;
3332         SECURITY_DESCRIPTOR_CONTROL setOrClear = ref & bitOfInterest;
3333
3334         SECURITY_DESCRIPTOR_CONTROL ctrl;
3335
3336         DWORD   dwExpect  = (bitOfInterest & immutable)
3337                           ?  ERROR_INVALID_PARAMETER  :  0xbebecaca;
3338         LPCSTR  strExpect = (bitOfInterest & immutable)
3339                           ? "ERROR_INVALID_PARAMETER" : "0xbebecaca";
3340
3341         ctrl = (bitOfInterest & mutable) ? ref + bitOfInterest : ref;
3342         setOrClear ^= bitOfInterest;
3343         SetLastError (0xbebecaca);
3344         pSetSecurityDescriptorControl (sec, bitOfInterest, setOrClear);
3345         ok (GetLastError () == dwExpect, fmt, strExpect, GetLastError ());
3346         GetSecurityDescriptorControl(sec, &test, &dwRevision);
3347         expect_eq(test, ctrl, int, "%x");
3348
3349         setOrClear ^= bitOfInterest;
3350         SetLastError (0xbebecaca);
3351         pSetSecurityDescriptorControl (sec, bitOfInterest, setOrClear);
3352         ok (GetLastError () == dwExpect, fmt, strExpect, GetLastError ());
3353         GetSecurityDescriptorControl (sec, &test, &dwRevision);
3354         expect_eq(test, ref, int, "%x");
3355     }
3356
3357     /* Check call barfs if any bit-to-set is immutable
3358        even when not a bit-of-interest */
3359     for (bit = 0; bit < 16; ++bit)
3360     {
3361         SECURITY_DESCRIPTOR_CONTROL const bitsOfInterest = mutable;
3362         SECURITY_DESCRIPTOR_CONTROL setOrClear = ref & bitsOfInterest;
3363
3364         SECURITY_DESCRIPTOR_CONTROL ctrl;
3365
3366         DWORD   dwExpect  = ((1 << bit) & immutable)
3367                           ?  ERROR_INVALID_PARAMETER  :  0xbebecaca;
3368         LPCSTR  strExpect = ((1 << bit) & immutable)
3369                           ? "ERROR_INVALID_PARAMETER" : "0xbebecaca";
3370
3371         ctrl = ((1 << bit) & immutable) ? test : ref | mutable;
3372         setOrClear ^= bitsOfInterest;
3373         SetLastError (0xbebecaca);
3374         pSetSecurityDescriptorControl (sec, bitsOfInterest, setOrClear | (1 << bit));
3375         ok (GetLastError () == dwExpect, fmt, strExpect, GetLastError ());
3376         GetSecurityDescriptorControl(sec, &test, &dwRevision);
3377         expect_eq(test, ctrl, int, "%x");
3378
3379         ctrl = ((1 << bit) & immutable) ? test : ref | (1 << bit);
3380         setOrClear ^= bitsOfInterest;
3381         SetLastError (0xbebecaca);
3382         pSetSecurityDescriptorControl (sec, bitsOfInterest, setOrClear | (1 << bit));
3383         ok (GetLastError () == dwExpect, fmt, strExpect, GetLastError ());
3384         GetSecurityDescriptorControl(sec, &test, &dwRevision);
3385         expect_eq(test, ctrl, int, "%x");
3386     }
3387 }
3388
3389 static void test_PrivateObjectSecurity(void)
3390 {
3391     SECURITY_INFORMATION sec_info = OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION|SACL_SECURITY_INFORMATION;
3392     SECURITY_DESCRIPTOR_CONTROL ctrl;
3393     PSECURITY_DESCRIPTOR sec;
3394     DWORD dwDescSize;
3395     DWORD dwRevision;
3396     DWORD retSize;
3397     LPSTR string;
3398     ULONG len;
3399     PSECURITY_DESCRIPTOR buf;
3400     BOOL ret;
3401
3402     if (!pConvertStringSecurityDescriptorToSecurityDescriptorA)
3403     {
3404         win_skip("ConvertStringSecurityDescriptorToSecurityDescriptor is not available\n");
3405         return;
3406     }
3407
3408     ok(pConvertStringSecurityDescriptorToSecurityDescriptorA(
3409         "O:SY"
3410         "G:S-1-5-21-93476-23408-4576"
3411         "D:(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)"
3412           "(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)"
3413         "S:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)(AU;NPSA;0x12019f;;;SU)",
3414         SDDL_REVISION_1, &sec, &dwDescSize), "Creating descriptor failed\n");
3415
3416     test_SetSecurityDescriptorControl(sec);
3417
3418     LocalFree(sec);
3419
3420     ok(pConvertStringSecurityDescriptorToSecurityDescriptorA(
3421         "O:SY"
3422         "G:S-1-5-21-93476-23408-4576",
3423         SDDL_REVISION_1, &sec, &dwDescSize), "Creating descriptor failed\n");
3424
3425     test_SetSecurityDescriptorControl(sec);
3426
3427     LocalFree(sec);
3428
3429     ok(pConvertStringSecurityDescriptorToSecurityDescriptorA(
3430         "O:SY"
3431         "G:S-1-5-21-93476-23408-4576"
3432         "D:(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)"
3433         "S:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)(AU;NPSA;0x12019f;;;SU)", SDDL_REVISION_1, &sec, &dwDescSize), "Creating descriptor failed\n");
3434     buf = HeapAlloc(GetProcessHeap(), 0, dwDescSize);
3435     pSetSecurityDescriptorControl(sec, SE_DACL_PROTECTED, SE_DACL_PROTECTED);
3436     GetSecurityDescriptorControl(sec, &ctrl, &dwRevision);
3437     expect_eq(ctrl, 0x9014, int, "%x");
3438
3439     ret = GetPrivateObjectSecurity(sec, GROUP_SECURITY_INFORMATION, buf, dwDescSize, &retSize);
3440     ok(ret, "GetPrivateObjectSecurity failed (err=%u)\n", GetLastError());
3441     ok(retSize <= dwDescSize, "Buffer too small (%d vs %d)\n", retSize, dwDescSize);
3442     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(buf, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3443     CHECK_RESULT_AND_FREE("G:S-1-5-21-93476-23408-4576");
3444     GetSecurityDescriptorControl(buf, &ctrl, &dwRevision);
3445     expect_eq(ctrl, 0x8000, int, "%x");
3446
3447     ret = GetPrivateObjectSecurity(sec, GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION, buf, dwDescSize, &retSize);
3448     ok(ret, "GetPrivateObjectSecurity failed (err=%u)\n", GetLastError());
3449     ok(retSize <= dwDescSize, "Buffer too small (%d vs %d)\n", retSize, dwDescSize);
3450     ret = pConvertSecurityDescriptorToStringSecurityDescriptorA(buf, SDDL_REVISION_1, sec_info, &string, &len);
3451     ok(ret, "Conversion failed err=%u\n", GetLastError());
3452     CHECK_ONE_OF_AND_FREE("G:S-1-5-21-93476-23408-4576D:(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)",
3453         "G:S-1-5-21-93476-23408-4576D:P(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)"); /* Win7 */
3454     GetSecurityDescriptorControl(buf, &ctrl, &dwRevision);
3455     expect_eq(ctrl & (~ SE_DACL_PROTECTED), 0x8004, int, "%x");
3456
3457     ret = GetPrivateObjectSecurity(sec, sec_info, buf, dwDescSize, &retSize);
3458     ok(ret, "GetPrivateObjectSecurity failed (err=%u)\n", GetLastError());
3459     ok(retSize == dwDescSize, "Buffer too small (%d vs %d)\n", retSize, dwDescSize);
3460     ok(pConvertSecurityDescriptorToStringSecurityDescriptorA(buf, SDDL_REVISION_1, sec_info, &string, &len), "Conversion failed\n");
3461     CHECK_ONE_OF_AND_FREE("O:SY"
3462         "G:S-1-5-21-93476-23408-4576"
3463         "D:(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)"
3464         "S:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)(AU;NPSA;0x12019f;;;SU)",
3465       "O:SY"
3466         "G:S-1-5-21-93476-23408-4576"
3467         "D:P(A;NP;GAGXGWGR;;;SU)(A;IOID;CCDC;;;SU)(D;OICI;0xffffffff;;;S-1-5-21-93476-23408-4576)"
3468         "S:(AU;OICINPIOIDSAFA;CCDCLCSWRPRC;;;SU)(AU;NPSA;0x12019f;;;SU)"); /* Win7 */
3469     GetSecurityDescriptorControl(buf, &ctrl, &dwRevision);
3470     expect_eq(ctrl & (~ SE_DACL_PROTECTED), 0x8014, int, "%x");
3471
3472     SetLastError(0xdeadbeef);
3473     ok(GetPrivateObjectSecurity(sec, sec_info, buf, 5, &retSize) == FALSE, "GetPrivateObjectSecurity should have failed\n");
3474     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Expected error ERROR_INSUFFICIENT_BUFFER, got %u\n", GetLastError());
3475
3476     LocalFree(sec);
3477     HeapFree(GetProcessHeap(), 0, buf);
3478 }
3479 #undef CHECK_RESULT_AND_FREE
3480 #undef CHECK_ONE_OF_AND_FREE
3481
3482 static void test_acls(void)
3483 {
3484     char buffer[256];
3485     PACL pAcl = (PACL)buffer;
3486     BOOL ret;
3487
3488     SetLastError(0xdeadbeef);
3489     ret = InitializeAcl(pAcl, sizeof(ACL) - 1, ACL_REVISION);
3490     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3491     {
3492         win_skip("InitializeAcl is not implemented\n");
3493         return;
3494     }
3495
3496     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InitializeAcl with too small a buffer should have failed with ERROR_INSUFFICIENT_BUFFER instead of %d\n", GetLastError());
3497
3498     SetLastError(0xdeadbeef);
3499     ret = InitializeAcl(pAcl, 0xffffffff, ACL_REVISION);
3500     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "InitializeAcl with too large a buffer should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
3501
3502     SetLastError(0xdeadbeef);
3503     ret = InitializeAcl(pAcl, sizeof(buffer), ACL_REVISION1);
3504     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "InitializeAcl(ACL_REVISION1) should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
3505
3506     ret = InitializeAcl(pAcl, sizeof(buffer), ACL_REVISION2);
3507     ok(ret, "InitializeAcl(ACL_REVISION2) failed with error %d\n", GetLastError());
3508
3509     ret = IsValidAcl(pAcl);
3510     ok(ret, "IsValidAcl failed with error %d\n", GetLastError());
3511
3512     ret = InitializeAcl(pAcl, sizeof(buffer), ACL_REVISION3);
3513     ok(ret, "InitializeAcl(ACL_REVISION3) failed with error %d\n", GetLastError());
3514
3515     ret = IsValidAcl(pAcl);
3516     ok(ret, "IsValidAcl failed with error %d\n", GetLastError());
3517
3518     SetLastError(0xdeadbeef);
3519     ret = InitializeAcl(pAcl, sizeof(buffer), ACL_REVISION4);
3520     if (GetLastError() != ERROR_INVALID_PARAMETER)
3521     {
3522         ok(ret, "InitializeAcl(ACL_REVISION4) failed with error %d\n", GetLastError());
3523
3524         ret = IsValidAcl(pAcl);
3525         ok(ret, "IsValidAcl failed with error %d\n", GetLastError());
3526     }
3527     else
3528         win_skip("ACL_REVISION4 is not implemented on NT4\n");
3529
3530     SetLastError(0xdeadbeef);
3531     ret = InitializeAcl(pAcl, sizeof(buffer), -1);
3532     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "InitializeAcl(-1) failed with error %d\n", GetLastError());
3533 }
3534
3535 static void test_GetSecurityInfo(void)
3536 {
3537     HANDLE obj;
3538     PSECURITY_DESCRIPTOR sd;
3539     PSID owner, group;
3540     PACL dacl;
3541     DWORD ret;
3542
3543     if (!pGetSecurityInfo)
3544     {
3545         win_skip("GetSecurityInfo is not available\n");
3546         return;
3547     }
3548
3549     /* Create something.  Files have lots of associated security info.  */
3550     obj = CreateFile(myARGV[0], GENERIC_READ, FILE_SHARE_READ, NULL,
3551                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
3552     if (obj == INVALID_HANDLE_VALUE)
3553     {
3554         skip("Couldn't create an object for GetSecurityInfo test\n");
3555         return;
3556     }
3557
3558     ret = pGetSecurityInfo(obj, SE_FILE_OBJECT,
3559                           OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
3560                           &owner, &group, &dacl, NULL, &sd);
3561     if (ret == ERROR_CALL_NOT_IMPLEMENTED)
3562     {
3563         win_skip("GetSecurityInfo is not implemented\n");
3564         CloseHandle(obj);
3565         return;
3566     }
3567     ok(ret == ERROR_SUCCESS, "GetSecurityInfo returned %d\n", ret);
3568     ok(sd != NULL, "GetSecurityInfo\n");
3569     ok(owner != NULL, "GetSecurityInfo\n");
3570     ok(group != NULL, "GetSecurityInfo\n");
3571     if (dacl != NULL)
3572         ok(IsValidAcl(dacl), "GetSecurityInfo\n");
3573     else
3574         win_skip("No ACL information returned\n");
3575
3576     LocalFree(sd);
3577
3578     if (!pCreateWellKnownSid)
3579     {
3580         win_skip("NULL parameter test would crash on NT4\n");
3581         CloseHandle(obj);
3582         return;
3583     }
3584
3585     /* If we don't ask for the security descriptor, Windows will still give us
3586        the other stuff, leaving us no way to free it.  */
3587     ret = pGetSecurityInfo(obj, SE_FILE_OBJECT,
3588                           OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
3589                           &owner, &group, &dacl, NULL, NULL);
3590     ok(ret == ERROR_SUCCESS, "GetSecurityInfo returned %d\n", ret);
3591     ok(owner != NULL, "GetSecurityInfo\n");
3592     ok(group != NULL, "GetSecurityInfo\n");
3593     if (dacl != NULL)
3594         ok(IsValidAcl(dacl), "GetSecurityInfo\n");
3595     else
3596         win_skip("No ACL information returned\n");
3597
3598     CloseHandle(obj);
3599 }
3600
3601 static void test_GetSidSubAuthority(void)
3602 {
3603     PSID psid = NULL;
3604
3605     if (!pGetSidSubAuthority || !pConvertStringSidToSidA || !pIsValidSid || !pGetSidSubAuthorityCount)
3606     {
3607         win_skip("Some functions not available\n");
3608         return;
3609     }
3610     /* Note: on windows passing in an invalid index like -1, lets GetSidSubAuthority return 0x05000000 but
3611              still GetLastError returns ERROR_SUCCESS then. We don't test these unlikely cornercases here for now */
3612     ok(pConvertStringSidToSidA("S-1-5-21-93476-23408-4576",&psid),"ConvertStringSidToSidA failed\n");
3613     ok(pIsValidSid(psid),"Sid is not valid\n");
3614     SetLastError(0xbebecaca);
3615     ok(*pGetSidSubAuthorityCount(psid) == 4,"GetSidSubAuthorityCount gave %d expected 4\n",*pGetSidSubAuthorityCount(psid));
3616     ok(GetLastError() == 0,"GetLastError returned %d instead of 0\n",GetLastError());
3617     SetLastError(0xbebecaca);
3618     ok(*pGetSidSubAuthority(psid,0) == 21,"GetSidSubAuthority gave %d expected 21\n",*pGetSidSubAuthority(psid,0));
3619     ok(GetLastError() == 0,"GetLastError returned %d instead of 0\n",GetLastError());
3620     SetLastError(0xbebecaca);
3621     ok(*pGetSidSubAuthority(psid,1) == 93476,"GetSidSubAuthority gave %d expected 93476\n",*pGetSidSubAuthority(psid,1));
3622     ok(GetLastError() == 0,"GetLastError returned %d instead of 0\n",GetLastError());
3623     SetLastError(0xbebecaca);
3624     ok(pGetSidSubAuthority(psid,4) != NULL,"Expected out of bounds GetSidSubAuthority to return a non-NULL pointer\n");
3625     ok(GetLastError() == 0,"GetLastError returned %d instead of 0\n",GetLastError());
3626     LocalFree(psid);
3627 }
3628
3629 static void test_CheckTokenMembership(void)
3630 {
3631     PTOKEN_GROUPS token_groups;
3632     DWORD size;
3633     HANDLE process_token, token;
3634     BOOL is_member;
3635     BOOL ret;
3636     DWORD i;
3637
3638     if (!pCheckTokenMembership)
3639     {
3640         win_skip("CheckTokenMembership is not available\n");
3641         return;
3642     }
3643     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE|TOKEN_QUERY, &process_token);
3644     ok(ret, "OpenProcessToken failed with error %d\n", GetLastError());
3645
3646     ret = DuplicateToken(process_token, SecurityImpersonation, &token);
3647     ok(ret, "DuplicateToken failed with error %d\n", GetLastError());
3648
3649     /* groups */
3650     ret = GetTokenInformation(token, TokenGroups, NULL, 0, &size);
3651     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
3652         "GetTokenInformation(TokenGroups) %s with error %d\n",
3653         ret ? "succeeded" : "failed", GetLastError());
3654     token_groups = HeapAlloc(GetProcessHeap(), 0, size);
3655     ret = GetTokenInformation(token, TokenGroups, token_groups, size, &size);
3656     ok(ret, "GetTokenInformation(TokenGroups) failed with error %d\n", GetLastError());
3657
3658     for (i = 0; i < token_groups->GroupCount; i++)
3659     {
3660         if (token_groups->Groups[i].Attributes & SE_GROUP_ENABLED)
3661             break;
3662     }
3663
3664     if (i == token_groups->GroupCount)
3665     {
3666         HeapFree(GetProcessHeap(), 0, token_groups);
3667         CloseHandle(token);
3668         skip("user not a member of any group\n");
3669         return;
3670     }
3671
3672     is_member = FALSE;
3673     ret = pCheckTokenMembership(token, token_groups->Groups[i].Sid, &is_member);
3674     ok(ret, "CheckTokenMembership failed with error %d\n", GetLastError());
3675     ok(is_member, "CheckTokenMembership should have detected sid as member\n");
3676
3677     is_member = FALSE;
3678     ret = pCheckTokenMembership(NULL, token_groups->Groups[i].Sid, &is_member);
3679     ok(ret, "CheckTokenMembership failed with error %d\n", GetLastError());
3680     ok(is_member, "CheckTokenMembership should have detected sid as member\n");
3681
3682     is_member = TRUE;
3683     SetLastError(0xdeadbeef);
3684     ret = pCheckTokenMembership(process_token, token_groups->Groups[i].Sid, &is_member);
3685     ok(!ret && GetLastError() == ERROR_NO_IMPERSONATION_TOKEN,
3686         "CheckTokenMembership with process token %s with error %d\n",
3687         ret ? "succeeded" : "failed", GetLastError());
3688     ok(!is_member, "CheckTokenMembership should have cleared is_member\n");
3689
3690     HeapFree(GetProcessHeap(), 0, token_groups);
3691     CloseHandle(token);
3692     CloseHandle(process_token);
3693 }
3694
3695 static void test_EqualSid(void)
3696 {
3697     PSID sid1, sid2;
3698     BOOL ret;
3699     SID_IDENTIFIER_AUTHORITY SIDAuthWorld = { SECURITY_WORLD_SID_AUTHORITY };
3700     SID_IDENTIFIER_AUTHORITY SIDAuthNT = { SECURITY_NT_AUTHORITY };
3701
3702     SetLastError(0xdeadbeef);
3703     ret = AllocateAndInitializeSid(&SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
3704         DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &sid1);
3705     if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3706     {
3707         win_skip("AllocateAndInitializeSid is not implemented\n");
3708         return;
3709     }
3710     ok(ret, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
3711     ok(GetLastError() == 0xdeadbeef,
3712        "AllocateAndInitializeSid shouldn't have set last error to %d\n",
3713        GetLastError());
3714
3715     ret = AllocateAndInitializeSid(&SIDAuthWorld, 1, SECURITY_WORLD_RID,
3716         0, 0, 0, 0, 0, 0, 0, &sid2);
3717     ok(ret, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
3718
3719     SetLastError(0xdeadbeef);
3720     ret = EqualSid(sid1, sid2);
3721     ok(!ret, "World and domain admins sids shouldn't have been equal\n");
3722     ok(GetLastError() == ERROR_SUCCESS ||
3723        broken(GetLastError() == 0xdeadbeef), /* NT4 */
3724        "EqualSid should have set last error to ERROR_SUCCESS instead of %d\n",
3725        GetLastError());
3726
3727     SetLastError(0xdeadbeef);
3728     sid2 = FreeSid(sid2);
3729     ok(!sid2, "FreeSid should have returned NULL instead of %p\n", sid2);
3730     ok(GetLastError() == 0xdeadbeef,
3731        "FreeSid shouldn't have set last error to %d\n",
3732        GetLastError());
3733
3734     ret = AllocateAndInitializeSid(&SIDAuthNT, 2, SECURITY_BUILTIN_DOMAIN_RID,
3735         DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &sid2);
3736     ok(ret, "AllocateAndInitializeSid failed with error %d\n", GetLastError());
3737
3738     SetLastError(0xdeadbeef);
3739     ret = EqualSid(sid1, sid2);
3740     ok(ret, "Same sids should have been equal\n");
3741     ok(GetLastError() == ERROR_SUCCESS ||
3742        broken(GetLastError() == 0xdeadbeef), /* NT4 */
3743        "EqualSid should have set last error to ERROR_SUCCESS instead of %d\n",
3744        GetLastError());
3745
3746     ((SID *)sid2)->Revision = 2;
3747     SetLastError(0xdeadbeef);
3748     ret = EqualSid(sid1, sid2);
3749     ok(!ret, "EqualSid with invalid sid should have returned FALSE\n");
3750     ok(GetLastError() == ERROR_SUCCESS ||
3751        broken(GetLastError() == 0xdeadbeef), /* NT4 */
3752        "EqualSid should have set last error to ERROR_SUCCESS instead of %d\n",
3753        GetLastError());
3754     ((SID *)sid2)->Revision = SID_REVISION;
3755
3756     FreeSid(sid1);
3757     FreeSid(sid2);
3758 }
3759
3760 static void test_GetUserNameA(void)
3761 {
3762     char buffer[UNLEN + 1], filler[UNLEN + 1];
3763     DWORD required_len, buffer_len;
3764     BOOL ret;
3765
3766     /* Test crashes on Windows. */
3767     if (0)
3768     {
3769         SetLastError(0xdeadbeef);
3770         GetUserNameA(NULL, NULL);
3771     }
3772
3773     SetLastError(0xdeadbeef);
3774     required_len = 0;
3775     ret = GetUserNameA(NULL, &required_len);
3776     ok(ret == FALSE, "GetUserNameA returned %d\n", ret);
3777     ok(required_len != 0, "Outputted buffer length was %u\n", required_len);
3778     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3779
3780     SetLastError(0xdeadbeef);
3781     required_len = 1;
3782     ret = GetUserNameA(NULL, &required_len);
3783     ok(ret == FALSE, "GetUserNameA returned %d\n", ret);
3784     ok(required_len != 0 && required_len != 1, "Outputted buffer length was %u\n", required_len);
3785     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3786
3787     /* Tests crashes on Windows. */
3788     if (0)
3789     {
3790         SetLastError(0xdeadbeef);
3791         required_len = UNLEN + 1;
3792         GetUserNameA(NULL, &required_len);
3793
3794         SetLastError(0xdeadbeef);
3795         GetUserNameA(buffer, NULL);
3796     }
3797
3798     memset(filler, 'x', sizeof(filler));
3799
3800     /* Note that GetUserNameA on XP and newer outputs the number of bytes
3801      * required for a Unicode string, which affects a test in the next block. */
3802     SetLastError(0xdeadbeef);
3803     memcpy(buffer, filler, sizeof(filler));
3804     required_len = 0;
3805     ret = GetUserNameA(buffer, &required_len);
3806     ok(ret == FALSE, "GetUserNameA returned %d\n", ret);
3807     ok(!memcmp(buffer, filler, sizeof(filler)), "Output buffer was altered\n");
3808     ok(required_len != 0, "Outputted buffer length was %u\n", required_len);
3809     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3810
3811     SetLastError(0xdeadbeef);
3812     memcpy(buffer, filler, sizeof(filler));
3813     buffer_len = required_len;
3814     ret = GetUserNameA(buffer, &buffer_len);
3815     ok(ret == TRUE, "GetUserNameA returned %d, last error %u\n", ret, GetLastError());
3816     ok(memcmp(buffer, filler, sizeof(filler)) != 0, "Output buffer was untouched\n");
3817     ok(buffer_len == required_len ||
3818        broken(buffer_len == required_len / sizeof(WCHAR)), /* XP+ */
3819        "Outputted buffer length was %u\n", buffer_len);
3820
3821     /* Use the reported buffer size from the last GetUserNameA call and pass
3822      * a length that is one less than the required value. */
3823     SetLastError(0xdeadbeef);
3824     memcpy(buffer, filler, sizeof(filler));
3825     buffer_len--;
3826     ret = GetUserNameA(buffer, &buffer_len);
3827     ok(ret == FALSE, "GetUserNameA returned %d\n", ret);
3828     ok(!memcmp(buffer, filler, sizeof(filler)), "Output buffer was untouched\n");
3829     ok(buffer_len == required_len, "Outputted buffer length was %u\n", buffer_len);
3830     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3831 }
3832
3833 static void test_GetUserNameW(void)
3834 {
3835     WCHAR buffer[UNLEN + 1], filler[UNLEN + 1];
3836     DWORD required_len, buffer_len;
3837     BOOL ret;
3838
3839     /* Test crashes on Windows. */
3840     if (0)
3841     {
3842         SetLastError(0xdeadbeef);
3843         GetUserNameW(NULL, NULL);
3844     }
3845
3846     SetLastError(0xdeadbeef);
3847     required_len = 0;
3848     ret = GetUserNameW(NULL, &required_len);
3849     ok(ret == FALSE, "GetUserNameW returned %d\n", ret);
3850     ok(required_len != 0, "Outputted buffer length was %u\n", required_len);
3851     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3852
3853     SetLastError(0xdeadbeef);
3854     required_len = 1;
3855     ret = GetUserNameW(NULL, &required_len);
3856     ok(ret == FALSE, "GetUserNameW returned %d\n", ret);
3857     ok(required_len != 0 && required_len != 1, "Outputted buffer length was %u\n", required_len);
3858     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3859
3860     /* Tests crash on Windows. */
3861     if (0)
3862     {
3863         SetLastError(0xdeadbeef);
3864         required_len = UNLEN + 1;
3865         GetUserNameW(NULL, &required_len);
3866
3867         SetLastError(0xdeadbeef);
3868         GetUserNameW(buffer, NULL);
3869     }
3870
3871     memset(filler, 'x', sizeof(filler));
3872
3873     SetLastError(0xdeadbeef);
3874     memcpy(buffer, filler, sizeof(filler));
3875     required_len = 0;
3876     ret = GetUserNameW(buffer, &required_len);
3877     ok(ret == FALSE, "GetUserNameW returned %d\n", ret);
3878     ok(!memcmp(buffer, filler, sizeof(filler)), "Output buffer was altered\n");
3879     ok(required_len != 0, "Outputted buffer length was %u\n", required_len);
3880     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3881
3882     SetLastError(0xdeadbeef);
3883     memcpy(buffer, filler, sizeof(filler));
3884     buffer_len = required_len;
3885     ret = GetUserNameW(buffer, &buffer_len);
3886     ok(ret == TRUE, "GetUserNameW returned %d, last error %u\n", ret, GetLastError());
3887     ok(memcmp(buffer, filler, sizeof(filler)) != 0, "Output buffer was untouched\n");
3888     ok(buffer_len == required_len, "Outputted buffer length was %u\n", buffer_len);
3889
3890     /* GetUserNameW on XP and newer writes a truncated portion of the username string to the buffer. */
3891     SetLastError(0xdeadbeef);
3892     memcpy(buffer, filler, sizeof(filler));
3893     buffer_len--;
3894     ret = GetUserNameW(buffer, &buffer_len);
3895     ok(ret == FALSE, "GetUserNameW returned %d\n", ret);
3896     ok(!memcmp(buffer, filler, sizeof(filler)) ||
3897        broken(memcmp(buffer, filler, sizeof(filler)) != 0), /* XP+ */
3898        "Output buffer was altered\n");
3899     ok(buffer_len == required_len, "Outputted buffer length was %u\n", buffer_len);
3900     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Last error was %u\n", GetLastError());
3901 }
3902
3903 static void test_CreateRestrictedToken(void)
3904 {
3905     HANDLE process_token, token, r_token;
3906     PTOKEN_GROUPS token_groups, groups2;
3907     SID_AND_ATTRIBUTES sattr;
3908     BOOL is_member;
3909     DWORD size;
3910     BOOL ret;
3911     DWORD i, j;
3912
3913     if (!pCreateRestrictedToken)
3914     {
3915         win_skip("CreateRestrictedToken is not available\n");
3916         return;
3917     }
3918
3919     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE|TOKEN_QUERY, &process_token);
3920     ok(ret, "got error %d\n", GetLastError());
3921
3922     ret = DuplicateTokenEx(process_token, TOKEN_DUPLICATE|TOKEN_ADJUST_GROUPS|TOKEN_QUERY,
3923         NULL, SecurityImpersonation, TokenImpersonation, &token);
3924     ok(ret, "got error %d\n", GetLastError());
3925
3926     /* groups */
3927     ret = GetTokenInformation(token, TokenGroups, NULL, 0, &size);
3928     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
3929         "got %d with error %d\n", ret, GetLastError());
3930     token_groups = HeapAlloc(GetProcessHeap(), 0, size);
3931     ret = GetTokenInformation(token, TokenGroups, token_groups, size, &size);
3932     ok(ret, "got error %d\n", GetLastError());
3933
3934     for (i = 0; i < token_groups->GroupCount; i++)
3935     {
3936         if (token_groups->Groups[i].Attributes & SE_GROUP_ENABLED)
3937             break;
3938     }
3939
3940     if (i == token_groups->GroupCount)
3941     {
3942         HeapFree(GetProcessHeap(), 0, token_groups);
3943         CloseHandle(token);
3944         skip("User not a member of any group\n");
3945         return;
3946     }
3947
3948     is_member = FALSE;
3949     ret = pCheckTokenMembership(token, token_groups->Groups[i].Sid, &is_member);
3950     ok(ret, "got error %d\n", GetLastError());
3951     ok(is_member, "not a member\n");
3952
3953     /* disable a SID in new token */
3954     sattr.Sid = token_groups->Groups[i].Sid;
3955     sattr.Attributes = 0;
3956     r_token = NULL;
3957     ret = pCreateRestrictedToken(token, 0, 1, &sattr, 0, NULL, 0, NULL, &r_token);
3958     todo_wine ok(ret, "got error %d\n", GetLastError());
3959
3960     if (ret)
3961     {
3962         /* check if a SID is enabled */
3963         is_member = TRUE;
3964         ret = pCheckTokenMembership(r_token, token_groups->Groups[i].Sid, &is_member);
3965         ok(ret, "got error %d\n", GetLastError());
3966         ok(!is_member, "not a member\n");
3967
3968         ret = GetTokenInformation(r_token, TokenGroups, NULL, 0, &size);
3969         ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %d with error %d\n",
3970             ret, GetLastError());
3971         groups2 = HeapAlloc(GetProcessHeap(), 0, size);
3972         ret = GetTokenInformation(r_token, TokenGroups, groups2, size, &size);
3973         ok(ret, "got error %d\n", GetLastError());
3974
3975         for (j = 0; j < groups2->GroupCount; j++)
3976         {
3977             if (EqualSid(groups2->Groups[j].Sid, token_groups->Groups[i].Sid))
3978                 break;
3979         }
3980
3981         ok(groups2->Groups[j].Attributes & SE_GROUP_USE_FOR_DENY_ONLY,
3982             "got wrong attributes\n");
3983         ok((groups2->Groups[j].Attributes & SE_GROUP_ENABLED) == 0,
3984             "got wrong attributes\n");
3985
3986         HeapFree(GetProcessHeap(), 0, groups2);
3987     }
3988
3989     HeapFree(GetProcessHeap(), 0, token_groups);
3990     CloseHandle(r_token);
3991     CloseHandle(token);
3992     CloseHandle(process_token);
3993 }
3994
3995 static void validate_default_security_descriptor(SECURITY_DESCRIPTOR *sd)
3996 {
3997     BOOL ret, present, defaulted;
3998     ACL *acl;
3999     void *sid;
4000
4001     ret = IsValidSecurityDescriptor(sd);
4002     ok(ret, "security descriptor is not valid\n");
4003
4004     present = -1;
4005     defaulted = -1;
4006     acl = (void *)0xdeadbeef;
4007     SetLastError(0xdeadbeef);
4008     ret = GetSecurityDescriptorDacl(sd, &present, &acl, &defaulted);
4009     ok(ret, "GetSecurityDescriptorDacl error %d\n", GetLastError());
4010 todo_wine
4011     ok(present == 1, "acl is not present\n");
4012 todo_wine
4013     ok(acl != (void *)0xdeadbeef && acl != NULL, "acl pointer is not set\n");
4014     ok(defaulted == 0, "defaulted is set to TRUE\n");
4015
4016     defaulted = -1;
4017     sid = (void *)0xdeadbeef;
4018     SetLastError(0xdeadbeef);
4019     ret = GetSecurityDescriptorOwner(sd, &sid, &defaulted);
4020     ok(ret, "GetSecurityDescriptorOwner error %d\n", GetLastError());
4021 todo_wine
4022     ok(sid != (void *)0xdeadbeef && sid != NULL, "sid pointer is not set\n");
4023     ok(defaulted == 0, "defaulted is set to TRUE\n");
4024
4025     defaulted = -1;
4026     sid = (void *)0xdeadbeef;
4027     SetLastError(0xdeadbeef);
4028     ret = GetSecurityDescriptorGroup(sd, &sid, &defaulted);
4029     ok(ret, "GetSecurityDescriptorGroup error %d\n", GetLastError());
4030 todo_wine
4031     ok(sid != (void *)0xdeadbeef && sid != NULL, "sid pointer is not set\n");
4032     ok(defaulted == 0, "defaulted is set to TRUE\n");
4033 }
4034
4035 static void test_default_handle_security(HANDLE token, HANDLE handle, GENERIC_MAPPING *mapping)
4036 {
4037     DWORD ret, length, needed, granted, priv_set_len;
4038     BOOL status;
4039     PRIVILEGE_SET priv_set;
4040     SECURITY_DESCRIPTOR *sd;
4041
4042     needed = 0xdeadbeef;
4043     SetLastError(0xdeadbeef);
4044     ret = GetKernelObjectSecurity(handle, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
4045                                   NULL, 0, &needed);
4046     ok(!ret, "GetKernelObjectSecurity should fail\n");
4047     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
4048     ok(needed != 0xdeadbeef, "GetKernelObjectSecurity should return required buffer length\n");
4049
4050     length = needed;
4051     sd = HeapAlloc(GetProcessHeap(), 0, length);
4052
4053     needed = 0xdeadbeef;
4054     SetLastError(0xdeadbeef);
4055     ret = GetKernelObjectSecurity(handle, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
4056                                   sd, length, &needed);
4057     ok(ret, "GetKernelObjectSecurity error %d\n", GetLastError());
4058     ok(needed == length || needed == 0 /* file, pipe */, "GetKernelObjectSecurity should return %u instead of %u\n", length, needed);
4059
4060     validate_default_security_descriptor(sd);
4061
4062     priv_set_len = sizeof(priv_set);
4063     granted = 0xdeadbeef;
4064     status = 0xdeadbeef;
4065     SetLastError(0xdeadbeef);
4066     ret = AccessCheck(sd, token, MAXIMUM_ALLOWED, mapping, &priv_set, &priv_set_len, &granted, &status);
4067 todo_wine {
4068     ok(ret, "AccessCheck error %d\n", GetLastError());
4069     ok(status == 1, "expected 1, got %d\n", status);
4070     ok(granted == mapping->GenericAll, "expected all access %#x, got %#x\n", mapping->GenericAll, granted);
4071 }
4072     priv_set_len = sizeof(priv_set);
4073     granted = 0xdeadbeef;
4074     status = 0xdeadbeef;
4075     SetLastError(0xdeadbeef);
4076     ret = AccessCheck(sd, token, 0, mapping, &priv_set, &priv_set_len, &granted, &status);
4077 todo_wine {
4078     ok(ret, "AccessCheck error %d\n", GetLastError());
4079     ok(status == 0 || broken(status == 1) /* NT4 */, "expected 0, got %d\n", status);
4080     ok(granted == 0 || broken(granted == mapping->GenericRead) /* NT4 */, "expected 0, got %#x\n", granted);
4081 }
4082     priv_set_len = sizeof(priv_set);
4083     granted = 0xdeadbeef;
4084     status = 0xdeadbeef;
4085     SetLastError(0xdeadbeef);
4086     ret = AccessCheck(sd, token, ACCESS_SYSTEM_SECURITY, mapping, &priv_set, &priv_set_len, &granted, &status);
4087 todo_wine {
4088     ok(ret, "AccessCheck error %d\n", GetLastError());
4089     ok(status == 0, "expected 0, got %d\n", status);
4090     ok(granted == 0, "expected 0, got %#x\n", granted);
4091 }
4092     priv_set_len = sizeof(priv_set);
4093     granted = 0xdeadbeef;
4094     status = 0xdeadbeef;
4095     SetLastError(0xdeadbeef);
4096     ret = AccessCheck(sd, token, mapping->GenericRead, mapping, &priv_set, &priv_set_len, &granted, &status);
4097 todo_wine {
4098     ok(ret, "AccessCheck error %d\n", GetLastError());
4099     ok(status == 1, "expected 1, got %d\n", status);
4100     ok(granted == mapping->GenericRead, "expected read access %#x, got %#x\n", mapping->GenericRead, granted);
4101 }
4102     priv_set_len = sizeof(priv_set);
4103     granted = 0xdeadbeef;
4104     status = 0xdeadbeef;
4105     SetLastError(0xdeadbeef);
4106     ret = AccessCheck(sd, token, mapping->GenericWrite, mapping, &priv_set, &priv_set_len, &granted, &status);
4107 todo_wine {
4108     ok(ret, "AccessCheck error %d\n", GetLastError());
4109     ok(status == 1, "expected 1, got %d\n", status);
4110     ok(granted == mapping->GenericWrite, "expected write access %#x, got %#x\n", mapping->GenericWrite, granted);
4111 }
4112     priv_set_len = sizeof(priv_set);
4113     granted = 0xdeadbeef;
4114     status = 0xdeadbeef;
4115     SetLastError(0xdeadbeef);
4116     ret = AccessCheck(sd, token, mapping->GenericExecute, mapping, &priv_set, &priv_set_len, &granted, &status);
4117 todo_wine {
4118     ok(ret, "AccessCheck error %d\n", GetLastError());
4119     ok(status == 1, "expected 1, got %d\n", status);
4120     ok(granted == mapping->GenericExecute, "expected execute access %#x, got %#x\n", mapping->GenericExecute, granted);
4121 }
4122     HeapFree(GetProcessHeap(), 0, sd);
4123 }
4124
4125 static void test_mutex_security(HANDLE token)
4126 {
4127     HANDLE mutex;
4128     GENERIC_MAPPING mapping = { STANDARD_RIGHTS_READ | MUTANT_QUERY_STATE | SYNCHRONIZE,
4129                                 STANDARD_RIGHTS_WRITE | MUTEX_MODIFY_STATE | SYNCHRONIZE,
4130                                 STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
4131                                 STANDARD_RIGHTS_ALL | MUTEX_ALL_ACCESS };
4132
4133     SetLastError(0xdeadbeef);
4134     mutex = OpenMutex(0, FALSE, "WineTestMutex");
4135     ok(!mutex, "mutex should not exist\n");
4136     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %u\n", GetLastError());
4137
4138     SetLastError(0xdeadbeef);
4139     mutex = CreateMutex(NULL, FALSE, "WineTestMutex");
4140     ok(mutex != 0, "CreateMutex error %d\n", GetLastError());
4141
4142     test_default_handle_security(token, mutex, &mapping);
4143
4144     CloseHandle (mutex);
4145 }
4146
4147 static void test_event_security(HANDLE token)
4148 {
4149     HANDLE event;
4150     GENERIC_MAPPING mapping = { STANDARD_RIGHTS_READ | EVENT_QUERY_STATE | SYNCHRONIZE,
4151                                 STANDARD_RIGHTS_WRITE | EVENT_MODIFY_STATE | SYNCHRONIZE,
4152                                 STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE,
4153                                 STANDARD_RIGHTS_ALL | EVENT_ALL_ACCESS };
4154
4155     SetLastError(0xdeadbeef);
4156     event = OpenEvent(0, FALSE, "WineTestEvent");
4157     ok(!event, "event should not exist\n");
4158     ok(GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %u\n", GetLastError());
4159
4160     SetLastError(0xdeadbeef);
4161     event = CreateEvent(NULL, FALSE, FALSE, "WineTestEvent");
4162     ok(event != 0, "CreateEvent error %d\n", GetLastError());
4163
4164     test_default_handle_security(token, event, &mapping);
4165
4166     CloseHandle(event);
4167 }
4168
4169 #define WINE_TEST_PIPE "\\\\.\\pipe\\WineTestPipe"
4170 static void test_named_pipe_security(HANDLE token)
4171 {
4172     HANDLE pipe, file;
4173     GENERIC_MAPPING mapping = { FILE_GENERIC_READ,
4174                                 FILE_GENERIC_WRITE,
4175                                 FILE_GENERIC_EXECUTE,
4176                                 STANDARD_RIGHTS_ALL | FILE_ALL_ACCESS };
4177
4178     SetLastError(0xdeadbeef);
4179     pipe = CreateNamedPipe(WINE_TEST_PIPE, PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE,
4180                            PIPE_TYPE_BYTE | PIPE_NOWAIT, PIPE_UNLIMITED_INSTANCES,
4181                            0, 0, NMPWAIT_USE_DEFAULT_WAIT, NULL);
4182     ok(pipe != INVALID_HANDLE_VALUE, "CreateNamedPipe error %d\n", GetLastError());
4183
4184     test_default_handle_security(token, pipe, &mapping);
4185
4186     SetLastError(0xdeadbeef);
4187     file = CreateFile(WINE_TEST_PIPE, FILE_ALL_ACCESS, 0, NULL, OPEN_EXISTING, 0, 0);
4188     ok(file != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
4189     CloseHandle(file);
4190
4191     CloseHandle(pipe);
4192
4193     SetLastError(0xdeadbeef);
4194     file = CreateFile("\\\\.\\pipe\\", FILE_ALL_ACCESS, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
4195     ok(file != INVALID_HANDLE_VALUE || broken(file == INVALID_HANDLE_VALUE) /* before Vista */, "CreateFile error %d\n", GetLastError());
4196     CloseHandle(file);
4197 }
4198
4199 static BOOL validate_impersonation_token(HANDLE token, DWORD *token_type)
4200 {
4201     DWORD ret, needed;
4202     TOKEN_TYPE type;
4203     SECURITY_IMPERSONATION_LEVEL sil;
4204
4205     type = 0xdeadbeef;
4206     needed = 0;
4207     SetLastError(0xdeadbeef);
4208     ret = GetTokenInformation(token, TokenType, &type, sizeof(type), &needed);
4209     ok(ret, "GetTokenInformation error %d\n", GetLastError());
4210     ok(needed == sizeof(type), "GetTokenInformation should return required buffer length\n");
4211     ok(type == TokenPrimary || type == TokenImpersonation, "expected TokenPrimary or TokenImpersonation, got %d\n", type);
4212
4213     *token_type = type;
4214     if (type != TokenImpersonation) return FALSE;
4215
4216     needed = 0;
4217     SetLastError(0xdeadbeef);
4218     ret = GetTokenInformation(token, TokenImpersonationLevel, &sil, sizeof(sil), &needed);
4219     ok(ret, "GetTokenInformation error %d\n", GetLastError());
4220     ok(needed == sizeof(sil), "GetTokenInformation should return required buffer length\n");
4221     ok(sil == SecurityImpersonation, "expected SecurityImpersonation, got %d\n", sil);
4222
4223     needed = 0xdeadbeef;
4224     SetLastError(0xdeadbeef);
4225     ret = GetTokenInformation(token, TokenDefaultDacl, NULL, 0, &needed);
4226     ok(!ret, "GetTokenInformation should fail\n");
4227     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
4228     ok(needed != 0xdeadbeef, "GetTokenInformation should return required buffer length\n");
4229     ok(needed > sizeof(TOKEN_DEFAULT_DACL), "GetTokenInformation returned empty default DACL\n");
4230
4231     needed = 0xdeadbeef;
4232     SetLastError(0xdeadbeef);
4233     ret = GetTokenInformation(token, TokenOwner, NULL, 0, &needed);
4234     ok(!ret, "GetTokenInformation should fail\n");
4235     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
4236     ok(needed != 0xdeadbeef, "GetTokenInformation should return required buffer length\n");
4237     ok(needed > sizeof(TOKEN_OWNER), "GetTokenInformation returned empty token owner\n");
4238
4239     needed = 0xdeadbeef;
4240     SetLastError(0xdeadbeef);
4241     ret = GetTokenInformation(token, TokenPrimaryGroup, NULL, 0, &needed);
4242     ok(!ret, "GetTokenInformation should fail\n");
4243     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
4244     ok(needed != 0xdeadbeef, "GetTokenInformation should return required buffer length\n");
4245     ok(needed > sizeof(TOKEN_PRIMARY_GROUP), "GetTokenInformation returned empty token primary group\n");
4246
4247     return TRUE;
4248 }
4249
4250 static void test_kernel_objects_security(void)
4251 {
4252     HANDLE token, process_token;
4253     DWORD ret, token_type;
4254
4255     ret = OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE | TOKEN_QUERY, &process_token);
4256     ok(ret, "OpenProcessToken error %d\n", GetLastError());
4257
4258     ret = validate_impersonation_token(process_token, &token_type);
4259     ok(token_type == TokenPrimary, "expected TokenPrimary, got %d\n", token_type);
4260     ok(!ret, "access token should not be an impersonation token\n");
4261
4262     ret = DuplicateToken(process_token, SecurityImpersonation, &token);
4263     ok(ret, "DuplicateToken error %d\n", GetLastError());
4264
4265     ret = validate_impersonation_token(token, &token_type);
4266     ok(ret, "access token should be a valid impersonation token\n");
4267     ok(token_type == TokenImpersonation, "expected TokenImpersonation, got %d\n", token_type);
4268
4269     test_mutex_security(token);
4270     test_event_security(token);
4271     test_named_pipe_security(token);
4272     /* FIXME: test other kernel object types */
4273
4274     CloseHandle(process_token);
4275     CloseHandle(token);
4276 }
4277
4278 static void test_TokenIntegrityLevel(void)
4279 {
4280     TOKEN_MANDATORY_LABEL *tml;
4281     BYTE buffer[64];        /* using max. 28 byte in win7 x64 */
4282     HANDLE token;
4283     DWORD size;
4284     DWORD res;
4285     char *sidname = NULL;
4286     static SID medium_level = {SID_REVISION, 1, {SECURITY_MANDATORY_LABEL_AUTHORITY},
4287                                                     {SECURITY_MANDATORY_HIGH_RID}};
4288     static SID high_level = {SID_REVISION, 1, {SECURITY_MANDATORY_LABEL_AUTHORITY},
4289                                                     {SECURITY_MANDATORY_MEDIUM_RID}};
4290
4291     SetLastError(0xdeadbeef);
4292     res = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token);
4293     ok(res, "got %d with %d (expected TRUE)\n", res, GetLastError());
4294
4295     SetLastError(0xdeadbeef);
4296     res = GetTokenInformation(token, TokenIntegrityLevel, buffer, sizeof(buffer), &size);
4297
4298     /* not supported before Vista */
4299     if (!res && (GetLastError() == ERROR_INVALID_PARAMETER))
4300     {
4301         win_skip("TokenIntegrityLevel not supported\n");
4302         CloseHandle(token);
4303         return;
4304     }
4305
4306     ok(res, "got %u with %u (expected TRUE)\n", res, GetLastError());
4307     if (!res)
4308     {
4309         CloseHandle(token);
4310         return;
4311     }
4312
4313     tml = (TOKEN_MANDATORY_LABEL*) buffer;
4314     ok(tml->Label.Attributes == (SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED),
4315         "got 0x%x (expected 0x%x)\n", tml->Label.Attributes, (SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED));
4316
4317     SetLastError(0xdeadbeef);
4318     res = pConvertSidToStringSidA(tml->Label.Sid, &sidname);
4319     ok(res, "got %u and %u\n", res, GetLastError());
4320
4321     ok(EqualSid(tml->Label.Sid, &medium_level) || EqualSid(tml->Label.Sid, &high_level),
4322         "got %s (expected 'S-1-16-8192' or 'S-1-16-12288')\n", sidname);
4323
4324     LocalFree(sidname);
4325     CloseHandle(token);
4326 }
4327
4328 START_TEST(security)
4329 {
4330     init();
4331     if (!hmod) return;
4332
4333     if (myARGC >= 3)
4334     {
4335         test_process_security_child();
4336         return;
4337     }
4338     test_kernel_objects_security();
4339     test_sid();
4340     test_trustee();
4341     test_luid();
4342     test_CreateWellKnownSid();
4343     test_FileSecurity();
4344     test_AccessCheck();
4345     test_token_attr();
4346     test_LookupAccountSid();
4347     test_LookupAccountName();
4348     test_security_descriptor();
4349     test_process_security();
4350     test_impersonation_level();
4351     test_SetEntriesInAclW();
4352     test_SetEntriesInAclA();
4353     test_GetNamedSecurityInfoA();
4354     test_ConvertStringSecurityDescriptor();
4355     test_ConvertSecurityDescriptorToString();
4356     test_PrivateObjectSecurity();
4357     test_acls();
4358     test_GetSecurityInfo();
4359     test_GetSidSubAuthority();
4360     test_CheckTokenMembership();
4361     test_EqualSid();
4362     test_GetUserNameA();
4363     test_GetUserNameW();
4364     test_CreateRestrictedToken();
4365     test_TokenIntegrityLevel();
4366 }