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.
3076 lines
78 KiB
3076 lines
78 KiB
//
|
|
// Driver Verifier UI
|
|
// Copyright (c) Microsoft Corporation, 1999
|
|
//
|
|
//
|
|
//
|
|
// module: VrfUtil.cpp
|
|
// author: DMihai
|
|
// created: 11/1/00
|
|
//
|
|
// Description
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "verifier.h"
|
|
|
|
#include "vrfutil.h"
|
|
#include "vglobal.h"
|
|
#include "VSetting.h"
|
|
#include "disk.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
//
|
|
// Global data
|
|
//
|
|
|
|
const TCHAR RegMemoryManagementKeyName[] =
|
|
_T( "System\\CurrentControlSet\\Control\\Session Manager\\Memory Management" );
|
|
|
|
const TCHAR RegVerifyDriverLevelValueName[] =
|
|
_T( "VerifyDriverLevel" );
|
|
|
|
const TCHAR RegVerifyDriversValueName[] =
|
|
_T( "VerifyDrivers" );
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Report an error using a dialog box or a console message.
|
|
// The message format string is loaded from the resources.
|
|
//
|
|
|
|
void __cdecl VrfErrorResourceFormat( UINT uIdResourceFormat,
|
|
... )
|
|
{
|
|
TCHAR szMessage[ 256 ];
|
|
TCHAR strFormat[ 256 ];
|
|
BOOL bResult;
|
|
va_list prms;
|
|
|
|
//
|
|
// Load the format string from the resources
|
|
//
|
|
|
|
bResult = VrfLoadString( uIdResourceFormat,
|
|
strFormat,
|
|
ARRAY_LENGTH( strFormat ) );
|
|
|
|
ASSERT( bResult );
|
|
|
|
if( bResult )
|
|
{
|
|
va_start (prms, uIdResourceFormat);
|
|
|
|
//
|
|
// Format the message in our local buffer
|
|
//
|
|
|
|
_vsntprintf ( szMessage,
|
|
ARRAY_LENGTH( szMessage ),
|
|
strFormat,
|
|
prms);
|
|
|
|
szMessage[ ARRAY_LENGTH( szMessage ) - 1 ] = (TCHAR)0;
|
|
|
|
if( g_bCommandLineMode )
|
|
{
|
|
//
|
|
// Command console mode
|
|
//
|
|
|
|
_putts( szMessage );
|
|
|
|
TRACE( _T( "%s\n" ), szMessage );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// GUI mode
|
|
//
|
|
|
|
AfxMessageBox( szMessage,
|
|
MB_OK | MB_ICONSTOP );
|
|
}
|
|
|
|
va_end (prms);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Print out a message to the console
|
|
// The message string is loaded from the resources.
|
|
//
|
|
|
|
void __cdecl VrfTPrintfResourceFormat( UINT uIdResourceFormat,
|
|
... )
|
|
{
|
|
TCHAR szMessage[ 256 ];
|
|
TCHAR strFormat[ 256 ];
|
|
BOOL bResult;
|
|
va_list prms;
|
|
|
|
ASSERT( g_bCommandLineMode );
|
|
|
|
//
|
|
// Load the format string from the resources
|
|
//
|
|
|
|
bResult = VrfLoadString( uIdResourceFormat,
|
|
strFormat,
|
|
ARRAY_LENGTH( strFormat ) );
|
|
|
|
ASSERT( bResult );
|
|
|
|
if( bResult )
|
|
{
|
|
va_start (prms, uIdResourceFormat);
|
|
|
|
//
|
|
// Format the message in our local buffer
|
|
//
|
|
|
|
_vsntprintf ( szMessage,
|
|
ARRAY_LENGTH( szMessage ),
|
|
strFormat,
|
|
prms);
|
|
|
|
szMessage[ ARRAY_LENGTH( szMessage ) - 1 ] = (TCHAR)0;
|
|
|
|
_putts( szMessage );
|
|
|
|
va_end (prms);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Print out a simple (non-formatted) message to the console
|
|
// The message string is loaded from the resources.
|
|
//
|
|
|
|
void __cdecl VrfPrintStringFromResources( UINT uIdString )
|
|
{
|
|
TCHAR szMessage[ 256 ];
|
|
|
|
ASSERT( g_bCommandLineMode );
|
|
|
|
VERIFY( VrfLoadString( uIdString,
|
|
szMessage,
|
|
ARRAY_LENGTH( szMessage ) ) );
|
|
|
|
_putts( szMessage );
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Report an error using a dialog box or a console message.
|
|
// The message string is loaded from the resources.
|
|
//
|
|
|
|
void __cdecl VrfMesssageFromResource( UINT uIdString )
|
|
{
|
|
TCHAR szMessage[ 256 ];
|
|
|
|
VERIFY( VrfLoadString( uIdString,
|
|
szMessage,
|
|
ARRAY_LENGTH( szMessage ) ) );
|
|
|
|
if( g_bCommandLineMode )
|
|
{
|
|
//
|
|
// Command console mode
|
|
//
|
|
|
|
_putts( szMessage );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// GUI mode
|
|
//
|
|
|
|
AfxMessageBox( szMessage,
|
|
MB_OK | MB_ICONINFORMATION );
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Load a string from resources.
|
|
// Return TRUE if we successfully loaded and FALSE if not.
|
|
//
|
|
|
|
BOOL VrfLoadString( ULONG uIdResource,
|
|
TCHAR *szBuffer,
|
|
ULONG uBufferLength )
|
|
{
|
|
ULONG uLoadStringResult;
|
|
|
|
if( uBufferLength < 1 )
|
|
{
|
|
ASSERT( FALSE );
|
|
return FALSE;
|
|
}
|
|
|
|
uLoadStringResult = LoadString (
|
|
g_hProgramModule,
|
|
uIdResource,
|
|
szBuffer,
|
|
uBufferLength );
|
|
|
|
//
|
|
// We should never try to load non-existent strings.
|
|
//
|
|
|
|
ASSERT (uLoadStringResult > 0);
|
|
|
|
return (uLoadStringResult > 0);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Load a string from resources.
|
|
// Return TRUE if we successfully loaded and FALSE if not.
|
|
//
|
|
|
|
BOOL VrfLoadString( ULONG uIdResource,
|
|
CString &strText )
|
|
{
|
|
TCHAR szText[ 256 ];
|
|
BOOL bSuccess;
|
|
|
|
bSuccess = VrfLoadString( uIdResource,
|
|
szText,
|
|
ARRAY_LENGTH( szText ) );
|
|
|
|
if( TRUE == bSuccess )
|
|
{
|
|
strText = szText;
|
|
}
|
|
else
|
|
{
|
|
strText = "";
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
VOID
|
|
CopyStringArray( const CStringArray &strArraySource,
|
|
CStringArray &strArrayDest )
|
|
{
|
|
INT_PTR nNewSize;
|
|
INT_PTR nCrtElem;
|
|
|
|
strArrayDest.RemoveAll();
|
|
|
|
nNewSize = strArraySource.GetSize();
|
|
|
|
for( nCrtElem = 0; nCrtElem < nNewSize; nCrtElem += 1 )
|
|
{
|
|
strArrayDest.Add( strArraySource.GetAt( nCrtElem ) );
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copied from sdktools\bvtsigvf
|
|
//
|
|
|
|
BOOL VerifyIsFileSigned( LPCTSTR pcszMatchFile,
|
|
PDRIVER_VER_INFO lpVerInfo)
|
|
{
|
|
HRESULT hRes;
|
|
WINTRUST_DATA WinTrustData;
|
|
WINTRUST_FILE_INFO WinTrustFile;
|
|
GUID gOSVerCheck = DRIVER_ACTION_VERIFY;
|
|
GUID gPublishedSoftware = WINTRUST_ACTION_GENERIC_VERIFY_V2;
|
|
#ifndef UNICODE
|
|
INT iRet;
|
|
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, wszFileName, ARRAY_LENGTH(wszFileName));
|
|
WinTrustFile.pcwszFilePath = wszFileName;
|
|
#else
|
|
WinTrustFile.pcwszFilePath = pcszMatchFile;
|
|
#endif
|
|
|
|
hRes = WinVerifyTrust( AfxGetMainWnd()->m_hWnd, &gOSVerCheck, &WinTrustData);
|
|
if (hRes != ERROR_SUCCESS)
|
|
hRes = WinVerifyTrust( AfxGetMainWnd()->m_hWnd, &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);
|
|
}
|
|
|
|
#define HASH_SIZE 100
|
|
|
|
BOOL IsDriverSigned( LPCTSTR szDriverFileName )
|
|
{
|
|
HANDLE hFile;
|
|
BOOL bSigned;
|
|
BOOL bSuccess;
|
|
HRESULT hTrustResult;
|
|
DWORD dwHashSize;
|
|
GUID guidSubSystemDriver = DRIVER_ACTION_VERIFY;
|
|
HCATINFO hCatInfo;
|
|
HCATINFO hPrevCatInfo;
|
|
BYTE Hash[ HASH_SIZE ];
|
|
WINTRUST_DATA WinTrustData;
|
|
DRIVER_VER_INFO VerInfo;
|
|
WINTRUST_CATALOG_INFO WinTrustCatalogInfo;
|
|
CATALOG_INFO CatInfo;
|
|
|
|
#ifndef UNICODE
|
|
WCHAR szUnicodeFileName[MAX_PATH];
|
|
#endif
|
|
|
|
ASSERT( NULL != szDriverFileName );
|
|
|
|
bSigned = FALSE;
|
|
|
|
//
|
|
// Open the file
|
|
//
|
|
|
|
hFile = CreateFile( szDriverFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
//
|
|
// ISSUE:
|
|
//
|
|
// If we cannot find the file we assume it's signed
|
|
//
|
|
|
|
bSigned = TRUE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Generate the hash from the file handle and store it in Hash
|
|
//
|
|
|
|
dwHashSize = ARRAY_LENGTH( Hash );
|
|
|
|
ZeroMemory( Hash,
|
|
sizeof( Hash ) );
|
|
|
|
bSuccess = CryptCATAdminCalcHashFromFileHandle( hFile,
|
|
&dwHashSize,
|
|
Hash,
|
|
0);
|
|
|
|
CloseHandle( hFile );
|
|
|
|
if( TRUE != bSuccess )
|
|
{
|
|
//
|
|
// If we couldn't generate a hash assume the file is not signed
|
|
//
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Now we have the file's hash. Initialize the structures that
|
|
// will be used later on in calls to WinVerifyTrust.
|
|
//
|
|
|
|
//
|
|
// Initialize the VerInfo structure
|
|
//
|
|
|
|
ZeroMemory( &VerInfo, sizeof( VerInfo ) );
|
|
|
|
VerInfo.cbStruct = sizeof( VerInfo );
|
|
|
|
//
|
|
// Initialize the WinTrustCatalogInfo structure
|
|
//
|
|
|
|
ZeroMemory( &WinTrustCatalogInfo, sizeof( WinTrustCatalogInfo ) );
|
|
|
|
WinTrustCatalogInfo.cbStruct = sizeof(WinTrustCatalogInfo);
|
|
WinTrustCatalogInfo.pbCalculatedFileHash = Hash;
|
|
WinTrustCatalogInfo.cbCalculatedFileHash = dwHashSize;
|
|
|
|
#ifdef UNICODE
|
|
|
|
WinTrustCatalogInfo.pcwszMemberTag = szDriverFileName;
|
|
|
|
#else
|
|
|
|
MultiByteToWideChar( CP_ACP,
|
|
0,
|
|
szDriverFileName,
|
|
-1,
|
|
szUnicodeFileName,
|
|
ARRAY_LENGTH( szUnicodeFileName ) );
|
|
|
|
WinTrustCatalogInfo.pcwszMemberTag = szUnicodeFileName;
|
|
|
|
#endif
|
|
|
|
//
|
|
// Initialize the WinTrustData structure
|
|
//
|
|
|
|
ZeroMemory( &WinTrustData, sizeof( WinTrustData ) );
|
|
|
|
WinTrustData.cbStruct = sizeof( WinTrustData );
|
|
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;
|
|
|
|
WinTrustData.pCatalog = &WinTrustCatalogInfo;
|
|
|
|
//
|
|
// If we don't have a g_hCatAdmin yet, acquire one
|
|
//
|
|
|
|
if( NULL == g_hCatAdmin )
|
|
{
|
|
CryptCATAdminAcquireContext( &g_hCatAdmin,
|
|
NULL,
|
|
0);
|
|
|
|
if( NULL == g_hCatAdmin )
|
|
{
|
|
//
|
|
// Bad luck - consider that the file is not signed and bail out
|
|
//
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now we try to find the file hash in the catalog list, via CryptCATAdminEnumCatalogFromHash
|
|
//
|
|
|
|
hPrevCatInfo = NULL;
|
|
|
|
hCatInfo = CryptCATAdminEnumCatalogFromHash(
|
|
g_hCatAdmin,
|
|
Hash,
|
|
dwHashSize,
|
|
0,
|
|
&hPrevCatInfo );
|
|
|
|
while( TRUE != bSigned && NULL != hCatInfo )
|
|
{
|
|
ZeroMemory( &CatInfo, sizeof( CatInfo ) );
|
|
CatInfo.cbStruct = sizeof( CatInfo );
|
|
|
|
bSuccess = CryptCATCatalogInfoFromContext( hCatInfo,
|
|
&CatInfo,
|
|
0);
|
|
|
|
if( FALSE != bSuccess )
|
|
{
|
|
WinTrustCatalogInfo.pcwszCatalogFilePath = CatInfo.wszCatalogFile;
|
|
|
|
//
|
|
// Now verify that the file is an actual member of the catalog.
|
|
//
|
|
|
|
hTrustResult = WinVerifyTrust( AfxGetMainWnd()->m_hWnd,
|
|
&guidSubSystemDriver,
|
|
&WinTrustData );
|
|
|
|
bSigned = SUCCEEDED( hTrustResult );
|
|
|
|
//
|
|
// 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( TRUE != bSigned )
|
|
{
|
|
//
|
|
// The hash was in this catalog, but the file wasn't a member... so off to the next catalog
|
|
//
|
|
|
|
hPrevCatInfo = hCatInfo;
|
|
|
|
hCatInfo = CryptCATAdminEnumCatalogFromHash( g_hCatAdmin,
|
|
Hash,
|
|
dwHashSize,
|
|
0,
|
|
&hPrevCatInfo );
|
|
}
|
|
}
|
|
|
|
if( NULL == hCatInfo )
|
|
{
|
|
//
|
|
// If it wasn't found in the catalogs, check if the file is individually signed.
|
|
//
|
|
|
|
bSigned = VerifyIsFileSigned( szDriverFileName,
|
|
&VerInfo );
|
|
}
|
|
|
|
Done:
|
|
|
|
return bSigned;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfSetWindowText( CWnd &Wnd,
|
|
ULONG uIdResourceString )
|
|
{
|
|
BOOL bLoaded;
|
|
CString strText;
|
|
|
|
//
|
|
// It's safe to use CString::LoadString here because we are
|
|
// in GUI mode
|
|
//
|
|
|
|
ASSERT( FALSE == g_bCommandLineMode );
|
|
|
|
bLoaded = strText.LoadString( uIdResourceString );
|
|
|
|
ASSERT( TRUE == bLoaded );
|
|
|
|
Wnd.SetWindowText( strText );
|
|
|
|
return ( TRUE == bLoaded );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfWriteVerifierSettings( BOOL bHaveNewDrivers,
|
|
const CString &strDriversToVerify,
|
|
BOOL bHaveNewFlags,
|
|
DWORD dwVerifyFlags )
|
|
{
|
|
HKEY hMmKey = NULL;
|
|
LONG lResult;
|
|
BOOL bSuccess;
|
|
|
|
ASSERT( bHaveNewDrivers || bHaveNewFlags );
|
|
|
|
if( bHaveNewDrivers && strDriversToVerify.GetLength() == 0 )
|
|
{
|
|
//
|
|
// No drivers to verify
|
|
//
|
|
|
|
return VrfDeleteAllVerifierSettings();
|
|
}
|
|
|
|
if( bHaveNewFlags )
|
|
{
|
|
TRACE( _T( "VrfWriteVerifierSettings: New verifier flags = %#x\n" ),
|
|
dwVerifyFlags );
|
|
}
|
|
|
|
if( bHaveNewDrivers )
|
|
{
|
|
TRACE( _T( "VrfWriteVerifierSettings: New drivers = %s\n" ),
|
|
(LPCTSTR) strDriversToVerify );
|
|
}
|
|
|
|
//
|
|
// Open the Mm key
|
|
//
|
|
|
|
lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
RegMemoryManagementKeyName,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
&hMmKey );
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
if( lResult == ERROR_ACCESS_DENIED )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
}
|
|
else
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGOPENKEYEX_FAILED,
|
|
RegMemoryManagementKeyName,
|
|
(DWORD)lResult);
|
|
}
|
|
|
|
goto Done;
|
|
}
|
|
|
|
if( bHaveNewFlags )
|
|
{
|
|
//
|
|
// Write VerifyDriverLevel value
|
|
//
|
|
|
|
if( VrfWriteRegistryDwordValue( hMmKey,
|
|
RegVerifyDriverLevelValueName,
|
|
dwVerifyFlags ) == FALSE )
|
|
{
|
|
RegCloseKey (hMmKey);
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
if( bHaveNewDrivers )
|
|
{
|
|
//
|
|
// Write VerifyDrivers value
|
|
//
|
|
|
|
if( VrfWriteRegistryStringValue( hMmKey,
|
|
RegVerifyDriversValueName,
|
|
strDriversToVerify ) == FALSE )
|
|
{
|
|
RegCloseKey (hMmKey);
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Close the Mm key and return success
|
|
//
|
|
|
|
RegCloseKey( hMmKey );
|
|
|
|
Done:
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfWriteRegistryDwordValue( HKEY hKey,
|
|
LPCTSTR szValueName,
|
|
DWORD dwValue )
|
|
{
|
|
LONG lResult;
|
|
BOOL bSuccess;
|
|
|
|
lResult = RegSetValueEx( hKey,
|
|
szValueName,
|
|
0,
|
|
REG_DWORD,
|
|
( LPBYTE ) &dwValue,
|
|
sizeof( dwValue ) );
|
|
|
|
bSuccess = ( lResult == ERROR_SUCCESS );
|
|
|
|
g_bSettingsSaved = g_bSettingsSaved | bSuccess;
|
|
|
|
if( TRUE != bSuccess )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGSETVALUEEX_FAILED,
|
|
szValueName,
|
|
(DWORD) lResult );
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfWriteRegistryStringValue( HKEY hKey,
|
|
LPCTSTR szValueName,
|
|
LPCTSTR szValue )
|
|
{
|
|
BOOL bSuccess;
|
|
LONG lResult;
|
|
|
|
lResult = RegSetValueEx ( hKey,
|
|
szValueName,
|
|
0,
|
|
REG_SZ,
|
|
(LPBYTE) szValue,
|
|
( _tcslen( szValue ) + 1 ) * sizeof (TCHAR) );
|
|
|
|
bSuccess = ( lResult == ERROR_SUCCESS );
|
|
|
|
g_bSettingsSaved = g_bSettingsSaved | bSuccess;
|
|
|
|
if( TRUE != bSuccess )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGSETVALUEEX_FAILED,
|
|
szValueName,
|
|
(DWORD) lResult);
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfReadVerifierSettings( CString &strDriversToVerify,
|
|
DWORD &dwVerifyFlags )
|
|
{
|
|
HKEY hMmKey = NULL;
|
|
LONG lResult;
|
|
BOOL bSuccess;
|
|
|
|
bSuccess = FALSE;
|
|
|
|
//
|
|
// Open the Mm key
|
|
//
|
|
|
|
lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
RegMemoryManagementKeyName,
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hMmKey );
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
if( lResult == ERROR_ACCESS_DENIED )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
}
|
|
else
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGOPENKEYEX_FAILED,
|
|
RegMemoryManagementKeyName,
|
|
(DWORD)lResult);
|
|
}
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Read VerifyDriverLevel value
|
|
//
|
|
|
|
if( VrfReadRegistryDwordValue( hMmKey,
|
|
RegVerifyDriverLevelValueName,
|
|
dwVerifyFlags ) == FALSE )
|
|
{
|
|
RegCloseKey (hMmKey);
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Read VerifyDrivers value
|
|
//
|
|
|
|
if( VrfReadRegistryStringValue( hMmKey,
|
|
RegVerifyDriversValueName,
|
|
strDriversToVerify ) == FALSE )
|
|
{
|
|
RegCloseKey (hMmKey);
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Close the Mm key and return success
|
|
//
|
|
|
|
RegCloseKey( hMmKey );
|
|
|
|
bSuccess = TRUE;
|
|
|
|
Done:
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrtLoadCurrentRegistrySettings( BOOL &bAllDriversVerified,
|
|
CStringArray &astrDriversToVerify,
|
|
DWORD &dwVerifyFlags )
|
|
{
|
|
BOOL bResult;
|
|
CString strDriversToVerify;
|
|
|
|
astrDriversToVerify.RemoveAll();
|
|
dwVerifyFlags = 0;
|
|
bAllDriversVerified = FALSE;
|
|
|
|
bResult = VrfReadVerifierSettings( strDriversToVerify,
|
|
dwVerifyFlags );
|
|
|
|
strDriversToVerify.TrimLeft();
|
|
strDriversToVerify.TrimRight();
|
|
|
|
if( strDriversToVerify.CompareNoCase( _T( "*" ) ) == 0 )
|
|
{
|
|
bAllDriversVerified = TRUE;
|
|
}
|
|
else
|
|
{
|
|
VrfSplitDriverNamesSpaceSeparated( strDriversToVerify,
|
|
astrDriversToVerify );
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID VrfSplitDriverNamesSpaceSeparated( CString strAllDrivers,
|
|
CStringArray &astrVerifyDriverNames )
|
|
{
|
|
INT nCharIndex;
|
|
CString strCrtDriverName;
|
|
|
|
astrVerifyDriverNames.RemoveAll();
|
|
|
|
//
|
|
// Split the space separated driver names in astrDriversToVerify
|
|
//
|
|
|
|
strAllDrivers.TrimRight();
|
|
|
|
while( TRUE )
|
|
{
|
|
strAllDrivers.TrimLeft();
|
|
|
|
if( strAllDrivers.GetLength() == 0 )
|
|
{
|
|
//
|
|
// We are done parsing the whole string
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Look for a space or a tab
|
|
//
|
|
|
|
nCharIndex = strAllDrivers.Find( _T( ' ' ) );
|
|
|
|
if( nCharIndex < 0 )
|
|
{
|
|
nCharIndex = strAllDrivers.Find( _T( '\t' ) );
|
|
}
|
|
|
|
if( nCharIndex >= 0 )
|
|
{
|
|
//
|
|
// Found a separator character
|
|
//
|
|
|
|
strCrtDriverName = strAllDrivers.Left( nCharIndex );
|
|
|
|
if( strCrtDriverName.GetLength() > 0 &&
|
|
FALSE == VrfIsStringInArray( strCrtDriverName,
|
|
astrVerifyDriverNames ) )
|
|
{
|
|
astrVerifyDriverNames.Add( strCrtDriverName );
|
|
}
|
|
|
|
strAllDrivers = strAllDrivers.Right( strAllDrivers.GetLength() - nCharIndex - 1 );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This is the last driver name
|
|
//
|
|
|
|
if( FALSE == VrfIsStringInArray( strAllDrivers,
|
|
astrVerifyDriverNames ) )
|
|
{
|
|
astrVerifyDriverNames.Add( strAllDrivers );
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfIsDriversSetDifferent( CString strAllDrivers1,
|
|
const CStringArray &astrVerifyDriverNames2 )
|
|
{
|
|
BOOL bDifferent;
|
|
INT_PTR nDriverNames1;
|
|
INT_PTR nDriverNames2;
|
|
INT_PTR nCrtDriver1;
|
|
INT_PTR nCrtDriver2;
|
|
CString strDriver1;
|
|
CString strDriver2;
|
|
CStringArray astrVerifyDriverNames1;
|
|
|
|
bDifferent = TRUE;
|
|
|
|
VrfSplitDriverNamesSpaceSeparated( strAllDrivers1,
|
|
astrVerifyDriverNames1 );
|
|
|
|
nDriverNames1 = astrVerifyDriverNames1.GetSize();
|
|
nDriverNames2 = astrVerifyDriverNames2.GetSize();
|
|
|
|
if( nDriverNames1 == nDriverNames2 )
|
|
{
|
|
//
|
|
// Same number of drivers
|
|
//
|
|
|
|
bDifferent = FALSE;
|
|
|
|
for( nCrtDriver1 = 0; nCrtDriver1 < nDriverNames1; nCrtDriver1 += 1 )
|
|
{
|
|
strDriver1 = astrVerifyDriverNames1.GetAt( nCrtDriver1 );
|
|
|
|
bDifferent = TRUE;
|
|
|
|
//
|
|
// Look for strDriver1 in astrVerifyDriverNames2
|
|
//
|
|
|
|
for( nCrtDriver2 = 0; nCrtDriver2 < nDriverNames2; nCrtDriver2 += 1 )
|
|
{
|
|
strDriver2 = astrVerifyDriverNames2.GetAt( nCrtDriver2 );
|
|
|
|
if( strDriver1.CompareNoCase( strDriver2 ) == 0 )
|
|
{
|
|
bDifferent = FALSE;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( TRUE == bDifferent )
|
|
{
|
|
//
|
|
// Did not find strDriver1 in astrVerifyDriverNames2
|
|
//
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bDifferent;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfReadRegistryDwordValue( HKEY hKey,
|
|
LPCTSTR szValueName,
|
|
DWORD &dwValue )
|
|
{
|
|
LONG lResult;
|
|
BOOL bSuccess;
|
|
DWORD dwType;
|
|
DWORD dwDataSize;
|
|
|
|
dwDataSize = sizeof( dwValue );
|
|
|
|
lResult = RegQueryValueEx( hKey,
|
|
szValueName,
|
|
0,
|
|
&dwType,
|
|
( LPBYTE ) &dwValue,
|
|
&dwDataSize );
|
|
|
|
if( lResult == ERROR_FILE_NOT_FOUND )
|
|
{
|
|
//
|
|
// The value doesn't currently exist
|
|
//
|
|
|
|
dwValue = 0;
|
|
bSuccess = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bSuccess = ( ERROR_SUCCESS == lResult &&
|
|
REG_DWORD == dwType &&
|
|
dwDataSize == sizeof( dwValue ) );
|
|
}
|
|
|
|
if( TRUE != bSuccess )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGQUERYVALUEEX_FAILED,
|
|
szValueName,
|
|
(DWORD) lResult );
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfReadRegistryStringValue( HKEY hKey,
|
|
LPCTSTR szValueName,
|
|
CString &strDriversToVerify )
|
|
{
|
|
BOOL bSuccess;
|
|
LONG lResult;
|
|
LPTSTR szDriversToVerify;
|
|
ULONG uRegKeyLength;
|
|
DWORD dwType;
|
|
DWORD dwDataSize;
|
|
|
|
bSuccess = FALSE;
|
|
lResult = ERROR_NOT_ENOUGH_MEMORY;
|
|
szDriversToVerify = NULL;
|
|
|
|
for( uRegKeyLength = 128; uRegKeyLength < 4096; uRegKeyLength += 128 )
|
|
{
|
|
//
|
|
// Try allocate a local buffer and use it to query
|
|
//
|
|
|
|
szDriversToVerify = new TCHAR[ uRegKeyLength ];
|
|
|
|
if( NULL != szDriversToVerify )
|
|
{
|
|
dwDataSize = uRegKeyLength * sizeof (TCHAR);
|
|
|
|
lResult = RegQueryValueEx( hKey,
|
|
szValueName,
|
|
0,
|
|
&dwType,
|
|
(LPBYTE) szDriversToVerify,
|
|
&dwDataSize );
|
|
|
|
switch( lResult )
|
|
{
|
|
case ERROR_FILE_NOT_FOUND:
|
|
//
|
|
// Return an empty string
|
|
//
|
|
|
|
szDriversToVerify[ 0 ] = (TCHAR)0;
|
|
|
|
bSuccess = TRUE;
|
|
|
|
break;
|
|
|
|
case ERROR_SUCCESS:
|
|
//
|
|
// Got the driver names from the registry
|
|
//
|
|
|
|
bSuccess = ( REG_SZ == dwType );
|
|
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// Try with a bigger buffer
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if( FALSE != bSuccess )
|
|
{
|
|
//
|
|
// Got what we needed
|
|
//
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Delete the current buffer and try with a bigger one
|
|
//
|
|
|
|
ASSERT( NULL != szDriversToVerify );
|
|
|
|
strDriversToVerify = szDriversToVerify;
|
|
|
|
delete [] szDriversToVerify;
|
|
szDriversToVerify = NULL;
|
|
}
|
|
}
|
|
|
|
if( TRUE != bSuccess )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGSETVALUEEX_FAILED,
|
|
szValueName,
|
|
(DWORD) lResult);
|
|
}
|
|
else
|
|
{
|
|
ASSERT( NULL != szDriversToVerify );
|
|
|
|
strDriversToVerify = szDriversToVerify;
|
|
|
|
delete [] szDriversToVerify;
|
|
szDriversToVerify = NULL;
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfDeleteAllVerifierSettings()
|
|
{
|
|
HKEY hMmKey = NULL;
|
|
LONG lResult;
|
|
BOOL bSuccess;
|
|
|
|
bSuccess = FALSE;
|
|
|
|
//
|
|
// Open the Mm key
|
|
//
|
|
|
|
lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
RegMemoryManagementKeyName,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
&hMmKey );
|
|
|
|
if( lResult != ERROR_SUCCESS )
|
|
{
|
|
if( lResult == ERROR_ACCESS_DENIED )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
}
|
|
else
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGOPENKEYEX_FAILED,
|
|
RegMemoryManagementKeyName,
|
|
(DWORD)lResult);
|
|
}
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Delete VerifyDriverLevel value
|
|
//
|
|
|
|
lResult = RegDeleteValue( hMmKey,
|
|
RegVerifyDriverLevelValueName );
|
|
|
|
if( lResult != ERROR_SUCCESS && lResult != ERROR_FILE_NOT_FOUND )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGDELETEVALUE_FAILED,
|
|
RegVerifyDriverLevelValueName,
|
|
(DWORD) lResult );
|
|
|
|
RegCloseKey (hMmKey);
|
|
|
|
goto Done;
|
|
}
|
|
|
|
g_bSettingsSaved = g_bSettingsSaved | ( lResult != ERROR_FILE_NOT_FOUND );
|
|
|
|
//
|
|
// Delete VerifyDrivers value
|
|
//
|
|
|
|
lResult = RegDeleteValue( hMmKey,
|
|
RegVerifyDriversValueName );
|
|
|
|
if( lResult != ERROR_SUCCESS && lResult != ERROR_FILE_NOT_FOUND )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_REGDELETEVALUE_FAILED,
|
|
RegVerifyDriversValueName,
|
|
(DWORD) lResult );
|
|
|
|
RegCloseKey (hMmKey);
|
|
|
|
goto Done;
|
|
}
|
|
|
|
g_bSettingsSaved = g_bSettingsSaved | ( lResult != ERROR_FILE_NOT_FOUND );
|
|
|
|
//
|
|
// Close the Mm key and return success
|
|
//
|
|
|
|
RegCloseKey( hMmKey );
|
|
|
|
//
|
|
// Delete the disk verifier settings.
|
|
//
|
|
|
|
bSuccess = DeleteAllDiskVerifierSettings();
|
|
|
|
Done:
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
BOOL DeleteAllDiskVerifierSettings()
|
|
{
|
|
BOOL bSuccess;
|
|
INT_PTR nArraySize;
|
|
CDiskData *pOldDiskData;
|
|
LPTSTR szDiskDevicesPDOName;
|
|
|
|
bSuccess = TRUE;
|
|
|
|
nArraySize = g_OldDiskData.GetSize();
|
|
|
|
while( nArraySize > 0 )
|
|
{
|
|
nArraySize -= 1;
|
|
|
|
pOldDiskData = g_OldDiskData.GetAt( nArraySize );
|
|
ASSERT_VALID( pOldDiskData );
|
|
|
|
if( FALSE != pOldDiskData->m_bVerifierEnabled )
|
|
{
|
|
szDiskDevicesPDOName = pOldDiskData->m_strDiskDevicesPDOName.GetBuffer(
|
|
pOldDiskData->m_strDiskDevicesPDOName.GetLength() + 1 );
|
|
|
|
if( NULL == szDiskDevicesPDOName )
|
|
{
|
|
bSuccess = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Verifier will be disabled for this disk.
|
|
//
|
|
|
|
bSuccess = ( DelFilter( g_szFilter,
|
|
szDiskDevicesPDOName ) != FALSE);
|
|
|
|
pOldDiskData->m_strDiskDevicesPDOName.ReleaseBuffer();
|
|
|
|
if( FALSE == bSuccess )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
g_bSettingsSaved = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfGetRuntimeVerifierData( CRuntimeVerifierData *pRuntimeVerifierData )
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG Length = 0;
|
|
ULONG buffersize;
|
|
BOOL bSuccess;
|
|
PSYSTEM_VERIFIER_INFORMATION VerifierInfo;
|
|
PSYSTEM_VERIFIER_INFORMATION VerifierInfoBase;
|
|
CRuntimeDriverData *pCrtDriverData;
|
|
LPTSTR szName;
|
|
|
|
ASSERT_VALID( pRuntimeVerifierData );
|
|
|
|
pRuntimeVerifierData->FillWithDefaults();
|
|
|
|
pRuntimeVerifierData->m_RuntimeDriverDataArray.DeleteAll();
|
|
|
|
bSuccess = FALSE;
|
|
|
|
//
|
|
// Try to get the right size for the NtQuery buffer
|
|
//
|
|
|
|
buffersize = 1024;
|
|
|
|
do
|
|
{
|
|
VerifierInfo = (PSYSTEM_VERIFIER_INFORMATION)malloc (buffersize);
|
|
|
|
if (VerifierInfo == NULL)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
break;
|
|
}
|
|
|
|
Status = NtQuerySystemInformation (SystemVerifierInformation,
|
|
VerifierInfo,
|
|
buffersize,
|
|
&Length);
|
|
|
|
if (Status != STATUS_INFO_LENGTH_MISMATCH)
|
|
{
|
|
break;
|
|
}
|
|
|
|
free (VerifierInfo);
|
|
buffersize += 1024;
|
|
|
|
} while (1);
|
|
|
|
if (! NT_SUCCESS(Status))
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_QUERY_SYSINFO_FAILED,
|
|
Status);
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// If no info fill out return success but no info.
|
|
//
|
|
|
|
if (Length == 0)
|
|
{
|
|
free (VerifierInfo);
|
|
|
|
bSuccess = TRUE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Fill out the cumulative-driver stuff.
|
|
//
|
|
|
|
VerifierInfoBase = VerifierInfo;
|
|
|
|
pRuntimeVerifierData->m_bSpecialPool = (VerifierInfo->Level & DRIVER_VERIFIER_SPECIAL_POOLING) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bForceIrql = (VerifierInfo->Level & DRIVER_VERIFIER_FORCE_IRQL_CHECKING) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bLowRes = (VerifierInfo->Level & DRIVER_VERIFIER_INJECT_ALLOCATION_FAILURES) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bPoolTracking = (VerifierInfo->Level & DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bIo = (VerifierInfo->Level & DRIVER_VERIFIER_IO_CHECKING) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bDeadlockDetect = (VerifierInfo->Level & DRIVER_VERIFIER_DEADLOCK_DETECTION) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bDMAVerif = (VerifierInfo->Level & DRIVER_VERIFIER_DMA_VERIFIER) ? TRUE : FALSE;
|
|
pRuntimeVerifierData->m_bEnhIo = (VerifierInfo->Level & DRIVER_VERIFIER_ENHANCED_IO_CHECKING) ? TRUE : FALSE;
|
|
|
|
pRuntimeVerifierData->RaiseIrqls = VerifierInfo->RaiseIrqls;
|
|
pRuntimeVerifierData->AcquireSpinLocks = VerifierInfo->AcquireSpinLocks;
|
|
pRuntimeVerifierData->SynchronizeExecutions = VerifierInfo->SynchronizeExecutions;
|
|
pRuntimeVerifierData->AllocationsAttempted = VerifierInfo->AllocationsAttempted;
|
|
pRuntimeVerifierData->AllocationsSucceeded = VerifierInfo->AllocationsSucceeded;
|
|
pRuntimeVerifierData->AllocationsSucceededSpecialPool = VerifierInfo->AllocationsSucceededSpecialPool;
|
|
pRuntimeVerifierData->AllocationsWithNoTag = VerifierInfo->AllocationsWithNoTag;
|
|
|
|
pRuntimeVerifierData->Trims = VerifierInfo->Trims;
|
|
pRuntimeVerifierData->AllocationsFailed = VerifierInfo->AllocationsFailed;
|
|
pRuntimeVerifierData->AllocationsFailedDeliberately = VerifierInfo->AllocationsFailedDeliberately;
|
|
|
|
pRuntimeVerifierData->UnTrackedPool = VerifierInfo->UnTrackedPool;
|
|
|
|
pRuntimeVerifierData->Level = VerifierInfo->Level;
|
|
|
|
//
|
|
// Fill out the per-driver stuff.
|
|
//
|
|
|
|
VerifierInfo = VerifierInfoBase;
|
|
|
|
do
|
|
{
|
|
//
|
|
// Allocate a new driver data structure
|
|
//
|
|
|
|
pCrtDriverData = new CRuntimeDriverData;
|
|
|
|
if( NULL == pCrtDriverData )
|
|
{
|
|
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
|
|
|
|
break;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
ANSI_STRING Name;
|
|
NTSTATUS Status;
|
|
|
|
Status = RtlUnicodeStringToAnsiString (
|
|
& Name,
|
|
& VerifierInfo->DriverName,
|
|
TRUE);
|
|
|
|
if (! (NT_SUCCESS(Status) ) )
|
|
{
|
|
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
|
|
|
|
break;
|
|
}
|
|
|
|
szName = pCrtDriverData->m_strName.GetBuffer( Name.Length + 1 );
|
|
|
|
if( NULL != szName )
|
|
{
|
|
CopyMemory( szName,
|
|
Name.Buffer,
|
|
( Name.Length + 1 ) * sizeof( Name.Buffer[ 0 ] ) );
|
|
|
|
szName[ Name.Length ] = 0;
|
|
|
|
pCrtDriverData->m_strName.ReleaseBuffer();
|
|
}
|
|
|
|
RtlFreeAnsiString (& Name);
|
|
|
|
#else
|
|
|
|
szName = pCrtDriverData->m_strName.GetBuffer( VerifierInfo->DriverName.Length + 1 );
|
|
|
|
if( NULL != szName )
|
|
{
|
|
CopyMemory( szName,
|
|
VerifierInfo->DriverName.Buffer,
|
|
( VerifierInfo->DriverName.Length + 1 ) * sizeof( VerifierInfo->DriverName.Buffer[ 0 ] ) );
|
|
|
|
szName[ VerifierInfo->DriverName.Length ] = 0;
|
|
|
|
pCrtDriverData->m_strName.ReleaseBuffer();
|
|
}
|
|
|
|
#endif //#ifndef UNICODE
|
|
|
|
if( FALSE != pRuntimeVerifierData->IsDriverVerified( pCrtDriverData->m_strName ) )
|
|
{
|
|
//
|
|
// This is a duplicate entry - ignore it.
|
|
//
|
|
|
|
delete pCrtDriverData;
|
|
}
|
|
else
|
|
{
|
|
pCrtDriverData->Loads = VerifierInfo->Loads;
|
|
pCrtDriverData->Unloads = VerifierInfo->Unloads;
|
|
|
|
pCrtDriverData->CurrentPagedPoolAllocations = VerifierInfo->CurrentPagedPoolAllocations;
|
|
pCrtDriverData->CurrentNonPagedPoolAllocations = VerifierInfo->CurrentNonPagedPoolAllocations;
|
|
pCrtDriverData->PeakPagedPoolAllocations = VerifierInfo->PeakPagedPoolAllocations;
|
|
pCrtDriverData->PeakNonPagedPoolAllocations = VerifierInfo->PeakNonPagedPoolAllocations;
|
|
|
|
pCrtDriverData->PagedPoolUsageInBytes = VerifierInfo->PagedPoolUsageInBytes;
|
|
pCrtDriverData->NonPagedPoolUsageInBytes = VerifierInfo->NonPagedPoolUsageInBytes;
|
|
pCrtDriverData->PeakPagedPoolUsageInBytes = VerifierInfo->PeakPagedPoolUsageInBytes;
|
|
pCrtDriverData->PeakNonPagedPoolUsageInBytes = VerifierInfo->PeakNonPagedPoolUsageInBytes;
|
|
|
|
pRuntimeVerifierData->m_RuntimeDriverDataArray.Add( pCrtDriverData );
|
|
}
|
|
|
|
if (VerifierInfo->NextEntryOffset == 0) {
|
|
break;
|
|
}
|
|
|
|
VerifierInfo = (PSYSTEM_VERIFIER_INFORMATION)((PCHAR)VerifierInfo + VerifierInfo->NextEntryOffset);
|
|
|
|
}
|
|
while (1);
|
|
|
|
free (VerifierInfoBase);
|
|
|
|
Done:
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
PLOADED_IMAGE VrfImageLoad( LPTSTR szBinaryName,
|
|
LPTSTR szDirectory )
|
|
{
|
|
#ifdef UNICODE
|
|
|
|
char *szOemImageName;
|
|
char *szOemDirectory;
|
|
int nStringLength;
|
|
PLOADED_IMAGE pLoadedImage;
|
|
|
|
pLoadedImage = NULL;
|
|
|
|
nStringLength = wcslen( szBinaryName );
|
|
|
|
szOemImageName = new char [ nStringLength + 1 ];
|
|
|
|
if( NULL != szOemImageName )
|
|
{
|
|
CharToOem( szBinaryName,
|
|
szOemImageName );
|
|
|
|
if( NULL == szDirectory )
|
|
{
|
|
szOemDirectory = NULL;
|
|
}
|
|
else
|
|
{
|
|
nStringLength = wcslen( szDirectory );
|
|
|
|
szOemDirectory = new char [ nStringLength + 1 ];
|
|
|
|
if (NULL != szOemDirectory)
|
|
{
|
|
CharToOem( szDirectory,
|
|
szOemDirectory );
|
|
}
|
|
}
|
|
|
|
pLoadedImage = ImageLoad( szOemImageName,
|
|
szOemDirectory );
|
|
|
|
if( NULL != szOemDirectory )
|
|
{
|
|
delete [] szOemDirectory;
|
|
}
|
|
|
|
delete [] szOemImageName;
|
|
}
|
|
|
|
return pLoadedImage;
|
|
|
|
#else
|
|
|
|
//
|
|
// Already have ANSI strings
|
|
//
|
|
|
|
return ImageLoad( szBinaryName,
|
|
szDirectory );
|
|
|
|
#endif //#ifdef UNICODE
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfDumpStateToFile( FILE *file )
|
|
{
|
|
BOOL bSuccess;
|
|
INT_PTR nDriversNo;
|
|
INT_PTR nCrtDriver;
|
|
SYSTEMTIME SystemTime;
|
|
TCHAR strLocalTime[ 64 ];
|
|
TCHAR strLocalDate[ 64 ];
|
|
CRuntimeDriverData *pRunDriverData;
|
|
CRuntimeVerifierData RunTimeVerifierData;
|
|
|
|
//
|
|
// Output the date&time in the current user format
|
|
//
|
|
|
|
GetLocalTime( &SystemTime );
|
|
|
|
if( GetDateFormat(
|
|
LOCALE_USER_DEFAULT,
|
|
0,
|
|
&SystemTime,
|
|
NULL,
|
|
strLocalDate,
|
|
ARRAY_LENGTH( strLocalDate ) ) )
|
|
{
|
|
VrfFTPrintf(
|
|
file,
|
|
_T( "%s, " ),
|
|
strLocalDate );
|
|
}
|
|
else
|
|
{
|
|
ASSERT( FALSE );
|
|
}
|
|
|
|
if( GetTimeFormat(
|
|
LOCALE_USER_DEFAULT,
|
|
0,
|
|
&SystemTime,
|
|
NULL,
|
|
strLocalTime,
|
|
ARRAY_LENGTH( strLocalTime ) ) )
|
|
{
|
|
VrfFTPrintf(
|
|
file,
|
|
_T( "%s\n" ),
|
|
strLocalTime);
|
|
}
|
|
else
|
|
{
|
|
ASSERT( FALSE );
|
|
|
|
VrfFTPrintf(
|
|
file,
|
|
_T( "\n" ) );
|
|
}
|
|
|
|
//
|
|
// Get the current verifier statistics
|
|
//
|
|
|
|
if( VrfGetRuntimeVerifierData( &RunTimeVerifierData ) == FALSE) {
|
|
|
|
VrfOuputStringFromResources(
|
|
IDS_CANTGET_VERIF_STATE,
|
|
file );
|
|
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
nDriversNo = RunTimeVerifierData.m_RuntimeDriverDataArray.GetSize();
|
|
|
|
if( 0 == nDriversNo )
|
|
{
|
|
//
|
|
// no statistics to dump
|
|
//
|
|
|
|
bSuccess = VrfOuputStringFromResources(
|
|
IDS_NO_DRIVER_VERIFIED,
|
|
file );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// dump the counters
|
|
//
|
|
|
|
//
|
|
// global counters
|
|
//
|
|
|
|
if( ( ! VrfFTPrintfResourceFormat( file, IDS_LEVEL, RunTimeVerifierData.Level ) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_RAISEIRQLS, RunTimeVerifierData.RaiseIrqls ) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ACQUIRESPINLOCKS, RunTimeVerifierData.AcquireSpinLocks ) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_SYNCHRONIZEEXECUTIONS, RunTimeVerifierData.SynchronizeExecutions) ) ||
|
|
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ALLOCATIONSATTEMPTED, RunTimeVerifierData.AllocationsAttempted) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ALLOCATIONSSUCCEEDED, RunTimeVerifierData.AllocationsSucceeded) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ALLOCATIONSSUCCEEDEDSPECIALPOOL, RunTimeVerifierData.AllocationsSucceededSpecialPool) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ALLOCATIONSWITHNOTAG, RunTimeVerifierData.AllocationsWithNoTag) ) ||
|
|
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ALLOCATIONSFAILED, RunTimeVerifierData.AllocationsFailed) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_ALLOCATIONSFAILEDDELIBERATELY, RunTimeVerifierData.AllocationsFailedDeliberately) ) ||
|
|
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_TRIMS, RunTimeVerifierData.Trims) ) ||
|
|
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_UNTRACKEDPOOL, RunTimeVerifierData.UnTrackedPool) ) )
|
|
{
|
|
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// per driver counters
|
|
//
|
|
|
|
if( ! VrfOuputStringFromResources(
|
|
IDS_THE_VERIFIED_DRIVERS,
|
|
file ) )
|
|
{
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
for( nCrtDriver = 0; nCrtDriver < nDriversNo; nCrtDriver += 1 )
|
|
{
|
|
VrfFTPrintf(
|
|
file,
|
|
_T( "\n" ) );
|
|
|
|
pRunDriverData = RunTimeVerifierData.m_RuntimeDriverDataArray.GetAt( nCrtDriver ) ;
|
|
|
|
ASSERT_VALID( pRunDriverData );
|
|
|
|
if( VrfFTPrintfResourceFormat(
|
|
file,
|
|
IDS_NAME_LOADS_UNLOADS,
|
|
(LPCTSTR)pRunDriverData->m_strName,
|
|
pRunDriverData->Loads,
|
|
pRunDriverData->Unloads) == FALSE )
|
|
{
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// pool statistics
|
|
//
|
|
|
|
if( ( ! VrfFTPrintfResourceFormat( file, IDS_CURRENTPAGEDPOOLALLOCATIONS, pRunDriverData->CurrentPagedPoolAllocations) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_CURRENTNONPAGEDPOOLALLOCATIONS, pRunDriverData->CurrentNonPagedPoolAllocations) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_PEAKPAGEDPOOLALLOCATIONS, pRunDriverData->PeakPagedPoolAllocations) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_PEAKNONPAGEDPOOLALLOCATIONS, pRunDriverData->PeakNonPagedPoolAllocations) ) ||
|
|
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_PAGEDPOOLUSAGEINBYTES, (ULONG) pRunDriverData->PagedPoolUsageInBytes) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_NONPAGEDPOOLUSAGEINBYTES, (ULONG) pRunDriverData->NonPagedPoolUsageInBytes) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_PEAKPAGEDPOOLUSAGEINBYTES, (ULONG) pRunDriverData->PeakPagedPoolUsageInBytes) ) ||
|
|
( ! VrfFTPrintfResourceFormat( file, IDS_PEAKNONPAGEDPOOLUSAGEINBYTES, (ULONG) pRunDriverData->PeakNonPagedPoolUsageInBytes) ) )
|
|
{
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
}
|
|
|
|
Done:
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL __cdecl VrfFTPrintf( FILE *file,
|
|
LPCTSTR szFormat,
|
|
... )
|
|
{
|
|
TCHAR szMessage[ 256 ];
|
|
BOOL bResult;
|
|
va_list prms;
|
|
|
|
ASSERT( NULL != file );
|
|
ASSERT( g_bCommandLineMode );
|
|
|
|
va_start (prms, szFormat);
|
|
|
|
//
|
|
// Format the message in our local buffer
|
|
//
|
|
|
|
_vsntprintf ( szMessage,
|
|
ARRAY_LENGTH( szMessage ),
|
|
szFormat,
|
|
prms );
|
|
|
|
szMessage[ ARRAY_LENGTH( szMessage ) - 1 ] = 0;
|
|
|
|
bResult = ( _fputts( szMessage, file ) >= 0 );
|
|
|
|
va_end (prms);
|
|
|
|
return bResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL __cdecl VrfFTPrintfResourceFormat( FILE *file,
|
|
UINT uIdResourceFormat,
|
|
... )
|
|
{
|
|
TCHAR szMessage[ 256 ];
|
|
TCHAR strFormat[ 256 ];
|
|
BOOL bResult;
|
|
va_list prms;
|
|
|
|
ASSERT( NULL != file );
|
|
|
|
//
|
|
// Load the format string from the resources
|
|
//
|
|
|
|
bResult = VrfLoadString( uIdResourceFormat,
|
|
strFormat,
|
|
ARRAY_LENGTH( strFormat ) );
|
|
|
|
ASSERT( bResult );
|
|
|
|
if( bResult )
|
|
{
|
|
va_start (prms, uIdResourceFormat);
|
|
|
|
//
|
|
// Format the message in our local buffer
|
|
//
|
|
|
|
_vsntprintf ( szMessage,
|
|
ARRAY_LENGTH( szMessage ),
|
|
strFormat,
|
|
prms);
|
|
|
|
szMessage[ ARRAY_LENGTH( szMessage ) - 1 ] = (TCHAR)0;
|
|
|
|
bResult = ( _fputts( szMessage, file ) >= 0 );
|
|
|
|
va_end (prms);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfOuputStringFromResources( UINT uIdString,
|
|
FILE *file )
|
|
{
|
|
TCHAR szText[ 256 ];
|
|
BOOL bResult;
|
|
|
|
ASSERT( NULL != file );
|
|
|
|
bResult = VrfLoadString( uIdString,
|
|
szText,
|
|
ARRAY_LENGTH( szText ) );
|
|
|
|
if( FALSE == bResult )
|
|
{
|
|
goto Done;
|
|
}
|
|
|
|
bResult = ( _fputts( szText, file ) >= 0 );
|
|
|
|
Done:
|
|
|
|
return bResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfSetNewFlagsVolatile( DWORD dwNewFlags )
|
|
{
|
|
BOOL bResult;
|
|
NTSTATUS Status;
|
|
INT_PTR nCurrentlyVerifiedDrivers;
|
|
CRuntimeVerifierData RunTimeVerifierData;
|
|
|
|
bResult = TRUE;
|
|
|
|
nCurrentlyVerifiedDrivers = 0;
|
|
|
|
if( VrfGetRuntimeVerifierData( &RunTimeVerifierData ) == FALSE )
|
|
{
|
|
//
|
|
// Cannot get current verifier settings
|
|
//
|
|
|
|
VrfErrorResourceFormat( IDS_CANTGET_VERIF_STATE );
|
|
|
|
bResult = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
nCurrentlyVerifiedDrivers = RunTimeVerifierData.m_RuntimeDriverDataArray.GetSize();
|
|
|
|
if( nCurrentlyVerifiedDrivers > 0 )
|
|
{
|
|
//
|
|
// There are some drivers currently verified
|
|
//
|
|
|
|
if( RunTimeVerifierData.Level != dwNewFlags )
|
|
{
|
|
//
|
|
// Just use NtSetSystemInformation to set the flags
|
|
// that can be modified on the fly. Don't write anything to the registry.
|
|
//
|
|
|
|
//
|
|
// Enable debug privilege
|
|
//
|
|
|
|
if( g_bPrivilegeEnabled != TRUE )
|
|
{
|
|
g_bPrivilegeEnabled = VrfEnableDebugPrivilege();
|
|
|
|
if( g_bPrivilegeEnabled != TRUE )
|
|
{
|
|
bResult = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the new flags
|
|
//
|
|
|
|
Status = NtSetSystemInformation(
|
|
SystemVerifierInformation,
|
|
&dwNewFlags,
|
|
sizeof( dwNewFlags ) );
|
|
|
|
if( ! NT_SUCCESS( Status ) )
|
|
{
|
|
if( Status == STATUS_ACCESS_DENIED )
|
|
{
|
|
//
|
|
// Access denied
|
|
//
|
|
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Some other error
|
|
//
|
|
|
|
VrfErrorResourceFormat(
|
|
IDS_CANNOT_CHANGE_SETTING_ON_FLY );
|
|
}
|
|
|
|
bResult = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
}
|
|
|
|
Done:
|
|
|
|
if( g_bCommandLineMode )
|
|
{
|
|
VrfDumpChangedSettings( RunTimeVerifierData.Level,
|
|
dwNewFlags,
|
|
nCurrentlyVerifiedDrivers );
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfAddDriversVolatile( const CStringArray &astrNewDrivers )
|
|
{
|
|
BOOL bSuccess;
|
|
INT_PTR nDrivers;
|
|
INT_PTR nCrtDriver;
|
|
CString strCrtDriver;
|
|
|
|
bSuccess = TRUE;
|
|
|
|
nDrivers = astrNewDrivers.GetSize();
|
|
|
|
for( nCrtDriver = 0; nCrtDriver < nDrivers; nCrtDriver += 1 )
|
|
{
|
|
strCrtDriver = astrNewDrivers.GetAt( nCrtDriver );
|
|
|
|
if( TRUE != VrfAddDriverVolatile( strCrtDriver ) )
|
|
{
|
|
bSuccess = FALSE;
|
|
}
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfAddDriverVolatile( const CString &strCrtDriver )
|
|
{
|
|
NTSTATUS Status;
|
|
UINT uIdErrorString;
|
|
BOOL bSuccess;
|
|
UNICODE_STRING usDriverName;
|
|
#ifndef UNICODE
|
|
|
|
WCHAR *szUnicodeName = NULL;
|
|
INT_PTR nNameLength;
|
|
|
|
#endif //#ifndef UNICODE
|
|
|
|
|
|
bSuccess = TRUE;
|
|
|
|
//
|
|
// Enable debug privilege
|
|
//
|
|
|
|
if( g_bPrivilegeEnabled != TRUE )
|
|
{
|
|
g_bPrivilegeEnabled = VrfEnableDebugPrivilege();
|
|
|
|
if( g_bPrivilegeEnabled != TRUE )
|
|
{
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Must have driver name as a UNICODE_STRING
|
|
//
|
|
|
|
#ifdef UNICODE
|
|
|
|
//
|
|
// UNICODE
|
|
//
|
|
|
|
RtlInitUnicodeString(
|
|
&usDriverName,
|
|
(LPCTSTR) strCrtDriver );
|
|
|
|
#else
|
|
//
|
|
// ANSI
|
|
//
|
|
|
|
nNameLength = strCrtDriver.GetLength();
|
|
|
|
szUnicodeName = new WCHAR[ nNameLength + 1 ];
|
|
|
|
if( NULL == szUnicodeName )
|
|
{
|
|
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
|
|
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
MultiByteToWideChar( CP_ACP,
|
|
0,
|
|
(LPCSTR) strCrtDriver,
|
|
-1,
|
|
szUnicodeName,
|
|
nNameLength + 1 );
|
|
|
|
RtlInitUnicodeString(
|
|
&usDriverName,
|
|
szUnicodeName );
|
|
|
|
#endif //#ifdef UNICODE
|
|
|
|
Status = NtSetSystemInformation(
|
|
SystemVerifierAddDriverInformation,
|
|
&usDriverName,
|
|
sizeof( UNICODE_STRING ) );
|
|
|
|
if( ! NT_SUCCESS( Status ) )
|
|
{
|
|
switch( Status )
|
|
{
|
|
case STATUS_INVALID_INFO_CLASS:
|
|
uIdErrorString = IDS_VERIFIER_ADD_NOT_SUPPORTED;
|
|
break;
|
|
|
|
case STATUS_NOT_SUPPORTED:
|
|
uIdErrorString = IDS_DYN_ADD_NOT_SUPPORTED;
|
|
break;
|
|
|
|
case STATUS_IMAGE_ALREADY_LOADED:
|
|
uIdErrorString = IDS_DYN_ADD_ALREADY_LOADED;
|
|
break;
|
|
|
|
case STATUS_INSUFFICIENT_RESOURCES:
|
|
case STATUS_NO_MEMORY:
|
|
uIdErrorString = IDS_DYN_ADD_INSUF_RESOURCES;
|
|
break;
|
|
|
|
case STATUS_PRIVILEGE_NOT_HELD:
|
|
uIdErrorString = IDS_DYN_ADD_ACCESS_DENIED;
|
|
break;
|
|
|
|
default:
|
|
VrfErrorResourceFormat(
|
|
IDS_DYN_ADD_MISC_ERROR,
|
|
(LPCTSTR) strCrtDriver,
|
|
Status );
|
|
|
|
bSuccess = FALSE;
|
|
}
|
|
|
|
VrfErrorResourceFormat(
|
|
uIdErrorString,
|
|
(LPCTSTR) strCrtDriver );
|
|
|
|
bSuccess = FALSE;
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
|
|
if( NULL != szUnicodeName )
|
|
{
|
|
delete [] szUnicodeName;
|
|
}
|
|
|
|
#endif //#ifndef UNICODE
|
|
|
|
Done:
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfRemoveDriversVolatile( const CStringArray &astrNewDrivers )
|
|
{
|
|
INT_PTR nDrivers;
|
|
INT_PTR nCrtDriver;
|
|
BOOL bSuccess;
|
|
CString strCrtDriver;
|
|
|
|
bSuccess = TRUE;
|
|
|
|
nDrivers = astrNewDrivers.GetSize();
|
|
|
|
for( nCrtDriver = 0; nCrtDriver < nDrivers; nCrtDriver += 1 )
|
|
{
|
|
strCrtDriver = astrNewDrivers.GetAt( nCrtDriver );
|
|
|
|
if( TRUE != VrfRemoveDriverVolatile( strCrtDriver ) )
|
|
{
|
|
bSuccess = FALSE;
|
|
}
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfRemoveDriverVolatile( const CString &strDriverName )
|
|
{
|
|
NTSTATUS Status;
|
|
UINT uIdErrorString;
|
|
BOOL bSuccess;
|
|
UNICODE_STRING usDriverName;
|
|
#ifndef UNICODE
|
|
|
|
WCHAR *szUnicodeName = NULL;
|
|
INT_PTR nNameLength;
|
|
|
|
#endif //#ifndef UNICODE
|
|
|
|
bSuccess = TRUE;
|
|
|
|
//
|
|
// Enable debug privilege
|
|
//
|
|
|
|
if( g_bPrivilegeEnabled != TRUE )
|
|
{
|
|
g_bPrivilegeEnabled = VrfEnableDebugPrivilege();
|
|
|
|
if( g_bPrivilegeEnabled != TRUE )
|
|
{
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Must have driver name as a UNICODE_STRING
|
|
//
|
|
|
|
#ifdef UNICODE
|
|
|
|
//
|
|
// UNICODE
|
|
//
|
|
|
|
RtlInitUnicodeString(
|
|
&usDriverName,
|
|
(LPCTSTR) strDriverName );
|
|
|
|
#else
|
|
//
|
|
// ANSI
|
|
//
|
|
|
|
nNameLength = strDriverName.GetLength();
|
|
|
|
szUnicodeName = new WCHAR[ nNameLength + 1 ];
|
|
|
|
if( NULL == szUnicodeName )
|
|
{
|
|
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
|
|
|
|
bSuccess = FALSE;
|
|
|
|
goto Done;
|
|
}
|
|
|
|
MultiByteToWideChar( CP_ACP,
|
|
0,
|
|
(LPCSTR) strDriverName,
|
|
-1,
|
|
szUnicodeName,
|
|
nNameLength + 1 );
|
|
|
|
RtlInitUnicodeString(
|
|
&usDriverName,
|
|
szUnicodeName );
|
|
|
|
#endif //#ifdef UNICODE
|
|
|
|
Status = NtSetSystemInformation(
|
|
SystemVerifierRemoveDriverInformation,
|
|
&usDriverName,
|
|
sizeof( UNICODE_STRING ) );
|
|
|
|
if( ! NT_SUCCESS( Status ) )
|
|
{
|
|
switch( Status )
|
|
{
|
|
case STATUS_INVALID_INFO_CLASS:
|
|
uIdErrorString = IDS_VERIFIER_REMOVE_NOT_SUPPORTED;
|
|
break;
|
|
|
|
case STATUS_NOT_SUPPORTED:
|
|
//
|
|
// the driver verifier is not currently active at all -> success
|
|
//
|
|
|
|
case STATUS_NOT_FOUND:
|
|
//
|
|
// the driver is not currently verified -> success
|
|
//
|
|
|
|
return TRUE;
|
|
|
|
case STATUS_IMAGE_ALREADY_LOADED:
|
|
uIdErrorString = IDS_DYN_REMOVE_ALREADY_LOADED;
|
|
break;
|
|
|
|
case STATUS_INSUFFICIENT_RESOURCES:
|
|
case STATUS_NO_MEMORY:
|
|
uIdErrorString = IDS_DYN_REMOVE_INSUF_RESOURCES;
|
|
break;
|
|
|
|
case STATUS_PRIVILEGE_NOT_HELD:
|
|
uIdErrorString = IDS_DYN_REMOVE_ACCESS_DENIED;
|
|
break;
|
|
|
|
default:
|
|
VrfErrorResourceFormat(
|
|
IDS_DYN_REMOVE_MISC_ERROR,
|
|
(LPCTSTR) strDriverName,
|
|
Status );
|
|
|
|
bSuccess = FALSE;
|
|
}
|
|
|
|
VrfErrorResourceFormat(
|
|
uIdErrorString,
|
|
(LPCTSTR) strDriverName );
|
|
|
|
bSuccess = FALSE;
|
|
}
|
|
|
|
Done:
|
|
|
|
#ifndef UNICODE
|
|
|
|
if( NULL != szUnicodeName )
|
|
{
|
|
delete [] szUnicodeName;
|
|
}
|
|
|
|
#endif //#ifndef UNICODE
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
BOOL VrfEnableDebugPrivilege( )
|
|
{
|
|
struct
|
|
{
|
|
DWORD Count;
|
|
LUID_AND_ATTRIBUTES Privilege [1];
|
|
|
|
} Info;
|
|
|
|
HANDLE Token;
|
|
BOOL Result;
|
|
|
|
//
|
|
// Open the process token
|
|
//
|
|
|
|
Result = OpenProcessToken (
|
|
GetCurrentProcess (),
|
|
TOKEN_ADJUST_PRIVILEGES,
|
|
& Token);
|
|
|
|
if( Result != TRUE )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Prepare the info structure
|
|
//
|
|
|
|
Info.Count = 1;
|
|
Info.Privilege[0].Attributes = SE_PRIVILEGE_ENABLED;
|
|
|
|
Result = LookupPrivilegeValue (
|
|
NULL,
|
|
SE_DEBUG_NAME,
|
|
&(Info.Privilege[0].Luid));
|
|
|
|
if( Result != TRUE )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
|
|
CloseHandle( Token );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Adjust the privileges
|
|
//
|
|
|
|
Result = AdjustTokenPrivileges (
|
|
Token,
|
|
FALSE,
|
|
(PTOKEN_PRIVILEGES) &Info,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
|
|
if( Result != TRUE || GetLastError() != ERROR_SUCCESS )
|
|
{
|
|
VrfErrorResourceFormat(
|
|
IDS_ACCESS_IS_DENIED );
|
|
|
|
CloseHandle( Token );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle( Token );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
VOID VrfDumpChangedSettings( UINT OldFlags,
|
|
UINT NewFlags,
|
|
INT_PTR nDriversVerified )
|
|
{
|
|
UINT uDifferentFlags;
|
|
|
|
if( nDriversVerified == 0 )
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_NO_DRIVER_VERIFIED );
|
|
|
|
goto Done;
|
|
}
|
|
|
|
if( OldFlags == NewFlags )
|
|
{
|
|
//
|
|
// no settings were changed
|
|
//
|
|
|
|
VrfPrintStringFromResources(
|
|
IDS_NO_SETTINGS_WERE_CHANGED );
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_CHANGED_SETTINGS_ARE );
|
|
|
|
uDifferentFlags = OldFlags ^ NewFlags;
|
|
|
|
//
|
|
// changed DRIVER_VERIFIER_SPECIAL_POOLING ?
|
|
//
|
|
|
|
if( uDifferentFlags & DRIVER_VERIFIER_SPECIAL_POOLING )
|
|
{
|
|
if( NewFlags & DRIVER_VERIFIER_SPECIAL_POOLING )
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_SPECIAL_POOL_ENABLED_NOW );
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_SPECIAL_POOL_DISABLED_NOW );
|
|
}
|
|
}
|
|
|
|
//
|
|
// changed DRIVER_VERIFIER_FORCE_IRQL_CHECKING ?
|
|
//
|
|
|
|
if( uDifferentFlags & DRIVER_VERIFIER_FORCE_IRQL_CHECKING )
|
|
{
|
|
if( NewFlags & DRIVER_VERIFIER_FORCE_IRQL_CHECKING )
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_FORCE_IRQLCHECK_ENABLED_NOW );
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_FORCE_IRQLCHECK_DISABLED_NOW );
|
|
}
|
|
}
|
|
|
|
//
|
|
// changed DRIVER_VERIFIER_INJECT_ALLOCATION_FAILURES ?
|
|
//
|
|
|
|
if( uDifferentFlags & DRIVER_VERIFIER_INJECT_ALLOCATION_FAILURES )
|
|
{
|
|
if( NewFlags & DRIVER_VERIFIER_INJECT_ALLOCATION_FAILURES )
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_FAULT_INJECTION_ENABLED_NOW );
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_FAULT_INJECTION_DISABLED_NOW );
|
|
}
|
|
}
|
|
|
|
//
|
|
// changed DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS ?
|
|
//
|
|
|
|
if( uDifferentFlags & DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS )
|
|
{
|
|
if( NewFlags & DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS )
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_POOL_TRACK_ENABLED_NOW );
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_POOL_TRACK_DISABLED_NOW );
|
|
}
|
|
}
|
|
|
|
//
|
|
// changed DRIVER_VERIFIER_IO_CHECKING ?
|
|
//
|
|
|
|
if( uDifferentFlags & DRIVER_VERIFIER_IO_CHECKING )
|
|
{
|
|
if( NewFlags & DRIVER_VERIFIER_IO_CHECKING )
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_IO_CHECKING_ENABLED_NOW );
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources(
|
|
IDS_IO_CHECKING_DISABLED_NOW );
|
|
}
|
|
}
|
|
|
|
//
|
|
// the changes are not saved to the registry
|
|
//
|
|
|
|
VrfPrintStringFromResources(
|
|
IDS_CHANGES_ACTIVE_ONLY_BEFORE_REBOOT );
|
|
}
|
|
|
|
Done:
|
|
|
|
NOTHING;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD VrfGetStandardFlags()
|
|
{
|
|
DWORD dwStandardFlags;
|
|
|
|
dwStandardFlags = DRIVER_VERIFIER_SPECIAL_POOLING |
|
|
DRIVER_VERIFIER_FORCE_IRQL_CHECKING |
|
|
DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS |
|
|
DRIVER_VERIFIER_IO_CHECKING |
|
|
DRIVER_VERIFIER_DEADLOCK_DETECTION |
|
|
DRIVER_VERIFIER_DMA_VERIFIER;
|
|
|
|
return dwStandardFlags;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID VrfAddMiniports( CStringArray &astrVerifiedDrivers )
|
|
{
|
|
CStringArray astrToAdd;
|
|
CString strCrtDriver;
|
|
CString strCrtDriverToAdd;
|
|
CString strLinkedDriver;
|
|
INT_PTR nVerifiedDrivers;
|
|
INT_PTR nCrtDriver;
|
|
INT_PTR nDriversToAdd;
|
|
INT_PTR nCrtDriverToAdd;
|
|
|
|
nVerifiedDrivers = astrVerifiedDrivers.GetSize();
|
|
|
|
for( nCrtDriver = 0; nCrtDriver < nVerifiedDrivers; nCrtDriver += 1 )
|
|
{
|
|
//
|
|
// This will be a verified driver
|
|
//
|
|
|
|
strCrtDriver = astrVerifiedDrivers.GetAt( nCrtDriver );
|
|
|
|
//
|
|
// Check if it is a miniport driver
|
|
//
|
|
|
|
if( VrfIsDriverMiniport( strCrtDriver,
|
|
strLinkedDriver ) )
|
|
{
|
|
//
|
|
// Check if we didn't add already strLinkedDriver
|
|
//
|
|
|
|
nDriversToAdd = astrToAdd.GetSize();
|
|
|
|
for( nCrtDriverToAdd = 0; nCrtDriverToAdd < nDriversToAdd; nCrtDriverToAdd += 1 )
|
|
{
|
|
strCrtDriverToAdd = astrToAdd.GetAt( nCrtDriverToAdd );
|
|
|
|
if( strCrtDriverToAdd.CompareNoCase( strLinkedDriver ) == 0 )
|
|
{
|
|
//
|
|
// We already wanted to add this driver
|
|
//
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( nCrtDriverToAdd >= nDriversToAdd )
|
|
{
|
|
//
|
|
// Add this new driver (strLinkedDriver)
|
|
//
|
|
|
|
astrToAdd.Add( strLinkedDriver );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Flush astrToAdd into astrVerifiedDrivers
|
|
//
|
|
|
|
nDriversToAdd = astrToAdd.GetSize();
|
|
|
|
for( nCrtDriverToAdd = 0; nCrtDriverToAdd < nDriversToAdd; nCrtDriverToAdd += 1 )
|
|
{
|
|
strCrtDriverToAdd = astrToAdd.GetAt( nCrtDriverToAdd );
|
|
|
|
astrVerifiedDrivers.Add( strCrtDriverToAdd );
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfIsDriverMiniport( CString &strCrtDriver,
|
|
CString &strLinkedDriver )
|
|
{
|
|
//
|
|
// N.B.
|
|
//
|
|
// The imagehlp functions are not multithreading safe
|
|
// (see Whistler bug #88373) so if we want to use them from more than
|
|
// one thread we will have to aquire some critical section before.
|
|
//
|
|
// Currently only one thread is using the imagehlp APIs in this app
|
|
// (CSlowProgressDlg::LoadDriverDataWorkerThread) so we don't need
|
|
// our synchronization.
|
|
//
|
|
|
|
LPTSTR szDriverName;
|
|
LPTSTR szDriversDir;
|
|
PLOADED_IMAGE pLoadedImage;
|
|
BOOL bIsMiniport;
|
|
BOOL bUnloaded;
|
|
|
|
bIsMiniport = FALSE;
|
|
|
|
ASSERT( strCrtDriver.GetLength() > 0 );
|
|
|
|
//
|
|
// ImageLoad doesn't know about const pointers so
|
|
// we have to GetBuffer here :-(
|
|
//
|
|
|
|
szDriverName = strCrtDriver.GetBuffer( strCrtDriver.GetLength() + 1 );
|
|
|
|
if( NULL == szDriverName )
|
|
{
|
|
goto Done;
|
|
}
|
|
|
|
szDriversDir = g_strDriversDir.GetBuffer( g_strDriversDir.GetLength() + 1 );
|
|
|
|
if( NULL == szDriversDir )
|
|
{
|
|
strCrtDriver.ReleaseBuffer();
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Load the image
|
|
//
|
|
|
|
pLoadedImage = VrfImageLoad( szDriverName,
|
|
szDriversDir );
|
|
|
|
if( NULL == pLoadedImage )
|
|
{
|
|
//
|
|
// Could not load the image from %windir%\system32\drivers
|
|
// Try again from the PATH
|
|
//
|
|
|
|
pLoadedImage = VrfImageLoad( szDriverName,
|
|
NULL );
|
|
}
|
|
|
|
//
|
|
// Give our string buffers back to MFC
|
|
//
|
|
|
|
strCrtDriver.ReleaseBuffer();
|
|
g_strDriversDir.ReleaseBuffer();
|
|
|
|
if( NULL == pLoadedImage )
|
|
{
|
|
//
|
|
// We couldn't load this image - bad luck
|
|
//
|
|
|
|
TRACE( _T( "ImageLoad failed for %s, error %u\n" ),
|
|
(LPCTSTR) strCrtDriver,
|
|
GetLastError() );
|
|
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Check if the current driver is a miniport
|
|
//
|
|
|
|
bIsMiniport = VrfIsDriverMiniport( pLoadedImage,
|
|
strLinkedDriver );
|
|
|
|
//
|
|
// Clean-up
|
|
//
|
|
|
|
bUnloaded = ImageUnload( pLoadedImage );
|
|
|
|
//
|
|
// If ImageUnload fails we cannot do much about it...
|
|
//
|
|
|
|
ASSERT( bUnloaded );
|
|
|
|
Done:
|
|
|
|
return bIsMiniport;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
LPSTR g_szSpecialDrivers[] =
|
|
{
|
|
"videoprt.sys",
|
|
"scsiport.sys"
|
|
};
|
|
|
|
BOOL VrfpLookForAllImportDescriptors( PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor,
|
|
ULONG_PTR uVACorrection,
|
|
CString &strLinkedAgainst )
|
|
{
|
|
PIMAGE_IMPORT_DESCRIPTOR pCurrentDescriptor;
|
|
PCHAR pCrtName;
|
|
ULONG uCrtSpecialDriver;
|
|
BOOL bIsMiniport;
|
|
#ifdef UNICODE
|
|
//
|
|
// UNICODE
|
|
//
|
|
|
|
INT nCrtStringLength;
|
|
PWSTR szMiniportName;
|
|
|
|
#endif //#ifdef UNICODE
|
|
|
|
bIsMiniport = FALSE;
|
|
|
|
for( uCrtSpecialDriver = 0; ! bIsMiniport && uCrtSpecialDriver < ARRAY_LENGTH( g_szSpecialDrivers ); uCrtSpecialDriver += 1 )
|
|
{
|
|
pCurrentDescriptor = pImportDescriptor;
|
|
|
|
while( pCurrentDescriptor->Characteristics != NULL )
|
|
{
|
|
pCrtName = (PCHAR)UlongToPtr( pCurrentDescriptor->Name ) + uVACorrection;
|
|
|
|
if( lstrcmpiA( g_szSpecialDrivers[ uCrtSpecialDriver ] , pCrtName ) == 0 )
|
|
{
|
|
//
|
|
// This is a miniport
|
|
//
|
|
|
|
#ifndef UNICODE
|
|
|
|
//
|
|
// ANSI
|
|
//
|
|
|
|
strLinkedAgainst = g_szSpecialDrivers[ uCrtSpecialDriver ];
|
|
|
|
#else
|
|
//
|
|
// UNICODE
|
|
//
|
|
|
|
nCrtStringLength = strlen( g_szSpecialDrivers[ uCrtSpecialDriver ] );
|
|
|
|
szMiniportName = strLinkedAgainst.GetBuffer( nCrtStringLength + 1 );
|
|
|
|
if( NULL != szMiniportName )
|
|
{
|
|
MultiByteToWideChar( CP_ACP,
|
|
0,
|
|
g_szSpecialDrivers[ uCrtSpecialDriver ],
|
|
-1,
|
|
szMiniportName,
|
|
( nCrtStringLength + 1 ) * sizeof( TCHAR ) );
|
|
|
|
strLinkedAgainst.ReleaseBuffer();
|
|
}
|
|
#endif
|
|
|
|
bIsMiniport = TRUE;
|
|
|
|
break;
|
|
}
|
|
|
|
pCurrentDescriptor += 1;
|
|
}
|
|
}
|
|
|
|
return bIsMiniport;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfIsDriverMiniport( PLOADED_IMAGE pLoadedImage,
|
|
CString &strLinkedDriver )
|
|
{
|
|
PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor;
|
|
PIMAGE_SECTION_HEADER pSectionHeader;
|
|
ULONG_PTR uVACorrection;
|
|
ULONG uDataSize;
|
|
BOOL bIsMiniport;
|
|
|
|
bIsMiniport = FALSE;
|
|
|
|
//
|
|
// We are protecting ourselves against corrupted binaries
|
|
// with this exception handler
|
|
//
|
|
|
|
try
|
|
{
|
|
pSectionHeader = NULL;
|
|
|
|
pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)ImageDirectoryEntryToDataEx(
|
|
pLoadedImage->MappedAddress,
|
|
FALSE,
|
|
IMAGE_DIRECTORY_ENTRY_IMPORT,
|
|
&uDataSize,
|
|
&pSectionHeader );
|
|
|
|
if( NULL == pSectionHeader )
|
|
{
|
|
goto Done;
|
|
}
|
|
|
|
uVACorrection = (ULONG_PTR) pLoadedImage->MappedAddress +
|
|
pSectionHeader->PointerToRawData -
|
|
pSectionHeader->VirtualAddress;
|
|
|
|
bIsMiniport = VrfpLookForAllImportDescriptors( pImportDescriptor,
|
|
uVACorrection,
|
|
strLinkedDriver );
|
|
#ifdef _DEBUG
|
|
if( bIsMiniport )
|
|
{
|
|
TRACE( _T( "%s will be auto-enabled\n" ),
|
|
(LPCTSTR) strLinkedDriver );
|
|
}
|
|
#endif //#ifdef DEBUG
|
|
}
|
|
catch( ... )
|
|
{
|
|
TRACE( _T( "VrfIsDriverMiniport: Caught exception\n" ) );
|
|
}
|
|
|
|
Done:
|
|
|
|
return bIsMiniport;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID VrfpDumpSettingToConsole( ULONG uIdResourceString,
|
|
BOOL bEnabled )
|
|
{
|
|
CString strTitle;
|
|
CString strEnabled;
|
|
ULONG uIdEnabledString;
|
|
TCHAR szBigBuffer[ 128 ];
|
|
|
|
VERIFY( VrfLoadString( uIdResourceString, strTitle ) );
|
|
|
|
if( FALSE == bEnabled )
|
|
{
|
|
uIdEnabledString = IDS_DISABLED;
|
|
}
|
|
else
|
|
{
|
|
uIdEnabledString = IDS_ENABLED;
|
|
}
|
|
|
|
VERIFY( VrfLoadString( uIdEnabledString, strEnabled ) );
|
|
|
|
_sntprintf( szBigBuffer,
|
|
ARRAY_LENGTH( szBigBuffer ),
|
|
_T( "%s: %s" ),
|
|
(LPCTSTR) strTitle,
|
|
(LPCTSTR) strEnabled );
|
|
|
|
szBigBuffer[ ARRAY_LENGTH( szBigBuffer ) - 1 ] = 0;
|
|
|
|
_putts( szBigBuffer );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID VrfDumpRegistrySettingsToConsole()
|
|
{
|
|
BOOL bLoaded;
|
|
BOOL bAllDriversVerified;
|
|
BOOL bDiskVerifierEnabled;
|
|
DWORD dwVerifyFlags;
|
|
INT_PTR nDrivers;
|
|
INT_PTR nCrtDriver;
|
|
CDiskData *pOldDiskData;
|
|
CString strCrtDriver;
|
|
CStringArray astrDriversToVerify;
|
|
|
|
bLoaded = VrtLoadCurrentRegistrySettings( bAllDriversVerified,
|
|
astrDriversToVerify,
|
|
dwVerifyFlags );
|
|
|
|
if( FALSE != bLoaded )
|
|
{
|
|
VrfpDumpSettingToConsole( IDS_SPECIAL_POOL, ( dwVerifyFlags & DRIVER_VERIFIER_SPECIAL_POOLING ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_FORCE_IRQL_CHECKING, ( dwVerifyFlags & DRIVER_VERIFIER_FORCE_IRQL_CHECKING ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_LOW_RESOURCE_SIMULATION, ( dwVerifyFlags & DRIVER_VERIFIER_INJECT_ALLOCATION_FAILURES ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_POOL_TRACKING, ( dwVerifyFlags & DRIVER_VERIFIER_TRACK_POOL_ALLOCATIONS ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_IO_VERIFICATION, ( dwVerifyFlags & DRIVER_VERIFIER_IO_CHECKING ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_DEADLOCK_DETECTION, ( dwVerifyFlags & DRIVER_VERIFIER_DEADLOCK_DETECTION ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_ENH_IO_VERIFICATION, ( dwVerifyFlags & DRIVER_VERIFIER_ENHANCED_IO_CHECKING ) != 0 );
|
|
VrfpDumpSettingToConsole( IDS_DMA_CHECHKING, ( dwVerifyFlags & DRIVER_VERIFIER_DMA_VERIFIER ) != 0 );
|
|
|
|
bDiskVerifierEnabled = g_OldDiskData.VerifyAnyDisk();
|
|
|
|
VrfpDumpSettingToConsole( IDS_DISK_INTEGRITY_CHECKING, bDiskVerifierEnabled );
|
|
|
|
//
|
|
// List of verified drivers.
|
|
//
|
|
|
|
VrfPrintStringFromResources( IDS_VERIFIED_DRIVERS );
|
|
|
|
if( FALSE != bAllDriversVerified )
|
|
{
|
|
VrfPrintStringFromResources( IDS_ALL );
|
|
}
|
|
else
|
|
{
|
|
nDrivers = astrDriversToVerify.GetSize();
|
|
|
|
if( nDrivers > 0 )
|
|
{
|
|
for( nCrtDriver = 0; nCrtDriver < nDrivers; nCrtDriver += 1 )
|
|
{
|
|
strCrtDriver = astrDriversToVerify.GetAt( nCrtDriver );
|
|
|
|
_putts( (LPCTSTR) strCrtDriver );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VrfPrintStringFromResources( IDS_NONE );
|
|
}
|
|
}
|
|
|
|
if( FALSE != bDiskVerifierEnabled )
|
|
{
|
|
//
|
|
// List of verified disks.
|
|
//
|
|
|
|
VrfPrintStringFromResources( IDS_VERIFIED_DISKS );
|
|
|
|
nDrivers = g_OldDiskData.GetSize();
|
|
|
|
for( nCrtDriver = 0; nCrtDriver < nDrivers; nCrtDriver += 1 )
|
|
{
|
|
pOldDiskData = g_OldDiskData.GetAt( nCrtDriver );
|
|
ASSERT_VALID( pOldDiskData );
|
|
|
|
if( FALSE != pOldDiskData->m_bVerifierEnabled )
|
|
{
|
|
_putts( (LPCTSTR) pOldDiskData->m_strDiskDevicesForDisplay );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfIsNameAlreadyInList( LPCTSTR szDriver,
|
|
LPCTSTR szAllDrivers )
|
|
{
|
|
INT nNameLength;
|
|
INT nLastIndex;
|
|
INT nIndex;
|
|
BOOL bFoundIt;
|
|
CString strDriver( szDriver );
|
|
CString strAllDrivers( szAllDrivers );
|
|
|
|
bFoundIt = FALSE;
|
|
|
|
strDriver.MakeLower();
|
|
strAllDrivers.MakeLower();
|
|
|
|
nNameLength = strDriver.GetLength();
|
|
|
|
nLastIndex = 0;
|
|
|
|
do
|
|
{
|
|
nIndex = strAllDrivers.Find( (LPCTSTR)strDriver, nLastIndex );
|
|
|
|
if( nIndex >= 0 )
|
|
{
|
|
//
|
|
// Found the substring. Verify it is separated of spaces, etc.
|
|
//
|
|
|
|
if( (nIndex == 0 || _T( ' ' ) == strAllDrivers[ nIndex - 1 ]) &&
|
|
( (TCHAR)0 == strAllDrivers[ nNameLength + nIndex ] || _T( ' ' ) == strAllDrivers[ nNameLength + nIndex ]) )
|
|
{
|
|
//
|
|
// This is our driver.
|
|
//
|
|
|
|
bFoundIt = TRUE;
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Continue searching.
|
|
//
|
|
|
|
nLastIndex = nIndex + 1;
|
|
}
|
|
}
|
|
}
|
|
while( nIndex >= 0 );
|
|
|
|
return bFoundIt;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID VrfAddDriverNameNoDuplicates( LPCTSTR szDriver,
|
|
CString &strAllDrivers )
|
|
{
|
|
if( FALSE == VrfIsNameAlreadyInList( szDriver,
|
|
strAllDrivers ) )
|
|
{
|
|
if( strAllDrivers.GetLength() > 0 )
|
|
{
|
|
strAllDrivers += _T( ' ' );
|
|
}
|
|
|
|
strAllDrivers += szDriver;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL VrfIsStringInArray( LPCTSTR szText,
|
|
const CStringArray &astrAllTexts )
|
|
{
|
|
INT_PTR nTexts;
|
|
BOOL bFound;
|
|
|
|
bFound = FALSE;
|
|
|
|
nTexts = astrAllTexts.GetSize();
|
|
|
|
while( nTexts > 0 )
|
|
{
|
|
nTexts -= 1;
|
|
|
|
if( 0 == astrAllTexts.GetAt( nTexts ).CompareNoCase( szText ) )
|
|
{
|
|
bFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return bFound;
|
|
}
|
|
|