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