ReactOS 0.4.15-dev-7897-g78dc504
regstore.c
Go to the documentation of this file.
1/*
2 * Copyright 2004-2007 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18#include <assert.h>
19#include <stdarg.h>
20#include "windef.h"
21#include "winbase.h"
22#include "wincrypt.h"
23#include "winreg.h"
24#include "winuser.h"
25#include "wine/debug.h"
26#include "crypt32_private.h"
27
29
31{
33 struct list entry;
35
36typedef struct _WINE_REGSTOREINFO
37{
47
48static void CRYPT_HashToStr(const BYTE *hash, LPWSTR asciiHash)
49{
50 static const WCHAR fmt[] = { '%','0','2','X',0 };
51 DWORD i;
52
53 assert(hash);
54 assert(asciiHash);
55
56 for (i = 0; i < 20; i++)
57 wsprintfW(asciiHash + i * 2, fmt, hash[i]);
58}
59
60static const WCHAR CertsW[] = { 'C','e','r','t','i','f','i','c','a','t','e','s',
61 0 };
62static const WCHAR CRLsW[] = { 'C','R','L','s',0 };
63static const WCHAR CTLsW[] = { 'C','T','L','s',0 };
64static const WCHAR BlobW[] = { 'B','l','o','b',0 };
65
67 HCERTSTORE store)
68{
69 LONG rc;
70 DWORD index = 0;
71 WCHAR subKeyName[MAX_PATH];
72
73 do {
74 DWORD size = ARRAY_SIZE(subKeyName);
75
76 rc = RegEnumKeyExW(key, index++, subKeyName, &size, NULL, NULL, NULL,
77 NULL);
78 if (!rc)
79 {
80 HKEY subKey;
81
82 rc = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
83 if (!rc)
84 {
85 LPBYTE buf = NULL;
86
87 size = 0;
88 rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, NULL, &size);
89 if (!rc)
91 if (buf)
92 {
93 rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, buf,
94 &size);
95 if (!rc)
96 {
97 const void *context;
98 DWORD addedType;
99
100 TRACE("Adding cert with hash %s\n",
101 debugstr_w(subKeyName));
103 contextType, &addedType);
104 if (context)
105 {
106 const WINE_CONTEXT_INTERFACE *contextInterface;
107 BYTE hash[20];
108
109 switch (addedType)
110 {
112 contextInterface = pCertInterface;
113 break;
115 contextInterface = pCRLInterface;
116 break;
118 contextInterface = pCTLInterface;
119 break;
120 default:
121 contextInterface = NULL;
122 }
123 if (contextInterface)
124 {
125 size = sizeof(hash);
126 if (contextInterface->getProp(context,
128 {
129 WCHAR asciiHash[20 * 2 + 1];
130
131 CRYPT_HashToStr(hash, asciiHash);
132 TRACE("comparing %s\n",
133 debugstr_w(asciiHash));
134 TRACE("with %s\n", debugstr_w(subKeyName));
135 if (!lstrcmpW(asciiHash, subKeyName))
136 {
137 TRACE("hash matches, adding\n");
138 contextInterface->addContextToStore(
139 store, context,
141 }
142 else
143 TRACE("hash doesn't match, ignoring\n");
144 }
146 }
147 }
148 }
150 }
151 RegCloseKey(subKey);
152 }
153 /* Ignore intermediate errors, continue enumerating */
154 rc = ERROR_SUCCESS;
155 }
156 } while (!rc);
157}
158
160{
161 static const WCHAR * const subKeys[] = { CertsW, CRLsW, CTLsW };
162 static const DWORD contextFlags[] = { CERT_STORE_CERTIFICATE_CONTEXT_FLAG,
164 DWORD i;
165
166 for (i = 0; i < ARRAY_SIZE(subKeys); i++)
167 {
168 HKEY hKey;
169 LONG rc;
170
171 rc = RegCreateKeyExW(key, subKeys[i], 0, NULL, 0, KEY_READ, NULL,
172 &hKey, NULL);
173 if (!rc)
174 {
175 CRYPT_RegReadSerializedFromReg(hKey, contextFlags[i], store);
177 }
178 }
179}
180
181/* Hash is assumed to be 20 bytes in length (a SHA-1 hash) */
183 DWORD len)
184{
185 WCHAR asciiHash[20 * 2 + 1];
186 LONG rc;
187 HKEY subKey;
188 BOOL ret;
189
190 CRYPT_HashToStr(hash, asciiHash);
191 rc = RegCreateKeyExW(key, asciiHash, 0, NULL, flags, KEY_ALL_ACCESS, NULL,
192 &subKey, NULL);
193 if (!rc)
194 {
195 rc = RegSetValueExW(subKey, BlobW, 0, REG_BINARY, buf, len);
196 RegCloseKey(subKey);
197 }
198 if (!rc)
199 ret = TRUE;
200 else
201 {
202 SetLastError(rc);
203 ret = FALSE;
204 }
205 return ret;
206}
207
209 const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore)
210{
211 const void *context = NULL;
212 BOOL ret;
213
214 do {
215 context = contextInterface->enumContextsInStore(memStore, context);
216 if (context)
217 {
218 BYTE hash[20];
219 DWORD hashSize = sizeof(hash);
220
221 ret = contextInterface->getProp(context, CERT_HASH_PROP_ID, hash,
222 &hashSize);
223 if (ret)
224 {
225 DWORD size = 0;
226 LPBYTE buf = NULL;
227
228 ret = contextInterface->serialize(context, 0, NULL, &size);
229 if (size)
231 if (buf)
232 {
233 ret = contextInterface->serialize(context, 0, buf, &size);
234 if (ret)
236 }
238 }
239 }
240 else
241 ret = TRUE;
242 } while (ret && context != NULL);
243 if (context)
245 return ret;
246}
247
249{
250 static const WCHAR * const subKeys[] = { CertsW, CRLsW, CTLsW };
251 const WINE_CONTEXT_INTERFACE * const interfaces[] = { pCertInterface,
253 struct list *listToDelete[] = { &store->certsToDelete, &store->crlsToDelete,
254 &store->ctlsToDelete };
255 BOOL ret = TRUE;
256 DWORD i;
257
258 for (i = 0; ret && i < ARRAY_SIZE(subKeys); i++)
259 {
260 HKEY key;
261 LONG rc = RegCreateKeyExW(store->key, subKeys[i], 0, NULL, 0,
263
264 if (!rc)
265 {
266 if (listToDelete[i])
267 {
268 WINE_HASH_TO_DELETE *toDelete, *next;
269 WCHAR asciiHash[20 * 2 + 1];
270
271 EnterCriticalSection(&store->cs);
272 LIST_FOR_EACH_ENTRY_SAFE(toDelete, next, listToDelete[i],
274 {
275 LONG rc;
276
277 CRYPT_HashToStr(toDelete->hash, asciiHash);
278 TRACE("Removing %s\n", debugstr_w(asciiHash));
279 rc = RegDeleteKeyW(key, asciiHash);
280 if (rc != ERROR_SUCCESS && rc != ERROR_FILE_NOT_FOUND)
281 {
282 SetLastError(rc);
283 ret = FALSE;
284 }
285 list_remove(&toDelete->entry);
286 CryptMemFree(toDelete);
287 }
288 LeaveCriticalSection(&store->cs);
289 }
290 ret = CRYPT_SerializeContextsToReg(key, 0, interfaces[i], store->memStore);
292 }
293 else
294 {
295 SetLastError(rc);
296 ret = FALSE;
297 }
298 }
299 return ret;
300}
301
302/* If force is true or the registry store is dirty, writes the contents of the
303 * store to the registry.
304 */
306{
307 BOOL ret;
308
309 TRACE("(%p, %d)\n", store, force);
310
311 if (store->dirty || force)
312 {
313 ret = CRYPT_RegWriteToReg(store);
314 if (ret)
315 store->dirty = FALSE;
316 }
317 else
318 ret = TRUE;
319 return ret;
320}
321
323{
324 WINE_REGSTOREINFO *store = hCertStore;
325
326 TRACE("(%p, %08x)\n", store, dwFlags);
327 if (dwFlags)
328 FIXME("Unimplemented flags: %08x\n", dwFlags);
329
331 RegCloseKey(store->key);
332 store->cs.DebugInfo->Spare[0] = 0;
333 DeleteCriticalSection(&store->cs);
334 CryptMemFree(store);
335}
336
338 const void *context, DWORD dwFlags)
339{
340 BOOL ret;
341
343 {
344 store->dirty = TRUE;
345 ret = TRUE;
346 }
347 else
348 ret = FALSE;
349 return ret;
350}
351
353 struct list *deleteList, const void *context,
354 const WINE_CONTEXT_INTERFACE *contextInterface)
355{
356 BOOL ret;
357
359 {
361 ret = FALSE;
362 }
363 else
364 {
366
367 if (toDelete)
368 {
369 DWORD size = sizeof(toDelete->hash);
370
371 ret = contextInterface->getProp(context, CERT_HASH_PROP_ID,
372 toDelete->hash, &size);
373 if (ret)
374 {
375 EnterCriticalSection(&store->cs);
376 list_add_tail(deleteList, &toDelete->entry);
377 LeaveCriticalSection(&store->cs);
378 }
379 else
380 {
381 CryptMemFree(toDelete);
382 ret = FALSE;
383 }
384 }
385 else
386 ret = FALSE;
387 if (ret)
388 store->dirty = TRUE;
389 }
390 return ret;
391}
392
395{
396 WINE_REGSTOREINFO *store = hCertStore;
397
398 TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
399
400 return CRYPT_RegWriteContext(store, cert, dwFlags);
401}
402
405{
406 WINE_REGSTOREINFO *store = hCertStore;
407
408 TRACE("(%p, %p, %08x)\n", store, pCertContext, dwFlags);
409
412}
413
416{
417 WINE_REGSTOREINFO *store = hCertStore;
418
419 TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
420
421 return CRYPT_RegWriteContext(store, crl, dwFlags);
422}
423
426{
427 WINE_REGSTOREINFO *store = hCertStore;
428
429 TRACE("(%p, %p, %08x)\n", store, pCrlContext, dwFlags);
430
431 return CRYPT_RegDeleteContext(store, &store->crlsToDelete, pCrlContext,
433}
434
437{
438 WINE_REGSTOREINFO *store = hCertStore;
439
440 TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
441
442 return CRYPT_RegWriteContext(store, ctl, dwFlags);
443}
444
447{
448 WINE_REGSTOREINFO *store = hCertStore;
449
450 TRACE("(%p, %p, %08x)\n", store, pCtlContext, dwFlags);
451
452 return CRYPT_RegDeleteContext(store, &store->ctlsToDelete, pCtlContext,
454}
455
457 DWORD dwCtrlType, void const *pvCtrlPara)
458{
459 WINE_REGSTOREINFO *store = hCertStore;
460 BOOL ret = TRUE;
461
462 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
463 pvCtrlPara);
464
465 switch (dwCtrlType)
466 {
468 {
471
473 CRYPT_RegReadFromReg(store->key, memStore);
474 I_CertUpdateStore(store->memStore, memStore, 0, 0);
475 CertCloseStore(memStore, 0);
476 break;
477 }
479 ret = CRYPT_RegFlushStore(store,
481 break;
483 FIXME("CERT_STORE_CTRL_AUTO_RESYNC: stub\n");
484 break;
486 FIXME("CERT_STORE_CTRL_NOTIFY_CHANGE: stub\n");
487 break;
488 default:
489 FIXME("%u: stub\n", dwCtrlType);
490 ret = FALSE;
491 }
492 return ret;
493}
494
495static void *regProvFuncs[] = {
497 NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
500 NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
501 NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
504 NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
505 NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
508 NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
510};
511
513 const void *pvPara)
514{
515 WINECRYPT_CERTSTORE *store = NULL;
516
517 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
518
520 {
522
523 if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
525 if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
527 if (rc == ERROR_NO_MORE_ITEMS)
528 rc = ERROR_SUCCESS;
529 SetLastError(rc);
530 }
531 else
532 {
533 HKEY key;
534
538 TRUE, 0))
539 {
540 WINECRYPT_CERTSTORE *memStore;
541
542 memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, hCryptProv,
544 if (memStore)
545 {
547 sizeof(WINE_REGSTOREINFO));
548
549 if (regInfo)
550 {
551 CERT_STORE_PROV_INFO provInfo = { 0 };
552
553 regInfo->dwOpenFlags = dwFlags;
554 regInfo->memStore = memStore;
555 regInfo->key = key;
556 InitializeCriticalSection(&regInfo->cs);
557 regInfo->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_REGSTOREINFO->cs");
558 list_init(&regInfo->certsToDelete);
559 list_init(&regInfo->crlsToDelete);
560 list_init(&regInfo->ctlsToDelete);
561 CRYPT_RegReadFromReg(regInfo->key, regInfo->memStore);
562 regInfo->dirty = FALSE;
563 provInfo.cbSize = sizeof(provInfo);
566 provInfo.hStoreProv = regInfo;
567 store = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
568 /* Reg store doesn't need crypto provider, so close it */
569 if (hCryptProv &&
571 CryptReleaseContext(hCryptProv, 0);
572 }
573 }
574 }
575 }
576 TRACE("returning %p\n", store);
577 return store;
578}
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define ARRAY_SIZE(A)
Definition: main.h:33
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
static void list_init(struct list_entry *head)
Definition: list.h:51
#define FIXME(fmt,...)
Definition: debug.h:111
#define RegCloseKey(hKey)
Definition: registry.h:49
Definition: list.h:37
LSTATUS WINAPI RegDeleteTreeW(_In_ HKEY, _In_opt_ LPCWSTR)
const void * CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType) DECLSPEC_HIDDEN
Definition: serialize.c:295
static context_t * context_from_ptr(const void *ptr)
WINECRYPT_CERTSTORE * CRYPT_ProvCreateStore(DWORD dwFlags, WINECRYPT_CERTSTORE *memStore, const CERT_STORE_PROV_INFO *pProvInfo) DECLSPEC_HIDDEN
Definition: provstore.c:307
BOOL WINAPI I_CertUpdateStore(HCERTSTORE store1, HCERTSTORE store2, DWORD unk0, DWORD unk1) DECLSPEC_HIDDEN
Definition: store.c:109
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1239
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
void Context_Release(context_t *context)
Definition: context.c:106
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:815
const WINE_CONTEXT_INTERFACE * pCTLInterface
Definition: store.c:80
const WINE_CONTEXT_INTERFACE * pCertInterface
Definition: store.c:54
const WINE_CONTEXT_INTERFACE * pCRLInterface
Definition: store.c:67
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:1127
#define SetLastError(x)
Definition: compat.h:752
#define GetCurrentProcess()
Definition: compat.h:759
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define MAX_PATH
Definition: compat.h:34
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
#define assert(x)
Definition: debug.h:53
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
GLsizeiptr size
Definition: glext.h:5919
GLuint index
Definition: glext.h:6031
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
uint32_t entry
Definition: isohybrid.c:63
#define debugstr_w
Definition: kernel32.h:32
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static const BYTE crl[]
Definition: message.c:864
static BYTE cert[]
Definition: msg.c:1437
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_READ
Definition: nt_native.h:1023
long LONG
Definition: pedump.c:60
static unsigned __int64 next
Definition: rand_nt.c:6
static BOOL WINAPI CRYPT_RegDeleteCTL(HCERTSTORE hCertStore, PCCTL_CONTEXT pCtlContext, DWORD dwFlags)
Definition: regstore.c:445
static void CRYPT_RegReadSerializedFromReg(HKEY key, DWORD contextType, HCERTSTORE store)
Definition: regstore.c:66
struct _WINE_HASH_TO_DELETE WINE_HASH_TO_DELETE
static BOOL WINAPI CRYPT_RegWriteCert(HCERTSTORE hCertStore, PCCERT_CONTEXT cert, DWORD dwFlags)
Definition: regstore.c:393
static BOOL CRYPT_RegFlushStore(WINE_REGSTOREINFO *store, BOOL force)
Definition: regstore.c:305
static BOOL WINAPI CRYPT_RegWriteCRL(HCERTSTORE hCertStore, PCCRL_CONTEXT crl, DWORD dwFlags)
Definition: regstore.c:414
WINECRYPT_CERTSTORE * CRYPT_RegOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: regstore.c:512
static void * regProvFuncs[]
Definition: regstore.c:495
static const WCHAR CertsW[]
Definition: regstore.c:60
static BOOL WINAPI CRYPT_RegWriteCTL(HCERTSTORE hCertStore, PCCTL_CONTEXT ctl, DWORD dwFlags)
Definition: regstore.c:435
static void CRYPT_RegReadFromReg(HKEY key, HCERTSTORE store)
Definition: regstore.c:159
struct _WINE_REGSTOREINFO WINE_REGSTOREINFO
static const WCHAR CTLsW[]
Definition: regstore.c:63
static BOOL CRYPT_RegDeleteContext(WINE_REGSTOREINFO *store, struct list *deleteList, const void *context, const WINE_CONTEXT_INTERFACE *contextInterface)
Definition: regstore.c:352
static const WCHAR CRLsW[]
Definition: regstore.c:62
static BOOL WINAPI CRYPT_RegDeleteCRL(HCERTSTORE hCertStore, PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
Definition: regstore.c:424
static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara)
Definition: regstore.c:456
BOOL CRYPT_SerializeContextsToReg(HKEY key, DWORD flags, const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore)
Definition: regstore.c:208
static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: regstore.c:322
static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore, PCCERT_CONTEXT pCertContext, DWORD dwFlags)
Definition: regstore.c:403
static const WCHAR BlobW[]
Definition: regstore.c:64
static BOOL CRYPT_WriteSerializedToReg(HKEY key, DWORD flags, const BYTE *hash, const BYTE *buf, DWORD len)
Definition: regstore.c:182
static void CRYPT_HashToStr(const BYTE *hash, LPWSTR asciiHash)
Definition: regstore.c:48
static BOOL CRYPT_RegWriteContext(WINE_REGSTOREINFO *store, const void *context, DWORD dwFlags)
Definition: regstore.c:337
static BOOL CRYPT_RegWriteToReg(WINE_REGSTOREINFO *store)
Definition: regstore.c:248
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
#define TRACE(s)
Definition: solgame.cpp:4
void ** rgpvStoreProvFunc
Definition: wincrypt.h:1149
HCERTSTOREPROV hStoreProv
Definition: wincrypt.h:1150
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:887
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:894
GetContextPropertyFunc getProp
SerializeElementFunc serialize
AddContextToStoreFunc addContextToStore
EnumContextsInStoreFunc enumContextsInStore
struct list entry
Definition: regstore.c:33
struct list crlsToDelete
Definition: regstore.c:44
struct list certsToDelete
Definition: regstore.c:43
HCERTSTORE memStore
Definition: regstore.c:39
struct list ctlsToDelete
Definition: regstore.c:45
CRITICAL_SECTION cs
Definition: regstore.c:42
Definition: http.c:7252
Definition: dsound.c:943
Definition: _hash_fun.h:40
Definition: copy.c:22
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DWORD_PTR
Definition: treelist.c:76
unsigned char * LPBYTE
Definition: typedefs.h:53
int ret
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
_In_ PCCRL_CONTEXT pCrlContext
Definition: wincrypt.h:4992
#define CERT_STORE_CTRL_COMMIT_FORCE_FLAG
Definition: wincrypt.h:2826
#define CERT_STORE_ADD_REPLACE_EXISTING
Definition: wincrypt.h:2484
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
#define CERT_STORE_CREATE_NEW_FLAG
Definition: wincrypt.h:2464
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
#define CERT_STORE_CTL_CONTEXT_FLAG
Definition: wincrypt.h:2981
#define CERT_STORE_CTRL_RESYNC
Definition: wincrypt.h:2820
_In_ PCCTL_CONTEXT pCtlContext
Definition: wincrypt.h:5001
#define CERT_STORE_CRL_CONTEXT_FLAG
Definition: wincrypt.h:2980
#define CERT_STORE_PROV_MEMORY
Definition: wincrypt.h:2251
#define CERT_STORE_CTRL_NOTIFY_CHANGE
Definition: wincrypt.h:2821
_In_ void * pvPara
Definition: wincrypt.h:6077
#define CERT_STORE_CERTIFICATE_CONTEXT
Definition: wincrypt.h:2974
#define CERT_STORE_CTRL_AUTO_RESYNC
Definition: wincrypt.h:2823
#define CERT_STORE_CTL_CONTEXT
Definition: wincrypt.h:2976
_In_ PCCERT_CONTEXT pCertContext
Definition: wincrypt.h:4836
#define CERT_HASH_PROP_ID
Definition: wincrypt.h:2688
#define CERT_STORE_PROV_WRITE_ADD_FLAG
Definition: wincrypt.h:2971
#define CERT_STORE_CTRL_COMMIT
Definition: wincrypt.h:2822
#define CERT_STORE_NO_CRYPT_RELEASE_FLAG
Definition: wincrypt.h:2452
#define CERT_STORE_CERTIFICATE_CONTEXT_FLAG
Definition: wincrypt.h:2978
#define CERT_STORE_DELETE_FLAG
Definition: wincrypt.h:2455
#define CERT_STORE_CRL_CONTEXT
Definition: wincrypt.h:2975
#define CERT_STORE_READONLY_FLAG
Definition: wincrypt.h:2466
#define WINAPI
Definition: msvc.h:6
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
unsigned char BYTE
Definition: xxhash.c:193