old hackshield source

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the IMP2DLL_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// IMP2DLL_API functions as being imported from a DLL, wheras this DLL sees symbols
// defined with this macro as being exported.
#ifdef IMP2DLL_EXPORTS
#define IMP2DLL_API __declspec(dllexport)
#else
#define IMP2DLL_API __declspec(dllimport)
#endif

#define REGISTERED_MSG TEXT("IMP2_52A2FF2B_1AC2_4186_B05E_3338FF0801F9")

// À§ÀÇ ¸޽ÃÁöÀÇ WPARAM  °ª 
#define ID_HACK_FIND	2
#define ID_ERROR		3



IMP2DLL_API BOOL	IP2_Initialize(HWND hWnd, CHAR *pszUserNo);
IMP2DLL_API void	IP2_Finalize();
IMP2DLL_API BOOL	IP2_GetHackName(char *pszBuff, DWORD dwBuffSize);
IMP2DLL_API DWORD	IP2_GetLastError();
IMP2DLL_API BOOL	IP2_ContinueCheck(BOOL bContinue);

typedef BOOL	(*LIP2_INITIALIZE)(HWND hWnd, CHAR *pszUserNo);
typedef void	(*LIP2_FINALIZE)(VOID);
typedef BOOL	(*LIP2_GETHACKNAME)(char *pszBuff, DWORD dwBuffSize);
typedef DWORD	(*LIP2_GETLASTERROR)(VOID);
typedef BOOL	(*LIP2_CONTINUECHECK)(BOOL bContinue);

enum {IP2_NOERROR = 0x1, IP2_INVALID_WINDOWHANDLE, IP2_FAIL_CREATETHREAD, 
			IP2_FAIL_RESUMETHREAD, IP2_FAIL_INITIALIZE, IP2_BUFFER_SMALL, 
			IP2_ALREADY_INITIALIZED};

void HackSpeedCheckThread(void* arg);

// HackShield.cpp: implementation of the HackShield class.
//
//////////////////////////////////////////////////////////////////////
#include "Windows.h"
#include "HackShield.h"
#include "HashDB.h"

CHashDB theHashDB;

BOOL HS_ConnectDB( BYTE* ip )
{
	return theHashDB.ConnectDB( ip );
}


void HS_DisConnectDB( void )
{
	theHashDB.DisConnectDB();
}


int HS_LoadHashVal( BYTE* hashVal )
{
	return theHashDB.LoadHashVal( hashVal );
}

// HackShield.h: interface for the HackShield class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_HACKSHIELD_H__CAFBB806_D007_4E5A_B361_BCD64FA11B8A__INCLUDED_)
#define AFX_HACKSHIELD_H__CAFBB806_D007_4E5A_B361_BCD64FA11B8A__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


BOOL				HS_ConnectDB( BYTE* ip );
void				HS_DisConnectDB(void);
int					HS_LoadHashVal(BYTE* hashVal);



#endif // !defined(AFX_HACKSHIELD_H__CAFBB806_D007_4E5A_B361_BCD64FA11B8A__INCLUDED_)

// HashDB.cpp: implementation of the CHashDB class.
//
//////////////////////////////////////////////////////////////////////

//#include "stdafx.h"
//#include "VerHash.h"
#include "Windows.h"
#include "HashDB.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CHashDB::CHashDB()
{
	m_hEnv = SQL_NULL_HENV;
	m_hDbc = SQL_NULL_HDBC;
	m_hStmt = SQL_NULL_HSTMT;

	SQLRETURN retCode;
		
	retCode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_hEnv);

	retCode = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION,(SQLPOINTER)SQL_OV_ODBC3,SQL_IS_INTEGER);

	retCode = SQLAllocHandle(SQL_HANDLE_DBC, m_hEnv, &m_hDbc);
}

CHashDB::~CHashDB()
{
	DisConnectDB();
	if(m_hStmt != SQL_NULL_HSTMT) SQLFreeHandle(SQL_HANDLE_STMT, m_hStmt);
	if(m_hDbc != SQL_NULL_HDBC) SQLFreeHandle(SQL_HANDLE_DBC, m_hDbc);
	if(m_hEnv != SQL_NULL_HENV) SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
}

BOOL CHashDB::ConnectDB(BYTE* ip)
{
//	ASSERT(m_hEnv != SQL_NULL_HENV);
//	ASSERT(m_hDbc != SQL_NULL_HDBC);

	SQLRETURN retCode;
	                                    
	SQLCHAR		ConnStr[256];
	sprintf((char*)ConnStr, "DRIVER={SQL Server};SERVER=%s;UID=fsadmin;PWD=f$ei#L!;DATABASE=FreeStyle", ip);

	SQLCHAR		ConnStrOut[256];	memset(ConnStrOut, 0, 256);
	SQLSMALLINT cbConnStrOut = 0;

	retCode = SQLDriverConnect(m_hDbc, NULL,
                  ConnStr,      // Input connect string
                  SQL_NTS,         // Null-terminated string
                  ConnStrOut,      // Address of output buffer
                  256,    // Size of output buffer
                  &cbConnStrOut,   // Address of output length
                  SQL_DRIVER_NOPROMPT);

	if(retCode >= 0 ) return TRUE;

	return FALSE;
}

BOOL CHashDB::ConnectDB(BYTE* dsn, BYTE* id, BYTE* pass)
{	
//	ASSERT(m_hEnv != SQL_NULL_HENV);
//	ASSERT(m_hDbc != SQL_NULL_HDBC);

	SQLRETURN retCode;
	
	retCode = SQLConnect(m_hDbc, dsn, SQL_NTS, id, SQL_NTS, pass, SQL_NTS);
                     
/*                                        
	SQLCHAR		ConnStr[256] = _T("DRIVER={SQL Server};SERVER=172.16.4.10;UID=fsadmin;PWD=f$ei#L!;DATABASE=FreeStyle");
//	SQLCHAR		ConnStr[256] = _T("DSN=versionhash;UID=fsadmin;PWD=f$ei#L!");

	SQLCHAR		ConnStrOut[256];	memset(ConnStrOut, 0, 256);
	SQLSMALLINT cbConnStrOut = 0;

	retCode = SQLDriverConnect(m_hDbc, NULL,
                  ConnStr,      // Input connect string
                  SQL_NTS,         // Null-terminated string
                  ConnStrOut,      // Address of output buffer
                  256,    // Size of output buffer
                  &cbConnStrOut,   // Address of output length
                  SQL_DRIVER_NOPROMPT);
*/
	if(retCode >= 0 ) return TRUE;

	return FALSE;
}

int CHashDB::AllocStmt()
{
	return SQLAllocHandle(SQL_HANDLE_STMT, m_hDbc, &m_hStmt);
}

int CHashDB::FreeStmt()
{
	if(m_hStmt == SQL_NULL_HSTMT) return 0;

	int ret = SQLFreeHandle(SQL_HANDLE_STMT, m_hStmt);
	m_hStmt = SQL_NULL_HSTMT;
	return ret;
}

int CHashDB::LoadHashVal(BYTE* hashVal)
{
	SQLRETURN  retCode;
	char szSQLStmt[1024];

	sprintf(szSQLStmt, "SELECT HashVal FROM tblVersionHash");

	AllocStmt();
	
	long IHash = 0;//HSCFLIB_SIZE_HASH;

	retCode = ::SQLBindCol(m_hStmt, 1, SQL_BINARY, hashVal, HSCFLIB_SIZE_HASH, &IHash );
	
	retCode = SQLExecDirect(m_hStmt, (BYTE*)szSQLStmt, SQL_NTS);

	retCode = SQLFetch(m_hStmt);
	if(retCode != SQL_SUCCESS && retCode != SQL_SUCCESS_WITH_INFO) 
	{
		FreeStmt();
		return retCode;
	}
	

	FreeStmt();

	return retCode;
}

int CHashDB::SaveHashVal(BYTE* hashVal)
{
	SQLRETURN  retCode;
	char szSQLStmt[1024];

	sprintf(szSQLStmt, "delete tblVersionHash INSERT INTO tblVersionHash(HashVal) VALUES (?)", hashVal);

	AllocStmt();
	
	long IHash = HSCFLIB_SIZE_HASH;

	retCode = ::SQLBindParameter(m_hStmt, 1, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_BINARY,
		HSCFLIB_SIZE_HASH, 1, hashVal, HSCFLIB_SIZE_HASH, &IHash );
	
	retCode = SQLExecDirect(m_hStmt, (BYTE*)szSQLStmt, SQL_NTS);

	FreeStmt();
	
	return retCode;

}

// HashDB.h: interface for the CHashDB class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_HASHDB_H__AA1865D4_3D8D_4197_8D10_2566D280B119__INCLUDED_)
#define AFX_HASHDB_H__AA1865D4_3D8D_4197_8D10_2566D280B119__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#include <stdio.h>
#include <string.h>
#include "Sql.h"
#include "Sqlext.h"
#include "Sqltypes.h"
#include "Odbcss.h"


#define HSCFLIB_SIZE_HASH 16

class CHashDB  
{
public:
	CHashDB();
	~CHashDB();

	BOOL	ConnectDB(BYTE* dsn, BYTE* id, BYTE* pass);
	BOOL	ConnectDB(BYTE* ip);
	void	DisConnectDB() { if(m_hDbc != SQL_NULL_HDBC) SQLDisconnect(m_hDbc); }

	int		LoadHashVal(BYTE* hashVal);
	int		SaveHashVal(BYTE* hashVal);

private:
	int AllocStmt();
	int FreeStmt();

	HENV m_hEnv;
	HDBC m_hDbc;
	HSTMT m_hStmt;	
};

#endif // !defined(AFX_HASHDB_H__AA1865D4_3D8D_4197_8D10_2566D280B119__INCLUDED_)

// KWall.cpp: implementation of the CKWall class.
//
//////////////////////////////////////////////////////////////////////
#include "Windows.h"
#include "ImPDll.h"
#include "KWall.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CKWall theKWall;

CKWall::CKWall()
{
	m_uMsgRegistered = 0;
}

CKWall::~CKWall()
{

}

int CKWall::StartUp( HWND hWnd, char* pUserName )
{
	m_uMsgRegistered = RegisterWindowMessage(REGISTERED_MSG);

	LIP2_INITIALIZE     pInitialize;
	LIP2_GETLASTERROR	pGetLastError;

	TCHAR szFilePath[MAX_PATH];
	GetSystemDirectory(szFilePath, MAX_PATH);
	lstrcat(szFilePath, "\\");
	lstrcat(szFilePath, "ImP2.DLL");
	m_hDll = LoadLibrary(szFilePath);

	if (m_hDll != NULL)  
	{
		pInitialize = (LIP2_INITIALIZE)GetProcAddress(m_hDll, "IP2_Initialize");
		pFinalize = (LIP2_FINALIZE)GetProcAddress(m_hDll, "IP2_Finalize");
		pGetHackName = (LIP2_GETHACKNAME)GetProcAddress(m_hDll, "IP2_GetHackName");
		pGetLastError = (LIP2_GETLASTERROR)GetProcAddress(m_hDll, "IP2_GetLastError");
	}

//	CHAR szUserNo[256];
	BOOL bRet = FALSE;

	if(pInitialize)  
	{
		bRet = pInitialize( hWnd, pUserName );
	}

	return bRet;
}


void CKWall::ShutDown(void)
{
	if( pFinalize )   
	{
		pFinalize();
	}
	
	if( m_hDll != NULL )  
	{
		FreeLibrary(m_hDll);
	}

}


LRESULT	CKWall::MainProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )  
{
	if (uMsg == m_uMsgRegistered)  
	{
		switch(wParam) 
		{
		case ID_ERROR :
			break;
		case ID_HACK_FIND :
			if (pGetHackName)  
			{
/*				CHAR szMsg[1024];
				CHAR szHackName[1024];
				pGetHackName(szHackName, 1024);// ÇÙ À̸§¸¸ ¾òÀ» ¼ö ÀÖÀ¸¹Ç				·Î ¸޽ÃÁö¸¦ Àû´çÈ÷ ¸¸µç´Ù.
				wsprintf(szMsg, "%s °¡ ¹߰ߵǾú½À´ϴÙ. ÇÁ·α×·¥À» Á¾·áÇմϴÙ.", szHackName);
				MessageBox(NULL, szMsg, "Error", MB_OK);
//				PostQuitMessage(0);  // ÇÁ·α×·¥À» Á¾·áÇѴÙ
*/
			}
			break;
		}
	} else 
	{
		switch(uMsg)  
		{
		}
	}

	return 1;
}

/////// ÆĶõ ÇÙ üũ KWall ¸ðµâ ////////////
int  KWall_StartUp( HWND hWnd, char* pUserName )
{
	return theKWall.StartUp( hWnd, pUserName );
}

void KWall_ShutDown(void)
{
	theKWall.ShutDown();
}

void KWall_MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	theKWall.MainProc( hWnd, uMsg, wParam, lParam );
}

// KWall.h: interface for the CKWall class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_KWALL_H__9D1465EC_1A3E_4BE1_AADF_9EE2233552D2__INCLUDED_)
#define AFX_KWALL_H__9D1465EC_1A3E_4BE1_AADF_9EE2233552D2__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CKWall  
{
public:
	CKWall();
	virtual ~CKWall();

private:
	UINT                m_uMsgRegistered;
	HMODULE             m_hDll;
	BOOL	            m_bInitialize;
	// Funciton pointer.
	LIP2_FINALIZE	    pFinalize;
	LIP2_GETHACKNAME	pGetHackName;

public:
	int     StartUp( HWND hWnd, char* pUserName );
	void    ShutDown(void);
	LRESULT	MainProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
};


int  KWall_StartUp( HWND hWnd, char* pUserName );
void KWall_ShutDown(void);
void KWall_MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );

#endif // !defined(AFX_KWALL_H__9D1465EC_1A3E_4BE1_AADF_9EE2233552D2__INCLUDED_)