mscat.h File Reference

#include <mssip.h>
#include <pshpack8.h>
#include <poppack.h>

Include dependency graph for mscat.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CRYPTCATATTRIBUTE_
struct	CRYPTCATMEMBER_
struct	CATALOG_INFO_
struct	CRYPTCATCDF_

Macros
#define	CRYPTCAT_ATTR_NAMEASCII   0x00000001
#define	CRYPTCAT_ATTR_NAMEOBJID   0x00000002
#define	CRYPTCAT_ATTR_DATAASCII   0x00010000
#define	CRYPTCAT_ATTR_DATAOBJID   0x00020000
#define	CRYPTCAT_ATTR_DATAREPLACE   0x00040000
#define	CRYPTCAT_ATTR_NO_AUTO_COMPAT_ENTRY   0x01000000
#define	CRYPTCAT_ATTR_AUTHENTICATED   0x10000000
#define	CRYPTCAT_ATTR_UNAUTHENTICATED   0x20000000
#define	CRYPTCAT_OPEN_CREATENEW   0x00000001
#define	CRYPTCAT_OPEN_ALWAYS   0x00000002
#define	CRYPTCAT_OPEN_EXISTING   0x00000004
#define	CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES   0x00010000
#define	CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES   0x00020000
#define	CRYPTCAT_OPEN_VERIFYSIGHASH   0x10000000
#define	CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG   0x20000000
#define	CRYPTCAT_OPEN_SORTED   0x40000000
#define	CRYPTCAT_OPEN_FLAGS_MASK   0xffff0000
#define	CRYPTCAT_E_AREA_HEADER   0x00000000
#define	CRYPTCAT_E_AREA_MEMBER   0x00010000
#define	CRYPTCAT_E_AREA_ATTRIBUTE   0x00020000
#define	CRYPTCAT_E_CDF_UNSUPPORTED   0x00000001
#define	CRYPTCAT_E_CDF_DUPLICATE   0x00000002
#define	CRYPTCAT_E_CDF_TAGNOTFOUND   0x00000004
#define	CRYPTCAT_E_CDF_MEMBER_FILE_PATH   0x00010001
#define	CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA   0x00010002
#define	CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND   0x00010004
#define	CRYPTCAT_E_CDF_BAD_GUID_CONV   0x00020001
#define	CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES   0x00020002
#define	CRYPTCAT_E_CDF_ATTR_TYPECOMBO   0x00020004
#define	CRYPTCAT_VERSION_1   0x100
#define	CRYPTCAT_VERSION_2   0x200

Typedefs
typedef HANDLE	HCATADMIN
typedef HANDLE	HCATINFO
typedef struct CRYPTCATATTRIBUTE_	CRYPTCATATTRIBUTE
typedef struct CRYPTCATMEMBER_	CRYPTCATMEMBER
typedef struct CATALOG_INFO_	CATALOG_INFO
typedef struct CRYPTCATCDF_	CRYPTCATCDF
typedef void(WINAPI *	PFN_CDF_PARSE_ERROR_CALLBACK) (DWORD, DWORD, WCHAR *)

Functions
BOOL WINAPI	CryptCATAdminAcquireContext (HCATADMIN *, const GUID *, DWORD)
BOOL WINAPI	CryptCATAdminAcquireContext2 (HCATADMIN *, const GUID *, const WCHAR *, const CERT_STRONG_SIGN_PARA *, DWORD)
HCATINFO WINAPI	CryptCATAdminAddCatalog (HCATADMIN, PWSTR, PWSTR, DWORD)
BOOL WINAPI	CryptCATAdminCalcHashFromFileHandle (HANDLE, DWORD *, BYTE *, DWORD)
BOOL WINAPI	CryptCATAdminCalcHashFromFileHandle2 (HCATADMIN, HANDLE, DWORD *, BYTE *, DWORD)
HCATINFO WINAPI	CryptCATAdminEnumCatalogFromHash (HCATADMIN, BYTE *, DWORD, DWORD, HCATINFO *)
BOOL WINAPI	CryptCATAdminReleaseCatalogContext (HCATADMIN, HCATINFO, DWORD)
BOOL WINAPI	CryptCATAdminReleaseContext (HCATADMIN, DWORD)
BOOL WINAPI	CryptCATAdminRemoveCatalog (HCATADMIN, LPCWSTR, DWORD)
BOOL WINAPI	CryptCATAdminResolveCatalogPath (HCATADMIN, WCHAR *, CATALOG_INFO *, DWORD)
BOOL WINAPI	CryptCATCatalogInfoFromContext (HCATINFO, CATALOG_INFO *, DWORD)
BOOL WINAPI	CryptCATCDFClose (CRYPTCATCDF *)
CRYPTCATATTRIBUTE *WINAPI	CryptCATCDFEnumCatAttributes (CRYPTCATCDF *, CRYPTCATATTRIBUTE *, PFN_CDF_PARSE_ERROR_CALLBACK)
LPWSTR WINAPI	CryptCATCDFEnumMembersByCDFTagEx (CRYPTCATCDF *, LPWSTR, PFN_CDF_PARSE_ERROR_CALLBACK, CRYPTCATMEMBER **, BOOL, LPVOID)
CRYPTCATCDF *WINAPI	CryptCATCDFOpen (LPWSTR, PFN_CDF_PARSE_ERROR_CALLBACK)
BOOL WINAPI	CryptCATClose (HANDLE)
CRYPTCATATTRIBUTE *WINAPI	CryptCATEnumerateAttr (HANDLE, CRYPTCATMEMBER *, CRYPTCATATTRIBUTE *)
CRYPTCATATTRIBUTE *WINAPI	CryptCATEnumerateCatAttr (HANDLE, CRYPTCATATTRIBUTE *)
CRYPTCATMEMBER *WINAPI	CryptCATEnumerateMember (HANDLE, CRYPTCATMEMBER *)
CRYPTCATATTRIBUTE *WINAPI	CryptCATGetAttrInfo (HANDLE, CRYPTCATMEMBER *, LPWSTR)
CRYPTCATATTRIBUTE *WINAPI	CryptCATGetCatAttrInfo (HANDLE, LPWSTR)
CRYPTCATMEMBER *WINAPI	CryptCATGetMemberInfo (HANDLE, LPWSTR)
HANDLE WINAPI	CryptCATOpen (LPWSTR, DWORD, HCRYPTPROV, DWORD, DWORD)
BOOL WINAPI	CryptCATPersistStore (HANDLE catalog)
CRYPTCATATTRIBUTE *WINAPI	CryptCATPutAttrInfo (HANDLE catalog, CRYPTCATMEMBER *member, WCHAR *name, DWORD flags, DWORD size, BYTE *data)
CRYPTCATATTRIBUTE *WINAPI	CryptCATPutCatAttrInfo (HANDLE catalog, WCHAR *name, DWORD flags, DWORD size, BYTE *data)
CRYPTCATMEMBER *WINAPI	CryptCATPutMemberInfo (HANDLE catalog, WCHAR *filename, WCHAR *member, GUID *subject, DWORD version, DWORD size, BYTE *data)

Macro Definition Documentation

CRYPTCAT_ATTR_AUTHENTICATED

#define CRYPTCAT_ATTR_AUTHENTICATED   0x10000000

Definition at line 37 of file mscat.h.

CRYPTCAT_ATTR_DATAASCII

#define CRYPTCAT_ATTR_DATAASCII   0x00010000

Definition at line 33 of file mscat.h.

CRYPTCAT_ATTR_DATAOBJID

#define CRYPTCAT_ATTR_DATAOBJID   0x00020000

Definition at line 34 of file mscat.h.

CRYPTCAT_ATTR_DATAREPLACE

#define CRYPTCAT_ATTR_DATAREPLACE   0x00040000

Definition at line 35 of file mscat.h.

CRYPTCAT_ATTR_NAMEASCII

#define CRYPTCAT_ATTR_NAMEASCII   0x00000001

Definition at line 31 of file mscat.h.

CRYPTCAT_ATTR_NAMEOBJID

#define CRYPTCAT_ATTR_NAMEOBJID   0x00000002

Definition at line 32 of file mscat.h.

CRYPTCAT_ATTR_NO_AUTO_COMPAT_ENTRY

#define CRYPTCAT_ATTR_NO_AUTO_COMPAT_ENTRY   0x01000000

Definition at line 36 of file mscat.h.

CRYPTCAT_ATTR_UNAUTHENTICATED

#define CRYPTCAT_ATTR_UNAUTHENTICATED   0x20000000

Definition at line 38 of file mscat.h.

CRYPTCAT_E_AREA_ATTRIBUTE

#define CRYPTCAT_E_AREA_ATTRIBUTE   0x00020000

Definition at line 52 of file mscat.h.

CRYPTCAT_E_AREA_HEADER

#define CRYPTCAT_E_AREA_HEADER   0x00000000

Definition at line 50 of file mscat.h.

CRYPTCAT_E_AREA_MEMBER

#define CRYPTCAT_E_AREA_MEMBER   0x00010000

Definition at line 51 of file mscat.h.

CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES

#define CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES   0x00020002

Definition at line 63 of file mscat.h.

CRYPTCAT_E_CDF_ATTR_TYPECOMBO

#define CRYPTCAT_E_CDF_ATTR_TYPECOMBO   0x00020004

Definition at line 64 of file mscat.h.

CRYPTCAT_E_CDF_BAD_GUID_CONV

#define CRYPTCAT_E_CDF_BAD_GUID_CONV   0x00020001

Definition at line 62 of file mscat.h.

CRYPTCAT_E_CDF_DUPLICATE

#define CRYPTCAT_E_CDF_DUPLICATE   0x00000002

Definition at line 55 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_FILE_PATH

#define CRYPTCAT_E_CDF_MEMBER_FILE_PATH   0x00010001

Definition at line 58 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND

#define CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND   0x00010004

Definition at line 60 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA

#define CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA   0x00010002

Definition at line 59 of file mscat.h.

CRYPTCAT_E_CDF_TAGNOTFOUND

#define CRYPTCAT_E_CDF_TAGNOTFOUND   0x00000004

Definition at line 56 of file mscat.h.

CRYPTCAT_E_CDF_UNSUPPORTED

#define CRYPTCAT_E_CDF_UNSUPPORTED   0x00000001

Definition at line 54 of file mscat.h.

CRYPTCAT_OPEN_ALWAYS

#define CRYPTCAT_OPEN_ALWAYS   0x00000002

Definition at line 41 of file mscat.h.

CRYPTCAT_OPEN_CREATENEW

#define CRYPTCAT_OPEN_CREATENEW   0x00000001

Definition at line 40 of file mscat.h.

CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES

#define CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES   0x00010000

Definition at line 43 of file mscat.h.

CRYPTCAT_OPEN_EXISTING

#define CRYPTCAT_OPEN_EXISTING   0x00000004

Definition at line 42 of file mscat.h.

CRYPTCAT_OPEN_FLAGS_MASK

#define CRYPTCAT_OPEN_FLAGS_MASK   0xffff0000

Definition at line 48 of file mscat.h.

CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES

#define CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES   0x00020000

Definition at line 44 of file mscat.h.

CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG

#define CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG   0x20000000

Definition at line 46 of file mscat.h.

CRYPTCAT_OPEN_SORTED

#define CRYPTCAT_OPEN_SORTED   0x40000000

Definition at line 47 of file mscat.h.

CRYPTCAT_OPEN_VERIFYSIGHASH

#define CRYPTCAT_OPEN_VERIFYSIGHASH   0x10000000

Definition at line 45 of file mscat.h.

CRYPTCAT_VERSION_1

#define CRYPTCAT_VERSION_1   0x100

Definition at line 66 of file mscat.h.

CRYPTCAT_VERSION_2

#define CRYPTCAT_VERSION_2   0x200

Definition at line 67 of file mscat.h.

Typedef Documentation

CATALOG_INFO

typedef struct CATALOG_INFO_ CATALOG_INFO

CRYPTCATATTRIBUTE

typedef struct CRYPTCATATTRIBUTE_ CRYPTCATATTRIBUTE

CRYPTCATCDF

typedef struct CRYPTCATCDF_ CRYPTCATCDF

CRYPTCATMEMBER

typedef struct CRYPTCATMEMBER_ CRYPTCATMEMBER

HCATADMIN

typedef HANDLE HCATADMIN

Definition at line 24 of file mscat.h.

HCATINFO

typedef HANDLE HCATINFO

Definition at line 25 of file mscat.h.

PFN_CDF_PARSE_ERROR_CALLBACK

typedef void(WINAPI * PFN_CDF_PARSE_ERROR_CALLBACK) (DWORD, DWORD, WCHAR *)

Definition at line 115 of file mscat.h.

Function Documentation

CryptCATAdminAcquireContext()

BOOL WINAPI CryptCATAdminAcquireContext	(	HCATADMIN *	catAdmin,
		const GUID *	sys,
		DWORD	dwFlags
	)

Definition at line 101 of file crypt.c.

{
    TRACE("%p %s %lx\n", catAdmin, debugstr_guid(sys), dwFlags);
    return CryptCATAdminAcquireContext2(catAdmin, sys, NULL, NULL, dwFlags);
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminAcquireContext2()

BOOL WINAPI CryptCATAdminAcquireContext2	(	HCATADMIN *	catAdmin,
		const GUID *	sys,
		const WCHAR *	algorithm,
		const CERT_STRONG_SIGN_PARA *	policy,
		DWORD	dwFlags
	)

Definition at line 124 of file crypt.c.

{
    static const WCHAR catroot[] =
        {'\\','c','a','t','r','o','o','t',0};
    static const WCHAR fmt[] =
        {'%','s','\\','{','%','0','8','x','-','%','0','4','x','-','%','0',
         '4','x','-','%','0','2','x','%','0','2','x','-','%','0','2','x',
         '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',
         '%','0','2','x','}',0};
    static const GUID defsys =
        {0x127d0a1d,0x4ef2,0x11d1,{0x86,0x08,0x00,0xc0,0x4f,0xc2,0x95,0xee}};
 
    WCHAR catroot_dir[MAX_PATH];
    struct catadmin *ca;
    ALG_ID alg;
    const WCHAR *providerName;
    DWORD providerType;
 
    TRACE("%p %s %s %p %lx\n", catAdmin, debugstr_guid(sys), debugstr_w(algorithm), policy, dwFlags);
 
    if (!catAdmin || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (policy != NULL)
        FIXME("strong policy parameter is unimplemented\n");
 
    if (algorithm == NULL || wcscmp(algorithm, BCRYPT_SHA1_ALGORITHM) == 0)
    {
        alg = CALG_SHA1;
        providerName = MS_DEF_PROV_W;
        providerType = PROV_RSA_FULL;
    }
    else if (wcscmp(algorithm, BCRYPT_SHA256_ALGORITHM) == 0)
    {
        alg = CALG_SHA_256;
        providerName = MS_ENH_RSA_AES_PROV_W;
        providerType = PROV_RSA_AES;
    }
    else
    {
        SetLastError(NTE_BAD_ALGID);
        return FALSE;
    }
 
    if (!(ca = malloc(sizeof(*ca))))
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    ca->alg = alg;
    ca->providerName = providerName;
    ca->providerType = providerType;
 
    GetSystemDirectoryW(catroot_dir, MAX_PATH);
    lstrcatW(catroot_dir, catroot);
 
    /* create the directory if it doesn't exist */
    CreateDirectoryW(catroot_dir, NULL);
 
    if (!sys) sys = &defsys;
    swprintf(ca->path, ARRAY_SIZE(ca->path), fmt, catroot_dir, sys->Data1, sys->Data2,
             sys->Data3, sys->Data4[0], sys->Data4[1], sys->Data4[2],
             sys->Data4[3], sys->Data4[4], sys->Data4[5], sys->Data4[6],
             sys->Data4[7]);
 
    /* create the directory if it doesn't exist */
    CreateDirectoryW(ca->path, NULL);
 
    ca->magic = CATADMIN_MAGIC;
    ca->find = INVALID_HANDLE_VALUE;
 
    *catAdmin = ca;
    return TRUE;
}

Referenced by CryptCATAdminAcquireContext(), and InitFunctionPtrs().

CryptCATAdminAddCatalog()

HCATINFO WINAPI CryptCATAdminAddCatalog	(	HCATADMIN	catAdmin,
		PWSTR	catalogFile,
		PWSTR	selectBaseName,
		DWORD	flags
	)

Definition at line 207 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    struct catadmin *ca = catAdmin;
    struct catinfo *ci;
    WCHAR *target;
    DWORD len;
 
    TRACE("%p %s %s %ld\n", catAdmin, debugstr_w(catalogFile),
          debugstr_w(selectBaseName), flags);
 
    if (!selectBaseName)
    {
        FIXME("NULL basename not handled\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    if (!ca || ca->magic != CATADMIN_MAGIC || !catalogFile || flags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    len = lstrlenW(ca->path) + lstrlenW(selectBaseName) + 2;
    if (!(target = malloc(len * sizeof(WCHAR))))
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
    lstrcpyW(target, ca->path);
    lstrcatW(target, slashW);
    lstrcatW(target, selectBaseName);
 
    if (!CopyFileW(catalogFile, target, FALSE))
    {
        free(target);
        return NULL;
    }
    SetFileAttributesW(target, FILE_ATTRIBUTE_SYSTEM);
 
    if (!(ci = malloc(sizeof(*ci))))
    {
        free(target);
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
    ci->magic = CATINFO_MAGIC;
    lstrcpyW(ci->file, target);
 
    free(target);
    return ci;
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminCalcHashFromFileHandle()

BOOL WINAPI CryptCATAdminCalcHashFromFileHandle	(	HANDLE	hFile,
		DWORD *	pcbHash,
		BYTE *	pbHash,
		DWORD	dwFlags
	)

Definition at line 424 of file crypt.c.

{
    TRACE("%p %p %p %lx\n", hFile, pcbHash, pbHash, dwFlags);
    return catadmin_calc_hash_from_filehandle(NULL, hFile, pcbHash, pbHash, dwFlags);
}

Referenced by InitFunctionPtrs().

CryptCATAdminCalcHashFromFileHandle2()

BOOL WINAPI CryptCATAdminCalcHashFromFileHandle2	(	HCATADMIN	catAdmin,
		HANDLE	hFile,
		DWORD *	pcbHash,
		BYTE *	pbHash,
		DWORD	dwFlags
	)

Definition at line 448 of file crypt.c.

{
    TRACE("%p %p %p %p %lx\n", catAdmin, hFile, pcbHash, pbHash, dwFlags);
 
    if (!catAdmin || ((struct catadmin *)catAdmin)->magic != CATADMIN_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    return catadmin_calc_hash_from_filehandle(catAdmin, hFile, pcbHash, pbHash, dwFlags);
}

Referenced by InitFunctionPtrs().

CryptCATAdminEnumCatalogFromHash()

HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash	(	HCATADMIN	hCatAdmin,
		BYTE *	pbHash,
		DWORD	cbHash,
		DWORD	dwFlags,
		HCATINFO *	phPrevCatInfo
	)

Definition at line 466 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    static const WCHAR globW[]  = {'\\','*','.','c','a','t',0};
 
    struct catadmin *ca = hCatAdmin;
    WIN32_FIND_DATAW data;
    HCATINFO prev = NULL;
    HCRYPTPROV prov;
    DWORD size;
    BOOL ret;
 
    TRACE("%p %p %ld %lx %p\n", hCatAdmin, pbHash, cbHash, dwFlags, phPrevCatInfo);
 
    if (!ca || ca->magic != CATADMIN_MAGIC || !pbHash || cbHash != 20 || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    if (phPrevCatInfo) prev = *phPrevCatInfo;
 
    ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
    if (!ret) return NULL;
 
    if (!prev)
    {
        WCHAR *path;
 
        size = lstrlenW(ca->path) * sizeof(WCHAR) + sizeof(globW);
        if (!(path = malloc(size)))
        {
            CryptReleaseContext(prov, 0);
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        lstrcpyW(path, ca->path);
        lstrcatW(path, globW);
 
        FindClose(ca->find);
        ca->find = FindFirstFileW(path, &data);
 
        free(path);
        if (ca->find == INVALID_HANDLE_VALUE)
        {
            CryptReleaseContext(prov, 0);
            return NULL;
        }
    }
    else if (!FindNextFileW(ca->find, &data))
    {
        CryptCATAdminReleaseCatalogContext(hCatAdmin, prev, 0);
        CryptReleaseContext(prov, 0);
        return NULL;
    }
 
    while (1)
    {
        WCHAR *filename;
        CRYPTCATMEMBER *member = NULL;
        struct catinfo *ci;
        HANDLE hcat;
 
        size = (lstrlenW(ca->path) + lstrlenW(data.cFileName) + 2) * sizeof(WCHAR);
        if (!(filename = malloc(size)))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        lstrcpyW(filename, ca->path);
        lstrcatW(filename, slashW);
        lstrcatW(filename, data.cFileName);
 
        hcat = CryptCATOpen(filename, CRYPTCAT_OPEN_EXISTING, prov, 0, 0);
        if (hcat == INVALID_HANDLE_VALUE)
        {
            WARN("couldn't open %s (%lu)\n", debugstr_w(filename), GetLastError());
            continue;
        }
        while ((member = CryptCATEnumerateMember(hcat, member)))
        {
            if (member->pIndirectData->Digest.cbData != cbHash)
            {
                WARN("amount of hash bytes differs: %lu/%lu\n", member->pIndirectData->Digest.cbData, cbHash);
                continue;
            }
            if (!memcmp(member->pIndirectData->Digest.pbData, pbHash, cbHash))
            {
                TRACE("file %s matches\n", debugstr_w(data.cFileName));
 
                CryptCATClose(hcat);
                CryptReleaseContext(prov, 0);
                if (!phPrevCatInfo)
                {
                    FindClose(ca->find);
                    ca->find = INVALID_HANDLE_VALUE;
                }
                ci = create_catinfo(filename);
                free(filename);
                return ci;
            }
        }
        CryptCATClose(hcat);
        free(filename);
 
        if (!FindNextFileW(ca->find, &data))
        {
            FindClose(ca->find);
            ca->find = INVALID_HANDLE_VALUE;
            CryptReleaseContext(prov, 0);
            return NULL;
        }
    }
    return NULL;
}

CryptCATAdminReleaseCatalogContext()

BOOL WINAPI CryptCATAdminReleaseCatalogContext	(	HCATADMIN	hCatAdmin,
		HCATINFO	hCatInfo,
		DWORD	dwFlags
	)

Definition at line 598 of file crypt.c.

{
    struct catinfo *ci = hCatInfo;
    struct catadmin *ca = hCatAdmin;
 
    TRACE("%p %p %lx\n", hCatAdmin, hCatInfo, dwFlags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC || !ci || ci->magic != CATINFO_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    /* Ensure compiler doesn't optimize out the assignment with 0. */
    SecureZeroMemory(&ci->magic, sizeof(ci->magic));
    free(ci);
    return TRUE;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminReleaseContext()

BOOL WINAPI CryptCATAdminReleaseContext	(	HCATADMIN	hCatAdmin,
		DWORD	dwFlags
	)

Definition at line 632 of file crypt.c.

{
    struct catadmin *ca = hCatAdmin;
 
    TRACE("%p %lx\n", hCatAdmin, dwFlags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (ca->find != INVALID_HANDLE_VALUE) FindClose(ca->find);
    /* Ensure compiler doesn't optimize out the assignment with 0. */
    SecureZeroMemory(&ca->magic, sizeof(ca->magic));
    free(ca);
    return TRUE;
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminRemoveCatalog()

BOOL WINAPI CryptCATAdminRemoveCatalog	(	HCATADMIN	hCatAdmin,
		LPCWSTR	pwszCatalogFile,
		DWORD	dwFlags
	)

Definition at line 665 of file crypt.c.

{
    struct catadmin *ca = hCatAdmin;
 
    TRACE("%p %s %lx\n", hCatAdmin, debugstr_w(pwszCatalogFile), dwFlags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Only delete when there is a filename and no path */
    if (pwszCatalogFile && pwszCatalogFile[0] != 0 &&
        !wcschr(pwszCatalogFile, '\\') && !wcschr(pwszCatalogFile, '/') &&
        !wcschr(pwszCatalogFile, ':'))
    {
        static const WCHAR slashW[] = {'\\',0};
        WCHAR *target;
        DWORD len;
 
        len = lstrlenW(ca->path) + lstrlenW(pwszCatalogFile) + 2;
        if (!(target = malloc(len * sizeof(WCHAR))))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        lstrcpyW(target, ca->path);
        lstrcatW(target, slashW);
        lstrcatW(target, pwszCatalogFile);
 
        DeleteFileW(target);
 
        free(target);
    }
 
    return TRUE;
}

Referenced by InitFunctionPtrs().

CryptCATAdminResolveCatalogPath()

BOOL WINAPI CryptCATAdminResolveCatalogPath	(	HCATADMIN	hcatadmin,
		WCHAR *	catalog_file,
		CATALOG_INFO *	info,
		DWORD	flags
	)

Definition at line 707 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    struct catadmin *ca = hcatadmin;
 
    TRACE("%p %s %p %lx\n", hcatadmin, debugstr_w(catalog_file), info, flags);
 
    if (!ca || ca->magic != CATADMIN_MAGIC || !info || info->cbStruct != sizeof(*info) || flags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    lstrcpyW(info->wszCatalogFile, ca->path);
    lstrcatW(info->wszCatalogFile, slashW);
    lstrcatW(info->wszCatalogFile, catalog_file);
 
    return TRUE;
}

CryptCATCatalogInfoFromContext()

BOOL WINAPI CryptCATCatalogInfoFromContext	(	HCATINFO	hcatinfo,
		CATALOG_INFO *	info,
		DWORD	flags
	)

Definition at line 1023 of file crypt.c.

{
    struct catinfo *ci = hcatinfo;
 
    TRACE("%p, %p, %lx\n", hcatinfo, info, flags);
 
    if (!hcatinfo || hcatinfo == INVALID_HANDLE_VALUE || ci->magic != CATINFO_MAGIC ||
        flags || !info || info->cbStruct != sizeof(*info))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    lstrcpyW(info->wszCatalogFile, ci->file);
    return TRUE;
}

Referenced by InitFunctionPtrs().

CryptCATCDFClose()

BOOL WINAPI CryptCATCDFClose

(

CRYPTCATCDF *

pCDF

)

Definition at line 1234 of file crypt.c.

{
    FIXME("(%p) stub\n", pCDF);
 
    return FALSE;
}

Referenced by InitFunctionPtrs().

CryptCATCDFEnumCatAttributes()

CRYPTCATATTRIBUTE *WINAPI CryptCATCDFEnumCatAttributes	(	CRYPTCATCDF *	pCDF,
		CRYPTCATATTRIBUTE *	pPrevAttr,
		PFN_CDF_PARSE_ERROR_CALLBACK	pfnParseError
	)

Definition at line 1244 of file crypt.c.

{
    FIXME("(%p %p %p) stub\n", pCDF, pPrevAttr, pfnParseError);
 
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATCDFEnumMembersByCDFTagEx()

LPWSTR WINAPI CryptCATCDFEnumMembersByCDFTagEx	(	CRYPTCATCDF *	pCDF,
		LPWSTR	pwszPrevCDFTag,
		PFN_CDF_PARSE_ERROR_CALLBACK	pfnParseError,
		CRYPTCATMEMBER **	ppMember,
		BOOL	fContinueOnError,
		LPVOID	pvReserved
	)

Definition at line 1256 of file crypt.c.

{
    FIXME("(%p %s %p %p %d %p) stub\n", pCDF, debugstr_w(pwszPrevCDFTag), pfnParseError,
          ppMember, fContinueOnError, pvReserved);
 
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATCDFOpen()

CRYPTCATCDF *WINAPI CryptCATCDFOpen	(	LPWSTR	pwszFilePath,
		PFN_CDF_PARSE_ERROR_CALLBACK	pfnParseError
	)

Definition at line 1270 of file crypt.c.

{
    FIXME("(%s %p) stub\n", debugstr_w(pwszFilePath), pfnParseError);
 
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATClose()

BOOL WINAPI CryptCATClose

(

HANDLE

hCatalog

)

Definition at line 730 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    TRACE("(%p)\n", hCatalog);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    free(cc->attr);
    free(cc->inner);
    CryptMsgClose(cc->msg);
 
    /* Ensure compiler doesn't optimize out the assignment with 0. */
    SecureZeroMemory(&cc->magic, sizeof(cc->magic));
    free(cc);
    return TRUE;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().

CryptCATEnumerateAttr()

CRYPTCATATTRIBUTE *WINAPI CryptCATEnumerateAttr	(	HANDLE	hCatalog,
		CRYPTCATMEMBER *	member,
		CRYPTCATATTRIBUTE *	prev
	)

Definition at line 805 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %p, %p\n", hCatalog, member, prev);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATEnumerateCatAttr()

CRYPTCATATTRIBUTE *WINAPI CryptCATEnumerateCatAttr	(	HANDLE	hCatalog,
		CRYPTCATATTRIBUTE *	prev
	)

Definition at line 823 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %p\n", hCatalog, prev);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATEnumerateMember()

CRYPTCATMEMBER *WINAPI CryptCATEnumerateMember	(	HANDLE	hCatalog,
		CRYPTCATMEMBER *	prev
	)

Definition at line 841 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
    CRYPTCATMEMBER *member = prev;
    CTL_ENTRY *entry;
    DWORD size, i;
 
    TRACE("%p, %p\n", hCatalog, prev);
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    /* dumping the contents makes me think that dwReserved is the iteration number */
    if (!member)
    {
        if (!(member = malloc(sizeof(*member))))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        member->cbStruct = sizeof(*member);
        member->pwszFileName = member->pwszReferenceTag = NULL;
        member->dwReserved = 0;
        member->hReserved = NULL;
        member->gSubjectType = cc->subject;
        member->fdwMemberFlags = 0;
        member->pIndirectData = NULL;
        member->dwCertVersion = cc->inner->dwVersion;
    }
    else member->dwReserved++;
 
    if (member->dwReserved >= cc->inner->cCTLEntry)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto error;
    }
 
    /* list them backwards, like native */
    entry = &cc->inner->rgCTLEntry[cc->inner->cCTLEntry - member->dwReserved - 1];
 
    member->sEncodedIndirectData.cbData = member->sEncodedMemberInfo.cbData = 0;
    member->sEncodedIndirectData.pbData = member->sEncodedMemberInfo.pbData = NULL;
    free(member->pIndirectData);
    member->pIndirectData = NULL;
 
    for (i = 0; i < entry->cAttribute; i++)
    {
        CRYPT_ATTRIBUTE *attr = entry->rgAttribute + i;
 
        if (attr->cValue != 1)
        {
            ERR("Can't handle attr->cValue of %lu\n", attr->cValue);
            continue;
        }
        if (!strcmp(attr->pszObjId, CAT_MEMBERINFO_OBJID))
        {
            CAT_MEMBERINFO *mi;
            BOOL ret;
 
            member->sEncodedMemberInfo.cbData = attr->rgValue->cbData;
            member->sEncodedMemberInfo.pbData = attr->rgValue->pbData;
 
            CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 
            if (!(mi = malloc(size)))
            {
                SetLastError(ERROR_OUTOFMEMORY);
                goto error;
            }
            ret = CryptDecodeObject(cc->encoding, CAT_MEMBERINFO_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, mi, &size);
            if (ret)
            {
                UNICODE_STRING guid;
 
                member->dwCertVersion = mi->dwCertVersion;
                RtlInitUnicodeString(&guid, mi->pwszSubjGuid);
                if (RtlGUIDFromString(&guid, &member->gSubjectType))
                {
                    free(mi);
                    goto error;
                }
            }
            free(mi);
            if (!ret) goto error;
        }
        else if (!strcmp(attr->pszObjId, SPC_INDIRECT_DATA_OBJID))
        {
            /* SPC_INDIRECT_DATA_CONTENT is equal to SIP_INDIRECT_DATA */
 
            member->sEncodedIndirectData.cbData = attr->rgValue->cbData;
            member->sEncodedIndirectData.pbData = attr->rgValue->pbData;
 
            CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, NULL, &size);
 
            if (!(member->pIndirectData = malloc(size)))
            {
                SetLastError(ERROR_OUTOFMEMORY);
                goto error;
            }
            CryptDecodeObject(cc->encoding, SPC_INDIRECT_DATA_OBJID, attr->rgValue->pbData, attr->rgValue->cbData, 0, member->pIndirectData, &size);
        }
        else
            /* this object id should probably be handled in CryptCATEnumerateAttr */
            FIXME("unhandled object id \"%s\"\n", attr->pszObjId);
    }
 
    if (!member->sEncodedMemberInfo.cbData || !member->sEncodedIndirectData.cbData)
    {
        ERR("Corrupted catalog entry?\n");
        SetLastError(CRYPT_E_ATTRIBUTES_MISSING);
        goto error;
    }
    size = (2 * member->pIndirectData->Digest.cbData + 1) * sizeof(WCHAR);
    member->pwszReferenceTag = realloc(member->pwszReferenceTag, size);
 
    if (!member->pwszReferenceTag)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        goto error;
    }
    /* FIXME: reference tag is usually the file hash but doesn't have to be */
    for (i = 0; i < member->pIndirectData->Digest.cbData; i++)
    {
        DWORD sub;
 
        sub = member->pIndirectData->Digest.pbData[i] >> 4;
        member->pwszReferenceTag[i * 2] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
        sub = member->pIndirectData->Digest.pbData[i] & 0xf;
        member->pwszReferenceTag[i * 2 + 1] = (sub < 10 ? '0' + sub : 'A' + sub - 10);
    }
    member->pwszReferenceTag[i * 2] = 0;
    return member;
 
error:
    free(member->pIndirectData);
    free(member->pwszReferenceTag);
    free(member);
    return NULL;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().

CryptCATGetAttrInfo()

CRYPTCATATTRIBUTE *WINAPI CryptCATGetAttrInfo	(	HANDLE	hCatalog,
		CRYPTCATMEMBER *	member,
		LPWSTR	tag
	)

Definition at line 754 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %p, %s\n", hCatalog, member, debugstr_w(tag));
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

CryptCATGetCatAttrInfo()

CRYPTCATATTRIBUTE *WINAPI CryptCATGetCatAttrInfo	(	HANDLE	hCatalog,
		LPWSTR	tag
	)

Definition at line 772 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

CryptCATGetMemberInfo()

CRYPTCATMEMBER *WINAPI CryptCATGetMemberInfo	(	HANDLE	hCatalog,
		LPWSTR	tag
	)

Definition at line 787 of file crypt.c.

{
    struct cryptcat *cc = hCatalog;
 
    FIXME("%p, %s\n", hCatalog, debugstr_w(tag));
 
    if (!hCatalog || hCatalog == INVALID_HANDLE_VALUE || cc->magic != CRYPTCAT_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
    SetLastError(CRYPT_E_NOT_FOUND);
    return NULL;
}

CryptCATOpen()

HANDLE WINAPI CryptCATOpen	(	LPWSTR	,
		DWORD	,
		HCRYPTPROV	,
		DWORD	,
		DWORD
	)

CryptCATPersistStore()

BOOL WINAPI CryptCATPersistStore

(

HANDLE

catalog

)

Definition at line 1081 of file crypt.c.

{
    FIXME("catalog %p, stub!\n", catalog);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

CryptCATPutAttrInfo()

CRYPTCATATTRIBUTE *WINAPI CryptCATPutAttrInfo	(	HANDLE	catalog,
		CRYPTCATMEMBER *	member,
		WCHAR *	name,
		DWORD	flags,
		DWORD	size,
		BYTE *	data
	)

Definition at line 1042 of file crypt.c.

{
    FIXME("catalog %p, member %p, name %s, flags %#lx, size %lu, data %p, stub!\n",
            catalog, member, debugstr_w(name), flags, size, data);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}

CryptCATPutCatAttrInfo()

CRYPTCATATTRIBUTE *WINAPI CryptCATPutCatAttrInfo	(	HANDLE	catalog,
		WCHAR *	name,
		DWORD	flags,
		DWORD	size,
		BYTE *	data
	)

Definition at line 1055 of file crypt.c.

{
    FIXME("catalog %p, name %s, flags %#lx, size %lu, data %p, stub!\n",
            catalog, debugstr_w(name), flags, size, data);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}

CryptCATPutMemberInfo()

CRYPTCATMEMBER *WINAPI CryptCATPutMemberInfo	(	HANDLE	catalog,
		WCHAR *	filename,
		WCHAR *	member,
		GUID *	subject,
		DWORD	version,
		DWORD	size,
		BYTE *	data
	)

Definition at line 1068 of file crypt.c.

{
    FIXME("catalog %p, filename %s, member %s, subject %s, version %lu, size %lu, data %p, stub!\n",
            catalog, debugstr_w(filename), debugstr_w(member), debugstr_guid(subject), version, size, data);
 
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}