//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1997-2001. // // File: Certifct.cpp // // Contents: Implementation of CCertmgrApp and DLL registration. // //---------------------------------------------------------------------------- #include "stdafx.h" #include "Certifct.h" #ifdef _DEBUG #ifndef ALPHA #define new DEBUG_NEW #endif #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif USE_HANDLE_MACROS("CERTMGR(Certifct.cpp)") ///////////////////////////////////////////////////////////////////////////// // const int FIELD_ISSUER_ALT_NAME = 0x00000001; const int FIELD_SUBJECT_ALT_NAME = 0x00000002; const int FIELD_CAN_DELETE = 0x00000004; const int FIELD_IS_ARCHIVED = 0x00000008; const int FIELD_TEMPLATE_NAME = 0x00000010; CCertificate::CCertificate(const PCCERT_CONTEXT pCertContext, CCertStore* pCertStore) : CCertMgrCookie (CERTMGR_CERTIFICATE), m_pCertContext (::CertDuplicateCertificateContext (pCertContext)), m_pCertInfo (0), m_fieldChecked (0), m_pCertStore (pCertStore), m_bCanDelete (false), m_bIsArchived (false) { // _TRACE (1, L"Entering CCertificate::CCertificate\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertStore); if ( m_pCertStore ) m_pCertStore->AddRef (); ASSERT (m_pCertContext); if ( m_pCertContext ) m_pCertInfo = m_pCertContext->pCertInfo; // _TRACE (-1, L"Leaving CCertificate::CCertificate\n"); } CCertificate::~CCertificate() { // _TRACE (1, L"Entering CCertificate::~CCertificate\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); if ( m_pCertContext ) ::CertFreeCertificateContext (m_pCertContext); if ( m_pCertStore ) m_pCertStore->Release (); // _TRACE (-1, L"Leaving CCertificate::~CCertificate\n"); } CString CCertificate::GetFriendlyName () { // _TRACE (1, L"Entering CCertificate::GetFriendlyName\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertContext); if ( m_pCertContext && m_szFriendlyName.IsEmpty () ) { AFX_MANAGE_STATE (AfxGetStaticModuleState ()); DWORD cbData = 0; BOOL bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_FRIENDLY_NAME_PROP_ID, NULL, &cbData); if ( bResult ) { LPWSTR pszName = new WCHAR[cbData]; if ( pszName ) { ::ZeroMemory (pszName, cbData*sizeof (WCHAR)); bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_FRIENDLY_NAME_PROP_ID, pszName, &cbData); ASSERT (bResult); if ( bResult ) { m_szFriendlyName = pszName; } else { VERIFY (m_szFriendlyName.LoadString (IDS_NOT_AVAILABLE)); } delete [] pszName; } } else { if ( GetLastError () == CRYPT_E_NOT_FOUND ) { VERIFY (m_szFriendlyName.LoadString (IDS_NONE)); } else { ASSERT (0); VERIFY (m_szFriendlyName.LoadString (IDS_NOT_AVAILABLE)); } } } // _TRACE (-1, L"Leaving CCertificate::GetFriendlyName\n"); return m_szFriendlyName; } CString CCertificate::GetIssuerName () { // _TRACE (1, L"Entering CCertificate::GetIssuerName\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { // Decode issuer name if not already present if ( m_szIssuerName.IsEmpty () ) { m_szIssuerName = ::GetNameString (m_pCertContext, CERT_NAME_ISSUER_FLAG); } } else return _T(""); // _TRACE (-1, L"Leaving CCertificate::GetIssuerName\n"); return m_szIssuerName; } /////////////////////////////////////////////////////////////////////////// // GetSubjectName () // // pszName (IN / OPTIONAL) - returns the alternate issuer name. An empty // string is a valid return value // cbName (IN / OUT) - If pszName is NULL, then the required length // of pszName is returned. // Otherwise, contains the length of pszName. /////////////////////////////////////////////////////////////////////////// CString CCertificate::GetSubjectName() { // _TRACE (1, L"Entering CCertificate::GetSubjectName\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { // Decode subject name if not already present if ( m_szSubjectName.IsEmpty () ) { m_szSubjectName = ::GetNameString (m_pCertContext, 0); } } else return _T(""); // _TRACE (-1, L"Leaving CCertificate::GetSubjectName\n"); return m_szSubjectName; } /////////////////////////////////////////////////////////////////////////// // GetValidNotBefore () // // pszDateTime (IN / OPTIONAL) - returns the formatted date and time. // cbDateTime (IN / OUT) - If pszDateTime is NULL, then the required length // of pszDateTime is returned. // Otherwise, contains the length of pszDateTime. /////////////////////////////////////////////////////////////////////////// CString CCertificate::GetValidNotBefore() { // _TRACE (1, L"Entering CCertificate::GetValidNotBefore\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { // Format date/time string if not already present if ( m_szValidNotBefore.IsEmpty () ) { HRESULT hResult = FormatDate (m_pCertInfo->NotBefore, m_szValidNotBefore); if ( !SUCCEEDED (hResult) ) return _T(""); } } else return _T(""); // _TRACE (-1, L"Leaving CCertificate::GetValidNotBefore\n"); return m_szValidNotBefore; } /////////////////////////////////////////////////////////////////////////// // GetValidNotAfter () // // pszDateTime (IN / OPTIONAL) - returns the formatted date and time. // cbDateTime (IN / OUT) - If pszDateTime is NULL, then the required length // of pszDateTime is returned. // Otherwise, contains the length of pszDateTime. /////////////////////////////////////////////////////////////////////////// CString CCertificate::GetValidNotAfter () { // _TRACE (1, L"Entering CCertificate::GetValidNotAfter\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { // Format date/time string if not already present if ( m_szValidNotAfter.IsEmpty () ) { HRESULT hResult = FormatDate (m_pCertInfo->NotAfter, m_szValidNotAfter); if ( !SUCCEEDED (hResult) ) m_szValidNotAfter = _T(""); } } else m_szValidNotAfter = _T(""); // _TRACE (-1, L"Leaving CCertificate::GetValidNotAfter\n"); return m_szValidNotAfter; } CString CCertificate::GetEnhancedKeyUsage () { // _TRACE (1, L"Entering CCertificate::GetEnhancedKeyUsage\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { // Format date/time string if not already present if ( m_szEnhancedKeyUsage.IsEmpty () ) { FormatEnhancedKeyUsagePropertyString ( m_szEnhancedKeyUsage); } } else m_szEnhancedKeyUsage = _T(""); // _TRACE (-1, L"Leaving CCertificate::GetEnhancedKeyUsage\n"); return m_szEnhancedKeyUsage; } bool CCertificate::FormatEnhancedKeyUsagePropertyString (CString& string) { // _TRACE (1, L"Entering CCertificate::FormatEnhancedKeyUsagePropertyString\n"); AFX_MANAGE_STATE(AfxGetStaticModuleState()); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); BOOL bReturn = TRUE; DWORD cbUsage = 0; bReturn = ::CertGetEnhancedKeyUsage (m_pCertContext, 0, // get extension and property NULL, &cbUsage); if ( bReturn ) { CString usageName; PCERT_ENHKEY_USAGE pUsage = (PCERT_ENHKEY_USAGE) ::LocalAlloc (LPTR, cbUsage); if ( pUsage ) { bReturn = ::CertGetEnhancedKeyUsage (m_pCertContext, 0, // get extension and property pUsage, &cbUsage); if ( bReturn ) { if ( !pUsage->cUsageIdentifier ) { switch (GetLastError ()) { case CRYPT_E_NOT_FOUND: VERIFY (string.LoadString (IDS_ANY)); break; case 0: VERIFY (string.LoadString (IDS_NONE)); break; default: break; } } else { for (DWORD dwIndex = 0; dwIndex < pUsage->cUsageIdentifier; dwIndex++) { if ( MyGetOIDInfo (usageName, pUsage->rgpszUsageIdentifier[dwIndex]) ) { // add delimeter if not first iteration if ( dwIndex ) string += _T(", "); string += usageName; } } } } else { switch (GetLastError ()) { case CRYPT_E_NOT_FOUND: VERIFY (string.LoadString (IDS_ANY)); break; case 0: VERIFY (string.LoadString (IDS_NONE)); break; default: break; } } ::LocalFree (pUsage); } else { bReturn = FALSE; } } else { switch (GetLastError ()) { case CRYPT_E_NOT_FOUND: VERIFY (string.LoadString (IDS_ANY)); break; case 0: VERIFY (string.LoadString (IDS_NONE)); break; default: break; } } // _TRACE (-1, L"Leaving CCertificate::FormatEnhancedKeyUsagePropertyString\n"); return bReturn ? true : false; } /////////////////////////////////////////////////////////////////////////// // GetAlternateIssuerName () // // pszName (IN / OPTIONAL) - returns the alternate issuer name. An empty // string is a valid return value // cbName (IN / OUT) - If pszName is NULL, then the required length // of pszName is returned. // Otherwise, contains the length of pszName. /////////////////////////////////////////////////////////////////////////// CString CCertificate::GetAlternateIssuerName () { // _TRACE (1, L"Entering CCertificate::GetAlternateIssuerName\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { if ( !(m_fieldChecked & FIELD_ISSUER_ALT_NAME) ) { HRESULT hResult = ConvertAltNameToString (_T(szOID_ISSUER_ALT_NAME), CERT_ALT_NAME_URL, m_szAltIssuerName); ASSERT (SUCCEEDED (hResult)); if ( !SUCCEEDED (hResult) ) m_szAltIssuerName = _T(""); m_fieldChecked |= FIELD_ISSUER_ALT_NAME; } } else m_szAltIssuerName = _T(""); // _TRACE (-1, L"Leaving CCertificate::GetAlternateIssuerName\n"); return m_szAltIssuerName; } /////////////////////////////////////////////////////////////////////////// // GetAlternateSubjectName () // // pszName (IN / OPTIONAL) - returns the alternate issuer name. An empty // string is a valid return value // cbName (IN / OUT) - If pszName is NULL, then the required length // of pszName is returned. // Otherwise, contains the length of pszName. /////////////////////////////////////////////////////////////////////////// CString CCertificate::GetAlternateSubjectName () { // _TRACE (1, L"Entering CCertificate::GetAlternateSubjectName\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { if ( !(m_fieldChecked & FIELD_SUBJECT_ALT_NAME) ) { HRESULT hResult = ConvertAltNameToString (_T(szOID_SUBJECT_ALT_NAME), CERT_ALT_NAME_URL, m_szAltSubjectName); if ( !SUCCEEDED (hResult) ) m_szAltSubjectName = _T(""); m_fieldChecked |= FIELD_SUBJECT_ALT_NAME; } } else m_szAltSubjectName = _T(""); // _TRACE (-1, L"Leaving CCertificate::GetAlternateSubjectName\n"); return m_szAltSubjectName; } /////////////////////////////////////////////////////////////////////////// // GetSerialNumber () // // pszSerNum (IN / OPTIONAL) - returns the alternate issuer name. An empty // string is a valid return value // cbSerNum (IN / OUT) - If pszSerNum is NULL, then the required length // of pszSerNum is returned. // Otherwise, contains the length of pszSerNum. /////////////////////////////////////////////////////////////////////////// CString CCertificate::GetSerialNumber () { // _TRACE (1, L"Entering CCertificate::GetSerialNumber\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertInfo); if ( m_pCertInfo ) { // Decode issuer name if not already present if ( m_szSerNum.IsEmpty () ) { LPWSTR pwszText = 0; if ( SUCCEEDED (FormatSerialNoString (&pwszText, & (m_pCertInfo->SerialNumber))) ) { m_szSerNum = pwszText; CoTaskMemFree (pwszText); } } } else m_szSerNum = _T(""); // _TRACE (-1, L"Leaving CCertificate::GetSerialNumber\n"); return m_szSerNum; } ////////////////////////////////////////////////////////////////////////////// // ConvertAltNameToString () // // szOID (IN) - The OID of the alternate name to retrieve // dwNameChoice (IN) - The type of alternate name to return // altName (OUT) - The version of the desired alternate name indicated // by dwNameChoice ////////////////////////////////////////////////////////////////////////////// HRESULT CCertificate::ConvertAltNameToString(LPCWSTR szOID, const DWORD dwNameChoice, CString & altName) { // _TRACE (1, L"Entering CCertificate::ConvertAltNameToString\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); HRESULT hResult = S_OK; // Iterate through the extensions until the one indicated by the // passed-in szOID is found. for (DWORD index = 0; index < m_pCertInfo->cExtension; index++) { ASSERT (m_pCertInfo->rgExtension); size_t len = strlen (m_pCertInfo->rgExtension[index].pszObjId); LPWSTR wcsObjId = new WCHAR[len]; if ( wcsObjId ) { ::ZeroMemory (wcsObjId, len * sizeof (WCHAR)); mbstowcs (wcsObjId, m_pCertInfo->rgExtension[index].pszObjId, len); if ( !wcscmp (wcsObjId, szOID) ) { CERT_ALT_NAME_INFO nameInfo; DWORD cbNameInfo = sizeof (CERT_ALT_NAME_INFO); BOOL bResult = CryptDecodeObject( MY_ENCODING_TYPE, X509_ALTERNATE_NAME, // in m_pCertInfo->rgExtension[index].Value.pbData, // in m_pCertInfo->rgExtension[index].Value.cbData, // in 0, // in (void *) &nameInfo, // out &cbNameInfo); // in/out ASSERT (bResult); if ( bResult ) { // We've found the right extension, now iterate through // the alternate names until we find the desired type. for (DWORD dwAltEntryIndex = 0; dwAltEntryIndex < nameInfo.cAltEntry; dwAltEntryIndex++) { if ( nameInfo.rgAltEntry[dwAltEntryIndex].dwAltNameChoice == dwNameChoice ) { altName = nameInfo.rgAltEntry[dwAltEntryIndex].pwszURL; break; } } } else hResult = E_UNEXPECTED; break; } delete [] wcsObjId; } else { hResult = E_OUTOFMEMORY; } } // _TRACE (-1, L"Leaving CCertificate::ConvertAltNameToString\n"); return hResult; } VOID CCertificate::DataToHex(PBYTE pSrc, CString & dest, int cb, bool bIncludeSpaces) { // _TRACE (1, L"Entering CCertificate::DataToHex\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); unsigned char ch = 0; TCHAR szDest[3]; UINT uLen = 0; dest.Empty (); while (cb-- > 0) { #pragma warning (once: 4244) ch = 0x00FF & (unsigned char) (*pSrc++); wsprintf(szDest, _T("%02X"), ch); dest += szDest; uLen++; if ( bIncludeSpaces && !(uLen % 2) && cb ) dest += _T(" "); } // _TRACE (-1, L"Leaving CCertificate::DataToHex\n"); } CCertStore* CCertificate::GetCertStore() const { // _TRACE (0, L"Entering and leaving CCertificate::GetCertStore\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); return m_pCertStore; } PCCERT_CONTEXT CCertificate::GetCertContext() const { // _TRACE (0, L"Entering and leaving CCertificate::GetCertContext\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); return m_pCertContext; } bool CCertificate::IsValid() { // _TRACE (1, L"Entering CCertificate::IsValid\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); bool bIsValid = false; ASSERT (m_pCertInfo); if ( m_pCertInfo ) { FILETIME systemTime; ::GetSystemTimeAsFileTime (&systemTime); LONG lBefore = ::CompareFileTime (&m_pCertInfo->NotBefore, &systemTime); LONG lAfter = ::CompareFileTime (&systemTime, &m_pCertInfo->NotAfter); if ( lBefore < 1 && lAfter < 1 ) bIsValid = true; } // _TRACE (-1, L"Leaving CCertificate::IsValid\n"); return bIsValid; } const SPECIAL_STORE_TYPE CCertificate::GetStoreType () const { // _TRACE (0, L"Entering and leaving CCertificate::GetStoreType\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); if ( m_pCertStore ) return m_pCertStore->GetStoreType (); else return NO_SPECIAL_TYPE; } void CCertificate::Refresh() { // _TRACE (1, L"Entering CCertificate::Refresh\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); // Clearing all fields forces rereading of the data. m_szAltIssuerName = L""; m_szAltSubjectName = L""; m_szAuthorityKeyID = L""; m_szEnhancedKeyUsage = L""; m_szFriendlyName = L""; m_szIssuerName = L""; m_szMD5Hash = L""; m_szPolicyURL = L""; m_szSerNum = L""; m_szSHAHash = L""; m_szSubjectKeyID = L""; m_szSubjectName = L""; m_szValidNotAfter = L""; m_szValidNotBefore = L""; m_fieldChecked = 0; // _TRACE (-1, L"Leaving CCertificate::Refresh\n"); } CString CCertificate::GetMD5Hash() { // _TRACE (1, L"Entering CCertificate::GetMD5Hash\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertContext); if ( m_pCertContext && m_szMD5Hash.IsEmpty ()) { m_szMD5Hash = GetGenericHash (CERT_MD5_HASH_PROP_ID); } // _TRACE (-1, L"Leaving CCertificate::GetMD5Hash\n"); return m_szMD5Hash; } CString CCertificate::GetSHAHash() { // _TRACE (1, L"Entering CCertificate::GetSHAHash\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertContext); if ( m_pCertContext && m_szSHAHash.IsEmpty ()) { m_szSHAHash = GetGenericHash (CERT_SHA1_HASH_PROP_ID); } // _TRACE (-1, L"Leaving CCertificate::GetSHAHash\n"); return m_szSHAHash; } CString CCertificate::GetGenericHash(DWORD dwPropId) { // _TRACE (1, L"Entering CCertificate::GetGenericHash\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); CString szHash; DWORD cbData = 0; BOOL bReturn = ::CertGetCertificateContextProperty ( m_pCertContext, dwPropId, NULL, &cbData); if ( bReturn ) { cbData += 2; // for null terminator BYTE* pCertHash = new BYTE[cbData]; if ( pCertHash ) { ::ZeroMemory (pCertHash, cbData); bReturn = CertGetCertificateContextProperty ( m_pCertContext, dwPropId, pCertHash, &cbData); ASSERT (bReturn); if ( bReturn ) { DataToHex (pCertHash, szHash, cbData, false); } delete [] pCertHash; } } // _TRACE (-1, L"Leaving CCertificate::GetGenericHash\n"); return szHash; } int CCertificate::CompareExpireDate(const CCertificate & cert) const { // _TRACE (1, L"Entering CCertificate::CompareExpireDate\n"); ASSERT (CERTMGR_CERTIFICATE == m_objecttype); int compVal = 0; ASSERT (m_pCertInfo && cert.m_pCertInfo); if ( m_pCertInfo && cert.m_pCertInfo ) { compVal = ::CompareFileTime (&m_pCertInfo->NotAfter, &cert.m_pCertInfo->NotAfter); } // _TRACE (-1, L"Leaving CCertificate::CompareExpireDate\n"); return compVal; } bool CCertificate::CanDelete() { // _TRACE (1, L"Entering CCertificate::CanDelete\n"); if ( m_pCertContext && !(m_fieldChecked & FIELD_CAN_DELETE) ) { DWORD dwAccessFlags = 0; DWORD cbData = sizeof (DWORD); BOOL bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_ACCESS_STATE_PROP_ID, &dwAccessFlags, &cbData); if ( bResult ) { if ( dwAccessFlags & CERT_ACCESS_STATE_WRITE_PERSIST_FLAG ) m_bCanDelete = true; } m_fieldChecked |= FIELD_CAN_DELETE; } // _TRACE (-1, L"Leaving CCertificate::CanDelete\n"); return m_bCanDelete; } bool CCertificate::IsReadOnly() { bool bResult = false; if ( m_pCertStore ) bResult = (m_pCertStore->IsReadOnly () || !CanDelete ()); return bResult; } bool CCertificate::IsArchived() { // _TRACE (1, L"Entering CCertificate::IsArchived\n"); if ( m_pCertContext && !(m_fieldChecked & FIELD_IS_ARCHIVED) ) { DWORD cbData = sizeof (DWORD); BOOL bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_ARCHIVED_PROP_ID, NULL, &cbData); if ( bResult ) { m_bIsArchived = true; } else m_bIsArchived = false; m_fieldChecked |= FIELD_IS_ARCHIVED; } // _TRACE (-1, L"Leaving CCertificate::IsArchived\n"); return m_bIsArchived; } BOOL CCertificate::DeleteFromStore(bool bDoCommit) { _TRACE (1, L"Entering CCertificate::DeleteFromStore\n"); BOOL bResult = FALSE; if ( m_pCertStore ) { PCCERT_CONTEXT pCertContext = GetNewCertContext (); if ( pCertContext ) { bResult = ::CertDeleteCertificateFromStore (pCertContext); if ( bResult ) { m_pCertStore->InvalidateCertCount (); m_pCertStore->SetDirty (); if ( bDoCommit ) { HRESULT hr = m_pCertStore->Commit (); if ( SUCCEEDED (hr) ) m_pCertStore->Resync (); else bResult = FALSE; } m_pCertStore->Release (); m_pCertStore = 0; } } } _TRACE (-1, L"Leaving CCertificate::DeleteFromStore\n"); return bResult; } PCCERT_CONTEXT CCertificate::GetNewCertContext() { PCCERT_CONTEXT pCertContext = 0; if ( m_pCertStore ) { HCERTSTORE hCertStore = m_pCertStore->GetStoreHandle (); if ( hCertStore ) { DWORD cbData = 20; BYTE certHash[20]; BOOL bReturn = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_SHA1_HASH_PROP_ID, &certHash, &cbData); ASSERT (bReturn); if ( bReturn ) { CRYPT_DATA_BLOB blob = {sizeof (certHash), certHash}; pCertContext = CertFindCertificateInStore( hCertStore, 0, 0, CERT_FIND_SHA1_HASH, &blob, 0); if ( pCertContext ) { ::CertFreeCertificateContext (m_pCertContext); m_pCertContext = ::CertDuplicateCertificateContext (pCertContext); } } } } return pCertContext; } CString CCertificate::FormatStatus() { CString status; status.FormatMessage (L"%1 %2", (IsReadOnly () ? L"R" : L" "), (IsArchived () ? L"A" : L" ")); return status; } ////////////////////////////////////////////////////////////////////////////////////// // Stolen from private\ispu\ui\cryptui\frmtutil.cpp ////////////////////////////////////////////////////////////////////////////////////// const WCHAR RgwchHex[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; HRESULT CCertificate::FormatSerialNoString(LPWSTR *ppString, CRYPT_INTEGER_BLOB const *pblob) { if ( !ppString || !pblob ) return E_POINTER; DWORD i = 0; LPBYTE pb; DWORD numCharsInserted = 0; // // calculate size needed // pb = &pblob->pbData[pblob->cbData-1]; while (pb >= &pblob->pbData[0]) { if (numCharsInserted == 4) { i += sizeof(WCHAR); numCharsInserted = 0; } else { i += 2 * sizeof(WCHAR); pb--; numCharsInserted += 2; } } if (NULL == (*ppString = (LPWSTR) CoTaskMemAlloc (i+sizeof(WCHAR)))) { return E_OUTOFMEMORY; } // fill the buffer i=0; numCharsInserted = 0; pb = &pblob->pbData[pblob->cbData-1]; while (pb >= &pblob->pbData[0]) { if (numCharsInserted == 4) { (*ppString)[i++] = L' '; numCharsInserted = 0; } else { (*ppString)[i++] = RgwchHex[(*pb & 0xf0) >> 4]; (*ppString)[i++] = RgwchHex[*pb & 0x0f]; pb--; numCharsInserted += 2; } } (*ppString)[i] = 0; return S_OK; } CString CCertificate::GetDescription() { ASSERT (CERTMGR_CERTIFICATE == m_objecttype); if ( m_pCertContext && m_szDescription.IsEmpty () ) { AFX_MANAGE_STATE (AfxGetStaticModuleState ()); DWORD cbData = 0; BOOL bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_DESCRIPTION_PROP_ID, NULL, &cbData); if ( bResult ) { LPWSTR pszName = new WCHAR[cbData]; if ( pszName ) { ::ZeroMemory (pszName, cbData*sizeof (WCHAR)); bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_DESCRIPTION_PROP_ID, pszName, &cbData); ASSERT (bResult); if ( bResult ) { m_szDescription = pszName; } delete [] pszName; } } else { DWORD dwErr = GetLastError (); if ( CRYPT_E_NOT_FOUND == dwErr ) { _TRACE (0, L"CertGetCertificateContextProperty (CERT_DESCRIPTION_PROP_ID) found no description.\n"); } else { _TRACE (0, L"CertGetCertificateContextProperty (CERT_DESCRIPTION_PROP_ID) failed: 0x%x\n", dwErr); } } } return m_szDescription; } HRESULT CCertificate::SetDescription(const CString &szDescription) { _TRACE (1, L"Entering CCertificate::SetDescription (%s)\n", (PCWSTR) szDescription); HRESULT hr = S_OK; CRYPT_DATA_BLOB cryptDataBlob; ::ZeroMemory (&cryptDataBlob, sizeof (CRYPT_DATA_BLOB)); cryptDataBlob.pbData = (LPBYTE) (PCWSTR) szDescription; cryptDataBlob.cbData = (DWORD) (wcslen (szDescription) + 1) * sizeof (WCHAR); BOOL bResult = ::CertSetCertificateContextProperty (m_pCertContext, CERT_DESCRIPTION_PROP_ID, 0, &cryptDataBlob); ASSERT (bResult); if ( bResult ) { m_szDescription = szDescription; } else { DWORD dwErr = GetLastError (); _TRACE (0, L"CertSetCertificateContextProperty (CERT_DESCRIPTION_PROP_ID, %s) failed: %d\n", (PCWSTR) szDescription, dwErr); hr = HRESULT_FROM_WIN32 (dwErr); } _TRACE (1, L"Entering CCertificate::SetDescription (%s): 0x%x\n", (PCWSTR) szDescription, hr); return hr; } HRESULT CCertificate::SetLastModified () { HRESULT hr = S_OK; if ( m_pCertContext ) { SYSTEMTIME st; FILETIME ft; GetSystemTime (&st); VERIFY (SystemTimeToFileTime(&st, &ft)); CRYPT_DATA_BLOB cryptDataBlob; ::ZeroMemory (&cryptDataBlob, sizeof (CRYPT_DATA_BLOB)); cryptDataBlob.pbData = (LPBYTE) &ft; cryptDataBlob.cbData = sizeof (FILETIME); BOOL bResult = ::CertSetCertificateContextProperty ( m_pCertContext, CERT_DATE_STAMP_PROP_ID, 0, &cryptDataBlob); ASSERT (bResult); if ( !bResult ) { DWORD dwErr = GetLastError (); _TRACE (0, L"CertSetCertificateContextProperty (CERT_DATE_STAMP_PROP_ID) failed: %d\n", dwErr); hr = HRESULT_FROM_WIN32 (dwErr); } } return hr; } CString CCertificate::GetShortLastModified () { return GetLastModified (DATE_SHORTDATE); } CString CCertificate::GetLongLastModified () { return GetLastModified (DATE_LONGDATE); } /////////////////////////////////////////////////////////////////////////////// // // Method: GetLastModified // Purpose: Get the date stamp property of the cert and format for display // Inputs: dwDateFlags - as defined in SDK, specify DATE_SHORTDATE or // DATE_LONGDATE // bRetryIfNotPresent - to prevent stack overflow. Used if the property // is not set, to set the property to the current time and // retrieve again. // // Output: locale-formatted date and time string // /////////////////////////////////////////////////////////////////////////////// CString CCertificate::GetLastModified(DWORD dwDateFlags, bool bRetryIfNotPresent /* true */) { CString szDate; ASSERT (CERTMGR_CERTIFICATE == m_objecttype); if ( m_pCertContext ) { AFX_MANAGE_STATE (AfxGetStaticModuleState ()); FILETIME ft; DWORD cbData = sizeof (ft); BOOL bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_DATE_STAMP_PROP_ID, &ft, &cbData); if ( bResult ) { VERIFY (SUCCEEDED (FormatDate (ft, szDate, dwDateFlags, true)) ); } else { if ( bRetryIfNotPresent ) { if ( SUCCEEDED (SetLastModified ()) ) // not present - set the value { szDate = GetLastModified (dwDateFlags, false); CCertStore* pCertStore = GetCertStore (); if ( pCertStore ) pCertStore->Commit (); } } DWORD dwErr = GetLastError (); if ( CRYPT_E_NOT_FOUND == dwErr ) { _TRACE (0, L"CertGetCertificateContextProperty (CERT_DATE_STAMP_PROP_ID) found no property.\n"); } else { _TRACE (0, L"CertGetCertificateContextProperty (CERT_DATE_STAMP_PROP_ID) failed: 0x%x\n", dwErr); } } } return szDate; } HRESULT CCertificate::GetLastModifiedFileTime (FILETIME& ft) { HRESULT hr = S_OK; ASSERT (CERTMGR_CERTIFICATE == m_objecttype); ASSERT (m_pCertContext); if ( m_pCertContext ) { DWORD cbData = sizeof (ft); BOOL bResult = ::CertGetCertificateContextProperty ( m_pCertContext, CERT_DATE_STAMP_PROP_ID, &ft, &cbData); if ( !bResult ) { DWORD dwErr = GetLastError (); if ( CRYPT_E_NOT_FOUND == dwErr ) { _TRACE (0, L"CertGetCertificateContextProperty (CERT_DATE_STAMP_PROP_ID) found no property.\n"); } else { _TRACE (0, L"CertGetCertificateContextProperty (CERT_DATE_STAMP_PROP_ID) failed: 0x%x\n", dwErr); } hr = HRESULT_FROM_WIN32 (dwErr); } } else hr = E_FAIL; return hr; } BOOL CCertificate::operator==(CCertificate& rCert) { if ( GetMD5Hash () == rCert.GetMD5Hash () ) return TRUE; else return FALSE; } // NTRAID# 247237 Cert UI: Cert Snapin: Certificates snapin should show template name CString CCertificate::GetTemplateName() { if ( m_pCertInfo && !(m_fieldChecked & FIELD_TEMPLATE_NAME) ) { // Iterate through the extensions until szOID_CERTIFICATE_TEMPLATE is found. for (DWORD index = 0; index < m_pCertInfo->cExtension; index++) { ASSERT (m_pCertInfo->rgExtension); if ( !strcmp (szOID_CERTIFICATE_TEMPLATE, m_pCertInfo->rgExtension[index].pszObjId) ) { m_szTemplateName = DecodeV2TemplateName (&(m_pCertInfo->rgExtension[index])); break; } else if ( !strcmp (szOID_ENROLL_CERTTYPE_EXTENSION, m_pCertInfo->rgExtension[index].pszObjId) ) { m_szTemplateName = DecodeV1TemplateName (&(m_pCertInfo->rgExtension[index])); break; } } m_fieldChecked |= FIELD_TEMPLATE_NAME; } return m_szTemplateName; } // NTRAID# 247237 Cert UI: Cert Snapin: Certificates snapin should show template name CString CCertificate::DecodeV1TemplateName (PCERT_EXTENSION pCertExtension) { CString szTemplateName; ASSERT (pCertExtension); if ( pCertExtension ) { DWORD cbValue = 0; if ( ::CryptDecodeObject( CRYPT_ASN_ENCODING, X509_UNICODE_ANY_STRING, pCertExtension->Value.pbData, pCertExtension->Value.cbData, 0, 0, &cbValue) ) { CERT_NAME_VALUE* pCNValue = (CERT_NAME_VALUE*) ::LocalAlloc(LPTR, cbValue); if ( pCNValue ) { if ( ::CryptDecodeObject( CRYPT_ASN_ENCODING, X509_UNICODE_ANY_STRING, pCertExtension->Value.pbData, pCertExtension->Value.cbData, 0, pCNValue, &cbValue) ) { szTemplateName = (LPWSTR) pCNValue->Value.pbData; // NTRAID# 395173 Certificates Snapin:The column " // Certificate Template" should contain value of "Template // Name" for V1 templates HCERTTYPE hCertType = 0; HRESULT hr = CAFindCertTypeByName (szTemplateName, NULL, CT_ENUM_MACHINE_TYPES | CT_ENUM_USER_TYPES, &hCertType); if ( SUCCEEDED (hr) ) { PWSTR* rgwszProp = 0; hr = CAGetCertTypePropertyEx (hCertType, CERTTYPE_PROP_FRIENDLY_NAME, &rgwszProp); if ( SUCCEEDED (hr) && rgwszProp ) { szTemplateName = *rgwszProp; CAFreeCertTypeProperty (hCertType, rgwszProp); } else { _TRACE (0, L"CAGetCertTypePropertyEx (CERTTYPE_PROP_FRIENDLY_NAME) failed: 0x%x\n", hr); } CACloseCertType (hCertType); } } else { _TRACE (0, L"CryptDecodeObject (CRYPT_ASN_ENCODING, X509_UNICODE_ANY_STRING, ...) failed: 0x%x\n", GetLastError ()); } ::LocalFree (pCNValue); } } else { _TRACE (0, L"CryptDecodeObject (CRYPT_ASN_ENCODING, X509_UNICODE_ANY_STRING, ...) failed: 0x%x\n", GetLastError ()); } } return szTemplateName; } // NTRAID# 247237 Cert UI: Cert Snapin: Certificates snapin should show template name CString CCertificate::DecodeV2TemplateName (PCERT_EXTENSION pCertExtension) { CString szTemplateName; ASSERT (pCertExtension); if ( pCertExtension ) { DWORD cbData = 0; if ( CryptDecodeObject(X509_ASN_ENCODING, szOID_CERTIFICATE_TEMPLATE, pCertExtension->Value.pbData, pCertExtension->Value.cbData, 0, NULL, &cbData) ) { CERT_TEMPLATE_EXT* pbTemplate = (CERT_TEMPLATE_EXT*) LocalAlloc(LPTR, cbData); if ( pbTemplate ) { if ( CryptDecodeObject(X509_ASN_ENCODING, szOID_CERTIFICATE_TEMPLATE, pCertExtension->Value.pbData, pCertExtension->Value.cbData, 0, pbTemplate, &cbData) ) { CString text; CString description; //copy the extension oid if ( pbTemplate->pszObjId ) { MyGetOIDInfo (szTemplateName, pbTemplate->pszObjId); } } else { _TRACE (0, L"CryptDecodeObject (X509_ASN_ENCODING, szOID_CERTIFICATE_TEMPLATE, ...) failed: 0x%x\n", GetLastError ()); } LocalFree (pbTemplate); } } else { _TRACE (0, L"CryptDecodeObject (X509_ASN_ENCODING, szOID_CERTIFICATE_TEMPLATE, ...) failed: 0x%x\n", GetLastError ()); } } return szTemplateName; } void CCertificate::SetStore (CCertStore* pStore) { if ( !m_pCertStore && !pStore ) return; if ( m_pCertStore && pStore ) { if ( *m_pCertStore == *pStore ) return; // don't change if the same } if ( m_pCertStore ) { m_pCertStore->Release (); m_pCertStore = 0; } if ( pStore ) { m_pCertStore = pStore; m_pCertStore->AddRef (); } if ( m_pCertContext ) { PCCERT_CONTEXT pCertContext = GetNewCertContext (); ::CertFreeCertificateContext (m_pCertContext); m_pCertInfo = 0; m_pCertContext = 0; m_pCertContext = pCertContext; if ( m_pCertContext ) m_pCertInfo = m_pCertContext->pCertInfo; } }