/////////////////////////////////////////////////////////////////////////////// //This file has the implementation for the WMI Provider for WHQL. //Uses MFC /////////////////////////////////////////////////////////////////////////////// // WhqlObj.cpp : Implementation of CWhqlObj #include "stdafx.h" #include "msinfo32.h" #include "WhqlObj.h" #include "chkdrv.h" HCATADMIN g_hCatAdmin; Classes_Provided eClasses; ///////////////////////////////////////////////////////////////////////////// // CWhqlObj //v-stlowe 5-7-2001 SCODE CWhqlObj::PutPropertyDTMFValue(IWbemClassObject* pInstance, LPCTSTR szName, LPCTSTR szValue) { HRESULT hr = S_FALSE; if (pInstance) { CComVariant ovValue(szValue); hr = ovValue.ChangeType(VT_DATE); COleDateTime dateTime = ovValue; CString strDateTime = dateTime.Format(_T("%Y%m%d%H%M%S.******+***")); ovValue = strDateTime.AllocSysString(); if(SUCCEEDED(hr)) { hr = pInstance->Put(CComBSTR(szName), 0, &ovValue, 0); } } return hr; } SCODE CWhqlObj::PutPropertyValue(IWbemClassObject* pInstance, LPCTSTR szName, LPCTSTR szValue) { HRESULT hr = S_FALSE; if(pInstance) { hr = pInstance->Put(CComBSTR(szName), 0, &CComVariant(szValue), 0); } return hr; } int WalkTreeHelper(DEVNODE hDevnode, DEVNODE hParent) { CheckDevice *pCurrentDevice; DEVNODE hSibling; DEVNODE hChild; CONFIGRET retval; pCurrentDevice = new CheckDevice(hDevnode, hParent); if(pCurrentDevice) { retval = pCurrentDevice->GetChild(&hChild); if(!retval) { WalkTreeHelper(hChild, hDevnode); } retval = pCurrentDevice->GetSibling(&hSibling); if(!retval) { WalkTreeHelper(hSibling, hParent); } } return TRUE; } int CWhqlObj::WalkTree(void) { CONFIGRET retval; DEVNODE hDevnode; //v-stlowe CheckDevice * pCurrentDevice = (CheckDevice *) DevnodeClass::GetHead(); if (pCurrentDevice) { return TRUE; } //end v-stlowe // create devnode list retval = CM_Locate_DevNode(&hDevnode, NULL, CM_LOCATE_DEVNODE_NORMAL); if(retval) { //logprintf("ERROR: Could not locate any PnP Devices\r\n"); return FALSE; } else WalkTreeHelper(hDevnode, NULL); return(TRUE); } STDMETHODIMP CWhqlObj::Initialize(LPWSTR pszUser, LONG lFlags, LPWSTR pszNamespace, LPWSTR pszLocale, IWbemServices *pNamespace, IWbemContext *pCtx, IWbemProviderInitSink *pInitSink) { if(pNamespace) pNamespace->AddRef(); //Standard Var Inits. m_pNamespace = pNamespace; //Let CIMOM know you are initialized pInitSink->SetStatus(WBEM_S_INITIALIZED, 0); return WBEM_S_NO_ERROR; } SCODE CWhqlObj::CreateInstanceEnumAsync(BSTR RefStr, long lFlags, IWbemContext *pCtx, IWbemObjectSink *pHandler) { HRESULT hr = S_OK; IWbemClassObject *pClass = NULL; IWbemClassObject **ppInstances = NULL; LONG cInstances, lIndex; cInstances = lIndex = 0L; // Do a check of arguments and make sure we have pointer to Namespace if(pHandler == NULL || m_pNamespace == NULL) return WBEM_E_INVALID_PARAMETER; // Get a class object from CIMOM hr = m_pNamespace->GetObject(RefStr, 0, pCtx, &pClass, NULL); if(FAILED(hr)) return WBEM_E_FAILED; CString csRefStr = RefStr; if(_tcsicmp(csRefStr , _T("Win32_PnPSignedDriver")) == 0) { eClasses = Class_Win32_PnPSignedDriver; } else if(_tcsicmp(csRefStr , _T("Win32_PnPSignedDriverCIMDataFile")) == 0) { eClasses = Class_Win32_PnPSignedDriverCIMDataFile; } CPtrArray ptrArr; ptrArr.RemoveAll(); CreateList(ptrArr, pClass, pCtx, eClasses); //regular devices BuildPrinterFileList(ptrArr, pClass, pCtx, eClasses); //installed printers hr = pClass->Release(); cInstances = (LONG)ptrArr.GetSize(); ppInstances = (IWbemClassObject**)new LPVOID[cInstances]; for(int nIndex = 0 ;nIndexIndicate(cInstances, ppInstances); for (lIndex = 0; lIndex < cInstances; lIndex++) ppInstances[lIndex]->Release(); } // Cleanup if (ppInstances) { delete []ppInstances; ppInstances = NULL; } ptrArr.RemoveAll(); // End Cleanup // Set status hr = pHandler->SetStatus(0, hr, NULL, NULL); return hr; } typedef BOOL (WINAPI *pSetupVerifyInfFile)( IN PCWSTR InfName, IN PSP_ALTPLATFORM_INFO AltPlatformInfo, OPTIONAL OUT PSP_INF_SIGNER_INFO_W InfSignerInfo ); int CWhqlObj::CreateList(CPtrArray& ptrArr, IWbemClassObject *& pClass, IWbemContext *pCtx ,Classes_Provided eClasses) { if(pCtx == NULL) return S_FALSE; TCHAR szName[MAX_PATH] ; TCHAR szDeviceID[MAX_PATH] , szClassGuid[MAX_PATH] , szDeviceDesc[MAX_PATH]; LONG len = sizeof(szName); HRESULT hr = S_FALSE; ULONG lRet = 0L; LONG lIndex = 0L; CString cstring; IWbemClassObject *pInstance = NULL; CheckDevice *pCurrentDevice = NULL; CheckDevice *pToBeDeletedDevice = NULL; FileNode *file; CComBSTR bstr; BOOL bAddedInstance = FALSE; TCHAR szTemp[ MAX_PATH + 1 ]; SP_INF_SIGNER_INFO infSignerInfo; HINSTANCE hinst = NULL; pSetupVerifyInfFile fpSetupVerifyInfFile = NULL; hinst = LoadLibrary(_T("SetupApi.dll")); #ifdef _UNICODE fpSetupVerifyInfFile = (pSetupVerifyInfFile)GetProcAddress(hinst, "SetupVerifyInfFileW"); #else fpSetupVerifyInfFile = (pSetupVerifyInfFile)GetProcAddress(hinst, "SetupVerifyInfFileA"); #endif ZeroMemory(&infSignerInfo , sizeof(SP_INF_SIGNER_INFO)); infSignerInfo.cbSize = sizeof(SP_INF_SIGNER_INFO); WalkTree(); CString csPathStr; GetServerAndNamespace(pCtx, csPathStr); //Get Server And Namespace. pCurrentDevice = (CheckDevice *) DevnodeClass::GetHead(); while(pCurrentDevice) { if(eClasses == Class_Win32_PnPSignedDriver && !bAddedInstance) { bAddedInstance = TRUE; if(pClass) hr = pClass->SpawnInstance(0, &pInstance); if(SUCCEEDED(hr) && pInstance) { //m_ptrArr.Add(pInstance); ptrArr.Add(pInstance); PutPropertyValue( pInstance , _T("DeviceName") , pCurrentDevice->DeviceName()); PutPropertyValue( pInstance , _T("DeviceClass") , pCurrentDevice->DeviceClass()); PutPropertyValue( pInstance , _T("HardwareID") , pCurrentDevice->HardwareID()); PutPropertyValue( pInstance , _T("CompatID") , pCurrentDevice->CompatID()); PutPropertyValue( pInstance , _T("DeviceID") , pCurrentDevice->DeviceID()); PutPropertyValue( pInstance , _T("ClassGuid") , pCurrentDevice->GUID()); PutPropertyValue( pInstance , _T("Location") , pCurrentDevice->Location()); PutPropertyValue( pInstance , _T("PDO") , pCurrentDevice->PDO()); PutPropertyValue( pInstance , _T("Manufacturer") , pCurrentDevice->MFG()); PutPropertyValue( pInstance , _T("FriendlyName") , pCurrentDevice->FriendlyName()); PutPropertyValue( pInstance , _T("InfName") , pCurrentDevice->InfName()); PutPropertyValue( pInstance , _T("DriverProviderName") , pCurrentDevice->InfProvider()); PutPropertyValue( pInstance , _T("DevLoader") , pCurrentDevice->DevLoader()); PutPropertyValue( pInstance , _T("DriverName") , pCurrentDevice->DriverName()); PutPropertyDTMFValue( pInstance , _T("DriverDate") , pCurrentDevice->DriverDate()); PutPropertyValue( pInstance , _T("Description") , pCurrentDevice->DriverDesc()); PutPropertyValue( pInstance , _T("DriverVersion") , pCurrentDevice->DriverVersion()); PutPropertyValue( pInstance , _T("InfSection") , pCurrentDevice->InfSection()); if(pCurrentDevice->InfName()) { //cstring.Format(_T("%%WINDIR%%\\inf\\%s"), pCurrentDevice->InfName()); //ExpandEnvironmentStrings(cstring , szTemp , sizeof(szTemp) + 1 ); TCHAR *pInfpath = NULL; DWORD dw = ExpandEnvironmentStrings(_T("%windir%"), NULL, 0); if(dw > 0) { pInfpath = new TCHAR[dw]; if(pInfpath) { dw = ExpandEnvironmentStrings(_T("%windir%"), pInfpath, dw); CString szTemp(pInfpath); szTemp += _T("\\inf\\"); szTemp += pCurrentDevice->InfName(); BOOL bRet = FALSE; //Do only if SetupApi.dll loaded & we have got fpSetupVerifyInfFile if(fpSetupVerifyInfFile != NULL) { bRet = (*fpSetupVerifyInfFile)( /*IN PCSTR*/ szTemp, /*IN PSP_ALTPLATFORM_INFO*/NULL, /*OUT PSP_INF_SIGNER_INFO_A*/ &infSignerInfo ); hr = pInstance->Put(L"IsSigned", 0, &CComVariant(bRet), 0 ); if(bRet) PutPropertyValue( pInstance , _T("Signer") , infSignerInfo.DigitalSigner); } delete[] pInfpath; pInfpath = NULL; }//if(pInfpath) }//if(dw > 0) }//if(pCurrentDevice->InfName()) } } if(eClasses == Class_Win32_PnPSignedDriverCIMDataFile) { CString szAntecedent(pCurrentDevice->DeviceID()); //Antecedent if(!szAntecedent.IsEmpty()) { szAntecedent.Replace(_T("\\"), _T("\\\\")); file = pCurrentDevice->GetFileList(); while(file) { CString szDependent(file->FilePath()); //Dependent if(!szDependent.IsEmpty()) { szDependent.Replace(_T("\\"), _T("\\\\")); if(pClass) hr = pClass->SpawnInstance(0, &pInstance); if(SUCCEEDED(hr) && pInstance) { if(!csPathStr.IsEmpty()) { CString szData(csPathStr); szData += _T(":Win32_PnPSignedDriver.DeviceID=\""); szData += szAntecedent; szData += _T("\""); hr = pInstance->Put(_T("Antecedent"), 0, &CComVariant(szData), 0); szData.Empty(); szData = csPathStr; szData += _T(":CIM_DataFile.Name=\""); szData += szDependent; szData += _T("\""); hr = pInstance->Put(_T("Dependent"), 0, &CComVariant(szData), 0); ptrArr.Add(pInstance); } } } file = file->pNext; } } } //pToBeDeletedDevice = pCurrentDevice; pCurrentDevice = (CheckDevice *)pCurrentDevice->GetNext(); //if(pToBeDeletedDevice) //delete pToBeDeletedDevice ;//delete pToBeDeletedDevice which will release it from CheckDevice Linked List. bAddedInstance = FALSE; } if(hinst) FreeLibrary(hinst); return hr; } SCODE CWhqlObj::GetServerAndNamespace(IWbemContext* pCtx, CString& csPathStr) { HRESULT hr = S_FALSE; ULONG lRet = 0L; CComBSTR language = _T("WQL"); CComBSTR query = _T("select __NameSpace , __Server from Win32_PnpEntity"); CComPtr pEnum; CComPtr pObject; hr = m_pNamespace->ExecQuery(language , query , WBEM_FLAG_RETURN_IMMEDIATELY|WBEM_FLAG_FORWARD_ONLY, pCtx , &pEnum); language.Empty(); query.Empty(); if(pEnum == NULL) return S_FALSE; CComVariant v; //Get Server And Namespace from the Enum. if( WBEM_S_NO_ERROR == pEnum->Next(WBEM_INFINITE , 1 , &pObject , &lRet ) ) { //Fill csPathStr.Its value will be used in Antecedent & Dependent in assoc. class. //At the end of the condition we should have something like //csPathStr = "\\\\A-KJAW-RI1\\root\\CIMV2" if(csPathStr.IsEmpty()) { hr = pObject->Get(L"__Server", 0, &v, NULL , NULL); if( SUCCEEDED(hr) ) { csPathStr += _T("\\\\"); csPathStr += V_BSTR(&v); hr = pObject->Get(L"__NameSpace", 0, &v, NULL , NULL); if( SUCCEEDED(hr) ) { csPathStr += _T("\\"); csPathStr += V_BSTR(&v); } ATLTRACE(_T("Server & Namespace Path = %s\n") , csPathStr); VariantClear(&v); } } } return hr; } /************************************************************************* * Function : VerifyIsFileSigned * Purpose : Calls WinVerifyTrust with Policy Provider GUID to * verify if an individual file is signed. **************************************************************************/ BOOL VerifyIsFileSigned(LPTSTR pcszMatchFile, PDRIVER_VER_INFO lpVerInfo) { INT iRet; HRESULT hRes; WINTRUST_DATA WinTrustData; WINTRUST_FILE_INFO WinTrustFile; GUID gOSVerCheck = DRIVER_ACTION_VERIFY; GUID gPublishedSoftware = WINTRUST_ACTION_GENERIC_VERIFY_V2; #ifndef UNICODE WCHAR wszFileName[MAX_PATH]; #endif ZeroMemory(&WinTrustData, sizeof(WINTRUST_DATA)); WinTrustData.cbStruct = sizeof(WINTRUST_DATA); WinTrustData.dwUIChoice = WTD_UI_NONE; WinTrustData.fdwRevocationChecks = WTD_REVOKE_NONE; WinTrustData.dwUnionChoice = WTD_CHOICE_FILE; WinTrustData.dwStateAction = WTD_STATEACTION_AUTO_CACHE; WinTrustData.pFile = &WinTrustFile; WinTrustData.pPolicyCallbackData = (LPVOID)lpVerInfo; ZeroMemory(lpVerInfo, sizeof(DRIVER_VER_INFO)); lpVerInfo->cbStruct = sizeof(DRIVER_VER_INFO); ZeroMemory(&WinTrustFile, sizeof(WINTRUST_FILE_INFO)); WinTrustFile.cbStruct = sizeof(WINTRUST_FILE_INFO); #ifndef UNICODE iRet = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pcszMatchFile, -1, (LPWSTR)&wszFileName, cA(wszFileName)); WinTrustFile.pcwszFilePath = wszFileName; #else WinTrustFile.pcwszFilePath = pcszMatchFile; #endif hRes = WinVerifyTrust((HWND) INVALID_HANDLE_VALUE, &gOSVerCheck, &WinTrustData); if (hRes != ERROR_SUCCESS) { hRes = WinVerifyTrust((HWND) INVALID_HANDLE_VALUE, &gPublishedSoftware, &WinTrustData); } // // Free the pcSignerCertContext member of the DRIVER_VER_INFO struct // that was allocated in our call to WinVerifyTrust. // if (lpVerInfo && lpVerInfo->pcSignerCertContext) { CertFreeCertificateContext(lpVerInfo->pcSignerCertContext); lpVerInfo->pcSignerCertContext = NULL; } return(hRes == ERROR_SUCCESS); } // // Given a specific LPFILENODE, verify that the file is signed or unsigned. // Fill in all the necessary structures so the listview control can display properly. // BOOL VerifyFileNode(LPFILENODE lpFileNode) { HANDLE hFile; BOOL bRet; HCATINFO hCatInfo = NULL; HCATINFO PrevCat; WINTRUST_DATA WinTrustData; WINTRUST_CATALOG_INFO WinTrustCatalogInfo; DRIVER_VER_INFO VerInfo; GUID gSubSystemDriver = DRIVER_ACTION_VERIFY; HRESULT hRes; DWORD cbHash = HASH_SIZE; BYTE szHash[HASH_SIZE]; LPBYTE lpHash = szHash; CATALOG_INFO CatInfo; LPTSTR lpFilePart; TCHAR szBuffer[MAX_PATH]; static TCHAR szCurrentDirectory[MAX_PATH]; OSVERSIONINFO OsVersionInfo; BOOL bTmp = FALSE; #ifndef UNICODE WCHAR UnicodeKey[MAX_PATH]; #endif if (!SetCurrentDirectory(lpFileNode->lpDirName)) { return FALSE; } // // Get the handle to the file, so we can call CryptCATAdminCalcHashFromFileHandle // hFile = CreateFile( lpFileNode->lpFileName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { lpFileNode->LastError = GetLastError(); return FALSE; } // Initialize the hash buffer ZeroMemory(lpHash, HASH_SIZE); // Generate the hash from the file handle and store it in lpHash if (!CryptCATAdminCalcHashFromFileHandle(hFile, &cbHash, lpHash, 0)) { // // If we couldn't generate a hash, it might be an individually signed catalog. // If it's a catalog, zero out lpHash and cbHash so we know there's no hash to check. // if (IsCatalogFile(hFile, NULL)) { lpHash = NULL; cbHash = 0; } else { // If it wasn't a catalog, we'll bail and this file will show up as unscanned. CloseHandle(hFile); return FALSE; } } // Close the file handle CloseHandle(hFile); // // Now we have the file's hash. Initialize the structures that // will be used later on in calls to WinVerifyTrust. // ZeroMemory(&WinTrustData, sizeof(WINTRUST_DATA)); WinTrustData.cbStruct = sizeof(WINTRUST_DATA); WinTrustData.dwUIChoice = WTD_UI_NONE; WinTrustData.fdwRevocationChecks = WTD_REVOKE_NONE; WinTrustData.dwUnionChoice = WTD_CHOICE_CATALOG; WinTrustData.dwStateAction = WTD_STATEACTION_AUTO_CACHE; WinTrustData.pPolicyCallbackData = (LPVOID)&VerInfo; ZeroMemory(&VerInfo, sizeof(DRIVER_VER_INFO)); VerInfo.cbStruct = sizeof(DRIVER_VER_INFO); // // Only validate against the current OS Version, unless the bValidateAgainstAnyOs // parameter was TRUE. In that case we will just leave the sOSVersionXxx fields // 0 which tells WinVerifyTrust to validate against any OS. // if (!lpFileNode->bValidateAgainstAnyOs) { OsVersionInfo.dwOSVersionInfoSize = sizeof(OsVersionInfo); if (GetVersionEx(&OsVersionInfo)) { VerInfo.sOSVersionLow.dwMajor = OsVersionInfo.dwMajorVersion; VerInfo.sOSVersionLow.dwMinor = OsVersionInfo.dwMinorVersion; VerInfo.sOSVersionHigh.dwMajor = OsVersionInfo.dwMajorVersion; VerInfo.sOSVersionHigh.dwMinor = OsVersionInfo.dwMinorVersion; } } WinTrustData.pCatalog = &WinTrustCatalogInfo; ZeroMemory(&WinTrustCatalogInfo, sizeof(WINTRUST_CATALOG_INFO)); WinTrustCatalogInfo.cbStruct = sizeof(WINTRUST_CATALOG_INFO); WinTrustCatalogInfo.pbCalculatedFileHash = lpHash; WinTrustCatalogInfo.cbCalculatedFileHash = cbHash; #ifdef UNICODE WinTrustCatalogInfo.pcwszMemberTag = lpFileNode->lpFileName; #else MultiByteToWideChar(CP_ACP, 0, lpFileNode->lpFileName, -1, UnicodeKey, cA(UnicodeKey)); WinTrustCatalogInfo.pcwszMemberTag = UnicodeKey; #endif // // Now we try to find the file hash in the catalog list, via CryptCATAdminEnumCatalogFromHash // PrevCat = NULL; hCatInfo = CryptCATAdminEnumCatalogFromHash(g_hCatAdmin, lpHash, cbHash, 0, &PrevCat); // // We want to cycle through the matching catalogs until we find one that matches both hash and member tag // bRet = FALSE; while (hCatInfo && !bRet) { ZeroMemory(&CatInfo, sizeof(CATALOG_INFO)); CatInfo.cbStruct = sizeof(CATALOG_INFO); if (CryptCATCatalogInfoFromContext(hCatInfo, &CatInfo, 0)) { WinTrustCatalogInfo.pcwszCatalogFilePath = CatInfo.wszCatalogFile; // Now verify that the file is an actual member of the catalog. hRes = WinVerifyTrust((HWND) INVALID_HANDLE_VALUE, &gSubSystemDriver, &WinTrustData); if (hRes == ERROR_SUCCESS) { #ifdef UNICODE GetFullPathName(CatInfo.wszCatalogFile, MAX_PATH, szBuffer, &lpFilePart); #else WideCharToMultiByte(CP_ACP, 0, CatInfo.wszCatalogFile, -1, szBuffer, sizeof(szBuffer), NULL, NULL); GetFullPathName(szBuffer, MAX_PATH, szBuffer, &lpFilePart); #endif lpFileNode->lpCatalog = (LPTSTR) MALLOC((lstrlen(lpFilePart) + 1) * sizeof(TCHAR)); if (lpFileNode->lpCatalog) { lstrcpy(lpFileNode->lpCatalog, lpFilePart); } bRet = TRUE; } // // Free the pcSignerCertContext member of the DRIVER_VER_INFO struct // that was allocated in our call to WinVerifyTrust. // if (VerInfo.pcSignerCertContext != NULL) { CertFreeCertificateContext(VerInfo.pcSignerCertContext); VerInfo.pcSignerCertContext = NULL; } } if (!bRet) { // The hash was in this catalog, but the file wasn't a member... so off to the next catalog PrevCat = hCatInfo; hCatInfo = CryptCATAdminEnumCatalogFromHash(g_hCatAdmin, lpHash, cbHash, 0, &PrevCat); } } // Mark this file as having been scanned. lpFileNode->bScanned = TRUE; if (!hCatInfo) { // // If it wasn't found in the catalogs, check if the file is individually signed. // bRet = VerifyIsFileSigned(lpFileNode->lpFileName, (PDRIVER_VER_INFO)&VerInfo); if (bRet) { // If so, mark the file as being signed. lpFileNode->bSigned = TRUE; } } else { // The file was verified in the catalogs, so mark it as signed and free the catalog context. lpFileNode->bSigned = TRUE; CryptCATAdminReleaseCatalogContext(g_hCatAdmin, hCatInfo, 0); } if (lpFileNode->bSigned) { #ifdef UNICODE lpFileNode->lpVersion = (LPTSTR) MALLOC((lstrlen(VerInfo.wszVersion) + 1) * sizeof(TCHAR)); if (lpFileNode->lpVersion) { lstrcpy(lpFileNode->lpVersion, VerInfo.wszVersion); } lpFileNode->lpSignedBy = (LPTSTR) MALLOC((lstrlen(VerInfo.wszSignedBy) + 1) * sizeof(TCHAR)); if (lpFileNode->lpSignedBy) { lstrcpy(lpFileNode->lpSignedBy, VerInfo.wszSignedBy); } #else WideCharToMultiByte(CP_ACP, 0, VerInfo.wszVersion, -1, szBuffer, sizeof(szBuffer), NULL, NULL); lpFileNode->lpVersion = MALLOC((lstrlen(szBuffer) + 1) * sizeof(TCHAR)); if (lpFileNode->lpVersion) { lstrcpy(lpFileNode->lpVersion, szBuffer); } WideCharToMultiByte(CP_ACP, 0, VerInfo.wszSignedBy, -1, szBuffer, sizeof(szBuffer), NULL, NULL); lpFileNode->lpSignedBy = MALLOC((lstrlen(szBuffer) + 1) * sizeof(TCHAR)); if (lpFileNode->lpSignedBy) { lstrcpy(lpFileNode->lpSignedBy, szBuffer); } #endif } else { // // Get the icon (if the file isn't signed) so we can display it in the listview faster. // //MyGetFileInfo(lpFileNode); } return lpFileNode->bSigned; } LPFILENODE CreateFileNode(LPTSTR lpDirectory, LPTSTR lpFileName) { LPFILENODE lpFileNode; TCHAR szDirName[MAX_PATH]; FILETIME ftLocalTime; WIN32_FILE_ATTRIBUTE_DATA faData; BOOL bRet; GetCurrentDirectory(MAX_PATH, szDirName); CharLowerBuff(szDirName, lstrlen(szDirName)); lpFileNode = (LPFILENODE) MALLOC(sizeof(FILENODE)); if (lpFileNode) { lpFileNode->lpFileName = (LPTSTR) MALLOC((lstrlen(lpFileName) + 1) * sizeof(TCHAR)); if (!lpFileNode->lpFileName) { goto clean0; } lstrcpy(lpFileNode->lpFileName, lpFileName); CharLowerBuff(lpFileNode->lpFileName, lstrlen(lpFileNode->lpFileName)); if (lpDirectory) { lpFileNode->lpDirName = (LPTSTR) MALLOC((lstrlen(lpDirectory) + 1) * sizeof(TCHAR)); if (!lpFileNode->lpDirName) { goto clean0; } lstrcpy(lpFileNode->lpDirName, lpDirectory); CharLowerBuff(lpFileNode->lpDirName, lstrlen(lpFileNode->lpDirName)); } else { lpFileNode->lpDirName = (LPTSTR) MALLOC((lstrlen(szDirName) + 1) * sizeof(TCHAR)); if (!lpFileNode->lpDirName) { goto clean0; } lstrcpy(lpFileNode->lpDirName, szDirName); CharLowerBuff(lpFileNode->lpDirName, lstrlen(lpFileNode->lpDirName)); } if (lpDirectory) SetCurrentDirectory(lpDirectory); ZeroMemory(&faData, sizeof(WIN32_FILE_ATTRIBUTE_DATA)); bRet = GetFileAttributesEx(lpFileName, GetFileExInfoStandard, &faData); if (bRet) { // Store away the last access time for logging purposes. FileTimeToLocalFileTime(&faData.ftLastWriteTime, &ftLocalTime); FileTimeToSystemTime(&ftLocalTime, &lpFileNode->LastModified); } } if (lpDirectory) SetCurrentDirectory(szDirName); return lpFileNode; clean0: // // If we get here then we weren't able to allocate all of the memory needed // for this structure, so free up any memory we were able to allocate and // reutnr NULL. // if (lpFileNode) { if (lpFileNode->lpFileName) { FREE(lpFileNode->lpFileName); } if (lpFileNode->lpDirName) { FREE(lpFileNode->lpDirName); } FREE(lpFileNode); } return NULL; } LPFILENODE Check_File(LPTSTR szFilePathName) { LPFILENODE lpFileNode = NULL; // If we don't already have a g_hCatAdmin handle, acquire one. if (!g_hCatAdmin) { CryptCATAdminAcquireContext(&g_hCatAdmin, NULL, 0); } TCHAR* szFileName = szFilePathName; if(szFilePathName) { szFileName = _tcsrchr(szFilePathName, _T('\\')); if(szFileName) { *szFileName++ = _T('\0'); lpFileNode = CreateFileNode(szFilePathName, szFileName); if(lpFileNode) { VerifyFileNode(lpFileNode); } } } return lpFileNode; } // returns data between dbl quotes, unescapes slashes // "\\\\red-prn-23\\priv0124" -> \\red-prn-23\priv0124 LPTSTR GetQuotedData(VARIANT& v, BOOL bUnescapeSlashs = TRUE) { CString szData; if(v.vt == VT_BSTR) { szData = v.bstrVal; if(!szData.IsEmpty()) { int nPos = szData.Find(_T('"')); if(nPos >= 0 && (szData.GetLength() > 1)) { szData = szData.Mid(nPos + 1); nPos = szData.Find(_T('"')); if(nPos >= 0) { szData = szData.Mid(0, nPos); if(bUnescapeSlashs) szData.Replace(_T("\\\\"), _T("\\")); } } } VariantClear(&v); v.vt = VT_BSTR; v.bstrVal = CComBSTR(szData); } return CComBSTR(szData); } void CWhqlObj::BuildPrinterFileList(CPtrArray& ptrArr, IWbemClassObject *& pClass, IWbemContext *pCtx , Classes_Provided eClasses) { IEnumWbemClassObject *pEnum = NULL; IWbemClassObject *pInstance = NULL; IWbemClassObject *pObject = NULL; ULONG uReturned = 0; HRESULT hr = WBEM_S_NO_ERROR; CComVariant val; LPFILENODE lpFileNode = NULL; if((eClasses == Class_Win32_PnPSignedDriver) || (eClasses == Class_Win32_PnPSignedDriverCIMDataFile)) { CoImpersonateClient(); //Impersonate the client. This is a must to be able to see network printers. CString csPathStr; GetServerAndNamespace(pCtx, csPathStr); //Get Server And Namespace. hr = m_pNamespace->CreateInstanceEnum(CComBSTR("Win32_PrinterDriverDll"), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, pCtx, &pEnum); while(WBEM_S_NO_ERROR == hr && pEnum) { hr = pEnum->Next(WBEM_INFINITE, 1, &pObject, &uReturned); if(SUCCEEDED(hr) && pObject) { hr = pObject->Get(_T("Antecedent"), 0, &val, NULL , NULL); if(SUCCEEDED(hr)) { if(pClass) hr = pClass->SpawnInstance(0, &pInstance); if(SUCCEEDED(hr) && pInstance) { if(eClasses == Class_Win32_PnPSignedDriver) { LPTSTR szDriverPath = GetQuotedData(val); if(szDriverPath) { lpFileNode = Check_File(szDriverPath); if(lpFileNode) { val = lpFileNode->bSigned; hr = pInstance->Put(_T("IsSigned"), 0, &val, 0); val.Clear(); val = lpFileNode->lpVersion; hr = pInstance->Put(_T("DriverVersion"), 0, &val, 0); val.Clear(); val = lpFileNode->lpSignedBy; hr = pInstance->Put(_T("Signer"), 0, &val, 0); } } } else if(eClasses == Class_Win32_PnPSignedDriverCIMDataFile) { GetQuotedData(val, FALSE); CString szData(csPathStr); szData += _T(":CIM_DataFile.Name=\""); szData += val.bstrVal; szData += _T("\""); val = szData; hr = pInstance->Put(_T("Dependent"), 0, &val, 0); } val.Clear(); hr = pObject->Get(_T("Dependent"), 0, &val, NULL , NULL); if(SUCCEEDED(hr)) { if(eClasses == Class_Win32_PnPSignedDriver) { GetQuotedData(val); hr = pInstance->Put(_T("DeviceID"), 0, &val, 0); } else if(eClasses == Class_Win32_PnPSignedDriverCIMDataFile) { GetQuotedData(val, FALSE); CString szData(csPathStr); szData += _T(":Win32_PnPSignedDriver.DeviceID=\""); szData += val.bstrVal; szData += _T("\""); val = szData; hr = pInstance->Put(_T("Antecedent"), 0, &val, 0); } } ptrArr.Add(pInstance); } val.Clear(); } if(pObject) { pObject->Release(); pObject = NULL; } } val.Clear(); } if(pEnum) { pEnum->Release(); pEnum = NULL; } CoRevertToSelf(); //Revert back } }