entrypoints.cpp

基于SD卡的软实现CSP程序

/*
	Call context.cpp to implement each API
*/

#include <windows.h>
#include <wincrypt.h>
#include "Context.h"

HINSTANCE g_hModule = NULL;

BOOL WINAPI DllMain(HANDLE hinstDLL, DWORD fdwReason, LPVOID lpData)
{
	return TRUE;
}
/////////////////////////////////
// Provider Functions


extern "C" BOOL WINAPI CPAcquireContext(
  HCRYPTPROV *phProv,       // out
  WCHAR *pszContainer,       // in, out
  DWORD dwFlags,            // in
  PVTableProvStruc pVTable  // in
)
{
	*phProv=NULL;

	const WCHAR * pszFinalContainerName;

    if (((dwFlags & CRYPT_VERIFYCONTEXT) == CRYPT_VERIFYCONTEXT) &&
        (NULL != pszContainer) && (0 != *pszContainer))

    {
        // should use NULL name with VERIFYCONTEXT
        SetLastError((DWORD) NTE_BAD_FLAGS);
        return FALSE;
    }
    
	if(!pszContainer || (0 == *pszContainer))
		pszFinalContainerName = WfSC_DEFAULT_CONTAINER;
	else
		pszFinalContainerName = pszContainer;

	CContext* pContext = new CContext();

	if(!pContext)
		return FALSE;

	if(!pContext->Initialize(pszFinalContainerName, dwFlags, pVTable))
	{
		delete pContext;
		return FALSE;
	}

	//We don't need to keep the context around if it's DELETEKEYSET
	if((dwFlags & CRYPT_DELETEKEYSET) == CRYPT_DELETEKEYSET)
		delete pContext;
	else
		*phProv = (HCRYPTPROV)pContext;

	return TRUE;
}

extern "C" BOOL WINAPI CPReleaseContext(
  HCRYPTPROV hProv,  // in
  DWORD dwFlags      // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}
	delete (CContext*)hProv;
	return TRUE;
}

extern "C" BOOL WINAPI CPGetProvParam(
  HCRYPTPROV hProv,  // in
  DWORD dwParam,     // in
  BYTE *pbData,      // out
  DWORD *pdwDataLen, // in, out
  DWORD dwFlags      // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->GetProvParam(dwParam, pbData, pdwDataLen, dwFlags);
}

extern "C" BOOL WINAPI CPSetProvParam(
  HCRYPTPROV hProv,  // in
  DWORD dwParam,     // in
  BYTE *pbData,      // in
  DWORD dwFlags      // in
)
{
	
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}
	return ((CContext*)hProv)->SetProvParam(dwParam, pbData, dwFlags);
}

/////////////////////////////////
// Hash Functions

extern "C" BOOL WINAPI CPCreateHash(
  HCRYPTPROV hProv,    // in
  ALG_ID Algid,        // in
  HCRYPTKEY hKey,      // in
  DWORD dwFlags,       // in
  HCRYPTHASH *phHash   // out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}
	
	return ((CContext*)hProv)->CreateHash(Algid, hKey, dwFlags, phHash);
}

extern "C" BOOL WINAPI CPDestroyHash(
  HCRYPTPROV hProv, // in
  HCRYPTHASH hHash  // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->DestroyHash(hHash);
}

extern "C" BOOL WINAPI CPGetHashParam(
  HCRYPTPROV hProv,        // in
  HCRYPTHASH hHash,        // in
  DWORD dwParam,           // in
  BYTE *pbData,            // out
  DWORD *pdwDataLen,       // in, out
  DWORD dwFlags            // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->GetHashParam(hHash, dwParam, pbData, pdwDataLen, dwFlags);
}

extern "C" BOOL WINAPI CPHashData(
  HCRYPTPROV hProv,       // in
  HCRYPTHASH hHash,       // in
  CONST BYTE *pbData,     // in
  DWORD dwDataLen,        // in
  DWORD dwFlags           // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->HashData(hHash, pbData, dwDataLen, dwFlags);
}

extern "C" BOOL WINAPI CPHashSessionKey(
  HCRYPTPROV hProv,      // in
  HCRYPTHASH hHash,      // in
  HCRYPTKEY hKey,        // in
  DWORD dwFlags          // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->HashSessionKey(hHash, hKey, dwFlags);
}

extern "C" BOOL WINAPI CPSetHashParam(
  HCRYPTPROV hProv,     // in
  HCRYPTHASH hHash,     // in
  DWORD dwParam,        // in
  BYTE *pbData,         // in
  DWORD dwFlags         // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->SetHashParam(hHash, dwParam, pbData, dwFlags);
}


/////////////////////////////////
// Encryption Functions
extern "C" BOOL WINAPI CPEncrypt(
  HCRYPTPROV hProv,       // in
  HCRYPTKEY hKey,         // in
  HCRYPTHASH hHash,       // in
  BOOL Final,             // in
  DWORD dwFlags,          // in
  BYTE *pbData,           // in, out
  DWORD *pdwDataLen,      // in, out
  DWORD dwBufLen          // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->Encrypt(hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
}

extern "C" BOOL WINAPI CPDecrypt(
  HCRYPTPROV hProv,      // in
  HCRYPTKEY hKey,        // in
  HCRYPTHASH hHash,      // in
  BOOL Final,            // in
  DWORD dwFlags,         // in
  BYTE *pbData,          // in, out
  DWORD *pdwDataLen      // in, out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->Decrypt(hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
}



/////////////////////////////////
// Signature Functions

extern "C" BOOL WINAPI CPSignHash(
  HCRYPTPROV hProv,           // in
  HCRYPTHASH hHash,           // in
  DWORD dwKeySpec,            // in
  LPCWSTR sDescription,       // in
  DWORD dwFlags,              // in
  BYTE *pbSignature,          // out
  DWORD *pdwSigLen            // in, out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->SignHash(hHash, dwKeySpec, sDescription, dwFlags, pbSignature, pdwSigLen);
}

extern "C" BOOL WINAPI CPVerifySignature(
  HCRYPTPROV hProv,         // in
  HCRYPTHASH hHash,         // in
  CONST BYTE *pbSignature,  // in
  DWORD dwSigLen,           // in
  HCRYPTKEY hPubKey,        // in
  LPCWSTR sDescription,     // in
  DWORD dwFlags             // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->VerifySignature(hHash, pbSignature, dwSigLen, hPubKey, sDescription, dwFlags);
}

/////////////////////////////////
// Key Functions

extern "C" BOOL WINAPI CPDeriveKey(
  HCRYPTPROV  hProv,        // in
  ALG_ID      Algid,        // in
  HCRYPTHASH  hBaseData,    // in
  DWORD       dwFlags,      // in
  HCRYPTKEY   *phKey        // out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->DeriveKey(Algid, hBaseData, dwFlags, phKey);
}

extern "C" BOOL WINAPI CPDestroyKey(
  HCRYPTPROV hProv,  // in
  HCRYPTKEY  hKey    // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->DestroyKey(hKey);
}

extern "C" BOOL WINAPI CPDuplicateKey(
  HCRYPTPROV hProv,     // in
  HCRYPTKEY hKey,      // in
  DWORD *pdwReserved,  // in
  DWORD dwFlags,       // in
  HCRYPTKEY *phKey     // out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->DuplicateKey(hKey, pdwReserved, dwFlags, phKey);
}

extern "C" BOOL WINAPI CPImportKey(
  HCRYPTPROV hProv,       // in
  BYTE *pbData,		      // in
  DWORD  dwDataLen,       // in
  HCRYPTKEY hPubKey,      // in
  DWORD dwFlags,          // in
  HCRYPTKEY *phKey        // out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->ImportKey(pbData, dwDataLen, hPubKey, dwFlags, phKey);
}

extern "C" BOOL WINAPI CPExportKey(
  HCRYPTPROV hProv,      // in
  HCRYPTKEY hKey,        // in
  HCRYPTKEY hPubKey,     // in
  DWORD dwBlobType,      // in
  DWORD dwFlags,         // in
  BYTE *pbData,          // out
  DWORD *pdwDataLen      // in, out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->ExportKey(hKey, hPubKey, dwBlobType, dwFlags, pbData, pdwDataLen);
}

extern "C" BOOL WINAPI CPGenKey(
  HCRYPTPROV hProv,     // in
  ALG_ID Algid,         // in
  DWORD dwFlags,        // in
  HCRYPTKEY *phKey     // out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->GenKey(Algid, dwFlags, phKey);
}

extern "C" BOOL WINAPI CPGetKeyParam(
  HCRYPTPROV hProv,       // in
  HCRYPTKEY hKey,         // in
  DWORD dwParam,          // in
  BYTE *pbData,           // out
  DWORD *pdwDataLen,      // in, out
  DWORD dwFlags           // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->GetKeyParam(hKey, dwParam, pbData, pdwDataLen, dwFlags);
}


extern "C" BOOL WINAPI CPSetKeyParam(
  HCRYPTPROV hProv,        // in
  HCRYPTKEY hKey,          // in
  DWORD dwParam,           // in
  BYTE *pbData,            // in
  DWORD dwFlags            // in
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->SetKeyParam(hKey, dwParam, pbData, dwFlags);
}

extern "C" BOOL WINAPI CPGetUserKey(
  HCRYPTPROV hProv,       // in
  DWORD dwKeySpec,        // in
  HCRYPTKEY *phUserKey    // out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->GetUserKey(dwKeySpec, phUserKey);
}

// Misc Functions
extern "C" BOOL WINAPI CPGenRandom(
  HCRYPTPROV hProv,  // in
  DWORD dwLen,       // in
  BYTE *pbBuffer     // in, out
)
{
	//If the context is invalid, return false...
	if(!CContext::VerifyContext((CContext*)hProv))
	{
		SetLastError(NTE_BAD_UID);
		return FALSE;
	}

	return ((CContext*)hProv)->GenRandom(dwLen, pbBuffer);
}