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