#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wincrypt.h"
#include "winreg.h"
#include "winuser.h"
#include "wine/debug.h"
#include "crypt32_private.h"

Include dependency graph for regstore.c:

Classes
struct	_WINE_HASH_TO_DELETE

struct	_WINE_REGSTOREINFO

Typedefs
typedef struct _WINE_HASH_TO_DELETE	WINE_HASH_TO_DELETE

typedef struct _WINE_REGSTOREINFO	WINE_REGSTOREINFO

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (crypt)

static void	CRYPT_HashToStr (const BYTE *hash, LPWSTR asciiHash)

static void	CRYPT_RegReadSerializedFromReg (HKEY key, DWORD contextType, HCERTSTORE store)

static void	CRYPT_RegReadFromReg (HKEY key, HCERTSTORE store)

static BOOL	CRYPT_WriteSerializedToReg (HKEY key, DWORD flags, const BYTE hash, const BYTE buf, DWORD len)

BOOL	CRYPT_SerializeContextsToReg (HKEY key, DWORD flags, const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore)

static BOOL	CRYPT_RegWriteToReg (WINE_REGSTOREINFO *store)

static BOOL	CRYPT_RegFlushStore (WINE_REGSTOREINFO *store, BOOL force)

static void WINAPI	CRYPT_RegCloseStore (HCERTSTORE hCertStore, DWORD dwFlags)

static BOOL	CRYPT_RegWriteContext (WINE_REGSTOREINFO store, const void context, DWORD dwFlags)

static BOOL	CRYPT_RegDeleteContext (WINE_REGSTOREINFO store, struct list deleteList, const void context, const WINE_CONTEXT_INTERFACE contextInterface)

static BOOL WINAPI	CRYPT_RegWriteCert (HCERTSTORE hCertStore, PCCERT_CONTEXT cert, DWORD dwFlags)

static BOOL WINAPI	CRYPT_RegDeleteCert (HCERTSTORE hCertStore, PCCERT_CONTEXT pCertContext, DWORD dwFlags)

static BOOL WINAPI	CRYPT_RegWriteCRL (HCERTSTORE hCertStore, PCCRL_CONTEXT crl, DWORD dwFlags)

static BOOL WINAPI	CRYPT_RegDeleteCRL (HCERTSTORE hCertStore, PCCRL_CONTEXT pCrlContext, DWORD dwFlags)

static BOOL WINAPI	CRYPT_RegWriteCTL (HCERTSTORE hCertStore, PCCTL_CONTEXT ctl, DWORD dwFlags)

static BOOL WINAPI	CRYPT_RegDeleteCTL (HCERTSTORE hCertStore, PCCTL_CONTEXT pCtlContext, DWORD dwFlags)

static BOOL WINAPI	CRYPT_RegControl (HCERTSTORE hCertStore, DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara)

WINECRYPT_CERTSTORE *	CRYPT_RegOpenStore (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)

Variables
static const WCHAR	CertsW []

static const WCHAR	CRLsW [] = { 'C','R','L','s',0 }

static const WCHAR	CTLsW [] = { 'C','T','L','s',0 }

static const WCHAR	BlobW [] = { 'B','l','o','b',0 }

static void *	regProvFuncs []

Typedef Documentation

◆ WINE_HASH_TO_DELETE

typedef struct _WINE_HASH_TO_DELETE WINE_HASH_TO_DELETE

◆ WINE_REGSTOREINFO

typedef struct _WINE_REGSTOREINFO WINE_REGSTOREINFO

Function Documentation

◆ CRYPT_HashToStr()

static void CRYPT_HashToStr	(	const BYTE *	hash,
		LPWSTR	asciiHash
	)

static

Definition at line 48 of file regstore.c.

{
    static const WCHAR fmt[] = { '%','0','2','X',0 };
    DWORD i;
 
    assert(hash);
    assert(asciiHash);
 
    for (i = 0; i < 20; i++)
        wsprintfW(asciiHash + i * 2, fmt, hash[i]);
}

Referenced by CRYPT_RegReadSerializedFromReg(), CRYPT_RegWriteToReg(), and CRYPT_WriteSerializedToReg().

◆ CRYPT_RegCloseStore()

static void WINAPI CRYPT_RegCloseStore	(	HCERTSTORE	hCertStore,
		DWORD	dwFlags
	)

static

Definition at line 322 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %08x)\n", store, dwFlags);
    if (dwFlags)
        FIXME("Unimplemented flags: %08x\n", dwFlags);
 
    CRYPT_RegFlushStore(store, FALSE);
    RegCloseKey(store->key);
    store->cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&store->cs);
    CryptMemFree(store);
}

◆ CRYPT_RegControl()

static BOOL WINAPI CRYPT_RegControl	(	HCERTSTORE	hCertStore,
		DWORD	dwFlags,
		DWORD	dwCtrlType,
		void const *	pvCtrlPara
	)

static

Definition at line 456 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
    BOOL ret = TRUE;
 
    TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
     pvCtrlPara);
 
    switch (dwCtrlType)
    {
    case CERT_STORE_CTRL_RESYNC:
    {
        HCERTSTORE memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
         CERT_STORE_CREATE_NEW_FLAG, NULL);
 
        CRYPT_RegFlushStore(store, FALSE);
        CRYPT_RegReadFromReg(store->key, memStore);
        I_CertUpdateStore(store->memStore, memStore, 0, 0);
        CertCloseStore(memStore, 0);
        break;
    }
    case CERT_STORE_CTRL_COMMIT:
        ret = CRYPT_RegFlushStore(store,
         dwFlags & CERT_STORE_CTRL_COMMIT_FORCE_FLAG);
        break;
    case CERT_STORE_CTRL_AUTO_RESYNC:
        FIXME("CERT_STORE_CTRL_AUTO_RESYNC: stub\n");
        break;
    case CERT_STORE_CTRL_NOTIFY_CHANGE:
        FIXME("CERT_STORE_CTRL_NOTIFY_CHANGE: stub\n");
        break;
    default:
        FIXME("%u: stub\n", dwCtrlType);
        ret = FALSE;
    }
    return ret;
}

◆ CRYPT_RegDeleteCert()

static BOOL WINAPI CRYPT_RegDeleteCert	(	HCERTSTORE	hCertStore,
		PCCERT_CONTEXT	pCertContext,
		DWORD	dwFlags
	)

static

Definition at line 403 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %p, %08x)\n", store, pCertContext, dwFlags);
 
    return CRYPT_RegDeleteContext(store, &store->certsToDelete, pCertContext,
     pCertInterface);
}

◆ CRYPT_RegDeleteContext()

static BOOL CRYPT_RegDeleteContext	(	WINE_REGSTOREINFO *	store,
		struct list *	deleteList,
		const void *	context,
		const WINE_CONTEXT_INTERFACE *	contextInterface
	)

static

Definition at line 352 of file regstore.c.

{
    BOOL ret;
 
    if (store->dwOpenFlags & CERT_STORE_READONLY_FLAG)
    {
        SetLastError(ERROR_ACCESS_DENIED);
        ret = FALSE;
    }
    else
    {
        WINE_HASH_TO_DELETE *toDelete = CryptMemAlloc(sizeof(WINE_HASH_TO_DELETE));
 
        if (toDelete)
        {
            DWORD size = sizeof(toDelete->hash);
 
            ret = contextInterface->getProp(context, CERT_HASH_PROP_ID,
             toDelete->hash, &size);
            if (ret)
            {
                EnterCriticalSection(&store->cs);
                list_add_tail(deleteList, &toDelete->entry);
                LeaveCriticalSection(&store->cs);
            }
            else
            {
                CryptMemFree(toDelete);
                ret = FALSE;
            }
        }
        else
            ret = FALSE;
        if (ret)
            store->dirty = TRUE;
    }
    return ret;
}

Referenced by CRYPT_RegDeleteCert(), CRYPT_RegDeleteCRL(), and CRYPT_RegDeleteCTL().

◆ CRYPT_RegDeleteCRL()

static BOOL WINAPI CRYPT_RegDeleteCRL	(	HCERTSTORE	hCertStore,
		PCCRL_CONTEXT	pCrlContext,
		DWORD	dwFlags
	)

static

Definition at line 424 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %p, %08x)\n", store, pCrlContext, dwFlags);
 
    return CRYPT_RegDeleteContext(store, &store->crlsToDelete, pCrlContext,
     pCRLInterface);
}

◆ CRYPT_RegDeleteCTL()

static BOOL WINAPI CRYPT_RegDeleteCTL	(	HCERTSTORE	hCertStore,
		PCCTL_CONTEXT	pCtlContext,
		DWORD	dwFlags
	)

static

Definition at line 445 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %p, %08x)\n", store, pCtlContext, dwFlags);
 
    return CRYPT_RegDeleteContext(store, &store->ctlsToDelete, pCtlContext,
     pCTLInterface);
}

◆ CRYPT_RegFlushStore()

static BOOL CRYPT_RegFlushStore	(	WINE_REGSTOREINFO *	store,
		BOOL	force
	)

static

Definition at line 305 of file regstore.c.

{
    BOOL ret;
 
    TRACE("(%p, %d)\n", store, force);
 
    if (store->dirty || force)
    {
        ret = CRYPT_RegWriteToReg(store);
        if (ret)
            store->dirty = FALSE;
    }
    else
        ret = TRUE;
    return ret;
}

Referenced by CRYPT_RegCloseStore(), and CRYPT_RegControl().

◆ CRYPT_RegOpenStore()

WINECRYPT_CERTSTORE * CRYPT_RegOpenStore	(	HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 512 of file regstore.c.

{
    WINECRYPT_CERTSTORE *store = NULL;
 
    TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
 
    if (dwFlags & CERT_STORE_DELETE_FLAG)
    {
        DWORD rc = RegDeleteTreeW((HKEY)pvPara, CertsW);
 
        if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
            rc = RegDeleteTreeW((HKEY)pvPara, CRLsW);
        if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
            rc = RegDeleteTreeW((HKEY)pvPara, CTLsW);
        if (rc == ERROR_NO_MORE_ITEMS)
            rc = ERROR_SUCCESS;
        SetLastError(rc);
    }
    else
    {
        HKEY key;
 
        if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
         GetCurrentProcess(), (LPHANDLE)&key,
         dwFlags & CERT_STORE_READONLY_FLAG ? KEY_READ : KEY_ALL_ACCESS,
         TRUE, 0))
        {
            WINECRYPT_CERTSTORE *memStore;
 
            memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, hCryptProv,
             CERT_STORE_CREATE_NEW_FLAG, NULL);
            if (memStore)
            {
                WINE_REGSTOREINFO *regInfo = CryptMemAlloc(
                 sizeof(WINE_REGSTOREINFO));
 
                if (regInfo)
                {
                    CERT_STORE_PROV_INFO provInfo = { 0 };
 
                    regInfo->dwOpenFlags = dwFlags;
                    regInfo->memStore = memStore;
                    regInfo->key = key;
                    InitializeCriticalSection(&regInfo->cs);
                    regInfo->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_REGSTOREINFO->cs");
                    list_init(&regInfo->certsToDelete);
                    list_init(&regInfo->crlsToDelete);
                    list_init(&regInfo->ctlsToDelete);
                    CRYPT_RegReadFromReg(regInfo->key, regInfo->memStore);
                    regInfo->dirty = FALSE;
                    provInfo.cbSize = sizeof(provInfo);
                    provInfo.cStoreProvFunc = ARRAY_SIZE(regProvFuncs);
                    provInfo.rgpvStoreProvFunc = regProvFuncs;
                    provInfo.hStoreProv = regInfo;
                    store = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
                    /* Reg store doesn't need crypto provider, so close it */
                    if (hCryptProv &&
                     !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
                        CryptReleaseContext(hCryptProv, 0);
                }
            }
        }
    }
    TRACE("returning %p\n", store);
    return store;
}

Referenced by CertOpenStore(), and CRYPT_SysRegOpenStoreW().

◆ CRYPT_RegReadFromReg()

static void CRYPT_RegReadFromReg	(	HKEY	key,
		HCERTSTORE	store
	)

static

Definition at line 159 of file regstore.c.

{
    static const WCHAR * const subKeys[] = { CertsW, CRLsW, CTLsW };
    static const DWORD contextFlags[] = { CERT_STORE_CERTIFICATE_CONTEXT_FLAG,
     CERT_STORE_CRL_CONTEXT_FLAG, CERT_STORE_CTL_CONTEXT_FLAG };
    DWORD i;
 
    for (i = 0; i < ARRAY_SIZE(subKeys); i++)
    {
        HKEY hKey;
        LONG rc;
 
        rc = RegCreateKeyExW(key, subKeys[i], 0, NULL, 0, KEY_READ, NULL,
         &hKey, NULL);
        if (!rc)
        {
            CRYPT_RegReadSerializedFromReg(hKey, contextFlags[i], store);
            RegCloseKey(hKey);
        }
    }
}

Referenced by CRYPT_RegControl(), and CRYPT_RegOpenStore().

◆ CRYPT_RegReadSerializedFromReg()

static void CRYPT_RegReadSerializedFromReg	(	HKEY	key,
		DWORD	contextType,
		HCERTSTORE	store
	)

static

Definition at line 66 of file regstore.c.

{
    LONG rc;
    DWORD index = 0;
    WCHAR subKeyName[MAX_PATH];
 
    do {
        DWORD size = ARRAY_SIZE(subKeyName);
 
        rc = RegEnumKeyExW(key, index++, subKeyName, &size, NULL, NULL, NULL,
         NULL);
        if (!rc)
        {
            HKEY subKey;
 
            rc = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
            if (!rc)
            {
                LPBYTE buf = NULL;
 
                size = 0;
                rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, NULL, &size);
                if (!rc)
                    buf = CryptMemAlloc(size);
                if (buf)
                {
                    rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, buf,
                     &size);
                    if (!rc)
                    {
                        const void *context;
                        DWORD addedType;
 
                        TRACE("Adding cert with hash %s\n",
                         debugstr_w(subKeyName));
                        context = CRYPT_ReadSerializedElement(buf, size,
                         contextType, &addedType);
                        if (context)
                        {
                            const WINE_CONTEXT_INTERFACE *contextInterface;
                            BYTE hash[20];
 
                            switch (addedType)
                            {
                            case CERT_STORE_CERTIFICATE_CONTEXT:
                                contextInterface = pCertInterface;
                                break;
                            case CERT_STORE_CRL_CONTEXT:
                                contextInterface = pCRLInterface;
                                break;
                            case CERT_STORE_CTL_CONTEXT:
                                contextInterface = pCTLInterface;
                                break;
                            default:
                                contextInterface = NULL;
                            }
                            if (contextInterface)
                            {
                                size = sizeof(hash);
                                if (contextInterface->getProp(context,
                                 CERT_HASH_PROP_ID, hash, &size))
                                {
                                    WCHAR asciiHash[20 * 2 + 1];
 
                                    CRYPT_HashToStr(hash, asciiHash);
                                    TRACE("comparing %s\n",
                                     debugstr_w(asciiHash));
                                    TRACE("with %s\n", debugstr_w(subKeyName));
                                    if (!lstrcmpW(asciiHash, subKeyName))
                                    {
                                        TRACE("hash matches, adding\n");
                                        contextInterface->addContextToStore(
                                         store, context,
                                         CERT_STORE_ADD_REPLACE_EXISTING, NULL);
                                    }
                                    else
                                        TRACE("hash doesn't match, ignoring\n");
                                }
                                Context_Release(context_from_ptr(context));
                            }
                        }
                    }
                    CryptMemFree(buf);
                }
                RegCloseKey(subKey);
            }
            /* Ignore intermediate errors, continue enumerating */
            rc = ERROR_SUCCESS;
        }
    } while (!rc);
}

Referenced by CRYPT_RegReadFromReg().

◆ CRYPT_RegWriteCert()

static BOOL WINAPI CRYPT_RegWriteCert	(	HCERTSTORE	hCertStore,
		PCCERT_CONTEXT	cert,
		DWORD	dwFlags
	)

static

Definition at line 393 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
 
    return CRYPT_RegWriteContext(store, cert, dwFlags);
}

◆ CRYPT_RegWriteContext()

static BOOL CRYPT_RegWriteContext	(	WINE_REGSTOREINFO *	store,
		const void *	context,
		DWORD	dwFlags
	)

static

Definition at line 337 of file regstore.c.

{
    BOOL ret;
 
    if (dwFlags & CERT_STORE_PROV_WRITE_ADD_FLAG)
    {
        store->dirty = TRUE;
        ret = TRUE;
    }
    else
        ret = FALSE;
    return ret;
}

Referenced by CRYPT_RegWriteCert(), CRYPT_RegWriteCRL(), and CRYPT_RegWriteCTL().

◆ CRYPT_RegWriteCRL()

static BOOL WINAPI CRYPT_RegWriteCRL	(	HCERTSTORE	hCertStore,
		PCCRL_CONTEXT	crl,
		DWORD	dwFlags
	)

static

Definition at line 414 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
 
    return CRYPT_RegWriteContext(store, crl, dwFlags);
}

◆ CRYPT_RegWriteCTL()

static BOOL WINAPI CRYPT_RegWriteCTL	(	HCERTSTORE	hCertStore,
		PCCTL_CONTEXT	ctl,
		DWORD	dwFlags
	)

static

Definition at line 435 of file regstore.c.

{
    WINE_REGSTOREINFO *store = hCertStore;
 
    TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
 
    return CRYPT_RegWriteContext(store, ctl, dwFlags);
}

◆ CRYPT_RegWriteToReg()

static BOOL CRYPT_RegWriteToReg ( WINE_REGSTOREINFO * store )

static

Definition at line 248 of file regstore.c.

{
    static const WCHAR * const subKeys[] = { CertsW, CRLsW, CTLsW };
    const WINE_CONTEXT_INTERFACE * const interfaces[] = { pCertInterface,
     pCRLInterface, pCTLInterface };
    struct list *listToDelete[] = { &store->certsToDelete, &store->crlsToDelete,
     &store->ctlsToDelete };
    BOOL ret = TRUE;
    DWORD i;
 
    for (i = 0; ret && i < ARRAY_SIZE(subKeys); i++)
    {
        HKEY key;
        LONG rc = RegCreateKeyExW(store->key, subKeys[i], 0, NULL, 0,
         KEY_ALL_ACCESS, NULL, &key, NULL);
 
        if (!rc)
        {
            if (listToDelete[i])
            {
                WINE_HASH_TO_DELETE *toDelete, *next;
                WCHAR asciiHash[20 * 2 + 1];
 
                EnterCriticalSection(&store->cs);
                LIST_FOR_EACH_ENTRY_SAFE(toDelete, next, listToDelete[i],
                 WINE_HASH_TO_DELETE, entry)
                {
                    LONG rc;
 
                    CRYPT_HashToStr(toDelete->hash, asciiHash);
                    TRACE("Removing %s\n", debugstr_w(asciiHash));
                    rc = RegDeleteKeyW(key, asciiHash);
                    if (rc != ERROR_SUCCESS && rc != ERROR_FILE_NOT_FOUND)
                    {
                        SetLastError(rc);
                        ret = FALSE;
                    }
                    list_remove(&toDelete->entry);
                    CryptMemFree(toDelete);
                }
                LeaveCriticalSection(&store->cs);
            }
            ret = CRYPT_SerializeContextsToReg(key, 0, interfaces[i], store->memStore);
            RegCloseKey(key);
        }
        else
        {
            SetLastError(rc);
            ret = FALSE;
        }
    }
    return ret;
}

Referenced by CRYPT_RegFlushStore().

◆ CRYPT_SerializeContextsToReg()

BOOL CRYPT_SerializeContextsToReg	(	HKEY	key,
		DWORD	flags,
		const WINE_CONTEXT_INTERFACE *	contextInterface,
		HCERTSTORE	memStore
	)

Definition at line 208 of file regstore.c.

{
    const void *context = NULL;
    BOOL ret;
 
    do {
        context = contextInterface->enumContextsInStore(memStore, context);
        if (context)
        {
            BYTE hash[20];
            DWORD hashSize = sizeof(hash);
 
            ret = contextInterface->getProp(context, CERT_HASH_PROP_ID, hash,
             &hashSize);
            if (ret)
            {
                DWORD size = 0;
                LPBYTE buf = NULL;
 
                ret = contextInterface->serialize(context, 0, NULL, &size);
                if (size)
                    buf = CryptMemAlloc(size);
                if (buf)
                {
                    ret = contextInterface->serialize(context, 0, buf, &size);
                    if (ret)
                        ret = CRYPT_WriteSerializedToReg(key, flags, hash, buf, size);
                }
                CryptMemFree(buf);
            }
        }
        else
            ret = TRUE;
    } while (ret && context != NULL);
    if (context)
        Context_Release(context_from_ptr(context));
    return ret;
}

Referenced by CRYPT_ImportSystemRootCertsToReg(), and CRYPT_RegWriteToReg().

◆ CRYPT_WriteSerializedToReg()

static BOOL CRYPT_WriteSerializedToReg	(	HKEY	key,
		DWORD	flags,
		const BYTE *	hash,
		const BYTE *	buf,
		DWORD	len
	)

static

Definition at line 182 of file regstore.c.

{
    WCHAR asciiHash[20 * 2 + 1];
    LONG rc;
    HKEY subKey;
    BOOL ret;
 
    CRYPT_HashToStr(hash, asciiHash);
    rc = RegCreateKeyExW(key, asciiHash, 0, NULL, flags, KEY_ALL_ACCESS, NULL,
     &subKey, NULL);
    if (!rc)
    {
        rc = RegSetValueExW(subKey, BlobW, 0, REG_BINARY, buf, len);
        RegCloseKey(subKey);
    }
    if (!rc)
        ret = TRUE;
    else
    {
        SetLastError(rc);
        ret = FALSE;
    }
    return ret;
}

Referenced by CRYPT_SerializeContextsToReg().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( crypt )

Variable Documentation

◆ BlobW

const WCHAR BlobW[] = { 'B','l','o','b',0 }

static

Definition at line 64 of file regstore.c.

Referenced by CRYPT_RegReadSerializedFromReg(), and CRYPT_WriteSerializedToReg().

◆ CertsW

const WCHAR CertsW[]

static

Initial value:

= { 'C','e','r','t','i','f','i','c','a','t','e','s',

0 }

Definition at line 60 of file regstore.c.

Referenced by CRYPT_RegOpenStore(), CRYPT_RegReadFromReg(), and CRYPT_RegWriteToReg().

◆ CRLsW

const WCHAR CRLsW[] = { 'C','R','L','s',0 }

static

Definition at line 62 of file regstore.c.

Referenced by CRYPT_RegOpenStore(), CRYPT_RegReadFromReg(), and CRYPT_RegWriteToReg().

◆ CTLsW

const WCHAR CTLsW[] = { 'C','T','L','s',0 }

static

Definition at line 63 of file regstore.c.

Referenced by CRYPT_RegOpenStore(), CRYPT_RegReadFromReg(), and CRYPT_RegWriteToReg().

◆ regProvFuncs

void* regProvFuncs[]

static

Initial value:

= {
    CRYPT_RegCloseStore,
    NULL, 
    CRYPT_RegWriteCert,
    CRYPT_RegDeleteCert,
    NULL, 
    NULL, 
    CRYPT_RegWriteCRL,
    CRYPT_RegDeleteCRL,
    NULL, 
    NULL, 
    CRYPT_RegWriteCTL,
    CRYPT_RegDeleteCTL,
    NULL, 
    CRYPT_RegControl,
}

Definition at line 495 of file regstore.c.

Referenced by CRYPT_RegOpenStore().

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ WINE_HASH_TO_DELETE

◆ WINE_REGSTOREINFO

Function Documentation

◆ CRYPT_HashToStr()

◆ CRYPT_RegCloseStore()

◆ CRYPT_RegControl()

◆ CRYPT_RegDeleteCert()

◆ CRYPT_RegDeleteContext()

◆ CRYPT_RegDeleteCRL()

◆ CRYPT_RegDeleteCTL()

◆ CRYPT_RegFlushStore()

◆ CRYPT_RegOpenStore()

◆ CRYPT_RegReadFromReg()

◆ CRYPT_RegReadSerializedFromReg()

◆ CRYPT_RegWriteCert()

◆ CRYPT_RegWriteContext()

◆ CRYPT_RegWriteCRL()

◆ CRYPT_RegWriteCTL()

◆ CRYPT_RegWriteToReg()

◆ CRYPT_SerializeContextsToReg()

◆ CRYPT_WriteSerializedToReg()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ BlobW

◆ CertsW

◆ CRLsW

◆ CTLsW

◆ regProvFuncs