?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winealsa: Remove AudioSessionManager.
[wine.git] / dlls / wintrust / crypt.c
blobac3ac9251f1da3bb424b8c10c62ee4cfd8a94f4c
1 /*
2 * WinTrust Cryptography functions
3 *
4 * Copyright 2006 James Hawkins
5 * Copyright 2000-2002 Stuart Caie
6 * Copyright 2002 Patrik Stridvall
7 * Copyright 2003 Greg Turner
8 * Copyright 2008 Juan Lang
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wintrust.h"
30 #include "winver.h"
31 #include "mscat.h"
32 #include "mssip.h"
33 #include "imagehlp.h"
34 #include "winternl.h"
35
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
39
40 #define CATADMIN_MAGIC 0x43415441 /* 'CATA' */
41 #define CRYPTCAT_MAGIC 0x43415443 /* 'CATC' */
42 #define CATINFO_MAGIC 0x43415449 /* 'CATI' */
43
44 struct cryptcat
45 {
46 DWORD magic;
47 HCRYPTMSG msg;
48 DWORD encoding;
49 CTL_INFO *inner;
50 DWORD inner_len;
51 GUID subject;
52 DWORD attr_count;
53 CRYPTCATATTRIBUTE *attr;
54 };
55
56 struct catadmin
57 {
58 DWORD magic;
59 WCHAR path[MAX_PATH];
60 HANDLE find;
61 };
62
63 struct catinfo
64 {
65 DWORD magic;
66 WCHAR file[MAX_PATH];
67 };
68
69 static HCATINFO create_catinfo(const WCHAR *filename)
70 {
71 struct catinfo *ci;
72
73 if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
74 {
75 SetLastError(ERROR_OUTOFMEMORY);
76 return INVALID_HANDLE_VALUE;
77 }
78 lstrcpyW(ci->file, filename);
79 ci->magic = CATINFO_MAGIC;
80 return ci;
81 }
82
83 /***********************************************************************
84 * CryptCATAdminAcquireContext (WINTRUST.@)
85 *
86 * Get a catalog administrator context handle.
87 *
88 * PARAMS
89 * catAdmin [O] Pointer to the context handle.
90 * sys [I] Pointer to a GUID for the needed subsystem.
91 * dwFlags [I] Reserved.
92 *
93 * RETURNS
94 * Success: TRUE. catAdmin contains the context handle.
95 * Failure: FALSE.
96 *
97 */
98 BOOL WINAPI CryptCATAdminAcquireContext(HCATADMIN *catAdmin,
99 const GUID *sys, DWORD dwFlags)
100 {
101 static const WCHAR catroot[] =
102 {'\\','c','a','t','r','o','o','t',0};
103 static const WCHAR fmt[] =
104 {'%','s','\\','{','%','0','8','x','-','%','0','4','x','-','%','0',
105 '4','x','-','%','0','2','x','%','0','2','x','-','%','0','2','x',
106 '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
107 '%','0','2','x','}',0};
108 static const GUID defsys =
109 {0x127d0a1d,0x4ef2,0x11d1,{0x86,0x08,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
110
111 WCHAR catroot_dir[MAX_PATH];
112 struct catadmin *ca;
113
114 TRACE("%p %s %lx\n", catAdmin, debugstr_guid(sys), dwFlags);
115
116 if (!catAdmin || dwFlags)
117 {
118 SetLastError(ERROR_INVALID_PARAMETER);
119 return FALSE;
120 }
121 if (!(ca = HeapAlloc(GetProcessHeap(), 0, sizeof(*ca))))
122 {
123 SetLastError(ERROR_OUTOFMEMORY);
124 return FALSE;
125 }
126
127 GetSystemDirectoryW(catroot_dir, MAX_PATH);
128 lstrcatW(catroot_dir, catroot);
129
130 /* create the directory if it doesn't exist */
131 CreateDirectoryW(catroot_dir, NULL);
132
133 if (!sys) sys = &defsys;
134 swprintf(ca->path, ARRAY_SIZE(ca->path), fmt, catroot_dir, sys->Data1, sys->Data2,
135 sys->Data3, sys->Data4[0], sys->Data4[1], sys->Data4[2],
136 sys->Data4[3], sys->Data4[4], sys->Data4[5], sys->Data4[6],
137 sys->Data4[7]);
138
139 /* create the directory if it doesn't exist */
140 CreateDirectoryW(ca->path, NULL);
141
142 ca->magic = CATADMIN_MAGIC;
143 ca->find = INVALID_HANDLE_VALUE;
144
145 *catAdmin = ca;
146 return TRUE;
147 }
148
149 /***********************************************************************
150 * CryptCATAdminAcquireContext2 (WINTRUST.@)
151 */
152 BOOL WINAPI CryptCATAdminAcquireContext2(HCATADMIN *catAdmin, const GUID *sys, const WCHAR *algorithm,
153 const CERT_STRONG_SIGN_PARA *policy, DWORD flags)
154 {
155 FIXME("%p %s %s %p %lx stub\n", catAdmin, debugstr_guid(sys), debugstr_w(algorithm), policy, flags);
156 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
157 return FALSE;
158 }
159
160 /***********************************************************************
161 * CryptCATAdminAddCatalog (WINTRUST.@)
162 */
163 HCATINFO WINAPI CryptCATAdminAddCatalog(HCATADMIN catAdmin, PWSTR catalogFile,
164 PWSTR selectBaseName, DWORD flags)
165 {
166 static const WCHAR slashW[] = {'\\',0};
167 struct catadmin *ca = catAdmin;
168 struct catinfo *ci;
169 WCHAR *target;
170 DWORD len;
171
172 TRACE("%p %s %s %ld\n", catAdmin, debugstr_w(catalogFile),
173 debugstr_w(selectBaseName), flags);
174
175 if (!selectBaseName)
176 {
177 FIXME("NULL basename not handled\n");
178 SetLastError(ERROR_INVALID_PARAMETER);
179 return NULL;
180 }
181 if (!ca || ca->magic != CATADMIN_MAGIC || !catalogFile || flags)
182 {
183 SetLastError(ERROR_INVALID_PARAMETER);
184 return NULL;
185 }
186
187 len = lstrlenW(ca->path) + lstrlenW(selectBaseName) + 2;
188 if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
189 {
190 SetLastError(ERROR_OUTOFMEMORY);
191 return NULL;
192 }
193 lstrcpyW(target, ca->path);
194 lstrcatW(target, slashW);
195 lstrcatW(target, selectBaseName);
196
197 if (!CopyFileW(catalogFile, target, FALSE))
198 {
199 HeapFree(GetProcessHeap(), 0, target);
200 return NULL;
201 }
202 SetFileAttributesW(target, FILE_ATTRIBUTE_SYSTEM);
203
204 if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
205 {
206 HeapFree(GetProcessHeap(), 0, target);
207 SetLastError(ERROR_OUTOFMEMORY);
208 return NULL;
209 }
210 ci->magic = CATINFO_MAGIC;
211 lstrcpyW(ci->file, target);
212
213 HeapFree(GetProcessHeap(), 0, target);
214 return ci;
215 }
216
217 /***********************************************************************
218 * CryptCATAdminCalcHashFromFileHandle (WINTRUST.@)
219 */
220 BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(HANDLE hFile, DWORD* pcbHash,
221 BYTE* pbHash, DWORD dwFlags )
222 {
223 BOOL ret = FALSE;
224
225 TRACE("%p %p %p %lx\n", hFile, pcbHash, pbHash, dwFlags);
226
227 if (!hFile || !pcbHash || dwFlags)
228 {
229 SetLastError(ERROR_INVALID_PARAMETER);
230 return FALSE;
231 }
232 if (*pcbHash < 20)
233 {
234 *pcbHash = 20;
235 SetLastError(ERROR_INSUFFICIENT_BUFFER);
236 return TRUE;
237 }
238
239 *pcbHash = 20;
240 if (pbHash)
241 {
242 HCRYPTPROV prov;
243 HCRYPTHASH hash;
244 DWORD bytes_read;
245 BYTE *buffer;
246
247 if (!(buffer = HeapAlloc(GetProcessHeap(), 0, 4096)))
248 {
249 SetLastError(ERROR_OUTOFMEMORY);
250 return FALSE;
251 }
252 ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
253 if (!ret)
254 {
255 HeapFree(GetProcessHeap(), 0, buffer);
256 return FALSE;
257 }
258 ret = CryptCreateHash(prov, CALG_SHA1, 0, 0, &hash);
259 if (!ret)
260 {
261 HeapFree(GetProcessHeap(), 0, buffer);
262 CryptReleaseContext(prov, 0);
263 return FALSE;
264 }
265 while ((ret = ReadFile(hFile, buffer, 4096, &bytes_read, NULL)) && bytes_read)
266 {
267 CryptHashData(hash, buffer, bytes_read, 0);
268 }
269 if (ret) ret = CryptGetHashParam(hash, HP_HASHVAL, pbHash, pcbHash, 0);
270
271 HeapFree(GetProcessHeap(), 0, buffer);
272 CryptDestroyHash(hash);
273 CryptReleaseContext(prov, 0);
274 }
275 return ret;
276 }
277
278 /***********************************************************************
279 * CryptCATAdminEnumCatalogFromHash (WINTRUST.@)
280 */
281 HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(HCATADMIN hCatAdmin, BYTE* pbHash,
282 DWORD cbHash, DWORD dwFlags,
283 HCATINFO* phPrevCatInfo )
284 {
285 static const WCHAR slashW[] = {'\\',0};
286 static const WCHAR globW[] = {'\\','*','.','c','a','t',0};
287
288 struct catadmin *ca = hCatAdmin;
289 WIN32_FIND_DATAW data;
290 HCATINFO prev = NULL;
291 HCRYPTPROV prov;
292 DWORD size;
293 BOOL ret;
294
295 TRACE("%p %p %ld %lx %p\n", hCatAdmin, pbHash, cbHash, dwFlags, phPrevCatInfo);
296
297 if (!ca || ca->magic != CATADMIN_MAGIC || !pbHash || cbHash != 20 || dwFlags)
298 {
299 SetLastError(ERROR_INVALID_PARAMETER);
300 return NULL;
301 }
302 if (phPrevCatInfo) prev = *phPrevCatInfo;
303
304 ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
305 if (!ret) return NULL;
306
307 if (!prev)
308 {
309 WCHAR *path;
310
311 size = lstrlenW(ca->path) * sizeof(WCHAR) + sizeof(globW);
312 if (!(path = HeapAlloc(GetProcessHeap(), 0, size)))
313 {
314 CryptReleaseContext(prov, 0);
315 SetLastError(ERROR_OUTOFMEMORY);
316 return NULL;
317 }
318 lstrcpyW(path, ca->path);
319 lstrcatW(path, globW);
320
321 FindClose(ca->find);
322 ca->find = FindFirstFileW(path, &data);
323
324 HeapFree(GetProcessHeap(), 0, path);
325 if (ca->find == INVALID_HANDLE_VALUE)
326 {
327 CryptReleaseContext(prov, 0);
328 return NULL;
329 }
330 }
331 else if (!FindNextFileW(ca->find, &data))
332 {
333 CryptCATAdminReleaseCatalogContext(hCatAdmin, prev, 0);
334 CryptReleaseContext(prov, 0);
335 return NULL;
336 }
337
338 while (1)
339 {
340 WCHAR *filename;
341 CRYPTCATMEMBER *member = NULL;
342 struct catinfo *ci;
343 HANDLE hcat;
344
345 size = (lstrlenW(ca->path) + lstrlenW(data.cFileName) + 2) * sizeof(WCHAR);
346 if (!(filename = HeapAlloc(GetProcessHeap(), 0, size)))
347 {
348 SetLastError(ERROR_OUTOFMEMORY);
349 return NULL;
350 }
351 lstrcpyW(filename, ca->path);
352 lstrcatW(filename, slashW);
353 lstrcatW(filename, data.cFileName);
354
355 hcat = CryptCATOpen(filename, CRYPTCAT_OPEN_EXISTING, prov, 0, 0);
356 if (hcat == INVALID_HANDLE_VALUE)
357 {
358 WARN("couldn't open %s (%lu)\n", debugstr_w(filename), GetLastError());
359 continue;
360 }
361 while ((member = CryptCATEnumerateMember(hcat, member)))
362 {
363 if (member->pIndirectData->Digest.cbData != cbHash)
364 {
365 WARN("amount of hash bytes differs: %lu/%lu\n", member->pIndirectData->Digest.cbData, cbHash);
366 continue;
367 }
368 if (!memcmp(member->pIndirectData->Digest.pbData, pbHash, cbHash))
369 {
370 TRACE("file %s matches\n", debugstr_w(data.cFileName));
371
372 CryptCATClose(hcat);
373 CryptReleaseContext(prov, 0);
374 if (!phPrevCatInfo)
375 {
376 FindClose(ca->find);
377 ca->find = INVALID_HANDLE_VALUE;
378 }
379 ci = create_catinfo(filename);
380 HeapFree(GetProcessHeap(), 0, filename);
381 return ci;
382 }
383 }
384 CryptCATClose(hcat);
385 HeapFree(GetProcessHeap(), 0, filename);
386
387 if (!FindNextFileW(ca->find, &data))
388 {
389 FindClose(ca->find);
390 ca->find = INVALID_HANDLE_VALUE;
391 CryptReleaseContext(prov, 0);
392 return NULL;
393 }
394 }
395 return NULL;
396 }
397
398 /***********************************************************************
399 * CryptCATAdminReleaseCatalogContext (WINTRUST.@)
400 *
401 * Release a catalog context handle.
402 *
403 * PARAMS
404 * hCatAdmin [I] Context handle.
405 * hCatInfo [I] Catalog handle.
406 * dwFlags [I] Reserved.
407 *
408 * RETURNS
409 * Success: TRUE.
410 * Failure: FALSE.
411 *
412 */
413 BOOL WINAPI CryptCATAdminReleaseCatalogContext(HCATADMIN hCatAdmin,
414 HCATINFO hCatInfo,
415 DWORD dwFlags)
416 {
417 struct catinfo *ci = hCatInfo;
418 struct catadmin *ca = hCatAdmin;
419
420 TRACE("%p %p %lx\n", hCatAdmin, hCatInfo, dwFlags);
421
422 if (!ca || ca->magic != CATADMIN_MAGIC || !ci || ci->magic != CATINFO_MAGIC)
423 {
424 SetLastError(ERROR_INVALID_PARAMETER);
425 return FALSE;
426 }
427 ci->magic = 0;
428 return HeapFree(GetProcessHeap(), 0, ci);
429 }
430
431 /***********************************************************************
432 * CryptCATAdminReleaseContext (WINTRUST.@)
433 *
434 * Release a catalog administrator context handle.
435 *
436 * PARAMS
437 * catAdmin [I] Context handle.
438 * dwFlags [I] Reserved.
439 *
440 * RETURNS
441 * Success: TRUE.
442 * Failure: FALSE.
443 *
444 */
445 BOOL WINAPI CryptCATAdminReleaseContext(HCATADMIN hCatAdmin, DWORD dwFlags )
446 {
447 struct catadmin *ca = hCatAdmin;
448
449 TRACE("%p %lx\n", hCatAdmin, dwFlags);
450
451 if (!ca || ca->magic != CATADMIN_MAGIC)
452 {
453 SetLastError(ERROR_INVALID_PARAMETER);
454 return FALSE;
455 }
456 if (ca->find != INVALID_HANDLE_VALUE) FindClose(ca->find);
457 ca->magic = 0;
458 return HeapFree(GetProcessHeap(), 0, ca);
459 }
460
461 /***********************************************************************
462 * CryptCATAdminRemoveCatalog (WINTRUST.@)
463 *
464 * Remove a catalog file.
465 *
466 * PARAMS
467 * catAdmin [I] Context handle.
468 * pwszCatalogFile [I] Catalog file.
469 * dwFlags [I] Reserved.
470 *
471 * RETURNS
472 * Success: TRUE.
473 * Failure: FALSE.
474 *
475 */
476 BOOL WINAPI CryptCATAdminRemoveCatalog(HCATADMIN hCatAdmin, LPCWSTR pwszCatalogFile, DWORD dwFlags)
477 {
478 struct catadmin *ca = hCatAdmin;
479
480 TRACE("%p %s %lx\n", hCatAdmin, debugstr_w(pwszCatalogFile), dwFlags);
481
482 if (!ca || ca->magic != CATADMIN_MAGIC)
483 {
484 SetLastError(ERROR_INVALID_PARAMETER);
485 return FALSE;
486 }
487
488 /* Only delete when there is a filename and no path */
489 if (pwszCatalogFile && pwszCatalogFile[0] != 0 &&
490 !wcschr(pwszCatalogFile, '\\') && !wcschr(pwszCatalogFile, '/') &&
491 !wcschr(pwszCatalogFile, ':'))
492 {
493 static const WCHAR slashW[] = {'\\',0};
494 WCHAR *target;
495 DWORD len;
496
497 len = lstrlenW(ca->path) + lstrlenW(pwszCatalogFile) + 2;
498 if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
499 {
500 SetLastError(ERROR_OUTOFMEMORY);
501 return FALSE;
502 }
503 lstrcpyW(target, ca->path);
504 lstrcatW(target, slashW);
505 lstrcatW(target, pwszCatalogFile);
506
507 DeleteFileW(target);
508
509 HeapFree(GetProcessHeap(), 0, target);
510 }
511
512 return TRUE;
513 }
514
515 /***********************************************************************
516 * CryptCATAdminResolveCatalogPath (WINTRUST.@)
517 */
518 BOOL WINAPI CryptCATAdminResolveCatalogPath(HCATADMIN hcatadmin, WCHAR *catalog_file,
519 CATALOG_INFO *info, DWORD flags)
520 {
521 static const WCHAR slashW[] = {'\\',0};
522 struct catadmin *ca = hcatadmin;
523
524 TRACE("%p %s %p %lx\n", hcatadmin, debugstr_w(catalog_file), info, flags);
525
526 if (!ca || ca->magic != CATADMIN_MAGIC || !info || info->cbStruct != sizeof(*info) || flags)
527 {
528 SetLastError(ERROR_INVALID_PARAMETER);
529 return FALSE;
530 }
531 lstrcpyW(info->wszCatalogFile, ca->path);
532 lstrcatW(info->wszCatalogFile, slashW);
533 lstrcatW(info->wszCatalogFile, catalog_file);
534
535 return TRUE;
536 }
537
538 /***********************************************************************
539 * CryptCATClose (WINTRUST.@)
540 */
541 BOOL WINAPI CryptCATClose(HANDLE hCatalog)
542 {
543 struct cryptcat *cc = hCatalog;
544
545 TRACE("(%p)\n", hCatalog);
546
547 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
548 {
549 SetLastError(ERROR_INVALID_PARAMETER);
550 return FALSE;
551 }
552 HeapFree(GetProcessHeap(), 0, cc->attr);
553 HeapFree(GetProcessHeap(), 0, cc->inner);
554 CryptMsgClose(cc->msg);
555
556 cc->magic = 0;
557 HeapFree(GetProcessHeap(), 0, cc);
558 return TRUE;
559 }
560
561 /***********************************************************************
562 * CryptCATGetAttrInfo (WINTRUST.@)
563 */
564 CRYPTCATATTRIBUTE * WINAPI CryptCATGetAttrInfo(HANDLE hCatalog, CRYPTCATMEMBER *member, LPWSTR tag)
565 {
566 struct cryptcat *cc = hCatalog;
567
568 FIXME("%p, %p, %s\n", hCatalog, member, debugstr_w(tag));
569
570 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
571 {
572 SetLastError(ERROR_INVALID_PARAMETER);
573 return NULL;
574 }
575 SetLastError(CRYPT_E_NOT_FOUND);
576 return NULL;
577 }
578
579 /***********************************************************************
580 * CryptCATGetCatAttrInfo (WINTRUST.@)
581 */
582 CRYPTCATATTRIBUTE * WINAPI CryptCATGetCatAttrInfo(HANDLE hCatalog, LPWSTR tag)
583 {
584 struct cryptcat *cc = hCatalog;
585
586 FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
587
588 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
589 {
590 SetLastError(ERROR_INVALID_PARAMETER);
591 return NULL;
592 }
593 SetLastError(CRYPT_E_NOT_FOUND);
594 return NULL;
595 }
596
597 CRYPTCATMEMBER * WINAPI CryptCATGetMemberInfo(HANDLE hCatalog, LPWSTR tag)
598 {
599 struct cryptcat *cc = hCatalog;
600
601 FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
602
603 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
604 {
605 SetLastError(ERROR_INVALID_PARAMETER);
606 return NULL;
607 }
608 SetLastError(CRYPT_E_NOT_FOUND);
609 return NULL;
610 }
611
612 /***********************************************************************
613 * CryptCATEnumerateAttr (WINTRUST.@)
614 */
615 CRYPTCATATTRIBUTE * WINAPI CryptCATEnumerateAttr(HANDLE hCatalog, CRYPTCATMEMBER *member, CRYPTCATATTRIBUTE *prev)
616 {
617 struct cryptcat *cc = hCatalog;
618
619 FIXME("%p, %p, %p\n", hCatalog, member, prev);
620
621 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
622 {
623 SetLastError(ERROR_INVALID_PARAMETER);
624 return NULL;
625 }
626 SetLastError(CRYPT_E_NOT_FOUND);
627 return NULL;
628 }
629
630 /***********************************************************************
631 * CryptCATEnumerateCatAttr (WINTRUST.@)
632 */
633 CRYPTCATATTRIBUTE * WINAPI CryptCATEnumerateCatAttr(HANDLE hCatalog, CRYPTCATATTRIBUTE *prev)
634 {
635 struct cryptcat *cc = hCatalog;
636
637 FIXME("%p, %p\n", hCatalog, prev);
638
639 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
640 {
641 SetLastError(ERROR_INVALID_PARAMETER);
642 return NULL;
643 }
644 SetLastError(CRYPT_E_NOT_FOUND);
645 return NULL;
646 }
647
648 /***********************************************************************
649 * CryptCATEnumerateMember (WINTRUST.@)
650 */
651 CRYPTCATMEMBER * WINAPI CryptCATEnumerateMember(HANDLE hCatalog, CRYPTCATMEMBER *prev)
652 {
653 struct cryptcat *cc = hCatalog;
654 CRYPTCATMEMBER *member = prev;
655 CTL_ENTRY *entry;
656 DWORD size, i;
657
658 TRACE("%p, %p\n", hCatalog, prev);
659
660 if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
661 {
662 SetLastError(ERROR_INVALID_PARAMETER);
663 return NULL;
664 }
665
666 /* dumping the contents makes me think that dwReserved is the iteration number */
667 if (!member)
668 {
669 if (!(member = HeapAlloc(GetProcessHeap(), 0, sizeof(*member))))
670 {
671 SetLastError(ERROR_OUTOFMEMORY);
672 return NULL;
673 }
674 member->cbStruct = sizeof(*member);
675 member->pwszFileName = member->pwszReferenceTag = NULL;
676 member->dwReserved = 0;
677 member->hReserved = NULL;
678 member->gSubjectType = cc->subject;
679 member->fdwMemberFlags = 0;
680 member->pIndirectData = NULL;
681 member->dwCertVersion = cc->inner->dwVersion;
682 }
683 else member->dwReserved++;
684
685 if (member->dwReserved >= cc->inner->cCTLEntry)
686 {
687 SetLastError(ERROR_INVALID_PARAMETER);
688 goto error;
689 }
690
691 /* list them backwards, like native */
692 entry = &cc->inner->rgCTLEntry[cc->inner->cCTLEntry - member->dwReserved - 1];
693
694 member->sEncodedIndirectData.cbData = member->sEncodedMemberInfo.cbData = 0;
695 member->sEncodedIndirectData.pbData = member->sEncodedMemberInfo.pbData = NULL;
696 HeapFree(GetProcessHeap(), 0, member->pIndirectData);
697 member->pIndirectData = NULL;
698
699 for (i = 0; i < entry->cAttribute; i++)
700 {
701 CRYPT_ATTRIBUTE *attr = entry->rgAttribute + i;
702
703 if (attr->cValue != 1)
704 {
705 ERR("Can't handle attr->cValue of %lu\n", attr->cValue);
706 continue;
707 }
708 if (!strcmp(attr->pszObjId, CAT_MEMBERINFO_OBJID))
709 {
710 CAT_MEMBERINFO *mi;
711 BOOL ret;
712
713 member->sEncodedMemberInfo.cbData = attr->rgValue->cbData;
714 member->sEncodedMemberInfo.pbData = attr->rgValue->pbData;
715
716 CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
717
718 if (!(mi = HeapAlloc(GetProcessHeap(), 0, size)))
719 {
720 SetLastError(ERROR_OUTOFMEMORY);
721 goto error;
722 }
723 ret = CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, mi, &size);
724 if (ret)
725 {
726 UNICODE_STRING guid;
727
728 member->dwCertVersion = mi->dwCertVersion;
729 RtlInitUnicodeString(&guid, mi->pwszSubjGuid);
730 if (RtlGUIDFromString(&guid, &member->gSubjectType))
731 {
732 HeapFree(GetProcessHeap(), 0, mi);
733 goto error;
734 }
735 }
736 HeapFree(GetProcessHeap(), 0, mi);
737 if (!ret) goto error;
738 }
739 else if (!strcmp(attr->pszObjId, SPC_INDIRECT_DATA_OBJID))
740 {
741 /* SPC_INDIRECT_DATA_CONTENT is equal to SIP_INDIRECT_DATA */
742
743 member->sEncodedIndirectData.cbData = attr->rgValue->cbData;
744 member->sEncodedIndirectData.pbData = attr->rgValue->pbData;
745
746 CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
747
748 if (!(member->pIndirectData = HeapAlloc(GetProcessHeap(), 0, size)))
749 {
750 SetLastError(ERROR_OUTOFMEMORY);
751 goto error;
752 }
753 CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, member->pIndirectData, &size);
754 }
755 else
756 /* this object id should probably be handled in CryptCATEnumerateAttr */
757 FIXME("unhandled object id \"%s\"\n", attr->pszObjId);
758 }
759
760 if (!member->sEncodedMemberInfo.cbData || !member->sEncodedIndirectData.cbData)
761 {
762 ERR("Corrupted catalog entry?\n");
763 SetLastError(CRYPT_E_ATTRIBUTES_MISSING);
764 goto error;
765 }
766 size = (2 * member->pIndirectData->Digest.cbData + 1) * sizeof(WCHAR);
767 if (member->pwszReferenceTag)
768 member->pwszReferenceTag = HeapReAlloc(GetProcessHeap(), 0, member->pwszReferenceTag, size);
769 else
770 member->pwszReferenceTag = HeapAlloc(GetProcessHeap(), 0, size);
771
772 if (!member->pwszReferenceTag)
773 {
774 SetLastError(ERROR_OUTOFMEMORY);
775 goto error;
776 }
777 /* FIXME: reference tag is usually the file hash but doesn't have to be */
778 for (i = 0; i < member->pIndirectData->Digest.cbData; i++)
779 {
780 DWORD sub;
781
782 sub = member->pIndirectData->Digest.pbData[i] >> 4;
783 member->pwszReferenceTag[i * 2] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
784 sub = member->pIndirectData->Digest.pbData[i] & 0xf;
785 member->pwszReferenceTag[i * 2 + 1] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
786 }
787 member->pwszReferenceTag[i * 2] = 0;
788 return member;
789
790 error:
791 HeapFree(GetProcessHeap(), 0, member->pIndirectData);
792 HeapFree(GetProcessHeap(), 0, member->pwszReferenceTag);
793 HeapFree(GetProcessHeap(), 0, member);
794 return NULL;
795 }
796
797 static CTL_INFO *decode_inner_content(HANDLE hmsg, DWORD encoding, DWORD *len)
798 {
799 DWORD size;
800 LPSTR oid = NULL;
801 BYTE *buffer = NULL;
802 CTL_INFO *inner = NULL;
803
804 if (!CryptMsgGetParam(hmsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, NULL, &size)) return NULL;
805 if (!(oid = HeapAlloc(GetProcessHeap(), 0, size)))
806 {
807 SetLastError(ERROR_OUTOFMEMORY);
808 return NULL;
809 }
810 if (!CryptMsgGetParam(hmsg, CMSG_INNER_CONTENT_TYPE_PARAM, 0, oid, &size)) goto out;
811 if (!CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM, 0, NULL, &size)) goto out;
812 if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
813 {
814 SetLastError(ERROR_OUTOFMEMORY);
815 goto out;
816 }
817 if (!CryptMsgGetParam(hmsg, CMSG_CONTENT_PARAM, 0, buffer, &size)) goto out;
818 if (!CryptDecodeObject(encoding, oid, buffer, size, 0, NULL, &size)) goto out;
819 if (!(inner = HeapAlloc(GetProcessHeap(), 0, size)))
820 {
821 SetLastError(ERROR_OUTOFMEMORY);
822 goto out;
823 }
824 if (!CryptDecodeObject(encoding, oid, buffer, size, 0, inner, &size)) goto out;
825 *len = size;
826
827 out:
828 HeapFree(GetProcessHeap(), 0, oid);
829 HeapFree(GetProcessHeap(), 0, buffer);
830 return inner;
831 }
832
833 /***********************************************************************
834 * CryptCATCatalogInfoFromContext (WINTRUST.@)
835 */
836 BOOL WINAPI CryptCATCatalogInfoFromContext(HCATINFO hcatinfo, CATALOG_INFO *info, DWORD flags)
837 {
838 struct catinfo *ci = hcatinfo;
839
840 TRACE("%p, %p, %lx\n", hcatinfo, info, flags);
841
842 if (!hcatinfo || hcatinfo == INVALID_HANDLE_VALUE || ci->magic != CATINFO_MAGIC ||
843 flags || !info || info->cbStruct != sizeof(*info))
844 {
845 SetLastError(ERROR_INVALID_PARAMETER);
846 return FALSE;
847 }
848 lstrcpyW(info->wszCatalogFile, ci->file);
849 return TRUE;
850 }
851
852 /***********************************************************************
853 * CryptCATPutAttrInfo (WINTRUST.@)
854 */
855 CRYPTCATATTRIBUTE * WINAPI CryptCATPutAttrInfo(HANDLE catalog, CRYPTCATMEMBER *member,
856 WCHAR *name, DWORD flags, DWORD size, BYTE *data)
857 {
858 FIXME("catalog %p, member %p, name %s, flags %#lx, size %lu, data %p, stub!\n",
859 catalog, member, debugstr_w(name), flags, size, data);
860
861 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
862 return NULL;
863 }
864
865 /***********************************************************************
866 * CryptCATPutCatAttrInfo (WINTRUST.@)
867 */
868 CRYPTCATATTRIBUTE * WINAPI CryptCATPutCatAttrInfo(HANDLE catalog,
869 WCHAR *name, DWORD flags, DWORD size, BYTE *data)
870 {
871 FIXME("catalog %p, name %s, flags %#lx, size %lu, data %p, stub!\n",
872 catalog, debugstr_w(name), flags, size, data);
873
874 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
875 return NULL;
876 }
877
878 /***********************************************************************
879 * CryptCATPutMemberInfo (WINTRUST.@)
880 */
881 CRYPTCATMEMBER * WINAPI CryptCATPutMemberInfo(HANDLE catalog, WCHAR *filename,
882 WCHAR *member, GUID *subject, DWORD version, DWORD size, BYTE *data)
883 {
884 FIXME("catalog %p, filename %s, member %s, subject %s, version %lu, size %lu, data %p, stub!\n",
885 catalog, debugstr_w(filename), debugstr_w(member), debugstr_guid(subject), version, size, data);
886
887 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
888 return NULL;
889 }
890
891 /***********************************************************************
892 * CryptCATPersistStore (WINTRUST.@)
893 */
894 BOOL WINAPI CryptCATPersistStore(HANDLE catalog)
895 {
896 FIXME("catalog %p, stub!\n", catalog);
897
898 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
899 return FALSE;
900 }
901
902 /***********************************************************************
903 * CryptCATOpen (WINTRUST.@)
904 */
905 HANDLE WINAPI CryptCATOpen(WCHAR *filename, DWORD flags, HCRYPTPROV hProv,
906 DWORD dwPublicVersion, DWORD dwEncodingType)
907 {
908 HANDLE file, hmsg;
909 BYTE *buffer = NULL;
910 DWORD size, open_mode = OPEN_ALWAYS;
911 struct cryptcat *cc;
912 BOOL valid;
913
914 TRACE("filename %s, flags %#lx, provider %#Ix, version %#lx, type %#lx\n",
915 debugstr_w(filename), flags, hProv, dwPublicVersion, dwEncodingType);
916
917 if (!filename)
918 {
919 SetLastError(ERROR_INVALID_PARAMETER);
920 return INVALID_HANDLE_VALUE;
921 }
922
923 if (!dwEncodingType) dwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
924
925 if (flags == CRYPTCAT_OPEN_EXISTING)
926 open_mode = OPEN_EXISTING;
927 if (flags & CRYPTCAT_OPEN_CREATENEW)
928 open_mode = CREATE_ALWAYS;
929
930 file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, open_mode, 0, NULL);
931 if (file == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;
932
933 size = GetFileSize(file, NULL);
934 if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
935 {
936 CloseHandle(file);
937 SetLastError(ERROR_OUTOFMEMORY);
938 return INVALID_HANDLE_VALUE;
939 }
940 if (!(hmsg = CryptMsgOpenToDecode(dwEncodingType, 0, 0, hProv, NULL, NULL)))
941 {
942 CloseHandle(file);
943 HeapFree(GetProcessHeap(), 0, buffer);
944 return INVALID_HANDLE_VALUE;
945 }
946 if (!size) valid = FALSE;
947 else if (!ReadFile(file, buffer, size, &size, NULL))
948 {
949 CloseHandle(file);
950 HeapFree(GetProcessHeap(), 0, buffer);
951 CryptMsgClose(hmsg);
952 return INVALID_HANDLE_VALUE;
953 }
954 else valid = CryptMsgUpdate(hmsg, buffer, size, TRUE);
955 HeapFree(GetProcessHeap(), 0, buffer);
956 CloseHandle(file);
957
958 size = sizeof(DWORD);
959 if (!(cc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cc))))
960 {
961 CryptMsgClose(hmsg);
962 SetLastError(ERROR_OUTOFMEMORY);
963 return INVALID_HANDLE_VALUE;
964 }
965
966 cc->msg = hmsg;
967 cc->encoding = dwEncodingType;
968 if (!valid)
969 {
970 cc->magic = CRYPTCAT_MAGIC;
971 SetLastError(ERROR_SUCCESS);
972 return cc;
973 }
974 else if (CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_COUNT_PARAM, 0, &cc->attr_count, &size))
975 {
976 DWORD i, sum = 0;
977 BYTE *p;
978
979 for (i = 0; i < cc->attr_count; i++)
980 {
981 if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
982 {
983 CryptMsgClose(hmsg);
984 HeapFree(GetProcessHeap(), 0, cc);
985 return INVALID_HANDLE_VALUE;
986 }
987 sum += size;
988 }
989 if (!(cc->attr = HeapAlloc(GetProcessHeap(), 0, sizeof(*cc->attr) * cc->attr_count + sum)))
990 {
991 CryptMsgClose(hmsg);
992 HeapFree(GetProcessHeap(), 0, cc);
993 SetLastError(ERROR_OUTOFMEMORY);
994 return INVALID_HANDLE_VALUE;
995 }
996 p = (BYTE *)(cc->attr + cc->attr_count);
997 for (i = 0; i < cc->attr_count; i++)
998 {
999 if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
1000 {
1001 CryptMsgClose(hmsg);
1002 HeapFree(GetProcessHeap(), 0, cc->attr);
1003 HeapFree(GetProcessHeap(), 0, cc);
1004 return INVALID_HANDLE_VALUE;
1005 }
1006 if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, p, &size))
1007 {
1008 CryptMsgClose(hmsg);
1009 HeapFree(GetProcessHeap(), 0, cc->attr);
1010 HeapFree(GetProcessHeap(), 0, cc);
1011 return INVALID_HANDLE_VALUE;
1012 }
1013 p += size;
1014 }
1015 cc->inner = decode_inner_content(hmsg, dwEncodingType, &cc->inner_len);
1016 if (!cc->inner || !CryptSIPRetrieveSubjectGuid(filename, NULL, &cc->subject))
1017 {
1018 CryptMsgClose(hmsg);
1019 HeapFree(GetProcessHeap(), 0, cc->attr);
1020 HeapFree(GetProcessHeap(), 0, cc->inner);
1021 HeapFree(GetProcessHeap(), 0, cc);
1022 return INVALID_HANDLE_VALUE;
1023 }
1024 cc->magic = CRYPTCAT_MAGIC;
1025 SetLastError(ERROR_SUCCESS);
1026 return cc;
1027 }
1028 HeapFree(GetProcessHeap(), 0, cc);
1029 return INVALID_HANDLE_VALUE;
1030 }
1031
1032 /***********************************************************************
1033 * CryptSIPCreateIndirectData (WINTRUST.@)
1034 */
1035 BOOL WINAPI CryptSIPCreateIndirectData(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pcbIndirectData,
1036 SIP_INDIRECT_DATA* pIndirectData)
1037 {
1038 FIXME("(%p %p %p) stub\n", pSubjectInfo, pcbIndirectData, pIndirectData);
1039
1040 return FALSE;
1041 }
1042
1043
1044 /***********************************************************************
1045 * CryptCATCDFClose (WINTRUST.@)
1046 */
1047 BOOL WINAPI CryptCATCDFClose(CRYPTCATCDF *pCDF)
1048 {
1049 FIXME("(%p) stub\n", pCDF);
1050
1051 return FALSE;
1052 }
1053
1054 /***********************************************************************
1055 * CryptCATCDFEnumCatAttributes (WINTRUST.@)
1056 */
1057 CRYPTCATATTRIBUTE * WINAPI CryptCATCDFEnumCatAttributes(CRYPTCATCDF *pCDF,
1058 CRYPTCATATTRIBUTE *pPrevAttr,
1059 PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError)
1060 {
1061 FIXME("(%p %p %p) stub\n", pCDF, pPrevAttr, pfnParseError);
1062
1063 return NULL;
1064 }
1065
1066 /***********************************************************************
1067 * CryptCATCDFEnumMembersByCDFTagEx (WINTRUST.@)
1068 */
1069 LPWSTR WINAPI CryptCATCDFEnumMembersByCDFTagEx(CRYPTCATCDF *pCDF, LPWSTR pwszPrevCDFTag,
1070 PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError,
1071 CRYPTCATMEMBER **ppMember, BOOL fContinueOnError,
1072 LPVOID pvReserved)
1073 {
1074 FIXME("(%p %s %p %p %d %p) stub\n", pCDF, debugstr_w(pwszPrevCDFTag), pfnParseError,
1075 ppMember, fContinueOnError, pvReserved);
1076
1077 return NULL;
1078 }
1079
1080 /***********************************************************************
1081 * CryptCATCDFOpen (WINTRUST.@)
1082 */
1083 CRYPTCATCDF * WINAPI CryptCATCDFOpen(LPWSTR pwszFilePath,
1084 PFN_CDF_PARSE_ERROR_CALLBACK pfnParseError)
1085 {
1086 FIXME("(%s %p) stub\n", debugstr_w(pwszFilePath), pfnParseError);
1087
1088 return NULL;
1089 }
1090
1091 static BOOL WINTRUST_GetSignedMsgFromPEFile(SIP_SUBJECTINFO *pSubjectInfo,
1092 DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1093 BYTE *pbSignedDataMsg)
1094 {
1095 BOOL ret;
1096 WIN_CERTIFICATE *pCert = NULL;
1097 HANDLE file;
1098
1099 TRACE("(%p %p %ld %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1100 pcbSignedDataMsg, pbSignedDataMsg);
1101
1102 if(pSubjectInfo->hFile && pSubjectInfo->hFile!=INVALID_HANDLE_VALUE)
1103 file = pSubjectInfo->hFile;
1104 else
1105 {
1106 file = CreateFileW(pSubjectInfo->pwsFileName, GENERIC_READ,
1107 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1108 if(file == INVALID_HANDLE_VALUE)
1109 return FALSE;
1110 }
1111
1112 if (!pbSignedDataMsg)
1113 {
1114 WIN_CERTIFICATE cert;
1115
1116 /* app hasn't passed buffer, just get the length */
1117 ret = ImageGetCertificateHeader(file, dwIndex, &cert);
1118 if (ret)
1119 {
1120 switch (cert.wCertificateType)
1121 {
1122 case WIN_CERT_TYPE_X509:
1123 case WIN_CERT_TYPE_PKCS_SIGNED_DATA:
1124 *pcbSignedDataMsg = cert.dwLength;
1125 break;
1126 default:
1127 WARN("unknown certificate type %d\n", cert.wCertificateType);
1128 ret = FALSE;
1129 }
1130 }
1131 }
1132 else
1133 {
1134 DWORD len = 0;
1135
1136 ret = ImageGetCertificateData(file, dwIndex, NULL, &len);
1137 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1138 goto error;
1139 pCert = HeapAlloc(GetProcessHeap(), 0, len);
1140 if (!pCert)
1141 {
1142 ret = FALSE;
1143 goto error;
1144 }
1145 ret = ImageGetCertificateData(file, dwIndex, pCert, &len);
1146 if (!ret)
1147 goto error;
1148 pCert->dwLength -= FIELD_OFFSET(WIN_CERTIFICATE, bCertificate);
1149 if (*pcbSignedDataMsg < pCert->dwLength)
1150 {
1151 *pcbSignedDataMsg = pCert->dwLength;
1152 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1153 ret = FALSE;
1154 }
1155 else
1156 {
1157 memcpy(pbSignedDataMsg, pCert->bCertificate, pCert->dwLength);
1158 *pcbSignedDataMsg = pCert->dwLength;
1159 switch (pCert->wCertificateType)
1160 {
1161 case WIN_CERT_TYPE_X509:
1162 *pdwEncodingType = X509_ASN_ENCODING;
1163 break;
1164 case WIN_CERT_TYPE_PKCS_SIGNED_DATA:
1165 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1166 break;
1167 default:
1168 WARN("don't know what to do for encoding type %d\n",
1169 pCert->wCertificateType);
1170 *pdwEncodingType = 0;
1171 ret = FALSE;
1172 }
1173 }
1174 }
1175 error:
1176 if(pSubjectInfo->hFile != file)
1177 CloseHandle(file);
1178 HeapFree(GetProcessHeap(), 0, pCert);
1179 return ret;
1180 }
1181
1182 static BOOL WINTRUST_PutSignedMsgToPEFile(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType,
1183 DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg)
1184 {
1185 WIN_CERTIFICATE *cert;
1186 HANDLE file;
1187 DWORD size;
1188 BOOL ret;
1189
1190 if(pSubjectInfo->hFile && pSubjectInfo->hFile!=INVALID_HANDLE_VALUE)
1191 file = pSubjectInfo->hFile;
1192 else
1193 {
1194 file = CreateFileW(pSubjectInfo->pwsFileName, GENERIC_READ|GENERIC_WRITE,
1195 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1196 if(file == INVALID_HANDLE_VALUE)
1197 return FALSE;
1198 }
1199
1200 /* int aligned WIN_CERTIFICATE structure with cbSignedDataMsg+1 bytes of data */
1201 size = FIELD_OFFSET(WIN_CERTIFICATE, bCertificate[cbSignedDataMsg+4]) & (~3);
1202 cert = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1203 if(!cert)
1204 return FALSE;
1205
1206 cert->dwLength = size;
1207 cert->wRevision = WIN_CERT_REVISION_2_0;
1208 cert->wCertificateType = WIN_CERT_TYPE_PKCS_SIGNED_DATA;
1209 memcpy(cert->bCertificate, pbSignedDataMsg, cbSignedDataMsg);
1210 ret = ImageAddCertificate(file, cert, pdwIndex);
1211
1212 HeapFree(GetProcessHeap(), 0, cert);
1213 if(file != pSubjectInfo->hFile)
1214 CloseHandle(file);
1215 return ret;
1216 }
1217
1218 /* structure offsets */
1219 #define cfhead_Signature (0x00)
1220 #define cfhead_CabinetSize (0x08)
1221 #define cfhead_MinorVersion (0x18)
1222 #define cfhead_MajorVersion (0x19)
1223 #define cfhead_Flags (0x1E)
1224 #define cfhead_SIZEOF (0x24)
1225 #define cfheadext_HeaderReserved (0x00)
1226 #define cfheadext_SIZEOF (0x04)
1227 #define cfsigninfo_CertOffset (0x04)
1228 #define cfsigninfo_CertSize (0x08)
1229 #define cfsigninfo_SIZEOF (0x0C)
1230
1231 /* flags */
1232 #define cfheadRESERVE_PRESENT (0x0004)
1233
1234 /* endian-neutral reading of little-endian data */
1235 #define EndGetI32(a) ((((a)[3])<<24)|(((a)[2])<<16)|(((a)[1])<<8)|((a)[0]))
1236 #define EndGetI16(a) ((((a)[1])<<8)|((a)[0]))
1237
1238 /* For documentation purposes only: this is the structure in the reserved
1239 * area of a signed cabinet file. The cert offset indicates where in the
1240 * cabinet file the signature resides, and the count indicates its size.
1241 */
1242 typedef struct _CAB_SIGNINFO
1243 {
1244 WORD unk0; /* always 0? */
1245 WORD unk1; /* always 0x0010? */
1246 DWORD dwCertOffset;
1247 DWORD cbCertBlock;
1248 } CAB_SIGNINFO, *PCAB_SIGNINFO;
1249
1250 static BOOL WINTRUST_GetSignedMsgFromCabFile(SIP_SUBJECTINFO *pSubjectInfo,
1251 DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1252 BYTE *pbSignedDataMsg)
1253 {
1254 int header_resv;
1255 LONG base_offset, cabsize;
1256 USHORT flags;
1257 BYTE buf[64];
1258 DWORD cert_offset, cert_size, dwRead;
1259
1260 TRACE("(%p %p %ld %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1261 pcbSignedDataMsg, pbSignedDataMsg);
1262
1263 /* get basic offset & size info */
1264 base_offset = SetFilePointer(pSubjectInfo->hFile, 0L, NULL, SEEK_CUR);
1265
1266 if (SetFilePointer(pSubjectInfo->hFile, 0, NULL, SEEK_END) == INVALID_SET_FILE_POINTER)
1267 {
1268 TRACE("seek error\n");
1269 return FALSE;
1270 }
1271
1272 cabsize = SetFilePointer(pSubjectInfo->hFile, 0L, NULL, SEEK_CUR);
1273 if ((cabsize == -1) || (base_offset == -1) ||
1274 (SetFilePointer(pSubjectInfo->hFile, 0, NULL, SEEK_SET) == INVALID_SET_FILE_POINTER))
1275 {
1276 TRACE("seek error\n");
1277 return FALSE;
1278 }
1279
1280 /* read in the CFHEADER */
1281 if (!ReadFile(pSubjectInfo->hFile, buf, cfhead_SIZEOF, &dwRead, NULL) ||
1282 dwRead != cfhead_SIZEOF)
1283 {
1284 TRACE("reading header failed\n");
1285 return FALSE;
1286 }
1287
1288 /* check basic MSCF signature */
1289 if (EndGetI32(buf+cfhead_Signature) != 0x4643534d)
1290 {
1291 WARN("cabinet signature not present\n");
1292 return FALSE;
1293 }
1294
1295 /* Ignore the number of folders and files and the set and cabinet IDs */
1296
1297 /* check the header revision */
1298 if ((buf[cfhead_MajorVersion] > 1) ||
1299 (buf[cfhead_MajorVersion] == 1 && buf[cfhead_MinorVersion] > 3))
1300 {
1301 WARN("cabinet format version > 1.3\n");
1302 return FALSE;
1303 }
1304
1305 /* pull the flags out */
1306 flags = EndGetI16(buf+cfhead_Flags);
1307
1308 if (!(flags & cfheadRESERVE_PRESENT))
1309 {
1310 TRACE("no header present, not signed\n");
1311 return FALSE;
1312 }
1313
1314 if (!ReadFile(pSubjectInfo->hFile, buf, cfheadext_SIZEOF, &dwRead, NULL) ||
1315 dwRead != cfheadext_SIZEOF)
1316 {
1317 ERR("bunk reserve-sizes?\n");
1318 return FALSE;
1319 }
1320
1321 header_resv = EndGetI16(buf+cfheadext_HeaderReserved);
1322 if (!header_resv)
1323 {
1324 TRACE("no header_resv, not signed\n");
1325 return FALSE;
1326 }
1327 else if (header_resv < cfsigninfo_SIZEOF)
1328 {
1329 TRACE("header_resv too small, not signed\n");
1330 return FALSE;
1331 }
1332
1333 if (header_resv > 60000)
1334 {
1335 WARN("WARNING; header reserved space > 60000\n");
1336 }
1337
1338 if (!ReadFile(pSubjectInfo->hFile, buf, cfsigninfo_SIZEOF, &dwRead, NULL) ||
1339 dwRead != cfsigninfo_SIZEOF)
1340 {
1341 ERR("couldn't read reserve\n");
1342 return FALSE;
1343 }
1344
1345 cert_offset = EndGetI32(buf+cfsigninfo_CertOffset);
1346 TRACE("cert_offset: %ld\n", cert_offset);
1347 cert_size = EndGetI32(buf+cfsigninfo_CertSize);
1348 TRACE("cert_size: %ld\n", cert_size);
1349
1350 /* The redundant checks are to avoid wraparound */
1351 if (cert_offset > cabsize || cert_size > cabsize ||
1352 cert_offset + cert_size > cabsize)
1353 {
1354 WARN("offset beyond file, not attempting to read\n");
1355 return FALSE;
1356 }
1357
1358 SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1359 if (!pbSignedDataMsg)
1360 {
1361 *pcbSignedDataMsg = cert_size;
1362 return TRUE;
1363 }
1364 if (*pcbSignedDataMsg < cert_size)
1365 {
1366 *pcbSignedDataMsg = cert_size;
1367 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1368 return FALSE;
1369 }
1370 if (SetFilePointer(pSubjectInfo->hFile, cert_offset, NULL, SEEK_SET) == INVALID_SET_FILE_POINTER)
1371 {
1372 ERR("couldn't seek to cert location\n");
1373 return FALSE;
1374 }
1375 if (!ReadFile(pSubjectInfo->hFile, pbSignedDataMsg, cert_size, &dwRead,
1376 NULL) || dwRead != cert_size)
1377 {
1378 ERR("couldn't read cert\n");
1379 SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1380 return FALSE;
1381 }
1382 /* The encoding of the files I've seen appears to be in ASN.1
1383 * format, and there isn't a field indicating the type, so assume it
1384 * always is.
1385 */
1386 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1387 /* Restore base offset */
1388 SetFilePointer(pSubjectInfo->hFile, base_offset, NULL, SEEK_SET);
1389 return TRUE;
1390 }
1391
1392 static BOOL WINTRUST_GetSignedMsgFromCatFile(SIP_SUBJECTINFO *pSubjectInfo,
1393 DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
1394 BYTE *pbSignedDataMsg)
1395 {
1396 BOOL ret;
1397
1398 TRACE("(%p %p %ld %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1399 pcbSignedDataMsg, pbSignedDataMsg);
1400
1401 if (!pbSignedDataMsg)
1402 {
1403 *pcbSignedDataMsg = GetFileSize(pSubjectInfo->hFile, NULL);
1404 ret = TRUE;
1405 }
1406 else
1407 {
1408 DWORD len = GetFileSize(pSubjectInfo->hFile, NULL);
1409
1410 if (*pcbSignedDataMsg < len)
1411 {
1412 *pcbSignedDataMsg = len;
1413 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1414 ret = FALSE;
1415 }
1416 else
1417 {
1418 ret = ReadFile(pSubjectInfo->hFile, pbSignedDataMsg, len,
1419 pcbSignedDataMsg, NULL);
1420 if (ret)
1421 *pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1422 }
1423 }
1424 return ret;
1425 }
1426
1427 /* GUIDs used by CryptSIPGetSignedDataMsg and CryptSIPPutSignedDataMsg */
1428 static const GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
1429 0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
1430 static const GUID cabGUID = { 0xC689AABA, 0x8E78, 0x11D0, { 0x8C,0x47,
1431 0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
1432 static const GUID catGUID = { 0xDE351A43, 0x8E59, 0x11D0, { 0x8C,0x47,
1433 0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
1434
1435 /***********************************************************************
1436 * CryptSIPGetSignedDataMsg (WINTRUST.@)
1437 */
1438 BOOL WINAPI CryptSIPGetSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD* pdwEncodingType,
1439 DWORD dwIndex, DWORD* pcbSignedDataMsg, BYTE* pbSignedDataMsg)
1440 {
1441 BOOL ret;
1442
1443 TRACE("(%p %p %ld %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
1444 pcbSignedDataMsg, pbSignedDataMsg);
1445
1446 if(!pSubjectInfo)
1447 {
1448 SetLastError(ERROR_INVALID_PARAMETER);
1449 return FALSE;
1450 }
1451
1452 if (!memcmp(pSubjectInfo->pgSubjectType, &unknown, sizeof(unknown)))
1453 ret = WINTRUST_GetSignedMsgFromPEFile(pSubjectInfo, pdwEncodingType,
1454 dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1455 else if (!memcmp(pSubjectInfo->pgSubjectType, &cabGUID, sizeof(cabGUID)))
1456 ret = WINTRUST_GetSignedMsgFromCabFile(pSubjectInfo, pdwEncodingType,
1457 dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1458 else if (!memcmp(pSubjectInfo->pgSubjectType, &catGUID, sizeof(catGUID)))
1459 ret = WINTRUST_GetSignedMsgFromCatFile(pSubjectInfo, pdwEncodingType,
1460 dwIndex, pcbSignedDataMsg, pbSignedDataMsg);
1461 else
1462 {
1463 FIXME("unimplemented for subject type %s\n",
1464 debugstr_guid(pSubjectInfo->pgSubjectType));
1465 ret = FALSE;
1466 }
1467
1468 TRACE("returning %d\n", ret);
1469 return ret;
1470 }
1471
1472 /***********************************************************************
1473 * CryptSIPPutSignedDataMsg (WINTRUST.@)
1474 */
1475 BOOL WINAPI CryptSIPPutSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo, DWORD pdwEncodingType,
1476 DWORD* pdwIndex, DWORD cbSignedDataMsg, BYTE* pbSignedDataMsg)
1477 {
1478 TRACE("(%p %ld %p %ld %p)\n", pSubjectInfo, pdwEncodingType, pdwIndex,
1479 cbSignedDataMsg, pbSignedDataMsg);
1480
1481 if(!pSubjectInfo) {
1482 SetLastError(ERROR_INVALID_PARAMETER);
1483 return FALSE;
1484 }
1485
1486 if(!memcmp(pSubjectInfo->pgSubjectType, &unknown, sizeof(unknown)))
1487 return WINTRUST_PutSignedMsgToPEFile(pSubjectInfo, pdwEncodingType,
1488 pdwIndex, cbSignedDataMsg, pbSignedDataMsg);
1489 else
1490 FIXME("unimplemented for subject type %s\n",
1491 debugstr_guid(pSubjectInfo->pgSubjectType));
1492
1493 return FALSE;
1494 }
1495
1496 /***********************************************************************
1497 * CryptSIPRemoveSignedDataMsg (WINTRUST.@)
1498 */
1499 BOOL WINAPI CryptSIPRemoveSignedDataMsg(SIP_SUBJECTINFO* pSubjectInfo,
1500 DWORD dwIndex)
1501 {
1502 FIXME("(%p %ld) stub\n", pSubjectInfo, dwIndex);
1503
1504 return FALSE;
1505 }
1506
1507 /***********************************************************************
1508 * CryptSIPVerifyIndirectData (WINTRUST.@)
1509 */
1510 BOOL WINAPI CryptSIPVerifyIndirectData(SIP_SUBJECTINFO* pSubjectInfo,
1511 SIP_INDIRECT_DATA* pIndirectData)
1512 {
1513 FIXME("(%p %p) stub\n", pSubjectInfo, pIndirectData);
1514
1515 return FALSE;
1516 }
Windows API implementation