1 /* Unit test suite for wintrust crypt functions
3 * Copyright 2007 Paul Vriens
4 * Copyright 2008 Hans Leidekker for CodeWeavers
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.
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.
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
28 #include "wine/test.h"
30 static char selfname[MAX_PATH];
31 static CHAR CURR_DIR[MAX_PATH];
32 static CHAR catroot[MAX_PATH];
33 static CHAR catroot2[MAX_PATH];
35 static const WCHAR hashmeW[] = {'h','a','s','h','m','e',0};
36 static const WCHAR attr1W[] = {'a','t','t','r','1',0};
37 static const WCHAR attr2W[] = {'a','t','t','r','2',0};
40 * Minimalistic catalog file. To reconstruct, save text below as winetest.cdf,
41 * convert to DOS line endings and run 'makecat /cat winetest.cdf'
48 PublicVersion=0x00000001
50 CATATTR1=0x10010001:attr1:value1
51 CATATTR2=0x10010001:attr2:value2
57 static const CHAR test_cdf[] =
59 "Name=winetest.cat\r\n"
61 "PublicVersion=0x00000001\r\n"
63 "CATATTR1=0x10010001:attr1:value1\r\n"
64 "CATATTR2=0x10010001:attr2:value2\r\n"
67 "hashme=.\\winetest.cdf\r\n";
69 static const BYTE test_catalog[] = {
70 0x30, 0x82, 0x01, 0xbc, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x02, 0xa0,
71 0x82, 0x01, 0xad, 0x30, 0x82, 0x01, 0xa9, 0x02, 0x01, 0x01, 0x31, 0x00, 0x30, 0x82, 0x01, 0x9e,
72 0x06, 0x09, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0a, 0x01, 0xa0, 0x82, 0x01, 0x8f, 0x30,
73 0x82, 0x01, 0x8b, 0x30, 0x0c, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x01,
74 0x01, 0x04, 0x10, 0xfa, 0x55, 0x2c, 0xc2, 0xf6, 0xcc, 0xdd, 0x11, 0x2a, 0x9c, 0x00, 0x14, 0x22,
75 0xec, 0x8f, 0x3b, 0x17, 0x0d, 0x30, 0x38, 0x31, 0x32, 0x31, 0x38, 0x31, 0x31, 0x32, 0x36, 0x34,
76 0x38, 0x5a, 0x30, 0x0e, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x01, 0x02,
77 0x05, 0x00, 0x30, 0x81, 0xdd, 0x30, 0x81, 0xda, 0x04, 0x0e, 0x68, 0x00, 0x61, 0x00, 0x73, 0x00,
78 0x68, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x00, 0x00, 0x31, 0x81, 0xc7, 0x30, 0x61, 0x06, 0x0a, 0x2b,
79 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x04, 0x31, 0x53, 0x30, 0x51, 0x30, 0x2c, 0x06,
80 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x19, 0xa2, 0x1e, 0x80, 0x1c, 0x00,
81 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x4f, 0x00, 0x62, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x6c, 0x00,
82 0x65, 0x00, 0x74, 0x00, 0x65, 0x00, 0x3e, 0x00, 0x3e, 0x00, 0x3e, 0x30, 0x21, 0x30, 0x09, 0x06,
83 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, 0xed, 0xd6, 0x9c, 0x9c, 0xb2, 0xfc,
84 0xaa, 0x03, 0xe8, 0xd3, 0x20, 0xf6, 0xab, 0x28, 0xc3, 0xff, 0xbd, 0x07, 0x36, 0xf5, 0x30, 0x62,
85 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x02, 0x02, 0x31, 0x54, 0x30, 0x52,
86 0x1e, 0x4c, 0x00, 0x7b, 0x00, 0x44, 0x00, 0x45, 0x00, 0x33, 0x00, 0x35, 0x00, 0x31, 0x00, 0x41,
87 0x00, 0x34, 0x00, 0x32, 0x00, 0x2d, 0x00, 0x38, 0x00, 0x45, 0x00, 0x35, 0x00, 0x39, 0x00, 0x2d,
88 0x00, 0x31, 0x00, 0x31, 0x00, 0x44, 0x00, 0x30, 0x00, 0x2d, 0x00, 0x38, 0x00, 0x43, 0x00, 0x34,
89 0x00, 0x37, 0x00, 0x2d, 0x00, 0x30, 0x00, 0x30, 0x00, 0x43, 0x00, 0x30, 0x00, 0x34, 0x00, 0x46,
90 0x00, 0x43, 0x00, 0x32, 0x00, 0x39, 0x00, 0x35, 0x00, 0x45, 0x00, 0x45, 0x00, 0x7d, 0x02, 0x02,
91 0x02, 0x00, 0xa0, 0x6a, 0x30, 0x68, 0x30, 0x32, 0x06, 0x0a, 0x2b, 0x06, 0x01, 0x04, 0x01, 0x82,
92 0x37, 0x0c, 0x02, 0x01, 0x04, 0x24, 0x30, 0x22, 0x1e, 0x0a, 0x00, 0x61, 0x00, 0x74, 0x00, 0x74,
93 0x00, 0x72, 0x00, 0x32, 0x02, 0x04, 0x10, 0x01, 0x00, 0x01, 0x04, 0x0e, 0x76, 0x00, 0x61, 0x00,
94 0x6c, 0x00, 0x75, 0x00, 0x65, 0x00, 0x32, 0x00, 0x00, 0x00, 0x30, 0x32, 0x06, 0x0a, 0x2b, 0x06,
95 0x01, 0x04, 0x01, 0x82, 0x37, 0x0c, 0x02, 0x01, 0x04, 0x24, 0x30, 0x22, 0x1e, 0x0a, 0x00, 0x61,
96 0x00, 0x74, 0x00, 0x74, 0x00, 0x72, 0x00, 0x31, 0x02, 0x04, 0x10, 0x01, 0x00, 0x01, 0x04, 0x0e,
97 0x76, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x75, 0x00, 0x65, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31, 0x00,
100 static BOOL (WINAPI * pCryptCATAdminAcquireContext)(HCATADMIN*, const GUID*, DWORD);
101 static BOOL (WINAPI * pCryptCATAdminReleaseContext)(HCATADMIN, DWORD);
102 static BOOL (WINAPI * pCryptCATAdminCalcHashFromFileHandle)(HANDLE hFile, DWORD*, BYTE*, DWORD);
103 static HCATINFO (WINAPI * pCryptCATAdminAddCatalog)(HCATADMIN, PWSTR, PWSTR, DWORD);
104 static BOOL (WINAPI * pCryptCATAdminRemoveCatalog)(HCATADMIN, LPCWSTR, DWORD);
105 static BOOL (WINAPI * pCryptCATAdminReleaseCatalogContext)(HCATADMIN, HCATINFO, DWORD);
106 static HANDLE (WINAPI * pCryptCATOpen)(LPWSTR, DWORD, HCRYPTPROV, DWORD, DWORD);
107 static BOOL (WINAPI * pCryptCATCatalogInfoFromContext)(HCATINFO, CATALOG_INFO *, DWORD);
108 static BOOL (WINAPI * pCryptCATCDFClose)(CRYPTCATCDF *);
109 static CRYPTCATATTRIBUTE * (WINAPI * pCryptCATCDFEnumCatAttributes)(CRYPTCATCDF *, CRYPTCATATTRIBUTE *,
110 PFN_CDF_PARSE_ERROR_CALLBACK);
111 static LPWSTR (WINAPI * pCryptCATCDFEnumMembersByCDFTagEx)(CRYPTCATCDF *, LPWSTR, PFN_CDF_PARSE_ERROR_CALLBACK,
112 CRYPTCATMEMBER **, BOOL, LPVOID);
113 static CRYPTCATCDF * (WINAPI * pCryptCATCDFOpen)(LPWSTR, PFN_CDF_PARSE_ERROR_CALLBACK);
114 static CRYPTCATATTRIBUTE * (WINAPI * pCryptCATEnumerateCatAttr)(HANDLE, CRYPTCATATTRIBUTE *);
115 static CRYPTCATMEMBER * (WINAPI * pCryptCATEnumerateMember)(HANDLE, CRYPTCATMEMBER *);
116 static CRYPTCATATTRIBUTE * (WINAPI * pCryptCATEnumerateAttr)(HANDLE, CRYPTCATMEMBER *, CRYPTCATATTRIBUTE *);
117 static BOOL (WINAPI * pCryptCATClose)(HANDLE);
118 static pCryptSIPGetSignedDataMsg pGetSignedDataMsg;
119 static pCryptSIPPutSignedDataMsg pPutSignedDataMsg;
121 static void InitFunctionPtrs(void)
123 HMODULE hWintrust = GetModuleHandleA("wintrust.dll");
125 #define WINTRUST_GET_PROC(func) \
126 p ## func = (void*)GetProcAddress(hWintrust, #func); \
128 trace("GetProcAddress(%s) failed\n", #func); \
131 WINTRUST_GET_PROC(CryptCATAdminAcquireContext)
132 WINTRUST_GET_PROC(CryptCATAdminReleaseContext)
133 WINTRUST_GET_PROC(CryptCATAdminCalcHashFromFileHandle)
134 WINTRUST_GET_PROC(CryptCATAdminAddCatalog)
135 WINTRUST_GET_PROC(CryptCATAdminRemoveCatalog)
136 WINTRUST_GET_PROC(CryptCATAdminReleaseCatalogContext)
137 WINTRUST_GET_PROC(CryptCATOpen)
138 WINTRUST_GET_PROC(CryptCATCatalogInfoFromContext)
139 WINTRUST_GET_PROC(CryptCATCDFClose)
140 WINTRUST_GET_PROC(CryptCATCDFEnumCatAttributes)
141 WINTRUST_GET_PROC(CryptCATCDFEnumMembersByCDFTagEx)
142 WINTRUST_GET_PROC(CryptCATCDFOpen)
143 WINTRUST_GET_PROC(CryptCATEnumerateCatAttr)
144 WINTRUST_GET_PROC(CryptCATEnumerateMember)
145 WINTRUST_GET_PROC(CryptCATEnumerateAttr)
146 WINTRUST_GET_PROC(CryptCATClose)
148 #undef WINTRUST_GET_PROC
150 pGetSignedDataMsg = (void*)GetProcAddress(hWintrust, "CryptSIPGetSignedDataMsg");
151 if(!pGetSignedDataMsg)
152 trace("GetProcAddress(CryptSIPGetSignedDataMsg) failed\n");
154 pPutSignedDataMsg = (void*)GetProcAddress(hWintrust, "CryptSIPPutSignedDataMsg");
155 if(!pPutSignedDataMsg)
156 trace("GetProcAddress(CryptSIPPutSignedDataMsg) failed\n");
159 static GUID dummy = {0xdeadbeef,0xdead,0xbeef,{0xde,0xad,0xbe,0xef,0xde,0xad,0xbe,0xef}};
161 static void test_context(void)
165 static GUID unknown = { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }}; /* WINTRUST.DLL */
166 CHAR dummydir[MAX_PATH];
169 /* When CryptCATAdminAcquireContext is successful it will create
170 * several directories if they don't exist:
172 * ...\system32\CatRoot\{GUID}, this directory holds the .cat files
173 * ...\system32\CatRoot2\{GUID} (WinXP and up), here we find the catalog database for that GUID
175 * Windows Vista uses lowercase catroot and catroot2.
177 * When passed a NULL GUID it will create the following directories although on
178 * WinXP and up these directories are already present when Windows is installed:
180 * ...\system32\CatRoot\{127D0A1D-4EF2-11D1-8608-00C04FC295EE}
181 * ...\system32\CatRoot2\{127D0A1D-4EF2-11D1-8608-00C04FC295EE} (WinXP up)
183 * TODO: Find out what this GUID is/does.
185 * On WinXP and up there is also a TimeStamp file in some of directories that
186 * seem to indicate the last change to the catalog database for that GUID.
188 * On Windows 2000 some files are created/updated:
190 * ...\system32\CatRoot\SYSMAST.cbk
191 * ...\system32\CatRoot\SYSMAST.cbd
192 * ...\system32\CatRoot\{GUID}\CATMAST.cbk
193 * ...\system32\CatRoot\{GUID}\CATMAST.cbd
198 SetLastError(0xdeadbeef);
199 ret = pCryptCATAdminAcquireContext(NULL, NULL, 0);
200 ok(!ret, "Expected failure\n");
201 ok(GetLastError() == ERROR_INVALID_PARAMETER,
202 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
205 ret = pCryptCATAdminAcquireContext(&hca, NULL, 0);
206 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
207 ok(hca != NULL, "Expected a context handle, got NULL\n");
210 SetLastError(0xdeadbeef);
211 ret = pCryptCATAdminReleaseContext(NULL, 0);
212 ok(!ret, "Expected failure\n");
213 ok(GetLastError() == ERROR_INVALID_PARAMETER,
214 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
217 SetLastError(0xdeadbeef);
218 ret = pCryptCATAdminReleaseContext(hca, 0);
219 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
221 /* Try to release a second time */
222 SetLastError(0xdeadbeef);
223 ret = pCryptCATAdminReleaseContext(hca, 0);
224 ok(!ret, "Expected failure\n");
225 ok(GetLastError() == ERROR_INVALID_PARAMETER,
226 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
228 /* NULL context handle and dummy GUID */
229 SetLastError(0xdeadbeef);
230 ret = pCryptCATAdminAcquireContext(NULL, &dummy, 0);
231 ok(!ret, "Expected failure\n");
232 ok(GetLastError() == ERROR_INVALID_PARAMETER,
233 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
235 /* Correct context handle and dummy GUID
237 * The tests run in the past unfortunately made sure that some directories were created.
240 * We don't want to mess too much with these for now so we should delete only the ones
241 * that shouldn't be there like the deadbeef ones. We first have to figure out if it's
242 * save to remove files and directories from CatRoot/CatRoot2.
245 ret = pCryptCATAdminAcquireContext(&hca, &dummy, 0);
246 ok(ret || GetLastError() == ERROR_ACCESS_DENIED, "CryptCATAdminAcquireContext failed %u\n", GetLastError());
247 if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
249 win_skip("Not running as administrator\n");
252 ok(hca != NULL, "Expected a context handle, got NULL\n");
254 attrs = GetFileAttributes(catroot);
255 ok(attrs != INVALID_FILE_ATTRIBUTES, "Expected the CatRoot directory to exist\n");
257 /* Windows creates the GUID directory in capitals */
258 lstrcpyA(dummydir, catroot);
259 lstrcatA(dummydir, "\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF}");
260 attrs = GetFileAttributes(dummydir);
261 ok(attrs != INVALID_FILE_ATTRIBUTES,
262 "Expected CatRoot\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF} directory to exist\n");
264 /* Only present on XP or higher. */
265 attrs = GetFileAttributes(catroot2);
266 if (attrs != INVALID_FILE_ATTRIBUTES)
268 lstrcpyA(dummydir, catroot2);
269 lstrcatA(dummydir, "\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF}");
270 attrs = GetFileAttributes(dummydir);
271 ok(attrs != INVALID_FILE_ATTRIBUTES,
272 "Expected CatRoot2\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF} directory to exist\n");
275 ret = pCryptCATAdminReleaseContext(hca, 0);
276 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
278 /* Correct context handle and GUID */
279 ret = pCryptCATAdminAcquireContext(&hca, &unknown, 0);
280 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
281 ok(hca != NULL, "Expected a context handle, got NULL\n");
283 ret = pCryptCATAdminReleaseContext(hca, 0);
284 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
286 /* Flags not equal to 0 */
287 ret = pCryptCATAdminAcquireContext(&hca, &unknown, 1);
288 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
289 ok(hca != NULL, "Expected a context handle, got NULL\n");
291 ret = pCryptCATAdminReleaseContext(hca, 0);
292 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
295 /* TODO: Check whether SHA-1 is the algorithm that's always used */
296 static void test_calchash(void)
302 BYTE expectedhash[20] = {0x3a,0xa1,0x19,0x08,0xec,0xa6,0x0d,0x2e,0x7e,0xcc,0x7a,0xca,0xf5,0xb8,0x2e,0x62,0x6a,0xda,0xf0,0x19};
307 SetLastError(0xdeadbeef);
308 ret = pCryptCATAdminCalcHashFromFileHandle(NULL, NULL, NULL, 0);
309 ok(!ret, "Expected failure\n");
310 ok(GetLastError() == ERROR_INVALID_PARAMETER,
311 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
313 /* NULL filehandle, rest is legal */
314 SetLastError(0xdeadbeef);
315 ret = pCryptCATAdminCalcHashFromFileHandle(NULL, &hashsize, NULL, 0);
316 ok(!ret, "Expected failure\n");
317 ok(GetLastError() == ERROR_INVALID_PARAMETER,
318 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
320 /* Correct filehandle, rest is NULL */
321 file = CreateFileA(selfname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
322 SetLastError(0xdeadbeef);
323 ret = pCryptCATAdminCalcHashFromFileHandle(file, NULL, NULL, 0);
324 ok(!ret, "Expected failure\n");
325 ok(GetLastError() == ERROR_INVALID_PARAMETER,
326 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
329 /* All OK, but dwFlags set to 1 */
330 file = CreateFileA(selfname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
331 SetLastError(0xdeadbeef);
332 ret = pCryptCATAdminCalcHashFromFileHandle(file, &hashsize, NULL, 1);
333 ok(!ret, "Expected failure\n");
334 ok(GetLastError() == ERROR_INVALID_PARAMETER,
335 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
338 /* All OK, requesting the size of the hash */
339 file = CreateFileA(selfname, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
340 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed %u\n", GetLastError());
341 SetLastError(0xdeadbeef);
342 ret = pCryptCATAdminCalcHashFromFileHandle(file, &hashsize, NULL, 0);
343 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
344 ok(hashsize == 20," Expected a hash size of 20, got %d\n", hashsize);
345 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
346 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
349 /* All OK, retrieve the hash
350 * Double the hash buffer to see what happens to the size parameter
352 file = CreateFileA(selfname, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
354 hash = HeapAlloc(GetProcessHeap(), 0, hashsize);
355 SetLastError(0xdeadbeef);
356 ret = pCryptCATAdminCalcHashFromFileHandle(file, &hashsize, hash, 0);
357 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
358 ok(hashsize == 20," Expected a hash size of 20, got %d\n", hashsize);
359 ok(GetLastError() == ERROR_SUCCESS,
360 "Expected ERROR_SUCCESS, got %d\n", GetLastError());
362 HeapFree(GetProcessHeap(), 0, hash);
364 /* Do the same test with a file created and filled by ourselves (and we thus
365 * have a known hash for).
367 GetTempFileNameA(CURR_DIR, "hsh", 0, temp);
368 file = CreateFileA(temp, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
369 WriteFile(file, "Text in this file is needed to create a know hash", 49, &written, NULL);
372 /* All OK, first request the size and then retrieve the hash */
373 file = CreateFileA(temp, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
375 pCryptCATAdminCalcHashFromFileHandle(file, &hashsize, NULL, 0);
376 hash = HeapAlloc(GetProcessHeap(), 0, hashsize);
377 SetLastError(0xdeadbeef);
378 ret = pCryptCATAdminCalcHashFromFileHandle(file, &hashsize, hash, 0);
379 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
380 ok(GetLastError() == ERROR_SUCCESS,
381 "Expected ERROR_SUCCESS, got %d\n", GetLastError());
382 ok(hashsize == sizeof(expectedhash) &&
383 !memcmp(hash, expectedhash, sizeof(expectedhash)),
384 "Hashes didn't match\n");
387 HeapFree(GetProcessHeap(), 0, hash);
391 static void test_CryptCATOpen(void)
394 char empty[MAX_PATH];
395 WCHAR emptyW[MAX_PATH];
399 SetLastError(0xdeadbeef);
400 hcat = pCryptCATOpen(NULL, 0, 0, 0, 0);
401 ok(hcat == INVALID_HANDLE_VALUE, "CryptCATOpen succeeded\n");
402 ok(GetLastError() == ERROR_INVALID_PARAMETER,
403 "Expected ERROR_INVALID_PARAMETER, got %08x\n", GetLastError());
405 if (!GetTempFileNameA(CURR_DIR, "cat", 0, empty)) return;
407 file = CreateFileA(empty, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
408 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %u\n", GetLastError());
410 MultiByteToWideChar(CP_ACP, 0, empty, -1, emptyW, MAX_PATH);
412 hcat = pCryptCATOpen(emptyW, 0, 0, 0, 0);
414 ok(hcat != INVALID_HANDLE_VALUE, "Expected a correct handle\n");
416 ret = pCryptCATClose(hcat);
418 ok(ret, "CryptCATClose failed\n");
422 static DWORD error_area;
423 static DWORD local_error;
425 static void WINAPI cdf_callback(DWORD area, DWORD error, WCHAR* line)
427 ok(error_area != -2, "Didn't expect cdf_callback() to be called (%08x, %08x)\n",
434 static void test_CryptCATCDF_params(void)
436 static WCHAR nonexistent[] = {'d','e','a','d','b','e','e','f','.','c','d','f',0};
440 if (!pCryptCATCDFOpen)
442 win_skip("CryptCATCDFOpen is not available\n");
446 SetLastError(0xdeadbeef);
447 catcdf = pCryptCATCDFOpen(NULL, NULL);
448 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
450 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
452 SetLastError(0xdeadbeef);
453 catcdf = pCryptCATCDFOpen(NULL, cdf_callback);
454 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
456 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
458 /* File doesn't exist */
459 SetLastError(0xdeadbeef);
460 catcdf = pCryptCATCDFOpen(nonexistent, cdf_callback);
461 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
463 ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
465 SetLastError(0xdeadbeef);
466 ret = pCryptCATCDFClose(NULL);
467 ok(!ret, "Expected failure\n");
469 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
472 SetLastError(0xdeadbeef);
473 ret = pCryptCATCDFClose(catcdf);
474 ok(!ret, "Expected failure\n");
476 ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
479 /* FIXME: Once Wine can create catalog files we should use the created catalog file in this test */
480 static void test_CryptCATAdminAddRemoveCatalog(void)
482 static WCHAR basenameW[] = {'w','i','n','e','t','e','s','t','.','c','a','t',0};
483 static CHAR basename[] = "winetest.cat";
487 WCHAR tmpfileW[MAX_PATH];
488 char tmpfile[MAX_PATH];
489 char catfile[MAX_PATH], catfilepath[MAX_PATH], *p;
490 WCHAR catfileW[MAX_PATH];
492 DWORD error, written;
496 if (!pCryptCATAdminRemoveCatalog)
498 /* NT4 and W2K do have CryptCATAdminAddCatalog !! */
499 win_skip("CryptCATAdminRemoveCatalog is not available\n");
503 if (!GetTempFileNameA(CURR_DIR, "cat", 0, tmpfile)) return;
504 DeleteFileA(tmpfile);
505 file = CreateFileA(tmpfile, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL);
506 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %u\n", GetLastError());
509 ret = pCryptCATAdminAcquireContext(&hcatadmin, &dummy, 0);
510 ok(ret || GetLastError() == ERROR_ACCESS_DENIED, "CryptCATAdminAcquireContext failed %u\n", GetLastError());
511 if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
513 win_skip("Not running as administrator\n");
517 SetLastError(0xdeadbeef);
518 hcatinfo = pCryptCATAdminAddCatalog(NULL, NULL, NULL, 0);
519 error = GetLastError();
520 ok(hcatinfo == NULL, "CryptCATAdminAddCatalog succeeded\n");
521 ok(error == ERROR_INVALID_PARAMETER, "got %u expected ERROR_INVALID_PARAMETER\n", GetLastError());
523 SetLastError(0xdeadbeef);
524 hcatinfo = pCryptCATAdminAddCatalog(hcatadmin, NULL, NULL, 0);
525 error = GetLastError();
526 ok(hcatinfo == NULL, "CryptCATAdminAddCatalog succeeded\n");
527 ok(error == ERROR_INVALID_PARAMETER, "got %u expected ERROR_INVALID_PARAMETER\n", GetLastError());
529 MultiByteToWideChar(CP_ACP, 0, tmpfile, -1, tmpfileW, MAX_PATH);
531 SetLastError(0xdeadbeef);
532 hcatinfo = pCryptCATAdminAddCatalog(hcatadmin, tmpfileW, basenameW, 0);
533 error = GetLastError();
535 ok(hcatinfo == NULL, "CryptCATAdminAddCatalog succeeded\n");
536 ok(error == ERROR_BAD_FORMAT, "got %u expected ERROR_BAD_FORMAT\n", GetLastError());
538 if (hcatinfo != NULL)
539 pCryptCATAdminReleaseCatalogContext(hcatadmin, hcatinfo, 0);
541 SetLastError(0xdeadbeef);
542 hcatinfo = pCryptCATAdminAddCatalog(hcatadmin, tmpfileW, basenameW, 1);
543 error = GetLastError();
544 ok(hcatinfo == NULL, "CryptCATAdminAddCatalog succeeded\n");
545 ok(error == ERROR_INVALID_PARAMETER, "got %u expected ERROR_INVALID_PARAMETER\n", GetLastError());
547 SetLastError(0xdeadbeef);
548 hcatinfo = pCryptCATAdminAddCatalog(hcatadmin, tmpfileW, NULL, 0);
549 error = GetLastError();
550 ok(hcatinfo == NULL, "CryptCATAdminAddCatalog succeeded\n");
551 todo_wine ok(error == ERROR_BAD_FORMAT, "got %u expected ERROR_BAD_FORMAT\n", GetLastError());
553 DeleteFileA(tmpfile);
554 file = CreateFileA(tmpfile, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL);
555 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %u\n", GetLastError());
556 WriteFile(file, test_catalog, sizeof(test_catalog), &written, NULL);
559 /* Unique name will be created */
560 hcatinfo = pCryptCATAdminAddCatalog(hcatadmin, tmpfileW, NULL, 0);
561 if (!hcatinfo && (GetLastError() == ERROR_ACCESS_DENIED))
563 win_skip("Not enough rights\n");
566 todo_wine ok(hcatinfo != NULL, "CryptCATAdminAddCatalog failed %u\n", GetLastError());
568 info.cbStruct = sizeof(info);
569 info.wszCatalogFile[0] = 0;
570 ret = pCryptCATCatalogInfoFromContext(hcatinfo, &info, 0);
573 ok(ret, "CryptCATCatalogInfoFromContext failed %u\n", GetLastError());
574 ok(info.wszCatalogFile[0] != 0, "Expected a filename\n");
576 WideCharToMultiByte(CP_ACP, 0, info.wszCatalogFile, -1, catfile, MAX_PATH, NULL, NULL);
577 if ((p = strrchr(catfile, '\\'))) p++;
578 memset(catfileW, 0, sizeof(catfileW));
579 MultiByteToWideChar(CP_ACP, 0, p, -1, catfileW, MAX_PATH);
581 /* Set the file attributes so we can check what happens with them during the 'copy' */
582 attrs = FILE_ATTRIBUTE_READONLY;
583 ret = SetFileAttributesA(tmpfile, attrs);
584 ok(ret, "SetFileAttributesA failed : %u\n", GetLastError());
586 /* winetest.cat will be created */
587 hcatinfo = pCryptCATAdminAddCatalog(hcatadmin, tmpfileW, basenameW, 0);
588 ok(hcatinfo != NULL, "CryptCATAdminAddCatalog failed %u\n", GetLastError());
590 lstrcpyA(catfilepath, catroot);
591 lstrcatA(catfilepath, "\\{DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF}\\winetest.cat");
592 attrs = GetFileAttributes(catfilepath);
593 ok(attrs != INVALID_FILE_ATTRIBUTES, "Expected %s to exist\n", catfilepath);
595 ok(attrs == FILE_ATTRIBUTE_SYSTEM ||
596 attrs == (FILE_ATTRIBUTE_NOT_CONTENT_INDEXED | FILE_ATTRIBUTE_SYSTEM), /* Vista */
597 "File has wrong attributes : %08x\n", attrs);
599 info.cbStruct = sizeof(info);
600 info.wszCatalogFile[0] = 0;
601 ret = pCryptCATCatalogInfoFromContext(hcatinfo, &info, 0);
602 ok(ret, "CryptCATCatalogInfoFromContext failed %u\n", GetLastError());
603 ok(info.wszCatalogFile[0] != 0, "Expected a filename\n");
604 WideCharToMultiByte(CP_ACP, 0, info.wszCatalogFile, -1, catfile, MAX_PATH, NULL, NULL);
605 if ((p = strrchr(catfile, '\\'))) p++;
606 ok(!lstrcmpA(basename, p), "Expected %s, got %s\n", basename, p);
608 ret = pCryptCATAdminReleaseCatalogContext(hcatadmin, hcatinfo, 0);
609 ok(ret, "CryptCATAdminReleaseCatalogContext failed %u\n", GetLastError());
611 /* Remove the catalog file with the unique name */
612 ret = pCryptCATAdminRemoveCatalog(hcatadmin, catfileW, 0);
613 ok(ret, "CryptCATAdminRemoveCatalog failed %u\n", GetLastError());
615 /* Remove the winetest.cat catalog file, first with the full path. This should not succeed
616 * according to MSDN */
617 ret = pCryptCATAdminRemoveCatalog(hcatadmin, info.wszCatalogFile, 0);
618 ok(ret, "CryptCATAdminRemoveCatalog failed %u\n", GetLastError());
619 /* The call succeeded with the full path but the file is not removed */
620 attrs = GetFileAttributes(catfilepath);
621 ok(attrs != INVALID_FILE_ATTRIBUTES, "Expected %s to exist\n", catfilepath);
622 /* Given only the filename the file is removed */
623 ret = pCryptCATAdminRemoveCatalog(hcatadmin, basenameW, 0);
624 ok(ret, "CryptCATAdminRemoveCatalog failed %u\n", GetLastError());
625 attrs = GetFileAttributes(catfilepath);
626 ok(attrs == INVALID_FILE_ATTRIBUTES, "Expected %s to be removed\n", catfilepath);
629 ret = pCryptCATAdminReleaseContext(hcatadmin, 0);
630 ok(ret, "CryptCATAdminReleaseContext failed %u\n", GetLastError());
632 /* Set the attributes so we can delete the file */
633 attrs = FILE_ATTRIBUTE_NORMAL;
634 ret = SetFileAttributesA(tmpfile, attrs);
635 ok(ret, "SetFileAttributesA failed %u\n", GetLastError());
636 DeleteFileA(tmpfile);
639 static void test_catalog_properties(CHAR *catfile, int attributes, int members)
641 static const GUID subject = {0xde351a42,0x8e59,0x11d0,{0x8c,0x47,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
645 CRYPTCATATTRIBUTE *attr;
646 char catalog[MAX_PATH];
647 WCHAR catalogW[MAX_PATH];
650 int attrcount = 0, membercount = 0;
652 /* FIXME: Wine can't create catalog files out of catalog definition files yet. Remove this piece
655 attrs = GetFileAttributesA(catfile);
656 if (attrs == INVALID_FILE_ATTRIBUTES)
661 trace("Creating the catalog file\n");
662 if (!GetTempFileNameA(CURR_DIR, "cat", 0, catalog)) return;
663 file = CreateFileA(catalog, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
664 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %u\n", GetLastError());
665 WriteFile(file, test_catalog, sizeof(test_catalog), &written, NULL);
670 MultiByteToWideChar(CP_ACP, 0, catalog, -1, catalogW, MAX_PATH);
674 MultiByteToWideChar(CP_ACP, 0, catfile, -1, catalogW, MAX_PATH);
678 hcat = pCryptCATOpen(catalogW, 0, 0, 0, 0);
679 if (hcat == INVALID_HANDLE_VALUE && members == 0)
681 win_skip("CryptCATOpen on W2K can't handle catalog files with no members\n");
684 ok(hcat != INVALID_HANDLE_VALUE, "CryptCATOpen failed %u\n", GetLastError());
686 m = pCryptCATEnumerateMember(NULL, NULL);
687 ok(m == NULL, "CryptCATEnumerateMember succeeded\n");
690 while ((m = pCryptCATEnumerateMember(hcat, m)))
692 ok(m->cbStruct == sizeof(CRYPTCATMEMBER), "unexpected size %u\n", m->cbStruct);
693 todo_wine ok(!lstrcmpW(m->pwszReferenceTag, hashmeW), "unexpected tag\n");
694 ok(!memcmp(&m->gSubjectType, &subject, sizeof(subject)), "guid differs\n");
695 ok(!m->fdwMemberFlags, "got %x expected 0\n", m->fdwMemberFlags);
696 ok(m->dwCertVersion == 0x200, "got %x expected 0x200\n", m->dwCertVersion);
697 ok(!m->dwReserved, "got %x expected 0\n", m->dwReserved);
698 ok(m->hReserved == NULL, "got %p expected NULL\n", m->hReserved);
700 attr = pCryptCATEnumerateAttr(hcat, m, NULL);
701 ok(attr == NULL, "CryptCATEnumerateAttr succeeded\n");
705 ok(membercount == members, "Expected %d members, got %d\n", members, membercount);
707 attr = pCryptCATEnumerateAttr(NULL, NULL, NULL);
708 ok(attr == NULL, "CryptCATEnumerateAttr succeeded\n");
710 attr = pCryptCATEnumerateAttr(hcat, NULL, NULL);
711 ok(attr == NULL, "CryptCATEnumerateAttr succeeded\n");
714 while ((attr = pCryptCATEnumerateCatAttr(hcat, attr)))
716 ok(!lstrcmpW(attr->pwszReferenceTag, attr1W) ||
717 !lstrcmpW(attr->pwszReferenceTag, attr2W),
718 "Expected 'attr1' or 'attr2'\n");
723 ok(attrcount == attributes, "Expected %d catalog attributes, got %d\n", attributes, attrcount);
725 ret = pCryptCATClose(hcat);
726 ok(ret, "CryptCATClose failed\n");
727 if (catalog[0]) DeleteFileA( catalog );
730 static void test_create_catalog_file(void)
732 static CHAR catfileA[] = "winetest.cat";
733 static CHAR cdffileA[] = "winetest.cdf";
734 static WCHAR cdffileW[] = {'w','i','n','e','t','e','s','t','.','c','d','f',0};
736 CRYPTCATATTRIBUTE *catattr;
737 CRYPTCATMEMBER *catmember;
739 DWORD written, attrs;
742 int attrcount, membercount;
744 if (!pCryptCATCDFOpen)
746 win_skip("CryptCATCDFOpen is not available\n");
750 /* Create the cdf file */
751 file = CreateFileA(cdffileA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
752 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %u\n", GetLastError());
753 WriteFile(file, test_cdf, sizeof(test_cdf) - 1, &written, NULL);
756 /* Don't enumerate attributes and members */
757 trace("No attribs and members\n");
758 SetLastError(0xdeadbeef);
759 catcdf = pCryptCATCDFOpen(cdffileW, NULL);
762 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
763 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
766 ret = pCryptCATCDFClose(catcdf);
769 ok(ret, "Expected success, got FALSE with %d\n", GetLastError());
770 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
773 attrs = GetFileAttributesA(catfileA);
775 ok(attrs != INVALID_FILE_ATTRIBUTES, "Expected the catalog file to exist\n");
777 test_catalog_properties(catfileA, 0, 0);
778 DeleteFileA(catfileA);
780 /* Only enumerate the attributes */
781 trace("Only attributes\n");
782 attrcount = membercount = 0;
783 catcdf = pCryptCATCDFOpen(cdffileW, NULL);
786 while ((catattr = pCryptCATCDFEnumCatAttributes(catcdf, catattr, NULL)))
788 ok(!lstrcmpW(catattr->pwszReferenceTag, attr1W) ||
789 !lstrcmpW(catattr->pwszReferenceTag, attr2W),
790 "Expected 'attr1' or 'attr2'\n");
795 ok(attrcount == 2, "Expected 2 attributes, got %d\n", attrcount);
797 pCryptCATCDFClose(catcdf);
798 /* Even though the resulting catalog file shows the attributes, they will not be enumerated */
799 test_catalog_properties(catfileA, 0, 0);
800 DeleteFileA(catfileA);
802 /* Only enumerate the members */
803 trace("Only members\n");
805 catcdf = pCryptCATCDFOpen(cdffileW, NULL);
809 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, NULL, &catmember, FALSE, NULL)))
811 ok(!lstrcmpW(catmembertag, hashmeW), "Expected 'hashme'\n");
815 ok(membercount == 1, "Expected 1 member, got %d\n", membercount);
817 pCryptCATCDFClose(catcdf);
818 test_catalog_properties(catfileA, 0, 1);
819 DeleteFileA(catfileA);
821 /* Enumerate members and attributes */
822 trace("Attributes and members\n");
823 attrcount = membercount = 0;
824 catcdf = pCryptCATCDFOpen(cdffileW, NULL);
827 while ((catattr = pCryptCATCDFEnumCatAttributes(catcdf, catattr, NULL)))
830 ok(attrcount == 2, "Expected 2 attributes, got %d\n", attrcount);
834 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, NULL, &catmember, FALSE, NULL)))
837 ok(membercount == 1, "Expected 1 member, got %d\n", membercount);
839 pCryptCATCDFClose(catcdf);
840 test_catalog_properties(catfileA, 2, 1);
841 DeleteFileA(catfileA);
843 DeleteFileA(cdffileA);
846 static void create_cdf_file(const CHAR *filename, const CHAR *contents)
851 file = CreateFileA(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
852 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %u\n", GetLastError());
853 WriteFile(file, contents, lstrlenA(contents), &written, NULL);
857 #define CHECK_EXPECT(a, b) \
859 ok(a == error_area, "Expected %08x, got %08x\n", a, error_area); \
860 ok(b == local_error, "Expected %08x, got %08x\n", b, local_error); \
863 /* Clear the variables (can't use 0) */
864 #define CLEAR_EXPECT \
865 error_area = local_error = -1
867 /* Set both variables so the callback routine can check if a call to it was unexpected */
868 #define SET_UNEXPECTED \
869 error_area = local_error = -2
871 static void test_cdf_parsing(void)
873 static CHAR catfileA[] = "tempfile.cat";
874 static CHAR cdffileA[] = "tempfile.cdf";
875 static WCHAR cdffileW[] = {'t','e','m','p','f','i','l','e','.','c','d','f',0};
876 CHAR cdf_contents[4096];
878 CRYPTCATATTRIBUTE *catattr;
879 CRYPTCATMEMBER *catmember;
882 if (!pCryptCATCDFOpen)
884 win_skip("CryptCATCDFOpen is not available\n");
889 DeleteFileA(cdffileA);
890 create_cdf_file(cdffileA, "");
893 SetLastError(0xdeadbeef);
894 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
896 CHECK_EXPECT(CRYPTCAT_E_AREA_HEADER, CRYPTCAT_E_CDF_TAGNOTFOUND);
897 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
899 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
900 DeleteFileA(cdffileA);
901 ok(!DeleteFileA(catfileA), "Didn't expect a catalog file to be created\n");
903 /* Just the header */
904 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
905 create_cdf_file(cdffileA, cdf_contents);
908 SetLastError(0xdeadbeef);
909 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
910 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
912 ok(GetLastError() == ERROR_SHARING_VIOLATION,
913 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
914 DeleteFileA(cdffileA);
916 /* Header and member only */
917 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
918 lstrcatA(cdf_contents, "[CatalogFiles]\r\n");
919 lstrcatA(cdf_contents, "hashme=.\\tempfile.cdf\r\n");
920 create_cdf_file(cdffileA, cdf_contents);
923 SetLastError(0xdeadbeef);
924 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
925 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
927 ok(GetLastError() == ERROR_SHARING_VIOLATION,
928 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
929 DeleteFileA(cdffileA);
930 ok(!DeleteFileA(catfileA), "Didn't expect a catalog file to be created\n");
932 /* Header and Name (no value) */
933 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
934 lstrcatA(cdf_contents, "Name=\r\n");
935 create_cdf_file(cdffileA, cdf_contents);
938 SetLastError(0xdeadbeef);
939 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
940 ok(catcdf == NULL, "CryptCATCDFOpen succeeded\n");
942 ok(GetLastError() == ERROR_SHARING_VIOLATION,
943 "Expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
944 DeleteFileA(cdffileA);
945 ok(!DeleteFileA(catfileA), "Didn't expect a catalog file to be created\n");
947 /* Header and Name */
948 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
949 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
950 create_cdf_file(cdffileA, cdf_contents);
953 SetLastError(0xdeadbeef);
954 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
957 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
958 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
960 pCryptCATCDFClose(catcdf);
961 DeleteFileA(cdffileA);
963 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
965 /* Header and nonexistent member */
966 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
967 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
968 lstrcatA(cdf_contents, "[CatalogFiles]\r\n");
969 lstrcatA(cdf_contents, "hashme=.\\deadbeef.cdf\r\n");
970 create_cdf_file(cdffileA, cdf_contents);
973 SetLastError(0xdeadbeef);
974 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
977 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
978 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
980 /* Loop through the members */
984 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, cdf_callback, &catmember, FALSE, NULL))) ;
986 CHECK_EXPECT(CRYPTCAT_E_AREA_MEMBER, CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND);
987 pCryptCATCDFClose(catcdf);
988 DeleteFileA(cdffileA);
990 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
992 /* Header, correct member but no explicit newline */
993 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
994 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
995 lstrcatA(cdf_contents, "[CatalogFiles]\r\n");
996 lstrcatA(cdf_contents, "hashme=.\\tempfile.cdf\r");
997 create_cdf_file(cdffileA, cdf_contents);
1000 SetLastError(0xdeadbeef);
1001 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
1004 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
1005 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1007 /* Loop through the members */
1010 catmembertag = NULL;
1011 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, cdf_callback, &catmember, FALSE, NULL))) ;
1013 CHECK_EXPECT(CRYPTCAT_E_AREA_MEMBER, CRYPTCAT_E_CDF_MEMBER_FILE_PATH);
1014 pCryptCATCDFClose(catcdf);
1015 DeleteFileA(cdffileA);
1017 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
1019 /* Header and 2 duplicate members */
1020 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
1021 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
1022 lstrcatA(cdf_contents, "[CatalogFiles]\r\n");
1023 lstrcatA(cdf_contents, "hashme=.\\tempfile.cdf\r\n");
1024 lstrcatA(cdf_contents, "hashme=.\\tempfile.cdf\r\n");
1025 create_cdf_file(cdffileA, cdf_contents);
1028 SetLastError(0xdeadbeef);
1029 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
1032 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
1033 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1035 /* Loop through the members */
1038 catmembertag = NULL;
1039 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, cdf_callback, &catmember, FALSE, NULL))) ;
1040 pCryptCATCDFClose(catcdf);
1041 test_catalog_properties(catfileA, 0, 1);
1042 DeleteFileA(cdffileA);
1044 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
1046 /* Wrong attribute */
1047 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
1048 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
1049 lstrcatA(cdf_contents, "CATATTR1=0x10010001:attr1\r\n");
1050 create_cdf_file(cdffileA, cdf_contents);
1053 SetLastError(0xdeadbeef);
1054 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
1057 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
1058 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1060 /* Loop through the attributes */
1063 while ((catattr = pCryptCATCDFEnumCatAttributes(catcdf, catattr, cdf_callback))) ;
1065 CHECK_EXPECT(CRYPTCAT_E_AREA_ATTRIBUTE, CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES);
1066 pCryptCATCDFClose(catcdf);
1067 DeleteFileA(cdffileA);
1069 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
1071 /* Two identical attributes */
1072 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
1073 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
1074 lstrcatA(cdf_contents, "CATATTR1=0x10010001:attr1:value1\r\n");
1075 lstrcatA(cdf_contents, "CATATTR1=0x10010001:attr1:value1\r\n");
1076 lstrcatA(cdf_contents, "[CatalogFiles]\r\n");
1077 lstrcatA(cdf_contents, "hashme=.\\tempfile.cdf\r\n");
1078 create_cdf_file(cdffileA, cdf_contents);
1081 SetLastError(0xdeadbeef);
1082 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
1085 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
1086 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1088 /* Loop through the members */
1091 catmembertag = NULL;
1092 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, cdf_callback, &catmember, FALSE, NULL))) ;
1093 /* Loop through the attributes */
1096 while ((catattr = pCryptCATCDFEnumCatAttributes(catcdf, catattr, cdf_callback))) ;
1097 pCryptCATCDFClose(catcdf);
1098 test_catalog_properties(catfileA, 1, 1);
1099 DeleteFileA(cdffileA);
1101 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
1103 /* Two different attribute values with the same tag */
1104 lstrcpyA(cdf_contents, "[CatalogHeader]\r\n");
1105 lstrcatA(cdf_contents, "Name=tempfile.cat\r\n");
1106 lstrcatA(cdf_contents, "CATATTR1=0x10010001:attr1:value1\r\n");
1107 lstrcatA(cdf_contents, "CATATTR1=0x10010001:attr2:value2\r\n");
1108 lstrcatA(cdf_contents, "[CatalogFiles]\r\n");
1109 lstrcatA(cdf_contents, "hashme=.\\tempfile.cdf\r\n");
1110 create_cdf_file(cdffileA, cdf_contents);
1113 SetLastError(0xdeadbeef);
1114 catcdf = pCryptCATCDFOpen(cdffileW, cdf_callback);
1117 ok(catcdf != NULL, "CryptCATCDFOpen failed\n");
1118 ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", GetLastError());
1120 /* Loop through the members */
1123 catmembertag = NULL;
1124 while ((catmembertag = pCryptCATCDFEnumMembersByCDFTagEx(catcdf, catmembertag, cdf_callback, &catmember, FALSE, NULL))) ;
1125 /* Loop through the attributes */
1128 while ((catattr = pCryptCATCDFEnumCatAttributes(catcdf, catattr, cdf_callback))) ;
1129 pCryptCATCDFClose(catcdf);
1130 test_catalog_properties(catfileA, 1, 1);
1131 DeleteFileA(cdffileA);
1133 ok(DeleteFileA(catfileA), "Expected a catalog file to be created\n");
1138 WORD e_magic; /* 00: MZ Header signature */
1140 DWORD e_lfanew; /* 3c: Offset to extended header */
1143 IMAGE_DOS_SIGNATURE, { 0 }, sizeof(dos_header)
1146 static IMAGE_NT_HEADERS nt_header =
1148 IMAGE_NT_SIGNATURE, /* Signature */
1150 IMAGE_FILE_MACHINE_I386, /* Machine */
1151 1, /* NumberOfSections */
1152 0, /* TimeDateStamp */
1153 0, /* PointerToSymbolTable */
1154 0, /* NumberOfSymbols */
1155 sizeof(IMAGE_OPTIONAL_HEADER), /* SizeOfOptionalHeader */
1156 IMAGE_FILE_EXECUTABLE_IMAGE /* Characteristics */
1159 IMAGE_NT_OPTIONAL_HDR_MAGIC, /* Magic */
1160 2, /* MajorLinkerVersion */
1161 15, /* MinorLinkerVersion */
1163 0, /* SizeOfInitializedData */
1164 0, /* SizeOfUninitializedData */
1165 0, /* AddressOfEntryPoint */
1166 0x10, /* BaseOfCode, also serves as e_lfanew in the truncated MZ header */
1170 0x10000000, /* ImageBase */
1171 0, /* SectionAlignment */
1172 0, /* FileAlignment */
1173 4, /* MajorOperatingSystemVersion */
1174 0, /* MinorOperatingSystemVersion */
1175 1, /* MajorImageVersion */
1176 0, /* MinorImageVersion */
1177 4, /* MajorSubsystemVersion */
1178 0, /* MinorSubsystemVersion */
1179 0, /* Win32VersionValue */
1180 0x200, /* SizeOfImage */
1181 sizeof(dos_header) + sizeof(nt_header), /* SizeOfHeaders */
1183 IMAGE_SUBSYSTEM_WINDOWS_CUI, /* Subsystem */
1184 0, /* DllCharacteristics */
1185 0, /* SizeOfStackReserve */
1186 0, /* SizeOfStackCommit */
1187 0, /* SizeOfHeapReserve */
1188 3, /* SizeOfHeapCommit */
1189 2, /* LoaderFlags */
1190 1, /* NumberOfRvaAndSizes */
1191 { { 0 } } /* DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] */
1195 static void test_sip(void)
1197 static WCHAR nameW[] = {'t','e','s','t','.','e','x','e',0};
1198 SIP_SUBJECTINFO info;
1199 DWORD index, encoding, size;
1205 file = CreateFileW(nameW, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1206 ok(file != INVALID_HANDLE_VALUE, "can't create file\n");
1207 if(file == INVALID_HANDLE_VALUE)
1209 WriteFile(file, &dos_header, sizeof(dos_header), &size, NULL);
1210 WriteFile(file, &nt_header, sizeof(nt_header), &size, NULL);
1211 memset(buf, 0, sizeof(buf));
1212 WriteFile(file, buf, 0x200 - sizeof(dos_header) - sizeof(nt_header), &size, NULL);
1215 file= CreateFileW(nameW, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1216 ok(file != INVALID_HANDLE_VALUE, "can't open file\n");
1218 memset(&info, 0, sizeof(SIP_SUBJECTINFO));
1219 info.cbSize = sizeof(SIP_SUBJECTINFO);
1220 info.pgSubjectType = &guid;
1221 ret = CryptSIPRetrieveSubjectGuid(NULL, file, info.pgSubjectType);
1222 ok(ret, "CryptSIPRetrieveSubjectGuid failed (%x)\n", GetLastError());
1224 ret = pPutSignedDataMsg(&info, X509_ASN_ENCODING, &index, 4, (BYTE*)"test");
1225 ok(!ret, "CryptSIPPutSignedDataMsg succeedded\n");
1226 index = GetLastError();
1227 ok(index == ERROR_PATH_NOT_FOUND, "GetLastError returned %x\n", index);
1230 info.pwsFileName = nameW;
1231 ret = pPutSignedDataMsg(&info, X509_ASN_ENCODING, &index, 4, (BYTE*)"test");
1232 ok(!ret, "CryptSIPPutSignedDataMsg succeedded\n");
1233 index = GetLastError();
1234 todo_wine ok(index == ERROR_INVALID_PARAMETER, "GetLastError returned %x\n", index);
1236 info.hFile = INVALID_HANDLE_VALUE;
1237 info.pwsFileName = nameW;
1238 ret = pPutSignedDataMsg(&info, X509_ASN_ENCODING, &index, 4, (BYTE*)"test");
1239 ok(!ret, "CryptSIPPutSignedDataMsg succeedded\n");
1240 index = GetLastError();
1241 ok(index == ERROR_SHARING_VIOLATION, "GetLastError returned %x\n", index);
1244 file= CreateFileW(nameW, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1247 info.pwsFileName = (void*)0xdeadbeef;
1248 ret = pPutSignedDataMsg(&info, X509_ASN_ENCODING, &index, 4, (BYTE*)"test");
1249 ok(ret, "CryptSIPPutSignedDataMsg failed (%x)\n", GetLastError());
1250 ok(index == 0, "index = %x\n", index);
1253 file= CreateFileW(nameW, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1255 info.hFile = INVALID_HANDLE_VALUE;
1256 info.pwsFileName = nameW;
1257 ret = pPutSignedDataMsg(&info, X509_ASN_ENCODING, &index, 14, (BYTE*)"longer message");
1258 ok(ret, "CryptSIPPutSignedDataMsg failed (%x)\n", GetLastError());
1259 ok(index == 1, "index = %x\n", index);
1262 encoding = 0xdeadbeef;
1263 ret = pGetSignedDataMsg(&info, &encoding, 0, &size, NULL);
1264 ok(ret, "CryptSIPGetSignedDataMsg failed (%x)\n", GetLastError());
1265 ok(encoding == 0xdeadbeef, "encoding = %x\n", encoding);
1266 ok(size == 16, "size = %d\n", size);
1268 ret = pGetSignedDataMsg(&info, &encoding, 0, &size, (BYTE*)buf);
1269 ok(ret, "CryptSIPGetSignedDataMsg failed (%x)\n", GetLastError());
1270 ok(encoding == (X509_ASN_ENCODING|PKCS_7_ASN_ENCODING), "encoding = %x\n", encoding);
1271 ok(size == 8, "size = %d\n", size);
1272 ok(!memcmp(buf, "test\0\0\0\0", 8), "buf = %s\n", buf);
1275 encoding = 0xdeadbeef;
1276 ret = pGetSignedDataMsg(&info, &encoding, 1, &size, NULL);
1277 ok(ret, "CryptSIPGetSignedDataMsg failed (%x)\n", GetLastError());
1278 ok(encoding == 0xdeadbeef, "encoding = %x\n", encoding);
1279 ok(size == 24, "size = %d\n", size);
1281 ret = pGetSignedDataMsg(&info, &encoding, 1, &size, (BYTE*)buf);
1282 ok(ret, "CryptSIPGetSignedDataMsg failed (%x)\n", GetLastError());
1283 ok(encoding == (X509_ASN_ENCODING|PKCS_7_ASN_ENCODING), "encoding = %x\n", encoding);
1284 ok(size == 16, "size = %d\n", size);
1285 ok(!strcmp(buf, "longer message"), "buf = %s\n", buf);
1287 CryptReleaseContext(info.hProv, 0);
1295 char sysdir[MAX_PATH];
1299 if (!pCryptCATAdminAcquireContext)
1301 win_skip("CryptCATAdmin functions are not available\n");
1305 GetSystemDirectoryA(sysdir, MAX_PATH);
1306 lstrcpyA(catroot, sysdir);
1307 lstrcatA(catroot, "\\CatRoot");
1308 lstrcpyA(catroot2, sysdir);
1309 lstrcatA(catroot2, "\\CatRoot2");
1311 winetest_get_mainargs(&myARGV);
1312 strcpy(selfname, myARGV[0]);
1314 GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1318 test_CryptCATOpen();
1319 /* Parameter checking only */
1320 test_CryptCATCDF_params();
1321 /* Test the parsing of a cdf file */
1323 /* Create a catalog file out of our own catalog definition file */
1324 test_create_catalog_file();
1325 test_CryptCATAdminAddRemoveCatalog();