/////////////////////////////////////////////////////////////////////////////
// FILE : nt_key.c //
// DESCRIPTION : Crypto CP interfaces: //
// CPGenKey //
// CPDeriveKey //
// CPExportKey //
// CPImportKey //
// CPDestroyKey //
// CPGetUserKey //
// CPSetKeyParam //
// CPGetKeyParam //
// AUTHOR : //
// HISTORY : //
// Jan 25 1995 larrys Changed from Nametag //
// Feb 16 1995 larrys Fix problem for 944 build //
// Feb 21 1995 larrys Added SPECIAL_KEY //
// Feb 23 1995 larrys Changed NTag_SetLastError to SetLastError //
// Mar 08 1995 larrys Fixed a few problems //
// Mar 23 1995 larrys Added variable key length //
// Apr 7 1995 larrys Removed CryptConfigure //
// Apr 17 1995 larrys Added 1024 key gen //
// Apr 19 1995 larrys Changed CRYPT_EXCH_PUB to AT_KEYEXCHANGE //
// May 10 1995 larrys added private api calls //
// May 17 1995 larrys added key data for DES test //
// Jul 20 1995 larrys Changed export of PUBLICKEYBLOB //
// Jul 21 1995 larrys Fixed Export of AUTHENTICATEDBLOB //
// Aug 03 1995 larrys Allow CryptG(S)etKeyParam for Public keys & //
// Removed CPTranslate //
// Aug 10 1995 larrys Fixed a few problems in CryptGetKeyParam //
// Aug 11 1995 larrys Return no key for CryptGetUserKey //
// Aug 14 1995 larrys Removed key exchange stuff //
// Aug 17 1995 larrys Removed a error //
// Aug 18 1995 larrys Changed NTE_BAD_LEN to ERROR_MORE_DATA //
// Aug 30 1995 larrys Removed RETURNASHVALUE from CryptGetHashValue //
// Aug 31 1995 larrys Fixed CryptExportKey if pbData == NULL //
// Sep 05 1995 larrys Fixed bug # 30 //
// Sep 05 1995 larrys Fixed bug # 31 //
// Sep 11 1995 larrys Fixed bug # 34 //
// Sep 12 1995 larrys Removed 2 DWORDS from exported keys //
// Sep 14 1995 Jeffspel/ramas Merged STT onto CSP //
// Sep 18 1995 larrys Changed def KP_PERMISSIONS to 0xffffffff //
// Oct 02 1995 larrys Fixed bug 43 return error for importkey on hPubkey //
// Oct 03 1995 larrys Fixed bug 37 call InflateKey from SetKeyParam //
// Oct 03 1995 larrys Fixed bug 36, removed OFB from SetKeyParam //
// Oct 03 1995 larrys Fixed bug 38, check key type in SetKeyParam //
// Oct 13 1995 larrys Added CPG/setProv/HashParam //
// Oct 13 1995 larrys Added code for CryptSetHashValue //
// Oct 16 1995 larrys Changes for CryptGetHashParam //
// Oct 23 1995 larrys Added code for GetProvParam PP_CONTAINER //
// Oct 27 1995 rajeshk RandSeed Stuff added hUID to PKCS2Encrypt+ others //
// Nov 3 1995 larrys Merge changes for NT checkin //
// Nov 9 1995 larrys Bug fix 10686 //
// Nov 30 1995 larrys Bug fix //
// Dec 11 1995 larrys Added WIN96 password cache //
// Feb 29 1996 rajeshk Added Check for SetHashParam for HASHVALUE //
// May 15 1996 larrys Added private key export //
// May 28 1996 larrys Fix bug 88 //
// Jun 6 1996 a-johnb Added support for SSL 3.0 signatures //
// Aug 28 1996 mattt Changed enum to calculate size from #defined sizes //
// Sep 13 1996 mattt Compat w/RSABase 88-bit 0 salt, FIsLegalKey() //
// Sep 16 1996 mattt Added KP_KEYLEN ability //
// Sep 16 1996 jeffspel Added triple DES functionality //
// Oct 14 1996 jeffspel Changed GenRandoms to NewGenRandoms //
// Apr 29 1997 jeffspel Key storage ability GetProvParam, PStore support //
// Apr 29 1997 jeffspel Added EnumAlgsEx tp GetProvParam //
// May 23 1997 jeffspel Added provider type checking //
// Jul 15 1997 jeffspel Added ability to decrypt with large RC2 keys //
// Jul 28 1997 jeffspel Added ability to delete a persisted key //
// Sep 09 1997 jeffspel Added PP_KEYSET_TYPE to CPGetProvParam //
// Sep 12 1997 jeffspel Added Opaque blob support //
// May 4 2000 dbarlow Error code return cleanup //
// //
// Copyright (C) 1993 - 2000 Microsoft Corporation //
// All Rights Reserved //
/////////////////////////////////////////////////////////////////////////////
#include "precomp.h"
#include "nt_rsa.h"
#include "nt_blobs.h"
#include "swnt_pk.h"
#include "mac.h"
#include "ntagimp1.h"
#include "tripldes.h"
#include "ntagum.h"
#include "randlib.h"
#ifdef CSP_USE_SSL3
#include "ssl3.h"
#endif
#include "protstor.h"
#include "sgccheck.h"
#include "aes.h"
extern CSP_STRINGS g_Strings;
#ifndef CSP_USE_AES
#define UnsupportedSymKey(pKey) ((CALG_RC4 != pKey->Algid) && \
(CALG_RC2 != pKey->Algid) && \
(CALG_DES != pKey->Algid) && \
(CALG_3DES != pKey->Algid) && \
(CALG_3DES_112 != pKey->Algid))
#else
#define UnsupportedSymKey(pKey) ((CALG_RC4 != pKey->Algid) && \
(CALG_RC2 != pKey->Algid) && \
(CALG_DES != pKey->Algid) && \
(CALG_3DES != pKey->Algid) && \
(CALG_3DES_112 != pKey->Algid) && \
(CALG_AES_128 != pKey->Algid) && \
(CALG_AES_192 != pKey->Algid) && \
(CALG_AES_256 != pKey->Algid))
#endif
#define NTAG_REG_KEY_LOC "Software\\Microsoft\\Cryptography\\UserKeys"
#define NTAG_MACH_REG_KEY_LOC "Software\\Microsoft\\Cryptography\\MachineKeys"
extern DWORD
InflateKey(
IN PNTAGKeyList pTmpKey);
/*static*/ DWORD
CopyKey(
IN PNTAGKeyList pOldKey,
OUT PNTAGKeyList *ppNewKey);
extern DWORD
SymEncrypt(
IN PNTAGKeyList pKey,
IN BOOL fFinal,
IN OUT BYTE *pbData,
IN OUT DWORD *pcbData,
IN DWORD cbBuf);
extern DWORD
SymDecrypt(
IN PNTAGKeyList pKey,
IN PNTAGHashList pHash,
IN BOOL fFinal,
IN OUT BYTE *pbData,
IN OUT DWORD *pcbData);
extern DWORD
BlockEncrypt(
void EncFun(BYTE *In, BYTE *Out, void *key, int op),
PNTAGKeyList pKey,
int BlockLen,
BOOL Final,
BYTE *pbData,
DWORD *pdwDataLen,
DWORD dwBufLen);
static BYTE rgbSymmetricKeyWrapIV[8]
= {0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05};
//
// Set the permissions on the key
//
/*static*/ void
SetInitialKeyPermissions(
PNTAGKeyList pKey)
{
if (CRYPT_EXPORTABLE == pKey->Rights)
{
pKey->Permissions |= CRYPT_EXPORT;
}
// UNDONE - set the appopropriate permission with the appropriate
// algorithm
pKey->Permissions |= CRYPT_ENCRYPT | CRYPT_DECRYPT| CRYPT_READ |
CRYPT_WRITE | CRYPT_MAC;
}
/* MakeNewKey
*
* Helper routine for ImportKey, GenKey
*
* Allocate a new key record, fill in the data and copy in the key
* bytes.
*/
DWORD
MakeNewKey(
ALG_ID aiKeyAlg,
DWORD dwRights,
DWORD dwKeyLen,
HCRYPTPROV hUID,
BYTE *pbKeyData,
BOOL fUsePassedKeyBuffer,
BOOL fPreserveExactKey,
PNTAGKeyList *ppKeyList)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGKeyList pKey = NULL;
*ppKeyList = NULL;
// allocate space for the key record
pKey = (PNTAGKeyList)_nt_malloc(sizeof(NTAGKeyList));
if (NULL == pKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
if (!fUsePassedKeyBuffer)
{
pKey->pKeyValue = (BYTE *)_nt_malloc((size_t)dwKeyLen);
if (NULL == pKey->pKeyValue)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
}
pKey->Algid = aiKeyAlg;
pKey->Rights = dwRights;
pKey->cbDataLen = 0;
pKey->pData = NULL;
pKey->hUID = hUID;
memset(pKey->IV, 0, MAX_BLOCKLEN);
memset(pKey->FeedBack, 0, MAX_BLOCKLEN);
pKey->InProgress = FALSE;
pKey->cbSaltLen = 0;
pKey->Padding = PKCS5_PADDING;
pKey->Mode = CRYPT_MODE_CBC;
pKey->ModeBits = 0;
SetInitialKeyPermissions(pKey);
pKey->cbKeyLen = dwKeyLen;
if (pbKeyData != NULL)
{
if (fUsePassedKeyBuffer)
pKey->pKeyValue = pbKeyData;
else
memcpy(pKey->pKeyValue, pbKeyData, (size_t)dwKeyLen);
}
// Handle special cases
switch (aiKeyAlg)
{
case CALG_RC2:
// for RC2 set a default effective key length
pKey->EffectiveKeyLen = RC2_DEFAULT_EFFECTIVE_KEYLEN;
pKey->dwBlockLen = RC2_BLOCKLEN;
break;
case CALG_DES:
if (DES_KEYSIZE != pKey->cbKeyLen)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (!fPreserveExactKey)
desparityonkey(pKey->pKeyValue, pKey->cbKeyLen);
pKey->dwBlockLen = DES_BLOCKLEN;
break;
case CALG_3DES_112:
if (DES_KEYSIZE * 2 != pKey->cbKeyLen)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (!fPreserveExactKey)
desparityonkey(pKey->pKeyValue, pKey->cbKeyLen);
pKey->dwBlockLen = DES_BLOCKLEN;
break;
case CALG_3DES:
if (DES_KEYSIZE * 3 != pKey->cbKeyLen)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (!fPreserveExactKey)
desparityonkey(pKey->pKeyValue, pKey->cbKeyLen);
pKey->dwBlockLen = DES_BLOCKLEN;
break;
#ifdef CSP_USE_AES
case CALG_AES_128:
pKey->dwBlockLen = CRYPT_AES128_BLKLEN;
break;
case CALG_AES_192:
pKey->dwBlockLen = CRYPT_AES192_BLKLEN;
break;
case CALG_AES_256:
pKey->dwBlockLen = CRYPT_AES256_BLKLEN;
break;
#endif
default:
pKey->dwBlockLen = 0;
}
*ppKeyList = pKey;
return ERROR_SUCCESS;
ErrorExit:
if (NULL != pKey)
_nt_free (pKey, sizeof(NTAGKeyList));
return dwReturn;
}
/* FreeNewKey
*
* Use for cleanup on abort of key build operations.
*
*/
void
FreeNewKey(
PNTAGKeyList pOldKey)
{
if (pOldKey->pKeyValue)
_nt_free(pOldKey->pKeyValue, pOldKey->cbKeyLen);
if (pOldKey->pData)
_nt_free(pOldKey->pData, pOldKey->cbDataLen);
_nt_free(pOldKey, sizeof(NTAGKeyList));
}
/* FIsLegalKeySize
*
* Check that the length of the key is legal (essentially
* complies with export).
*
*/
BOOL
FIsLegalKeySize(
IN DWORD dwCspTypeId,
IN ALG_ID Algid,
IN DWORD cbKey,
IN BOOL fRC2BigKeyOK,
OUT BOOL *pfPubKey)
{
BOOL fRet = FALSE;
*pfPubKey = FALSE;
switch (Algid)
{
#ifdef CSP_USE_RC2
case CALG_RC2:
if (!fRC2BigKeyOK)
{
if (!IsLegalLength(g_AlgTables[dwCspTypeId], Algid,
cbKey * 8, NULL))
goto ErrorExit;
}
break;
#endif
#ifdef CSP_USE_DES
case CALG_DES:
if ((DES_KEYSIZE != cbKey) && ((DES_KEYSIZE - 1) != cbKey))
goto ErrorExit;
break;
#endif
#ifdef CSP_USE_3DES
case CALG_3DES_112:
if ((DES2_KEYSIZE != cbKey) && ((DES2_KEYSIZE - 2) != cbKey))
goto ErrorExit;
break;
case CALG_3DES:
if ((DES3_KEYSIZE != cbKey) && ((DES3_KEYSIZE - 3) != cbKey))
goto ErrorExit;
break;
#endif
case CALG_RSA_SIGN:
case CALG_RSA_KEYX:
*pfPubKey = TRUE;
// Fall through intentionally.
default:
if (!IsLegalLength(g_AlgTables[dwCspTypeId], Algid, cbKey * 8, NULL))
goto ErrorExit;
}
fRet = TRUE;
ErrorExit:
// not of regulation size
return fRet;
}
#ifdef USE_SGC
/* FIsLegalSGCKeySize
*
* Check that the length of the key is SGC legal (essentially
* complies with export).
*
*/
BOOL
FIsLegalSGCKeySize(
IN ALG_ID Algid,
IN DWORD cbKey,
IN BOOL fRC2BigKeyOK,
IN BOOL fGenKey,
OUT BOOL *pfPubKey)
{
BOOL fSts = FALSE;
if (!fGenKey)
{
if (!FIsLegalKeySize(POLICY_MS_SCHANNEL, Algid, cbKey, fRC2BigKeyOK,
pfPubKey))
goto ErrorExit;
}
else
{
switch (Algid)
{
#ifdef CSP_USE_RC2
case CALG_RC2:
if (!fRC2BigKeyOK)
goto ErrorExit;
break;
#endif
#ifdef CSP_USE_SSL3
case CALG_SSL3_MASTER:
case CALG_TLS1_MASTER:
case CALG_PCT1_MASTER:
case CALG_SSL2_MASTER:
if (!FIsLegalKeySize(POLICY_MS_SCHANNEL, Algid, cbKey,
fRC2BigKeyOK, pfPubKey))
goto ErrorExit;
break;
case CALG_SCHANNEL_MAC_KEY:
break;
#endif
case CALG_RSA_KEYX:
if (!FIsLegalKeySize(POLICY_MS_SCHANNEL, Algid, cbKey,
fRC2BigKeyOK, pfPubKey))
goto ErrorExit;
break;
default:
goto ErrorExit;
}
}
fSts = TRUE;
ErrorExit:
return fSts;
}
#endif
/* FIsLegalKey
*
* Check that the length of the key is legal (essentially
* complies with export).
*
*/
BOOL
FIsLegalKey(
IN PNTAGUserList pTmpUser,
IN PNTAGKeyList pKey,
IN BOOL fRC2BigKeyOK)
{
BOOL fPubKey;
BOOL fRet = FALSE;
if (pKey == NULL)
goto ErrorExit;
#ifdef USE_SGC
// check if the provider is an SChannel provider and if so if the
// SGC flag is set then use the FIsLegalSGCKeySize function
if ((PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
&& (0 != pTmpUser->dwSGCFlags))
{
if (!FIsLegalSGCKeySize(pKey->Algid, pKey->cbKeyLen,
fRC2BigKeyOK, FALSE, &fPubKey))
{
goto ErrorExit;
}
}
else
#endif
{
// 4th parameter, dwFlags, is used for SGC Exch keys so just
// pass zero in this case
if (!FIsLegalKeySize(pTmpUser->dwCspTypeId,
pKey->Algid, pKey->cbKeyLen,
fRC2BigKeyOK, &fPubKey))
{
goto ErrorExit;
}
}
fRet = TRUE;
ErrorExit:
return fRet;
}
/* FIsLegalImportSymKey
*
* Verify that imported symmetric keys meet the size restrictions
* of the CSP in use. In addition, require all DES-variant
* keys to be of the full required size, including parity bits.
*/
BOOL
FIsLegalImportSymKey(
IN PNTAGUserList pTmpUser,
IN PNTAGKeyList pKey,
IN BOOL fRC2BigKeyOK)
{
BOOL fRet = FALSE;
switch (pKey->Algid)
{
#ifdef CSP_USE_RC2
case CALG_RC2:
if (!fRC2BigKeyOK)
{
if (!IsLegalLength(g_AlgTables[pTmpUser->dwCspTypeId], pKey->Algid,
pKey->cbKeyLen * 8, NULL))
goto ErrorExit;
}
break;
#endif
#ifdef CSP_USE_DES
case CALG_DES:
if (DES_KEYSIZE != pKey->cbKeyLen)
goto ErrorExit;
break;
#endif
#ifdef CSP_USE_3DES
case CALG_3DES_112:
if (DES2_KEYSIZE != pKey->cbKeyLen)
goto ErrorExit;
break;
case CALG_3DES:
if (DES3_KEYSIZE != pKey->cbKeyLen)
goto ErrorExit;
break;
#endif
case CALG_RSA_SIGN:
case CALG_RSA_KEYX:
goto ErrorExit;
default:
if (!IsLegalLength(g_AlgTables[pTmpUser->dwCspTypeId], pKey->Algid,
pKey->cbKeyLen * 8, NULL))
goto ErrorExit;
}
fRet = TRUE;
ErrorExit:
return fRet;
}
/*static*/ DWORD
MakeKeyRSABaseCompatible(
HCRYPTPROV hUID,
HCRYPTKEY hKey)
{
CRYPT_DATA_BLOB sSaltData;
BYTE rgbZeroSalt[11];
BOOL fSts;
ZeroMemory(rgbZeroSalt, 11);
sSaltData.pbData = rgbZeroSalt;
sSaltData.cbData = sizeof(rgbZeroSalt);
fSts = CPSetKeyParam(hUID, hKey, KP_SALT_EX, (PBYTE)&sSaltData, 0);
if (!fSts)
return GetLastError();
return ERROR_SUCCESS;
}
typedef struct
{
DWORD magic; /* Should always be RSA2 */
DWORD bitlen; // bit size of key
DWORD pubexp; // public exponent
} EXPORT_PRV_KEY, FAR *PEXPORT_PRV_KEY;
/* GetLengthOfPrivateKeyForExport
*
* Get the length of the private key
* blob from the public key.
*
*/
/*static*/ void
GetLengthOfPrivateKeyForExport(
IN BSAFE_PUB_KEY *pPubKey,
OUT PDWORD pcbBlob)
{
DWORD cbHalfModLen;
cbHalfModLen = (pPubKey->bitlen + 15) / 16;
*pcbBlob = sizeof(EXPORT_PRV_KEY) + 9 * cbHalfModLen;
}
/* PreparePrivateKeyForExport
*
* Massage the key from the registry
* into an exportable format.
*
*/
/*static*/ BOOL
PreparePrivateKeyForExport(
IN BSAFE_PRV_KEY *pPrvKey,
OUT PBYTE pbBlob,
IN OUT PDWORD pcbBlob)
{
PEXPORT_PRV_KEY pExportKey;
DWORD cbHalfModLen;
DWORD cbBlobLen;
DWORD cbTmpLen;
DWORD cbHalfTmpLen;
PBYTE pbIn;
PBYTE pbOut;
cbHalfModLen = (pPrvKey->bitlen + 15) / 16;
cbBlobLen = sizeof(EXPORT_PRV_KEY) + 9 * cbHalfModLen;
// figure out the number of overflow bytes which are in the private
// key structure
cbTmpLen = (sizeof(DWORD) * 2)
- (((pPrvKey->bitlen + 7) / 8) % (sizeof(DWORD) * 2));
if ((sizeof(DWORD) * 2) != cbTmpLen)
cbTmpLen += sizeof(DWORD) * 2;
cbHalfTmpLen = cbTmpLen / 2;
if (NULL == pbBlob)
{
*pcbBlob = cbBlobLen;
return TRUE;
}
if (*pcbBlob < cbBlobLen)
{
*pcbBlob = cbBlobLen;
return FALSE;
}
// take most of the header info
pExportKey = (PEXPORT_PRV_KEY)pbBlob;
pExportKey->magic = pPrvKey->magic;
pExportKey->bitlen = pPrvKey->bitlen;
pExportKey->pubexp = pPrvKey->pubexp;
pbIn = (PBYTE)pPrvKey + sizeof(BSAFE_PRV_KEY);
pbOut = pbBlob + sizeof(EXPORT_PRV_KEY);
// copy all the private key info
CopyMemory(pbOut, pbIn, pExportKey->bitlen / 8);
pbIn += pExportKey->bitlen / 8 + cbTmpLen;
pbOut += pExportKey->bitlen / 8;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbIn += cbHalfModLen + cbHalfTmpLen;
pbOut += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbIn += cbHalfModLen + cbHalfTmpLen;
pbOut += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbIn += cbHalfModLen + cbHalfTmpLen;
pbOut += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbIn += cbHalfModLen + cbHalfTmpLen;
pbOut += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbIn += cbHalfModLen + cbHalfTmpLen;
pbOut += cbHalfModLen;
CopyMemory(pbOut, pbIn, pExportKey->bitlen / 8);
*pcbBlob = cbBlobLen;
return TRUE;
}
/* PreparePrivateKeyForImport
*
* Massage the incoming into a form acceptable for
* the registry.
*
*/
/*static*/ BOOL
PreparePrivateKeyForImport(
IN PBYTE pbBlob,
OUT BSAFE_PRV_KEY *pPrvKey,
IN OUT PDWORD pPrvKeyLen,
OUT BSAFE_PUB_KEY *pPubKey,
IN OUT PDWORD pPubKeyLen)
{
PEXPORT_PRV_KEY pExportKey = (PEXPORT_PRV_KEY)pbBlob;
DWORD cbHalfModLen;
DWORD cbPub;
DWORD cbPrv;
PBYTE pbIn;
PBYTE pbOut;
DWORD cbTmpLen;
DWORD cbHalfTmpLen;
if (RSA2 != pExportKey->magic)
return FALSE;
// figure out the number of overflow bytes which are in the private
// key structure
cbTmpLen = (sizeof(DWORD) * 2)
- (((pExportKey->bitlen + 7) / 8) % (sizeof(DWORD) * 2));
if ((sizeof(DWORD) * 2) != cbTmpLen)
cbTmpLen += sizeof(DWORD) * 2;
cbHalfTmpLen = cbTmpLen / 2;
cbHalfModLen = (pExportKey->bitlen + 15) / 16;
cbPub = sizeof(BSAFE_PUB_KEY) + (pExportKey->bitlen / 8) + cbTmpLen;
cbPrv = sizeof(BSAFE_PRV_KEY) + (cbHalfModLen + cbHalfTmpLen) * 10;
if ((NULL == pPrvKey) || (NULL == pPubKey))
{
*pPubKeyLen = cbPub;
*pPrvKeyLen = cbPrv;
return TRUE;
}
if ((*pPubKeyLen < cbPub) || (*pPrvKeyLen < cbPrv))
{
*pPubKeyLen = cbPub;
*pPrvKeyLen = cbPrv;
return FALSE;
}
// form the public key
ZeroMemory(pPubKey, *pPubKeyLen);
pPubKey->magic = RSA1;
pPubKey->bitlen = pExportKey->bitlen;
pPubKey->keylen = (pExportKey->bitlen / 8) + cbTmpLen;
pPubKey->datalen = (pExportKey->bitlen+7)/8 - 1;
pPubKey->pubexp = pExportKey->pubexp;
pbIn = pbBlob + sizeof(EXPORT_PRV_KEY);
pbOut = (PBYTE)pPubKey + sizeof(BSAFE_PUB_KEY);
CopyMemory(pbOut, pbIn, pExportKey->bitlen / 8);
// form the private key
ZeroMemory(pPrvKey, *pPrvKeyLen);
pPrvKey->magic = pExportKey->magic;
pPrvKey->keylen = pPubKey->keylen;
pPrvKey->bitlen = pExportKey->bitlen;
pPrvKey->datalen = pPubKey->datalen;
pPrvKey->pubexp = pExportKey->pubexp;
pbOut = (PBYTE)pPrvKey + sizeof(BSAFE_PRV_KEY);
CopyMemory(pbOut, pbIn, pExportKey->bitlen / 8);
pbOut += pExportKey->bitlen / 8 + cbTmpLen;
pbIn += pExportKey->bitlen / 8;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbOut += cbHalfModLen + cbHalfTmpLen;
pbIn += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbOut += cbHalfModLen + cbHalfTmpLen;
pbIn += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbOut += cbHalfModLen + cbHalfTmpLen;
pbIn += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbOut += cbHalfModLen + cbHalfTmpLen;
pbIn += cbHalfModLen;
CopyMemory(pbOut, pbIn, cbHalfModLen);
pbOut += cbHalfModLen + cbHalfTmpLen;
pbIn += cbHalfModLen;
CopyMemory(pbOut, pbIn, pExportKey->bitlen / 8);
*pPubKeyLen = cbPub;
*pPrvKeyLen = cbPrv;
return TRUE;
}
/*static*/ BOOL
ValidKeyAlgid(
PNTAGUserList pTmpUser,
ALG_ID Algid)
{
if (ALG_CLASS_HASH == GET_ALG_CLASS(Algid))
return FALSE;
return IsLegalAlgorithm(g_AlgTables[pTmpUser->dwCspTypeId],
Algid, NULL);
}
#ifdef USE_SGC
/*
- GetSGCDefaultKeyLength
-
* Purpose:
* Returns the default key size in pcbKey.
*
* Parameters:
* IN Algid - For the key to be created
* OUT pcbKey - Size of the key in bytes to generate
* OUT pfPubKey- TRUE if the Algid is a pub key
*
* Returns: TRUE on success, FALSE on failure.
*/
/*static*/ BOOL
GetSGCDefaultKeyLength(
IN ALG_ID Algid,
OUT DWORD *pcbKey,
OUT BOOL *pfPubKey)
{
BOOL fRet = FALSE;
*pfPubKey = FALSE;
// determine which crypt algorithm is to be used
switch (Algid)
{
#ifdef CSP_USE_SSL3
case CALG_SSL3_MASTER:
case CALG_TLS1_MASTER:
*pcbKey = SSL3_MASTER_KEYSIZE;
break;
case CALG_PCT1_MASTER:
*pcbKey = PCT1_MASTER_KEYSIZE;
break;
case CALG_SSL2_MASTER:
*pcbKey = SSL2_MASTER_KEYSIZE;
break;
#endif
case CALG_RSA_KEYX:
*pcbKey = SGC_RSA_DEF_EXCH_MODLEN;
*pfPubKey = TRUE;
break;
default:
goto ErrorExit;
}
fRet = TRUE;
ErrorExit:
return fRet;
}
#endif
/*
- GetDefaultKeyLength
-
* Purpose:
* Returns the default key size in pcbKey.
*
* Parameters:
* IN pTmpUser- The context info
* IN Algid - For the key to be created
* OUT pcbKey - Size of the key in bytes to generate
* OUT pfPubKey- TRUE if the Algid is a pub key
*
* Returns: TRUE on success, FALSE on failure.
*/
/*static*/ BOOL
GetDefaultKeyLength(
IN PNTAGUserList pTmpUser,
IN ALG_ID Algid,
OUT DWORD *pcbKey,
OUT BOOL *pfPubKey)
{
BOOL fRet = FALSE;
DWORD cbits;
*pfPubKey = FALSE;
// determine which crypt algorithm is to be used
switch (Algid)
{
#ifdef CSP_USE_SSL3
case CALG_SSL3_MASTER:
case CALG_TLS1_MASTER:
*pcbKey = SSL3_MASTER_KEYSIZE;
break;
case CALG_PCT1_MASTER:
*pcbKey = PCT1_MASTER_KEYSIZE;
break;
case CALG_SSL2_MASTER:
*pcbKey = SSL2_MASTER_KEYSIZE;
break;
#endif
case CALG_RSA_KEYX:
case CALG_RSA_SIGN:
*pfPubKey = TRUE;
// Fall through intentionally.
default:
if (!GetDefaultLength(g_AlgTables[pTmpUser->dwCspTypeId],
Algid, NULL, &cbits))
goto ErrorExit;
*pcbKey = cbits / 8;
}
fRet = TRUE;
ErrorExit:
return fRet;
}
/*
- CheckKeyLength
-
* Purpose:
* Checks the settable key length and if it is OK then
* returns that as the size of key to use (pcbKey). If
* no key length is in dwFlags then the default key size
* is returned (pcbKey). If a settable key size is
* specified but is not legal then a failure occurs.
*
* Parameters:
* IN Algid - For the key to be created
* IN dwFlags - Flag value with possible key size
* OUT pcbKey - Size of the key in bytes to generate
* OUT pfPubKey- TRUE if the Algid is a pub key
*
* Returns: A DWORD status code.
*/
/*static*/ DWORD
CheckKeyLength(
IN PNTAGUserList pTmpUser,
IN ALG_ID Algid,
IN DWORD dwFlags,
OUT DWORD *pcbKey,
OUT BOOL *pfPubKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
DWORD cBits;
DWORD cbKey = 0;
cBits = dwFlags >> 16;
if (cBits)
{
// settable key sizes must be divisible by 8 (by bytes)
if (0 != (cBits % 8))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check if requested size is legal
cbKey = cBits / 8;
#ifdef USE_SGC
if ((PROV_RSA_SCHANNEL == pTmpUser->dwProvType) &&
(0 != pTmpUser->dwSGCFlags))
{
if (!FIsLegalSGCKeySize(Algid, cbKey,
FALSE, TRUE, pfPubKey))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
else
#endif
{
if (!FIsLegalKeySize(pTmpUser->dwCspTypeId,
Algid, cbKey,
FALSE, pfPubKey))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
*pcbKey = cbKey;
}
else
{
#ifdef USE_SGC
if ((PROV_RSA_SCHANNEL == pTmpUser->dwProvType) &&
(0 != pTmpUser->dwSGCFlags))
{
if (!GetSGCDefaultKeyLength(Algid, pcbKey, pfPubKey))
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
}
else
#endif
{
if (!GetDefaultKeyLength(pTmpUser, Algid, pcbKey, pfPubKey))
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
}
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}
#ifdef USE_SGC
/*
- CheckSGCSimpleForExport
-
* Purpose:
* Check if the SGC key values in the context against the
* passed in values to see if an simple blob export with
* this key is allowed.
*
*
* Parameters:
* IN hUID - Handle to a CSP
* IN Algid - Algorithm identifier
* IN dwFlags - Flags values
* OUT phKey - Handle to a generated key
*
* Returns:
*/
/*static*/ BOOL
CheckSGCSimpleForExport(
IN PNTAGUserList pTmpUser,
IN BSAFE_PUB_KEY *pBsafePubKey)
{
BOOL fRet = FALSE;
BYTE *pb;
pb = ((BYTE*)pBsafePubKey) + sizeof(BSAFE_PUB_KEY);
if (((pBsafePubKey->bitlen / 8) != pTmpUser->cbSGCKeyMod)
|| (pBsafePubKey->pubexp != pTmpUser->dwSGCKeyExpo)
|| (0 != memcmp(pb, pTmpUser->pbSGCKeyMod, pTmpUser->cbSGCKeyMod)))
{
goto ErrorExit;
}
fRet = TRUE;
ErrorExit:
return fRet;
}
#endif
/*
- CPGenKey
-
* Purpose:
* Generate cryptographic keys
*
*
* Parameters:
* IN hUID - Handle to a CSP
* IN Algid - Algorithm identifier
* IN dwFlags - Flags values
* OUT phKey - Handle to a generated key
*
* Returns:
*/
BOOL WINAPI
CPGenKey(
IN HCRYPTPROV hUID,
IN ALG_ID Algid,
IN DWORD dwFlags,
OUT HCRYPTKEY * phKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pTmpUser;
PNTAGKeyList pTmpKey = NULL;
DWORD dwRights = 0;
BYTE rgbRandom[MAX_KEY_SIZE];
int localAlgid;
DWORD cbKey;
BOOL fPubKey = FALSE;
BOOL fRet;
DWORD dwSts;
EntryPoint
if ((dwFlags & ~(CRYPT_EXPORTABLE | CRYPT_USER_PROTECTED |
CRYPT_CREATE_SALT | CRYPT_NO_SALT |
KEY_LENGTH_MASK | CRYPT_SGCKEY | CRYPT_ARCHIVABLE)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
switch (Algid)
{
case AT_KEYEXCHANGE:
localAlgid = CALG_RSA_KEYX;
break;
case AT_SIGNATURE:
localAlgid = CALG_RSA_SIGN;
break;
default:
if (0 != (dwFlags & CRYPT_ARCHIVABLE))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
localAlgid = Algid;
break;
}
pTmpUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
if ((CRYPT_USER_PROTECTED & dwFlags) && (CRYPT_VERIFYCONTEXT & pTmpUser->Rights))
{
dwReturn = (DWORD)NTE_SILENT_CONTEXT;
goto ErrorExit;
}
if (!ValidKeyAlgid(pTmpUser, localAlgid))
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
// check if the size of the key is set in the dwFlags parameter
dwSts = CheckKeyLength(pTmpUser, localAlgid, dwFlags, &cbKey, &fPubKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
if (fPubKey)
{
dwSts = ReGenKey(hUID,
dwFlags,
(localAlgid == CALG_RSA_KEYX)
? NTPK_USE_EXCH
: NTPK_USE_SIG,
phKey,
cbKey * 8);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
else
{
// Force the full key lengths on DES algorithms.
if (CALG_DES == localAlgid)
cbKey = DES_KEYSIZE;
else if (CALG_3DES_112 == localAlgid)
cbKey = DES2_KEYSIZE;
else if (CALG_3DES == localAlgid)
cbKey = DES3_KEYSIZE;
// generate the random key
dwSts = FIPS186GenRandom(&pTmpUser->hRNGDriver,
&pTmpUser->ContInfo.pbRandom,
&pTmpUser->ContInfo.ContLens.cbRandom,
rgbRandom, cbKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // NTE_FAIL
goto ErrorExit;
}
if ((CALG_DES == localAlgid) || (CALG_3DES_112 == localAlgid) ||
(CALG_3DES == localAlgid))
{
if (dwFlags & CRYPT_CREATE_SALT)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
#ifdef CSP_USE_SSL3
else if (CALG_SSL3_MASTER == localAlgid)
{
// set the first byte to 0x03 and the second to 0x00
rgbRandom[0] = 0x03;
rgbRandom[1] = 0x00;
}
else if (CALG_TLS1_MASTER == localAlgid)
{
// set the first byte to 0x03 and the second to 0x01
rgbRandom[0] = 0x03;
rgbRandom[1] = 0x01;
}
#endif
// check if the key is CRYPT_EXPORTABLE
if (dwFlags & CRYPT_EXPORTABLE)
dwRights = CRYPT_EXPORTABLE;
dwSts = MakeNewKey(localAlgid, dwRights, cbKey, hUID, rgbRandom,
FALSE, FALSE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
if (dwFlags & CRYPT_CREATE_SALT)
{
if ((POLICY_MS_DEF == pTmpUser->dwCspTypeId)
|| (POLICY_MS_STRONG == pTmpUser->dwCspTypeId))
{
pTmpKey->cbSaltLen = DEFAULT_WEAK_SALT_LENGTH;
}
else
{
pTmpKey->cbSaltLen = DEFAULT_STRONG_SALT_LENGTH;
}
dwSts = FIPS186GenRandom(&pTmpUser->hRNGDriver,
&pTmpUser->ContInfo.pbRandom,
&pTmpUser->ContInfo.ContLens.cbRandom,
pTmpKey->rgbSalt, pTmpKey->cbSaltLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // NTE_FAIL
goto ErrorExit;
}
}
dwSts = NTLMakeItem(phKey, KEY_HANDLE, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if 40bit key + no mention of salt, set zeroized salt for RSABase compatibility
if ((5 == cbKey) && (!(dwFlags & CRYPT_NO_SALT)) &&
(!(dwFlags & CRYPT_CREATE_SALT)) &&
(CALG_SSL3_MASTER != Algid) && (CALG_TLS1_MASTER != Algid) &&
(CALG_PCT1_MASTER != Algid) && (CALG_SSL2_MASTER != Algid))
{
dwSts = MakeKeyRSABaseCompatible(hUID, *phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
{
if (pTmpKey)
FreeNewKey(pTmpKey);
SetLastError(dwReturn);
}
return fRet;
}
/*
- CPDeriveKey
-
* Purpose:
* Derive cryptographic keys from base data
*
*
* Parameters:
* IN hUID - Handle to a CSP
* IN Algid - Algorithm identifier
* IN hBaseData - Handle to hash of base data
* IN dwFlags - Flags values
* OUT phKey - Handle to a generated key
*
* Returns:
*/
BOOL WINAPI
CPDeriveKey(
IN HCRYPTPROV hUID,
IN ALG_ID Algid,
IN HCRYPTHASH hBaseData,
IN DWORD dwFlags,
OUT HCRYPTKEY * phKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pTmpUser = NULL;
PNTAGKeyList pTmpKey = NULL;
DWORD dwRights = 0;
BYTE rgbRandom[MAX_KEY_SIZE];
BYTE rgbBaseVal[MAX_KEY_SIZE];
HCRYPTHASH h1 = 0;
HCRYPTHASH h2 = 0;
BYTE rgbBuff1[64];
BYTE rgbBuff2[64];
BYTE rgbHash1[NT_HASH_BYTES];
BYTE rgbHash2[NT_HASH_BYTES];
DWORD cb1;
DWORD cb2;
DWORD i;
PNTAGHashList pTmpHash;
DWORD temp;
BOOL fPubKey = FALSE;
DWORD cbKey;
BOOL fRet;
DWORD dwSts;
EntryPoint
if ((dwFlags & ~(CRYPT_EXPORTABLE |
CRYPT_CREATE_SALT | CRYPT_NO_SALT | CRYPT_SERVER |
KEY_LENGTH_MASK)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
pTmpUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
if (!ValidKeyAlgid(pTmpUser, Algid))
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
dwSts = NTLValidate(hBaseData, hUID, HASH_HANDLE, &pTmpHash);
if (ERROR_SUCCESS != dwSts)
{
// NTLValidate doesn't know what error to set
// so it set NTE_FAIL -- fix it up.
dwReturn = (dwSts == NTE_FAIL) ? (DWORD)NTE_BAD_HASH : dwSts;
goto ErrorExit;
}
#ifdef CSP_USE_SSL3
// if the hash is for secure channel usage then go to that derive function
if (CALG_SCHANNEL_MASTER_HASH == pTmpHash->Algid)
{
dwReturn = SecureChannelDeriveKey(pTmpUser, pTmpHash, Algid,
dwFlags, phKey);
goto ErrorExit;
}
#endif // CSP_USE_SSL3
// check if the size of the key is set in the dwFlags parameter
dwSts = CheckKeyLength(pTmpUser, Algid, dwFlags, &cbKey, &fPubKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// Force the full key lengths on DES algorithms.
if (CALG_DES == Algid)
cbKey = DES_KEYSIZE;
else if (CALG_3DES_112 == Algid)
cbKey = DES2_KEYSIZE;
else if (CALG_3DES == Algid)
cbKey = DES3_KEYSIZE;
if (fPubKey)
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
if (pTmpHash->HashFlags & HF_VALUE_SET)
{
dwReturn = (DWORD)NTE_BAD_HASH;
goto ErrorExit;
}
memset(rgbBaseVal, 0, MAX_KEY_SIZE);
temp = MAX_KEY_SIZE;
if (!CPGetHashParam(hUID, hBaseData, HP_HASHVAL, rgbBaseVal, &temp, 0))
{
dwReturn = GetLastError();
goto ErrorExit;
}
#ifdef CSP_USE_3DES
if (CALG_3DES == Algid)
{
// the hash value is not long enough so we must expand it
if (!CPCreateHash(hUID, pTmpHash->Algid, 0, 0, &h1))
{
dwReturn = GetLastError();
goto ErrorExit;
}
if (!CPCreateHash(hUID, pTmpHash->Algid, 0, 0, &h2))
{
dwReturn = GetLastError();
goto ErrorExit;
}
// set up the two buffers to be hashed
memset(rgbBuff1, 0x36, sizeof(rgbBuff1));
memset(rgbBuff2, 0x5C, sizeof(rgbBuff2));
for (i=0;i<temp;i++)
{
rgbBuff1[i] ^= rgbBaseVal[i];
rgbBuff2[i] ^= rgbBaseVal[i];
}
// hash the two buffers
if (!CPHashData(hUID, h1, rgbBuff1, sizeof(rgbBuff1), 0))
{
dwReturn = GetLastError();
goto ErrorExit;
}
if (!CPHashData(hUID, h2, rgbBuff2, sizeof(rgbBuff2), 0))
{
dwReturn = GetLastError();
goto ErrorExit;
}
// finish the hashes and copy them into BaseVal
memset(rgbHash1, 0, sizeof(rgbHash1));
cb1 = sizeof(rgbHash1);
if (!CPGetHashParam(hUID, h1, HP_HASHVAL, rgbHash1, &cb1, 0))
{
dwReturn = GetLastError();
goto ErrorExit;
}
memcpy(rgbBaseVal, rgbHash1, cb1);
memset(rgbHash2, 0, sizeof(rgbHash2));
cb2 = sizeof(rgbHash2);
if (!CPGetHashParam(hUID, h2, HP_HASHVAL, rgbHash2, &cb2, 0))
{
dwReturn = GetLastError();
goto ErrorExit;
}
memcpy(rgbBaseVal + cb1, rgbHash2, cb2);
}
#endif
memcpy(rgbRandom, rgbBaseVal, cbKey);
// check if the key is CRYPT_EXPORTABLE
if (dwFlags & CRYPT_EXPORTABLE)
dwRights = CRYPT_EXPORTABLE;
dwSts = MakeNewKey(Algid, dwRights, cbKey, hUID, rgbRandom,
FALSE, FALSE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
if (dwFlags & CRYPT_CREATE_SALT)
{
if ((POLICY_MS_DEF == pTmpUser->dwCspTypeId)
|| (POLICY_MS_STRONG == pTmpUser->dwCspTypeId))
{
pTmpKey->cbSaltLen = DEFAULT_WEAK_SALT_LENGTH;
}
else
{
pTmpKey->cbSaltLen = DEFAULT_STRONG_SALT_LENGTH;
}
memcpy(pTmpKey->rgbSalt, rgbBaseVal+cbKey, pTmpKey->cbSaltLen);
}
dwSts = NTLMakeItem(phKey, KEY_HANDLE, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if 40bit key + no mention of salt, set zeroized salt for RSABase
// compatibility
if ((5 == cbKey) && (!(dwFlags & CRYPT_NO_SALT)) &&
(!(dwFlags & CRYPT_CREATE_SALT)))
{
dwSts = MakeKeyRSABaseCompatible(hUID, *phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (pTmpUser && h1)
CPDestroyHash(hUID, h1);
if (pTmpUser && h2)
CPDestroyHash(hUID, h2);
if (!fRet)
{
if (NULL != pTmpKey)
FreeNewKey(pTmpKey);
SetLastError(dwReturn);
}
return fRet;
}
/*static*/ DWORD
ExportOpaqueBlob(
PNTAGKeyList pKey,
BYTE *pbData,
DWORD *pcbData)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
DWORD cb = 0;
PNTAGPackedKeyList pPackedKey;
// make sure the key is a symmetric key
if ((CALG_RSA_SIGN == pKey->Algid) || (CALG_RSA_KEYX == pKey->Algid))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// calculate the length of the blob
cb = sizeof(BLOBHEADER) +
sizeof(NTAGPackedKeyList) +
pKey->cbKeyLen +
pKey->cbDataLen;
if (pbData == NULL || *pcbData < cb)
{
*pcbData = cb;
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
// set up the blob
pPackedKey = (PNTAGPackedKeyList)(pbData + sizeof(BLOBHEADER));
memset(pPackedKey, 0, sizeof(NTAGPackedKeyList));
pPackedKey->Algid = pKey->Algid;
pPackedKey->Rights = pKey->Rights;
memcpy(pPackedKey->IV, pKey->IV, sizeof(pKey->IV));
memcpy(pPackedKey->FeedBack, pKey->FeedBack, sizeof(pKey->FeedBack));
pPackedKey->InProgress = pKey->InProgress;
pPackedKey->cbSaltLen = pKey->cbSaltLen;
memcpy(pPackedKey->rgbSalt, pKey->rgbSalt, sizeof(pKey->rgbSalt));
pPackedKey->Padding = pKey->Padding;
pPackedKey->Mode = pKey->Mode;
pPackedKey->ModeBits = pKey->ModeBits;
pPackedKey->Permissions = pKey->Permissions;
pPackedKey->EffectiveKeyLen = pKey->EffectiveKeyLen;
pPackedKey->dwBlockLen = pKey->dwBlockLen;
if (pKey->pKeyValue)
{
memcpy((PBYTE)pPackedKey + sizeof(NTAGPackedKeyList),
pKey->pKeyValue,
pKey->cbKeyLen);
pPackedKey->cbKeyLen = pKey->cbKeyLen;
}
if(pKey->pData)
{
memcpy((PBYTE)pPackedKey + sizeof(NTAGPackedKeyList) + pPackedKey->cbKeyLen,
pKey->pData,
pKey->cbDataLen);
pPackedKey->cbDataLen = pKey->cbDataLen;
}
*pcbData = cb;
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}
/*
- GetRC4KeyForSymWrap
-
* Purpose:
* RC4 or more precisely stream ciphers are not supported by the CMS spec
* on symmetric key wrapping so we had to do something proprietary since
* we want to support RC4 for applications other than SMIME
*
*
* Parameters:
* IN pTmpUser - Pointer to the context
* IN pbSalt - Pointer to the 8 byte salt buffer
* IN pKey - Pointer to the orignial key
* OUT ppNewKey - Pointer to a pointer to the new key
*/
/*static*/ DWORD
GetRC4KeyForSymWrap(
IN BYTE *pbSalt,
IN PNTAGKeyList pKey,
OUT PNTAGKeyList *ppNewKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
DWORD dwSts;
// duplicate the key
dwSts = CopyKey(pKey, ppNewKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// set the value as salt + current salt
(*ppNewKey)->cbSaltLen += 8;
memcpy((*ppNewKey)->rgbSalt + ((*ppNewKey)->cbSaltLen - 8), pbSalt, 8);
dwSts = InflateKey(*ppNewKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}
/*
- GetSymmetricKeyChecksum
-
* Purpose:
* Calculates the checksum for a symmetric key which is to be
* wrapped with another symmetric key. This should meet the
* CMS specification
*
*
* Parameters:
* IN pKey - Pointer to the key
* OUT pbChecksum - Pointer to the 8 byte checksum
*/
/*static*/ void
GetSymmetricKeyChecksum(
IN BYTE *pbKey,
IN DWORD cbKey,
OUT BYTE *pbChecksum)
{
A_SHA_CTX SHACtx;
BYTE rgb[A_SHA_DIGEST_LEN];
A_SHAInit(&SHACtx);
A_SHAUpdate(&SHACtx, pbKey, cbKey);
A_SHAFinal(&SHACtx, rgb);
memcpy(pbChecksum, rgb, 8);
}
/*
- WrapSymKey
-
* Purpose:
* Wrap a symmetric key with another symmetric key. This should
* meet the CMS specification for symmetric key wrapping.
*
* Parameters:
* IN pTmpUser - Pointer to the user context
* IN pKey - Pointer to the key to be wrapped
* IN pWrapKey - Pointer to the key to be used for wrapping
* IN OUT pbBlob - Pointer to the resulting blob (may be NULL
* to get the length)
* IN OUT pcbBlob - Pointer to the length of the blob buffer
*/
/*static*/ DWORD
WrapSymKey(
IN PNTAGUserList pTmpUser,
IN PNTAGKeyList pKey,
IN PNTAGKeyList pWrapKey,
IN OUT BYTE *pbBlob,
IN OUT DWORD *pcbBlob)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
DWORD cb = 0;
DWORD cbIndex = 0;
DWORD cbPad = 0;
BLOBHEADER *pBlobHdr;
ALG_ID *pAlgid;
BYTE rgbTmp1[49]; // 1 length + 8 padding + 8 checksum + 8 IV + 24 max key
BYTE rgbTmp2[49]; // 1 length + 8 padding + 8 checksum + 8 IV + 24 max key
BYTE rgbIV[8];
PNTAGKeyList pLocalWrapKey = NULL;
BOOL fAlloc = FALSE;
DWORD i;
DWORD dwSts;
memset(rgbTmp1, 0, sizeof(rgbTmp1));
memset(rgbTmp2, 0, sizeof(rgbTmp2));
memset(rgbIV, 0, sizeof(rgbIV));
// both keys must be supported symmetric keys
if (UnsupportedSymKey(pKey) || UnsupportedSymKey(pWrapKey))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
#ifdef CSP_USE_AES
// For now, punt on supporting AES algs in this scenario
if (CALG_AES_128 == pWrapKey->Algid ||
CALG_AES_192 == pWrapKey->Algid ||
CALG_AES_256 == pWrapKey->Algid ||
CALG_AES_128 == pKey->Algid ||
CALG_AES_192 == pKey->Algid ||
CALG_AES_256 == pKey->Algid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
#endif
if ((!FIsLegalKey(pTmpUser, pKey, FALSE)) ||
(!FIsLegalKey(pTmpUser, pWrapKey, FALSE)))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// Check if we should do an auto-inflate
if (pWrapKey->pData == NULL)
{
dwSts = InflateKey(pWrapKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
// calculate how long the encrypted data is going to be.
if ((CALG_RC4 == pKey->Algid) || (CALG_RC2 == pKey->Algid)) // variable key lengths
{
// 1 byte for length, up to 8 bytes for pad and 8 bytes
// for the checksum and 8 bytes for the IV
cbPad = 8 - ((pKey->cbKeyLen + 1) % 8);
cb += pKey->cbKeyLen + 9 + cbPad + 8;
// place the length in the buffer
rgbTmp1[0] = (BYTE)pKey->cbKeyLen;
cbIndex += 1;
}
else
{
// up to 8 bytes for salt and 8 bytes for the checksum and 8 bytes
// for the IV
cb += pKey->cbKeyLen + 16;
}
// check if just looking for a length
if (NULL == pbBlob)
{
*pcbBlob = cb + sizeof(BLOBHEADER) + sizeof(ALG_ID);
dwReturn = ERROR_SUCCESS;
goto ErrorExit;
}
else if (*pcbBlob < (cb + sizeof(BLOBHEADER) + sizeof(ALG_ID)))
{
*pcbBlob = cb + sizeof(BLOBHEADER) + sizeof(ALG_ID);
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
// copy the key data
memcpy(rgbTmp1 + cbIndex, pKey->pKeyValue, pKey->cbKeyLen);
cbIndex += pKey->cbKeyLen;
// generate random pad
if (cbPad)
{
dwSts = FIPS186GenRandom(&pTmpUser->hRNGDriver,
&pTmpUser->ContInfo.pbRandom,
&pTmpUser->ContInfo.ContLens.cbRandom,
rgbTmp1 + cbIndex, cbPad);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
cbIndex += cbPad;
}
// get the checksum
GetSymmetricKeyChecksum(rgbTmp1, cbIndex, rgbTmp1 + cbIndex);
cbIndex += 8;
dwSts = FIPS186GenRandom(&pTmpUser->hRNGDriver,
&pTmpUser->ContInfo.pbRandom,
&pTmpUser->ContInfo.ContLens.cbRandom,
rgbIV, 8);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// set the IV if the algorithm is not RC4
if (CALG_RC4 != pWrapKey->Algid)
{
memcpy(pWrapKey->IV, rgbIV, 8);
pWrapKey->InProgress = FALSE;
pLocalWrapKey = pWrapKey;
}
else
{
// RC4 ()or more precisely stream ciphers) are not supported by the
// CMS spec for symmetric key wrapping. Therefore we had to do
// something proprietary to support RC4 for applications other
// than SMIME.
dwSts = GetRC4KeyForSymWrap(rgbIV,
pWrapKey,
&pLocalWrapKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
fAlloc = TRUE;
}
// encrypt the key blob data
dwSts = SymEncrypt(pLocalWrapKey, FALSE, rgbTmp1, &cbIndex, cbIndex);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// concatenate the initial ciphertext with the IV
memcpy(rgbTmp2, rgbIV, 8);
memcpy(rgbTmp2 + 8, rgbTmp1, cbIndex);
cbIndex += 8;
// byte reverse the ciphertext + IV buffer
for (i = 0; i < cbIndex; i++)
rgbTmp1[i] = rgbTmp2[cbIndex - (i + 1)];
// encrypt the key blob data again with the hardcoded IV
if (CALG_RC4 != pWrapKey->Algid)
{
memcpy(pWrapKey->IV, rgbSymmetricKeyWrapIV, 8);
pWrapKey->InProgress = FALSE;
}
else
{
if (fAlloc && pLocalWrapKey)
{
FreeNewKey(pLocalWrapKey);
pLocalWrapKey = NULL;
fAlloc = FALSE;
}
// RC4 (or more precisely stream ciphers) are not supported by the
// CMS spec for symmetric key wrapping. Therefore we had to do
// something proprietary to support RC4 for applications other
// than SMIME
dwSts = GetRC4KeyForSymWrap(rgbSymmetricKeyWrapIV,
pWrapKey,
&pLocalWrapKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
fAlloc = TRUE;
}
dwSts = SymEncrypt(pLocalWrapKey, FALSE, rgbTmp1, &cbIndex, cbIndex);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// set the header info
pBlobHdr = (BLOBHEADER*)pbBlob;
pBlobHdr->aiKeyAlg = pKey->Algid;
pAlgid = (ALG_ID*)(pbBlob + sizeof(BLOBHEADER));
*pAlgid = pWrapKey->Algid;
memcpy(pbBlob + sizeof(BLOBHEADER) + sizeof(ALG_ID),
rgbTmp1, cbIndex);
*pcbBlob = cbIndex + sizeof(BLOBHEADER) + sizeof(ALG_ID);
dwReturn = ERROR_SUCCESS;
ErrorExit:
if (fAlloc && pLocalWrapKey)
FreeNewKey(pLocalWrapKey);
memset(rgbTmp1, 0, sizeof(rgbTmp1));
memset(rgbTmp2, 0, sizeof(rgbTmp2));
memset(rgbIV, 0, sizeof(rgbIV));
return dwReturn;
}
/*
- UnWrapSymKey
-
* Purpose:
* Unwrap a symmetric key with another symmetric key. This should
* meet the CMS specification for symmetric key wrapping.
*
* Parameters:
* IN pTmpUser - Pointer to the user context
* IN pWrapKey - Pointer to the key to be used for unwrapping
* IN pbBlob - Pointer to the blob to be unwrapped
* IN cbBlob - The length of the blob buffer
* OUT phKey - Handle to the unwrapped key
*/
/*static*/ DWORD
UnWrapSymKey(
IN HCRYPTPROV hUID,
IN PNTAGUserList pTmpUser,
IN PNTAGKeyList pWrapKey,
IN BYTE *pbBlob,
IN DWORD cbBlob,
IN DWORD dwFlags,
OUT HCRYPTKEY *phKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
DWORD cb = 0;
DWORD cbIndex = 0;
DWORD cbKey = 0;
BYTE rgbChecksum[8];
BLOBHEADER *pBlobHdr = (BLOBHEADER*)pbBlob;
ALG_ID *pAlgid;
BYTE rgbTmp1[49]; // 1 length + 8 padding + 8 checksum + 8 IV + 24 max key
BYTE rgbTmp2[49]; // 1 length + 8 padding + 8 checksum + 8 IV + 24 max key
DWORD dwRights = 0;
PNTAGKeyList pTmpKey = NULL;
PNTAGKeyList pLocalWrapKey = NULL;
BOOL fAlloc = FALSE;
DWORD i;
BOOL fPubKey;
DWORD dwSts;
memset(rgbTmp1, 0, sizeof(rgbTmp1));
memset(rgbTmp2, 0, sizeof(rgbTmp2));
cb = cbBlob - (sizeof(BLOBHEADER) + sizeof(ALG_ID));
if ((sizeof(rgbTmp1) < cb) || (0 != (cb % 8)))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// both keys must be supported symmetric keys
if (UnsupportedSymKey(pWrapKey) || UnsupportedSymKey(pWrapKey))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
#ifdef CSP_USE_AES
// For now, punt on supporting AES algs in this scenario
if (CALG_AES_128 == pWrapKey->Algid ||
CALG_AES_192 == pWrapKey->Algid ||
CALG_AES_256 == pWrapKey->Algid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
#endif
if (!FIsLegalKey(pTmpUser, pWrapKey, FALSE))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// check the wrapping key ALG_ID
pAlgid = (ALG_ID*)(pbBlob + sizeof(BLOBHEADER));
if (pWrapKey->Algid != *pAlgid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// Check if we should do an auto-inflate
if (pWrapKey->pData == NULL)
{
dwSts = InflateKey(pWrapKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
// set the hardcoded IV
if (CALG_RC4 != pWrapKey->Algid)
{
memcpy(pWrapKey->IV, rgbSymmetricKeyWrapIV, 8);
pWrapKey->InProgress = FALSE;
pLocalWrapKey = pWrapKey;
}
else
{
// RC4 (or more precisely, stream ciphers) are not supported by the
// CMS spec for symmetric key wrapping. Therefore we had to do
// something proprietary to support RC4 for applications other
// than SMIME.
dwSts = GetRC4KeyForSymWrap(rgbSymmetricKeyWrapIV,
pWrapKey,
&pLocalWrapKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
fAlloc = TRUE;
}
memcpy(rgbTmp1, pbBlob + sizeof(BLOBHEADER) + sizeof(ALG_ID), cb);
// decrypt the key blob data
dwSts = SymDecrypt(pLocalWrapKey, 0, FALSE, rgbTmp1, &cb);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// byte reverse the plaintext + IV buffer
for (i = 0; i < cb; i++)
rgbTmp2[i] = rgbTmp1[cb - (i + 1)];
// set the IV if the algorithm is not RC4
cb -= 8;
if (CALG_RC4 != pWrapKey->Algid)
{
memcpy(pWrapKey->IV, rgbTmp2, 8);
pWrapKey->InProgress = FALSE;
}
else
{
if (fAlloc && pLocalWrapKey)
{
FreeNewKey(pLocalWrapKey);
pLocalWrapKey = NULL;
fAlloc = FALSE;
}
// RC4 (or more precisely, stream ciphers) are not supported by the
// CMS spec for symmetric key wrapping. Therefore we had to do
// something proprietary to support RC4 for applications other
// than SMIME.
dwSts = GetRC4KeyForSymWrap(rgbTmp2, pWrapKey, &pLocalWrapKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
fAlloc = TRUE;
}
// decrypt the key blob data again
dwSts = SymDecrypt(pLocalWrapKey, 0, FALSE, rgbTmp2 + 8, &cb);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// check the length of the key
switch (pBlobHdr->aiKeyAlg)
{
case CALG_RC2: // variable key lengths
case CALG_RC4:
cbKey = (DWORD)rgbTmp2[8];
cbIndex += 1;
break;
case CALG_DES: // Ignore the default length, and use the full DES length.
case CALG_DESX:
case CALG_CYLINK_MEK:
cbKey = DES_KEYSIZE;
break;
case CALG_3DES_112:
cbKey = DES_KEYSIZE * 2;
break;
case CALG_3DES:
cbKey = DES_KEYSIZE * 3;
break;
default:
if (!GetDefaultKeyLength(pTmpUser, pBlobHdr->aiKeyAlg,
&cbKey, &fPubKey))
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
}
// get the checksum and make sure it matches
cb -= 8;
GetSymmetricKeyChecksum(rgbTmp2 + 8, cb, rgbChecksum);
if (0 != memcmp(rgbChecksum, rgbTmp2 + 8 + cb, sizeof(rgbChecksum)))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// check if the key is to be exportable
if (dwFlags & CRYPT_EXPORTABLE)
dwRights = CRYPT_EXPORTABLE;
dwSts = MakeNewKey(pBlobHdr->aiKeyAlg, dwRights, cbKey, hUID,
rgbTmp2 + cbIndex + 8, FALSE, TRUE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// check keylength...
if (!FIsLegalKey(pTmpUser, pTmpKey, TRUE))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = NTLMakeItem(phKey, KEY_HANDLE, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if 40 bit key + no mention of salt, set zeroized salt for
// RSABase compatibility
if ((5 == pTmpKey->cbKeyLen) && (0 == (dwFlags & CRYPT_NO_SALT)))
{
dwSts = MakeKeyRSABaseCompatible(hUID, *phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
pTmpKey = NULL;
dwReturn = ERROR_SUCCESS;
ErrorExit:
if (fAlloc && pLocalWrapKey)
FreeNewKey(pLocalWrapKey);
memset(rgbTmp1, 0, sizeof(rgbTmp1));
memset(rgbTmp2, 0, sizeof(rgbTmp2));
if (NULL != pTmpKey)
FreeNewKey(pTmpKey);
return dwReturn;
}
/*
- CPExportKey
-
* Purpose:
* Export cryptographic keys out of a CSP in a secure manner
*
*
* Parameters:
* IN hUID - 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
* OUT pdwDataLen - Length of key blob in bytes
*
* Returns:
*/
BOOL WINAPI
CPExportKey(
IN HCRYPTPROV hUID,
IN HCRYPTKEY hKey,
IN HCRYPTKEY hPubKey,
IN DWORD dwBlobType,
IN DWORD dwFlags,
OUT BYTE *pbData,
OUT DWORD *pdwDataLen)
{
// return codes
DWORD dwReturn = ERROR_INTERNAL_ERROR;
BOOL fRet;
// miscellaneous variables
DWORD dwLen;
NTSimpleBlob *pSimpleHeader;
BLOBHEADER *pPreHeader;
BLOBHEADER shScratch;
RSAPUBKEY *pExpPubKey;
BSAFE_PUB_KEY *pBsafePubKey;
BSAFE_PUB_KEY *pPublicKey;
DWORD PubKeyLen;
BSAFE_PRV_KEY *pPrvKey = NULL;
DWORD PrvKeyLen = 0;
DWORD cbPrivateBlob = 0;
PBYTE pbPrivateBlob = NULL;
DWORD cb = 0;
BOOL fExportable = FALSE;
DWORD dwSts;
// temporary variables for pointing to user and key records
PNTAGKeyList pTmpKey;
PNTAGKeyList pPubKey;
PNTAGUserList pTmpUser;
EntryPoint
if (0 != (dwFlags & ~(CRYPT_SSL2_FALLBACK
| CRYPT_DESTROYKEY
| CRYPT_OAEP)))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pdwDataLen == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
if (((PUBLICKEYBLOB == dwBlobType) || (OPAQUEKEYBLOB == dwBlobType)
|| (PLAINTEXTKEYBLOB == dwBlobType))
&& (0 != hPubKey))
{
dwReturn = (DWORD)NTE_BAD_PUBLIC_KEY;
goto ErrorExit;
}
// check the user identification
pTmpUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
// check if the user is just looking for a length. If so,
// use a scratchpad to construct a pseudoblob.
if ((pbData != NULL) && (*pdwDataLen > sizeof(BLOBHEADER)))
pPreHeader = (BLOBHEADER *)pbData;
else
pPreHeader = &shScratch;
pPreHeader->bType = (BYTE)(dwBlobType & 0xff);
pPreHeader->bVersion = CUR_BLOB_VERSION;
pPreHeader->reserved = 0;
dwSts = NTLValidate((HNTAG)hKey, hUID, HNTAG_TO_HTYPE(hKey), &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (NTE_FAIL == dwSts) ? (DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
if ((dwBlobType != PUBLICKEYBLOB) &&
(0 == (pTmpKey->Rights & (CRYPT_EXPORTABLE | CRYPT_ARCHIVABLE))))
{
dwReturn = (DWORD)NTE_BAD_KEY_STATE;
goto ErrorExit;
}
pPreHeader->aiKeyAlg = pTmpKey->Algid;
switch (dwBlobType)
{
case PUBLICKEYBLOB:
{
if ((HNTAG_TO_HTYPE(hKey) != SIGPUBKEY_HANDLE) &&
(HNTAG_TO_HTYPE(hKey) != EXCHPUBKEY_HANDLE))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
pBsafePubKey = (BSAFE_PUB_KEY *) pTmpKey->pKeyValue;
if (pBsafePubKey == NULL)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
//
// Subtract off 2 extra DWORD needed by RSA code
//
dwLen = sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
((pBsafePubKey->bitlen + 7) / 8);
// Check user buffer size
if (pbData == NULL || *pdwDataLen < dwLen)
{
*pdwDataLen = dwLen;
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
pExpPubKey = (RSAPUBKEY *) (pbData + sizeof(BLOBHEADER));
pExpPubKey->magic = pBsafePubKey->magic;
pExpPubKey->bitlen = pBsafePubKey->bitlen;
pExpPubKey->pubexp = pBsafePubKey->pubexp;
memcpy((BYTE *) pbData + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY),
(BYTE *) pBsafePubKey + sizeof(BSAFE_PUB_KEY),
((pBsafePubKey->bitlen + 7) / 8));
break;
}
case PRIVATEKEYBLOB:
{
DWORD dwBlockLen = 0;
BOOL fSigKey;
LPWSTR szPrompt;
cb = sizeof(DWORD);
if (HNTAG_TO_HTYPE(hKey) == SIGPUBKEY_HANDLE)
{
fSigKey = TRUE;
szPrompt = g_Strings.pwszExportPrivSig;
pPublicKey = (BSAFE_PUB_KEY*)pTmpUser->ContInfo.pbSigPub;
PubKeyLen = pTmpUser->ContInfo.ContLens.cbSigPub;
}
else if (HNTAG_TO_HTYPE(hKey) == EXCHPUBKEY_HANDLE)
{
fSigKey = FALSE;
szPrompt = g_Strings.pwszExportPrivExch;
pPublicKey = (BSAFE_PUB_KEY*)pTmpUser->ContInfo.pbExchPub;
PubKeyLen = pTmpUser->ContInfo.ContLens.cbExchPub;
}
else
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// make sure the public key is available and appropriate
if ((pPublicKey == NULL)
|| (PubKeyLen != pTmpKey->cbKeyLen)
|| (0 != memcmp((PBYTE)pPublicKey, pTmpKey->pKeyValue, PubKeyLen)))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
GetLengthOfPrivateKeyForExport(pPublicKey, &cbPrivateBlob);
if (hPubKey)
{
if (!CPGetKeyParam(hUID, hPubKey, KP_BLOCKLEN,
(PBYTE)&dwBlockLen, &cb, 0))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// convert to byte count
dwBlockLen /= 8;
}
// Check user buffer size
if (pbData == NULL)
{
*pdwDataLen = sizeof(BLOBHEADER) + cbPrivateBlob + dwBlockLen;
dwReturn = ERROR_SUCCESS;
goto ErrorExit;
}
else if (*pdwDataLen < (sizeof(BLOBHEADER)
+ cbPrivateBlob + dwBlockLen))
{
*pdwDataLen = sizeof(BLOBHEADER) + cbPrivateBlob + dwBlockLen;
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
// if the context being used is a Verify context then the key is not
// in persisted storage and therefore is in memory
if (0 == (pTmpUser->Rights & CRYPT_VERIFYCONTEXT))
{
// always read the private key from storage when exporting
dwSts= UnprotectPrivKey(pTmpUser, szPrompt, fSigKey, TRUE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // NTE_BAD_KEYSET
goto ErrorExit;
}
}
if (fSigKey)
{
PrvKeyLen = pTmpUser->SigPrivLen;
pPrvKey = (BSAFE_PRV_KEY*)pTmpUser->pSigPrivKey;
fExportable = pTmpUser->ContInfo.fSigExportable;
}
else
{
PrvKeyLen = pTmpUser->ExchPrivLen;
pPrvKey = (BSAFE_PRV_KEY*)pTmpUser->pExchPrivKey;
fExportable = pTmpUser->ContInfo.fExchExportable;
}
if (pPrvKey == NULL)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
if (!fExportable && (0 == (CRYPT_ARCHIVABLE & pTmpKey->Rights)))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (!PreparePrivateKeyForExport(pPrvKey, NULL, &cbPrivateBlob))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
// allocate memory for the private key blob
cb = cbPrivateBlob + dwBlockLen;
pbPrivateBlob = _nt_malloc(cb);
if (NULL == pbPrivateBlob)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
if (!PreparePrivateKeyForExport(pPrvKey,
pbPrivateBlob, &cbPrivateBlob))
{
// ?BUGBUG? Fix this
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (hPubKey)
{
dwSts = LocalEncrypt(hUID, hPubKey, 0, TRUE, 0, pbPrivateBlob,
&cbPrivateBlob, cb, FALSE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
dwLen = sizeof(BLOBHEADER) + cbPrivateBlob;
CopyMemory(pbData + sizeof(BLOBHEADER), pbPrivateBlob, cbPrivateBlob);
break;
}
case SIMPLEBLOB:
{
if (HNTAG_TO_HTYPE(hKey) != KEY_HANDLE)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (0 == hPubKey)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
if (!FIsLegalKey(pTmpUser, pTmpKey, FALSE))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
#ifdef CSP_USE_SSL3
// if the SSL2_FALLBACK flag is set then make sure the key
// is an SSL2 master key
if (CRYPT_SSL2_FALLBACK & dwFlags)
{
if (CALG_SSL2_MASTER != pTmpKey->Algid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
}
#endif
dwSts = NTLValidate((HNTAG)hPubKey, hUID, EXCHPUBKEY_HANDLE,
&pPubKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (NTE_FAIL == dwSts) ? (DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
pBsafePubKey = (BSAFE_PUB_KEY *) pPubKey->pKeyValue;
if (pBsafePubKey == NULL)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
//
// Subtract off 8 bytes for 2 extra DWORD needed by RSA code
dwLen = sizeof(BLOBHEADER) + sizeof(NTSimpleBlob) +
(pBsafePubKey->bitlen + 7) / 8;
if (pbData == NULL || *pdwDataLen < dwLen)
{
*pdwDataLen = dwLen; // set what we need
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
pSimpleHeader = (NTSimpleBlob *) (pbData + sizeof(BLOBHEADER));
pSimpleHeader->aiEncAlg = CALG_RSA_KEYX;
#ifdef USE_SGC
// if this is the schannel provider and we are a verify context and
// the SGC flags are set and the key is large then make sure the
// key is the same as the SGC key
if ((PROV_RSA_SCHANNEL == pTmpUser->dwProvType) &&
(0 != pTmpUser->dwSGCFlags) &&
(pTmpUser->Rights & CRYPT_VERIFYCONTEXT) &&
(pBsafePubKey->bitlen > 1024))
{
if (!CheckSGCSimpleForExport(pTmpUser, pBsafePubKey))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
}
#endif
// perform the RSA encryption.
dwSts = RSAEncrypt(pTmpUser, pBsafePubKey, pTmpKey->pKeyValue,
pTmpKey->cbKeyLen, pTmpKey->pbParams,
pTmpKey->cbParams, dwFlags,
pbData + sizeof(BLOBHEADER) + sizeof(NTSimpleBlob));
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
}
case OPAQUEKEYBLOB:
{
dwLen = *pdwDataLen;
dwSts = ExportOpaqueBlob(pTmpKey, pbData, &dwLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if the destroy key flag is set then destroy the key
if (CRYPT_DESTROYKEY & dwFlags)
{
if (!CPDestroyKey(hUID, hKey))
{
dwReturn = GetLastError();
goto ErrorExit;
}
}
break;
}
case SYMMETRICWRAPKEYBLOB:
{
// get a pointer to the symmetric key to wrap with (the variable
// name pPubKey is a misnomer)
dwSts = NTLValidate((HNTAG)hPubKey,
hUID,
HNTAG_TO_HTYPE(hKey),
&pPubKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (NTE_FAIL == dwSts) ? (DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
dwSts = WrapSymKey(pTmpUser, pTmpKey, pPubKey, pbData, pdwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwLen = *pdwDataLen;
break;
}
case PLAINTEXTKEYBLOB:
{
if (HNTAG_TO_HTYPE(hKey) != KEY_HANDLE)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (! FIsLegalKey(pTmpUser, pTmpKey, FALSE))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
dwLen = sizeof(BLOBHEADER) + sizeof(DWORD) + pTmpKey->cbKeyLen;
if (NULL == pbData || *pdwDataLen < dwLen)
{
*pdwDataLen = dwLen;
if (NULL == pbData)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
pbData += sizeof(BLOBHEADER);
*((DWORD*)pbData) = pTmpKey->cbKeyLen;
pbData += sizeof(DWORD);
memcpy(pbData, pTmpKey->pKeyValue, pTmpKey->cbKeyLen);
*pdwDataLen = dwLen;
break;
}
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
// set the size of the key blob
*pdwDataLen = dwLen;
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (pbPrivateBlob)
_nt_free(pbPrivateBlob, cb);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*static*/ DWORD
ImportOpaqueBlob(
HCRYPTPROV hUID,
CONST BYTE *pbData,
DWORD cbData,
HCRYPTKEY *phKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGKeyList pTmpKey = NULL;
PNTAGPackedKeyList pPackedKey;
DWORD cbRequired;
DWORD dwSts;
*phKey = 0;
// allocate a temporary key structure
pTmpKey = (PNTAGKeyList)_nt_malloc(sizeof(NTAGKeyList));
if (NULL == pTmpKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
// make sure we have enough data
cbRequired = sizeof(BLOBHEADER) +
sizeof(NTAGPackedKeyList);
if (cbData < cbRequired)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// build key structure from packed key structure
pPackedKey = (PNTAGPackedKeyList)(pbData + sizeof(BLOBHEADER));
pTmpKey->hUID = hUID;
pTmpKey->Algid = pPackedKey->Algid;
pTmpKey->Rights = pPackedKey->Rights;
pTmpKey->cbKeyLen = pPackedKey->cbKeyLen;
pTmpKey->cbDataLen = pPackedKey->cbDataLen;
memcpy(pTmpKey->IV, pPackedKey->IV, sizeof(pTmpKey->IV));
memcpy(pTmpKey->FeedBack, pPackedKey->FeedBack, sizeof(pTmpKey->FeedBack));
pTmpKey->InProgress = pPackedKey->InProgress;
pTmpKey->cbSaltLen = pPackedKey->cbSaltLen;
memcpy(pTmpKey->rgbSalt, pPackedKey->rgbSalt, sizeof(pTmpKey->rgbSalt));
pTmpKey->Padding = pPackedKey->Padding;
pTmpKey->Mode = pPackedKey->Mode;
pTmpKey->ModeBits = pPackedKey->ModeBits;
pTmpKey->Permissions = pPackedKey->Permissions;
pTmpKey->EffectiveKeyLen = pPackedKey->EffectiveKeyLen;
pTmpKey->dwBlockLen = pPackedKey->dwBlockLen;
// make sure we still have enough data
cbRequired += pTmpKey->cbKeyLen +
pTmpKey->cbDataLen;
if (cbData < cbRequired)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// allocate memory and copy the key value
if (0 < pTmpKey->cbKeyLen)
{
pTmpKey->pKeyValue = _nt_malloc(pTmpKey->cbKeyLen);
if (NULL == pTmpKey->pKeyValue)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pTmpKey->pKeyValue,
(PBYTE)pPackedKey + sizeof(NTAGPackedKeyList),
pTmpKey->cbKeyLen);
}
// allocate memory and copy the key data
if (0 < pTmpKey->cbDataLen)
{
pTmpKey->pData = _nt_malloc(pTmpKey->cbDataLen);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pTmpKey->pData,
(PBYTE)pPackedKey + sizeof(NTAGPackedKeyList) + pTmpKey->cbKeyLen,
pTmpKey->cbDataLen);
}
dwSts = NTLMakeItem(phKey, KEY_HANDLE, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
pTmpKey = NULL;
dwReturn = ERROR_SUCCESS;
ErrorExit:
if (NULL != pTmpKey)
FreeNewKey(pTmpKey);
return dwReturn;
}
/*
- CPImportKey
-
* Purpose:
* Import cryptographic keys
*
*
* Parameters:
* IN hUID - 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:
*/
BOOL WINAPI
CPImportKey(
IN HCRYPTPROV hUID,
IN CONST BYTE *pbData,
IN DWORD dwDataLen,
IN HCRYPTKEY hPubKey,
IN DWORD dwFlags,
OUT HCRYPTKEY *phKey)
{
// Status return variables
DWORD dwReturn = ERROR_INTERNAL_ERROR;
BOOL fRet;
// miscellaneous variables
DWORD KeyBufLen;
CONST BYTE *pbEncPortion;
BLOBHEADER *ThisStdHeader = (BLOBHEADER *)pbData;
BSAFE_PRV_KEY *pBsafePrvKey = NULL;
BYTE *pKeyBuf = NULL;
DWORD dwRights = 0;
DWORD cbTmpLen;
DWORD dwSts;
// temporary variables for pointing to user and key records
PNTAGUserList pTmpUser = NULL;
PNTAGKeyList pTmpKey = NULL;
LPWSTR szPrompt;
BLOBHEADER *pPublic;
RSAPUBKEY *pImpPubKey;
BSAFE_PUB_KEY *pBsafePubKey;
PBYTE pbData2 = NULL;
DWORD cb;
DWORD *pcbPub;
BYTE **ppbPub;
DWORD *pcbPrv;
BYTE **ppbPrv;
BOOL *pfExportable;
BOOL fExch;
PEXPORT_PRV_KEY pExportKey;
BOOL fPubKey = FALSE;
NTSimpleBlob *ThisSB;
PNTAGKeyList pExPubKey = NULL;
BOOL fInCritSec = FALSE;
BYTE *pbParams = NULL;
DWORD cbParams = 0;
BOOL fAllowBigRC2Key = FALSE;
EntryPoint
// Validate user pointer
// count = *phKey;
if ((dwFlags & ~(CRYPT_USER_PROTECTED | CRYPT_EXPORTABLE |
CRYPT_NO_SALT | CRYPT_SGCKEY | CRYPT_OAEP |
CRYPT_IPSEC_HMAC_KEY)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if ((PUBLICKEYBLOB == ThisStdHeader->bType) && (0 != hPubKey))
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
// check the user identification
pTmpUser = (PNTAGUserList)NTLCheckList((HNTAG)hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
if (ThisStdHeader->bVersion != CUR_BLOB_VERSION)
{
dwReturn = (DWORD)NTE_BAD_VER;
goto ErrorExit;
}
// Handy pointer for decrypting the blob...
pbEncPortion = pbData + sizeof(BLOBHEADER) + sizeof(NTSimpleBlob);
// determine which key blob is being imported
switch (ThisStdHeader->bType)
{
case PUBLICKEYBLOB:
pPublic = (BLOBHEADER *) pbData;
pImpPubKey = (RSAPUBKEY *)(pbData+sizeof(BLOBHEADER));
if ((pPublic->aiKeyAlg != CALG_RSA_KEYX) &&
(pPublic->aiKeyAlg != CALG_RSA_SIGN))
{
dwReturn =(DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
cbTmpLen = (sizeof(DWORD) * 2) -
(((pImpPubKey->bitlen + 7) / 8) % (sizeof(DWORD) * 2));
if ((sizeof(DWORD) * 2) != cbTmpLen)
cbTmpLen += sizeof(DWORD) * 2;
dwSts = MakeNewKey(pPublic->aiKeyAlg,
0,
sizeof(BSAFE_PUB_KEY)
+ (pImpPubKey->bitlen / 8)
+ cbTmpLen,
hUID,
0,
FALSE,
TRUE,
&pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
pBsafePubKey = (BSAFE_PUB_KEY *)pTmpKey->pKeyValue;
pBsafePubKey->magic = pImpPubKey->magic;
pBsafePubKey->keylen = (pImpPubKey->bitlen / 8) + cbTmpLen;
pBsafePubKey->bitlen = pImpPubKey->bitlen;
pBsafePubKey->datalen = (pImpPubKey->bitlen+7)/8 - 1;
pBsafePubKey->pubexp = pImpPubKey->pubexp;
memset((BYTE *) pBsafePubKey + sizeof(BSAFE_PUB_KEY),
'\0', pBsafePubKey->keylen);
memcpy((BYTE *) pBsafePubKey + sizeof(BSAFE_PUB_KEY),
(BYTE *) pPublic + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY),
(pImpPubKey->bitlen+7)/8);
dwSts = NTLMakeItem(phKey,
(BYTE) (pPublic->aiKeyAlg == CALG_RSA_KEYX
? EXCHPUBKEY_HANDLE
: SIGPUBKEY_HANDLE),
(void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case PRIVATEKEYBLOB:
// wrap with a try since there is a critical section in here
__try
{
EnterCriticalSection(&pTmpUser->CritSec);
fInCritSec = TRUE;
pPublic = (BLOBHEADER *) pbData;
cb = dwDataLen - sizeof(BLOBHEADER);
pbData2 = _nt_malloc(cb);
if (NULL == pbData2)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
CopyMemory(pbData2, pbData + sizeof(BLOBHEADER), cb);
if (hPubKey)
{
dwSts = LocalDecrypt(hUID, hPubKey, 0, TRUE, 0,
pbData2, &cb, FALSE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
if (pPublic->aiKeyAlg == CALG_RSA_KEYX)
{
if (PROV_RSA_SIG == pTmpUser->dwProvType)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
pcbPub = &pTmpUser->ContInfo.ContLens.cbExchPub;
ppbPub = &pTmpUser->ContInfo.pbExchPub;
pcbPrv = &pTmpUser->ExchPrivLen;
ppbPrv = &pTmpUser->pExchPrivKey;
pfExportable = &pTmpUser->ContInfo.fExchExportable;
fExch = TRUE;
szPrompt = g_Strings.pwszImportPrivExch;
}
else if (pPublic->aiKeyAlg == CALG_RSA_SIGN)
{
if (PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
pcbPub = &pTmpUser->ContInfo.ContLens.cbSigPub;
ppbPub = &pTmpUser->ContInfo.pbSigPub;
pcbPrv = &pTmpUser->SigPrivLen;
ppbPrv = &pTmpUser->pSigPrivKey;
fExch = FALSE;
pfExportable = &pTmpUser->ContInfo.fSigExportable;
szPrompt = g_Strings.pwszImportPrivSig;
}
else
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// check the length of the key exchange key
pExportKey = (PEXPORT_PRV_KEY)pbData2;
#ifdef USE_SGC
// check if the provider is an SChannel provider and if so if the
// SGC flag is set then use the FIsLegalSGCKeySize function
if ((PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
&& (!(pTmpUser->Rights & CRYPT_VERIFYCONTEXT))
&& (0 != pTmpUser->dwSGCFlags)) // make sure this is server side
{
if (!FIsLegalSGCKeySize(pPublic->aiKeyAlg,
pExportKey->bitlen / 8,
FALSE, FALSE, &fPubKey))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
else
#endif
{
if (!FIsLegalKeySize(pTmpUser->dwCspTypeId,
pPublic->aiKeyAlg,
pExportKey->bitlen / 8,
FALSE, &fPubKey))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
if (!fPubKey)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
if (*ppbPub)
{
ASSERT(*pcbPub);
ASSERT(*pcbPrv);
ASSERT(*ppbPrv);
_nt_free(*ppbPub, *pcbPub);
*ppbPub = NULL;
*pcbPub = 0;
_nt_free(*ppbPrv, *pcbPrv);
*ppbPrv = NULL;
*pcbPrv = 0;
}
if (!PreparePrivateKeyForImport(pbData2, NULL, pcbPrv,
NULL, pcbPub))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
*ppbPub = _nt_malloc(*pcbPub);
if (NULL == *ppbPub)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
*ppbPrv = _nt_malloc(*pcbPrv);
if (NULL == *ppbPrv)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
if (!PreparePrivateKeyForImport(pbData2,
(LPBSAFE_PRV_KEY)*ppbPrv,
pcbPrv,
(LPBSAFE_PUB_KEY)*ppbPub,
pcbPub))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
if (dwFlags & CRYPT_EXPORTABLE)
*pfExportable = TRUE;
else
*pfExportable = FALSE;
// test the RSA key to make sure it works
dwSts = EncryptAndDecryptWithRSAKey(*ppbPub, *ppbPrv,
TRUE, FALSE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // NTE_BAD_DATA
goto ErrorExit;
}
dwSts = EncryptAndDecryptWithRSAKey(*ppbPub, *ppbPrv,
FALSE, FALSE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // NTE_BAD_DATA
goto ErrorExit;
}
// if the context being used is a Verify Context then the key
// is not persisted to storage
if (0 == (pTmpUser->Rights & CRYPT_VERIFYCONTEXT))
{
// write the new keys to the user storage file
dwSts = ProtectPrivKey(pTmpUser, szPrompt, dwFlags, (!fExch));
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
if (!CPGetUserKey(hUID,
(fExch ? AT_KEYEXCHANGE : AT_SIGNATURE),
phKey))
{
dwReturn = GetLastError();
goto ErrorExit;
}
}
__except ( EXCEPTION_EXECUTE_HANDLER )
{
// ?BUGBUG? No it's not!
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
break;
case SIMPLEBLOB:
ThisSB = (NTSimpleBlob *) (pbData + sizeof(BLOBHEADER));
if (!ValidKeyAlgid(pTmpUser, ThisStdHeader->aiKeyAlg))
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
if (ThisSB->aiEncAlg != CALG_RSA_KEYX)
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
// if the import key handle is not zero make sure it is the
if (0 != hPubKey)
{
dwSts = NTLValidate((HNTAG)hPubKey,
hUID,
HNTAG_TO_HTYPE((HNTAG)hPubKey),
&pExPubKey);
if (ERROR_SUCCESS != dwSts)
{
// NTLValidate doesn't know what error to set
// so it set NTE_FAIL -- fix it up.
dwReturn = (dwSts == NTE_FAIL) ?(DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
if ((pTmpUser->ContInfo.ContLens.cbExchPub != pExPubKey->cbKeyLen)
|| (0 != memcmp((PBYTE)pExPubKey->pKeyValue,
pTmpUser->ContInfo.pbExchPub,
pExPubKey->cbKeyLen)))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
pbParams = pExPubKey->pbParams;
cbParams = pExPubKey->cbParams;
}
pBsafePubKey = (BSAFE_PUB_KEY *)pTmpUser->ContInfo.pbExchPub;
if (NULL == pBsafePubKey)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
#ifdef USE_SGC
// check if the provider is an SChannel provider and if so if the
// SGC flag is set then use the FIsLegalSGCKeySize function
if ((PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
&& (!(pTmpUser->Rights & CRYPT_VERIFYCONTEXT))
&& (0 != pTmpUser->dwSGCFlags)) // make sure this is server side
{
if (!FIsLegalSGCKeySize(CALG_RSA_KEYX,
pBsafePubKey->bitlen / 8,
FALSE, FALSE, &fPubKey))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
else
#endif
{
if (!FIsLegalKeySize(pTmpUser->dwCspTypeId,
CALG_RSA_KEYX,
pBsafePubKey->bitlen / 8,
FALSE, &fPubKey))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
// get the key to use
dwSts = UnprotectPrivKey(pTmpUser, g_Strings.pwszImportSimple,
FALSE, FALSE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // NTE_NO_KEY
goto ErrorExit;
}
pBsafePrvKey = (BSAFE_PRV_KEY *)pTmpUser->pExchPrivKey;
if (NULL == pBsafePrvKey)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
// Check the input data length
if ((dwDataLen - (sizeof(BLOBHEADER) + sizeof(NTSimpleBlob)))
< ((pBsafePrvKey->bitlen + 7) / 8))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// perform the RSA decryption
dwSts = RSADecrypt(pTmpUser, pBsafePrvKey,
pbData + sizeof(BLOBHEADER) + sizeof(NTSimpleBlob),
dwDataLen - (sizeof(BLOBHEADER) + sizeof(NTSimpleBlob)),
pbParams, cbParams, dwFlags,
&pKeyBuf, &KeyBufLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// check if the key is CRYPT_EXPORTABLE
if (dwFlags & CRYPT_EXPORTABLE)
dwRights = CRYPT_EXPORTABLE;
#ifdef CSP_USE_SSL3
// if SSL3 or TLS1 master key then check the version
if (CALG_SSL3_MASTER == ThisStdHeader->aiKeyAlg ||
CALG_TLS1_MASTER == ThisStdHeader->aiKeyAlg)
{
if (MAKEWORD(pKeyBuf[1], pKeyBuf[0]) < 0x300)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
#endif // CSP_USE_SSL3
dwSts = MakeNewKey(ThisStdHeader->aiKeyAlg, dwRights, KeyBufLen,
hUID, pKeyBuf, TRUE, TRUE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
pKeyBuf = NULL;
// check keylength...
if (!FIsLegalImportSymKey(pTmpUser, pTmpKey, TRUE))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = NTLMakeItem(phKey, KEY_HANDLE, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if 40 bit key + no mention of salt, set zeroized salt for
// RSABase compatibility
if ((5 == KeyBufLen)
&& (0 == (dwFlags & CRYPT_NO_SALT))
&& (CALG_SSL2_MASTER != ThisStdHeader->aiKeyAlg))
{
dwSts = MakeKeyRSABaseCompatible(hUID, *phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
break;
case OPAQUEKEYBLOB:
dwSts = ImportOpaqueBlob(hUID, pbData, dwDataLen, phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case SYMMETRICWRAPKEYBLOB:
// get a pointer to the symmetric key to unwrap with (the variable
// name pExPubKey is a misnomer)
dwSts = NTLValidate((HNTAG)hPubKey, hUID,
HNTAG_TO_HTYPE((HNTAG)hPubKey),
&pExPubKey);
if (ERROR_SUCCESS != dwSts)
{
// NTLValidate doesn't know what error to set
// so it set NTE_FAIL -- fix it up.
dwReturn = (dwSts == NTE_FAIL) ? (DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
dwSts = UnWrapSymKey(hUID, pTmpUser, pExPubKey, (BYTE*)pbData,
dwDataLen, dwFlags, phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case PLAINTEXTKEYBLOB:
if (! ValidKeyAlgid(pTmpUser, ThisStdHeader->aiKeyAlg))
{
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
// check if the key is CRYPT_EXPORTABLE
if (dwFlags & CRYPT_EXPORTABLE)
dwRights = CRYPT_EXPORTABLE;
KeyBufLen = *((DWORD*)(pbData + sizeof(BLOBHEADER)));
dwSts = MakeNewKey( ThisStdHeader->aiKeyAlg, dwRights,
KeyBufLen, hUID,
(BYTE *) (pbData + sizeof(BLOBHEADER) + sizeof(DWORD)),
FALSE, TRUE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
if (CRYPT_IPSEC_HMAC_KEY & dwFlags)
fAllowBigRC2Key = TRUE;
if (! FIsLegalImportSymKey(pTmpUser, pTmpKey, fAllowBigRC2Key))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
dwSts = NTLMakeItem(phKey, KEY_HANDLE, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if 40 bit key + no mention of salt, set zeroized salt for
// RSABase compatibility
if ((5 == KeyBufLen)
&& (0 == (dwFlags & CRYPT_NO_SALT))
&& (CALG_SSL2_MASTER != ThisStdHeader->aiKeyAlg))
{
dwSts = MakeKeyRSABaseCompatible(hUID, *phKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
break;
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
pTmpKey = NULL;
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (fInCritSec)
LeaveCriticalSection(&pTmpUser->CritSec);
if (pKeyBuf)
_nt_free(pKeyBuf, KeyBufLen);
if (pbData2)
_nt_free(pbData2, dwDataLen - sizeof(BLOBHEADER));
if (NULL != pTmpKey)
FreeNewKey(pTmpKey);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*
- CPInflateKey
-
* Purpose:
* Use to "inflate" (expand) a cryptographic key for use with
* the CryptEncrypt and CryptDecrypt functions
*
* Parameters:
* IN hUID - Handle to a CSP
* IN hKey - Handle to a key
* IN dwFlags - Flags values
*
* Returns:
*/
DWORD
InflateKey(
IN PNTAGKeyList pTmpKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
BYTE *pbRealKey = NULL;
// if space for the key table has been allocated previously
// then free it
if (pTmpKey->pData != NULL)
{
ASSERT(0 != pTmpKey->cbDataLen);
_nt_free(pTmpKey->pData, pTmpKey->cbDataLen);
pTmpKey->cbDataLen = 0;
}
else
{
ASSERT(pTmpKey->cbDataLen == 0);
}
// determine the algorithm to be used
switch (pTmpKey->Algid)
{
#ifdef CSP_USE_RC2
case CALG_RC2:
pTmpKey->pData = (BYTE *)_nt_malloc(RC2_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
return NTF_FAILED;
}
pbRealKey = (BYTE *)_nt_malloc(pTmpKey->cbKeyLen
+ pTmpKey->cbSaltLen);
if (NULL == pbRealKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pbRealKey, pTmpKey->pKeyValue, pTmpKey->cbKeyLen);
memcpy(pbRealKey+pTmpKey->cbKeyLen, pTmpKey->rgbSalt,
pTmpKey->cbSaltLen);
pTmpKey->cbDataLen = RC2_TABLESIZE;
RC2KeyEx((WORD *)pTmpKey->pData,
pbRealKey,
pTmpKey->cbKeyLen + pTmpKey->cbSaltLen,
pTmpKey->EffectiveKeyLen);
break;
#endif
#ifdef CSP_USE_RC4
case CALG_RC4:
pTmpKey->pData = (BYTE *)_nt_malloc(sizeof(RC4_KEYSTRUCT));
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pbRealKey = (BYTE *)_nt_malloc(pTmpKey->cbKeyLen
+ pTmpKey->cbSaltLen);
if (NULL == pbRealKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pbRealKey, pTmpKey->pKeyValue, pTmpKey->cbKeyLen);
memcpy(pbRealKey+pTmpKey->cbKeyLen, pTmpKey->rgbSalt,
pTmpKey->cbSaltLen);
pTmpKey->cbDataLen = sizeof(RC4_KEYSTRUCT);
rc4_key((struct RC4_KEYSTRUCT *)pTmpKey->pData,
pTmpKey->cbKeyLen+pTmpKey->cbSaltLen,
pbRealKey);
break;
#endif
#ifdef CSP_USE_DES
case CALG_DES:
pTmpKey->pData = (BYTE *)_nt_malloc(DES_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pTmpKey->cbDataLen = DES_TABLESIZE;
deskey((DESTable *)pTmpKey->pData, pTmpKey->pKeyValue);
break;
#endif
#ifdef CSP_USE_3DES
case CALG_3DES_112:
pTmpKey->pData = (BYTE *)_nt_malloc(DES3_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pTmpKey->cbDataLen = DES3_TABLESIZE;
tripledes2key((PDES3TABLE)pTmpKey->pData, pTmpKey->pKeyValue);
break;
case CALG_3DES:
pTmpKey->pData = (BYTE *)_nt_malloc(DES3_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pTmpKey->cbDataLen = DES3_TABLESIZE;
tripledes3key((PDES3TABLE)pTmpKey->pData, pTmpKey->pKeyValue);
break;
#endif
#ifdef CSP_USE_SSL3
case CALG_SSL3_MASTER:
case CALG_PCT1_MASTER:
case CALG_SCHANNEL_MAC_KEY:
break;
#endif
#ifdef CSP_USE_AES
case CALG_AES_128:
pTmpKey->pData = (BYTE *)_nt_malloc(AES_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pTmpKey->cbDataLen = AES_TABLESIZE;
aeskey((AESTable *)pTmpKey->pData, pTmpKey->pKeyValue, CRYPT_AES128_ROUNDS);
break;
case CALG_AES_192:
pTmpKey->pData = (BYTE *)_nt_malloc(AES_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pTmpKey->cbDataLen = AES_TABLESIZE;
aeskey((AESTable *)pTmpKey->pData, pTmpKey->pKeyValue, CRYPT_AES192_ROUNDS);
break;
case CALG_AES_256:
pTmpKey->pData = (BYTE *)_nt_malloc(AES_TABLESIZE);
if (NULL == pTmpKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pTmpKey->cbDataLen = AES_TABLESIZE;
aeskey((AESTable *)pTmpKey->pData, pTmpKey->pKeyValue, CRYPT_AES256_ROUNDS);
break;
#endif
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
if (pbRealKey)
_nt_free(pbRealKey, pTmpKey->cbKeyLen + pTmpKey->cbSaltLen);
return dwReturn;
}
/*
- CPDestroyKey
-
* Purpose:
* Destroys the cryptographic key that is being referenced
* with the hKey parameter
*
*
* Parameters:
* IN hUID - Handle to a CSP
* IN hKey - Handle to a key
*
* Returns:
*/
BOOL WINAPI
CPDestroyKey(
IN HCRYPTPROV hUID,
IN HCRYPTKEY hKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGKeyList pTmpKey;
BOOL fRet;
DWORD dwSts;
EntryPoint
// check the user identification
if (NULL == NTLCheckList((HNTAG)hUID, USER_HANDLE))
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
dwSts = NTLValidate((HNTAG)hKey, hUID, SIGPUBKEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwSts = NTLValidate((HNTAG)hKey, hUID, EXCHPUBKEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwSts = NTLValidate((HNTAG)hKey, hUID, KEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
// NTLValidate doesn't know what error to set
// so it set NTE_FAIL -- fix it up.
dwReturn = (dwSts == NTE_FAIL)
? (DWORD)NTE_BAD_KEY
: dwSts;
goto ErrorExit;
}
}
}
// Remove from internal list first so others can't get to it, then free.
NTLDelete((HNTAG)hKey);
// scrub the memory where the key information was held
if (pTmpKey->pKeyValue)
{
ASSERT(pTmpKey->cbKeyLen);
memnuke(pTmpKey->pKeyValue, pTmpKey->cbKeyLen);
_nt_free(pTmpKey->pKeyValue, pTmpKey->cbKeyLen);
}
if (pTmpKey->pbParams)
_nt_free(pTmpKey->pbParams, pTmpKey->cbParams);
if (pTmpKey->pData)
{
ASSERT(pTmpKey->cbDataLen);
if ((CALG_SSL3_MASTER == pTmpKey->Algid) ||
(CALG_PCT1_MASTER == pTmpKey->Algid))
{
FreeSChKey((PSCH_KEY)pTmpKey->pData);
}
memnuke(pTmpKey->pData, pTmpKey->cbDataLen);
_nt_free(pTmpKey->pData, pTmpKey->cbDataLen);
}
_nt_free(pTmpKey, sizeof(NTAGKeyList));
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*
- CPGetUserKey
-
* Purpose:
* Gets a handle to a permanent user key
*
*
* Parameters:
* IN hUID - Handle to the user identifcation
* IN dwWhichKey - Specification of the key to retrieve
* OUT phKey - Pointer to key handle of retrieved key
*
* Returns:
*/
BOOL WINAPI
CPGetUserKey(
IN HCRYPTPROV hUID,
IN DWORD dwWhichKey,
OUT HCRYPTKEY *phKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pUser;
PNTAGKeyList pTmpKey;
ALG_ID Algid;
DWORD cb;
BYTE *pb;
BYTE bType;
DWORD dwExportability = 0;
BOOL fRet;
DWORD dwSts;
EntryPoint
// check the user identification
pUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
switch (dwWhichKey)
{
case AT_KEYEXCHANGE:
Algid = CALG_RSA_KEYX;
cb = pUser->ContInfo.ContLens.cbExchPub;
pb = pUser->ContInfo.pbExchPub;
if (pUser->ContInfo.fExchExportable)
dwExportability = CRYPT_EXPORTABLE;
bType = EXCHPUBKEY_HANDLE;
break;
case AT_SIGNATURE:
Algid = CALG_RSA_SIGN;
cb = pUser->ContInfo.ContLens.cbSigPub;
pb = pUser->ContInfo.pbSigPub;
if (pUser->ContInfo.fSigExportable)
dwExportability = CRYPT_EXPORTABLE;
bType = SIGPUBKEY_HANDLE;
break;
default:
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (!ValidKeyAlgid(pUser, Algid))
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
if (0 == cb)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
dwSts = MakeNewKey(Algid, dwExportability, cb, hUID, pb, FALSE, FALSE,
&pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwSts = NTLMakeItem(phKey, bType, (void *)pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*
- CPSetKeyParam
-
* Purpose:
* Allows applications to customize various aspects of the
* operations of a key
*
* Parameters:
* IN hUID - Handle to a CSP
* IN hKey - Handle to a key
* IN dwParam - Parameter number
* IN pbData - Pointer to data
* IN dwFlags - Flags values
*
* Returns:
*/
BOOL WINAPI
CPSetKeyParam(
IN HCRYPTPROV hUID,
IN HCRYPTKEY hKey,
IN DWORD dwParam,
IN CONST BYTE *pbData,
IN DWORD dwFlags)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pTmpUser;
PNTAGKeyList pTmpKey;
PCRYPT_DATA_BLOB psData;
DWORD *pdw;
DWORD dw;
BOOL fRet;
DWORD dwSts;
EntryPoint
if ((dwFlags & ~CRYPT_SERVER) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check the user identification
pTmpUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
dwSts = NTLValidate((HNTAG)hKey, hUID, KEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwSts = NTLValidate((HNTAG)hKey, hUID, SIGPUBKEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwSts = NTLValidate((HNTAG)hKey, hUID,
EXCHPUBKEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
// NTLValidate doesn't know what error to set
// so it set NTE_FAIL -- fix it up.
dwReturn = (dwSts == NTE_FAIL)
? (DWORD)NTE_BAD_KEY
: dwSts;
goto ErrorExit;
}
}
}
switch (dwParam)
{
case KP_IV:
memcpy(pTmpKey->IV, pbData, RC2_BLOCKLEN);
break;
case KP_SALT:
if ((CALG_RC2 != pTmpKey->Algid) && (CALG_RC4 != pTmpKey->Algid))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (pbData == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
if ((POLICY_MS_DEF == pTmpUser->dwCspTypeId)
|| (POLICY_MS_STRONG == pTmpUser->dwCspTypeId))
{
pTmpKey->cbSaltLen = DEFAULT_WEAK_SALT_LENGTH;
}
else
{
pTmpKey->cbSaltLen = DEFAULT_STRONG_SALT_LENGTH;
}
if (pTmpKey->cbSaltLen)
CopyMemory(pTmpKey->rgbSalt, pbData, pTmpKey->cbSaltLen);
dwSts = InflateKey(pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case KP_SALT_EX:
if ((CALG_RC2 != pTmpKey->Algid) && (CALG_RC4 != pTmpKey->Algid))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
psData = (PCRYPT_DATA_BLOB)pbData;
if (pbData == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
if (psData->cbData > MAX_SALT_LEN)
{
dwReturn = NTE_BAD_DATA;
goto ErrorExit;
}
pTmpKey->cbSaltLen = psData->cbData;
CopyMemory(pTmpKey->rgbSalt, psData->pbData, pTmpKey->cbSaltLen);
dwSts = InflateKey(pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case KP_PADDING:
if (*((DWORD *) pbData) != PKCS5_PADDING)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
break;
case KP_MODE:
if ((CALG_RSA_SIGN == pTmpKey->Algid) ||
(CALG_RSA_KEYX == pTmpKey->Algid))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (*pbData != CRYPT_MODE_CBC &&
*pbData != CRYPT_MODE_ECB &&
*pbData != CRYPT_MODE_CFB &&
*pbData != CRYPT_MODE_OFB)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
pTmpKey->Mode = *((DWORD *) pbData);
break;
case KP_MODE_BITS:
dw = *((DWORD *) pbData);
if ((dw == 0) || (dw > 64)) // if 0 or larger than the blocklength
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
pTmpKey->ModeBits = dw;
break;
case KP_PERMISSIONS:
{
DWORD dwPerm = *(LPDWORD)pbData;
if (0 != (dwPerm & ~(CRYPT_ENCRYPT|CRYPT_DECRYPT|CRYPT_EXPORT|
CRYPT_READ|CRYPT_WRITE|CRYPT_MAC|CRYPT_ARCHIVE)))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// the exportability of a key may not be changed, but it may be ignored.
if (0 != (dwPerm & CRYPT_EXPORT)
&& 0 == (pTmpKey->Permissions & CRYPT_EXPORT))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
if (0 != (dwPerm & CRYPT_ARCHIVE)
&& 0 == (pTmpKey->Permissions & CRYPT_ARCHIVE))
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
dwPerm &= ~(CRYPT_ARCHIVE | CRYPT_EXPORT);
dwPerm |= pTmpKey->Permissions & (CRYPT_ARCHIVE | CRYPT_EXPORT);
pTmpKey->Permissions = dwPerm;
break;
}
case KP_EFFECTIVE_KEYLEN:
if (CALG_RC2 != pTmpKey->Algid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
pdw = (DWORD*)pbData;
if (*pdw < RC2_MIN_EFFECTIVE_KEYLEN)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
if (POLICY_MS_DEF == pTmpUser->dwCspTypeId)
{
if (*pdw > RC2_MAX_WEAK_EFFECTIVE_KEYLEN)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
else
{
if (*pdw > RC2_MAX_STRONG_EFFECTIVE_KEYLEN)
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
}
pTmpKey->EffectiveKeyLen = *pdw;
dwSts = InflateKey(pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#ifdef CSP_USE_SSL3
case KP_CLIENT_RANDOM:
case KP_SERVER_RANDOM:
case KP_CERTIFICATE:
case KP_CLEAR_KEY:
case KP_SCHANNEL_ALG:
if (PROV_RSA_SCHANNEL != pTmpUser->dwProvType)
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwSts = SCHSetKeyParam(pTmpUser, pTmpKey, dwParam, pbData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#endif // CSP_USE_SSL3
case KP_OAEP_PARAMS:
if (CALG_RSA_KEYX != pTmpKey->Algid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
psData = (PCRYPT_DATA_BLOB)pbData;
if (pbData == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
// free salt if it already exists
if (NULL != pTmpKey->pbParams)
{
_nt_free(pTmpKey->pbParams, pTmpKey->cbParams);
pTmpKey->pbParams = NULL;
}
pTmpKey->cbParams = psData->cbData;
// alloc variable size
pTmpKey->pbParams = (BYTE *)_nt_malloc(pTmpKey->cbParams);
if (NULL == pTmpKey->pbParams)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
pTmpKey->cbParams = 0;
goto ErrorExit;
}
CopyMemory(pTmpKey->pbParams, psData->pbData, pTmpKey->cbParams);
break;
#ifdef CSP_USE_SSL3
case KP_HIGHEST_VERSION:
if ((CALG_SSL3_MASTER != pTmpKey->Algid) &&
(CALG_TLS1_MASTER != pTmpKey->Algid))
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (pbData == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
if (dwFlags & CRYPT_SERVER)
{
if ((CALG_SSL3_MASTER == pTmpKey->Algid)
&& (*(DWORD *)pbData >= 0x301))
{
// We're a server doing SSL3, and we also support TLS1.
// If the pre_master_secret contains a version number
// greater than or equal to TLS1, then abort the connection.
if (MAKEWORD(pTmpKey->pKeyValue[1], pTmpKey->pKeyValue[0]) >= 0x301)
{
dwReturn = (DWORD)NTE_BAD_VER;
goto ErrorExit;
}
}
}
else
{
pTmpKey->pKeyValue[0] = HIBYTE(*(DWORD *)pbData);
pTmpKey->pKeyValue[1] = LOBYTE(*(DWORD *)pbData);
}
break;
#endif // CSP_USE_SSL3
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*
- CPGetKeyParam
-
* Purpose:
* Allows applications to get various aspects of the
* operations of a key
*
* Parameters:
* IN hUID - Handle to a CSP
* IN hKey - Handle to a key
* IN dwParam - Parameter number
* IN pbData - Pointer to data
* IN pdwDataLen - Length of parameter data
* IN dwFlags - Flags values
*
* Returns:
*/
BOOL WINAPI
CPGetKeyParam(
IN HCRYPTPROV hUID,
IN HCRYPTKEY hKey,
IN DWORD dwParam,
IN BYTE *pbData,
IN DWORD *pwDataLen,
IN DWORD dwFlags)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pTmpUser;
PNTAGKeyList pTmpKey;
BSAFE_PUB_KEY *pBsafePubKey;
DWORD *pdw;
BOOL fRet;
DWORD dwSts;
EntryPoint
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check the user identification
pTmpUser = NTLCheckList((HNTAG)hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
dwSts = NTLValidate((HNTAG)hKey, hUID, KEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwSts = NTLValidate((HNTAG)hKey, hUID, SIGPUBKEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwSts = NTLValidate((HNTAG)hKey, hUID,
EXCHPUBKEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
// NTLValidate doesn't know what error to set
// so it set NTE_FAIL -- fix it up.
dwReturn = (dwSts == NTE_FAIL)
? (DWORD)NTE_BAD_KEY
: dwSts;
goto ErrorExit;
}
}
}
if (pwDataLen == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
switch (dwParam)
{
case KP_IV:
if (pbData == NULL || *pwDataLen < RC2_BLOCKLEN)
{
*pwDataLen = RC2_BLOCKLEN;
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
memcpy(pbData, pTmpKey->IV, RC2_BLOCKLEN);
*pwDataLen = RC2_BLOCKLEN;
break;
case KP_SALT:
if ((CALG_RC2 != pTmpKey->Algid) && (CALG_RC4 != pTmpKey->Algid))
{
if ((CALG_DES == pTmpKey->Algid)
|| (CALG_3DES == pTmpKey->Algid)
|| (CALG_3DES_112 == pTmpKey->Algid))
{
*pwDataLen = 0;
dwReturn = ERROR_SUCCESS;
goto ErrorExit;
}
else
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
}
if (pbData == NULL || (*pwDataLen < pTmpKey->cbSaltLen))
{
*pwDataLen = pTmpKey->cbSaltLen;
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
CopyMemory(pbData, pTmpKey->rgbSalt, pTmpKey->cbSaltLen);
*pwDataLen = pTmpKey->cbSaltLen;
break;
case KP_PADDING:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
*((DWORD *) pbData) = PKCS5_PADDING;
*pwDataLen = sizeof(DWORD);
break;
case KP_MODE:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
*((DWORD *) pbData) = pTmpKey->Mode;
*pwDataLen = sizeof(DWORD);
break;
case KP_MODE_BITS:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
*((DWORD *)pbData) = pTmpKey->ModeBits;
*pwDataLen = sizeof(DWORD);
break;
case KP_PERMISSIONS:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
*((DWORD *) pbData) = pTmpKey->Permissions;
*pwDataLen = sizeof(DWORD);
break;
case KP_ALGID:
if (pbData == NULL || *pwDataLen < sizeof(ALG_ID))
{
*pwDataLen = sizeof(ALG_ID);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
*((ALG_ID *) pbData) = pTmpKey->Algid;
*pwDataLen = sizeof(ALG_ID);
break;
case KP_KEYLEN:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
// ALWAYS report keylen in BITS
if ((HNTAG_TO_HTYPE(hKey) == SIGPUBKEY_HANDLE) ||
(HNTAG_TO_HTYPE(hKey) == EXCHPUBKEY_HANDLE))
{
pBsafePubKey = (BSAFE_PUB_KEY *) pTmpKey->pKeyValue;
if (pBsafePubKey == NULL)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
*((DWORD *) pbData) = pBsafePubKey->bitlen;
}
else
{
switch (pTmpKey->Algid)
{
#ifdef CSP_USE_DES
case CALG_DES:
*((DWORD *) pbData) = (DES_KEYSIZE) * 8;
break;
#endif
#ifdef CSP_USE_3DES
case CALG_3DES_112:
*((DWORD *) pbData) = (DES2_KEYSIZE) * 8;
break;
case CALG_3DES:
*((DWORD *) pbData) = (DES3_KEYSIZE) * 8;
break;
#endif
default:
*((DWORD *) pbData) = pTmpKey->cbKeyLen * 8;
}
}
*pwDataLen = sizeof(DWORD);
break;
case KP_BLOCKLEN:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
if ((HNTAG_TO_HTYPE(hKey) == SIGPUBKEY_HANDLE) ||
(HNTAG_TO_HTYPE(hKey) == EXCHPUBKEY_HANDLE))
{
pBsafePubKey = (BSAFE_PUB_KEY *) pTmpKey->pKeyValue;
if (pBsafePubKey == NULL)
{
dwReturn = (DWORD)NTE_NO_KEY;
goto ErrorExit;
}
*(DWORD *)pbData = pBsafePubKey->bitlen;
*pwDataLen = sizeof(DWORD);
}
else
{
switch (pTmpKey->Algid)
{
#ifdef CSP_USE_RC2
case CALG_RC2:
*((DWORD *) pbData) = RC2_BLOCKLEN * 8;
*pwDataLen = sizeof(DWORD);
break;
#endif
#ifdef CSP_USE_DES
case CALG_DES:
*((DWORD *) pbData) = DES_BLOCKLEN * 8;
*pwDataLen = sizeof(DWORD);
break;
#endif
#ifdef CSP_USE_3DES
case CALG_3DES_112:
case CALG_3DES:
*((DWORD *) pbData) = DES_BLOCKLEN * 8;
*pwDataLen = sizeof(DWORD);
break;
#endif
#ifdef CSP_USE_AES
case CALG_AES_128:
case CALG_AES_192:
case CALG_AES_256:
*((DWORD *) pbData) = pTmpKey->dwBlockLen * 8;
*pwDataLen = sizeof(DWORD);
break;
#endif
default:
*((DWORD *) pbData) = 0;
*pwDataLen = sizeof(DWORD);
}
}
break;
case KP_EFFECTIVE_KEYLEN:
if (CALG_RC2 != pTmpKey->Algid &&
CALG_DES != pTmpKey->Algid &&
CALG_3DES != pTmpKey->Algid &&
CALG_3DES_112 != pTmpKey->Algid)
{
dwReturn = (DWORD)NTE_BAD_KEY;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
if (pbData == NULL)
dwReturn = ERROR_SUCCESS;
else
dwReturn = ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
pdw = (DWORD*)pbData;
switch (pTmpKey->Algid)
{
case CALG_RC2:
*pdw = pTmpKey->EffectiveKeyLen;
break;
case CALG_DES:
*pdw = (DES_KEYSIZE - 1) * 8;
break;
case CALG_3DES_112:
*pdw = (DES2_KEYSIZE - 2) * 8;
break;
case CALG_3DES:
*pdw = (DES3_KEYSIZE - 3) * 8;
break;
}
break;
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*static*/ DWORD
DeletePersistedKey(
PNTAGUserList pTmpUser,
DWORD dwKeySpec)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
CHAR *pszExport;
CHAR *pszPrivKey;
CHAR *pszPubKey;
BOOL fMachineKeySet = FALSE;
DWORD dwSts;
if (pTmpUser->Rights & CRYPT_MACHINE_KEYSET)
fMachineKeySet = TRUE;
if (AT_SIGNATURE == dwKeySpec)
{
pszExport = "SExport";
pszPrivKey = "SPvK";
pszPubKey = "SPbK";
}
else if (AT_KEYEXCHANGE == dwKeySpec)
{
pszExport = "EExport";
pszPrivKey = "EPvK";
pszPubKey = "EPbK";
}
else
{
dwReturn = (DWORD)NTE_BAD_DATA;
goto ErrorExit;
}
// if protected store is available then delete the key from there
if (pTmpUser->pPStore)
{
dwSts = DeleteKeyFromProtectedStorage(
pTmpUser, &g_Strings, dwKeySpec,
fMachineKeySet, FALSE);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
// delete stuff from the registry
RegDeleteValue(pTmpUser->hKeys, pszPrivKey);
RegDeleteValue(pTmpUser->hKeys, pszPubKey);
RegDeleteValue(pTmpUser->hKeys, pszExport);
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}
#ifdef USE_SGC
//
// Function to bring all the SGC checking together
//
/*static*/ DWORD
SetSGCInfo(
PNTAGUserList pTmpUser,
CONST BYTE *pbData)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PCCERT_CONTEXT pCertContext = (PCCERT_CONTEXT)pbData;
BSAFE_PUB_KEY *pPubKey;
BYTE *pbMod;
DWORD dwSts;
// make sure the root certs are loaded
dwSts = LoadSGCRoots(&pTmpUser->CritSec);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// verify context means that you are on the client side
if (pTmpUser->Rights & CRYPT_VERIFYCONTEXT)
{
dwSts = SPQueryCFLevel(pCertContext, NULL, 0, 0,
(LPDWORD)&pTmpUser->dwSGCFlags);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// set the modulus of the SGC cert so it may be checked later
// when exporting the pre-master secret
dwSts = SGCAssignPubKey(pCertContext,
&pTmpUser->pbSGCKeyMod,
&pTmpUser->cbSGCKeyMod,
&pTmpUser->dwSGCKeyExpo);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
else
{
// get a pointer to the exchange public key
if ((0 == pTmpUser->ContInfo.ContLens.cbExchPub)
|| (NULL == pTmpUser->ContInfo.pbExchPub))
{
dwReturn = (DWORD)NTE_FAIL;
goto ErrorExit;
}
pPubKey = (BSAFE_PUB_KEY*)pTmpUser->ContInfo.pbExchPub;
pbMod = (BYTE*)pPubKey + sizeof(BSAFE_PUB_KEY);
dwSts = SPQueryCFLevel(pCertContext, pbMod, pPubKey->bitlen / 8,
pPubKey->pubexp,
(LPDWORD)&pTmpUser->dwSGCFlags);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
if (0 == pTmpUser->dwSGCFlags)
{
dwReturn = (DWORD)NTE_FAIL;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}
#endif
/*
- CPSetProvParam
-
* Purpose:
* Allows applications to customize various aspects of the
* operations of a provider
*
* Parameters:
* IN hUID - Handle to a CSP
* IN dwParam - Parameter number
* IN pbData - Pointer to data
* IN dwFlags - Flags values
*
* Returns:
*/
BOOL WINAPI
CPSetProvParam(
IN HCRYPTPROV hUID,
IN DWORD dwParam,
IN CONST BYTE *pbData,
IN DWORD dwFlags)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pTmpUser;
HCRYPTKEY hKey = 0;
BOOL fRet;
DWORD dwSts;
EntryPoint
pTmpUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
switch (dwParam)
{
case PP_KEYSET_SEC_DESCR:
if (0 != (dwFlags & ~(OWNER_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
| DACL_SECURITY_INFORMATION
| SACL_SECURITY_INFORMATION)))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (!(dwFlags & OWNER_SECURITY_INFORMATION) &&
!(dwFlags & GROUP_SECURITY_INFORMATION) &&
!(dwFlags & DACL_SECURITY_INFORMATION) &&
!(dwFlags & SACL_SECURITY_INFORMATION))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// set the security descriptor for the hKey of the keyset
dwSts = SetSecurityOnContainer(pTmpUser->ContInfo.rgwszFileName,
pTmpUser->dwProvType,
pTmpUser->Rights & CRYPT_MACHINE_KEYSET,
(SECURITY_INFORMATION)dwFlags,
(PSECURITY_DESCRIPTOR)pbData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case PP_KEY_TYPE_SUBTYPE:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
break;
case PP_UI_PROMPT:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pTmpUser->pPStore)
{
dwSts = SetUIPrompt(pTmpUser, (LPWSTR)pbData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
else
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
break;
case PP_DELETEKEY:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check if it is a verify context
if (pTmpUser->Rights & CRYPT_VERIFYCONTEXT)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
// check if the keys exists
if (!CPGetUserKey(hUID, *((DWORD*)pbData), &hKey))
{
dwReturn = GetLastError(); // (DWORD)NTE_NO_KEY
goto ErrorExit;
}
// destroy the key handle right away
if (!CPDestroyKey(hUID, hKey))
{
dwReturn = GetLastError();
goto ErrorExit;
}
// delete the key
dwSts = DeletePersistedKey(pTmpUser, *(DWORD*)pbData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case PP_SGC_INFO:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check if it is an SChannel provider
if (PROV_RSA_SCHANNEL != pTmpUser->dwProvType)
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
#ifdef USE_SGC
// check if the SGC Info (cert) is good
dwSts = SetSGCInfo(pTmpUser, pbData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts; // (DWORD)NTE_FAIL
goto ErrorExit;
}
#endif
break;
#ifdef USE_HW_RNG
#ifdef _M_IX86
case PP_USE_HARDWARE_RNG:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = GetRNGDriverHandle(&(pTmpUser->hRNGDriver));
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#endif // _M_IX86
#endif // USE_HW_RNG
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*
- CPGetProvParam
-
* Purpose:
* Allows applications to get various aspects of the
* operations of a provider
*
* Parameters:
* IN hUID - Handle to a CSP
* IN dwParam - Parameter number
* IN pbData - Pointer to data
* IN pdwDataLen - Length of parameter data
* IN dwFlags - Flags values
*
* Returns:
*/
BOOL WINAPI
CPGetProvParam(
IN HCRYPTPROV hUID,
IN DWORD dwParam,
IN BYTE *pbData,
IN DWORD *pwDataLen,
IN DWORD dwFlags)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGUserList pTmpUser;
PROV_ENUMALGS *pEnum = NULL;
PROV_ENUMALGS_EX *pEnumEx = NULL;
DWORD cbName = 0;
LPSTR pszName;
DWORD cbTmpData;
BOOL fRet;
DWORD dwSts;
EntryPoint
pTmpUser = (PNTAGUserList)NTLCheckList(hUID, USER_HANDLE);
if (NULL == pTmpUser)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
if (pwDataLen == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
switch (dwParam)
{
case PP_ENUMALGS:
if (PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
{
if ((dwFlags & ~(CRYPT_FIRST | CRYPT_NEXT | CRYPT_SGC_ENUM)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
else
{
if ((dwFlags & ~(CRYPT_FIRST | CRYPT_NEXT)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
pEnumEx = g_AlgTables[pTmpUser->dwCspTypeId];
if (dwFlags & CRYPT_FIRST)
pTmpUser->dwEnumalgs = 0;
else if (0xFFFFFFFF == pTmpUser->dwEnumalgs)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pEnumEx[pTmpUser->dwEnumalgs].aiAlgid == 0)
{
dwReturn = ERROR_NO_MORE_ITEMS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(PROV_ENUMALGS))
{
*pwDataLen = sizeof(PROV_ENUMALGS);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
// each entry in ENUMALGS is of fixed size
pEnum = (PROV_ENUMALGS *)pbData;
pEnum->aiAlgid = pEnumEx[pTmpUser->dwEnumalgs].aiAlgid;
pEnum->dwBitLen = pEnumEx[pTmpUser->dwEnumalgs].dwDefaultLen;
pEnum->dwNameLen = pEnumEx[pTmpUser->dwEnumalgs].dwNameLen;
memcpy(pEnum->szName, pEnumEx[pTmpUser->dwEnumalgs].szName,
sizeof(pEnum->szName));
*pwDataLen = sizeof(PROV_ENUMALGS);
pTmpUser->dwEnumalgs++;
break;
case PP_ENUMALGS_EX:
if (PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
{
if ((dwFlags & ~(CRYPT_FIRST | CRYPT_NEXT | CRYPT_SGC_ENUM)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
else
{
if ((dwFlags & ~(CRYPT_FIRST | CRYPT_NEXT)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
}
pEnumEx = g_AlgTables[pTmpUser->dwCspTypeId];
if (dwFlags & CRYPT_FIRST)
pTmpUser->dwEnumalgsEx = 0;
else if (0xFFFFFFFF == pTmpUser->dwEnumalgsEx)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pEnumEx[pTmpUser->dwEnumalgsEx].aiAlgid == 0)
{
dwReturn = ERROR_NO_MORE_ITEMS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(pEnumEx[0]))
{
*pwDataLen = sizeof(pEnumEx[0]);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
// each entry in ENUMALGSEX is of fixed size
memcpy(pbData, &pEnumEx[pTmpUser->dwEnumalgsEx], sizeof(pEnumEx[0]));
*pwDataLen = sizeof(pEnumEx[0]);
pTmpUser->dwEnumalgsEx++;
break;
case PP_ENUMCONTAINERS:
{
BOOL fMachineKeySet = pTmpUser->Rights & CRYPT_MACHINE_KEYSET;
if ((dwFlags & ~(CRYPT_FIRST | CRYPT_NEXT)) != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (dwFlags & CRYPT_FIRST)
{
if (0 != pTmpUser->ContInfo.hFind)
{
FindClose(pTmpUser->ContInfo.hFind);
pTmpUser->ContInfo.hFind = 0;
}
FreeEnumOldMachKeyEntries(&pTmpUser->ContInfo);
FreeEnumRegEntries(&pTmpUser->ContInfo);
pTmpUser->ContInfo.fCryptFirst = TRUE;
pTmpUser->ContInfo.fNoMoreFiles = FALSE;
}
else if (!pTmpUser->ContInfo.fCryptFirst)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = ERROR_SUCCESS;
if (!pTmpUser->ContInfo.fNoMoreFiles)
{
dwSts = GetNextContainer(pTmpUser->dwProvType,
fMachineKeySet,
dwFlags,
(LPSTR)pbData,
pwDataLen,
&pTmpUser->ContInfo.hFind);
}
// ?BUGBUG? This logic needs desperate cleaning!
if ((ERROR_SUCCESS != dwSts) || pTmpUser->ContInfo.fNoMoreFiles)
{
if ((ERROR_SUCCESS != dwSts) && (ERROR_NO_MORE_ITEMS != dwSts))
{
dwReturn = dwSts;
goto ErrorExit;
}
pTmpUser->ContInfo.fNoMoreFiles = TRUE;
if (fMachineKeySet)
{
dwSts = EnumOldMachineKeys(pTmpUser->dwProvType,
&pTmpUser->ContInfo);
if (ERROR_SUCCESS != dwSts)
{
if (ERROR_NO_MORE_ITEMS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
}
dwSts = EnumRegKeys(&pTmpUser->ContInfo,
fMachineKeySet,
pTmpUser->dwProvType,
pbData,
pwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
cbTmpData = *pwDataLen;
if ((!fMachineKeySet)
|| (0 != (dwSts = GetNextEnumedOldMachKeys(&pTmpUser->ContInfo,
fMachineKeySet,
pbData,
&cbTmpData))))
{
if (0 != (dwSts = GetNextEnumedRegKeys(&pTmpUser->ContInfo,
pbData,
pwDataLen)))
{
dwReturn = dwSts;
goto ErrorExit;
}
}
else
*pwDataLen = cbTmpData;
}
break;
}
case PP_IMPTYPE:
if (0 != dwFlags)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
*((DWORD *) pbData) = CRYPT_IMPL_SOFTWARE;
break;
case PP_NAME:
if (0 != dwFlags)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
ASSERT(NULL != pTmpUser->szProviderName);
if (NULL != pTmpUser->szProviderName)
cbName = (lstrlen(pTmpUser->szProviderName) + 1) * sizeof(CHAR);
else
cbName = 0;
if (pbData == NULL || *pwDataLen < cbName)
{
*pwDataLen = cbName;
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = cbName;
memcpy(pbData, pTmpUser->szProviderName, cbName);
break;
case PP_VERSION:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
*((DWORD *) pbData) = 0x200; // ?BUGBUG? Symbolic?
break;
case PP_CONTAINER:
if (0 != dwFlags)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
pszName = pTmpUser->ContInfo.pszUserName;
if (pbData == NULL || *pwDataLen < (strlen(pszName) + 1))
{
*pwDataLen = strlen(pszName) + 1;
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = strlen(pszName) + 1;
strcpy((LPSTR)pbData, pszName);
break;
case PP_UNIQUE_CONTAINER:
if (0 != dwFlags)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = GetUniqueContainerName(&pTmpUser->ContInfo,
pbData, pwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case PP_KEYSET_SEC_DESCR:
if (0 != (dwFlags & ~(OWNER_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
| DACL_SECURITY_INFORMATION
| SACL_SECURITY_INFORMATION)))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (!(dwFlags & OWNER_SECURITY_INFORMATION) &&
!(dwFlags & GROUP_SECURITY_INFORMATION) &&
!(dwFlags & DACL_SECURITY_INFORMATION) &&
!(dwFlags & SACL_SECURITY_INFORMATION))
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = GetSecurityOnContainer(pTmpUser->ContInfo.rgwszFileName,
pTmpUser->dwProvType,
pTmpUser->Rights & CRYPT_MACHINE_KEYSET,
(SECURITY_INFORMATION)dwFlags,
(PSECURITY_DESCRIPTOR)pbData,
pwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case PP_KEYSTORAGE:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
if (pTmpUser->pPStore)
*((DWORD*)pbData) = CRYPT_PSTORE
| CRYPT_UI_PROMPT
| CRYPT_SEC_DESCR;
else
*((DWORD*)pbData) = CRYPT_SEC_DESCR;
break;
case PP_PROVTYPE:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
*((DWORD*)pbData) = pTmpUser->dwProvType;
break;
case PP_KEYSET_TYPE:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
if (pTmpUser->Rights & CRYPT_MACHINE_KEYSET)
*(DWORD*)pbData = CRYPT_MACHINE_KEYSET;
else
*(DWORD*)pbData = 0;
break;
case PP_SIG_KEYSIZE_INC:
case PP_KEYX_KEYSIZE_INC:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
*((DWORD*)pbData) = RSA_KEYSIZE_INC;
break;
case PP_SGC_INFO:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check if it is an SChannel provider
if (PROV_RSA_SCHANNEL != pTmpUser->dwProvType)
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
// return the SGC Flags
#ifdef USE_SGC
*((DWORD*)pbData) = pTmpUser->dwSGCFlags;
#else
*((DWORD*)pbData) = 0;
#endif
break;
#ifdef USE_HW_RNG
#ifdef _M_IX86
case PP_USE_HARDWARE_RNG:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
*pwDataLen = 0;
// check if the hardware RNG is available for use
dwSts = CheckIfRNGAvailable();
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#endif // _M_IX86
#endif // USE_HW_RNG
case PP_KEYSPEC:
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
if (PROV_RSA_SIG == pTmpUser->dwProvType)
*((DWORD*)pbData) = AT_SIGNATURE;
else if (PROV_RSA_FULL == pTmpUser->dwProvType)
*((DWORD*)pbData) = AT_SIGNATURE | AT_KEYEXCHANGE;
else if (PROV_RSA_SCHANNEL == pTmpUser->dwProvType)
*((DWORD*)pbData) = AT_KEYEXCHANGE;
break;
case PP_ENUMEX_SIGNING_PROT:
if (0 != dwFlags)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
*pwDataLen = 0;
break;
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*
- CPSetHashParam
-
* Purpose:
* Allows applications to customize various aspects of the
* operations of a hash
*
* Parameters:
* IN hUID - Handle to a CSP
* IN hHash - Handle to a hash
* IN dwParam - Parameter number
* IN pbData - Pointer to data
* IN dwFlags - Flags values
*
* Returns:
*/
BOOL WINAPI
CPSetHashParam(
IN HCRYPTPROV hUID,
IN HCRYPTHASH hHash,
IN DWORD dwParam,
IN CONST BYTE *pbData,
IN DWORD dwFlags)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGHashList pTmpHash;
PNTAGKeyList pTmpKey;
MD4_object *pMD4Hash;
MD5_object *pMD5Hash;
A_SHA_CTX *pSHAHash;
MACstate *pMAC;
PHMAC_INFO pHMACInfo;
BYTE *pb;
BOOL fRet;
DWORD dwSts;
EntryPoint
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check the user identification
if (NTLCheckList((HNTAG)hUID, USER_HANDLE) == NULL)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
dwSts = NTLValidate(hHash, hUID, HASH_HANDLE, &pTmpHash);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (dwSts == NTE_FAIL) ? (DWORD)NTE_BAD_HASH : dwSts;
goto ErrorExit;
}
switch (dwParam)
{
case HP_HASHVAL:
switch (pTmpHash->Algid)
{
#ifdef CSP_USE_MD2
case CALG_MD2:
{
MD2_object *pMD2Hash;
pMD2Hash = (MD2_object *) pTmpHash->pHashData;
if (pMD2Hash->FinishFlag == TRUE)
{
dwReturn = (DWORD)NTE_BAD_HASH_STATE;
goto ErrorExit;
}
memcpy(&pMD2Hash->MD.state, pbData, MD2DIGESTLEN);
break;
}
#endif
#ifdef CSP_USE_MD4
case CALG_MD4:
pMD4Hash = (MD4_object *) pTmpHash->pHashData;
if (pMD4Hash->FinishFlag == TRUE)
{
dwReturn = (DWORD)NTE_BAD_HASH_STATE;
goto ErrorExit;
}
memcpy (&pMD4Hash->MD, pbData, MD4DIGESTLEN);
break;
#endif
#ifdef CSP_USE_MD5
case CALG_MD5:
pMD5Hash = (MD5_object *) pTmpHash->pHashData;
if (pMD5Hash->FinishFlag == TRUE)
{
dwReturn = (DWORD)NTE_BAD_HASH_STATE;
goto ErrorExit;
}
memcpy (pMD5Hash->digest, pbData, MD5DIGESTLEN);
break;
#endif
#ifdef CSP_USE_SHA
case CALG_SHA:
pSHAHash = (A_SHA_CTX *) pTmpHash->pHashData;
if (pSHAHash->FinishFlag == TRUE)
{
dwReturn = (DWORD)NTE_BAD_HASH_STATE;
goto ErrorExit;
}
memcpy (pSHAHash->HashVal, pbData, A_SHA_DIGEST_LEN);
break;
#endif
#ifdef CSP_USE_SSL3SHAMD5
case CALG_SSL3_SHAMD5:
memcpy (pTmpHash->pHashData, pbData, SSL3_SHAMD5_LEN);
break;
#endif
#ifdef CSP_USE_MAC
case CALG_MAC:
pMAC = (MACstate *)pTmpHash->pHashData;
dwSts = NTLValidate(pTmpHash->hKey, hUID, KEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (dwSts == NTE_FAIL) ? (DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
if (pMAC->FinishFlag == TRUE)
{
dwReturn = (DWORD)NTE_BAD_HASH_STATE;
goto ErrorExit;
}
memcpy(pTmpKey->FeedBack, pbData, pTmpKey->dwBlockLen);
break;
#endif
default:
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
pTmpHash->dwHashState |= DATA_IN_HASH;
break;
case HP_HMAC_INFO:
if (CALG_HMAC != pTmpHash->Algid)
{
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
pHMACInfo = (PHMAC_INFO)pbData;
pTmpHash->HMACAlgid = pHMACInfo->HashAlgid;
// now that we know the type of hash we can create it
dwSts = LocalCreateHash(pTmpHash->HMACAlgid,
(BYTE**)&pTmpHash->pHashData,
&pTmpHash->dwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// if the length of the inner string is 0 then use the default string
if (0 == pHMACInfo->cbInnerString)
pTmpHash->cbHMACInner = HMAC_DEFAULT_STRING_LEN;
else
pTmpHash->cbHMACInner = pHMACInfo->cbInnerString;
pb = _nt_malloc(pTmpHash->cbHMACInner);
if (NULL == pb)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
if (0 == pHMACInfo->cbInnerString)
memset(pb, 0x36, pTmpHash->cbHMACInner);
else
memcpy(pb, pHMACInfo->pbInnerString, pTmpHash->cbHMACInner);
if (pTmpHash->pbHMACInner)
_nt_free(pTmpHash->pbHMACInner, pTmpHash->cbHMACInner);
pTmpHash->pbHMACInner = pb;
// if the length of the outer string is 0 then use the default string
if (0 == pHMACInfo->cbOuterString)
pTmpHash->cbHMACOuter = HMAC_DEFAULT_STRING_LEN;
else
pTmpHash->cbHMACOuter = pHMACInfo->cbOuterString;
pb = _nt_malloc(pTmpHash->cbHMACOuter);
if (NULL == pb)
{
_nt_free(pTmpHash->pbHMACInner, pTmpHash->cbHMACInner);
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
if (0 == pHMACInfo->cbOuterString)
memset(pb, 0x5C, pTmpHash->cbHMACOuter);
else
memcpy(pb, pHMACInfo->pbOuterString, pTmpHash->cbHMACOuter);
if (pTmpHash->pbHMACOuter)
_nt_free(pTmpHash->pbHMACOuter, pTmpHash->cbHMACOuter);
pTmpHash->pbHMACOuter = pb;
break;
#ifdef CSP_USE_SSL3
case HP_TLS1PRF_LABEL:
case HP_TLS1PRF_SEED:
{
if (CALG_TLS1PRF != pTmpHash->Algid)
{
dwReturn = (DWORD)NTE_BAD_HASH;
goto ErrorExit;
}
dwSts = SetPRFHashParam((PRF_HASH*)pTmpHash->pHashData,
dwParam, pbData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
pTmpHash->dwHashState |= DATA_IN_HASH;
break;
}
#endif
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
if (dwParam == HP_HASHVAL)
pTmpHash->HashFlags |= HF_VALUE_SET;
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*static*/ DWORD
LocalGetHashVal(
IN ALG_ID Algid,
IN DWORD dwHashFlags,
IN OUT BYTE *pbHashData,
OUT BYTE *pbHashVal,
OUT DWORD *pcbHashVal)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
MD2_object *pMD2Hash;
MD4_object *pMD4Hash;
MD5_object *pMD5Hash;
A_SHA_CTX *pSHAHash;
switch (Algid)
{
#ifdef CSP_USE_MD2
case CALG_MD2:
// make sure there's enough room.
if (pbHashVal == NULL || *pcbHashVal < MD2DIGESTLEN)
{
*pcbHashVal = MD2DIGESTLEN;
dwReturn = (pbHashVal == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
pMD2Hash = (MD2_object *)pbHashData;
if ((dwHashFlags & HF_VALUE_SET) == 0)
{
if (pMD2Hash->FinishFlag == TRUE)
{
*pcbHashVal = MD2DIGESTLEN;
memcpy(pbHashVal, pMD2Hash->MD.state, MD2DIGESTLEN);
break;
}
// set the finish flag on the hash and
// process what's left in the buffer.
pMD2Hash->FinishFlag = TRUE;
// Finish offthe hash
MD2Final(&pMD2Hash->MD);
}
*pcbHashVal = MD2DIGESTLEN;
memcpy (pbHashVal, pMD2Hash->MD.state, MD2DIGESTLEN);
break;
#endif
#ifdef CSP_USE_MD4
case CALG_MD4:
// make sure there's enough room.
if (pbHashVal == NULL || *pcbHashVal < MD4DIGESTLEN)
{
*pcbHashVal = MD4DIGESTLEN;
dwReturn = (pbHashVal == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
pMD4Hash = (MD4_object *)pbHashData;
if ((dwHashFlags & HF_VALUE_SET) == 0)
{
if (pMD4Hash->FinishFlag == TRUE)
{
*pcbHashVal = MD4DIGESTLEN;
memcpy(pbHashVal, &pMD4Hash->MD, *pcbHashVal);
break;
}
// set the finish flag on the hash and
// process what's left in the buffer.
pMD4Hash->FinishFlag = TRUE;
if (MD4_SUCCESS != MDupdate(&pMD4Hash->MD, pMD4Hash->Buf,
MD4BYTESTOBITS(pMD4Hash->BufLen)))
{
dwReturn = (DWORD)NTE_FAIL;
goto ErrorExit;
}
}
*pcbHashVal = MD4DIGESTLEN;
memcpy(pbHashVal, &pMD4Hash->MD, *pcbHashVal);
break;
#endif
#ifdef CSP_USE_MD5
case CALG_MD5:
// make sure there's enough room.
if (pbHashVal == NULL || *pcbHashVal < MD5DIGESTLEN)
{
*pcbHashVal = MD5DIGESTLEN;
dwReturn = (pbHashVal == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
pMD5Hash = (MD5_object *)pbHashData;
if ((dwHashFlags & HF_VALUE_SET) == 0)
{
if (pMD5Hash->FinishFlag == TRUE)
{
*pcbHashVal = MD5DIGESTLEN;
memcpy (pbHashVal, pMD5Hash->digest, MD5DIGESTLEN);
break;
}
// set the finish flag on the hash and
// process what's left in the buffer.
pMD5Hash->FinishFlag = TRUE;
// Finish offthe hash
MD5Final(pMD5Hash);
}
*pcbHashVal = MD5DIGESTLEN;
memcpy (pbHashVal, pMD5Hash->digest, MD5DIGESTLEN);
break;
#endif
#ifdef CSP_USE_SHA
case CALG_SHA:
// make sure there's enough room.
if (pbHashVal == NULL || *pcbHashVal < A_SHA_DIGEST_LEN)
{
*pcbHashVal = A_SHA_DIGEST_LEN;
dwReturn = (pbHashVal == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
pSHAHash = (A_SHA_CTX *)pbHashData;
if ((dwHashFlags & HF_VALUE_SET) == 0)
{
if (pSHAHash->FinishFlag == TRUE)
{
*pcbHashVal = A_SHA_DIGEST_LEN;
memcpy (pbHashVal, pSHAHash->HashVal, A_SHA_DIGEST_LEN);
break;
}
// set the finish flag on the hash and
// process what's left in the buffer.
pSHAHash->FinishFlag = TRUE;
// Finish off the hash
A_SHAFinal(pSHAHash, pSHAHash->HashVal);
}
*pcbHashVal = A_SHA_DIGEST_LEN;
memcpy (pbHashVal, pSHAHash->HashVal, A_SHA_DIGEST_LEN);
break;
#endif
default:
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}
/*static*/ DWORD
GetHashLength(
IN ALG_ID Algid)
{
DWORD cbLen;
switch (Algid)
{
#ifdef CSP_USE_MD2
case CALG_MD2:
cbLen = MD2DIGESTLEN;
break;
#endif
#ifdef CSP_USE_MD4
case CALG_MD4:
cbLen = MD4DIGESTLEN;
break;
#endif
#ifdef CSP_USE_MD5
case CALG_MD5:
cbLen = MD5DIGESTLEN;
break;
#endif
#ifdef CSP_USE_SHA
case CALG_SHA:
cbLen = A_SHA_DIGEST_LEN;
break;
#endif
default:
ASSERT(FALSE);
cbLen = 0;
}
return cbLen;
}
/*
- CPGetHashParam
-
* Purpose:
* Allows applications to get various aspects of the
* operations of a key
*
* Parameters:
* IN hUID - Handle to a CSP
* IN hHash - Handle to a hash
* IN dwParam - Parameter number
* IN pbData - Pointer to data
* IN pdwDataLen - Length of parameter data
* IN dwFlags - Flags values
*
* Returns:
*/
BOOL WINAPI
CPGetHashParam(
IN HCRYPTPROV hUID,
IN HCRYPTHASH hHash,
IN DWORD dwParam,
IN BYTE *pbData,
IN DWORD *pwDataLen,
IN DWORD dwFlags)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGHashList pTmpHash;
MACstate *pMAC;
BYTE MACbuf[2*MAX_BLOCKLEN];
PNTAGKeyList pTmpKey;
BYTE rgbFinalHash[A_SHA_DIGEST_LEN];
DWORD cbFinalHash;
DWORD cb;
BYTE *pb = NULL;
DWORD cbHashData;
BYTE *pbHashData = NULL;
DWORD i;
BOOL fRet;
DWORD dwSts;
EntryPoint
if (dwFlags != 0)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
// check the user identification
if (NTLCheckList ((HNTAG)hUID, USER_HANDLE) == NULL)
{
dwReturn = (DWORD)NTE_BAD_UID;
goto ErrorExit;
}
if (pwDataLen == NULL)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
dwSts = NTLValidate(hHash, hUID, HASH_HANDLE, &pTmpHash);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (dwSts == NTE_FAIL) ? (DWORD)NTE_BAD_HASH : dwSts;
goto ErrorExit;
}
switch (dwParam)
{
case HP_ALGID:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
*((DWORD *) pbData) = pTmpHash->Algid;
*pwDataLen = sizeof(DWORD);
break;
case HP_HASHSIZE:
if (pbData == NULL || *pwDataLen < sizeof(DWORD))
{
*pwDataLen = sizeof(DWORD);
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
switch (pTmpHash->Algid)
{
case CALG_MD2:
case CALG_MD4:
case CALG_MD5:
case CALG_SHA:
*(DWORD *)pbData = GetHashLength(pTmpHash->Algid);
break;
#ifdef CSP_USE_MAC
case CALG_MAC:
*(DWORD *)pbData = MAX_BLOCKLEN;
break;
#endif // CSP_USE_MAC
case CALG_HMAC:
*(DWORD *)pbData = GetHashLength(pTmpHash->HMACAlgid);
break;
#ifdef CSP_USE_SSL3SHAMD5
case CALG_SSL3_SHAMD5:
*((DWORD *) pbData) = SSL3_SHAMD5_LEN;
break;
#endif
default:
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
*pwDataLen = sizeof(DWORD);
break;
case HP_HASHVAL:
switch (pTmpHash->Algid)
{
#ifdef CSP_USE_SSL3SHAMD5
case CALG_SSL3_SHAMD5:
// make sure there's enough room.
if (pbData == NULL || *pwDataLen < SSL3_SHAMD5_LEN)
{
*pwDataLen = SSL3_SHAMD5_LEN;
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
// Hash value must have already been set.
if ((pTmpHash->HashFlags & HF_VALUE_SET) == 0)
{
dwReturn = (DWORD)NTE_BAD_HASH_STATE;
goto ErrorExit;
}
*pwDataLen = SSL3_SHAMD5_LEN;
memcpy (pbData, pTmpHash->pHashData, SSL3_SHAMD5_LEN);
break;
#endif
#ifdef CSP_USE_MAC
case CALG_MAC:
pMAC = (MACstate *)pTmpHash->pHashData;
dwSts = NTLValidate(pTmpHash->hKey, hUID, KEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (dwSts == NTE_FAIL) ? (DWORD)NTE_BAD_KEY : dwSts;
goto ErrorExit;
}
// make sure there is enough room.
if (pbData == NULL || (*pwDataLen < pTmpKey->dwBlockLen))
{
*pwDataLen = pTmpKey->dwBlockLen;
dwReturn = (pbData == NULL) ? ERROR_SUCCESS : ERROR_MORE_DATA;
goto ErrorExit;
}
if (pMAC->FinishFlag == TRUE)
{
*pwDataLen = pTmpKey->dwBlockLen;
memcpy(pbData, pTmpKey->FeedBack, pTmpKey->dwBlockLen);
break;
}
// set the finish flag on the hash and
// process what's left in the buffer.
pMAC->FinishFlag = TRUE;
if (pMAC->dwBufLen)
{
memset(MACbuf, 0, 2*MAX_BLOCKLEN);
memcpy(MACbuf, pMAC->Buffer, pMAC->dwBufLen);
switch (pTmpKey->Algid)
{
case CALG_RC2:
dwSts = BlockEncrypt(RC2, pTmpKey, RC2_BLOCKLEN, TRUE,
MACbuf, &pMAC->dwBufLen,
2*MAX_BLOCKLEN);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
case CALG_DES:
dwSts = BlockEncrypt(des, pTmpKey, DES_BLOCKLEN, TRUE,
MACbuf, &pMAC->dwBufLen,
2*MAX_BLOCKLEN);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#ifdef CSP_USE_3DES
case CALG_3DES_112:
case CALG_3DES:
dwSts = BlockEncrypt(tripledes, pTmpKey, DES_BLOCKLEN,
TRUE, MACbuf, &pMAC->dwBufLen,
2*MAX_BLOCKLEN);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#endif
#ifdef CSP_USE_AES
case CALG_AES_128:
case CALG_AES_192:
case CALG_AES_256:
dwSts = BlockEncrypt(aes, pTmpKey, pTmpKey->dwBlockLen,
TRUE, MACbuf, &pMAC->dwBufLen,
2*MAX_BLOCKLEN);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#endif
// default: It's not a block cipher.
}
}
*pwDataLen = pTmpKey->dwBlockLen;
memcpy(pbData, pTmpKey->FeedBack, pTmpKey->dwBlockLen);
break;
#endif
case CALG_HMAC:
if (!(pTmpHash->HMACState & HMAC_FINISHED))
{
cbFinalHash = sizeof(rgbFinalHash);
dwSts = LocalGetHashVal(pTmpHash->HMACAlgid,
pTmpHash->HashFlags,
pTmpHash->pHashData,
rgbFinalHash,
&cbFinalHash);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
// now XOR the outer string with the key and hash
// over this and the inner hash
dwSts = NTLValidate(pTmpHash->hKey, hUID,
KEY_HANDLE, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (dwSts == NTE_FAIL)
? (DWORD)NTE_BAD_KEY
: dwSts;
goto ErrorExit;
}
if (pTmpKey->cbKeyLen < pTmpHash->cbHMACOuter)
cb = pTmpHash->cbHMACOuter;
else
cb = pTmpKey->cbKeyLen;
pb = (BYTE *)_nt_malloc(cb);
if (NULL == pb)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pb, pTmpHash->pbHMACOuter, pTmpHash->cbHMACOuter);
// currently no support for byte reversed keys with HMAC
for (i=0;i<pTmpKey->cbKeyLen;i++)
pb[i] ^= (pTmpKey->pKeyValue)[i];
dwSts = LocalCreateHash(pTmpHash->HMACAlgid,
&pbHashData,
&cbHashData);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwSts = LocalHashData(pTmpHash->HMACAlgid, pbHashData,
pb, cb);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwSts = LocalHashData(pTmpHash->HMACAlgid, pbHashData,
rgbFinalHash, cbFinalHash);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
_nt_free(pTmpHash->pHashData, pTmpHash->dwDataLen);
pTmpHash->dwDataLen = cbHashData;
pTmpHash->pHashData = pbHashData;
pbHashData = NULL;
pTmpHash->HMACState |= HMAC_FINISHED;
}
dwSts = LocalGetHashVal(pTmpHash->HMACAlgid, pTmpHash->HashFlags,
pTmpHash->pHashData, pbData, pwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
#ifdef CSP_USE_SSL3
case CALG_TLS1PRF:
{
dwSts = CalculatePRF((PRF_HASH*)pTmpHash->pHashData,
pbData, pwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
break;
}
#endif
default:
dwSts = LocalGetHashVal(pTmpHash->Algid, pTmpHash->HashFlags,
pTmpHash->pHashData, pbData, pwDataLen);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
}
break;
default:
dwReturn = (DWORD)NTE_BAD_TYPE;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (pb)
_nt_free(pb, cb);
if (pbHashData)
_nt_free(pbHashData, cbHashData);
if (!fRet)
SetLastError(dwReturn);
return fRet;
}
/*static*/ DWORD
CopyKey(
IN PNTAGKeyList pOldKey,
OUT PNTAGKeyList *ppNewKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGKeyList pNewKey;
pNewKey = (PNTAGKeyList)_nt_malloc(sizeof(NTAGKeyList));
if (NULL == pNewKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pNewKey, pOldKey, sizeof(NTAGKeyList));
pNewKey->Rights &= ~CRYPT_ARCHIVABLE;
pNewKey->Permissions &= ~CRYPT_ARCHIVE;
pNewKey->pKeyValue = NULL;
pNewKey->cbDataLen = 0;
pNewKey->pData = NULL;
pNewKey->cbSaltLen = 0;
pNewKey->cbKeyLen = pOldKey->cbKeyLen;
if (pNewKey->cbKeyLen)
{
pNewKey->pKeyValue = (BYTE*)_nt_malloc(pNewKey->cbKeyLen);
if (NULL == pNewKey->pKeyValue)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
}
memcpy(pNewKey->pKeyValue, pOldKey->pKeyValue, pNewKey->cbKeyLen);
pNewKey->cbDataLen = pOldKey->cbDataLen;
if (pNewKey->cbDataLen)
{
pNewKey->pData = (BYTE*)_nt_malloc(pNewKey->cbDataLen);
if (NULL == pNewKey->pData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
}
memcpy(pNewKey->pData, pOldKey->pData, pNewKey->cbDataLen);
if (pOldKey->Algid == CALG_PCT1_MASTER)
{
// This is a PCT master key, and so it might have some certificate
// data attached to it. If this is the case, then make a copy
// of the certificate data and attach it to the new key.
if (pOldKey->cbDataLen == sizeof(SCH_KEY))
{
PSCH_KEY pOldSChKey = (PSCH_KEY)pOldKey->pData;
PSCH_KEY pNewSChKey = (PSCH_KEY)pNewKey->pData;
if (pOldSChKey->pbCertData && pOldSChKey->cbCertData)
{
pNewSChKey->pbCertData = (BYTE*)_nt_malloc(pOldSChKey->cbCertData);
if (NULL == pNewSChKey->pbCertData)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
memcpy(pNewSChKey->pbCertData,
pOldSChKey->pbCertData,
pOldSChKey->cbCertData);
}
}
}
pNewKey->cbSaltLen = pOldKey->cbSaltLen;
memcpy(pNewKey->rgbSalt, pOldKey->rgbSalt, pNewKey->cbSaltLen);
*ppNewKey = pNewKey;
pNewKey = NULL;
dwReturn = ERROR_SUCCESS;
ErrorExit:
if (NULL != pNewKey)
FreeNewKey(pNewKey);
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:
*/
BOOL WINAPI
CPDuplicateKey(
IN HCRYPTPROV hUID,
IN HCRYPTKEY hKey,
IN DWORD *pdwReserved,
IN DWORD dwFlags,
IN HCRYPTKEY *phKey)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
PNTAGKeyList pTmpKey;
PNTAGKeyList pNewKey = NULL;
BYTE bType = KEY_HANDLE;
BOOL fRet;
DWORD dwSts;
EntryPoint
if (NULL != pdwReserved)
{
dwReturn = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
if (0 != dwFlags)
{
dwReturn = (DWORD)NTE_BAD_FLAGS;
goto ErrorExit;
}
dwSts = NTLValidate((HNTAG)hKey, hUID, bType, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
bType = SIGPUBKEY_HANDLE;
dwSts = NTLValidate((HNTAG)hKey, hUID, bType, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
bType = EXCHPUBKEY_HANDLE;
dwSts = NTLValidate((HNTAG)hKey, hUID, bType, &pTmpKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = (NTE_FAIL == dwSts)
? (DWORD)NTE_BAD_KEY
: dwSts;
goto ErrorExit;
}
}
}
dwSts = CopyKey(pTmpKey, &pNewKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwSts = NTLMakeItem(phKey, bType, (void *)pNewKey);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
fRet = (ERROR_SUCCESS == dwReturn);
if (!fRet)
{
if (NULL != pNewKey)
FreeNewKey(pNewKey);
SetLastError(dwReturn);
}
return fRet;
}
//
// Function : TestEncDec
//
// Description : This function expands the passed in key buffer for the
// appropriate algorithm, and then either encryption or
// decryption is performed. A comparison is then made to see
// if the ciphertext or plaintext matches the expected value.
// The function only uses ECB mode for block ciphers and the
// plaintext buffer must be the same length as the ciphertext
// buffer. The length of the plaintext must be either the
// block length of the cipher if it is a block cipher or less
// than MAX_BLOCKLEN if a stream cipher is being used.
//
/*static*/ DWORD
TestEncDec(
IN ALG_ID Algid,
IN BYTE *pbKey,
IN DWORD cbKey,
IN BYTE *pbPlaintext,
IN DWORD cbPlaintext,
IN BYTE *pbCiphertext,
IN BYTE *pbIV,
IN int iOperation)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
BYTE *pbExpandedKey = NULL;
BYTE rgbBuffIn[MAX_BLOCKLEN];
BYTE rgbBuffOut[MAX_BLOCKLEN];
DWORD i;
memset(rgbBuffIn, 0, sizeof(rgbBuffIn));
memset(rgbBuffOut, 0, sizeof(rgbBuffOut));
// length of data to encrypt must be < MAX_BLOCKLEN
if (cbPlaintext > MAX_BLOCKLEN)
{
dwReturn = (DWORD)NTE_BAD_LEN;
goto ErrorExit;
}
// alloc for and expand the key
switch (Algid)
{
#ifdef CSP_USE_RC4
case (CALG_RC4):
pbExpandedKey = _nt_malloc(sizeof(RC4_KEYSTRUCT));
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
rc4_key((RC4_KEYSTRUCT*)pbExpandedKey, cbKey, pbKey);
break;
#endif // CSP_USE_RC4
#ifdef CSP_USE_RC2
case (CALG_RC2):
pbExpandedKey = _nt_malloc(RC2_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
RC2KeyEx((WORD*)pbExpandedKey, pbKey, cbKey, cbKey * 8);
break;
#endif // CSP_USE_RC2
#ifdef CSP_USE_DES40
case (CALG_DES40):
pbExpandedKey = _nt_malloc(DES_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
pbKey[0] &= 0x0F; // set 4 leftmost bits of first byte to zero
pbKey[2] &= 0x0F; // set 4 leftmost bits of third byte to zero
pbKey[4] &= 0x0F; // set 4 leftmost bits of fifth byte to zero
pbKey[6] &= 0x0F; // set 4 leftmost bits of seventh byte to zero
desparityonkey(pbKey, cbKey);
deskey((DESTable*)pbExpandedKey, pbKey);
break;
#endif // CSP_USE_DES40
#ifdef CSP_USE_DES
case (CALG_DES):
pbExpandedKey = _nt_malloc(DES_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
desparityonkey(pbKey, cbKey);
deskey((DESTable*)pbExpandedKey, pbKey);
break;
#endif // CSP_USE_DES
#ifdef CSP_USE_3DES
case (CALG_3DES):
pbExpandedKey = _nt_malloc(DES3_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
desparityonkey(pbKey, cbKey);
tripledes3key((PDES3TABLE)pbExpandedKey, pbKey);
break;
case (CALG_3DES_112):
pbExpandedKey = _nt_malloc(DES3_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
desparityonkey(pbKey, cbKey);
tripledes2key((PDES3TABLE)pbExpandedKey, pbKey);
break;
#endif // CSP_USE_3DES
#ifdef CSP_USE_AES
case CALG_AES_128:
pbExpandedKey = _nt_malloc(AES_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
aeskey((AESTable *) pbExpandedKey, pbKey, CRYPT_AES128_ROUNDS);
break;
case CALG_AES_192:
pbExpandedKey = _nt_malloc(AES_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
aeskey((AESTable *) pbExpandedKey, pbKey, CRYPT_AES192_ROUNDS);
break;
case CALG_AES_256:
pbExpandedKey = _nt_malloc(AES_TABLESIZE);
if (NULL == pbExpandedKey)
{
dwReturn = ERROR_NOT_ENOUGH_MEMORY;
goto ErrorExit;
}
aeskey((AESTable *) pbExpandedKey, pbKey, CRYPT_AES256_ROUNDS);
break;
#endif
default:
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
// if encrypting and there is an IV then use it
if ((ENCRYPT == iOperation) && (CALG_RC4 != Algid))
{
memcpy(rgbBuffIn, pbPlaintext, cbPlaintext);
if (NULL != pbIV)
{
for (i = 0; i < cbPlaintext; i++)
rgbBuffIn[i] = (BYTE)(rgbBuffIn[i] ^ pbIV[i]);
}
}
// encrypt the plaintext
switch (Algid)
{
#ifdef CSP_USE_RC4
case (CALG_RC4):
if (ENCRYPT == iOperation)
memcpy(rgbBuffOut, pbPlaintext, cbPlaintext);
else
memcpy(rgbBuffOut, pbCiphertext, cbPlaintext);
rc4((RC4_KEYSTRUCT*)pbExpandedKey, cbPlaintext, rgbBuffOut);
break;
#endif // CSP_USE_RC4
#ifdef CSP_USE_RC2
case (CALG_RC2):
if (ENCRYPT == iOperation)
RC2(rgbBuffOut, rgbBuffIn, pbExpandedKey, ENCRYPT);
else
RC2(rgbBuffOut, pbCiphertext, pbExpandedKey, DECRYPT);
break;
#endif // CSP_USE_RC2
#ifdef CSP_USE_DES40
case (CALG_DES40):
if (ENCRYPT == iOperation)
des(rgbBuffOut, rgbBuffIn, pbExpandedKey, ENCRYPT);
else
des(rgbBuffOut, pbCiphertext, pbExpandedKey, DECRYPT);
break;
#endif // CSP_USE_DES40
#ifdef CSP_USE_DES
case (CALG_DES):
if (ENCRYPT == iOperation)
des(rgbBuffOut, rgbBuffIn, pbExpandedKey, ENCRYPT);
else
des(rgbBuffOut, pbCiphertext, pbExpandedKey, DECRYPT);
break;
#endif // CSP_USE_DES
#ifdef CSP_USE_3DES
case (CALG_3DES):
case (CALG_3DES_112):
if (ENCRYPT == iOperation)
tripledes(rgbBuffOut, rgbBuffIn, pbExpandedKey, ENCRYPT);
else
tripledes(rgbBuffOut, pbCiphertext, pbExpandedKey, DECRYPT);
break;
#endif // CSP_USE_3DES
#ifdef CSP_USE_AES
case CALG_AES_128:
case CALG_AES_192:
case CALG_AES_256:
if (ENCRYPT == iOperation)
aes(rgbBuffOut, rgbBuffIn, pbExpandedKey, ENCRYPT);
else
aes(rgbBuffOut, pbCiphertext, pbExpandedKey, DECRYPT);
break;
#endif
default:
dwReturn = (DWORD)NTE_BAD_ALGID;
goto ErrorExit;
}
if (ENCRYPT == iOperation)
{
// compare the encrypted plaintext with the passed in ciphertext
if (0 != memcmp(pbCiphertext, rgbBuffOut, cbPlaintext))
{
dwReturn = (DWORD)NTE_FAIL;
goto ErrorExit;
}
}
else
{
// if there is an IV then use it
if (NULL != pbIV)
{
for (i = 0; i < cbPlaintext; i++)
rgbBuffOut[i] = (BYTE)(rgbBuffOut[i] ^ pbIV[i]);
}
// compare the decrypted ciphertext with the passed in plaintext
if (0 != memcmp(pbPlaintext, rgbBuffOut, cbPlaintext))
{
dwReturn = (DWORD)NTE_FAIL;
goto ErrorExit;
}
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
if (pbExpandedKey)
_nt_free(pbExpandedKey, 0);
return dwReturn;
}
//
// Function : TestSymmetricAlgorithm
//
// Description : This function expands the passed in key buffer for the
// appropriate algorithm, encrypts the plaintext buffer with the
// same algorithm and key, and the compares the passed in
// expected ciphertext with the calculated ciphertext to make
// sure they are the same. The opposite is then done with
// decryption.
//
// The function only uses ECB mode for block ciphers and the
// plaintext buffer must be the same length as the ciphertext
// buffer. The length of the plaintext must be either the block
// length of the cipher if it is a block cipher or less than
// MAX_BLOCKLEN if a stream cipher is being used.
//
DWORD
TestSymmetricAlgorithm(
IN ALG_ID Algid,
IN BYTE *pbKey,
IN DWORD cbKey,
IN BYTE *pbPlaintext,
IN DWORD cbPlaintext,
IN BYTE *pbCiphertext,
IN BYTE *pbIV)
{
DWORD dwReturn = ERROR_INTERNAL_ERROR;
DWORD dwSts;
dwSts = TestEncDec(Algid, pbKey, cbKey, pbPlaintext, cbPlaintext,
pbCiphertext, pbIV, ENCRYPT);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwSts = TestEncDec(Algid, pbKey, cbKey, pbPlaintext, cbPlaintext,
pbCiphertext, pbIV, DECRYPT);
if (ERROR_SUCCESS != dwSts)
{
dwReturn = dwSts;
goto ErrorExit;
}
dwReturn = ERROR_SUCCESS;
ErrorExit:
return dwReturn;
}