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_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

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)
HCATINFO WINAPI	CryptCATAdminAddCatalog (HCATADMIN, PWSTR, PWSTR, DWORD)
BOOL WINAPI	CryptCATAdminCalcHashFromFileHandle (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)

Macro Definition Documentation

CRYPTCAT_E_AREA_ATTRIBUTE

#define CRYPTCAT_E_AREA_ATTRIBUTE   0x00020000

Definition at line 43 of file mscat.h.

CRYPTCAT_E_AREA_HEADER

#define CRYPTCAT_E_AREA_HEADER   0x00000000

Definition at line 41 of file mscat.h.

CRYPTCAT_E_AREA_MEMBER

#define CRYPTCAT_E_AREA_MEMBER   0x00010000

Definition at line 42 of file mscat.h.

CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES

#define CRYPTCAT_E_CDF_ATTR_TOOFEWVALUES   0x00020002

Definition at line 54 of file mscat.h.

CRYPTCAT_E_CDF_ATTR_TYPECOMBO

#define CRYPTCAT_E_CDF_ATTR_TYPECOMBO   0x00020004

Definition at line 55 of file mscat.h.

CRYPTCAT_E_CDF_BAD_GUID_CONV

#define CRYPTCAT_E_CDF_BAD_GUID_CONV   0x00020001

Definition at line 53 of file mscat.h.

CRYPTCAT_E_CDF_DUPLICATE

#define CRYPTCAT_E_CDF_DUPLICATE   0x00000002

Definition at line 46 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_FILE_PATH

#define CRYPTCAT_E_CDF_MEMBER_FILE_PATH   0x00010001

Definition at line 49 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND

#define CRYPTCAT_E_CDF_MEMBER_FILENOTFOUND   0x00010004

Definition at line 51 of file mscat.h.

CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA

#define CRYPTCAT_E_CDF_MEMBER_INDIRECTDATA   0x00010002

Definition at line 50 of file mscat.h.

CRYPTCAT_E_CDF_TAGNOTFOUND

#define CRYPTCAT_E_CDF_TAGNOTFOUND   0x00000004

Definition at line 47 of file mscat.h.

CRYPTCAT_E_CDF_UNSUPPORTED

#define CRYPTCAT_E_CDF_UNSUPPORTED   0x00000001

Definition at line 45 of file mscat.h.

CRYPTCAT_OPEN_ALWAYS

#define CRYPTCAT_OPEN_ALWAYS   0x00000002

Definition at line 32 of file mscat.h.

CRYPTCAT_OPEN_CREATENEW

#define CRYPTCAT_OPEN_CREATENEW   0x00000001

Definition at line 31 of file mscat.h.

CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES

#define CRYPTCAT_OPEN_EXCLUDE_PAGE_HASHES   0x00010000

Definition at line 34 of file mscat.h.

CRYPTCAT_OPEN_EXISTING

#define CRYPTCAT_OPEN_EXISTING   0x00000004

Definition at line 33 of file mscat.h.

CRYPTCAT_OPEN_FLAGS_MASK

#define CRYPTCAT_OPEN_FLAGS_MASK   0xffff0000

Definition at line 39 of file mscat.h.

CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES

#define CRYPTCAT_OPEN_INCLUDE_PAGE_HASHES   0x00020000

Definition at line 35 of file mscat.h.

CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG

#define CRYPTCAT_OPEN_NO_CONTENT_HCRYPTMSG   0x20000000

Definition at line 37 of file mscat.h.

CRYPTCAT_OPEN_SORTED

#define CRYPTCAT_OPEN_SORTED   0x40000000

Definition at line 38 of file mscat.h.

CRYPTCAT_OPEN_VERIFYSIGHASH

#define CRYPTCAT_OPEN_VERIFYSIGHASH   0x10000000

Definition at line 36 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 103 of file mscat.h.

Function Documentation

CryptCATAdminAcquireContext()

BOOL WINAPI CryptCATAdminAcquireContext	(	HCATADMIN *	,
		const GUID *	,
		DWORD
	)

Definition at line 98 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;

    TRACE("%p %s %x\n", catAdmin, debugstr_guid(sys), dwFlags);

    if (!catAdmin || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (!(ca = HeapAlloc(GetProcessHeap(), 0, sizeof(*ca))))
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }

    GetSystemDirectoryW(catroot_dir, MAX_PATH);
    strcatW(catroot_dir, catroot);

    /* create the directory if it doesn't exist */
    CreateDirectoryW(catroot_dir, NULL);

    if (!sys) sys = &defsys;
    sprintfW(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 InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminAddCatalog()

HCATINFO WINAPI CryptCATAdminAddCatalog	(	HCATADMIN	,
		PWSTR	,
		PWSTR	,
		DWORD
	)

Definition at line 152 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    struct catadmin *ca = catAdmin;
    struct catinfo *ci;
    WCHAR *target;
    DWORD len;

    TRACE("%p %s %s %d\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 = strlenW(ca->path) + strlenW(selectBaseName) + 2;
    if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
    strcpyW(target, ca->path);
    strcatW(target, slashW);
    strcatW(target, selectBaseName);

    if (!CopyFileW(catalogFile, target, FALSE))
    {
        HeapFree(GetProcessHeap(), 0, target);
        return NULL;
    }
    SetFileAttributesW(target, FILE_ATTRIBUTE_SYSTEM);

    if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci))))
    {
        HeapFree(GetProcessHeap(), 0, target);
        SetLastError(ERROR_OUTOFMEMORY);
        return NULL;
    }
    ci->magic = CATINFO_MAGIC;
    strcpyW(ci->file, target);

    HeapFree(GetProcessHeap(), 0, target);
    return ci;
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminCalcHashFromFileHandle()

BOOL WINAPI CryptCATAdminCalcHashFromFileHandle	(	HANDLE	,
		DWORD *	,
		BYTE *	,
		DWORD
	)

Definition at line 209 of file crypt.c.

{
    BOOL ret = FALSE;

    TRACE("%p %p %p %x\n", hFile, pcbHash, pbHash, dwFlags);

    if (!hFile || !pcbHash || dwFlags)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (*pcbHash < 20)
    {
        *pcbHash = 20;
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return TRUE;
    }

    *pcbHash = 20;
    if (pbHash)
    {
        HCRYPTPROV prov;
        HCRYPTHASH hash;
        DWORD bytes_read;
        BYTE *buffer;

        if (!(buffer = HeapAlloc(GetProcessHeap(), 0, 4096)))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        ret = CryptAcquireContextW(&prov, NULL, MS_DEF_PROV_W, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
        if (!ret)
        {
            HeapFree(GetProcessHeap(), 0, buffer);
            return FALSE;
        }
        ret = CryptCreateHash(prov, CALG_SHA1, 0, 0, &hash);
        if (!ret)
        {
            HeapFree(GetProcessHeap(), 0, buffer);
            CryptReleaseContext(prov, 0);
            return FALSE;
        }
        while ((ret = ReadFile(hFile, buffer, 4096, &bytes_read, NULL)) && bytes_read)
        {
            CryptHashData(hash, buffer, bytes_read, 0);
        }
        if (ret) ret = CryptGetHashParam(hash, HP_HASHVAL, pbHash, pcbHash, 0);

        HeapFree(GetProcessHeap(), 0, buffer);
        CryptDestroyHash(hash);
        CryptReleaseContext(prov, 0);
    }
    return ret;
}

Referenced by InitFunctionPtrs().

CryptCATAdminEnumCatalogFromHash()

HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash	(	HCATADMIN	,
		BYTE *	,
		DWORD	,
		DWORD	,
		HCATINFO *
	)

Definition at line 270 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 %d %x %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 = strlenW(ca->path) * sizeof(WCHAR) + sizeof(globW);
        if (!(path = HeapAlloc(GetProcessHeap(), 0, size)))
        {
            CryptReleaseContext(prov, 0);
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        strcpyW(path, ca->path);
        strcatW(path, globW);

        FindClose(ca->find);
        ca->find = FindFirstFileW(path, &data);

        HeapFree(GetProcessHeap(), 0, 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 = (strlenW(ca->path) + strlenW(data.cFileName) + 2) * sizeof(WCHAR);
        if (!(filename = HeapAlloc(GetProcessHeap(), 0, size)))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return NULL;
        }
        strcpyW(filename, ca->path);
        strcatW(filename, slashW);
        strcatW(filename, data.cFileName);

        hcat = CryptCATOpen(filename, CRYPTCAT_OPEN_EXISTING, prov, 0, 0);
        if (hcat == INVALID_HANDLE_VALUE)
        {
            WARN("couldn't open %s (%u)\n", debugstr_w(filename), GetLastError());
            continue;
        }
        while ((member = CryptCATEnumerateMember(hcat, member)))
        {
            if (member->pIndirectData->Digest.cbData != cbHash)
            {
                WARN("amount of hash bytes differs: %u/%u\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);
                HeapFree(GetProcessHeap(), 0, filename);
                return ci;
            }
        }
        CryptCATClose(hcat);
        HeapFree(GetProcessHeap(), 0, 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	,
		HCATINFO	,
		DWORD
	)

Definition at line 402 of file crypt.c.

{
    struct catinfo *ci = hCatInfo;
    struct catadmin *ca = hCatAdmin;

    TRACE("%p %p %x\n", hCatAdmin, hCatInfo, dwFlags);

    if (!ca || ca->magic != CATADMIN_MAGIC || !ci || ci->magic != CATINFO_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    ci->magic = 0;
    return HeapFree(GetProcessHeap(), 0, ci);
}

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

CryptCATAdminReleaseContext()

BOOL WINAPI CryptCATAdminReleaseContext	(	HCATADMIN	,
		DWORD
	)

Definition at line 434 of file crypt.c.

{
    struct catadmin *ca = hCatAdmin;

    TRACE("%p %x\n", hCatAdmin, dwFlags);

    if (!ca || ca->magic != CATADMIN_MAGIC)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (ca->find != INVALID_HANDLE_VALUE) FindClose(ca->find);
    ca->magic = 0;
    return HeapFree(GetProcessHeap(), 0, ca);
}

Referenced by InitFunctionPtrs(), and pSetupInstallCatalog().

CryptCATAdminRemoveCatalog()

BOOL WINAPI CryptCATAdminRemoveCatalog	(	HCATADMIN	,
		LPCWSTR	,
		DWORD
	)

Definition at line 465 of file crypt.c.

{
    struct catadmin *ca = hCatAdmin;

    TRACE("%p %s %x\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 &&
        !strchrW(pwszCatalogFile, '\\') && !strchrW(pwszCatalogFile, '/') &&
        !strchrW(pwszCatalogFile, ':'))
    {
        static const WCHAR slashW[] = {'\\',0};
        WCHAR *target;
        DWORD len;

        len = strlenW(ca->path) + strlenW(pwszCatalogFile) + 2;
        if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        strcpyW(target, ca->path);
        strcatW(target, slashW);
        strcatW(target, pwszCatalogFile);

        DeleteFileW(target);

        HeapFree(GetProcessHeap(), 0, target);
    }

    return TRUE;
}

Referenced by InitFunctionPtrs().

CryptCATAdminResolveCatalogPath()

BOOL WINAPI CryptCATAdminResolveCatalogPath	(	HCATADMIN	,
		WCHAR *	,
		CATALOG_INFO *	,
		DWORD
	)

Definition at line 507 of file crypt.c.

{
    static const WCHAR slashW[] = {'\\',0};
    struct catadmin *ca = hcatadmin;

    TRACE("%p %s %p %x\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;
    }
    strcpyW(info->wszCatalogFile, ca->path);
    strcatW(info->wszCatalogFile, slashW);
    strcatW(info->wszCatalogFile, catalog_file);

    return TRUE;
}

CryptCATCatalogInfoFromContext()

BOOL WINAPI CryptCATCatalogInfoFromContext	(	HCATINFO	,
		CATALOG_INFO *	,
		DWORD
	)

Definition at line 825 of file crypt.c.

{
    struct catinfo *ci = hcatinfo;

    TRACE("%p, %p, %x\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;
    }
    strcpyW(info->wszCatalogFile, ci->file);
    return TRUE;
}

Referenced by InitFunctionPtrs().

CryptCATCDFClose()

BOOL WINAPI CryptCATCDFClose

(

CRYPTCATCDF *

)

Definition at line 974 of file crypt.c.

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

    return FALSE;
}

Referenced by InitFunctionPtrs().

CryptCATCDFEnumCatAttributes()

CRYPTCATATTRIBUTE* WINAPI CryptCATCDFEnumCatAttributes	(	CRYPTCATCDF *	,
		CRYPTCATATTRIBUTE *	,
		PFN_CDF_PARSE_ERROR_CALLBACK
	)

Definition at line 984 of file crypt.c.

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

    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATCDFEnumMembersByCDFTagEx()

LPWSTR WINAPI CryptCATCDFEnumMembersByCDFTagEx	(	CRYPTCATCDF *	,
		LPWSTR	,
		PFN_CDF_PARSE_ERROR_CALLBACK	,
		CRYPTCATMEMBER **	,
		BOOL	,
		LPVOID
	)

Definition at line 996 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	,
		PFN_CDF_PARSE_ERROR_CALLBACK
	)

Definition at line 1010 of file crypt.c.

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

    return NULL;
}

Referenced by InitFunctionPtrs().

CryptCATClose()

BOOL WINAPI CryptCATClose

(

HANDLE

)

Definition at line 530 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;
    }
    HeapFree(GetProcessHeap(), 0, cc->attr);
    HeapFree(GetProcessHeap(), 0, cc->inner);
    CryptMsgClose(cc->msg);

    cc->magic = 0;
    HeapFree(GetProcessHeap(), 0, cc);
    return TRUE;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().

CryptCATEnumerateAttr()

CRYPTCATATTRIBUTE* WINAPI CryptCATEnumerateAttr	(	HANDLE	,
		CRYPTCATMEMBER *	,
		CRYPTCATATTRIBUTE *
	)

Definition at line 604 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	,
		CRYPTCATATTRIBUTE *
	)

Definition at line 622 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	,
		CRYPTCATMEMBER *
	)

Definition at line 640 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 = HeapAlloc(GetProcessHeap(), 0, 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;
    HeapFree(GetProcessHeap(), 0, 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 %u\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 = HeapAlloc(GetProcessHeap(), 0, 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))
                {
                    HeapFree(GetProcessHeap(), 0, mi);
                    goto error;
                }
            }
            HeapFree(GetProcessHeap(), 0, 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 = HeapAlloc(GetProcessHeap(), 0, 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);
    if (member->pwszReferenceTag)
        member->pwszReferenceTag = HeapReAlloc(GetProcessHeap(), 0, member->pwszReferenceTag, size);
    else
        member->pwszReferenceTag = HeapAlloc(GetProcessHeap(), 0, 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:
    HeapFree(GetProcessHeap(), 0, member->pIndirectData);
    HeapFree(GetProcessHeap(), 0, member->pwszReferenceTag);
    HeapFree(GetProcessHeap(), 0, member);
    return NULL;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().

CryptCATGetAttrInfo()

CRYPTCATATTRIBUTE* WINAPI CryptCATGetAttrInfo	(	HANDLE	,
		CRYPTCATMEMBER *	,
		LPWSTR
	)

Definition at line 553 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	,
		LPWSTR
	)

Definition at line 571 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	,
		LPWSTR
	)

Definition at line 586 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
	)

Definition at line 844 of file crypt.c.

{
    HANDLE file, hmsg;
    BYTE *buffer = NULL;
    DWORD size, flags = OPEN_EXISTING;
    struct cryptcat *cc;

    TRACE("%s, %x, %lx, %x, %x\n", debugstr_w(pwszFileName), fdwOpenFlags,
          hProv, dwPublicVersion, dwEncodingType);

    if (!pwszFileName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return INVALID_HANDLE_VALUE;
    }

    if (!dwEncodingType)  dwEncodingType  = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;

    if (fdwOpenFlags & CRYPTCAT_OPEN_ALWAYS)    flags |= OPEN_ALWAYS;
    if (fdwOpenFlags & CRYPTCAT_OPEN_CREATENEW) flags |= CREATE_NEW;

    file = CreateFileW(pwszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, flags, 0, NULL);
    if (file == INVALID_HANDLE_VALUE) return INVALID_HANDLE_VALUE;

    size = GetFileSize(file, NULL);
    if (!(buffer = HeapAlloc(GetProcessHeap(), 0, size)))
    {
        CloseHandle(file);
        SetLastError(ERROR_OUTOFMEMORY);
        return INVALID_HANDLE_VALUE;
    }
    if (!(hmsg = CryptMsgOpenToDecode(dwEncodingType, 0, 0, hProv, NULL, NULL)))
    {
        CloseHandle(file);
        HeapFree(GetProcessHeap(), 0, buffer);
        return INVALID_HANDLE_VALUE;
    }
    if (!ReadFile(file, buffer, size, &size, NULL) || !CryptMsgUpdate(hmsg, buffer, size, TRUE))
    {
        CloseHandle(file);
        HeapFree(GetProcessHeap(), 0, buffer);
        CryptMsgClose(hmsg);
        return INVALID_HANDLE_VALUE;
    }
    HeapFree(GetProcessHeap(), 0, buffer);
    CloseHandle(file);

    size = sizeof(DWORD);
    if (!(cc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cc))))
    {
        CryptMsgClose(hmsg);
        SetLastError(ERROR_OUTOFMEMORY);
        return INVALID_HANDLE_VALUE;
    }

    cc->msg = hmsg;
    cc->encoding = dwEncodingType;
    if (CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_COUNT_PARAM, 0, &cc->attr_count, &size))
    {
        DWORD i, sum = 0;
        BYTE *p;

        for (i = 0; i < cc->attr_count; i++)
        {
            if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
            {
                CryptMsgClose(hmsg);
                HeapFree(GetProcessHeap(), 0, cc);
                return INVALID_HANDLE_VALUE;
            }
            sum += size;
        }
        if (!(cc->attr = HeapAlloc(GetProcessHeap(), 0, sizeof(*cc->attr) * cc->attr_count + sum)))
        {
            CryptMsgClose(hmsg);
            HeapFree(GetProcessHeap(), 0, cc);
            SetLastError(ERROR_OUTOFMEMORY);
            return INVALID_HANDLE_VALUE;
        }
        p = (BYTE *)(cc->attr + cc->attr_count);
        for (i = 0; i < cc->attr_count; i++)
        {
            if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, NULL, &size))
            {
                CryptMsgClose(hmsg);
                HeapFree(GetProcessHeap(), 0, cc->attr);
                HeapFree(GetProcessHeap(), 0, cc);
                return INVALID_HANDLE_VALUE;
            }
            if (!CryptMsgGetParam(hmsg, CMSG_ATTR_CERT_PARAM, i, p, &size))
            {
                CryptMsgClose(hmsg);
                HeapFree(GetProcessHeap(), 0, cc->attr);
                HeapFree(GetProcessHeap(), 0, cc);
                return INVALID_HANDLE_VALUE;
            }
            p += size;
        }
        cc->inner = decode_inner_content(hmsg, dwEncodingType, &cc->inner_len);
        if (!cc->inner || !CryptSIPRetrieveSubjectGuid(pwszFileName, NULL, &cc->subject))
        {
            CryptMsgClose(hmsg);
            HeapFree(GetProcessHeap(), 0, cc->attr);
            HeapFree(GetProcessHeap(), 0, cc->inner);
            HeapFree(GetProcessHeap(), 0, cc);
            return INVALID_HANDLE_VALUE;
        }
        cc->magic = CRYPTCAT_MAGIC;
        return cc;
    }
    HeapFree(GetProcessHeap(), 0, cc);
    return INVALID_HANDLE_VALUE;
}

Referenced by CryptCATAdminEnumCatalogFromHash(), and InitFunctionPtrs().