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

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