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.
1082 lines
36 KiB
1082 lines
36 KiB
//**********************************************************************************
|
|
// Copyright (c) Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// CONNECTWMI.cpp
|
|
//
|
|
// Abstract:
|
|
// Contains functions to connect to wmi.
|
|
//
|
|
// Author:
|
|
// J.S.Vasu
|
|
//
|
|
// Revision History:
|
|
// J.S.Vasu 26-sep-2k : Created It.
|
|
// *********************************************************************************
|
|
|
|
// Include files
|
|
#include "pch.h"
|
|
#include "resource.h"
|
|
#include "driverquery.h"
|
|
|
|
// error constants
|
|
#define E_SERVER_NOTFOUND 0x800706ba
|
|
|
|
// function prototypes
|
|
BOOL IsValidServerEx( LPCWSTR pwszServer,
|
|
BOOL &bLocalSystem );
|
|
|
|
HRESULT GetSecurityArguments( IUnknown *pInterface,
|
|
DWORD& dwAuthorization,
|
|
DWORD& dwAuthentication );
|
|
|
|
HRESULT SetInterfaceSecurity( IUnknown *pInterface,
|
|
LPCWSTR pwszServer,
|
|
LPCWSTR pwszUser,
|
|
LPCWSTR pwszPassword,
|
|
COAUTHIDENTITY **ppAuthIdentity );
|
|
|
|
HRESULT WINAPI SetProxyBlanket( IUnknown *pInterface,
|
|
DWORD dwAuthnSvc,
|
|
DWORD dwAuthzSvc,
|
|
LPWSTR pwszPrincipal,
|
|
DWORD dwAuthLevel,
|
|
DWORD dwImpLevel,
|
|
RPC_AUTH_IDENTITY_HANDLE pAuthInfo,
|
|
DWORD dwCapabilities );
|
|
|
|
HRESULT WINAPI WbemAllocAuthIdentity( LPCWSTR pwszUser,
|
|
LPCWSTR pwszPassword,
|
|
LPCWSTR pwszDomain,
|
|
COAUTHIDENTITY **ppAuthIdent );
|
|
|
|
BOOL ConnectWmi( IWbemLocator *pLocator,
|
|
IWbemServices ** ppServices,
|
|
LPCWSTR pwszServer,
|
|
LPCWSTR pwszUser,
|
|
LPCWSTR pwszPassword,
|
|
COAUTHIDENTITY **ppAuthIdentity,
|
|
BOOL bCheckWithNullPwd = FALSE,
|
|
LPCWSTR pwszNamespace = CIMV2_NAME_SPACE,
|
|
HRESULT *phr = NULL,
|
|
BOOL *pbLocalSystem = NULL );
|
|
|
|
VOID WINAPI WbemFreeAuthIdentity( COAUTHIDENTITY **ppAuthIdentity );
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Checks whether the server name is a valid server name or not.
|
|
//
|
|
// Arguments:
|
|
// pwszServer [in] - Server name to be validated.
|
|
// bLocalSystem [in/out] - Set to TRUE if server specified is local system.
|
|
//
|
|
// Return Value:
|
|
// TRUE if server is valid else FALSE.
|
|
//
|
|
// ***************************************************************************
|
|
BOOL IsValidServerEx( LPCWSTR pwszServer, BOOL &bLocalSystem )
|
|
{
|
|
// local variables
|
|
CHString strTemp;
|
|
|
|
if( pwszServer == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
bLocalSystem = FALSE;
|
|
|
|
// get a local copy
|
|
strTemp = pwszServer;
|
|
|
|
// remove the forward slashes (UNC) if exist in the begining of the server name
|
|
if ( IsUNCFormat( strTemp ) == TRUE )
|
|
{
|
|
strTemp = strTemp.Mid( 2 );
|
|
if ( strTemp.GetLength() == 0 )
|
|
return FALSE;
|
|
}
|
|
|
|
// now check if any '\' character appears in the server name. If so error
|
|
if ( strTemp.Find( L'\\' ) != -1 )
|
|
return FALSE;
|
|
|
|
// now check if server name is '.' only which represent local system in WMI
|
|
// else determine whether this is a local system or not
|
|
bLocalSystem = TRUE;
|
|
if ( strTemp.CompareNoCase( L"." ) != 0 )
|
|
{
|
|
// validate the server
|
|
if ( IsValidServer( strTemp ) == FALSE )
|
|
return FALSE;
|
|
|
|
// check whether this is a local system or not
|
|
bLocalSystem = IsLocalSystem( strTemp );
|
|
}
|
|
|
|
// valid server name
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Connects to wmi.
|
|
//
|
|
// Arguments:
|
|
// pLocator [in] - Pointer to the IWbemLocator object.
|
|
// ppServices [out] - Pointer to IWbemServices object.
|
|
// pwszServer [in] - Holds the server name to connect to.
|
|
// pwszUser [in/out] - Holds the user name.
|
|
// pwszPassword [in/out] - Holds the password.
|
|
// ppAuthIdentity [in/out] - Pointer to authentication structure.
|
|
// bCheckWithNullPwd [in] - Specifies whether to connect through null password.
|
|
// pwszNamespace [in] - Specifies the namespace to connect to.
|
|
// phRes [in/out] - Holds the error value.
|
|
// pbLocalSystem [in/out] - Holds the boolean value to represent whether the server
|
|
// name is local or not.
|
|
// Return Value:
|
|
// TRUE if successfully connected, FALSE if not.
|
|
// ***************************************************************************
|
|
BOOL ConnectWmi( IWbemLocator *pLocator, IWbemServices **ppServices,
|
|
LPCWSTR pwszServer, LPCWSTR pwszUser, LPCWSTR pwszPassword,
|
|
COAUTHIDENTITY **ppAuthIdentity,
|
|
BOOL bCheckWithNullPwd, LPCWSTR pwszNamespace, HRESULT *phRes,
|
|
BOOL *pbLocalSystem )
|
|
{
|
|
// local variables
|
|
HRESULT hRes = 0;
|
|
BOOL bResult = FALSE;
|
|
BOOL bLocalSystem = FALSE;
|
|
_bstr_t bstrServer;
|
|
_bstr_t bstrNamespace;
|
|
_bstr_t bstrUser;
|
|
_bstr_t bstrPassword;
|
|
|
|
if ( pbLocalSystem != NULL )
|
|
{
|
|
*pbLocalSystem = FALSE;
|
|
}
|
|
|
|
if ( phRes != NULL )
|
|
{
|
|
*phRes = NO_ERROR;
|
|
}
|
|
|
|
try
|
|
{
|
|
// clear the error
|
|
SetLastError( WBEM_S_NO_ERROR );
|
|
|
|
// assume that connection to WMI namespace is failed
|
|
bResult = FALSE;
|
|
|
|
// check whether locator object exists or not if not return FALSE
|
|
if ( pLocator == NULL )
|
|
{
|
|
if ( phRes != NULL )
|
|
{
|
|
*phRes = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
// return failure
|
|
return FALSE;
|
|
}
|
|
|
|
// validate the server name
|
|
// NOTE: The error being raised in custom define for '0x800706ba' value
|
|
// The message that will be displayed in "The RPC server is unavailable."
|
|
if ( IsValidServerEx( pwszServer, bLocalSystem ) == FALSE )
|
|
{
|
|
_com_issue_error( ERROR_BAD_NETPATH );
|
|
}
|
|
|
|
// validate the user name
|
|
if ( IsValidUserEx( pwszUser ) == FALSE )
|
|
{
|
|
_com_issue_error( ERROR_NO_SUCH_USER );
|
|
}
|
|
|
|
// prepare namespace
|
|
bstrNamespace = pwszNamespace; // name space
|
|
if ( pwszServer != NULL && bLocalSystem == FALSE )
|
|
{
|
|
// get the server name
|
|
bstrServer = pwszServer;
|
|
|
|
// prepare the namespace
|
|
// NOTE: check for the UNC naming format of the server and do
|
|
if ( IsUNCFormat( pwszServer ) == TRUE )
|
|
{
|
|
bstrNamespace = bstrServer + L"\\" + pwszNamespace;
|
|
}
|
|
else
|
|
{
|
|
bstrNamespace = L"\\\\" + bstrServer + L"\\" + pwszNamespace;
|
|
}
|
|
|
|
// user credentials
|
|
if ( pwszUser != NULL && StringLengthW( pwszUser, 0 ) != 0 )
|
|
{
|
|
// copy the user name
|
|
bstrUser = pwszUser;
|
|
|
|
// if password is empty string and if we need to check with
|
|
// null password, then do not set the password and try
|
|
bstrPassword = pwszPassword;
|
|
if ( bCheckWithNullPwd == TRUE && bstrPassword.length() == 0 )
|
|
{
|
|
bstrPassword = (LPWSTR) NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// release the existing services object ( to be in safer side )
|
|
SAFE_RELEASE( *ppServices );
|
|
|
|
// connect to the remote system's WMI
|
|
// there is a twist here ...
|
|
// do not trap the ConnectServer function failure into exception
|
|
// instead handle that action manually
|
|
// by default try the ConnectServer function as the information which we have
|
|
// in our hands at this point. If the ConnectServer is failed,
|
|
// check whether password variable has any contents are not ... if no contents
|
|
// check with "" (empty) password ... this might pass in this situation ..
|
|
// if this call is also failed ... nothing is there that we can do ... throw the exception
|
|
hRes = pLocator->ConnectServer( bstrNamespace,
|
|
bstrUser, bstrPassword, 0L, 0L, NULL, NULL, ppServices );
|
|
if ( FAILED( hRes ) )
|
|
{
|
|
//
|
|
// special case ...
|
|
|
|
// check whether password exists or not
|
|
// NOTE: do not check for 'WBEM_E_ACCESS_DENIED'
|
|
// this error code says that user with the current credentials is not
|
|
// having access permisions to the 'namespace'
|
|
|
|
if ( hRes == E_ACCESSDENIED )
|
|
{
|
|
// check if we tried to connect to the system using null password
|
|
// if so, then try connecting to the remote system with empty string
|
|
if ( bCheckWithNullPwd == TRUE &&
|
|
bstrUser.length() != 0 && bstrPassword.length() == 0 )
|
|
{
|
|
// now invoke with ...
|
|
hRes = pLocator->ConnectServer( bstrNamespace,
|
|
bstrUser, _bstr_t( L"" ), 0L, 0L, NULL, NULL, ppServices );
|
|
}
|
|
}
|
|
else if ( hRes == WBEM_E_LOCAL_CREDENTIALS )
|
|
{
|
|
// credentials were passed to the local system.
|
|
// So ignore the credentials and try to reconnect
|
|
bLocalSystem = TRUE;
|
|
bstrUser = (LPWSTR) NULL;
|
|
bstrPassword = (LPWSTR) NULL;
|
|
bstrNamespace = pwszNamespace; // name space
|
|
hRes = pLocator->ConnectServer( bstrNamespace,
|
|
NULL, NULL, 0L, 0L, NULL, NULL, ppServices );
|
|
// now check the result again .. if failed
|
|
}
|
|
// now check the result again .. if failed .. ummmm..
|
|
if ( FAILED( hRes ) )
|
|
{
|
|
_com_issue_error( hRes );
|
|
}
|
|
|
|
else
|
|
{
|
|
bstrPassword = L"";
|
|
}
|
|
}
|
|
|
|
// set the security at the interface level also
|
|
SAFE_EXECUTE( SetInterfaceSecurity( *ppServices,
|
|
pwszServer, bstrUser, bstrPassword, ppAuthIdentity ) );
|
|
|
|
// connection to WMI is successful
|
|
bResult = TRUE;
|
|
|
|
// save the hr value if needed by the caller
|
|
if ( phRes != NULL )
|
|
{
|
|
*phRes = WBEM_S_NO_ERROR;
|
|
}
|
|
}
|
|
catch( _com_error& e )
|
|
{
|
|
// save the error
|
|
WMISaveError( e );
|
|
|
|
// save the hr value if needed by the caller
|
|
if ( phRes != NULL )
|
|
{
|
|
*phRes = e.Error();
|
|
}
|
|
}
|
|
|
|
if ( pbLocalSystem != NULL )
|
|
{
|
|
*pbLocalSystem = bLocalSystem;
|
|
}
|
|
|
|
// return the result
|
|
return bResult;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Connects to wmi.
|
|
//
|
|
// Arguments:
|
|
// pLocator [in] - Pointer to the IWbemLocator object.
|
|
// ppServices [out] - Pointer to IWbemServices object.
|
|
// strServer [in] - Holds the server name to connect to.
|
|
// strUserName [in/out] - Holds the user name.
|
|
// strPassword [in/out] - Holds the password.
|
|
// ppAuthIdentity [in/out] - Pointer to authentication structure.
|
|
// bNeedPassword [in] - Specifies whether to prompt for password.
|
|
// pwszNamespace [in] - Specifies the namespace to connect to.
|
|
// pbLocalSystem [in/out] - Holds the boolean value to represent whether the server
|
|
// name is local or not.
|
|
// Return Value:
|
|
// TRUE if successfully connected, FALSE if not.
|
|
// ***************************************************************************
|
|
BOOL ConnectWmiEx( IWbemLocator *pLocator,
|
|
IWbemServices **ppServices,
|
|
const CHString &strServer, CHString &strUserName, CHString &strPassword,
|
|
COAUTHIDENTITY **ppAuthIdentity, BOOL bNeedPassword, LPCWSTR pwszNamespace,
|
|
BOOL* pbLocalSystem )
|
|
{
|
|
// local variables
|
|
HRESULT hRes = 0;
|
|
DWORD dwSize = 0;
|
|
BOOL bResult = FALSE;
|
|
LPWSTR pwszPassword = NULL;
|
|
CHString strBuffer = NULL_STRING;
|
|
__MAX_SIZE_STRING szBuffer = NULL_STRING;
|
|
|
|
|
|
|
|
// clear the error .. if any
|
|
SetLastError( WBEM_S_NO_ERROR );
|
|
|
|
// sometime users want the utility to prompt for the password
|
|
// check what user wants the utility to do
|
|
if ( bNeedPassword == TRUE && strPassword.Compare( L"*" ) == 0 )
|
|
{
|
|
// user wants the utility to prompt for the password
|
|
// so skip this part and let the flow directly jump the password acceptance part
|
|
}
|
|
else
|
|
{
|
|
// try to establish connection to the remote system with the credentials supplied
|
|
if ( strUserName.GetLength() == 0 )
|
|
{
|
|
// user name is empty
|
|
// so, it is obvious that password will also be empty
|
|
// even if password is specified, we have to ignore that
|
|
bResult = ConnectWmi( pLocator, ppServices,
|
|
(LPCWSTR)strServer, NULL, NULL, ppAuthIdentity, FALSE, pwszNamespace, &hRes, pbLocalSystem );
|
|
}
|
|
else
|
|
{
|
|
// credentials were supplied
|
|
// but password might not be specified ... so check and act accordingly
|
|
LPCWSTR pwszTemp = NULL;
|
|
if ( bNeedPassword == FALSE )
|
|
pwszTemp = strPassword;
|
|
|
|
// ...
|
|
bResult = ConnectWmi( pLocator, ppServices, (LPCWSTR)strServer,
|
|
(LPCWSTR)strUserName, pwszTemp, ppAuthIdentity, FALSE, pwszNamespace, &hRes, pbLocalSystem );
|
|
}
|
|
|
|
// check the result ... if successful in establishing connection ... return
|
|
if ( bResult == TRUE )
|
|
return TRUE;
|
|
|
|
// now check the kind of error occurred
|
|
switch( hRes )
|
|
{
|
|
case 0x80040154:
|
|
//the wmi is not registered on remote machine
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowMessage( stderr, GetResString(IDS_ERROR_REMOTE_INCOMPATIBLE));
|
|
return FALSE;
|
|
case E_ACCESSDENIED:
|
|
break;
|
|
|
|
case WBEM_E_LOCAL_CREDENTIALS:
|
|
// needs to do special processing
|
|
break;
|
|
|
|
case WBEM_E_ACCESS_DENIED:
|
|
|
|
|
|
default:
|
|
GetWbemErrorText( hRes );
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowMessage( stderr, GetReason() );
|
|
return( FALSE ); // no use of accepting the password .. return failure
|
|
|
|
|
|
}
|
|
|
|
// if failed in establishing connection to the remote terminal
|
|
// even if the password is specifed, then there is nothing to do ... simply return failure
|
|
if ( bNeedPassword == FALSE )
|
|
{
|
|
GetWbemErrorText( hRes );
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowMessage( stderr, GetReason() );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// check whether user name is specified or not
|
|
// if not, get the local system's current user name under whose credentials, the process
|
|
// is running
|
|
if ( strUserName.GetLength() == 0 )
|
|
{
|
|
// sub-local variables
|
|
LPWSTR pwszUserName = NULL;
|
|
|
|
try
|
|
{
|
|
// get the required buffer
|
|
pwszUserName = strUserName.GetBufferSetLength( MAX_STRING_LENGTH );
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowLastError( stderr );
|
|
return FALSE;
|
|
}
|
|
|
|
// get the user name
|
|
|
|
_TCHAR szUserName[MAX_RES_STRING];
|
|
ULONG ulLong = MAX_RES_STRING;
|
|
if ( GetUserNameEx ( NameSamCompatible, szUserName , &ulLong)== FALSE )
|
|
{
|
|
// error occured while trying to get the current user info
|
|
SaveLastError();
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowLastError( stderr );
|
|
return FALSE;
|
|
}
|
|
|
|
StringCopy(pwszUserName,szUserName, MAX_STRING_LENGTH );
|
|
// format the user name
|
|
if ( _tcschr( pwszUserName, _T( '\\' ) ) == NULL )
|
|
{
|
|
// server not present in user name ... prepare ... this is only for display purpose
|
|
StringCchPrintf( szBuffer, SIZE_OF_ARRAY(szBuffer), _T( "%s\\%s" ), (LPCWSTR)strServer, szUserName );
|
|
StringCopy( pwszUserName, szBuffer, MAX_STRING_LENGTH );
|
|
}
|
|
|
|
// release the extra buffer allocated
|
|
strUserName.ReleaseBuffer();
|
|
}
|
|
|
|
try
|
|
{
|
|
// get the required buffer
|
|
pwszPassword = strPassword.GetBufferSetLength( MAX_STRING_LENGTH );
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowLastError( stderr );
|
|
return FALSE;
|
|
}
|
|
|
|
// accept the password from the user
|
|
strBuffer.Format( INPUT_PASSWORD, strUserName );
|
|
WriteConsoleW( GetStdHandle( STD_ERROR_HANDLE ),
|
|
strBuffer, strBuffer.GetLength(), &dwSize, NULL );
|
|
GetPassword( pwszPassword, MAX_STRING_LENGTH );
|
|
|
|
// release the buffer allocated for password
|
|
strPassword.ReleaseBuffer();
|
|
|
|
// now again try to establish the connection using the currently
|
|
// supplied credentials
|
|
bResult = ConnectWmi( pLocator, ppServices, (LPCWSTR)strServer,
|
|
(LPCWSTR)strUserName, (LPCWSTR)strPassword, ppAuthIdentity, FALSE, pwszNamespace, &hRes, pbLocalSystem );
|
|
|
|
if( bResult == FALSE )
|
|
{
|
|
if( 0x80040154 == hRes )
|
|
{
|
|
//the wmi is not registered on remote machine
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowMessage( stderr, GetResString(IDS_ERROR_REMOTE_INCOMPATIBLE));
|
|
}
|
|
else
|
|
{
|
|
GetWbemErrorText( hRes );
|
|
ShowMessage( stderr, ERROR_TAG );
|
|
ShowMessage( stderr, GetReason() );
|
|
}
|
|
return( FALSE ); // no use of accepting the password .. return failure
|
|
}
|
|
// return the success
|
|
return bResult;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Gets the security arguments for an interface.
|
|
//
|
|
// Arguments:
|
|
// pInterface [in] - Pointer to interface stucture.
|
|
// dwAuthorization [in/out] - Holds Authorization value.
|
|
// dwAuthentication [in/out] - Holds the Authentication value.
|
|
//
|
|
// Return Value:
|
|
// Returns HRESULT value.
|
|
// ***************************************************************************
|
|
HRESULT GetSecurityArguments( IUnknown *pInterface,
|
|
DWORD& dwAuthorization, DWORD& dwAuthentication )
|
|
{
|
|
// local variables
|
|
HRESULT hRes = 0;
|
|
DWORD dwAuthnSvc = 0, dwAuthzSvc = 0;
|
|
IClientSecurity *pClientSecurity = NULL;
|
|
|
|
if(pInterface == NULL)
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER; ;
|
|
}
|
|
// try to get the client security services values if possible
|
|
hRes = pInterface->QueryInterface( IID_IClientSecurity, (void**) &pClientSecurity );
|
|
if ( SUCCEEDED( hRes ) )
|
|
{
|
|
// got the client security interface
|
|
// now try to get the security services values
|
|
hRes = pClientSecurity->QueryBlanket( pInterface,
|
|
&dwAuthnSvc, &dwAuthzSvc, NULL, NULL, NULL, NULL, NULL );
|
|
if ( SUCCEEDED( hRes ) )
|
|
{
|
|
// we've got the values from the interface
|
|
dwAuthentication = dwAuthnSvc;
|
|
dwAuthorization = dwAuthzSvc;
|
|
}
|
|
|
|
// release the client security interface
|
|
SAFEIRELEASE( pClientSecurity );
|
|
}
|
|
|
|
// return always success
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Sets the interface security for the interface.
|
|
//
|
|
// Arguments:
|
|
// pInterface [in] - pointer to the interface.
|
|
// pAuthIdentity [in] - pointer to authentication structure.
|
|
//
|
|
// Return Value:
|
|
// returns HRESULT value.
|
|
// ***************************************************************************
|
|
HRESULT SetInterfaceSecurity( IUnknown *pInterface, COAUTHIDENTITY *pAuthIdentity )
|
|
{
|
|
// local variables
|
|
HRESULT hRes;
|
|
LPWSTR pwszDomain = NULL;
|
|
DWORD dwAuthorization = RPC_C_AUTHZ_NONE;
|
|
DWORD dwAuthentication = RPC_C_AUTHN_WINNT;
|
|
|
|
// check the interface
|
|
if ( pInterface == NULL )
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
// get the current security argument value
|
|
// GetSecurityArguments( pInterface, dwAuthorization, dwAuthentication );
|
|
|
|
// set the security information to the interface
|
|
hRes = SetProxyBlanket( pInterface, dwAuthentication, dwAuthorization, NULL,
|
|
RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE, pAuthIdentity, EOAC_NONE );
|
|
|
|
// return the result
|
|
return hRes;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Sets proxy blanket for the interface.
|
|
//
|
|
// Arguments:
|
|
// pInterface [in] - pointer to the inteface.
|
|
// dwAuthnsvc [in] - Authentication service to use.
|
|
// dwAuthzSvc [in] - Authorization service to use.
|
|
// pwszPricipal [in] - Server principal name to use with the authentication service.
|
|
// dwAuthLevel [in] - Authentication level to use.
|
|
// dwImpLevel [in] - Impersonation level to use.
|
|
// pAuthInfo [in] - Identity of the client.
|
|
// dwCapabilities [in] - Capability flags.
|
|
//
|
|
// Return Value:
|
|
// Return HRESULT value.
|
|
//
|
|
// ***************************************************************************
|
|
HRESULT WINAPI SetProxyBlanket( IUnknown *pInterface,
|
|
DWORD dwAuthnSvc, DWORD dwAuthzSvc,
|
|
LPWSTR pwszPrincipal, DWORD dwAuthLevel, DWORD dwImpLevel,
|
|
RPC_AUTH_IDENTITY_HANDLE pAuthInfo, DWORD dwCapabilities )
|
|
{
|
|
// local variables
|
|
HRESULT hRes;
|
|
IUnknown *pUnknown = NULL;
|
|
IClientSecurity *pClientSecurity = NULL;
|
|
|
|
if( pInterface == NULL )
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
// get the IUnknown interface ... to check whether this is a valid interface or not
|
|
hRes = pInterface->QueryInterface( IID_IUnknown, (void **) &pUnknown );
|
|
if ( hRes != S_OK )
|
|
{
|
|
return hRes;
|
|
}
|
|
|
|
// now get the client security interface
|
|
hRes = pInterface->QueryInterface( IID_IClientSecurity, (void **) &pClientSecurity );
|
|
if ( hRes != S_OK )
|
|
{
|
|
SAFEIRELEASE( pUnknown );
|
|
return hRes;
|
|
}
|
|
|
|
//
|
|
// Can't set pAuthInfo if cloaking requested, as cloaking implies
|
|
// that the current proxy identity in the impersonated thread (rather
|
|
// than the credentials supplied explicitly by the RPC_AUTH_IDENTITY_HANDLE)
|
|
// is to be used.
|
|
// See MSDN info on CoSetProxyBlanket for more details.
|
|
//
|
|
if ( dwCapabilities & (EOAC_STATIC_CLOAKING | EOAC_DYNAMIC_CLOAKING) )
|
|
pAuthInfo = NULL;
|
|
|
|
// now set the security
|
|
hRes = pClientSecurity->SetBlanket( pInterface, dwAuthnSvc, dwAuthzSvc, pwszPrincipal,
|
|
dwAuthLevel, dwImpLevel, pAuthInfo, dwCapabilities );
|
|
|
|
// release the security interface
|
|
SAFEIRELEASE( pClientSecurity );
|
|
|
|
// we should check the auth identity structure. if exists .. set for IUnknown also
|
|
if ( pAuthInfo != NULL )
|
|
{
|
|
hRes = pUnknown->QueryInterface( IID_IClientSecurity, (void **) &pClientSecurity );
|
|
if ( hRes == S_OK )
|
|
{
|
|
// set security authentication
|
|
hRes = pClientSecurity->SetBlanket(
|
|
pUnknown, dwAuthnSvc, dwAuthzSvc, pwszPrincipal,
|
|
dwAuthLevel, dwImpLevel, pAuthInfo, dwCapabilities );
|
|
|
|
// release
|
|
SAFEIRELEASE( pClientSecurity );
|
|
}
|
|
else if ( hRes == E_NOINTERFACE )
|
|
hRes = S_OK; // ignore no interface errors
|
|
}
|
|
|
|
// release the IUnknown
|
|
SAFEIRELEASE( pUnknown );
|
|
|
|
// return the result
|
|
return hRes;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Allocate memory for authentication variables.
|
|
//
|
|
// Arguments:
|
|
// pwszUser [in/out] - User name.
|
|
// pwszPassword [in/out] - Password.
|
|
// pwszDomain [in/out] - Domain name.
|
|
// ppAuthIdent [in/out] - Poointer to authentication structure.
|
|
//
|
|
// Return Value:
|
|
// Returns HRESULT value.
|
|
// ***************************************************************************
|
|
HRESULT WINAPI WbemAllocAuthIdentity( LPCWSTR pwszUser, LPCWSTR pwszPassword,
|
|
LPCWSTR pwszDomain, COAUTHIDENTITY **ppAuthIdent )
|
|
{
|
|
// local variables
|
|
COAUTHIDENTITY* pAuthIdent = NULL;
|
|
|
|
// validate the input parameter
|
|
if ( ppAuthIdent == NULL )
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
|
|
// allocation thru COM API
|
|
pAuthIdent = ( COAUTHIDENTITY* ) CoTaskMemAlloc( sizeof( COAUTHIDENTITY ) );
|
|
if ( NULL == pAuthIdent )
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
|
|
// init with 0's
|
|
SecureZeroMemory( ( void* ) pAuthIdent, sizeof( COAUTHIDENTITY ) );
|
|
|
|
//
|
|
// Allocate needed memory and copy in data. Cleanup if anything goes wrong
|
|
|
|
// user
|
|
if ( pwszUser != NULL )
|
|
{
|
|
// allocate memory for user
|
|
LONG lLength = StringLengthW( pwszUser, 0 );
|
|
pAuthIdent->User = ( LPWSTR ) CoTaskMemAlloc( (lLength + 1) * sizeof( WCHAR ) );
|
|
if ( pAuthIdent->User == NULL )
|
|
{
|
|
WbemFreeAuthIdentity( &pAuthIdent );
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
// set the length and do copy contents
|
|
pAuthIdent->UserLength = lLength;
|
|
StringCopy( pAuthIdent->User, pwszUser, lLength+1 );
|
|
}
|
|
|
|
// domain
|
|
if ( pwszDomain != NULL )
|
|
{
|
|
// allocate memory for domain
|
|
LONG lLength = StringLengthW( pwszDomain, 0 );
|
|
pAuthIdent->Domain = ( LPWSTR ) CoTaskMemAlloc( (lLength + 1) * sizeof( WCHAR ) );
|
|
if ( pAuthIdent->Domain == NULL )
|
|
{
|
|
WbemFreeAuthIdentity( &pAuthIdent );
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
// set the length and do copy contents
|
|
pAuthIdent->DomainLength = lLength;
|
|
StringCopy( pAuthIdent->Domain, pwszDomain, lLength+1 );
|
|
}
|
|
|
|
// passsord
|
|
if ( pwszPassword != NULL )
|
|
{
|
|
// allocate memory for passsord
|
|
LONG lLength = StringLengthW( pwszPassword, 0 );
|
|
pAuthIdent->Password = ( LPWSTR ) CoTaskMemAlloc( (lLength + 1) * sizeof( WCHAR ) );
|
|
if ( pAuthIdent->Password == NULL )
|
|
{
|
|
WbemFreeAuthIdentity( &pAuthIdent );
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
// set the length and do copy contents
|
|
pAuthIdent->PasswordLength = lLength;
|
|
StringCopy( pAuthIdent->Password, pwszPassword, lLength+1 );
|
|
}
|
|
|
|
// type of the structure
|
|
pAuthIdent->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
|
|
|
|
// final set the address to out parameter
|
|
*ppAuthIdent = pAuthIdent;
|
|
|
|
// return result
|
|
return S_OK;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Frees the memory of authentication stucture variable.
|
|
//
|
|
// Arguments:
|
|
// ppAuthIdentity [in] - Pointer to authentication structure.
|
|
//
|
|
// Return Value:
|
|
// none.
|
|
// ***************************************************************************
|
|
VOID WINAPI WbemFreeAuthIdentity( COAUTHIDENTITY** ppAuthIdentity )
|
|
{
|
|
// make sure we have a pointer, then walk the structure members and cleanup.
|
|
if ( *ppAuthIdentity != NULL )
|
|
{
|
|
// free the memory allocated for user
|
|
if ( (*ppAuthIdentity)->User != NULL )
|
|
CoTaskMemFree( (*ppAuthIdentity)->User );
|
|
|
|
// free the memory allocated for password
|
|
if ( (*ppAuthIdentity)->Password != NULL )
|
|
CoTaskMemFree( (*ppAuthIdentity)->Password );
|
|
|
|
// free the memory allocated for domain
|
|
if ( (*ppAuthIdentity)->Domain != NULL )
|
|
CoTaskMemFree( (*ppAuthIdentity)->Domain );
|
|
|
|
// final the structure
|
|
CoTaskMemFree( *ppAuthIdentity );
|
|
}
|
|
|
|
// set to NULL
|
|
*ppAuthIdentity = NULL;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
// Routine Description: checks if a user name is valid.
|
|
//
|
|
// Arguments: UserName
|
|
//
|
|
// Return Value: BOOL
|
|
//
|
|
// ***************************************************************************
|
|
BOOL IsValidUserEx( LPCWSTR pwszUser )
|
|
{
|
|
// local variables
|
|
CHString strUser;
|
|
|
|
try
|
|
{
|
|
// get user into local memory
|
|
strUser = pwszUser;
|
|
|
|
// user name should not be just '\'
|
|
if ( strUser.CompareNoCase( L"\\" ) == 0 )
|
|
return FALSE;
|
|
|
|
// user name should not contain invalid characters
|
|
if ( strUser.FindOneOf( L"/[]:|<>+=;,?*" ) != -1 )
|
|
return FALSE;
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
return FALSE;
|
|
}
|
|
|
|
// user name is valid
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Sets interface security.
|
|
//
|
|
// Arguments:
|
|
// pInterface [in] - Pointer to the interface to which security has to be set.
|
|
// pwszServer [in] - Holds the server name of the interface.
|
|
// pwszUser [in] - Holds the user name of the server.
|
|
// pwszPassword [in] - Hold the password of the user.
|
|
// ppAuthIdentity [in/out] - Pointer to authentication structure.
|
|
//
|
|
// Return Value:
|
|
// returns HRESULT value.
|
|
// ***************************************************************************
|
|
HRESULT SetInterfaceSecurity( IUnknown* pInterface,
|
|
LPCWSTR pwszServer, LPCWSTR pwszUser,
|
|
LPCWSTR pwszPassword, COAUTHIDENTITY** ppAuthIdentity )
|
|
{
|
|
// local variables
|
|
HRESULT hr=0;
|
|
CHString strUser;
|
|
CHString strDomain;
|
|
LPCWSTR pwszUserArg = NULL;
|
|
LPCWSTR pwszDomainArg = NULL;
|
|
DWORD dwAuthorization = RPC_C_AUTHZ_NONE;
|
|
DWORD dwAuthentication = RPC_C_AUTHN_WINNT;
|
|
|
|
// check the interface
|
|
if ( pInterface == NULL )
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
// check the authentity strcuture ... if authentity structure is already ready
|
|
// simply invoke the 2nd version of SetInterfaceSecurity
|
|
if ( *ppAuthIdentity != NULL )
|
|
{
|
|
return SetInterfaceSecurity( pInterface, *ppAuthIdentity );
|
|
}
|
|
|
|
// get the current security argument value
|
|
// GetSecurityArguments( pInterface, dwAuthorization, dwAuthentication );
|
|
|
|
// If we are doing trivial case, just pass in a null authenication structure
|
|
// for which the current logged in user's credentials will be considered
|
|
if ( pwszUser == NULL && pwszPassword == NULL )
|
|
{
|
|
// set the security
|
|
hr = SetProxyBlanket( pInterface, dwAuthentication, dwAuthorization,
|
|
NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );
|
|
|
|
// return the result
|
|
return hr;
|
|
}
|
|
|
|
// parse and find out if the user name contains the domain name
|
|
// if contains, extract the domain value from it
|
|
LONG lPos = -1;
|
|
strDomain = L"";
|
|
strUser = pwszUser;
|
|
if ( ( lPos = strUser.Find( L'\\' ) ) != -1 )
|
|
{
|
|
// user name contains domain name ... domain\user format
|
|
strDomain = strUser.Left( lPos );
|
|
strUser = strUser.Mid( lPos + 1 );
|
|
}
|
|
|
|
// get the domain info if it exists only
|
|
if ( strDomain.GetLength() != 0 )
|
|
{
|
|
pwszDomainArg = strDomain;
|
|
}
|
|
|
|
// get the user info if it exists only
|
|
if ( strUser.GetLength() != 0 )
|
|
{
|
|
pwszUserArg = strUser;
|
|
}
|
|
|
|
// check if authentication info is available or not ...
|
|
// initialize the security authenication information ... UNICODE VERSION STRUCTURE
|
|
if ( ppAuthIdentity == NULL )
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
else if ( *ppAuthIdentity == NULL )
|
|
{
|
|
hr = WbemAllocAuthIdentity( pwszUserArg, pwszPassword, pwszDomainArg, ppAuthIdentity );
|
|
if ( hr != S_OK )
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
// set the security information to the interface
|
|
hr = SetProxyBlanket( pInterface, dwAuthentication, dwAuthorization, NULL,
|
|
RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE, *ppAuthIdentity, EOAC_NONE );
|
|
|
|
// return the result
|
|
return hr;
|
|
}
|
|
|
|
VOID
|
|
WMISaveError(
|
|
HRESULT hrError
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function saves the description of the last error returned by WMI
|
|
|
|
Arguments:
|
|
|
|
HRESULT : The last return value from WMI
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
// local variables
|
|
HRESULT hr = S_OK;
|
|
IWbemStatusCodeText* pWbemStatus = NULL;
|
|
_bstr_t bstrErrorString;
|
|
|
|
try
|
|
{
|
|
// Set error to different value.
|
|
if ( E_ACCESSDENIED == hrError )
|
|
{
|
|
// change the error message to "Logon failure: unknown user name or bad password."
|
|
hrError = ERROR_LOGON_FAILURE;
|
|
}
|
|
|
|
//Set the reason to incompatible os when no class is registered on remote mechine
|
|
if( 0x80040154 == hrError )
|
|
{
|
|
bstrErrorString = _bstr_t( GetResString(IDS_ERROR_REMOTE_INCOMPATIBLE) );
|
|
SetReason( bstrErrorString );
|
|
return;
|
|
}
|
|
else
|
|
{ // Get error string.
|
|
hr = CoCreateInstance( CLSID_WbemStatusCodeText,
|
|
NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IWbemStatusCodeText,
|
|
(LPVOID*) &pWbemStatus );
|
|
if( SUCCEEDED( hr ) )
|
|
{
|
|
BSTR bstrString = NULL;
|
|
// Get error string from error code.
|
|
hr = pWbemStatus->GetErrorCodeText( hrError, 0, 0,
|
|
&bstrString );
|
|
if( NULL != bstrString )
|
|
{
|
|
bstrErrorString = _bstr_t( bstrString );
|
|
SysFreeString( bstrString );
|
|
}
|
|
if( FAILED( hr ) )
|
|
{
|
|
_com_issue_error( hrError );
|
|
}
|
|
SAFE_RELEASE(pWbemStatus);
|
|
}
|
|
else
|
|
{
|
|
_com_issue_error( hrError );
|
|
}
|
|
}
|
|
}
|
|
catch( _com_error& e )
|
|
{ // We have got the error. Needs to handle carefully.
|
|
LPWSTR lpwszGetString = NULL;
|
|
SAFE_RELEASE(pWbemStatus);
|
|
try
|
|
{ // ErrorMessage() can throw an exception.
|
|
DWORD dwLength = StringLength( e.ErrorMessage(), 0 ) + 5 ;
|
|
lpwszGetString = ( LPWSTR )AllocateMemory( dwLength * sizeof( WCHAR ) );
|
|
if( NULL != lpwszGetString )
|
|
{
|
|
StringCopy( lpwszGetString, e.ErrorMessage(), dwLength );
|
|
StringConcat( lpwszGetString, L"\n", dwLength );
|
|
SetReason( ( LPCWSTR )lpwszGetString );
|
|
FreeMemory( (LPVOID*) &lpwszGetString );
|
|
}
|
|
else
|
|
{ // Failed to know the exact error occured
|
|
// due to insufficient memory.
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
SaveLastError();
|
|
}
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
SaveLastError();
|
|
}
|
|
return;
|
|
}
|
|
|
|
SetReason( (LPCWSTR) bstrErrorString );
|
|
return;
|
|
}
|