You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1497 lines
35 KiB
1497 lines
35 KiB
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1999
|
|
|
|
Module Name:
|
|
|
|
logcsp
|
|
|
|
Abstract:
|
|
|
|
This module provides the standard CSP entrypoints for the Logging CSP.
|
|
The Logging CSP provides for additional control over loading CSPs, and
|
|
for tracing of the activities of CSPs.
|
|
|
|
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"
|
|
|
|
#define LOGCSPAPI BOOL WINAPI
|
|
typedef struct {
|
|
HCRYPTPROV hProv;
|
|
CLoggingContext *pCtx;
|
|
} LogProvider;
|
|
|
|
CDynamicPointerArray<CLoggingContext> *g_prgCtxs = NULL;
|
|
|
|
|
|
/*
|
|
- CPAcquireContext
|
|
-
|
|
* Purpose:
|
|
* The CPAcquireContext function is used to acquire a context
|
|
* handle to a cryptograghic service provider (CSP).
|
|
*
|
|
*
|
|
* Parameters:
|
|
* OUT phProv - Handle to a CSP
|
|
* IN pszContainer - Pointer to a string of key container
|
|
* IN dwFlags - Flags values
|
|
* IN pVTable - Pointer to table of function pointers
|
|
*
|
|
* Returns:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPAcquireContext(
|
|
OUT HCRYPTPROV *phProv,
|
|
IN LPCTSTR pszContainer,
|
|
IN DWORD dwFlags,
|
|
IN PVTableProvStruc pVTable)
|
|
{
|
|
DWORD dwReturn;
|
|
DWORD dwIndex;
|
|
CLoggingContext *pTmpCtx;
|
|
CLoggingContext *pCtx = NULL;
|
|
LogProvider *pProv = NULL;
|
|
HINSTANCE hInst;
|
|
CRegistry regRoot;
|
|
LPCTSTR szImage;
|
|
|
|
|
|
//
|
|
// Make sure we're initialized.
|
|
//
|
|
|
|
entrypoint
|
|
if (NULL == g_prgCtxs)
|
|
{
|
|
g_prgCtxs = new CDynamicPointerArray<CLoggingContext>;
|
|
if (NULL == g_prgCtxs)
|
|
{
|
|
dwReturn = NTE_NO_MEMORY;
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Get the CSP image name.
|
|
//
|
|
|
|
switch (pVTable->Version)
|
|
{
|
|
|
|
//
|
|
// These cases are older versions of the operating systems that don't
|
|
// tell us which CSP is being loaded. Hence we need to pick up the
|
|
// information from a separate registry setting.
|
|
//
|
|
|
|
case 1:
|
|
case 2:
|
|
regRoot.Open(HKEY_LOCAL_MACHINE, g_szLogCspRegistry, KEY_READ);
|
|
if (ERROR_SUCCESS != regRoot.Status(TRUE))
|
|
{
|
|
dwReturn = ERROR_SERVICE_NOT_FOUND;
|
|
goto ErrorExit;
|
|
}
|
|
break;
|
|
|
|
|
|
//
|
|
// This must be at least a Win2k or Millennium system. We can see which
|
|
// CSP is being loaded, so we can do logging to different files for each
|
|
// CSP.
|
|
//
|
|
|
|
case 3:
|
|
if ((NULL == pVTable->pszProvName) || (0 == *pVTable->pszProvName))
|
|
{
|
|
regRoot.Open(HKEY_LOCAL_MACHINE, g_szLogCspRegistry, KEY_READ);
|
|
if (ERROR_SUCCESS != regRoot.Status(TRUE))
|
|
{
|
|
dwReturn = ERROR_SERVICE_NOT_FOUND;
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
CRegistry regCrypt(
|
|
HKEY_LOCAL_MACHINE,
|
|
g_szCspRegistry,
|
|
KEY_READ);
|
|
|
|
regRoot.Open(regCrypt, pVTable->pszProvName, KEY_READ);
|
|
regRoot.Status();
|
|
}
|
|
catch (...)
|
|
{
|
|
dwReturn = ERROR_SERVICE_NOT_FOUND;
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
//
|
|
// Either this file is out of date, or we've gotten onto a really old
|
|
// version of windows who's advapi is just supplying us with the address
|
|
// of the signature verification subroutine.
|
|
//
|
|
|
|
default:
|
|
if (1024 < pVTable->Version)
|
|
dwReturn = ERROR_OLD_WIN_VERSION;
|
|
else
|
|
dwReturn = ERROR_RMODE_APP;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
|
|
//
|
|
// regRoot now provides a handle to to a point in the registry from
|
|
// which we can read additional parameters. Get the name of dll to be
|
|
// loaded.
|
|
//
|
|
|
|
try
|
|
{
|
|
szImage = regRoot.GetStringValue(g_szSavedImagePath);
|
|
}
|
|
catch (...)
|
|
{
|
|
dwReturn = ERROR_SERVICE_NOT_FOUND;
|
|
// ?BUGBUG? Might also be Out of Memory.
|
|
goto ErrorExit;
|
|
}
|
|
|
|
|
|
//
|
|
// Is this CSP in our cache?
|
|
//
|
|
|
|
pTmpCtx = NULL;
|
|
hInst = GetModuleHandle(szImage);
|
|
if (NULL != hInst)
|
|
{
|
|
for (dwIndex = g_prgCtxs->Count(); 0 < dwIndex;)
|
|
{
|
|
pTmpCtx = (*g_prgCtxs)[--dwIndex];
|
|
if (NULL != pTmpCtx)
|
|
{
|
|
if (hInst == pTmpCtx->Module())
|
|
break;
|
|
else
|
|
pTmpCtx = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (NULL == pTmpCtx)
|
|
{
|
|
pCtx = new CLoggingContext();
|
|
if (NULL == pCtx)
|
|
{
|
|
dwReturn = NTE_NO_MEMORY;
|
|
goto ErrorExit;
|
|
}
|
|
for (dwIndex = 0; NULL != (*g_prgCtxs)[dwIndex]; dwIndex += 1)
|
|
; // Empty loop
|
|
g_prgCtxs->Set(dwIndex, pCtx);
|
|
pCtx->m_dwIndex = dwIndex;
|
|
dwReturn = pCtx->Initialize(pVTable, regRoot);
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
goto ErrorExit;
|
|
}
|
|
else
|
|
pCtx = pTmpCtx->AddRef();
|
|
pProv = new LogProvider;
|
|
if (NULL == pProv)
|
|
{
|
|
dwReturn = NTE_NO_MEMORY;
|
|
goto ErrorExit;
|
|
}
|
|
ZeroMemory(pProv, sizeof(LogProvider));
|
|
|
|
|
|
//
|
|
// Now we can really call the CSP.
|
|
//
|
|
|
|
dwReturn = pCtx->AcquireContext(
|
|
&pProv->hProv,
|
|
pszContainer,
|
|
dwFlags,
|
|
pVTable);
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
goto ErrorExit;
|
|
pProv->pCtx = pCtx;
|
|
pCtx = NULL;
|
|
*phProv = (HCRYPTPROV)pProv;
|
|
pProv = NULL;
|
|
return TRUE;
|
|
|
|
ErrorExit:
|
|
if (NULL != pCtx)
|
|
pCtx->Release();
|
|
if (NULL != pProv)
|
|
{
|
|
if (NULL != pProv->pCtx)
|
|
pProv->pCtx->Release();
|
|
delete pProv;
|
|
}
|
|
SetLastError(dwReturn);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPGetProvParam(
|
|
IN HCRYPTPROV hProv,
|
|
IN DWORD dwParam,
|
|
OUT BYTE *pbData,
|
|
IN OUT DWORD *pdwDataLen,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->GetProvParam(
|
|
pProv->hProv,
|
|
dwParam,
|
|
pbData,
|
|
pdwDataLen,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPReleaseContext(
|
|
IN HCRYPTPROV hProv,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->ReleaseContext(
|
|
pProv->hProv,
|
|
dwFlags);
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
{
|
|
pCtx->Release();
|
|
delete pProv;
|
|
fReturn = TRUE;
|
|
}
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPSetProvParam(
|
|
IN HCRYPTPROV hProv,
|
|
IN DWORD dwParam,
|
|
IN BYTE *pbData,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->SetProvParam(
|
|
pProv->hProv,
|
|
dwParam,
|
|
pbData,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPDeriveKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN ALG_ID Algid,
|
|
IN HCRYPTHASH hHash,
|
|
IN DWORD dwFlags,
|
|
OUT HCRYPTKEY * phKey)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->DeriveKey(
|
|
pProv->hProv,
|
|
Algid,
|
|
hHash,
|
|
dwFlags,
|
|
phKey);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPDestroyKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTKEY hKey)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->DestroyKey(
|
|
pProv->hProv,
|
|
hKey);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPExportKey(
|
|
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;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->ExportKey(
|
|
pProv->hProv,
|
|
hKey,
|
|
hPubKey,
|
|
dwBlobType,
|
|
dwFlags,
|
|
pbData,
|
|
pdwDataLen);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPGenKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN ALG_ID Algid,
|
|
IN DWORD dwFlags,
|
|
OUT HCRYPTKEY *phKey)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->GenKey(
|
|
pProv->hProv,
|
|
Algid,
|
|
dwFlags,
|
|
phKey);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPGetKeyParam(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTKEY hKey,
|
|
IN DWORD dwParam,
|
|
OUT BYTE *pbData,
|
|
IN OUT DWORD *pdwDataLen,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->GetKeyParam(
|
|
pProv->hProv,
|
|
hKey,
|
|
dwParam,
|
|
pbData,
|
|
pdwDataLen,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPGenRandom(
|
|
IN HCRYPTPROV hProv,
|
|
IN DWORD dwLen,
|
|
IN OUT BYTE *pbBuffer)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->GenRandom(
|
|
pProv->hProv,
|
|
dwLen,
|
|
pbBuffer);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPGetUserKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN DWORD dwKeySpec,
|
|
OUT HCRYPTKEY *phUserKey)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->GetUserKey(
|
|
pProv->hProv,
|
|
dwKeySpec,
|
|
phUserKey);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPImportKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN CONST BYTE *pbData,
|
|
IN DWORD dwDataLen,
|
|
IN HCRYPTKEY hPubKey,
|
|
IN DWORD dwFlags,
|
|
OUT HCRYPTKEY *phKey)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->ImportKey(
|
|
pProv->hProv,
|
|
pbData,
|
|
dwDataLen,
|
|
hPubKey,
|
|
dwFlags,
|
|
phKey);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPSetKeyParam(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTKEY hKey,
|
|
IN DWORD dwParam,
|
|
IN BYTE *pbData,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->SetKeyParam(
|
|
pProv->hProv,
|
|
hKey,
|
|
dwParam,
|
|
pbData,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPEncrypt(
|
|
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;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->Encrypt(
|
|
pProv->hProv,
|
|
hKey,
|
|
hHash,
|
|
Final,
|
|
dwFlags,
|
|
pbData,
|
|
pdwDataLen,
|
|
dwBufLen);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPDecrypt(
|
|
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;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->Decrypt(
|
|
pProv->hProv,
|
|
hKey,
|
|
hHash,
|
|
Final,
|
|
dwFlags,
|
|
pbData,
|
|
pdwDataLen);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPCreateHash(
|
|
IN HCRYPTPROV hProv,
|
|
IN ALG_ID Algid,
|
|
IN HCRYPTKEY hKey,
|
|
IN DWORD dwFlags,
|
|
OUT HCRYPTHASH *phHash)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->CreateHash(
|
|
pProv->hProv,
|
|
Algid,
|
|
hKey,
|
|
dwFlags,
|
|
phHash);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- CPDestoryHash
|
|
-
|
|
* Purpose:
|
|
* Destory the hash object
|
|
*
|
|
*
|
|
* Parameters:
|
|
* IN hProv - Handle to the user identifcation
|
|
* IN hHash - Handle to hash object
|
|
*
|
|
* Returns:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPDestroyHash(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTHASH hHash)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->DestroyHash(
|
|
pProv->hProv,
|
|
hHash);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPGetHashParam(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTHASH hHash,
|
|
IN DWORD dwParam,
|
|
OUT BYTE *pbData,
|
|
IN OUT DWORD *pdwDataLen,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->GetHashParam(
|
|
pProv->hProv,
|
|
hHash,
|
|
dwParam,
|
|
pbData,
|
|
pdwDataLen,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPHashData(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTHASH hHash,
|
|
IN CONST BYTE *pbData,
|
|
IN DWORD dwDataLen,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->HashData(
|
|
pProv->hProv,
|
|
hHash,
|
|
pbData,
|
|
dwDataLen,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPHashSessionKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTHASH hHash,
|
|
IN HCRYPTKEY hKey,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->HashSessionKey(
|
|
pProv->hProv,
|
|
hHash,
|
|
hKey,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPSetHashParam(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTHASH hHash,
|
|
IN DWORD dwParam,
|
|
IN BYTE *pbData,
|
|
IN DWORD dwFlags)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->SetHashParam(
|
|
pProv->hProv,
|
|
hHash,
|
|
dwParam,
|
|
pbData,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPSignHash(
|
|
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;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->SignHash(
|
|
pProv->hProv,
|
|
hHash,
|
|
dwKeySpec,
|
|
sDescription,
|
|
dwFlags,
|
|
pbSignature,
|
|
pdwSigLen);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
|
|
LOGCSPAPI
|
|
CPVerifySignature(
|
|
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;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->VerifySignature(
|
|
pProv->hProv,
|
|
hHash,
|
|
pbSignature,
|
|
dwSigLen,
|
|
hPubKey,
|
|
sDescription,
|
|
dwFlags);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
LOGCSPAPI
|
|
CPDuplicateHash(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTHASH hHash,
|
|
IN DWORD *pdwReserved,
|
|
IN DWORD dwFlags,
|
|
IN HCRYPTHASH *phHash)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->DuplicateHash(
|
|
pProv->hProv,
|
|
hHash,
|
|
pdwReserved,
|
|
dwFlags,
|
|
phHash);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
- 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:
|
|
*/
|
|
LOGCSPAPI
|
|
CPDuplicateKey(
|
|
IN HCRYPTPROV hProv,
|
|
IN HCRYPTKEY hKey,
|
|
IN DWORD *pdwReserved,
|
|
IN DWORD dwFlags,
|
|
IN HCRYPTKEY *phKey)
|
|
{
|
|
BOOL fReturn;
|
|
DWORD dwReturn;
|
|
LogProvider *pProv = (LogProvider *)hProv;
|
|
CLoggingContext *pCtx = pProv->pCtx;
|
|
|
|
entrypoint
|
|
dwReturn = pCtx->DuplicateKey(
|
|
pProv->hProv,
|
|
hKey,
|
|
pdwReserved,
|
|
dwFlags,
|
|
phKey);
|
|
|
|
if (ERROR_SUCCESS != dwReturn)
|
|
{
|
|
fReturn = FALSE;
|
|
SetLastError(dwReturn);
|
|
}
|
|
else
|
|
fReturn = TRUE;
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
DllMain:
|
|
|
|
This routine is called during DLL initialization. It collects any startup
|
|
and shutdown work that needs to be done. (Currently, none.)
|
|
|
|
Arguments:
|
|
|
|
hinstDLL - handle to the DLL module
|
|
fdwReason - reason for calling function
|
|
lpvReserved - reserved
|
|
|
|
Return Value:
|
|
|
|
?return-value?
|
|
|
|
Remarks:
|
|
|
|
?Remarks?
|
|
|
|
Author:
|
|
|
|
Doug Barlow (dbarlow) 4/9/2001
|
|
|
|
--*/
|
|
#undef __SUBROUTINE__
|
|
#define __SUBROUTINE__ TEXT("DllMain")
|
|
|
|
BOOL WINAPI
|
|
DllInitialize(
|
|
HINSTANCE hinstDLL,
|
|
DWORD fdwReason,
|
|
LPVOID lpvReserved)
|
|
{
|
|
BOOL fReturn = FALSE;
|
|
|
|
switch (fdwReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
fReturn = TRUE;
|
|
break;
|
|
default:
|
|
fReturn = TRUE;
|
|
}
|
|
|
|
return fReturn;
|
|
}
|
|
|