// TestCSPDlg.cpp : implementation file
//
/*
	call SCWCSPCE.dll to test csp functions
	
*/
#include "stdafx.h"
#include "TestCSP.h"
#include "TestCSPDlg.h"
#include "Test.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

#define CREATE_CONTAINER "Create Container"
#define DELETE_CONTAINER "Delete Container"
#define GEN_KEYS "Gen RSA Keys"
#define HASH_DATA  "Hash_Data"
#define SIGN_HASH "Sign Hash"
#define GET_PROV_PARAM "Get Prov Param"
#define ENCRYPT_DECRYPT "En/decrypt"
#define SDLISTEN "SDListen"
#define SDNOTLISTEN "SDNotListen"

#define BUF_SIZE 256

HMODULE csp = LoadLibrary(TEXT("SCWCSPCE.dll"));

CSPFunc cf;


// CTestCSPDlg dialog

CTestCSPDlg::CTestCSPDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CTestCSPDlg::IDD, pParent)
	, msg(_T(""))
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CTestCSPDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, MSG, msg);
}

BEGIN_MESSAGE_MAP(CTestCSPDlg, CDialog)
#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
	ON_WM_SIZE()
#endif
	//}}AFX_MSG_MAP
	ON_BN_CLICKED(IDC_BUTTON1, &CTestCSPDlg::OnBnClickedButton1)
END_MESSAGE_MAP()

void CTestCSPDlg::WriteLog(CString log)
{
	msg = msg + log + (CString)"\r\n";
	UpdateData(false);
}

void CTestCSPDlg::WL(const char *bytes)
{
	msg += (CString)bytes + (CString)"\r\n";
	UpdateData(false);
}

void CTestCSPDlg::SL()
{
	msg += (CString)"	Succeed!\r\n";
	UpdateData(false);
}

void CTestCSPDlg::FL()
{
	msg += (CString)"	Failed!\r\n";
	UpdateData(false);
}
// CTestCSPDlg message handlers
void InitCSPFuntions()
{
	if(csp == NULL)
	{
		CTestCSPDlg dlg1;
		dlg1.WriteLog((CString)"Error:The module SCWCSPCE.DLL is not found!");
	};
	cf.lp_fnAcquire = (ACQUIRECONTEXT)GetProcAddress(csp,TEXT("CPAcquireContext"));
	cf.lp_fnRelease = (RELEASECONTEXT)GetProcAddress(csp,TEXT("CPReleaseContext"));

	cf.lp_fnGetProvParam = (GETPROVPARAM)GetProcAddress(csp,TEXT("CPGetProvParam"));

	cf.lp_fnCreateHash = (CREATEHASH)GetProcAddress(csp,TEXT("CPCreateHash"));
	cf.lp_fnDestroyHash = (DESTROYHASH)GetProcAddress(csp,TEXT("CPDestroyHash"));
	cf.lp_fnGetHashParam = (GETHASHPARAM)GetProcAddress(csp,TEXT("CPGetHashParam"));
	cf.lp_fnHashData = (HASHDATA)GetProcAddress(csp,TEXT("CPHashData"));
	cf.lp_fnHashSessionKey = (HASHSESSIONKEY)GetProcAddress(csp,TEXT("CPHashSessionKey"));
	cf.lp_fnSetHashParam = (SETHASHPARAM)GetProcAddress(csp,TEXT("CPSetHashParam"));

	cf.lp_fnEncrypt = (ENCRYPT)GetProcAddress(csp,TEXT("CPEncrypt"));
	cf.lp_fnDecrypt = (DECRYPT)GetProcAddress(csp,TEXT("CPDecrypt"));
	cf.lp_fnSignHash = (SIGNHASH)GetProcAddress(csp,TEXT("CPSignHash"));

	cf.lp_fnVerifySignature = (VERIFYSIGNATURE)GetProcAddress(csp,TEXT("CPVerifySignature"));

	cf.lp_fnDeriveKey = (DERIVEKEY)GetProcAddress(csp,TEXT("CPDeriveKey"));
	cf.lp_fnDestroyKey = (DESTROYKEY)GetProcAddress(csp,TEXT("CPDestroyKey"));
	cf.lp_fnImportKey = (IMPORTKEY)GetProcAddress(csp,TEXT("CPImportKey"));
	cf.lp_fnExportKey = (EXPORTKEY)GetProcAddress(csp,TEXT("CPExportKey"));
	cf.lp_fnGenKey = (GENKEY)GetProcAddress(csp,TEXT("CPGenKey"));
	cf.lp_fnGetKeyParam = (GETKEYPARAM)GetProcAddress(csp,TEXT("CPGetKeyParam"));
	cf.lp_fnSetKeyParam = (SETKEYPARAM)GetProcAddress(csp,TEXT("CPSetKeyParam"));
	cf.lp_fnGetUserKey = (GETUSERKEY)GetProcAddress(csp,TEXT("CPGetUserKey"));
	cf.lp_fnGenRandom = (GENRANDOM)GetProcAddress(csp,TEXT("CPGenRandom"));

	//cui.lp_fnNewCard = (NEWCARD)GetProcAddress(hUI,TEXT("NewCard"));
}
BOOL CTestCSPDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	InitCSPFuntions();
	// TODO: Add extra initialization here
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

#if defined(_DEVICE_RESOLUTION_AWARE) && !defined(WIN32_PLATFORM_WFSP)
void CTestCSPDlg::OnSize(UINT /*nType*/, int /*cx*/, int /*cy*/)
{
	DRA::RelayoutDialog(
		AfxGetInstanceHandle(), 
		this->m_hWnd, 
		DRA::GetDisplayMode() != DRA::Portrait ? 
			MAKEINTRESOURCE(IDD_TESTCSP_DIALOG_WIDE) : 
			MAKEINTRESOURCE(IDD_TESTCSP_DIALOG));
}
#endif

bool CTestCSPDlg::AcquireContext(HCRYPTPROV* hProv)
{
	WL("Begin in CPAcquireContext....");
	if(cf.lp_fnAcquire(hProv,0,0,NULL))
	{
		SL();
		return true;
	} 
	else 
	{
		if(GetLastError() == NTE_BAD_KEYSET)
		{
			WriteLog((CString)"Key container need to be created.");
			if(cf.lp_fnAcquire(hProv,0,CRYPT_NEWKEYSET,NULL))
			{
				WriteLog((CString)"A new key container has been created.");
				return true;
			}
			else
			{
				WriteLog((CString)"Could not create a key container.");
				return false;
			}
		}
		else
		{
			FL();
			return false;
		}
	}
	return true;
}

void CTestCSPDlg::TestCreateContainer()
{
	HCRYPTPROV hProv;
	WriteLog((CString)"CPAcquireContext....");
	if(cf.lp_fnAcquire(&hProv,0,0,NULL))
	{
		WriteLog((CString)"	 Container is already there.");
	} 
	else 
	{
		if(GetLastError() == NTE_BAD_KEYSET)
		{
			if(cf.lp_fnAcquire(&hProv,0,CRYPT_NEWKEYSET,NULL))
			{
				WriteLog((CString)"	 Container created.");
			}
			else
			{
				FL();
			}
		}
	}
	WL("CPReleaseContext....");
	if(cf.lp_fnRelease(hProv,0))
	{
		SL();
	}
	else
	{
		FL();
	}
}
void CTestCSPDlg::TestDeleteKeySet()
{
	HCRYPTPROV hProv;
	WriteLog((CString)"Begin in CPAcquireContext....");
	if(cf.lp_fnAcquire(&hProv,0,CRYPT_DELETEKEYSET,NULL))
	{
		WriteLog((CString)"		Deleted.");
	} 
	else 
	{
		if(GetLastError() == NTE_BAD_KEYSET)
		{
			WL("Key set not exist!");
		}
		else
		{
			WL("Failed to delete!");
		}
	}
	
}

void CTestCSPDlg::TestGenKey()
{  
	HCRYPTPROV hProv;
	HCRYPTKEY hKey;
	if(!AcquireContext(&hProv))
		return;
	WriteLog((CString)"CPGetUserKey ....");
	if(cf.lp_fnGetUserKey(hProv,AT_SIGNATURE,&hKey))
	{    
		WriteLog((CString)"Key already there!");
	}
	else 
	{ 
		WriteLog((CString)"CPGenKey...");
		if (cf.lp_fnGenKey(hProv,AT_SIGNATURE,0,&hKey))
		{
			SL();
		} 
		else
		{
			FL();
		}
	}
	WL("CPReleaseContext...");
	if(cf.lp_fnRelease(hProv,0))
	{
		SL();
	}
	else
	{
		FL();
	}
}

void CTestCSPDlg::TestHashData()
{
	HCRYPTPROV hProv;
	HCRYPTHASH hash;
	if(!AcquireContext(&hProv))
		return;
	WriteLog((CString)"CPCreateHash....");
	if(cf.lp_fnCreateHash(hProv,CALG_MD5,0,0,&hash))
		SL();
	else
	{
		FL();
		return;
	}

	DWORD bLen = 100;
	BYTE* pbData = new BYTE[bLen];
	WCHAR* temp = TEXT("Welcome to test.");
	WideCharToMultiByte(CP_ACP,0,temp,wcslen(temp),(LPSTR)pbData,bLen,0,0);
	WriteLog((CString)temp);
	bLen = sizeof(pbData);

	WL("CPHashData....");
	if(cf.lp_fnHashData(hProv,hash,pbData,bLen,0))
	{  
		SL();
	}
	else 
	{ 
		FL();
		return;
	}

	WL("CPReleaseContext...");
	if(cf.lp_fnRelease(hProv,0))
	{
		SL();
	}
	else
	{
		FL();
	}
}
void CTestCSPDlg::TestSignHash()
{  
	HCRYPTPROV hProv;
	HCRYPTHASH hash;
	HCRYPTKEY hKey;

	if(!AcquireContext(&hProv))
		return;

	WriteLog((CString)"Begin in test RSA sign....");

	if(!cf.lp_fnGetUserKey(hProv,AT_SIGNATURE,&hKey))
	{
		WriteLog((CString)"The signature keys are not exist.\r\nBegin to generate them....");
		WriteLog((CString)"CPGenKey");
		if(!cf.lp_fnGenKey(hProv,AT_SIGNATURE,0,&hKey))
		{
			WriteLog((CString)"  Failed.");
			return;
		}
		else
		{
			WriteLog((CString)"  Succeed.");
		}		
	}

	WriteLog((CString)"CPCreateHash...");
	if(cf.lp_fnCreateHash(hProv,CALG_MD5,0,0,&hash))
		WriteLog((CString)"  Succeed.");
	else
		WriteLog((CString)"  Failed.");
	DWORD bLen = 100;
	BYTE* pbData = new BYTE[bLen];
	WCHAR* temp = TEXT("Welcome to test.");
	WideCharToMultiByte(CP_ACP,0,temp,wcslen(temp),(LPSTR)pbData,bLen,0,0);
	bLen = sizeof(pbData);
	WriteLog((CString)"CPHashData");
	if(cf.lp_fnHashData(hProv,hash,pbData,bLen,0))
		WriteLog((CString)"  Succeed.");
	else 
		WriteLog((CString)"  Failed.");

	DWORD bufferLength;
	if(!cf.lp_fnSignHash(hProv,hash,AT_SIGNATURE,NULL,0,NULL,&bufferLength))
		WriteLog((CString)"Get signature size failed.");
	BYTE* buffer = new BYTE[sizeof(BYTE)*bufferLength];

	WriteLog((CString)"CPSignHash");
	if(cf.lp_fnSignHash(hProv,hash,AT_SIGNATURE,NULL,0,buffer,&bufferLength))
		WriteLog((CString)"  Succeed.");
	else
		WriteLog((CString)"  Failed.");
	
	WriteLog((CString)"CPVerifySignature");
	if(cf.lp_fnVerifySignature(hProv,hash,buffer,bufferLength,hKey,NULL,0))
		WriteLog((CString)"  Succeed.");
	else
		WriteLog((CString)"  Failed.");
	
	WriteLog((CString)"CPReleaseContext....");
	if(cf.lp_fnRelease(hProv,0))
	{
		WriteLog((CString)"  Succeed.");
	}
	else
	{
		WriteLog((CString)"  Failed");
	}
}

void CTestCSPDlg::TestGetProvParam()
{
	HCRYPTPROV hProv;
	if(!AcquireContext(&hProv))
		return;
	DWORD params[12] = {PP_CONTAINER,PP_ENUMALGS,PP_ENUMALGS_EX,PP_ENUMCONTAINERS,PP_IMPTYPE,PP_NAME,PP_VERSION,PP_SIG_KEYSIZE_INC,PP_KEYX_KEYSIZE_INC,
		PP_KEYSET_SEC_DESCR,PP_UNIQUE_CONTAINER,PP_PROVTYPE};
	DWORD flags[3] = {};
	DWORD dwParam;
	BYTE *pbData = new BYTE[256];
	DWORD pdwDataLen = 256;
	DWORD dwFlags = 0;
	char* temp = new char[400];
	WL("CPGetProvParam....");
	for(int i = 0; i < 12; i++)
	{
		pdwDataLen = 256;
		dwParam = params[i];
		switch(i)
		{

		case 1:
			{
				PROV_ENUMALGS	pbwData;
				dwFlags = CRYPT_FIRST;
				WL("{ALG_ID, BitLen, NameLen, Name}");
				while(cf.lp_fnGetProvParam(hProv,dwParam,reinterpret_cast<BYTE*>(&pbwData),&pdwDataLen,dwFlags))
				{
					dwFlags = 0;
					sprintf(temp,"{%d,   %d,   %d,   %S}",pbwData.aiAlgid,pbwData.dwBitLen,pbwData.dwNameLen,pbwData.szName);
					WL(temp);
					memset(temp,0,400);
					pdwDataLen = sizeof(pbwData);
				}
				break;
			}
		case 2:
			{
				/*PROV_ENUMALGS_EX	pbwData;
				dwFlags = CRYPT_FIRST;
				WL("{ALG_ID,  BitLen,  NameLen,  Name}");
				while(cf.lp_fnGetProvParam(hProv,dwParam,reinterpret_cast<BYTE*>(&pbwData),&pdwDataLen,dwFlags))
				{
					dwFlags = 0;
					sprintf(temp,"{%d, %d, %d, %S}",pbwData.aiAlgid,pbwData.dwDefaultLen,pbwData.dwNameLen,pbwData.szName);
					WL(temp);
					memset(temp,0,400);
					pdwDataLen = sizeof(pbwData);
				}*/
				break;
			}
		case 5:
			{
				if(cf.lp_fnGetProvParam(hProv,dwParam,pbData,&pdwDataLen,dwFlags))
				{
					sprintf(temp,"CSP name is:\r\n  %S",pbData);
					WL(temp);
					memset(temp,0,400);
				}
				else
				{
					SL();
				}
				break;
			}
		case 9:
			break;
		case 10:
			{
				if(cf.lp_fnGetProvParam(hProv,dwParam,pbData,&pdwDataLen,dwFlags))
				{
					sprintf(temp,"Default container is:\r\n  %S",pbData);
					WL(temp);
					memset(temp,0,400);
				}
				else
				{
					SL();
				}
				break;
			}
		default:
			{
				/*if(cf.lp_fnGetProvParam(hProv,dwParam,pbData,&pdwDataLen,dwFlags))
				{
					sprintf(temp,"%S - length:%d \n",pbData,pdwDataLen);
					WL(temp);
					memset(temp,0,400);
				}
				else
				{
					SL();
				}*/
				break;
			}

		}

	}
	WL("CPReleaseContext...");
	if(cf.lp_fnRelease(hProv,0))
	{
		SL();
	}
	else
	{
		FL();
	}
}


void CTestCSPDlg::TestEncrypt()
{
	HCRYPTPROV hProv;
	if(!AcquireContext(&hProv))
		return;

	DWORD bLen = 100;
	BYTE* pbData = new BYTE[bLen];
	WCHAR* temp = TEXT("Welcome to test.");
	WideCharToMultiByte(CP_ACP,0,temp,wcslen(temp),(LPSTR)pbData,bLen,0,0);
	bLen = sizeof(pbData);

	WL("Test data is:");
	WL((LPSTR)pbData);

	HCRYPTKEY hSessionKey;
	WL("CPGenKey....(3DES)");
	if(cf.lp_fnGenKey(hProv,CALG_3DES,CRYPT_EXPORTABLE,&hSessionKey))
	{
		SL();
	}
	else
	{
		FL();
		return;
	}
	
	WL("CPEncrypt...");
	if(cf.lp_fnEncrypt(hProv,hSessionKey,0,TRUE,0,pbData,&bLen,100))
	{
		SL();
	}
	else
	{
		FL();
		return;
	}
	
	WL("CPDecrypt...");
	if(cf.lp_fnDecrypt(hProv,hSessionKey,0,TRUE,0,pbData,&bLen))
	{
		SL();
		WL("Decrypt data is:");
		WL((LPSTR)pbData);
	}
	else
	{
		FL();
		return;
	}

	WriteLog((CString)"CPReleaseContext....");
	if(cf.lp_fnRelease(hProv,0))
	{
		WriteLog((CString)"  Succeed.");
	}
	else
	{
		WriteLog((CString)"  Failed");
	}
}

void CTestCSPDlg::TestReleaseContext()
{
	HCRYPTPROV hProv;
	if(!AcquireContext(&hProv))
		return;
	WriteLog((CString)"CPReleaseContext....");
	if(cf.lp_fnRelease( hProv,0))
	{
		SL();
	}
	else
	{
		FL();
	}
}
void CTestCSPDlg::OnBnClickedButton1()
{
	// TODO: Add your control notification handler code here
	HANDLE hDrv;
	CString elem;
	GetDlgItem(FUNC_CHOOSE)->GetWindowText(elem);
	if(elem ==CREATE_CONTAINER)
	{ 
		msg=(CString)"";
		TestCreateContainer();
	}
	else if(elem == DELETE_CONTAINER)
	{
		msg = (CString)"";
		TestDeleteKeySet();
	}
	else if (elem==GEN_KEYS)
	{  msg=(CString)"";
	   TestGenKey();
	} 
	else if(elem==HASH_DATA)
	{  msg=(CString)"";
	   TestHashData();
	}
	else if(elem == SIGN_HASH)
	{
		msg = (CString)"";
		TestSignHash();
	}
	else if(elem == GET_PROV_PARAM)
	{
		msg = (CString)"";
		TestGetProvParam();
	}
	else if(ENCRYPT_DECRYPT == elem)
	{
		msg = (CString)"";
		TestEncrypt();
	}
	else if(SDLISTEN == elem)
	{
		msg = (CString)"";
		WL("Activate SDListen.dll as service....");
		hDrv = RegisterService (TEXT("MSL"), 0, TEXT("ListenSD.dll"), 0);
		
		if(hDrv)
		{
			SL();
		}
		else
		{
			FL();
		}
	}
	else if(SDNOTLISTEN == elem)
	{
		msg = (CString)"";
		if(hDrv)
		{
			WL("Deregister SDListen.dll ....");
			if(DeregisterService(hDrv))
			{
				SL();
			}
			else
			{
				FL();
				WCHAR* err = new WCHAR[20];
				wsprintf(err,TEXT("Error Code:%d."),GetLastError());
				WriteLog((CString)err);
				delete[] err;
			}
		}
		else
		{
			WL("SD listen service is not started.");
		}
	}
}