1011 lines
30 KiB
C++
1011 lines
30 KiB
C++
/****************************************************************************/
|
|
/* capienc.cpp */
|
|
/* */
|
|
/* FIPS encrpt/decrypt */
|
|
/* */
|
|
/* Copyright (C) 2002-2004 Microsoft Corporation */
|
|
/****************************************************************************/
|
|
|
|
|
|
|
|
#include <adcg.h>
|
|
|
|
extern "C" {
|
|
#define TRC_GROUP TRC_GROUP_CORE
|
|
#define TRC_FILE "capienc"
|
|
#include <atrcapi.h>
|
|
}
|
|
|
|
#include "capienc.h"
|
|
#include "sl.h"
|
|
|
|
#define TERMSRV_NAME L"terminal_server_client"
|
|
|
|
const BYTE DESParityTable[] = {0x00,0x01,0x01,0x02,0x01,0x02,0x02,0x03,
|
|
0x01,0x02,0x02,0x03,0x02,0x03,0x03,0x04};
|
|
// IV for all block ciphers
|
|
BYTE rgbIV[] = {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
|
|
|
|
|
|
//
|
|
// Name: PrintData
|
|
//
|
|
// Purpose: Print out the data in debugger
|
|
//
|
|
// Returns: No
|
|
//
|
|
// Params: IN pKeyData: point to the data to be printed
|
|
// IN cbSize: the size of the key
|
|
|
|
void PrintData(BYTE *pKeyData, DWORD cbSize)
|
|
{
|
|
DWORD dwIndex;
|
|
TCHAR Buffer[128];
|
|
|
|
for( dwIndex = 0; dwIndex<cbSize; dwIndex++ ) {
|
|
|
|
StringCchPrintf(Buffer, 128, TEXT("0x%x "), pKeyData[dwIndex]);
|
|
OutputDebugString(Buffer);
|
|
if( dwIndex > 0 && (dwIndex+1) % 8 == 0 )
|
|
OutputDebugString((TEXT("\n")));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Name: Is_WinXP_or_Later
|
|
//
|
|
// Purpose: Tell if the OS is WinXP or later
|
|
//
|
|
// Returns: TRUE if it's WinXP or later
|
|
//
|
|
// Params: No
|
|
|
|
BOOL Is_WinXP_or_Later ()
|
|
{
|
|
OSVERSIONINFO osvi;
|
|
BOOL bIsWinXPorLater = FALSE;
|
|
|
|
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
|
|
|
|
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
if (GetVersionEx(&osvi)) {
|
|
bIsWinXPorLater = ((osvi.dwMajorVersion >= 5) && (osvi.dwMinorVersion >= 1));
|
|
}
|
|
return bIsWinXPorLater;
|
|
}
|
|
|
|
|
|
//
|
|
// Name: Mydesparityonkey
|
|
//
|
|
// Purpose: Set the parity on the DES key to be odd
|
|
//
|
|
// Returns: No
|
|
//
|
|
// Params: IN/OUT pbKey: point to the key
|
|
// IN cbKey: the size of the key
|
|
|
|
void Mydesparityonkey(
|
|
BYTE *pbKey,
|
|
DWORD cbKey
|
|
)
|
|
{
|
|
DWORD i;
|
|
|
|
for (i=0;i<cbKey;i++)
|
|
{
|
|
if (!((DESParityTable[pbKey[i]>>4] + DESParityTable[pbKey[i]&0x0F]) % 2))
|
|
pbKey[i] = pbKey[i] ^ 0x01;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Name: Expandkey
|
|
//
|
|
// Purpose: Expand a 21-byte 3DES key to a 24-byte 3DES key (including parity bit)
|
|
// by inserting a parity bit after every 7 bits in the 21-byte DES
|
|
//
|
|
// Returns: No
|
|
//
|
|
// Params: IN/OUT pbKey: point to the key
|
|
//
|
|
|
|
#define PARITY_UNIT 7
|
|
void Expandkey(
|
|
BYTE *pbKey
|
|
)
|
|
{
|
|
BYTE pbTemp[DES3_KEYLEN];
|
|
DWORD i, dwCount;
|
|
UINT16 shortTemp;
|
|
BYTE *pbIn, *pbOut;
|
|
|
|
memcpy(pbTemp, pbKey, sizeof(pbTemp));
|
|
dwCount = (DES3_KEYLEN * 8) / PARITY_UNIT;
|
|
|
|
pbOut = pbKey;
|
|
for (i=0; i<dwCount; i++) {
|
|
pbIn = ((pbTemp + (PARITY_UNIT * i) / 8));
|
|
//shortTemp = *(pbIn + 1);
|
|
shortTemp = *pbIn + (((UINT16)*(pbIn + 1)) << 8);
|
|
shortTemp = shortTemp >> ((PARITY_UNIT * i) % 8);
|
|
//shortTemp = (*(unsigned short *)((pbTemp + (PARITY_UNIT * i) / 8))) >> ((PARITY_UNIT * i) % 8);
|
|
*pbOut = (BYTE)(shortTemp & 0x7F);
|
|
pbOut++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Name: HashData
|
|
//
|
|
// Purpose: Hash the data using SHA.
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiFunctionTable: CAPI function table
|
|
// IN hProv: Handle of the cript provider
|
|
// IN pbData: point to the data to be hashed
|
|
// IN dwDataLen: the size of the data to be hashed
|
|
// OUT phHash: point to the hash
|
|
|
|
BOOL HashData(PCAPI_FUNCTION_TABLE pCapiFunctionTable, HCRYPTPROV hProv, PBYTE pbData, DWORD dwDataLen, HCRYPTHASH* phHash)
|
|
{
|
|
BOOL rc = FALSE;
|
|
|
|
DC_BEGIN_FN("HashData");
|
|
|
|
//
|
|
// Create a hash object.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptCreateHash(hProv, CALG_SHA1, 0, 0, phHash)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptCreateHash!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
// Hash in the data.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptHashData(*phHash, pbData, dwDataLen, 0)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptHashData!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
// Name: HashDataEx
|
|
//
|
|
// Purpose: Hash 2 set of data using SHA.
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiFunctionTable: CAPI function table
|
|
// IN hProv: Handle of the cript provider
|
|
// IN pbData: point to the data to be hashed
|
|
// IN dwDataLen: the size of the data to be hashed
|
|
// IN pbData2: point to the data to be hashed
|
|
// IN dwDataLen2: the size of the data to be hashed
|
|
// OUT phHash: point to the hash
|
|
|
|
BOOL HashDataEx(PCAPI_FUNCTION_TABLE pCapiFunctionTable, HCRYPTPROV hProv, PBYTE pbData, DWORD dwDataLen,
|
|
PBYTE pbData2, DWORD dwDataLen2, HCRYPTHASH* phHash)
|
|
{
|
|
BOOL rc = FALSE;
|
|
|
|
DC_BEGIN_FN("HashDataEx");
|
|
|
|
//
|
|
// Create a hash object.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptCreateHash(hProv, CALG_SHA1, 0, 0, phHash)) {
|
|
printf("Error %x during CryptCreateHash!\n", GetLastError());
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
// Hash in the data.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptHashData(*phHash, pbData, dwDataLen, 0)) {
|
|
printf("Error %x during CryptHashData!\n", GetLastError());
|
|
goto done;
|
|
}
|
|
if(!pCapiFunctionTable->pfnCryptHashData(*phHash, pbData2, dwDataLen2, 0)) {
|
|
printf("Error %x during CryptHashData!\n", GetLastError());
|
|
goto done;
|
|
}
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
// Name: HmacHashData
|
|
//
|
|
// Purpose: Hash the data using HmacSHA.
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiFunctionTable: CAPI function table
|
|
// IN hProv: Handle of the cript provider
|
|
// IN pbData: point to the data to be hashed
|
|
// IN dwDataLen: the size of the data to be hashed
|
|
// IN hKey: handle to the key
|
|
// OUT phHash: point to the hash
|
|
|
|
BOOL HmacHashData(PCAPI_FUNCTION_TABLE pCapiFunctionTable, HCRYPTPROV hProv, PBYTE pbData, DWORD dwDataLen,
|
|
HCRYPTKEY hKey, HCRYPTHASH* phHash)
|
|
{
|
|
BOOL rc = FALSE;
|
|
BYTE bmacinfo[sizeof(HMAC_INFO)];
|
|
HMAC_INFO* pmac;
|
|
memset(bmacinfo, 0, sizeof(bmacinfo));
|
|
|
|
pmac = (HMAC_INFO*)bmacinfo;
|
|
pmac->HashAlgid = CALG_SHA1;
|
|
|
|
DC_BEGIN_FN("HmacHashData");
|
|
|
|
//
|
|
// Create a hash object.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptCreateHash(hProv, CALG_HMAC, hKey, 0, phHash)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptCreateHash!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
rc = pCapiFunctionTable->pfnCryptSetHashParam(*phHash, HP_HMAC_INFO, bmacinfo, 0);
|
|
|
|
//
|
|
// Hash in the data.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptHashData(*phHash, pbData, dwDataLen, 0)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptHashData!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
// Name: HmacHashDataEx
|
|
//
|
|
// Purpose: Hash 2 set of data using HmacSHA.
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiFunctionTable: CAPI function table
|
|
// IN hProv: Handle of the cript provider
|
|
// IN pbData: point to the data to be hashed
|
|
// IN dwDataLen: the size of the data to be hashed
|
|
// IN pbData2: point to the data to be hashed
|
|
// IN dwDataLen2: the size of the data to be hashed
|
|
// IN hKey: handle to the key
|
|
// OUT phHash: point to the hash
|
|
|
|
BOOL HmacHashDataEx(PCAPI_FUNCTION_TABLE pCapiFunctionTable, HCRYPTPROV hProv, PBYTE pbData, DWORD dwDataLen,
|
|
PBYTE pbData2, DWORD dwDataLen2, HCRYPTKEY hKey, HCRYPTHASH* phHash)
|
|
{
|
|
BOOL rc = FALSE;
|
|
BYTE bmacinfo[sizeof(HMAC_INFO)];
|
|
HMAC_INFO* pmac;
|
|
memset(bmacinfo, 0, sizeof(bmacinfo));
|
|
|
|
pmac = (HMAC_INFO*)bmacinfo;
|
|
pmac->HashAlgid = CALG_SHA1;
|
|
|
|
DC_BEGIN_FN("HmacHashDataEx");
|
|
|
|
//
|
|
// Create a hash object.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptCreateHash(hProv, CALG_HMAC, hKey, 0, phHash)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptCreateHash!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
rc = pCapiFunctionTable->pfnCryptSetHashParam(*phHash, HP_HMAC_INFO, bmacinfo, 0);
|
|
|
|
//
|
|
// Hash in the data.
|
|
//
|
|
if(!pCapiFunctionTable->pfnCryptHashData(*phHash, pbData, dwDataLen, 0)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptHashData!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
if(!pCapiFunctionTable->pfnCryptHashData(*phHash, pbData2, dwDataLen2, 0)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptHashData!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Name: DumpHashes
|
|
//
|
|
// Purpose: Get the hash bits from hash handle
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiFunctionTable: CAPI function table
|
|
// IN phHash: point to hash handle
|
|
// OUT pbBytes: point data buffer to get hash
|
|
// IN dwTotal: len of the data buffer
|
|
|
|
BOOL DumpHashes(PCAPI_FUNCTION_TABLE pCapiFunctionTable, HCRYPTHASH* phHash, PBYTE pbBytes, DWORD dwTotal)
|
|
{
|
|
BOOL rc = FALSE;
|
|
|
|
DC_BEGIN_FN("DumpHashes");
|
|
|
|
if (!pCapiFunctionTable->pfnCryptGetHashParam(*phHash, HP_HASHVAL, pbBytes, &dwTotal , 0)) {
|
|
TRC_ERR((TB, _T("Error %x during CryptGetHashParam!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
//destroy the hash, we don't need it anymore
|
|
//
|
|
if(*phHash) {
|
|
pCapiFunctionTable->pfnCryptDestroyHash(*phHash);
|
|
*phHash = 0;
|
|
}
|
|
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
// Name: TSCAPI_Init
|
|
//
|
|
// Purpose: Initialize the CAPI function table.
|
|
//
|
|
// Returns: TRUE - succeeded
|
|
// FALSE - failed
|
|
//
|
|
// Params: IN pCapiData: CAPI data
|
|
|
|
BOOL TSCAPI_Init(PCAPIData pCapiData)
|
|
{
|
|
BOOL rc = FALSE;
|
|
|
|
// FIPS is only available on WinXP and later
|
|
if (!Is_WinXP_or_Later()) {
|
|
goto done;
|
|
}
|
|
|
|
pCapiData->hAdvapi32 = LoadLibrary(L"advapi32.dll");
|
|
|
|
if (pCapiData->hAdvapi32 == NULL) {
|
|
goto done;
|
|
}
|
|
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptAcquireContext = (CRYPTACQUIRECONTEXT *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptAcquireContextW")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptReleaseContext = (CRYPTRELEASECONTEXT *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptReleaseContext")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptGenRandom = (CRYPTGENRANDOM *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptGenRandom")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptEncrypt = (CRYPTENCRYPT *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptEncrypt")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptDecrypt = (CRYPTDECRYPT *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptDecrypt")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptImportKey = (CRYPTIMPORTKEY *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptImportKey")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptSetKeyParam = (CRYPTSETKEYPARAM *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptSetKeyParam")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptDestroyKey = (CRYPTDESTROYKEY *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptDestroyKey")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptCreateHash = (CRYPTCREATEHASH *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptCreateHash")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptHashData = (CRYPTHASHDATA *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptHashData")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptSetHashParam = (CRYPTSETHASHPARAM *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptSetHashParam")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptGetHashParam = (CRYPTGETHASHPARAM *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptGetHashParam")) == NULL) {
|
|
goto done;
|
|
}
|
|
if ((pCapiData->CapiFunctionTable.pfnCryptDestroyHash = (CRYPTDESTROYHASH *)GetProcAddress(
|
|
pCapiData->hAdvapi32, "CryptDestroyHash")) == NULL) {
|
|
goto done;
|
|
}
|
|
|
|
|
|
rc = TRUE;
|
|
done:
|
|
return rc;
|
|
}
|
|
|
|
|
|
// Name: TSCAPI_Enable
|
|
//
|
|
// Purpose: Some CAPI initialization
|
|
//
|
|
// Returns: TRUE - succeeded
|
|
// FALSE - failed
|
|
//
|
|
// Params: IN pCapiData: CAPI data
|
|
|
|
BOOL TSCAPI_Enable(PCAPIData pCapiData)
|
|
{
|
|
BOOL rc = FALSE;
|
|
DWORD Error;
|
|
DWORD dwExtraFlags = 0;
|
|
HRESULT hr;
|
|
|
|
DC_BEGIN_FN("TSCAPI_Enable");
|
|
|
|
// Get handle to the default provider.
|
|
if(!pCapiData->CapiFunctionTable.pfnCryptAcquireContext(&(pCapiData->hProv),
|
|
TERMSRV_NAME, MS_ENHANCED_PROV, PROV_RSA_FULL, dwExtraFlags)) {
|
|
|
|
// Could not acquire a crypt context, get the reason of failure
|
|
Error = GetLastError();
|
|
hr = HRESULT_FROM_WIN32(Error);
|
|
|
|
if (hr == NTE_BAD_KEYSET) {
|
|
//
|
|
//create a new keyset
|
|
//
|
|
if(!pCapiData->CapiFunctionTable.pfnCryptAcquireContext(&(pCapiData->hProv), TERMSRV_NAME,
|
|
MS_ENHANCED_PROV, PROV_RSA_FULL, dwExtraFlags | CRYPT_NEWKEYSET)) {
|
|
Error = GetLastError();
|
|
TRC_ERR((TB, _T("Error %x during CryptAcquireContext!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
}
|
|
else {
|
|
goto done;
|
|
}
|
|
}
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
// Name: TSCAPI_Term
|
|
//
|
|
// Purpose: Terminate the CAPI .
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
//
|
|
// Params: IN pCapiData: CAPI data
|
|
|
|
BOOL TSCAPI_Term(PCAPIData pCapiData)
|
|
{
|
|
BOOL rc = TRUE;
|
|
|
|
DC_BEGIN_FN("TSCAPI_Enable");
|
|
|
|
if (pCapiData->hEncKey) {
|
|
rc = pCapiData->CapiFunctionTable.pfnCryptDestroyKey(pCapiData->hEncKey);
|
|
pCapiData->hEncKey = NULL;
|
|
}
|
|
|
|
if (pCapiData->hDecKey) {
|
|
rc = pCapiData->CapiFunctionTable.pfnCryptDestroyKey(pCapiData->hDecKey);
|
|
pCapiData->hDecKey = NULL;
|
|
}
|
|
|
|
if (pCapiData->hProv) {
|
|
rc = pCapiData->CapiFunctionTable.pfnCryptReleaseContext(pCapiData->hProv, 0);
|
|
pCapiData->hProv = NULL;
|
|
}
|
|
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
// Name: TSCAPI_GenerateRandomNumber
|
|
//
|
|
// Purpose: Generates random number using CAPI in user mode
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
//
|
|
// Params: IN pCapiData: CAPI data
|
|
// OUT pbRandomBits: pointer to a buffer where a random key is returned.
|
|
// IN cbLen: length of the random key required.
|
|
|
|
BOOL TSCAPI_GenerateRandomNumber(
|
|
PCAPIData pCapiData,
|
|
LPBYTE pbRandomBits,
|
|
DWORD cbLen)
|
|
{
|
|
BOOL rc = FALSE;
|
|
|
|
DC_BEGIN_FN("TSCAPI_GenerateRandomNumber");
|
|
|
|
if (pCapiData->CapiFunctionTable.pfnCryptGenRandom(pCapiData->hProv, cbLen, pbRandomBits)) {
|
|
rc = TRUE;
|
|
}
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Name: ImportKey
|
|
//
|
|
// Purpose: Import the key in bits to crypt provider
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
//
|
|
// Params: IN pCapiData: CAPI data
|
|
// IN hProv: handle to the crypt provider
|
|
// IN Algid: Algorithm identifier
|
|
// IN pbKey: point to the buffer contain the key bits
|
|
// IN dwKeyLen: length of the key.
|
|
// IN dwFlags: dwFlags used in CryptImportKey
|
|
// OUT phKey: point to the key handle
|
|
|
|
BOOL ImportKey(PCAPI_FUNCTION_TABLE pCapiFunctionTable, HCRYPTPROV hProv, ALG_ID Algid, PBYTE pbKey, DWORD dwKeyLen, DWORD dwFlags, HCRYPTKEY* phKey)
|
|
{
|
|
BOOL rc = FALSE;
|
|
PBYTE pbData = NULL;
|
|
DWORD cbLen = 0;
|
|
DWORD Error;
|
|
//
|
|
//create blob header first
|
|
//
|
|
BLOBHEADER blobHead;
|
|
blobHead.bType = PLAINTEXTKEYBLOB;
|
|
blobHead.bVersion = 2;
|
|
blobHead.reserved = 0;
|
|
blobHead.aiKeyAlg = Algid;
|
|
|
|
DC_BEGIN_FN("ImportKey");
|
|
|
|
//
|
|
//calculate the length
|
|
//
|
|
cbLen = sizeof(blobHead) + sizeof(dwKeyLen) + dwKeyLen;
|
|
|
|
pbData = (PBYTE)LocalAlloc(LPTR, cbLen);
|
|
|
|
if(NULL == pbData) {
|
|
TRC_ERR((TB, _T("Out of memory\n")));
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
//copy data. First data must be header, then the size of the key, then the key
|
|
//
|
|
memcpy( pbData, &blobHead, sizeof(blobHead));
|
|
memcpy( pbData + sizeof(blobHead), &dwKeyLen, sizeof(dwKeyLen));
|
|
memcpy( pbData + sizeof(blobHead) + sizeof(dwKeyLen), pbKey, dwKeyLen);
|
|
|
|
if( !pCapiFunctionTable->pfnCryptImportKey( hProv, pbData, cbLen, 0, dwFlags, phKey)) {
|
|
Error = GetLastError();
|
|
TRC_ERR((TB, _T("Failed to import plaint text key Error = 0x%x\n"), Error));
|
|
*phKey = 0;
|
|
goto done;
|
|
}
|
|
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
if(pbData) {
|
|
LocalFree(pbData);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Name: TSCAPI_DeriveKey
|
|
//
|
|
// Purpose: Derive the key from the hash.
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiFunctionTable: CAPI function table
|
|
// IN hProv: crypt provider handle
|
|
// OUT phKey: point to key handle
|
|
// IN rgbSHABase: base data used to derive the key
|
|
// IN cbSHABase: size of the base data
|
|
// OUT pbKey: point to the derived DESkey
|
|
// OUT pdwKeyLen: point to the key length
|
|
|
|
BOOL TSCAPI_DeriveKey(
|
|
PCAPI_FUNCTION_TABLE pCapiFunctionTable,
|
|
HCRYPTPROV hProv,
|
|
HCRYPTKEY *phKey,
|
|
BYTE *rgbSHABase,
|
|
DWORD cbSHABase,
|
|
BYTE *pbKey,
|
|
DWORD *pdwKeyLen)
|
|
{
|
|
BOOL rc = FALSE;
|
|
BOOL fRet = FALSE;
|
|
BYTE rgb3DESKey[MAX_FIPS_SESSION_KEY_SIZE];
|
|
|
|
DC_BEGIN_FN("TSCAPI_DeriveKey");
|
|
|
|
//
|
|
//Generate the key as follows
|
|
//1. Hash the secret. Call the result H1 (rgbSHABase in our case)
|
|
//2. Use 1st 21 bytes of [H1|H1] as the 3DES key
|
|
//3. Expand the 21-byte 3DES key to a 24-byte 3DES key (including parity bit), which
|
|
// will be used by CryptAPI
|
|
//4. Set the parity on the 3DES key to be odd
|
|
|
|
//
|
|
//Step 2 - [H1|H1]
|
|
//
|
|
|
|
memcpy(rgb3DESKey, rgbSHABase, cbSHABase);
|
|
memcpy(rgb3DESKey + cbSHABase, rgbSHABase, DES3_KEYLEN - cbSHABase);
|
|
|
|
//
|
|
//Step 3 - Expand the key
|
|
//
|
|
|
|
Expandkey(rgb3DESKey);
|
|
|
|
//
|
|
//Step 4 - Set parity
|
|
//
|
|
|
|
Mydesparityonkey(rgb3DESKey, sizeof(rgb3DESKey));
|
|
|
|
//
|
|
//import the key as PLAINTEXT into the csp
|
|
//
|
|
rc = ImportKey(pCapiFunctionTable, hProv, CALG_3DES, rgb3DESKey, sizeof(rgb3DESKey), 0, phKey);
|
|
if (!rc) {
|
|
goto done;
|
|
}
|
|
|
|
//give the key to the caller
|
|
//
|
|
memcpy(pbKey, rgb3DESKey, sizeof(rgb3DESKey));
|
|
*pdwKeyLen = sizeof(rgb3DESKey);
|
|
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
// Name: TSCAPI_MakeSessionKeys
|
|
//
|
|
// Purpose: Make the key from client/server random numbers
|
|
//
|
|
// Returns: TRUE if succeeded
|
|
//
|
|
// Params: IN pCapiData: CAPI Data
|
|
// IN pKeyPair: Randow numbers used to generate key
|
|
// IN pEnumMethod: To generate Encrypt or Decrypt key, If NULL, both keys
|
|
|
|
BOOL TSCAPI_MakeSessionKeys(
|
|
PCAPIData pCapiData,
|
|
RANDOM_KEYS_PAIR *pKeyPair,
|
|
CryptMethod *pEnumMethod)
|
|
{
|
|
BOOL rc = FALSE;
|
|
HCRYPTHASH hHash;
|
|
DWORD dwKeyLen;
|
|
BYTE rgbSHABase1[A_SHA_DIGEST_LEN];
|
|
BYTE rgbSHABase2[A_SHA_DIGEST_LEN];
|
|
|
|
DC_BEGIN_FN("TSCAPI_MakeSessionKeys");
|
|
|
|
memset(rgbSHABase1, 0, sizeof(rgbSHABase1));
|
|
memset(rgbSHABase2, 0, sizeof(rgbSHABase2));
|
|
|
|
//
|
|
// Client Encrypt/Server Decrypt key
|
|
//
|
|
if ((pEnumMethod == NULL) ||
|
|
(*pEnumMethod == Encrypt)) {
|
|
if (!pCapiData->CapiFunctionTable.pfnCryptCreateHash(pCapiData->hProv, CALG_SHA1, 0, 0, &hHash)) {
|
|
TRC_ERR((TB, _T("CryptCreateHash failed with %u"), GetLastError()));
|
|
goto done;
|
|
}
|
|
if (!pCapiData->CapiFunctionTable.pfnCryptHashData(hHash, pKeyPair->clientRandom + RANDOM_KEY_LENGTH/2, RANDOM_KEY_LENGTH/2, 0)) {
|
|
TRC_ERR((TB, _T("CryptHashData failed with %u"), GetLastError()));
|
|
goto done;
|
|
}
|
|
if (!pCapiData->CapiFunctionTable.pfnCryptHashData(hHash, pKeyPair->serverRandom + RANDOM_KEY_LENGTH/2, RANDOM_KEY_LENGTH/2, 0)) {
|
|
TRC_ERR((TB, _T("CryptHashData failed with %u"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
if (!DumpHashes(&(pCapiData->CapiFunctionTable), &hHash, rgbSHABase1, sizeof(rgbSHABase1))) {
|
|
goto done;
|
|
}
|
|
dwKeyLen = sizeof(pCapiData->bEncKey);
|
|
if (!TSCAPI_DeriveKey(&(pCapiData->CapiFunctionTable), pCapiData->hProv, &(pCapiData->hEncKey), rgbSHABase1,
|
|
sizeof(rgbSHABase1), pCapiData->bEncKey, &dwKeyLen)) {
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
//set the IV
|
|
//
|
|
if(!pCapiData->CapiFunctionTable.pfnCryptSetKeyParam(pCapiData->hEncKey, KP_IV, rgbIV, 0 )) {
|
|
TRC_ERR((TB, _T("Error %x during CryptSetKeyParam!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Server Encrypt/Client Decrypt key
|
|
//
|
|
if ((pEnumMethod == NULL) ||
|
|
(*pEnumMethod == Decrypt)) {
|
|
if (!pCapiData->CapiFunctionTable.pfnCryptCreateHash(pCapiData->hProv, CALG_SHA1, 0, 0, &hHash)) {
|
|
TRC_ERR((TB, _T("CryptCreateHash failed with %u"), GetLastError()));
|
|
goto done;
|
|
}
|
|
if (!pCapiData->CapiFunctionTable.pfnCryptHashData(hHash, pKeyPair->clientRandom, RANDOM_KEY_LENGTH/2, 0)) {
|
|
TRC_ERR((TB, _T("CryptHashData failed with %u"), GetLastError()));
|
|
goto done;
|
|
}
|
|
if (!pCapiData->CapiFunctionTable.pfnCryptHashData(hHash, pKeyPair->serverRandom, RANDOM_KEY_LENGTH/2, 0)) {
|
|
TRC_ERR((TB, _T("CryptHashData failed with %u"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
if (!DumpHashes(&(pCapiData->CapiFunctionTable), &hHash, rgbSHABase2, sizeof(rgbSHABase2))) {
|
|
goto done;
|
|
}
|
|
dwKeyLen = sizeof(pCapiData->bDecKey);
|
|
if (!TSCAPI_DeriveKey(&(pCapiData->CapiFunctionTable), pCapiData->hProv, &(pCapiData->hDecKey), rgbSHABase2,
|
|
sizeof(rgbSHABase2), pCapiData->bDecKey, &dwKeyLen)) {
|
|
goto done;
|
|
}
|
|
|
|
//
|
|
//set the IV
|
|
//
|
|
if(!pCapiData->CapiFunctionTable.pfnCryptSetKeyParam(pCapiData->hDecKey, KP_IV, rgbIV, 0 )) {
|
|
TRC_ERR((TB, _T("Error %x during CryptSetKeyParam!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get the signing key
|
|
// The signing key is SHA(rgbSHABase2|rgbSHABase1)
|
|
//
|
|
if (pEnumMethod == NULL) {
|
|
if (!HashDataEx(&(pCapiData->CapiFunctionTable), pCapiData->hProv, rgbSHABase2, sizeof(rgbSHABase2),
|
|
rgbSHABase1, sizeof(rgbSHABase1), &hHash)) {
|
|
goto done;
|
|
}
|
|
if (!DumpHashes(&(pCapiData->CapiFunctionTable), &hHash, pCapiData->bSignKey, sizeof(pCapiData->bSignKey))) {
|
|
goto done;
|
|
}
|
|
rc = ImportKey(&(pCapiData->CapiFunctionTable), pCapiData->hProv, CALG_RC2, pCapiData->bSignKey, sizeof(pCapiData->bSignKey), CRYPT_IPSEC_HMAC_KEY, &(pCapiData->hSignKey));
|
|
if (!rc) {
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Name: TSCAPI_AdjustDataLen
|
|
//
|
|
// Purpose: In Block encryption mode, adjust the data len to multiple of blocks
|
|
//
|
|
// Returns: Adjusted data length
|
|
//
|
|
// Params: IN dataLen: Data length needed to be encrypted
|
|
|
|
DCUINT TSCAPI_AdjustDataLen(DCUINT dataLen)
|
|
{
|
|
return (dataLen - dataLen % FIPS_BLOCK_LEN + FIPS_BLOCK_LEN);
|
|
}
|
|
|
|
|
|
|
|
// Name: TSCAPI_EncryptData
|
|
//
|
|
// Purpose: Encrypt the data and compute the signature
|
|
//
|
|
// Returns: No
|
|
//
|
|
// Params: IN pCapiData: CAPI Data
|
|
// IN/OUT pbData: pointer to the data buffer being encrypted, encrypted data is
|
|
// returned in the same buffer.
|
|
// IN/OUT pdwDataLen: data length to be encrypted, and returns encrypted data length
|
|
// IN dwPadLen: padding length in the data buffer
|
|
// OUT pbSignature: pointer to a signature buffer where the data signature is returned.
|
|
// IN dwEncryptionCount: running counter of all encryptions
|
|
|
|
BOOL TSCAPI_EncryptData(
|
|
PCAPIData pCapiData,
|
|
LPBYTE pbData,
|
|
DWORD *pdwDataLen,
|
|
DWORD dwBufLen,
|
|
LPBYTE pbSignature,
|
|
DWORD dwEncryptionCount)
|
|
{
|
|
BOOL rc = FALSE;
|
|
DWORD Error;
|
|
HCRYPTHASH hHash;
|
|
BYTE rgbSHA[A_SHA_DIGEST_LEN];
|
|
BYTE pbHmac[A_SHA_DIGEST_LEN];
|
|
DWORD dwTemp = dwBufLen;
|
|
|
|
DC_BEGIN_FN("TSCAPI_EncryptData");
|
|
|
|
// Compute signature
|
|
if (!HmacHashDataEx(&(pCapiData->CapiFunctionTable), pCapiData->hProv, pbData, *pdwDataLen, (BYTE *)&dwEncryptionCount,
|
|
sizeof(dwEncryptionCount), pCapiData->hSignKey, &hHash)) {
|
|
goto done;
|
|
}
|
|
|
|
if (!DumpHashes(&(pCapiData->CapiFunctionTable), &hHash, pbHmac, sizeof(pbHmac))) {
|
|
goto done;
|
|
}
|
|
// Take the 1st 8 bytes of Hmac as signature
|
|
memcpy(pbSignature, pbHmac, MAX_SIGN_SIZE);
|
|
|
|
rc = pCapiData->CapiFunctionTable.pfnCryptEncrypt(pCapiData->hEncKey,
|
|
NULL, //Hash
|
|
FALSE, //Final
|
|
0,
|
|
pbData,
|
|
&dwTemp,
|
|
dwBufLen);
|
|
|
|
if (!rc) {
|
|
TRC_ERR((TB, _T("Error %x during CryptEncrypt!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
rc = TRUE;
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
// Name: TSCAPI_DecryptData
|
|
//
|
|
// Purpose: Decrypt the data and compare the signature
|
|
//
|
|
// Returns: TRUE if successfully decrypted the data
|
|
//
|
|
// Params: IN PCAPIData: CAPI Data
|
|
// IN/OUT pbData: pointer to the data buffer being decrypted, decrypted data is
|
|
// returned in the same buffer.
|
|
// IN dwDataLen: data length to be decrypted
|
|
// IN dwPadLen: padding length in the data buffer
|
|
// IN pbSignature: pointer to a signature buffer
|
|
// IN dwDecryptionCount: running counter of all encryptions
|
|
|
|
BOOL TSCAPI_DecryptData(
|
|
PCAPIData pCapiData,
|
|
LPBYTE pbData,
|
|
DWORD dwDataLen,
|
|
DWORD dwPadLen,
|
|
LPBYTE pbSignature,
|
|
DWORD dwDecryptionCount)
|
|
{
|
|
BOOL rc = FALSE;
|
|
DWORD dwLen = dwDataLen;
|
|
DWORD Error;
|
|
HCRYPTHASH hHash;
|
|
BYTE abSignature[A_SHA_DIGEST_LEN];
|
|
BYTE rgbSHA[A_SHA_DIGEST_LEN];
|
|
|
|
DC_BEGIN_FN("TSCAPI_DecryptData");
|
|
|
|
// data length check
|
|
if (dwDataLen <= dwPadLen) {
|
|
TRC_ERR((TB, _T("Bad data length, padLen %d is larger than DataLen %d"),
|
|
dwPadLen, dwDataLen));
|
|
goto done;
|
|
}
|
|
|
|
rc = pCapiData->CapiFunctionTable.pfnCryptDecrypt(pCapiData->hDecKey,
|
|
NULL, //Hash
|
|
FALSE, //Final
|
|
0,
|
|
pbData,
|
|
&dwLen);
|
|
if (!rc) {
|
|
TRC_ERR((TB, _T("Error %x during CryptDecrypt!\n"), GetLastError()));
|
|
goto done;
|
|
}
|
|
|
|
// Compute signature
|
|
if (!HmacHashDataEx(&(pCapiData->CapiFunctionTable), pCapiData->hProv, pbData, dwDataLen - dwPadLen, (BYTE *)&dwDecryptionCount,
|
|
sizeof(dwDecryptionCount), pCapiData->hSignKey, &hHash)) {
|
|
goto done;
|
|
}
|
|
|
|
if (!DumpHashes(&(pCapiData->CapiFunctionTable), &hHash, abSignature, sizeof(abSignature))) {
|
|
goto done;
|
|
}
|
|
//
|
|
// check to see the sigature match.
|
|
//
|
|
|
|
if(!memcmp(
|
|
(LPBYTE)abSignature,
|
|
pbSignature,
|
|
MAX_SIGN_SIZE)) {
|
|
rc = TRUE;;
|
|
}
|
|
done:
|
|
DC_END_FN();
|
|
|
|
return rc;
|
|
}
|