shell32: Add initial Romanian translation.
[wine] / dlls / wintrust / wintrust_main.c
1 /*
2  * Copyright 2001 Rein Klazes
3  * Copyright 2007 Juan Lang
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19
20 #include "config.h"
21
22 #include <stdarg.h>
23
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winerror.h"
29 #include "winreg.h"
30 #include "guiddef.h"
31 #include "wintrust.h"
32 #include "softpub.h"
33 #include "mscat.h"
34 #include "objbase.h"
35 #include "winuser.h"
36 #include "wintrust_priv.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
40
41
42 /***********************************************************************
43  *              DllMain  (WINTRUST.@)
44  */
45 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
46 {
47     switch(reason)
48     {
49     case DLL_PROCESS_ATTACH:
50         DisableThreadLibraryCalls( inst );
51         break;
52     }
53     return TRUE;
54 }
55
56 /***********************************************************************
57  *              TrustIsCertificateSelfSigned (WINTRUST.@)
58  */
59 BOOL WINAPI TrustIsCertificateSelfSigned( PCCERT_CONTEXT cert )
60 {
61     BOOL ret;
62
63     TRACE("%p\n", cert);
64     ret = CertCompareCertificateName(cert->dwCertEncodingType,
65      &cert->pCertInfo->Subject, &cert->pCertInfo->Issuer);
66     return ret;
67 }
68
69 static LONG WINTRUST_DefaultVerify(HWND hwnd, GUID *actionID,
70  WINTRUST_DATA *data)
71 {
72     DWORD err = ERROR_SUCCESS;
73     CRYPT_PROVIDER_DATA *provData;
74     BOOL ret;
75
76     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
77
78     provData = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_DATA));
79     if (!provData)
80         goto oom;
81     provData->cbStruct = sizeof(CRYPT_PROVIDER_DATA);
82
83     provData->padwTrustStepErrors =
84      WINTRUST_Alloc(TRUSTERROR_MAX_STEPS * sizeof(DWORD));
85     if (!provData->padwTrustStepErrors)
86         goto oom;
87     provData->cdwTrustStepErrors = TRUSTERROR_MAX_STEPS;
88
89     provData->u.pPDSip = WINTRUST_Alloc(sizeof(PROVDATA_SIP));
90     if (!provData->u.pPDSip)
91         goto oom;
92     provData->u.pPDSip->cbStruct = sizeof(PROVDATA_SIP);
93
94     provData->psPfns = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_FUNCTIONS));
95     if (!provData->psPfns)
96         goto oom;
97     provData->psPfns->cbStruct = sizeof(CRYPT_PROVIDER_FUNCTIONS);
98     ret = WintrustLoadFunctionPointers(actionID, provData->psPfns);
99     if (!ret)
100     {
101         err = GetLastError();
102         goto error;
103     }
104
105     data->hWVTStateData = (HANDLE)provData;
106     provData->pWintrustData = data;
107     if (hwnd == INVALID_HANDLE_VALUE)
108         provData->hWndParent = GetDesktopWindow();
109     else
110         provData->hWndParent = hwnd;
111     provData->pgActionID = actionID;
112     WintrustGetRegPolicyFlags(&provData->dwRegPolicySettings);
113
114     if (provData->psPfns->pfnInitialize)
115     {
116         err = provData->psPfns->pfnInitialize(provData);
117         if (err)
118             goto done;
119     }
120     if (provData->psPfns->pfnObjectTrust)
121     {
122         err = provData->psPfns->pfnObjectTrust(provData);
123         if (err)
124             goto done;
125     }
126     if (provData->psPfns->pfnSignatureTrust)
127     {
128         err = provData->psPfns->pfnSignatureTrust(provData);
129         if (err)
130             goto done;
131     }
132     if (provData->psPfns->pfnCertificateTrust)
133     {
134         err = provData->psPfns->pfnCertificateTrust(provData);
135         if (err)
136             goto done;
137     }
138     if (provData->psPfns->pfnFinalPolicy)
139         err = provData->psPfns->pfnFinalPolicy(provData);
140     goto done;
141
142 oom:
143     err = ERROR_OUTOFMEMORY;
144 error:
145     if (provData)
146     {
147         WINTRUST_Free(provData->padwTrustStepErrors);
148         WINTRUST_Free(provData->u.pPDSip);
149         WINTRUST_Free(provData->psPfns);
150         WINTRUST_Free(provData);
151     }
152 done:
153     TRACE("returning %08x\n", err);
154     return err;
155 }
156
157 static LONG WINTRUST_DefaultClose(HWND hwnd, GUID *actionID,
158  WINTRUST_DATA *data)
159 {
160     DWORD err = ERROR_SUCCESS;
161     CRYPT_PROVIDER_DATA *provData = (CRYPT_PROVIDER_DATA *)data->hWVTStateData;
162
163     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
164
165     if (provData)
166     {
167         if (provData->psPfns->pfnCleanupPolicy)
168             err = provData->psPfns->pfnCleanupPolicy(provData);
169
170         WINTRUST_Free(provData->padwTrustStepErrors);
171         WINTRUST_Free(provData->u.pPDSip);
172         WINTRUST_Free(provData->psPfns);
173         WINTRUST_Free(provData);
174         data->hWVTStateData = NULL;
175     }
176     TRACE("returning %08x\n", err);
177     return err;
178 }
179
180 static LONG WINTRUST_DefaultVerifyAndClose(HWND hwnd, GUID *actionID,
181  WINTRUST_DATA *data)
182 {
183     LONG err;
184
185     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
186
187     err = WINTRUST_DefaultVerify(hwnd, actionID, data);
188     WINTRUST_DefaultClose(hwnd, actionID, data);
189     TRACE("returning %08x\n", err);
190     return err;
191 }
192
193 static LONG WINTRUST_PublishedSoftware(HWND hwnd, GUID *actionID,
194  WINTRUST_DATA *data)
195 {
196     WINTRUST_DATA wintrust_data = { sizeof(wintrust_data), 0 };
197     /* Undocumented: the published software action is passed a path,
198      * and pSIPClientData points to a WIN_TRUST_SUBJECT_FILE.
199      */
200     LPCWSTR path = (LPCWSTR)data->u.pFile;
201     LPWIN_TRUST_SUBJECT_FILE subjectFile =
202      (LPWIN_TRUST_SUBJECT_FILE)data->pSIPClientData;
203     WINTRUST_FILE_INFO fileInfo = { sizeof(fileInfo), 0 };
204
205     TRACE("subjectFile->hFile: %p\n", subjectFile->hFile);
206     TRACE("subjectFile->lpPath: %s\n", debugstr_w(subjectFile->lpPath));
207     fileInfo.pcwszFilePath = path;
208     fileInfo.hFile = subjectFile->hFile;
209     wintrust_data.u.pFile = &fileInfo;
210     wintrust_data.dwUnionChoice = WTD_CHOICE_FILE;
211     wintrust_data.dwUIChoice = WTD_UI_NONE;
212
213     return WINTRUST_DefaultVerifyAndClose(hwnd, actionID, &wintrust_data);
214 }
215
216 static void dump_file_info(WINTRUST_FILE_INFO *pFile)
217 {
218     TRACE("%p\n", pFile);
219     if (pFile)
220     {
221         TRACE("cbStruct: %d\n", pFile->cbStruct);
222         TRACE("pcwszFilePath: %s\n", debugstr_w(pFile->pcwszFilePath));
223         TRACE("hFile: %p\n", pFile->hFile);
224         TRACE("pgKnownSubject: %s\n", debugstr_guid(pFile->pgKnownSubject));
225     }
226 }
227
228 static void dump_catalog_info(WINTRUST_CATALOG_INFO *catalog)
229 {
230     TRACE("%p\n", catalog);
231     if (catalog)
232     {
233         TRACE("cbStruct: %d\n", catalog->cbStruct);
234         TRACE("dwCatalogVersion: %d\n", catalog->dwCatalogVersion);
235         TRACE("pcwszCatalogFilePath: %s\n",
236          debugstr_w(catalog->pcwszCatalogFilePath));
237         TRACE("pcwszMemberTag: %s\n", debugstr_w(catalog->pcwszMemberTag));
238         TRACE("pcwszMemberFilePath: %s\n",
239          debugstr_w(catalog->pcwszMemberFilePath));
240         TRACE("hMemberFile: %p\n", catalog->hMemberFile);
241         TRACE("pbCalculatedFileHash: %p\n", catalog->pbCalculatedFileHash);
242         TRACE("cbCalculatedFileHash: %d\n", catalog->cbCalculatedFileHash);
243         TRACE("pcCatalogContext: %p\n", catalog->pcCatalogContext);
244     }
245 }
246
247 static void dump_blob_info(WINTRUST_BLOB_INFO *blob)
248 {
249     TRACE("%p\n", blob);
250     if (blob)
251     {
252         TRACE("cbStruct: %d\n", blob->cbStruct);
253         TRACE("gSubject: %s\n", debugstr_guid(&blob->gSubject));
254         TRACE("pcwszDisplayName: %s\n", debugstr_w(blob->pcwszDisplayName));
255         TRACE("cbMemObject: %d\n", blob->cbMemObject);
256         TRACE("pbMemObject: %p\n", blob->pbMemObject);
257         TRACE("cbMemSignedMsg: %d\n", blob->cbMemSignedMsg);
258         TRACE("pbMemSignedMsg: %p\n", blob->pbMemSignedMsg);
259     }
260 }
261
262 static void dump_sgnr_info(WINTRUST_SGNR_INFO *sgnr)
263 {
264     TRACE("%p\n", sgnr);
265     if (sgnr)
266     {
267         TRACE("cbStruct: %d\n", sgnr->cbStruct);
268         TRACE("pcwszDisplayName: %s\n", debugstr_w(sgnr->pcwszDisplayName));
269         TRACE("psSignerInfo: %p\n", sgnr->psSignerInfo);
270         TRACE("chStores: %d\n", sgnr->chStores);
271     }
272 }
273
274 static void dump_cert_info(WINTRUST_CERT_INFO *cert)
275 {
276     TRACE("%p\n", cert);
277     if (cert)
278     {
279         TRACE("cbStruct: %d\n", cert->cbStruct);
280         TRACE("pcwszDisplayName: %s\n", debugstr_w(cert->pcwszDisplayName));
281         TRACE("psCertContext: %p\n", cert->psCertContext);
282         TRACE("chStores: %d\n", cert->chStores);
283         TRACE("dwFlags: %08x\n", cert->dwFlags);
284         TRACE("psftVerifyAsOf: %p\n", cert->psftVerifyAsOf);
285     }
286 }
287
288 static void dump_wintrust_data(WINTRUST_DATA *data)
289 {
290     TRACE("%p\n", data);
291     if (data)
292     {
293         TRACE("cbStruct: %d\n", data->cbStruct);
294         TRACE("pPolicyCallbackData: %p\n", data->pPolicyCallbackData);
295         TRACE("pSIPClientData: %p\n", data->pSIPClientData);
296         TRACE("dwUIChoice: %d\n", data->dwUIChoice);
297         TRACE("fdwRevocationChecks: %08x\n", data->fdwRevocationChecks);
298         TRACE("dwUnionChoice: %d\n", data->dwUnionChoice);
299         switch (data->dwUnionChoice)
300         {
301         case WTD_CHOICE_FILE:
302             dump_file_info(data->u.pFile);
303             break;
304         case WTD_CHOICE_CATALOG:
305             dump_catalog_info(data->u.pCatalog);
306             break;
307         case WTD_CHOICE_BLOB:
308             dump_blob_info(data->u.pBlob);
309             break;
310         case WTD_CHOICE_SIGNER:
311             dump_sgnr_info(data->u.pSgnr);
312             break;
313         case WTD_CHOICE_CERT:
314             dump_cert_info(data->u.pCert);
315             break;
316         }
317         TRACE("dwStateAction: %d\n", data->dwStateAction);
318         TRACE("hWVTStateData: %p\n", data->hWVTStateData);
319         TRACE("pwszURLReference: %s\n", debugstr_w(data->pwszURLReference));
320         TRACE("dwProvFlags: %08x\n", data->dwProvFlags);
321         TRACE("dwUIContext: %d\n", data->dwUIContext);
322     }
323 }
324
325 /***********************************************************************
326  *              WinVerifyTrust (WINTRUST.@)
327  *
328  * Verifies an object by calling the specified trust provider.
329  *
330  * PARAMS
331  *   hwnd       [I] Handle to a caller window.
332  *   ActionID   [I] Pointer to a GUID that identifies the action to perform.
333  *   ActionData [I] Information used by the trust provider to verify the object.
334  *
335  * RETURNS
336  *   Success: Zero.
337  *   Failure: A TRUST_E_* error code.
338  *
339  * NOTES
340  *   Trust providers can be found at:
341  *   HKLM\SOFTWARE\Microsoft\Cryptography\Providers\Trust\
342  */
343 LONG WINAPI WinVerifyTrust( HWND hwnd, GUID *ActionID, LPVOID ActionData )
344 {
345     static const GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
346      0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
347     static const GUID published_software = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE;
348     static const GUID generic_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
349     static const GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
350     static const GUID generic_chain_verify = WINTRUST_ACTION_GENERIC_CHAIN_VERIFY;
351     LONG err = ERROR_SUCCESS;
352     WINTRUST_DATA *actionData = (WINTRUST_DATA *)ActionData;
353
354     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(ActionID), ActionData);
355     dump_wintrust_data(ActionData);
356
357     /* Support for known old-style callers: */
358     if (IsEqualGUID(ActionID, &published_software))
359         err = WINTRUST_PublishedSoftware(hwnd, ActionID, ActionData);
360     else
361     {
362         /* Check known actions to warn of possible problems */
363         if (!IsEqualGUID(ActionID, &unknown) &&
364          !IsEqualGUID(ActionID, &generic_verify_v2) &&
365          !IsEqualGUID(ActionID, &generic_cert_verify) &&
366          !IsEqualGUID(ActionID, &generic_chain_verify))
367             WARN("unknown action %s, default behavior may not be right\n",
368              debugstr_guid(ActionID));
369         switch (actionData->dwStateAction)
370         {
371         case WTD_STATEACTION_IGNORE:
372             err = WINTRUST_DefaultVerifyAndClose(hwnd, ActionID, ActionData);
373             break;
374         case WTD_STATEACTION_VERIFY:
375             err = WINTRUST_DefaultVerify(hwnd, ActionID, ActionData);
376             break;
377         case WTD_STATEACTION_CLOSE:
378             err = WINTRUST_DefaultClose(hwnd, ActionID, ActionData);
379             break;
380         default:
381             FIXME("unimplemented for %d\n", actionData->dwStateAction);
382         }
383     }
384
385     TRACE("returning %08x\n", err);
386     return err;
387 }
388
389 /***********************************************************************
390  *              WinVerifyTrustEx (WINTRUST.@)
391  */
392 HRESULT WINAPI WinVerifyTrustEx( HWND hwnd, GUID *ActionID,
393  WINTRUST_DATA* ActionData )
394 {
395     return WinVerifyTrust(hwnd, ActionID, ActionData);
396 }
397
398 /***********************************************************************
399  *              WTHelperGetProvSignerFromChain (WINTRUST.@)
400  */
401 CRYPT_PROVIDER_SGNR * WINAPI WTHelperGetProvSignerFromChain(
402  CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSigner,
403  DWORD idxCounterSigner)
404 {
405     CRYPT_PROVIDER_SGNR *sgnr;
406
407     TRACE("(%p %d %d %d)\n", pProvData, idxSigner, fCounterSigner,
408      idxCounterSigner);
409
410     if (idxSigner >= pProvData->csSigners || !pProvData->pasSigners)
411         return NULL;
412     sgnr = &pProvData->pasSigners[idxSigner];
413     if (fCounterSigner)
414     {
415         if (idxCounterSigner >= sgnr->csCounterSigners ||
416          !sgnr->pasCounterSigners)
417             return NULL;
418         sgnr = &sgnr->pasCounterSigners[idxCounterSigner];
419     }
420     TRACE("returning %p\n", sgnr);
421     return sgnr;
422 }
423
424 /***********************************************************************
425  *              WTHelperGetProvCertFromChain (WINTRUST.@)
426  */
427 CRYPT_PROVIDER_CERT * WINAPI WTHelperGetProvCertFromChain(
428  CRYPT_PROVIDER_SGNR *pSgnr, DWORD idxCert)
429 {
430     CRYPT_PROVIDER_CERT *cert;
431
432     TRACE("(%p %d)\n", pSgnr, idxCert);
433
434     if (idxCert >= pSgnr->csCertChain || !pSgnr->pasCertChain)
435         return NULL;
436     cert = &pSgnr->pasCertChain[idxCert];
437     TRACE("returning %p\n", cert);
438     return cert;
439 }
440
441 CRYPT_PROVIDER_PRIVDATA *WINAPI WTHelperGetProvPrivateDataFromChain(
442  CRYPT_PROVIDER_DATA* pProvData,
443  GUID* pgProviderID)
444 {
445     CRYPT_PROVIDER_PRIVDATA *privdata = NULL;
446     DWORD i;
447
448     TRACE("(%p, %s)\n", pProvData, debugstr_guid(pgProviderID));
449
450     for (i = 0; i < pProvData->csProvPrivData; i++)
451         if (IsEqualGUID(pgProviderID, &pProvData->pasProvPrivData[i].gProviderID))
452         {
453             privdata = &pProvData->pasProvPrivData[i];
454             break;
455         }
456
457     return privdata;
458 }
459
460 /***********************************************************************
461  *              WTHelperProvDataFromStateData (WINTRUST.@)
462  */
463 CRYPT_PROVIDER_DATA * WINAPI WTHelperProvDataFromStateData(HANDLE hStateData)
464 {
465     TRACE("%p\n", hStateData);
466     return (CRYPT_PROVIDER_DATA *)hStateData;
467 }
468
469 /***********************************************************************
470  *              WTHelperGetFileName(WINTRUST.@)
471  */
472 LPCWSTR WINAPI WTHelperGetFileName(WINTRUST_DATA *data)
473 {
474     TRACE("%p\n",data);
475     if (data->dwUnionChoice == WTD_CHOICE_FILE)
476         return data->u.pFile->pcwszFilePath;
477     else
478         return NULL;
479 }
480
481 /***********************************************************************
482  *              WTHelperGetFileHandle(WINTRUST.@)
483  */
484 HANDLE WINAPI WTHelperGetFileHandle(WINTRUST_DATA *data)
485 {
486     TRACE("%p\n",data);
487     if (data->dwUnionChoice == WTD_CHOICE_FILE)
488         return data->u.pFile->hFile;
489     else
490         return INVALID_HANDLE_VALUE;
491 }
492
493 static const WCHAR Software_Publishing[] = {
494  'S','o','f','t','w','a','r','e','\\',
495  'M','i','c','r','o','s','o','f','t','\\',
496  'W','i','n','d','o','w','s','\\',
497  'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
498  'W','i','n','t','r','u','s','t','\\',
499  'T','r','u','s','t',' ','P','r','o','v','i','d','e','r','s','\\',
500  'S','o','f','t','w','a','r','e',' ',
501  'P','u','b','l','i','s','h','i','n','g',0 };
502 static const WCHAR State[] = { 'S','t','a','t','e',0 };
503
504 /***********************************************************************
505  *              WintrustGetRegPolicyFlags (WINTRUST.@)
506  */
507 void WINAPI WintrustGetRegPolicyFlags( DWORD* pdwPolicyFlags )
508 {
509     HKEY key;
510     LONG r;
511
512     TRACE("%p\n", pdwPolicyFlags);
513
514     *pdwPolicyFlags = 0;
515     r = RegCreateKeyExW(HKEY_CURRENT_USER, Software_Publishing, 0, NULL, 0,
516      KEY_READ, NULL, &key, NULL);
517     if (!r)
518     {
519         DWORD size = sizeof(DWORD);
520
521         r = RegQueryValueExW(key, State, NULL, NULL, (LPBYTE)pdwPolicyFlags,
522          &size);
523         RegCloseKey(key);
524         if (r)
525         {
526             /* Failed to query, create and return default value */
527             *pdwPolicyFlags = WTPF_IGNOREREVOCATIONONTS |
528              WTPF_OFFLINEOKNBU_COM |
529              WTPF_OFFLINEOKNBU_IND |
530              WTPF_OFFLINEOK_COM |
531              WTPF_OFFLINEOK_IND;
532             WintrustSetRegPolicyFlags(*pdwPolicyFlags);
533         }
534     }
535 }
536
537 /***********************************************************************
538  *              WintrustSetRegPolicyFlags (WINTRUST.@)
539  */
540 BOOL WINAPI WintrustSetRegPolicyFlags( DWORD dwPolicyFlags)
541 {
542     HKEY key;
543     LONG r;
544
545     TRACE("%x\n", dwPolicyFlags);
546
547     r = RegCreateKeyExW(HKEY_CURRENT_USER, Software_Publishing, 0,
548      NULL, 0, KEY_WRITE, NULL, &key, NULL);
549     if (!r)
550     {
551         r = RegSetValueExW(key, State, 0, REG_DWORD, (LPBYTE)&dwPolicyFlags,
552          sizeof(DWORD));
553         RegCloseKey(key);
554     }
555     if (r) SetLastError(r);
556     return r == ERROR_SUCCESS;
557 }
558
559 /* Utility functions */
560 void * WINAPI WINTRUST_Alloc(DWORD cb)
561 {
562     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cb);
563 }
564
565 void * WINAPI WINTRUST_ReAlloc(void *ptr, DWORD cb)
566 {
567     return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptr, cb);
568 }
569
570 void WINAPI WINTRUST_Free(void *p)
571 {
572     HeapFree(GetProcessHeap(), 0, p);
573 }
574
575 BOOL WINAPI WINTRUST_AddStore(CRYPT_PROVIDER_DATA *data, HCERTSTORE store)
576 {
577     BOOL ret = FALSE;
578
579     if (data->chStores)
580         data->pahStores = WINTRUST_ReAlloc(data->pahStores,
581          (data->chStores + 1) * sizeof(HCERTSTORE));
582     else
583     {
584         data->pahStores = WINTRUST_Alloc(sizeof(HCERTSTORE));
585         data->chStores = 0;
586     }
587     if (data->pahStores)
588     {
589         data->pahStores[data->chStores++] = CertDuplicateStore(store);
590         ret = TRUE;
591     }
592     else
593         SetLastError(ERROR_OUTOFMEMORY);
594     return ret;
595 }
596
597 BOOL WINAPI WINTRUST_AddSgnr(CRYPT_PROVIDER_DATA *data,
598  BOOL fCounterSigner, DWORD idxSigner, CRYPT_PROVIDER_SGNR *sgnr)
599 {
600     BOOL ret = FALSE;
601
602     if (sgnr->cbStruct > sizeof(CRYPT_PROVIDER_SGNR))
603     {
604         SetLastError(ERROR_INVALID_PARAMETER);
605         return FALSE;
606     }
607     if (fCounterSigner)
608     {
609         FIXME("unimplemented for counter signers\n");
610         SetLastError(ERROR_INVALID_PARAMETER);
611         return FALSE;
612     }
613     if (data->csSigners)
614         data->pasSigners = WINTRUST_ReAlloc(data->pasSigners,
615          (data->csSigners + 1) * sizeof(CRYPT_PROVIDER_SGNR));
616     else
617     {
618         data->pasSigners = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_SGNR));
619         data->csSigners = 0;
620     }
621     if (data->pasSigners)
622     {
623         if (idxSigner < data->csSigners)
624             memmove(&data->pasSigners[idxSigner],
625              &data->pasSigners[idxSigner + 1],
626              (data->csSigners - idxSigner) * sizeof(CRYPT_PROVIDER_SGNR));
627         ret = TRUE;
628         if (sgnr->cbStruct == sizeof(CRYPT_PROVIDER_SGNR))
629         {
630             /* The PSDK says psSigner should be allocated using pfnAlloc, but
631              * it doesn't say anything about ownership.  Since callers are
632              * internal, assume ownership is passed, and just store the
633              * pointer.
634              */
635             memcpy(&data->pasSigners[idxSigner], sgnr,
636              sizeof(CRYPT_PROVIDER_SGNR));
637         }
638         else
639             memset(&data->pasSigners[idxSigner], 0,
640              sizeof(CRYPT_PROVIDER_SGNR));
641         data->csSigners++;
642     }
643     else
644         SetLastError(ERROR_OUTOFMEMORY);
645     return ret;
646 }
647
648 BOOL WINAPI WINTRUST_AddCert(CRYPT_PROVIDER_DATA *data, DWORD idxSigner,
649  BOOL fCounterSigner, DWORD idxCounterSigner, PCCERT_CONTEXT pCert2Add)
650 {
651     BOOL ret = FALSE;
652
653     if (fCounterSigner)
654     {
655         FIXME("unimplemented for counter signers\n");
656         SetLastError(ERROR_INVALID_PARAMETER);
657         return FALSE;
658     }
659     if (data->pasSigners[idxSigner].csCertChain)
660         data->pasSigners[idxSigner].pasCertChain =
661          WINTRUST_ReAlloc(data->pasSigners[idxSigner].pasCertChain,
662          (data->pasSigners[idxSigner].csCertChain + 1) *
663          sizeof(CRYPT_PROVIDER_CERT));
664     else
665     {
666         data->pasSigners[idxSigner].pasCertChain =
667          WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_CERT));
668         data->pasSigners[idxSigner].csCertChain = 0;
669     }
670     if (data->pasSigners[idxSigner].pasCertChain)
671     {
672         CRYPT_PROVIDER_CERT *cert = &data->pasSigners[idxSigner].pasCertChain[
673          data->pasSigners[idxSigner].csCertChain];
674
675         cert->cbStruct = sizeof(CRYPT_PROVIDER_CERT);
676         cert->pCert = CertDuplicateCertificateContext(pCert2Add);
677         data->pasSigners[idxSigner].csCertChain++;
678         ret = TRUE;
679     }
680     else
681         SetLastError(ERROR_OUTOFMEMORY);
682     return ret;
683 }
684
685 BOOL WINAPI WINTRUST_AddPrivData(CRYPT_PROVIDER_DATA *data,
686  CRYPT_PROVIDER_PRIVDATA *pPrivData2Add)
687 {
688     BOOL ret = FALSE;
689
690     TRACE("(%p, %p)\n", data, pPrivData2Add);
691
692     if (pPrivData2Add->cbStruct > sizeof(CRYPT_PROVIDER_PRIVDATA))
693     {
694         SetLastError(ERROR_INVALID_PARAMETER);
695         WARN("invalid struct size\n");
696         return FALSE;
697     }
698     if (data->csProvPrivData)
699         data->pasProvPrivData = WINTRUST_ReAlloc(data->pasProvPrivData,
700          (data->csProvPrivData + 1) * sizeof(CRYPT_PROVIDER_SGNR));
701     else
702     {
703         data->pasProvPrivData = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_SGNR));
704         data->csProvPrivData = 0;
705     }
706     if (data->pasProvPrivData)
707     {
708         DWORD i;
709
710         for (i = 0; i < data->csProvPrivData; i++)
711             if (IsEqualGUID(&pPrivData2Add->gProviderID, &data->pasProvPrivData[i]))
712                 break;
713
714         data->pasProvPrivData[i] = *pPrivData2Add;
715         if (i == data->csProvPrivData)
716             data->csProvPrivData++;
717     }
718     else
719         SetLastError(ERROR_OUTOFMEMORY);
720     return ret;
721 }