mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
683 lines
22 KiB
683 lines
22 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
certupgr.cxx
|
|
|
|
Abstract:
|
|
|
|
Functions used in upgrading server certs from K2 [server cert in metabase] to
|
|
Avalanche [server cert in CAPI store].
|
|
|
|
Author:
|
|
|
|
Alex Mallet (amallet) 07-Dec-1997
|
|
Boyd Multerer (boydm) 20-Jan-1998 Converted to be useful in setup
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include <objbase.h>
|
|
|
|
#ifndef _CHICAGO_
|
|
|
|
|
|
#include "oidenc.h"
|
|
|
|
|
|
// keyring include
|
|
#include "intrlkey.h"
|
|
|
|
//
|
|
//Local includes
|
|
//
|
|
#include "certupgr.h"
|
|
//#include "certtools.h"
|
|
|
|
|
|
// The below define is in some interal schannel header file. John Banes
|
|
// told me to just redefine it below as such........ - Boyd
|
|
LPCSTR SGC_KEY_SALT = "SGCKEYSALT";
|
|
|
|
|
|
// prototypes
|
|
BOOL DecodeAndImportPrivateKey( PBYTE pbEncodedPrivateKey IN,
|
|
DWORD cbEncodedPrivateKey IN,
|
|
PCHAR pszPassword IN,
|
|
PWCHAR pszKeyContainerIN,
|
|
CRYPT_KEY_PROV_INFO *pCryptKeyProvInfo );
|
|
BOOL UpdateCSPInfo( PCCERT_CONTEXT pcCertContext );
|
|
|
|
|
|
BOOL FImportAndStoreRequest( PCCERT_CONTEXT pCert, PVOID pbPKCS10req, DWORD cbPKCS10req );
|
|
|
|
//-------------------------------------------------------------------------
|
|
PCCERT_CONTEXT CopyKRCertToCAPIStore_A( PVOID pbPrivateKey, DWORD cbPrivateKey,
|
|
PVOID pbPublicKey, DWORD cbPublicKey,
|
|
PVOID pbPKCS10req, DWORD cbPKCS10req,
|
|
PCHAR pszPassword,
|
|
PCHAR pszCAPIStore)
|
|
{
|
|
PCCERT_CONTEXT pCert = NULL;
|
|
|
|
// prep the wide strings
|
|
PWCHAR pszwCAPIStore = NULL;
|
|
DWORD lenStore = (strlen(pszCAPIStore)+1) * sizeof(WCHAR);
|
|
pszwCAPIStore = (PWCHAR)GlobalAlloc( GPTR, lenStore );
|
|
if ( !pszwCAPIStore )
|
|
goto cleanup;
|
|
|
|
// convert the strings
|
|
MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, pszCAPIStore, -1, pszwCAPIStore, lenStore );
|
|
|
|
// do the real call
|
|
pCert = CopyKRCertToCAPIStore_W(
|
|
pbPrivateKey, cbPrivateKey,
|
|
pbPublicKey, cbPublicKey,
|
|
pbPKCS10req, cbPKCS10req,
|
|
pszPassword,
|
|
pszwCAPIStore );
|
|
|
|
cleanup:
|
|
// preserve the last error state
|
|
DWORD err = GetLastError();
|
|
|
|
// clean up the strings
|
|
if ( pszwCAPIStore )
|
|
GlobalFree( pszwCAPIStore );
|
|
|
|
// reset the last error state
|
|
SetLastError( err );
|
|
|
|
// return the cert
|
|
return pCert;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
// Copies an old Key-Ring style cert to the CAPI store. This cert comes in as two binaries and a password.
|
|
PCCERT_CONTEXT CopyKRCertToCAPIStore_W( PVOID pbPrivateKey, DWORD cbPrivateKey,
|
|
PVOID pbPublicKey, DWORD cbPublicKey,
|
|
PVOID pbPKCS10req, DWORD cbPKCS10req,
|
|
PCHAR pszPassword,
|
|
PWCHAR pszCAPIStore)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Upgrades K2 server certs to Avalanche server certs - reads server cert out of K2
|
|
metabase, creates cert context and stores it in CAPI2 "MY" store and writes
|
|
relevant information back to metabase.
|
|
|
|
Arguments:
|
|
|
|
pMDObject - pointer to Metabase object
|
|
pszOldMBPath - path to where server cert is stored in old MB, relative to SSL_W3_KEYS_MD_PATH
|
|
pszNewMBPath - fully qualified path to where server cert info should be stored in new MB
|
|
|
|
Returns:
|
|
|
|
BOOL indicating success/failure
|
|
|
|
--*/
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
|
|
HCERTSTORE hStore = NULL;
|
|
PCCERT_CONTEXT pcCertContext = NULL;
|
|
LPOLESTR polestr = NULL;
|
|
|
|
|
|
// start by opening the CAPI store that we will be saving the certificate into
|
|
hStore = CertOpenStore( CERT_STORE_PROV_SYSTEM,
|
|
0,
|
|
NULL,
|
|
CERT_SYSTEM_STORE_LOCAL_MACHINE,
|
|
pszCAPIStore );
|
|
if ( !hStore )
|
|
{
|
|
// iisDebugOut((_T("Error 0x%x calling CertOpenStore \n"), GetLastError());
|
|
goto EndUpgradeServerCert;
|
|
}
|
|
|
|
|
|
// at this point we check to see if a certificate was passed in. If none was, then we need
|
|
// to create a dummy-temporary certificate that markes the private key as incomplete. That
|
|
// way, then the real certificate comes back from verisign the regular tools can be used
|
|
// to complete the key.
|
|
//CertCreateSelfSignCertificate()
|
|
|
|
|
|
//
|
|
//Create cert context to be stored in CAPI store
|
|
//
|
|
pbPublicKey = (PVOID)((PBYTE)pbPublicKey + CERT_DER_PREFIX);
|
|
cbPublicKey -= CERT_DER_PREFIX;
|
|
pcCertContext = CertCreateCertificateContext( X509_ASN_ENCODING, (PUCHAR)pbPublicKey, cbPublicKey);
|
|
if ( pcCertContext )
|
|
{
|
|
|
|
// the private key gets stored in a seperate location from the certificate and gets referred to
|
|
// by the certificate. We should try to pick a unique name so that some other cert won't step
|
|
// on it by accident. There is no formal format for this name whatsoever. Some groups use a
|
|
// human-readable string, some use a hash of the cert, and some use a GUID string. All are valid
|
|
// although for generated certs the hash or the GUID are probably better.
|
|
|
|
// get the 128 big md5 hash of the cert for the name
|
|
DWORD dwHashSize;
|
|
BOOL fHash;
|
|
|
|
BYTE MD5Hash[16]; // give it some extra size
|
|
dwHashSize = sizeof(MD5Hash);
|
|
fHash = CertGetCertificateContextProperty( pcCertContext,
|
|
CERT_MD5_HASH_PROP_ID,
|
|
(VOID *) MD5Hash,
|
|
&dwHashSize );
|
|
|
|
// Since the MD5 hash is the same size as a guid, we can use the guid utilities to make a
|
|
// nice string out of it.
|
|
HRESULT hresult;
|
|
hresult = StringFromCLSID( (REFCLSID)MD5Hash, &polestr );
|
|
|
|
//
|
|
// Now decode private key blob and import it into CAPI1 private key
|
|
//
|
|
CRYPT_KEY_PROV_INFO CryptKeyProvInfo;
|
|
|
|
if ( DecodeAndImportPrivateKey( (PUCHAR)pbPrivateKey, cbPrivateKey, pszPassword,
|
|
polestr, &CryptKeyProvInfo ) )
|
|
{
|
|
//
|
|
// Add the private key to the cert context
|
|
//
|
|
BOOL f;
|
|
f = CertSetCertificateContextProperty( pcCertContext, CERT_KEY_PROV_INFO_PROP_ID,
|
|
0, &CryptKeyProvInfo );
|
|
f = UpdateCSPInfo( pcCertContext );
|
|
if ( f )
|
|
{
|
|
//
|
|
// Store it in the provided store
|
|
//
|
|
if ( CertAddCertificateContextToStore( hStore, pcCertContext,
|
|
CERT_STORE_ADD_REPLACE_EXISTING, NULL ) )
|
|
{
|
|
fSuccess = TRUE;
|
|
|
|
// Write out the original request as a property on the cert
|
|
FImportAndStoreRequest( pcCertContext, pbPKCS10req, cbPKCS10req );
|
|
}
|
|
else
|
|
{
|
|
// iisDebugOut((_T("Error 0x%x calling CertAddCertificateContextToStore"), GetLastError());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// iisDebugOut((_T("Error 0x%x calling CertSetCertificateContextProperty"), GetLastError());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// iisDebugOut((_T("Error 0x%x calling CertCreateCertificateContext"), GetLastError());
|
|
}
|
|
|
|
//
|
|
//Cleanup that's done only on failure
|
|
//
|
|
if ( !fSuccess )
|
|
{
|
|
if ( pcCertContext )
|
|
{
|
|
CertFreeCertificateContext( pcCertContext );
|
|
}
|
|
pcCertContext = NULL;
|
|
}
|
|
|
|
EndUpgradeServerCert:
|
|
// cleanup
|
|
if ( hStore )
|
|
CertCloseStore ( hStore, 0 );
|
|
|
|
if ( polestr )
|
|
CoTaskMemFree( polestr );
|
|
|
|
|
|
// return the answer
|
|
return pcCertContext;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
BOOL UpdateCSPInfo( PCCERT_CONTEXT pcCertContext )
|
|
{
|
|
BYTE cbData[1000];
|
|
CRYPT_KEY_PROV_INFO* pProvInfo = (CRYPT_KEY_PROV_INFO *) cbData;
|
|
DWORD dwFoo = 1000;
|
|
BOOL fSuccess = TRUE;
|
|
|
|
if ( ! CertGetCertificateContextProperty( pcCertContext,
|
|
CERT_KEY_PROV_INFO_PROP_ID,
|
|
pProvInfo,
|
|
&dwFoo ) )
|
|
{
|
|
fSuccess = FALSE;
|
|
// iisDebugOut((_T("Fudge. failed to get property : 0x%x"), GetLastError());
|
|
}
|
|
else
|
|
{
|
|
pProvInfo->dwProvType = PROV_RSA_SCHANNEL;
|
|
pProvInfo->pwszProvName = NULL;
|
|
if ( !CertSetCertificateContextProperty( pcCertContext,
|
|
CERT_KEY_PROV_INFO_PROP_ID,
|
|
0,
|
|
pProvInfo ) )
|
|
{
|
|
fSuccess = FALSE;
|
|
// iisDebugOut((_T("Fudge. failed to set property : 0x%x"), GetLastError());
|
|
}
|
|
}
|
|
|
|
// return success
|
|
return fSuccess;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
BOOL DecodeAndImportPrivateKey( PBYTE pbEncodedPrivateKey IN,
|
|
DWORD cbEncodedPrivateKey IN,
|
|
PCHAR pszPassword IN,
|
|
PWCHAR pszKeyContainer IN,
|
|
CRYPT_KEY_PROV_INFO *pCryptKeyProvInfo )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts the private key stored in the metabase, in Schannel-internal format,
|
|
into a key that can be imported via CryptImportKey() to create a CAP1 key blob.
|
|
|
|
Arguments:
|
|
|
|
pbEncodedPrivateKey - pointer to [encoded] private key
|
|
cbEncodedPrivateKey - size of encoded private key blob
|
|
pszPassword - password used to encode private key
|
|
pszKeyContainer - container name for private key
|
|
pCryptKeyProvInfo - pointer to CRYPT_KEY_PROV_INFO structure filled in on success
|
|
|
|
Returns:
|
|
|
|
BOOL indicating success/failure
|
|
|
|
--*/
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
DWORD cbPassword = strlen(pszPassword);
|
|
PPRIVATE_KEY_FILE_ENCODE pPrivateFile = NULL;
|
|
DWORD cbPrivateFile = 0;
|
|
MD5_CTX md5Ctx;
|
|
struct RC4_KEYSTRUCT rc4Key;
|
|
DWORD i;
|
|
HCRYPTPROV hProv = NULL;
|
|
HCRYPTKEY hPrivateKey = NULL;
|
|
DWORD cbDecodedPrivateKey = 0;
|
|
PBYTE pbDecodedPrivateKey = NULL;
|
|
|
|
DWORD err;
|
|
//
|
|
//HACK HACK HACK - need to make sure Schannel is initialized, so it registers
|
|
//its custom decoders, which we make use of in the following code. So, make a
|
|
//bogus call to an Schannel function
|
|
|
|
// Note: on NT5, the AcquireCredentialsHandle operates in the lsass process and
|
|
// thus will not properly initialize the stuff we need in our process. Thus we
|
|
// call SslGenerateRandomBits instead.
|
|
//
|
|
DWORD dw;
|
|
SslGenerateRandomBits( (PUCHAR)&dw, sizeof(dw) );
|
|
|
|
// We have to do a little fixup here. Old versions of
|
|
// schannel wrote the wrong header data into the ASN
|
|
// for private key files, so we must fix the size data.
|
|
pbEncodedPrivateKey[2] = (BYTE) (((cbEncodedPrivateKey - 4) & 0xFF00) >> 8); //Get MSB
|
|
pbEncodedPrivateKey[3] = (BYTE) ((cbEncodedPrivateKey - 4) & 0xFF); //Get LSB
|
|
|
|
//
|
|
// ASN.1 decode the private key.
|
|
//
|
|
|
|
//
|
|
// Figure out the size of the buffer needed
|
|
//
|
|
if( !CryptDecodeObject(X509_ASN_ENCODING,
|
|
szPrivateKeyFileEncode,
|
|
pbEncodedPrivateKey,
|
|
cbEncodedPrivateKey,
|
|
0,
|
|
NULL,
|
|
&cbPrivateFile) )
|
|
{
|
|
err = GetLastError();
|
|
// iisDebugOut((_T("Error 0x%x decoding the private key"), err);
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
pPrivateFile = (PPRIVATE_KEY_FILE_ENCODE) LocalAlloc( LPTR, cbPrivateFile );
|
|
|
|
if(pPrivateFile == NULL)
|
|
{
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
//
|
|
// Actually fill in the buffer
|
|
//
|
|
if( !CryptDecodeObject( X509_ASN_ENCODING,
|
|
szPrivateKeyFileEncode,
|
|
pbEncodedPrivateKey,
|
|
cbEncodedPrivateKey,
|
|
0,
|
|
pPrivateFile,
|
|
&cbPrivateFile ) )
|
|
{
|
|
err = GetLastError();
|
|
// iisDebugOut((_T("Error 0x%x decoding the private key"), err);
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
//
|
|
// Decrypt the decoded private key using the password.
|
|
//
|
|
MD5Init(&md5Ctx);
|
|
MD5Update(&md5Ctx, (PBYTE) pszPassword, cbPassword);
|
|
MD5Final(&md5Ctx);
|
|
|
|
rc4_key( &rc4Key, 16, md5Ctx.digest );
|
|
// memset( &md5Ctx, 0, sizeof(md5Ctx) );
|
|
|
|
rc4( &rc4Key,
|
|
pPrivateFile->EncryptedBlob.cbData,
|
|
pPrivateFile->EncryptedBlob.pbData );
|
|
|
|
|
|
|
|
//
|
|
// Build a PRIVATEKEYBLOB from the decrypted private key.
|
|
//
|
|
|
|
//
|
|
// Figure out size of buffer needed
|
|
//
|
|
if( !CryptDecodeObject( X509_ASN_ENCODING,
|
|
szPrivateKeyInfoEncode,
|
|
pPrivateFile->EncryptedBlob.pbData,
|
|
pPrivateFile->EncryptedBlob.cbData,
|
|
0,
|
|
NULL,
|
|
&cbDecodedPrivateKey ) )
|
|
{
|
|
// NOTE: This stuff is complicated!!! The following code came
|
|
// from John Banes. Heck this whole routine pretty much came
|
|
// from John Banes. -- Boyd
|
|
|
|
// Maybe this was a SGC style key.
|
|
// Re-encrypt it, and build the SGC decrypting
|
|
// key, and re-decrypt it.
|
|
BYTE md5Digest[MD5DIGESTLEN];
|
|
|
|
rc4_key(&rc4Key, 16, md5Ctx.digest);
|
|
rc4(&rc4Key,
|
|
pPrivateFile->EncryptedBlob.cbData,
|
|
pPrivateFile->EncryptedBlob.pbData);
|
|
CopyMemory(md5Digest, md5Ctx.digest, MD5DIGESTLEN);
|
|
|
|
MD5Init(&md5Ctx);
|
|
MD5Update(&md5Ctx, md5Digest, MD5DIGESTLEN);
|
|
MD5Update(&md5Ctx, (PUCHAR)SGC_KEY_SALT, strlen(SGC_KEY_SALT));
|
|
MD5Final(&md5Ctx);
|
|
rc4_key(&rc4Key, 16, md5Ctx.digest);
|
|
rc4(&rc4Key,
|
|
pPrivateFile->EncryptedBlob.cbData,
|
|
pPrivateFile->EncryptedBlob.pbData);
|
|
|
|
// Try again...
|
|
if(!CryptDecodeObject(X509_ASN_ENCODING,
|
|
szPrivateKeyInfoEncode,
|
|
pPrivateFile->EncryptedBlob.pbData,
|
|
pPrivateFile->EncryptedBlob.cbData,
|
|
0,
|
|
NULL,
|
|
&cbDecodedPrivateKey))
|
|
{
|
|
ZeroMemory(&md5Ctx, sizeof(md5Ctx));
|
|
err = GetLastError();
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
pbDecodedPrivateKey = (PBYTE) LocalAlloc( LPTR, cbDecodedPrivateKey );
|
|
|
|
if( pbDecodedPrivateKey == NULL )
|
|
{
|
|
SetLastError( ERROR_OUTOFMEMORY );
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
//
|
|
// Actually fill in the buffer
|
|
//
|
|
if( !CryptDecodeObject( X509_ASN_ENCODING,
|
|
szPrivateKeyInfoEncode,
|
|
pPrivateFile->EncryptedBlob.pbData,
|
|
pPrivateFile->EncryptedBlob.cbData,
|
|
0,
|
|
pbDecodedPrivateKey,
|
|
&cbDecodedPrivateKey ) )
|
|
{
|
|
err = GetLastError();
|
|
// iisDebugOut((_T("Error 0x%x decoding the private key"), err);
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
|
|
// On NT 4 the ff holds true : <- from Alex Mallet
|
|
// Although key is going to be used for key exchange, mark it as being
|
|
// used for signing, because only 512-bit key exchange keys are supported
|
|
// in the non-domestic rsabase.dll, whereas signing keys can be up to
|
|
// 2048 bits.
|
|
//
|
|
// On NT 5, PROV_RSA_FULL should be changed to PROV_RSA_SCHANNEL, and
|
|
// aiKeyAlg to CALG_RSA_KEYX, because PROV_RSA_SCHANNEL, which is only
|
|
// installed on NT 5, supports 1024-bit private keys for key exchange
|
|
//
|
|
// On NT4, Schannel doesn't care whether a key is marked for signing or exchange,
|
|
// but on NT5 it does, so aiKeyAlg must be set appropriately
|
|
//
|
|
((BLOBHEADER *) pbDecodedPrivateKey)->aiKeyAlg = CALG_RSA_KEYX;
|
|
|
|
//
|
|
// Clean out the key container, pszKeyContainer
|
|
//
|
|
|
|
CryptAcquireContext(&hProv,
|
|
pszKeyContainer,
|
|
NULL,
|
|
PROV_RSA_SCHANNEL,
|
|
CRYPT_DELETEKEYSET | CRYPT_MACHINE_KEYSET);
|
|
//
|
|
// Create a CryptoAPI key container in which to store the key.
|
|
//
|
|
if( !CryptAcquireContext( &hProv,
|
|
pszKeyContainer,
|
|
NULL,
|
|
PROV_RSA_SCHANNEL,
|
|
CRYPT_NEWKEYSET | CRYPT_MACHINE_KEYSET))
|
|
{
|
|
err = GetLastError();
|
|
// iisDebugOut((_T("Error 0x%x calling CryptAcquireContext"), err);
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
//
|
|
// Import the private key blob into the key container.
|
|
//
|
|
if( !CryptImportKey( hProv,
|
|
pbDecodedPrivateKey,
|
|
cbDecodedPrivateKey,
|
|
0,
|
|
CRYPT_EXPORTABLE, //so we can export it later
|
|
&hPrivateKey ) )
|
|
{
|
|
err = GetLastError();
|
|
// iisDebugOut((_T("Error 0x%x importing PRIVATEKEYBLOB"), err);
|
|
goto EndDecodeKey;
|
|
}
|
|
|
|
|
|
//
|
|
// Fill in the CRYPT_KEY_PROV_INFO structure, with the same parameters we
|
|
// used in the call to CryptAcquireContext() above
|
|
//
|
|
|
|
//
|
|
// container name in the structure is a unicode string, so we need to convert
|
|
//
|
|
|
|
if ( pszKeyContainer != NULL )
|
|
{
|
|
// point the key container name to the passed in string
|
|
// WARNING: this does not actually copy the string, just the pointer
|
|
// to it. So the strings needs to remain valid until the ProvInfo is commited.
|
|
pCryptKeyProvInfo->pwszContainerName = pszKeyContainer;
|
|
}
|
|
else
|
|
{
|
|
pCryptKeyProvInfo->pwszContainerName = NULL;
|
|
}
|
|
|
|
pCryptKeyProvInfo->pwszProvName = NULL;
|
|
pCryptKeyProvInfo->dwProvType = PROV_RSA_FULL;
|
|
pCryptKeyProvInfo->dwFlags = 0x20; // allow the cert to be exchanged
|
|
pCryptKeyProvInfo->cProvParam = 0;
|
|
pCryptKeyProvInfo->rgProvParam = NULL;
|
|
pCryptKeyProvInfo->dwKeySpec = AT_KEYEXCHANGE; // allow the cert to be exchanged
|
|
|
|
fSuccess = TRUE;
|
|
|
|
EndDecodeKey:
|
|
|
|
//
|
|
// Clean-up that happens regardless of success/failure
|
|
//
|
|
if ( pPrivateFile )
|
|
{
|
|
LocalFree( pPrivateFile );
|
|
}
|
|
|
|
if ( pbDecodedPrivateKey )
|
|
{
|
|
LocalFree( pbDecodedPrivateKey );
|
|
}
|
|
|
|
if ( hPrivateKey )
|
|
{
|
|
CryptDestroyKey( hPrivateKey );
|
|
}
|
|
|
|
if ( hProv )
|
|
{
|
|
CryptReleaseContext( hProv, 0 );
|
|
}
|
|
|
|
return fSuccess;
|
|
|
|
|
|
} //DecodeAndImportPrivateKey
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Takes an incoming PKCS10 request and saves it as a property attached to the key. It also
|
|
checks if the request is in the old internal Keyring format or not......
|
|
|
|
Arguments:
|
|
|
|
pCert - CAPI certificate context pointer for the cert to save the request on
|
|
pbPKCS10req - pointer to the request
|
|
cbPKCS10req - size of the request
|
|
|
|
Returns:
|
|
|
|
BOOL indicating success/failure
|
|
|
|
--*/
|
|
BOOL FImportAndStoreRequest( PCCERT_CONTEXT pCert, PVOID pbPKCS10req, DWORD cbPKCS10req )
|
|
{
|
|
BOOL f;
|
|
DWORD err;
|
|
|
|
// if any NULLS are passed in, fail gracefully
|
|
if ( !pCert || !pbPKCS10req || !cbPKCS10req )
|
|
return FALSE;
|
|
|
|
// first, check if the incoming request is actually pointing to an old KeyRing internal
|
|
// request format. That just means that the real request is actuall slightly into
|
|
// the block. The way you tell is by testing the first DWORD to see it
|
|
// is REQUEST_HEADER_IDENTIFIER
|
|
// start by seeing if this is a new style key request
|
|
LPREQUEST_HEADER pHeader = (LPREQUEST_HEADER)pbPKCS10req;
|
|
if ( pHeader->Identifier == REQUEST_HEADER_IDENTIFIER )
|
|
{
|
|
// update the request pointer and data count
|
|
pbPKCS10req = (PBYTE)pbPKCS10req + pHeader->cbSizeOfHeader;
|
|
cbPKCS10req = pHeader->cbRequestSize;
|
|
}
|
|
|
|
// now save the request onto the key
|
|
CRYPT_DATA_BLOB dataBlob;
|
|
ZeroMemory( &dataBlob, sizeof(dataBlob) );
|
|
dataBlob.pbData = (PBYTE)pbPKCS10req; // pointer to blob data
|
|
dataBlob.cbData = cbPKCS10req; // blob length info
|
|
f = CertSetCertificateContextProperty(
|
|
pCert,
|
|
CERTWIZ_REQUEST_PROP_ID,
|
|
0,
|
|
&dataBlob
|
|
);
|
|
err = GetLastError();
|
|
|
|
/*
|
|
HRESULT hRes = CertTool_SetBinaryBlobProp(
|
|
pCert, // cert context to set the prop on
|
|
pbPKCS10req, // pointer to blob data
|
|
cbPKCS10req, // blob length info
|
|
CERTWIZ_REQUEST_PROP_ID,// property ID for context
|
|
TRUE // the request is already encoded
|
|
);
|
|
*/
|
|
|
|
return f;
|
|
}
|
|
|
|
|
|
|
|
#endif //_CHICAGO_
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|