crypt32: Don't fail chain creation if signature doesn't match.
[wine] / dlls / crypt32 / tests / sip.c
1 /*
2  * Subject Interface Package tests
3  *
4  * Copyright 2006 Paul Vriens
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <windef.h>
24 #include <winbase.h>
25 #include <winerror.h>
26 #include <winnls.h>
27 #include <wincrypt.h>
28 #include <mssip.h>
29
30 #include "wine/test.h"
31
32 static BOOL (WINAPI * funcCryptSIPGetSignedDataMsg)(SIP_SUBJECTINFO *,DWORD *,DWORD,DWORD *,BYTE *);
33 static BOOL (WINAPI * funcCryptSIPPutSignedDataMsg)(SIP_SUBJECTINFO *,DWORD,DWORD *,DWORD,BYTE *);
34 static BOOL (WINAPI * funcCryptSIPCreateIndirectData)(SIP_SUBJECTINFO *,DWORD *,SIP_INDIRECT_DATA *);
35 static BOOL (WINAPI * funcCryptSIPVerifyIndirectData)(SIP_SUBJECTINFO *,SIP_INDIRECT_DATA *);
36 static BOOL (WINAPI * funcCryptSIPRemoveSignedDataMsg)(SIP_SUBJECTINFO *,DWORD);
37
38 static char *show_guid(const GUID *guid)
39 {
40     static char guidstring[39];
41
42     sprintf(guidstring,
43         "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
44         guid->Data1, guid->Data2, guid->Data3,
45         guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
46         guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
47
48     return guidstring;
49 }
50
51 static void test_AddRemoveProvider(void)
52 {
53     BOOL ret;
54     SIP_ADD_NEWPROVIDER newprov;
55     GUID actionid = { 0xdeadbe, 0xefde, 0xadbe, { 0xef,0xde,0xad,0xbe,0xef,0xde,0xad,0xbe }};
56     static WCHAR dummydll[]      = {'d','e','a','d','b','e','e','f','.','d','l','l',0 };
57     static WCHAR dummyfunction[] = {'d','u','m','m','y','f','u','n','c','t','i','o','n',0 };
58
59     /* NULL check */
60     SetLastError(0xdeadbeef);
61     ret = CryptSIPRemoveProvider(NULL);
62     ok (!ret, "Expected CryptSIPRemoveProvider to fail.\n");
63     ok (GetLastError() == ERROR_INVALID_PARAMETER,
64         "Expected ERROR_INVALID_PARAMETER, got %d.\n", GetLastError());
65
66     /* nonexistent provider should result in a registry error */
67     SetLastError(0xdeadbeef);
68     ret = CryptSIPRemoveProvider(&actionid);
69     if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
70     {
71         /* Apparently the needed rights are checked before the existence of the provider */
72         skip("Need admin rights\n");
73     }
74     else
75     {
76         ok (!ret, "Expected CryptSIPRemoveProvider to fail.\n");
77         ok (GetLastError() == ERROR_FILE_NOT_FOUND,
78             "Expected ERROR_FILE_NOT_FOUND, got %d.\n", GetLastError());
79     }
80
81     /* Everything OK, pwszIsFunctionName and pwszIsFunctionNameFmt2 are left NULL
82      * as allowed */
83
84     memset(&newprov, 0, sizeof(SIP_ADD_NEWPROVIDER));
85     newprov.cbStruct = sizeof(SIP_ADD_NEWPROVIDER);
86     newprov.pgSubject = &actionid;
87     newprov.pwszDLLFileName = dummydll;
88     newprov.pwszGetFuncName = dummyfunction;
89     newprov.pwszPutFuncName = dummyfunction;
90     newprov.pwszCreateFuncName = dummyfunction;
91     newprov.pwszVerifyFuncName = dummyfunction;
92     newprov.pwszRemoveFuncName = dummyfunction;
93     SetLastError(0xdeadbeef);
94     ret = CryptSIPAddProvider(&newprov);
95     if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
96     {
97         skip("Need admin rights\n");
98         return;
99     }
100     ok ( ret, "CryptSIPAddProvider should have succeeded\n");
101
102     /* Dummy provider will be deleted, but the function still fails because
103      * pwszIsFunctionName and pwszIsFunctionNameFmt2 are not present in the
104      * registry.
105      */
106     SetLastError(0xdeadbeef);
107     ret = CryptSIPRemoveProvider(&actionid);
108     ok (!ret, "Expected CryptSIPRemoveProvider to fail.\n");
109     ok (GetLastError() == ERROR_FILE_NOT_FOUND,
110         "Expected ERROR_FILE_NOT_FOUND, got %d.\n", GetLastError());
111
112     /* Everything OK */
113     memset(&newprov, 0, sizeof(SIP_ADD_NEWPROVIDER));
114     newprov.cbStruct = sizeof(SIP_ADD_NEWPROVIDER);
115     newprov.pgSubject = &actionid;
116     newprov.pwszDLLFileName = dummydll;
117     newprov.pwszGetFuncName = dummyfunction;
118     newprov.pwszPutFuncName = dummyfunction;
119     newprov.pwszCreateFuncName = dummyfunction;
120     newprov.pwszVerifyFuncName = dummyfunction;
121     newprov.pwszRemoveFuncName = dummyfunction;
122     newprov.pwszIsFunctionNameFmt2 = dummyfunction;
123     newprov.pwszIsFunctionName = dummyfunction;
124     SetLastError(0xdeadbeef);
125     ret = CryptSIPAddProvider(&newprov);
126     ok ( ret, "CryptSIPAddProvider should have succeeded\n");
127
128     /* Dummy provider should be deleted */
129     SetLastError(0xdeadbeef);
130     ret = CryptSIPRemoveProvider(&actionid);
131     ok ( ret, "CryptSIPRemoveProvider should have succeeded\n");
132 }
133
134 static void test_SIPRetrieveSubjectGUID(void)
135 {
136     BOOL ret;
137     GUID subject;
138     HANDLE file;
139     static const CHAR windir[] = "windir";
140     static const CHAR regeditExe[] = "regedit.exe";
141     static const GUID nullSubject  = { 0x0, 0x0, 0x0, { 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0 }};
142     static const WCHAR deadbeef[]  = { 'c',':','\\','d','e','a','d','b','e','e','f','.','d','b','f',0 };
143     /* Couldn't find a name for this GUID, it's the one used for 95% of the files */
144     static const GUID unknownGUID = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
145     static CHAR  regeditPath[MAX_PATH];
146     static WCHAR regeditPathW[MAX_PATH];
147     static CHAR path[MAX_PATH];
148     static CHAR tempfile[MAX_PATH];
149     static WCHAR tempfileW[MAX_PATH];
150     DWORD written;
151
152     /* NULL check */
153     SetLastError(0xdeadbeef);
154     ret = CryptSIPRetrieveSubjectGuid(NULL, NULL, NULL);
155     ok ( !ret, "Expected CryptSIPRetrieveSubjectGuid to fail\n");
156     ok (GetLastError() == ERROR_INVALID_PARAMETER,
157         "Expected ERROR_INVALID_PARAMETER, got %d.\n", GetLastError());
158
159     /* Test with a nonexistent file (hopefully) */
160     SetLastError(0xdeadbeef);
161     /* Set subject to something other than zeros */
162     memset(&subject, 1, sizeof(GUID));
163     ret = CryptSIPRetrieveSubjectGuid(deadbeef, NULL, &subject);
164     ok ( !ret, "Expected CryptSIPRetrieveSubjectGuid to fail\n");
165     ok (GetLastError() == ERROR_FILE_NOT_FOUND,
166         "Expected ERROR_FILE_NOT_FOUND, got %d.\n", GetLastError());
167     ok ( !memcmp(&subject, &nullSubject, sizeof(GUID)),
168         "Expected a NULL GUID for c:\\deadbeef.dbf, not %s\n", show_guid(&subject));
169
170     /* Now with an executable that should exist
171      *
172      * Use A-functions where possible as that should be available on all platforms
173      */
174     ret = GetEnvironmentVariableA(windir, regeditPath, MAX_PATH);
175     ok (ret > 0, "expected GEVA(windir) to succeed, last error %d\n", GetLastError());
176     strcat(regeditPath, "\\");
177     strcat(regeditPath, regeditExe);
178     MultiByteToWideChar( CP_ACP, 0, regeditPath,
179                          strlen(regeditPath)+1, regeditPathW,
180                          sizeof(regeditPathW)/sizeof(regeditPathW[0]) );
181
182     SetLastError(0xdeadbeef);
183     memset(&subject, 1, sizeof(GUID));
184     ret = CryptSIPRetrieveSubjectGuid(regeditPathW, NULL, &subject);
185     ok ( ret, "Expected CryptSIPRetrieveSubjectGuid to succeed\n");
186     ok ( !memcmp(&subject, &unknownGUID, sizeof(GUID)),
187         "Expected (%s), got (%s).\n", show_guid(&unknownGUID), show_guid(&subject));
188
189     /* The same thing but now with a handle instead of a filename */
190     file = CreateFileA(regeditPath, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
191     SetLastError(0xdeadbeef);
192     memset(&subject, 1, sizeof(GUID));
193     ret = CryptSIPRetrieveSubjectGuid(NULL, file, &subject);
194     ok ( ret, "Expected CryptSIPRetrieveSubjectGuid to succeed\n");
195     ok ( !memcmp(&subject, &unknownGUID, sizeof(GUID)),
196         "Expected (%s), got (%s).\n", show_guid(&unknownGUID), show_guid(&subject));
197     CloseHandle(file);
198
199     /* And both */
200     file = CreateFileA(regeditPath, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
201     SetLastError(0xdeadbeef);
202     memset(&subject, 1, sizeof(GUID));
203     ret = CryptSIPRetrieveSubjectGuid(regeditPathW, file, &subject);
204     ok ( ret, "Expected CryptSIPRetrieveSubjectGuid to succeed\n");
205     ok ( !memcmp(&subject, &unknownGUID, sizeof(GUID)),
206         "Expected (%s), got (%s).\n", show_guid(&unknownGUID), show_guid(&subject));
207     CloseHandle(file);
208
209     /* Now with an empty file */
210     GetTempPathA(sizeof(path), path);
211     GetTempFileNameA(path, "sip", 0 , tempfile);
212     MultiByteToWideChar( CP_ACP, 0, tempfile,
213                          strlen(tempfile)+1, tempfileW,
214                          sizeof(tempfileW)/sizeof(tempfileW[0]) );
215
216     SetLastError(0xdeadbeef);
217     memset(&subject, 1, sizeof(GUID));
218     ret = CryptSIPRetrieveSubjectGuid(tempfileW, NULL, &subject);
219     ok ( !ret, "Expected CryptSIPRetrieveSubjectGuid to fail\n");
220     ok ( GetLastError() == ERROR_FILE_INVALID ||
221          GetLastError() == ERROR_INVALID_PARAMETER /* Vista */ ||
222          GetLastError() == ERROR_SUCCESS /* Win98 */,
223         "Expected ERROR_FILE_INVALID, ERROR_INVALID_PARAMETER or ERROR_SUCCESS, got 0x%08x\n", GetLastError());
224     ok ( !memcmp(&subject, &nullSubject, sizeof(GUID)),
225         "Expected a NULL GUID for empty file %s, not %s\n", tempfile, show_guid(&subject));
226
227     /* Use a file with a size of 3 (at least < 4) */
228     file = CreateFileA(tempfile, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
229     WriteFile(file, "123", 3, &written, NULL);
230     CloseHandle(file);
231
232     SetLastError(0xdeadbeef);
233     memset(&subject, 1, sizeof(GUID));
234     ret = CryptSIPRetrieveSubjectGuid(tempfileW, NULL, &subject);
235     ok ( !ret, "Expected CryptSIPRetrieveSubjectGuid to fail\n");
236     ok ( GetLastError() == ERROR_INVALID_PARAMETER ||
237          GetLastError() == ERROR_SUCCESS /* Win98 */,
238         "Expected ERROR_INVALID_PARAMETER or ERROR_SUCCESS, got 0x%08x\n", GetLastError());
239     ok ( !memcmp(&subject, &nullSubject, sizeof(GUID)),
240         "Expected a NULL GUID for empty file %s, not %s\n", tempfile, show_guid(&subject));
241
242     /* And now >= 4 */
243     file = CreateFileA(tempfile, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
244     WriteFile(file, "1234", 4, &written, NULL);
245     CloseHandle(file);
246
247     SetLastError(0xdeadbeef);
248     memset(&subject, 1, sizeof(GUID));
249     ret = CryptSIPRetrieveSubjectGuid(tempfileW, NULL, &subject);
250     ok ( !ret, "Expected CryptSIPRetrieveSubjectGuid to fail\n");
251     ok ( GetLastError() == TRUST_E_SUBJECT_FORM_UNKNOWN ||
252          GetLastError() == ERROR_SUCCESS /* Win98 */,
253         "Expected TRUST_E_SUBJECT_FORM_UNKNOWN or ERROR_SUCCESS, got 0x%08x\n", GetLastError());
254     ok ( !memcmp(&subject, &nullSubject, sizeof(GUID)),
255         "Expected a NULL GUID for empty file %s, not %s\n", tempfile, show_guid(&subject));
256
257     /* Clean up */
258     DeleteFileA(tempfile);
259 }
260
261 static void test_SIPLoad(void)
262 {
263     BOOL ret;
264     GUID subject;
265     static GUID dummySubject = { 0xdeadbeef, 0xdead, 0xbeef, { 0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef }};
266     static GUID unknown      = { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }}; /* WINTRUST.DLL */
267     static GUID unknown2     = { 0xDE351A43, 0x8E59, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }}; /* WINTRUST.DLL */
268     /* The next SIP is available on Windows (not on a clean Wine install) */
269     static GUID unknown3     = { 0x000C10F1, 0x0000, 0x0000, { 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 }}; /* MSISIP.DLL */
270     SIP_DISPATCH_INFO sdi;
271     HMODULE hCrypt;
272
273     /* All NULL */
274     SetLastError(0xdeadbeef);
275     ret = CryptSIPLoad(NULL, 0, NULL);
276     ok ( !ret, "Expected CryptSIPLoad to fail\n");
277     ok ( GetLastError() == ERROR_INVALID_PARAMETER,
278         "Expected ERROR_INVALID_PARAMETER, got 0x%08x\n", GetLastError());
279
280     /* Only pSipDispatch NULL */
281     SetLastError(0xdeadbeef);
282     ret = CryptSIPLoad(&subject, 0, NULL);
283     ok ( !ret, "Expected CryptSIPLoad to fail\n");
284     ok ( GetLastError() == ERROR_INVALID_PARAMETER,
285         "Expected ERROR_INVALID_PARAMETER, got 0x%08x\n", GetLastError());
286
287     /* No NULLs, but nonexistent pgSubject */
288     SetLastError(0xdeadbeef);
289     memset(&sdi, 0, sizeof(SIP_DISPATCH_INFO));
290     sdi.cbSize = sizeof(SIP_DISPATCH_INFO);
291     sdi.pfGet = (pCryptSIPGetSignedDataMsg)0xdeadbeef;
292     ret = CryptSIPLoad(&dummySubject, 0, &sdi);
293     ok ( !ret, "Expected CryptSIPLoad to fail\n");
294     ok ( GetLastError() == TRUST_E_SUBJECT_FORM_UNKNOWN,
295         "Expected TRUST_E_SUBJECT_FORM_UNKNOWN, got 0x%08x\n", GetLastError());
296     ok( sdi.pfGet == (pCryptSIPGetSignedDataMsg)0xdeadbeef, "Expected no change to the function pointer\n");
297
298     hCrypt = GetModuleHandleA("crypt32.dll");
299     funcCryptSIPGetSignedDataMsg = (void*)GetProcAddress(hCrypt, "CryptSIPGetSignedDataMsg");
300     funcCryptSIPPutSignedDataMsg = (void*)GetProcAddress(hCrypt, "CryptSIPPutSignedDataMsg");
301     funcCryptSIPCreateIndirectData = (void*)GetProcAddress(hCrypt, "CryptSIPCreateIndirectData");
302     funcCryptSIPVerifyIndirectData = (void*)GetProcAddress(hCrypt, "CryptSIPVerifyIndirectData");
303     funcCryptSIPRemoveSignedDataMsg = (void*)GetProcAddress(hCrypt, "CryptSIPRemoveSignedDataMsg");
304
305     /* All OK */
306     SetLastError(0xdeadbeef);
307     memset(&sdi, 0, sizeof(SIP_DISPATCH_INFO));
308     sdi.cbSize = sizeof(SIP_DISPATCH_INFO);
309     sdi.pfGet = (pCryptSIPGetSignedDataMsg)0xdeadbeef;
310     ret = CryptSIPLoad(&unknown, 0, &sdi);
311     ok ( ret, "Expected CryptSIPLoad to succeed\n");
312     /* On native the last error will always be ERROR_PROC_NOT_FOUND as native searches for the function DllCanUnloadNow
313      * in WINTRUST.DLL (in this case). This function is not available in WINTRUST.DLL.
314      * For now there's no need to implement this is Wine as I doubt any program will rely on
315      * this last error when the call succeeded.
316      */
317     ok( sdi.pfGet != (pCryptSIPGetSignedDataMsg)0xdeadbeef, "Expected a function pointer to be loaded.\n");
318
319     /* The function addresses returned by CryptSIPLoad are actually the addresses of
320      * crypt32's own functions. A function calling these addresses will end up first
321      * calling crypt32 functions which in its turn call the equivalent in the SIP
322      * as dictated by the given GUID.
323      */
324     if (funcCryptSIPGetSignedDataMsg && funcCryptSIPPutSignedDataMsg && funcCryptSIPCreateIndirectData &&
325         funcCryptSIPVerifyIndirectData && funcCryptSIPRemoveSignedDataMsg)
326         ok (sdi.pfGet == funcCryptSIPGetSignedDataMsg &&
327             sdi.pfPut == funcCryptSIPPutSignedDataMsg &&
328             sdi.pfCreate == funcCryptSIPCreateIndirectData &&
329             sdi.pfVerify == funcCryptSIPVerifyIndirectData &&
330             sdi.pfRemove == funcCryptSIPRemoveSignedDataMsg,
331             "Expected function addresses to be from crypt32\n");
332     else
333         trace("Couldn't load function pointers\n");
334
335     /* All OK, but different GUID (same SIP though) */
336     SetLastError(0xdeadbeef);
337     memset(&sdi, 0, sizeof(SIP_DISPATCH_INFO));
338     sdi.cbSize = sizeof(SIP_DISPATCH_INFO);
339     sdi.pfGet = (pCryptSIPGetSignedDataMsg)0xdeadbeef;
340     ret = CryptSIPLoad(&unknown2, 0, &sdi);
341     ok ( ret, "Expected CryptSIPLoad to succeed\n");
342     /* This call on its own would have resulted in an ERROR_PROC_NOT_FOUND, but the previous
343      * call to CryptSIPLoad already loaded wintrust.dll. As this information is cached,
344      * CryptSIPLoad will not try to search for the already mentioned DllCanUnloadNow.
345      */
346     ok( sdi.pfGet != (pCryptSIPGetSignedDataMsg)0xdeadbeef, "Expected a function pointer to be loaded.\n");
347
348     /* All OK, but other SIP */
349     SetLastError(0xdeadbeef);
350     memset(&sdi, 0, sizeof(SIP_DISPATCH_INFO));
351     sdi.cbSize = sizeof(SIP_DISPATCH_INFO);
352     sdi.pfGet = (pCryptSIPGetSignedDataMsg)0xdeadbeef;
353     ret = CryptSIPLoad(&unknown3, 0, &sdi);
354     if (ret)
355     {
356         /* The SIP is known so we can safely assume that the next tests can be done */
357
358         /* As msisip.dll is not checked yet by any of the previous calls, the
359          * function DllCanUnloadNow will be checked again in msisip.dll (it's not present)
360          */
361         todo_wine
362         {
363             ok( sdi.pfGet != (pCryptSIPGetSignedDataMsg)0xdeadbeef, "Expected a function pointer to be loaded.\n");
364
365             /* This is another SIP but this test proves the function addresses are the same as
366              * in the previous test.
367              */
368             if (funcCryptSIPGetSignedDataMsg && funcCryptSIPPutSignedDataMsg && funcCryptSIPCreateIndirectData &&
369                 funcCryptSIPVerifyIndirectData && funcCryptSIPRemoveSignedDataMsg)
370                 ok (sdi.pfGet == funcCryptSIPGetSignedDataMsg &&
371                     sdi.pfPut == funcCryptSIPPutSignedDataMsg &&
372                     sdi.pfCreate == funcCryptSIPCreateIndirectData &&
373                     sdi.pfVerify == funcCryptSIPVerifyIndirectData &&
374                     sdi.pfRemove == funcCryptSIPRemoveSignedDataMsg,
375                     "Expected function addresses to be from crypt32\n");
376             else
377                 trace("Couldn't load function pointers\n");
378         }
379     }
380
381     /* Reserved parameter not 0 */
382     SetLastError(0xdeadbeef);
383     memset(&sdi, 0, sizeof(SIP_DISPATCH_INFO));
384     sdi.cbSize = sizeof(SIP_DISPATCH_INFO);
385     sdi.pfGet = (pCryptSIPGetSignedDataMsg)0xdeadbeef;
386     ret = CryptSIPLoad(&unknown, 1, &sdi);
387     ok ( !ret, "Expected CryptSIPLoad to fail\n");
388     ok ( GetLastError() == ERROR_INVALID_PARAMETER,
389         "Expected ERROR_INVALID_PARAMETER, got 0x%08x\n", GetLastError());
390     ok( sdi.pfGet == (pCryptSIPGetSignedDataMsg)0xdeadbeef, "Expected no change to the function pointer\n");
391 }
392
393 START_TEST(sip)
394 {
395     test_AddRemoveProvider();
396     /* It seems that the caching for loaded dlls is shared between CryptSIPRetrieveSubjectGUID
397      * and CryptSIPLoad. The tests have to be in this order to succeed. This is because in the last
398      * test for CryptSIPRetrieveSubjectGUID, several SIPs will be loaded (on Windows).
399      */
400     test_SIPLoad();
401     test_SIPRetrieveSubjectGUID();
402 }