windows-server-2003/ds/security/services/smartcrd/tools/logscp/logcsp/logctx.cpp

/*++

 Copyright (C) Microsoft Corporation, 1999

 Module Name:

     logctx

 Abstract:

     This module provides the implementation for the CLoggingContext object.

 Author:

     Doug Barlow (dbarlow) 12/7/1999

 Notes:

     ?Notes?

 --*/

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#include <windows.h>
#include "logcsp.h"

typedef enum {
    EndFlag = 0,
    AsnEncoding,
    AnsiString,
    UnicodeString,
    StructWithLength,
    SecDesc,
    Blob,
    Direct,
    Unknown     // Must be last.
} LengthEncoding;
typedef struct {
    DWORD dwParamId;
    LengthEncoding leLengthType;
    DWORD cbLength;
} LengthMap;

static const LPCTSTR CPNames[]
    = { TEXT("CPAcquireContext"),
        TEXT("CPGetProvParam"),
        TEXT("CPReleaseContext"),
        TEXT("CPSetProvParam"),
        TEXT("CPDeriveKey"),
        TEXT("CPDestroyKey"),
        TEXT("CPExportKey"),
        TEXT("CPGenKey"),
        TEXT("CPGetKeyParam"),
        TEXT("CPGenRandom"),
        TEXT("CPGetUserKey"),
        TEXT("CPImportKey"),
        TEXT("CPSetKeyParam"),
        TEXT("CPEncrypt"),
        TEXT("CPDecrypt"),
        TEXT("CPCreateHash"),
        TEXT("CPDestroyHash"),
        TEXT("CPGetHashParam"),
        TEXT("CPHashData"),
        TEXT("CPHashSessionKey"),
        TEXT("CPSetHashParam"),
        TEXT("CPSignHash"),
        TEXT("CPVerifySignature"),
        TEXT("CPDuplicateHash"),
        TEXT("CPDuplicateKey"),
        NULL };

static const LengthMap rglmProvParam[]
    = { { PP_CLIENT_HWND,           Direct,     sizeof(DWORD) },
        { PP_IMPTYPE,               Direct,     sizeof(DWORD) },
        { PP_NAME,                  AnsiString, 0 },
        { PP_VERSION,               Direct,     sizeof(DWORD) },
        { PP_CONTAINER,             AnsiString, 0 },
        { PP_KEYSET_SEC_DESCR,      SecDesc,    0 },
        { PP_CERTCHAIN,             AsnEncoding, 0 },
        { PP_KEY_TYPE_SUBTYPE,      Direct,     sizeof(KEY_TYPE_SUBTYPE) },
        { PP_KEYEXCHANGE_KEYSIZE,   Direct,     sizeof(DWORD) },
        { PP_SIGNATURE_KEYSIZE,     Direct,     sizeof(DWORD) },
        { PP_KEYEXCHANGE_ALG,       Direct,     sizeof(DWORD) },
        { PP_SIGNATURE_ALG,         Direct,     sizeof(DWORD) },
        { PP_PROVTYPE,              Direct,     sizeof(DWORD) },
        { PP_SYM_KEYSIZE,           Direct,     sizeof(DWORD) },
        { PP_SESSION_KEYSIZE,       Direct,     sizeof(DWORD) },
        { PP_UI_PROMPT,             UnicodeString, 0 },
        { PP_DELETEKEY,             Direct,     sizeof(DWORD) },
        { PP_ADMIN_PIN,             AnsiString, 0 },
        { PP_KEYEXCHANGE_PIN,       AnsiString, 0 },
        { PP_SIGNATURE_PIN,         AnsiString, 0 },
        { PP_SIG_KEYSIZE_INC,       Direct,     sizeof(DWORD) },
        { PP_KEYX_KEYSIZE_INC,      Direct,     sizeof(DWORD) },
        { PP_SGC_INFO,              Direct,     sizeof(CERT_CONTEXT) }, // contains pointers
        { PP_USE_HARDWARE_RNG,      Unknown,    0 },      // Nothing returned but status
//      { PP_ENUMEX_SIGNING_PROT,   Unknown,    0 },      // Get only, zero length
//      { PP_KEYSPEC,               Direct,     sizeof(DWORD) }, // Get only
//      { PP_ENUMALGS               Unknown,    0 },      // Get Only ENUMALGS structure
//      { PP_ENUMCONTAINERS         AnsiString, 0 },   // Get Only
//      { PP_ENUMALGS_EX            Unknown,    0 },      // Get Only ENUMALGSEX structure
//      { PP_KEYSTORAGE             Direct,     sizeof(DWORD) },     // Get Only
//      { PP_KEYSET_TYPE            Direct,     sizeof(DWORD) },     // Get Only
//      { PP_UNIQUE_CONTAINER       AnsiString, 0 },   // Get Only
//      { PP_CHANGE_PASSWORD,       Unknown,    0 },      // unused
//      { PP_CONTEXT_INFO,          Unknown,    0 },      // unused
//      { PP_APPLI_CERT,            Unknown,    0 },      // unused
//      { PP_ENUMMANDROOTS,         Unknown,    0 },      // unused
//      { PP_ENUMELECTROOTS,        Unknown,    0 },      // unused
        { 0,                        EndFlag,    0 } };

static const LengthMap rglmKeyParam[]
    = { { KP_IV,                    Direct,     8 },    // RC2_BLOCKLEN
        { KP_SALT,                  Direct,     11 },   // 11 bytes in Base CSP, 0 bytes in Enh CSP
        { KP_PADDING,               Direct,     sizeof(DWORD) },
        { KP_MODE,                  Direct,     sizeof(DWORD) },
        { KP_MODE_BITS,             Direct,     sizeof(DWORD) },
        { KP_PERMISSIONS,           Direct,     sizeof(DWORD) },
        { KP_ALGID,                 Direct,     sizeof(DWORD) },
        { KP_BLOCKLEN,              Direct,     sizeof(DWORD) },
        { KP_KEYLEN,                Direct,     sizeof(DWORD) },
        { KP_SALT_EX,               Blob,       0 },
        { KP_P,                     Blob,       0 },
        { KP_G,                     Blob,       0 },
        { KP_Q,                     Blob,       0 },
        { KP_X,                     Unknown,    0 },  // Must be NULL.
        { KP_EFFECTIVE_KEYLEN,      Direct,     sizeof(DWORD) },
        { KP_SCHANNEL_ALG,          Direct,     sizeof(SCHANNEL_ALG) },
        { KP_CLIENT_RANDOM,         Blob,       0 },
        { KP_SERVER_RANDOM,         Blob,       0 },
        { KP_CERTIFICATE,           AsnEncoding, 0 },
        { KP_CLEAR_KEY,             Blob,       0 },
        { KP_KEYVAL,                Unknown,    0 },  // (aka KP_Z) length of key
        { KP_ADMIN_PIN,             AnsiString, 0 },
        { KP_KEYEXCHANGE_PIN,       AnsiString, 0 },
        { KP_SIGNATURE_PIN,         AnsiString, 0 },
        { KP_OAEP_PARAMS,           Blob,       0 },
        { KP_CMS_DH_KEY_INFO,       Direct,     sizeof(CMS_DH_KEY_INFO) },  //contains pointers
        { KP_PUB_PARAMS,            Blob,       0 },
        { KP_HIGHEST_VERSION,       Direct,     sizeof(DWORD) },
//      { KP_VERIFY_PARAMS,         Unknown,    0 },  // Get only, returns empty string w/ status
//      { KP_Y,                     Unknown,    0 },  // Unused
//      { KP_RA,                    Unknown,    0 },  // Unused
//      { KP_RB,                    Unknown,    0 },  // Unused
//      { KP_INFO,                  Unknown,    0 },  // Unused
//      { KP_RP,                    Unknown,    0 },  // Unused
//      { KP_PRECOMP_MD5,           Unknown,    0 },  // Unused
//      { KP_PRECOMP_SHA,           Unknown,    0 },  // Unused
//      { KP_PUB_EX_LEN,            Unknown,    0 },  // Unused
//      { KP_PUB_EX_VAL,            Unknown,    0 },  // Unused
//      { KP_PREHASH,               Unknown,    0 },  // Unused
//      { KP_CMS_KEY_INFO,          Unknown,    0 },  // Unused CMS_KEY_INFO structure
        { 0,                        EndFlag,    0 } };

static const LengthMap rglmHashParam[]
    = { { HP_ALGID,                 Direct,     sizeof(DWORD) },
        { HP_HASHVAL,               Direct,     20 },  // (A_SHA_DIGEST_LEN) Length of hash
        { HP_HASHSIZE,              Direct,     sizeof(DWORD) },
        { HP_HMAC_INFO,             Direct,     sizeof(HMAC_INFO) }, // contains pointers
        { HP_TLS1PRF_LABEL,         Blob,       0 },
        { HP_TLS1PRF_SEED,          Blob,       0 },
        { 0,                        EndFlag,    0 } };

const LPCTSTR
    g_szCspRegistry
        = TEXT("SOFTWARE\\Microsoft\\Cryptography\\Defaults\\Provider"),
    g_szSignature      = TEXT("Signature"),
    g_szImagePath      = TEXT("Image Path"),
    g_szSigInFile      = TEXT("SigInFile"),
    g_szType           = TEXT("Type");
const LPCTSTR
    g_szLogCspRegistry
        = TEXT("SOFTWARE\\Microsoft\\Cryptography\\CSPDK\\Logging Crypto Provider"),
    g_szLogFile        = TEXT("Logging File"),
    g_szSavedImagePath = TEXT("Logging Image Path"),
    g_szSavedSignature = TEXT("Logging Signature"),
    g_szSavedSigInFile = TEXT("Logging SigInFile");
const LPCTSTR
    g_szLogCsp         = TEXT("LogCsp.dll");
const LPCTSTR
    g_szCspDkRegistry
        = TEXT("SOFTWARE\\Microsoft\\Cryptography\\CSPDK\\Certificates");

static DWORD
MapLength(
    const LengthMap *rglmParamId,
    DWORD dwParam,
    LPCBYTE *ppbData,
    DWORD dwFlags);
static DWORD
ExtractTag(
    IN const BYTE *pbSrc,
    OUT LPDWORD pdwTag,
    OUT LPBOOL pfConstr);
static DWORD
ExtractLength(
    IN const BYTE *pbSrc,
    OUT LPDWORD pdwLen,
    OUT LPBOOL pfIndefinite);
static DWORD
Asn1Length(
    IN LPCBYTE pbAsn1);


/*++

CONSTRUCTOR:

    The constructor for this object simply initializes the properties to a
    known state.  Use the Initialize member to actually build the object.

Arguments:

    None

Remarks:

    ?Remarks?

Author:

    Doug Barlow (dbarlow) 12/7/1999

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::CLoggingContext")

CLoggingContext::CLoggingContext(
    void)
:   m_tzCspImage(),
    m_tzLogFile()
{
    m_nRefCount = 1;
    m_hModule = NULL;
    ZeroMemory(&m_cspRedirect, sizeof(CSP_REDIRECT));
}


/*++

DESTRUCTOR:

    The destructor for this object cleans up everything it can without
    generating an error.

Remarks:

    ?Remarks?

Author:

    Doug Barlow (dbarlow) 12/7/1999

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::~CLoggingContext")

CLoggingContext::~CLoggingContext()
{
    g_prgCtxs->Set(m_dwIndex, NULL);
    if (NULL != m_hModule)
        FreeLibrary(m_hModule);
}


/*++

Initialize:

    This function actually does the work of loading the target CSP.

Arguments:

    pVTable supplies the VTable structure from the controlling ADVAPI32.dll.

Return Value:

    ?return-value?

Remarks:

    ?Remarks?

Author:

    Doug Barlow (dbarlow) 12/7/1999

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::Initialize")

DWORD
CLoggingContext::Initialize(
    IN PVTableProvStruc pVTable,
    IN CRegistry &regRoot)
{
    DWORD dwSts;
    DWORD dwReturn;
    BOOL fVerified = FALSE;
    const LPCTSTR *psz;
    FARPROC *pf;


    //
    // Replace the system image validation function with ours.
    //

    pVTable->FuncVerifyImage = CspdkVerifyImage;


    //
    // regRoot provides a handle to to a point in the registry from
    // which we can read additional parameters.  First, get the dll to be
    // loaded.
    //

    try
    {
        m_tzCspImage.Copy(regRoot.GetStringValue(g_szSavedImagePath));
    }
    catch (...)
    {
        dwReturn = ERROR_SERVICE_NOT_FOUND;
        goto ErrorExit;
    }


    //
    // Next get the Log File Name for this CSP.  If there isn't one, we still
    // load the CSP, but we don't do logging.
    //

    try
    {
        if (regRoot.ValueExists(g_szLogFile))
            m_tzLogFile.Copy(regRoot.GetStringValue(g_szLogFile));
    }
    catch (...)
    {
        dwReturn = NTE_NO_MEMORY;
        goto ErrorExit;
    }


    //
    // Verify the signature of the proposed image.  First, see if there's
    // a signature in the registry.
    //

    if (regRoot.ValueExists(g_szSavedSignature))
    {
        try
        {
            LPCBYTE pbSig = regRoot.GetBinaryValue(g_szSavedSignature);
            fVerified = CspdkVerifyImage(m_tzCspImage, pbSig);

        }
        catch (...)
        {
            dwReturn = NTE_NO_MEMORY;
            goto ErrorExit;
        }
    }


    //
    // If that didn't work, see if there's a signature in the file.
    //

    if (!fVerified)
        fVerified = CspdkVerifyImage(m_tzCspImage, NULL);


    //
    // We're out of options.  If it hasn't verified by now, give up.
    //

    if (!fVerified)
    {
        dwReturn = NTE_BAD_SIGNATURE;
        goto ErrorExit;
    }


    //
    // The image has passed signature checks.  Now load the image.
    //

    pf = (FARPROC *)&m_cspRedirect.pfAcquireContext;
    m_hModule = LoadLibrary(m_tzCspImage);
    if (NULL == m_hModule)
    {
        dwSts = GetLastError();
        goto ErrorExit;
    }
    for (psz = CPNames; NULL != *psz; psz += 1)
    {
        *pf = GetProcAddress(m_hModule, *psz);
        pf += 1;
    }

    return ERROR_SUCCESS;

ErrorExit:
    return dwReturn;
}


/*++

CLoggingContext::AddRef:

    Add a new reference to this object.

Arguments:

    None

Return Value:

    A pointer to this object.

Author:

    Doug Barlow (dbarlow) 12/11/1999

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::AddRef")

CLoggingContext *
CLoggingContext::AddRef(
    void)
{
    m_nRefCount += 1;
    return this;
}


/*++

CLoggingContext::Release:

    This routine decrements the number of references to this object.  If there
    are no more references to this object, it deletes itself.

Arguments:

    None

Return Value:

    None

Author:

    Doug Barlow (dbarlow) 12/11/1999

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::Release")

void
CLoggingContext::Release(
    void)
{
    if (0 == --m_nRefCount)
        delete this;
}


/*
 -      CPAcquireContext
 -
 *      Purpose:
 *               The CPAcquireContext function is used to acquire a context
 *               handle to a cryptograghic service provider (CSP).
 *
 *
 *      Parameters:
 *               IN  pszContainer  -  Pointer to a string of key container
 *               IN  dwFlags       -  Flags values
 *               IN  pVTable       -  Pointer to table of function pointers
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::AcquireContext")

DWORD
CLoggingContext::AcquireContext(
    OUT HCRYPTPROV *phProv,
    IN LPCTSTR pszContainer,
    IN DWORD dwFlags,
    IN PVTableProvStruc pVTable)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogAcquireContext logObj;

        logObj.Request(phProv,
                       pszContainer,
                       dwFlags,
                       pVTable);
        if (NULL != m_cspRedirect.pfAcquireContext)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfAcquireContext)(
                            phProv,
                            pszContainer,
                            dwFlags,
                            pVTable);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            phProv,
                            pszContainer,
                            dwFlags,
                            pVTable);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPGetProvParam
 -
 *      Purpose:
 *                Allows applications to get various aspects of the
 *                operations of a provider
 *
 *      Parameters:
 *               IN      hProv      -  Handle to a CSP
 *               IN      dwParam    -  Parameter number
 *               IN      pbData     -  Pointer to data
 *               IN OUT  pdwDataLen -  Length of parameter data
 *               IN      dwFlags    -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::GetProvParam")

DWORD
CLoggingContext::GetProvParam(
    IN HCRYPTPROV hProv,
    IN DWORD dwParam,
    OUT BYTE *pbData,
    IN OUT DWORD *pdwDataLen,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogGetProvParam logObj;

        logObj.Request(
                        hProv,
                        dwParam,
                        pbData,
                        pdwDataLen,
                        dwFlags);
        if (NULL != m_cspRedirect.pfGetProvParam)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfGetProvParam)(
                            hProv,
                            dwParam,
                            pbData,
                            pdwDataLen,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            dwParam,
                            pbData,
                            pdwDataLen,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPReleaseContext
 -
 *      Purpose:
 *               The CPReleaseContext function is used to release a
 *               context created by CrytAcquireContext.
 *
 *     Parameters:
 *               IN  phProv        -  Handle to a CSP
 *               IN  dwFlags       -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::ReleaseContext")

DWORD
CLoggingContext::ReleaseContext(
    IN HCRYPTPROV hProv,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogReleaseContext logObj;

        logObj.Request(
                        hProv,
                        dwFlags);
        if (NULL != m_cspRedirect.pfReleaseContext)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfReleaseContext)(
                            hProv,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPSetProvParam
 -
 *      Purpose:
 *                Allows applications to customize various aspects of the
 *                operations of a provider
 *
 *      Parameters:
 *               IN      hProv   -  Handle to a CSP
 *               IN      dwParam -  Parameter number
 *               IN      pbData  -  Pointer to data
 *               IN      dwFlags -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::SetProvParam")

DWORD
CLoggingContext::SetProvParam(
    IN HCRYPTPROV hProv,
    IN DWORD dwParam,
    IN CONST BYTE *pbData,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogSetProvParam logObj;
        DWORD dwLength;
        CONST BYTE *pbRealData = pbData;

        dwLength = MapLength(rglmProvParam, dwParam, &pbRealData, dwFlags);
        logObj.Request(
                        hProv,
                        dwParam,
                        pbRealData,
                        dwLength,
                        dwFlags);
        if (NULL != m_cspRedirect.pfSetProvParam)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfSetProvParam)(
                            hProv,
                            dwParam,
                            pbData,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            dwParam,
                            pbRealData,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPDeriveKey
 -
 *      Purpose:
 *                Derive cryptographic keys from base data
 *
 *
 *      Parameters:
 *               IN      hProv      -  Handle to a CSP
 *               IN      Algid      -  Algorithm identifier
 *               IN      hHash      -  Handle to hash
 *               IN      dwFlags    -  Flags values
 *               OUT     phKey      -  Handle to a generated key
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::DeriveKey")

DWORD
CLoggingContext::DeriveKey(
    IN HCRYPTPROV hProv,
    IN ALG_ID Algid,
    IN HCRYPTHASH hHash,
    IN DWORD dwFlags,
    OUT HCRYPTKEY * phKey)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogDeriveKey logObj;

        logObj.Request(
                        hProv,
                        Algid,
                        hHash,
                        dwFlags,
                        phKey);
        if (NULL != m_cspRedirect.pfDeriveKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfDeriveKey)(
                            hProv,
                            Algid,
                            hHash,
                            dwFlags,
                            phKey);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            Algid,
                            hHash,
                            dwFlags,
                            phKey);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPDestroyKey
 -
 *      Purpose:
 *                Destroys the cryptographic key that is being referenced
 *                with the hKey parameter
 *
 *
 *      Parameters:
 *               IN      hProv  -  Handle to a CSP
 *               IN      hKey   -  Handle to a key
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::DestroyKey")

DWORD
CLoggingContext::DestroyKey(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogDestroyKey logObj;

        logObj.Request(
                        hProv,
                        hKey);
        if (NULL != m_cspRedirect.pfDestroyKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfDestroyKey)(
                            hProv,
                            hKey);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPExportKey
 -
 *      Purpose:
 *                Export cryptographic keys out of a CSP in a secure manner
 *
 *
 *      Parameters:
 *               IN  hProv      - Handle to the CSP user
 *               IN  hKey       - Handle to the key to export
 *               IN  hPubKey    - Handle to the exchange public key value of
 *                                the destination user
 *               IN  dwBlobType - Type of key blob to be exported
 *               IN  dwFlags -    Flags values
 *               OUT pbData -     Key blob data
 *               IN OUT pdwDataLen - Length of key blob in bytes
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::ExportKey")

DWORD
CLoggingContext::ExportKey(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey,
    IN HCRYPTKEY hPubKey,
    IN DWORD dwBlobType,
    IN DWORD dwFlags,
    OUT BYTE *pbData,
    IN OUT DWORD *pdwDataLen)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogExportKey logObj;

        logObj.Request(
                        hProv,
                        hKey,
                        hPubKey,
                        dwBlobType,
                        dwFlags,
                        pbData,
                        pdwDataLen);
        if (NULL != m_cspRedirect.pfExportKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfExportKey)(
                            hProv,
                            hKey,
                            hPubKey,
                            dwBlobType,
                            dwFlags,
                            pbData,
                            pdwDataLen);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey,
                            hPubKey,
                            dwBlobType,
                            dwFlags,
                            pbData,
                            pdwDataLen);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPGenKey
 -
 *      Purpose:
 *                Generate cryptographic keys
 *
 *
 *      Parameters:
 *               IN      hProv   -  Handle to a CSP
 *               IN      Algid   -  Algorithm identifier
 *               IN      dwFlags -  Flags values
 *               OUT     phKey   -  Handle to a generated key
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::GenKey")

DWORD
CLoggingContext::GenKey(
    IN HCRYPTPROV hProv,
    IN ALG_ID Algid,
    IN DWORD dwFlags,
    OUT HCRYPTKEY *phKey)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogGenKey logObj;

        logObj.Request(
                        hProv,
                        Algid,
                        dwFlags,
                        phKey);
        if (NULL != m_cspRedirect.pfGenKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfGenKey)(
                            hProv,
                            Algid,
                            dwFlags,
                            phKey);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            Algid,
                            dwFlags,
                            phKey);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPGetKeyParam
 -
 *      Purpose:
 *                Allows applications to get various aspects of the
 *                operations of a key
 *
 *      Parameters:
 *               IN      hProv      -  Handle to a CSP
 *               IN      hKey       -  Handle to a key
 *               IN      dwParam    -  Parameter number
 *               OUT     pbData     -  Pointer to data
 *               IN      pdwDataLen -  Length of parameter data
 *               IN      dwFlags    -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::GetKeyParam")

DWORD
CLoggingContext::GetKeyParam(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey,
    IN DWORD dwParam,
    OUT BYTE *pbData,
    IN OUT DWORD *pdwDataLen,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogGetKeyParam logObj;

        logObj.Request(
                        hProv,
                        hKey,
                        dwParam,
                        pbData,
                        pdwDataLen,
                        dwFlags);
        if (NULL != m_cspRedirect.pfGetKeyParam)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfGetKeyParam)(
                            hProv,
                            hKey,
                            dwParam,
                            pbData,
                            pdwDataLen,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey,
                            dwParam,
                            pbData,
                            pdwDataLen,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPGenRandom
 -
 *      Purpose:
 *                Used to fill a buffer with random bytes
 *
 *
 *      Parameters:
 *               IN  hProv      -  Handle to the user identifcation
 *               IN  dwLen      -  Number of bytes of random data requested
 *               IN OUT pbBuffer-  Pointer to the buffer where the random
 *                                 bytes are to be placed
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::GenRandom")

DWORD
CLoggingContext::GenRandom(
    IN HCRYPTPROV hProv,
    IN DWORD dwLen,
    IN OUT BYTE *pbBuffer)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogGenRandom logObj;

        logObj.Request(
                        hProv,
                        dwLen,
                        pbBuffer);
        if (NULL != m_cspRedirect.pfGenRandom)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfGenRandom)(
                            hProv,
                            dwLen,
                            pbBuffer);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            dwLen,
                            pbBuffer);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPGetUserKey
 -
 *      Purpose:
 *                Gets a handle to a permanent user key
 *
 *
 *      Parameters:
 *               IN  hProv      -  Handle to the user identifcation
 *               IN  dwKeySpec  -  Specification of the key to retrieve
 *               OUT phUserKey  -  Pointer to key handle of retrieved key
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::GetUserKey")

DWORD
CLoggingContext::GetUserKey(
    IN HCRYPTPROV hProv,
    IN DWORD dwKeySpec,
    OUT HCRYPTKEY *phUserKey)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogGetUserKey logObj;

        logObj.Request(
                        hProv,
                        dwKeySpec,
                        phUserKey);
        if (NULL != m_cspRedirect.pfGetUserKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfGetUserKey)(
                            hProv,
                            dwKeySpec,
                            phUserKey);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            dwKeySpec,
                            phUserKey);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPImportKey
 -
 *      Purpose:
 *                Import cryptographic keys
 *
 *
 *      Parameters:
 *               IN  hProv     -  Handle to the CSP user
 *               IN  pbData    -  Key blob data
 *               IN  dwDataLen -  Length of the key blob data
 *               IN  hPubKey   -  Handle to the exchange public key value of
 *                                the destination user
 *               IN  dwFlags   -  Flags values
 *               OUT phKey     -  Pointer to the handle to the key which was
 *                                Imported
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::ImportKey")

DWORD
CLoggingContext::ImportKey(
    IN HCRYPTPROV hProv,
    IN CONST BYTE *pbData,
    IN DWORD dwDataLen,
    IN HCRYPTKEY hPubKey,
    IN DWORD dwFlags,
    OUT HCRYPTKEY *phKey)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogImportKey logObj;

        logObj.Request(
                        hProv,
                        pbData,
                        dwDataLen,
                        hPubKey,
                        dwFlags,
                        phKey);
        if (NULL != m_cspRedirect.pfImportKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfImportKey)(
                            hProv,
                            pbData,
                            dwDataLen,
                            hPubKey,
                            dwFlags,
                            phKey);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            pbData,
                            dwDataLen,
                            hPubKey,
                            dwFlags,
                            phKey);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPSetKeyParam
 -
 *      Purpose:
 *                Allows applications to customize various aspects of the
 *                operations of a key
 *
 *      Parameters:
 *               IN      hProv   -  Handle to a CSP
 *               IN      hKey    -  Handle to a key
 *               IN      dwParam -  Parameter number
 *               IN      pbData  -  Pointer to data
 *               IN      dwFlags -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::SetKeyParam")

DWORD
CLoggingContext::SetKeyParam(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey,
    IN DWORD dwParam,
    IN CONST BYTE *pbData,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogSetKeyParam logObj;
        DWORD dwLength;
        CONST BYTE *pbRealData = pbData;

        dwLength = MapLength(rglmKeyParam, dwParam, &pbRealData, dwFlags);
        logObj.Request(
                        hProv,
                        hKey,
                        dwParam,
                        pbRealData,
                        dwLength,
                        dwFlags);
        if (NULL != m_cspRedirect.pfSetKeyParam)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfSetKeyParam)(
                            hProv,
                            hKey,
                            dwParam,
                            pbData,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey,
                            dwParam,
                            pbRealData,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPEncrypt
 -
 *      Purpose:
 *                Encrypt data
 *
 *
 *      Parameters:
 *               IN  hProv         -  Handle to the CSP user
 *               IN  hKey          -  Handle to the key
 *               IN  hHash         -  Optional handle to a hash
 *               IN  Final         -  Boolean indicating if this is the final
 *                                    block of plaintext
 *               IN  dwFlags       -  Flags values
 *               IN OUT pbData     -  Data to be encrypted
 *               IN OUT pdwDataLen -  Pointer to the length of the data to be
 *                                    encrypted
 *               IN dwBufLen       -  Size of Data buffer
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::Encrypt")

DWORD
CLoggingContext::Encrypt(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey,
    IN HCRYPTHASH hHash,
    IN BOOL Final,
    IN DWORD dwFlags,
    IN OUT BYTE *pbData,
    IN OUT DWORD *pdwDataLen,
    IN DWORD dwBufLen)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogEncrypt logObj;

        logObj.Request(
                        hProv,
                        hKey,
                        hHash,
                        Final,
                        dwFlags,
                        pbData,
                        pdwDataLen,
                        dwBufLen);
        if (NULL != m_cspRedirect.pfEncrypt)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfEncrypt)(
                            hProv,
                            hKey,
                            hHash,
                            Final,
                            dwFlags,
                            pbData,
                            pdwDataLen,
                            dwBufLen);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey,
                            hHash,
                            Final,
                            dwFlags,
                            pbData,
                            pdwDataLen,
                            dwBufLen);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPDecrypt
 -
 *      Purpose:
 *                Decrypt data
 *
 *
 *      Parameters:
 *               IN  hProv         -  Handle to the CSP user
 *               IN  hKey          -  Handle to the key
 *               IN  hHash         -  Optional handle to a hash
 *               IN  Final         -  Boolean indicating if this is the final
 *                                    block of ciphertext
 *               IN  dwFlags       -  Flags values
 *               IN OUT pbData     -  Data to be decrypted
 *               IN OUT pdwDataLen -  Pointer to the length of the data to be
 *                                    decrypted
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::Decrypt")

DWORD
CLoggingContext::Decrypt(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey,
    IN HCRYPTHASH hHash,
    IN BOOL Final,
    IN DWORD dwFlags,
    IN OUT BYTE *pbData,
    IN OUT DWORD *pdwDataLen)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogDecrypt logObj;

        logObj.Request(
                        hProv,
                        hKey,
                        hHash,
                        Final,
                        dwFlags,
                        pbData,
                        pdwDataLen);
        if (NULL != m_cspRedirect.pfDecrypt)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfDecrypt)(
                            hProv,
                            hKey,
                            hHash,
                            Final,
                            dwFlags,
                            pbData,
                            pdwDataLen);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey,
                            hHash,
                            Final,
                            dwFlags,
                            pbData,
                            pdwDataLen);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPCreateHash
 -
 *      Purpose:
 *                initate the hashing of a stream of data
 *
 *
 *      Parameters:
 *               IN  hUID    -  Handle to the user identifcation
 *               IN  Algid   -  Algorithm identifier of the hash algorithm
 *                              to be used
 *               IN  hKey    -  Optional key for MAC algorithms
 *               IN  dwFlags -  Flags values
 *               OUT pHash   -  Handle to hash object
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::CreateHash")

DWORD
CLoggingContext::CreateHash(
    IN HCRYPTPROV hProv,
    IN ALG_ID Algid,
    IN HCRYPTKEY hKey,
    IN DWORD dwFlags,
    OUT HCRYPTHASH *phHash)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogCreateHash logObj;

        logObj.Request(
                        hProv,
                        Algid,
                        hKey,
                        dwFlags,
                        phHash);
        if (NULL != m_cspRedirect.pfCreateHash)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfCreateHash)(
                            hProv,
                            Algid,
                            hKey,
                            dwFlags,
                            phHash);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            Algid,
                            hKey,
                            dwFlags,
                            phHash);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPDestoryHash
 -
 *      Purpose:
 *                Destory the hash object
 *
 *
 *      Parameters:
 *               IN  hProv     -  Handle to the user identifcation
 *               IN  hHash     -  Handle to hash object
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::DestroyHash")

DWORD
CLoggingContext::DestroyHash(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogDestroyHash logObj;

        logObj.Request(
                        hProv,
                        hHash);
        if (NULL != m_cspRedirect.pfDestroyHash)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfDestroyHash)(
                            hProv,
                            hHash);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPGetHashParam
 -
 *      Purpose:
 *                Allows applications to get various aspects of the
 *                operations of a hash
 *
 *      Parameters:
 *               IN      hProv      -  Handle to a CSP
 *               IN      hHash      -  Handle to a hash
 *               IN      dwParam    -  Parameter number
 *               OUT     pbData     -  Pointer to data
 *               IN      pdwDataLen -  Length of parameter data
 *               IN      dwFlags    -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::GetHashParam")

DWORD
CLoggingContext::GetHashParam(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN DWORD dwParam,
    OUT BYTE *pbData,
    IN OUT DWORD *pdwDataLen,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogGetHashParam logObj;

        logObj.Request(
                        hProv,
                        hHash,
                        dwParam,
                        pbData,
                        pdwDataLen,
                        dwFlags);
        if (NULL != m_cspRedirect.pfGetHashParam)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfGetHashParam)(
                            hProv,
                            hHash,
                            dwParam,
                            pbData,
                            pdwDataLen,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            dwParam,
                            pbData,
                            pdwDataLen,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPHashData
 -
 *      Purpose:
 *                Compute the cryptograghic hash on a stream of data
 *
 *
 *      Parameters:
 *               IN  hProv     -  Handle to the user identifcation
 *               IN  hHash     -  Handle to hash object
 *               IN  pbData    -  Pointer to data to be hashed
 *               IN  dwDataLen -  Length of the data to be hashed
 *               IN  dwFlags   -  Flags values
 *               IN  pdwMaxLen -  Maximum length of the data stream the CSP
 *                                module may handle
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::HashData")

DWORD
CLoggingContext::HashData(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN CONST BYTE *pbData,
    IN DWORD dwDataLen,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogHashData logObj;

        logObj.Request(
                        hProv,
                        hHash,
                        pbData,
                        dwDataLen,
                        dwFlags);
        if (NULL != m_cspRedirect.pfHashData)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfHashData)(
                            hProv,
                            hHash,
                            pbData,
                            dwDataLen,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            pbData,
                            dwDataLen,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPHashSessionKey
 -
 *      Purpose:
 *                Compute the cryptograghic hash on a key object.
 *
 *
 *      Parameters:
 *               IN  hProv     -  Handle to the user identifcation
 *               IN  hHash     -  Handle to hash object
 *               IN  hKey      -  Handle to a key object
 *               IN  dwFlags   -  Flags values
 *
 *      Returns:
 *               CRYPT_FAILED
 *               CRYPT_SUCCEED
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::HashSessionKey")

DWORD
CLoggingContext::HashSessionKey(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN  HCRYPTKEY hKey,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogHashSessionKey logObj;

        logObj.Request(
                        hProv,
                        hHash,
                        hKey,
                        dwFlags);
        if (NULL != m_cspRedirect.pfHashSessionKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfHashSessionKey)(
                            hProv,
                            hHash,
                            hKey,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            hKey,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPSetHashParam
 -
 *      Purpose:
 *                Allows applications to customize various aspects of the
 *                operations of a hash
 *
 *      Parameters:
 *               IN      hProv   -  Handle to a CSP
 *               IN      hHash   -  Handle to a hash
 *               IN      dwParam -  Parameter number
 *               IN      pbData  -  Pointer to data
 *               IN      dwFlags -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::SetHashParam")

DWORD
CLoggingContext::SetHashParam(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN DWORD dwParam,
    IN CONST BYTE *pbData,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogSetHashParam logObj;
        DWORD dwLength;
        CONST BYTE *pbRealData = pbData;

        dwLength = MapLength(rglmHashParam, dwParam, &pbRealData, dwFlags);
        logObj.Request(
                        hProv,
                        hHash,
                        dwParam,
                        pbRealData,
                        dwLength,
                        dwFlags);
        if (NULL != m_cspRedirect.pfSetHashParam)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfSetHashParam)(
                            hProv,
                            hHash,
                            dwParam,
                            pbData,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            dwParam,
                            pbRealData,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPSignHash
 -
 *      Purpose:
 *                Create a digital signature from a hash
 *
 *
 *      Parameters:
 *               IN  hProv        -  Handle to the user identifcation
 *               IN  hHash        -  Handle to hash object
 *               IN  dwKeySpec    -  Key pair that is used to sign with
 *               IN  sDescription -  Description of data to be signed
 *               IN  dwFlags      -  Flags values
 *               OUT pbSignture   -  Pointer to signature data
 *               IN OUT pdwSignLen-  Pointer to the len of the signature data
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::SignHash")

DWORD
CLoggingContext::SignHash(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN DWORD dwKeySpec,
    IN LPCTSTR sDescription,
    IN DWORD dwFlags,
    OUT BYTE *pbSignature,
    IN OUT DWORD *pdwSigLen)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogSignHash logObj;

        logObj.Request(
                        hProv,
                        hHash,
                        dwKeySpec,
                        sDescription,
                        dwFlags,
                        pbSignature,
                        pdwSigLen);
        if (NULL != m_cspRedirect.pfSignHash)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfSignHash)(
                            hProv,
                            hHash,
                            dwKeySpec,
                            sDescription,
                            dwFlags,
                            pbSignature,
                            pdwSigLen);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            dwKeySpec,
                            sDescription,
                            dwFlags,
                            pbSignature,
                            pdwSigLen);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -      CPVerifySignature
 -
 *      Purpose:
 *                Used to verify a signature against a hash object
 *
 *
 *      Parameters:
 *               IN  hProv        -  Handle to the user identifcation
 *               IN  hHash        -  Handle to hash object
 *               IN  pbSignture   -  Pointer to signature data
 *               IN  dwSigLen     -  Length of the signature data
 *               IN  hPubKey      -  Handle to the public key for verifying
 *                                   the signature
 *               IN  sDescription -  Description of data to be signed
 *               IN  dwFlags      -  Flags values
 *
 *      Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::VerifySignature")

DWORD
CLoggingContext::VerifySignature(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN CONST BYTE *pbSignature,
    IN DWORD dwSigLen,
    IN HCRYPTKEY hPubKey,
    IN LPCTSTR sDescription,
    IN DWORD dwFlags)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogVerifySignature logObj;

        logObj.Request(
                        hProv,
                        hHash,
                        pbSignature,
                        dwSigLen,
                        hPubKey,
                        sDescription,
                        dwFlags);
        if (NULL != m_cspRedirect.pfVerifySignature)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfVerifySignature)(
                            hProv,
                            hHash,
                            pbSignature,
                            dwSigLen,
                            hPubKey,
                            sDescription,
                            dwFlags);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            pbSignature,
                            dwSigLen,
                            hPubKey,
                            sDescription,
                            dwFlags);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -  CPDuplicateHash
 -
 *  Purpose:
 *                Duplicates the state of a hash and returns a handle to it
 *
 *  Parameters:
 *               IN      hUID           -  Handle to a CSP
 *               IN      hHash          -  Handle to a hash
 *               IN      pdwReserved    -  Reserved
 *               IN      dwFlags        -  Flags
 *               IN      phHash         -  Handle to the new hash
 *
 *  Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::DuplicateHash")

DWORD
CLoggingContext::DuplicateHash(
    IN HCRYPTPROV hProv,
    IN HCRYPTHASH hHash,
    IN DWORD *pdwReserved,
    IN DWORD dwFlags,
    IN HCRYPTHASH *phHash)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogDuplicateHash logObj;

        logObj.Request(
                        hProv,
                        hHash,
                        pdwReserved,
                        dwFlags,
                        phHash);
        if (NULL != m_cspRedirect.pfDuplicateHash)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfDuplicateHash)(
                            hProv,
                            hHash,
                            pdwReserved,
                            dwFlags,
                            phHash);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hHash,
                            pdwReserved,
                            dwFlags,
                            phHash);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


/*
 -  CPDuplicateKey
 -
 *  Purpose:
 *                Duplicates the state of a key and returns a handle to it
 *
 *  Parameters:
 *               IN      hUID           -  Handle to a CSP
 *               IN      hKey           -  Handle to a key
 *               IN      pdwReserved    -  Reserved
 *               IN      dwFlags        -  Flags
 *               IN      phKey          -  Handle to the new key
 *
 *  Returns:
 */
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("CLoggingContext::DuplicateKey")

DWORD
CLoggingContext::DuplicateKey(
    IN HCRYPTPROV hProv,
    IN HCRYPTKEY hKey,
    IN DWORD *pdwReserved,
    IN DWORD dwFlags,
    IN HCRYPTKEY *phKey)
{
    BOOL fReturn;
    DWORD dwReturn;

    {
        CLogDuplicateKey logObj;

        logObj.Request(
                        hProv,
                        hKey,
                        pdwReserved,
                        dwFlags,
                        phKey);
        if (NULL != m_cspRedirect.pfDuplicateKey)
        {
            try
            {
                fReturn = (*m_cspRedirect.pfDuplicateKey)(
                            hProv,
                            hKey,
                            pdwReserved,
                            dwFlags,
                            phKey);
                dwReturn = GetLastError();
                logObj.Response(
                            fReturn,
                            hProv,
                            hKey,
                            pdwReserved,
                            dwFlags,
                            phKey);
            }
            catch (...)
            {
                logObj.LogException();
                fReturn = FALSE;
                dwReturn = ERROR_ARENA_TRASHED;
            }
        }
        else
        {
            fReturn = FALSE;
            dwReturn = ERROR_CALL_NOT_IMPLEMENTED;
            logObj.LogNotCalled(dwReturn);
        }

        logObj.Log(m_tzLogFile);
    }

    if (!fReturn)
    {
        if (ERROR_SUCCESS == dwReturn)
            dwReturn = ERROR_DISCARDED;
    }
    else
        dwReturn = ERROR_SUCCESS;
    return dwReturn;
}


//
///////////////////////////////////////////////////////////////////////////////
//

#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("MapLength")

static DWORD
MapLength(
    const LengthMap *rglmParamId,
    DWORD dwParam,
    LPCBYTE *ppbData,
    DWORD dwFlags)
{
    DWORD dwIndex;
    DWORD dwLength;

    try
    {
        for (dwIndex = 0;
             EndFlag != rglmParamId[dwIndex].leLengthType;
             dwIndex += 1)
        {
            if (dwParam == rglmParamId[dwIndex].dwParamId)
                break;
        }

        switch (rglmParamId[dwIndex].leLengthType)
        {
        case AsnEncoding:
            dwLength = Asn1Length(*ppbData);
            break;
        case AnsiString:
            dwLength = (lstrlenA((LPCSTR)(*ppbData)) + 1) * sizeof(CHAR);
            break;
        case UnicodeString:
            dwLength = (lstrlenW((LPCWSTR)(*ppbData)) +1) *sizeof(WCHAR);
            break;
        case StructWithLength:
            dwLength = *(const DWORD *)(*ppbData);
            break;
        case Blob:
        {
            const CRYPT_ATTR_BLOB *pBlob = (const CRYPT_ATTR_BLOB *)(*ppbData);
            if (NULL != pBlob)
            {
                dwLength = pBlob->cbData;
                *ppbData = pBlob->pbData;
            }
            else
                dwLength = 0;
            break;
        }
        case SecDesc:
            dwLength = GetSecurityDescriptorLength((LPVOID)(*ppbData));
            break;
        case EndFlag:
        case Unknown:
            dwLength = 0;
            break;
        case Direct:
            dwLength = rglmParamId[dwIndex].cbLength;
            break;
        default:
            // Oops!
            dwLength = 0;
        }
    }
    catch (...)
    {
        dwLength = 0;
    }

    return dwLength;
}


/*++

ExtractTag:

    This routine extracts a tag from an ASN.1 BER stream.

Arguments:

    pbSrc supplies the buffer containing the ASN.1 stream.

    pdwTag receives the tag.

Return Value:

    The number of bytes extracted from the stream.  Errors are thrown
    as DWORD status codes.

Author:

    Doug Barlow (dbarlow) 10/9/1995
    Doug Barlow (dbarlow) 7/31/1997

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("ExtractTag")

static DWORD
ExtractTag(
    IN const BYTE *pbSrc,
    OUT LPDWORD pdwTag,
    OUT LPBOOL pfConstr)
{
    LONG lth = 0;
    DWORD tagw;
    BYTE tagc, cls;


    tagc = pbSrc[lth++];
    cls = tagc & 0xc0;  // Top 2 bits.
    if (NULL != pfConstr)
        *pfConstr = (0 != (tagc & 0x20));
    tagc &= 0x1f;       // Bottom 5 bits.

    if (31 > tagc)
        tagw = tagc;
    else
    {
        tagw = 0;
        do
        {
            if (0 != (tagw & 0xfe000000))
                throw (DWORD)ERROR_ARITHMETIC_OVERFLOW;
            tagc = pbSrc[lth++];
            tagw <<= 7;
            tagw |= tagc & 0x7f;
        } while (0 != (tagc & 0x80));
    }

    *pdwTag = tagw | (cls << 24);
    return lth;
}


/*++

ExtractLength:

    This routine extracts a length from an ASN.1 BER stream.  If the
length is
    indefinite, this routine recurses to figure out the real length.  A
flag as
    to whether or not the encoding was indefinite is optionally
returned.

Arguments:

    pbSrc supplies the buffer containing the ASN.1 stream.

    pdwLen receives the len.

    pfIndefinite, if not NULL, receives a flag indicating whether or not
the
        encoding was indefinite.

Return Value:

    The number of bytes extracted from the stream.  Errors are thrown as
    DWORD status codes.

Author:

    Doug Barlow (dbarlow) 10/9/1995
    Doug Barlow (dbarlow) 7/31/1997

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("ExtractLength")

static DWORD
ExtractLength(
    IN const BYTE *pbSrc,
    OUT LPDWORD pdwLen,
    OUT LPBOOL pfIndefinite)
{
    DWORD ll, rslt, lth, lTotal = 0;
    BOOL fInd = FALSE;


    //
    // Extract the Length.
    //

    if (0 == (pbSrc[lTotal] & 0x80))
    {

        //
        // Short form encoding.
        //

        rslt = pbSrc[lTotal++];
    }
    else
    {
        rslt = 0;
        ll = pbSrc[lTotal++] & 0x7f;
        if (0 != ll)
        {

            //
            // Long form encoding.
            //

            for (; 0 < ll; ll -= 1)
            {
                if (0 != (rslt & 0xff000000))
                    throw (DWORD)ERROR_ARITHMETIC_OVERFLOW;
                rslt = (rslt << 8) | pbSrc[lTotal];
                lTotal += 1;
            }
        }
        else
        {
            DWORD ls = lTotal;

            //
            // Indefinite encoding.
            //

            fInd = TRUE;
            while ((0 != pbSrc[ls]) || (0 != pbSrc[ls + 1]))
            {

                // Skip over the Type.
                if (31 > (pbSrc[ls] & 0x1f))
                    ls += 1;
                else
                    while (0 != (pbSrc[++ls] & 0x80));   // Empty loop body.

                lth = ExtractLength(&pbSrc[ls], &ll, NULL);
                ls += lth + ll;
            }
            rslt = ls - lTotal;
        }
    }

    //
    // Supply the caller with what we've learned.
    //

    *pdwLen = rslt;
    if (NULL != pfIndefinite)
        *pfIndefinite = fInd;
    return lTotal;
}


/*++

Asn1Length:

    This routine parses a given ASN.1 buffer and returns the complete
    length of the encoding, including the leading tag and length bytes.

Arguments:

    pbData supplies the buffer to be parsed.

Return Value:

    The length of the entire ASN.1 buffer.

Throws:

    Overflow errors are thrown as DWORD status codes.

Author:

    Doug Barlow (dbarlow) 7/31/1997

--*/
#undef __SUBROUTINE__
#define __SUBROUTINE__ TEXT("Asn1Length")

static DWORD
Asn1Length(
    IN LPCBYTE pbAsn1)
{
    DWORD dwTagLen, dwLenLen, dwValLen;
    DWORD dwTag;

    dwTagLen = ExtractTag(pbAsn1, &dwTag, NULL);
    dwLenLen = ExtractLength(&pbAsn1[dwTagLen], &dwValLen, NULL);
    return dwTagLen + dwLenLen + dwValLen;
}