ReactOS  0.4.14-dev-323-g6fe6a88
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 
30 typedef struct _WINE_HASH_TO_DELETE
31 {
32  BYTE hash[20];
33  struct list entry;
35 
36 typedef struct _WINE_REGSTOREINFO
37 {
47 
48 static 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 
60 static const WCHAR CertsW[] = { 'C','e','r','t','i','f','i','c','a','t','e','s',
61  0 };
62 static const WCHAR CRLsW[] = { 'C','R','L','s',0 };
63 static const WCHAR CTLsW[] = { 'C','T','L','s',0 };
64 static const WCHAR BlobW[] = { 'B','l','o','b',0 };
65 
66 static void CRYPT_RegReadSerializedFromReg(HKEY key, DWORD contextType,
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  }
149  CryptMemFree(buf);
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);
176  RegCloseKey(hKey);
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  }
237  CryptMemFree(buf);
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);
291  RegCloseKey(key);
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 
330  CRYPT_RegFlushStore(store, FALSE);
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 
410  return CRYPT_RegDeleteContext(store, &store->certsToDelete, pCertContext,
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,
432  pCRLInterface);
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,
453  pCTLInterface);
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 
472  CRYPT_RegFlushStore(store, FALSE);
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 
495 static 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  {
546  WINE_REGSTOREINFO *regInfo = CryptMemAlloc(
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);
565  provInfo.rgpvStoreProvFunc = regProvFuncs;
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 }
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
#define CERT_STORE_DELETE_FLAG
Definition: wincrypt.h:2455
static BOOL WINAPI CRYPT_RegDeleteCRL(HCERTSTORE hCertStore, PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
Definition: regstore.c:424
const WINE_CONTEXT_INTERFACE * pCRLInterface
Definition: store.c:67
static context_t * context_from_ptr(const void *ptr)
#define TRUE
Definition: types.h:120
static void CRYPT_HashToStr(const BYTE *hash, LPWSTR asciiHash)
Definition: regstore.c:48
static const BYTE crl[]
Definition: message.c:864
#define CERT_STORE_CTRL_RESYNC
Definition: wincrypt.h:2820
WINE_DEFAULT_DEBUG_CHANNEL(crypt)
#define ERROR_SUCCESS
Definition: deptool.c:10
WINECRYPT_CERTSTORE * CRYPT_RegOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: regstore.c:512
#define DWORD_PTR
Definition: treelist.c:76
static void CRYPT_RegReadFromReg(HKEY key, HCERTSTORE store)
Definition: regstore.c:159
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:95
Definition: http.c:6587
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_READ
Definition: nt_native.h:1023
const WINE_CONTEXT_INTERFACE * pCTLInterface
Definition: store.c:80
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
#define CERT_STORE_CTRL_AUTO_RESYNC
Definition: wincrypt.h:2823
#define CERT_STORE_CERTIFICATE_CONTEXT_FLAG
Definition: wincrypt.h:2978
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1237
static const WCHAR BlobW[]
Definition: regstore.c:64
struct list crlsToDelete
Definition: regstore.c:44
HCERTSTOREPROV hStoreProv
Definition: wincrypt.h:1150
#define assert(x)
Definition: debug.h:53
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
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define CERT_STORE_CTRL_COMMIT
Definition: wincrypt.h:2822
struct list ctlsToDelete
Definition: regstore.c:45
static BOOL CRYPT_RegWriteToReg(WINE_REGSTOREINFO *store)
Definition: regstore.c:248
void Context_Release(context_t *context)
Definition: context.c:106
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:1091
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
Definition: list.h:102
#define CERT_STORE_CTRL_COMMIT_FORCE_FLAG
Definition: wincrypt.h:2826
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
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
#define CERT_STORE_CTL_CONTEXT_FLAG
Definition: wincrypt.h:2981
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
#define CERT_STORE_CREATE_NEW_FLAG
Definition: wincrypt.h:2464
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
int hash
Definition: main.c:58
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
static void * regProvFuncs[]
Definition: regstore.c:495
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
WINECRYPT_CERTSTORE * CRYPT_ProvCreateStore(DWORD dwFlags, WINECRYPT_CERTSTORE *memStore, const CERT_STORE_PROV_INFO *pProvInfo) DECLSPEC_HIDDEN
Definition: provstore.c:307
void ** rgpvStoreProvFunc
Definition: wincrypt.h:1149
#define CERT_STORE_PROV_MEMORY
Definition: wincrypt.h:2251
BOOL CRYPT_SerializeContextsToReg(HKEY key, DWORD flags, const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore)
Definition: regstore.c:208
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:1127
#define CERT_STORE_ADD_REPLACE_EXISTING
Definition: wincrypt.h:2484
static BYTE cert[]
Definition: msg.c:1437
GLuint index
Definition: glext.h:6031
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara)
Definition: regstore.c:456
SerializeElementFunc serialize
const void * CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType) DECLSPEC_HIDDEN
Definition: serialize.c:295
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:4895
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
#define CERT_STORE_CERTIFICATE_CONTEXT
Definition: wincrypt.h:2974
#define TRACE(s)
Definition: solgame.cpp:4
static BOOL CRYPT_WriteSerializedToReg(HKEY key, DWORD flags, const BYTE *hash, const BYTE *buf, DWORD len)
Definition: regstore.c:182
GLsizeiptr size
Definition: glext.h:5919
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
struct list entry
Definition: regstore.c:33
HANDLE WINAPI GetCurrentProcess(VOID)
Definition: proc.c:1138
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
#define CERT_STORE_PROV_WRITE_ADD_FLAG
Definition: wincrypt.h:2971
static BOOL CRYPT_RegWriteContext(WINE_REGSTOREINFO *store, const void *context, DWORD dwFlags)
Definition: regstore.c:337
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
static BOOL WINAPI CRYPT_RegWriteCTL(HCERTSTORE hCertStore, PCCTL_CONTEXT ctl, DWORD dwFlags)
Definition: regstore.c:435
#define CERT_HASH_PROP_ID
Definition: wincrypt.h:2688
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:866
GLbitfield flags
Definition: glext.h:7161
#define CERT_STORE_READONLY_FLAG
Definition: wincrypt.h:2466
int ret
struct list certsToDelete
Definition: regstore.c:43
struct _WINE_HASH_TO_DELETE WINE_HASH_TO_DELETE
GetContextPropertyFunc getProp
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
HKEY key
Definition: reg.c:42
static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: regstore.c:322
uint32_t entry
Definition: isohybrid.c:63
static const WCHAR CertsW[]
Definition: regstore.c:60
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
Definition: _list.h:228
_In_ PCCTL_CONTEXT pCtlContext
Definition: wincrypt.h:5005
static BOOL CRYPT_RegFlushStore(WINE_REGSTOREINFO *store, BOOL force)
Definition: regstore.c:305
LSTATUS WINAPI RegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey)
Definition: reg.c:1746
AddContextToStoreFunc addContextToStore
static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore, PCCERT_CONTEXT pCertContext, DWORD dwFlags)
Definition: regstore.c:403
static unsigned __int64 next
Definition: rand_nt.c:6
#define CERT_STORE_CRL_CONTEXT_FLAG
Definition: wincrypt.h:2980
#define CERT_STORE_CTL_CONTEXT
Definition: wincrypt.h:2976
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
static BOOL WINAPI CRYPT_RegWriteCRL(HCERTSTORE hCertStore, PCCRL_CONTEXT crl, DWORD dwFlags)
Definition: regstore.c:414
#define CERT_STORE_CTRL_NOTIFY_CHANGE
Definition: wincrypt.h:2821
CRITICAL_SECTION cs
Definition: regstore.c:42
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
EnumContextsInStoreFunc enumContextsInStore
#define ARRAY_SIZE(a)
Definition: main.h:24
static void CRYPT_RegReadSerializedFromReg(HKEY key, DWORD contextType, HCERTSTORE store)
Definition: regstore.c:66
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
BOOL WINAPI I_CertUpdateStore(HCERTSTORE store1, HCERTSTORE store2, DWORD unk0, DWORD unk1) DECLSPEC_HIDDEN
Definition: store.c:109
#define CERT_STORE_CRL_CONTEXT
Definition: wincrypt.h:2975
static BOOL WINAPI CRYPT_RegDeleteCTL(HCERTSTORE hCertStore, PCCTL_CONTEXT pCtlContext, DWORD dwFlags)
Definition: regstore.c:445
HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:815
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, ULONG_PTR dwFlags)
Definition: crypt.c:651
static const WCHAR CTLsW[]
Definition: regstore.c:63
static BOOL WINAPI CRYPT_RegWriteCert(HCERTSTORE hCertStore, PCCERT_CONTEXT cert, DWORD dwFlags)
Definition: regstore.c:393
_In_ PCCRL_CONTEXT pCrlContext
Definition: wincrypt.h:4996
#define CERT_STORE_NO_CRYPT_RELEASE_FLAG
Definition: wincrypt.h:2452
HCERTSTORE memStore
Definition: regstore.c:39
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
_In_ void * pvPara
Definition: wincrypt.h:6081
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:2527
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WINE_CONTEXT_INTERFACE * pCertInterface
Definition: store.c:54
struct _WINE_REGSTOREINFO WINE_REGSTOREINFO
Definition: _hash_fun.h:40
Definition: dsound.c:943
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
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:859
Definition: path.c:42
_In_ PCCERT_CONTEXT pCertContext
Definition: wincrypt.h:4840