//---------------------------------------------------------------------------
#pragma hdrstop
#include "USBLock.h"
#include "tchar.h"
//---------------------------------------------------------------------------
#include "seed.h"
#include <DateUtils.hpp>
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
// 실행 중인 프로세스의 목록을 얻어온다
bool CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lpParam)
{
  HANDLE hSnapshot = NULL;
  HANDLE hProcess = NULL;
  PROCESSENTRY32 pe32;
  bool bContinue = false;
  DWORD dwPID;
	Char *WindowTitle = NULL;
	String strWindowTitle;
	TStringList *strReverseEngineeringToolList = NULL;  // 실행 중인 프로세스의 목록과 비교를 위한 전역 변수
	bool bFind;

	if (hWnd && IsWindowVisible(hWnd)
			&& ((GetWindowLong(hWnd, GWL_HWNDPARENT) == 0) || (HWND(GetWindowLong(hWnd, GWL_HWNDPARENT)) == GetDesktopWindow))
			&& (GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW) == 0) {
		WindowTitle = new Char[256];

		GetWindowText(hWnd, WindowTitle, 255);  // 프로세스의 캡션을 얻어온다

    strWindowTitle = WindowTitle;

    strWindowTitle = strWindowTitle.UpperCase();

    bFind = false;
    strReverseEngineeringToolList = (TStringList *)lpParam;
    for (int i = 0; i < strReverseEngineeringToolList->Count; i++) {
      if (strWindowTitle.Pos(strReverseEngineeringToolList->Strings[i].UpperCase()) > 0) {
        bFind = true;
        break;
      }
    }

    if (WindowTitle) { delete []WindowTitle; WindowTitle = NULL; }

    if (bFind) { // 입력된 값과 하나라도 같으면 종료
      GetWindowThreadProcessId(hWnd, &dwPID); // 프로세스 ID를 얻어오며

      pe32.dwSize = sizeof(PROCESSENTRY32);

      hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);

      bContinue = Process32First(hSnapshot, &pe32);
      while (bContinue) {
        if (pe32.th32ProcessID == dwPID) {  // 동일한 프로세스의 핸들을 얻기위한 작업이다
          hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pe32.th32ProcessID);
          if (hProcess) {
            // 메시지 박스를 호출하지 않도록 한다 (메시지 박스가 떠 있는 동안 디버그할 수 있기 때문)
            //Application->MessageBox(pMessage06, pMessage01, MB_ICONSTOP);
            TerminateProcess(hProcess, 0);  // 프로세스의 핸들을 이용한 프로세스 종료
            CloseHandle(hProcess);
          }
          break;
        }
        bContinue = Process32Next(hSnapshot, &pe32);
      }
      if (hSnapshot) { CloseHandle(hSnapshot); }
    }
  }

  return true;
}
//---------------------------------------------------------------------------
__fastcall TUSBLock::TUSBLock()
{
  strReverseEngineeringToolList = NULL;

  CheckReverseEngineeringTools();
}
//---------------------------------------------------------------------------
__fastcall TUSBLock::~TUSBLock()
{
  if (strReverseEngineeringToolList) {
    strReverseEngineeringToolList->Clear();
    delete strReverseEngineeringToolList;
  }
  strReverseEngineeringToolList = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TUSBLock::KillReverseEngineeringTool(TStringList *strExcutionNameList)
{
  // ReverseEngineeringTool이 감지되면 프로그램을 종료한다
  HANDLE hSnapshot = NULL;
  HANDLE hProcess = NULL;
  PROCESSENTRY32 pe32;
  bool bContinue = false;
  char WindowsCaption[255];
	String strWindowsCaption;
  int nIndex = 0;

  hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  pe32.dwSize = sizeof(PROCESSENTRY32);

  // 프로그램의 이름과 같을 경우 종료
  if (strExcutionNameList && hSnapshot) {
    bContinue = Process32First(hSnapshot, &pe32);
    while (bContinue) {
      strWindowsCaption = pe32.szExeFile;
      strWindowsCaption = strWindowsCaption.LowerCase();

      nIndex = 0;
      for (int i = 0; i < strExcutionNameList->Count; i++) {
        if (strWindowsCaption.Pos(strExcutionNameList->Strings[i].LowerCase()) > 0) {
          nIndex = i;
          break;
        }
      }
      if (nIndex > 0) {
        hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pe32.th32ProcessID);
        if (hProcess) {
          TerminateProcess(hProcess, 0);  // 프로세스의 핸들을 이용한 프로세스 종료
          CloseHandle(hProcess);
        }
        break;
      }
      bContinue = Process32Next(hSnapshot, &pe32);
    }

    if (hSnapshot) { CloseHandle(hSnapshot); hSnapshot= NULL; }
  }
}
//---------------------------------------------------------------------------
void __fastcall TUSBLock::CheckReverseEngineeringTools()
{
  if (strReverseEngineeringToolList == NULL) {
    strReverseEngineeringToolList = new TStringList;

    // Reverse Engineering Tool Kill
    // http://www.drvi.com/DrVirus/sub02/sub02_01_view.php?no=262 에 표기되어있는 디버깅 프로그램 목록
    strReverseEngineeringToolList->Add("EXESPY");
    strReverseEngineeringToolList->Add("WXR95");
    strReverseEngineeringToolList->Add("REGMON");
    strReverseEngineeringToolList->Add("FILE MONITOR");
    strReverseEngineeringToolList->Add("REGMONEX");
    strReverseEngineeringToolList->Add("WINDOW DETECTIVE");
    strReverseEngineeringToolList->Add("DEBUGVIEW");
    strReverseEngineeringToolList->Add("RESSPY");
    strReverseEngineeringToolList->Add("ADVANCED REGISTRY TRACER");
    strReverseEngineeringToolList->Add("REGSNAP");
    strReverseEngineeringToolList->Add("MEMSPY");
    strReverseEngineeringToolList->Add("MEMORY DOCTOR");
    strReverseEngineeringToolList->Add("PROCDUMP32");
    strReverseEngineeringToolList->Add("MEMORY EDITOR");
    strReverseEngineeringToolList->Add("FROGSICE");
    strReverseEngineeringToolList->Add("SMU WINSPECTOR");
    strReverseEngineeringToolList->Add("MEMORY DUMPER");
    strReverseEngineeringToolList->Add("MEMORYMONITOR");
    strReverseEngineeringToolList->Add("NUMEGA SOFTICE LOADER");
    strReverseEngineeringToolList->Add("URSOFT W32DASM");
    strReverseEngineeringToolList->Add("OLLYDBG");
    strReverseEngineeringToolList->Add("TRW2000");

    strReverseEngineeringToolList->Add("DEDE");  // Delphi Decompiler
    strReverseEngineeringToolList->Add("HACK");
    strReverseEngineeringToolList->Add("CRACK");
    strReverseEngineeringToolList->Add("WINICE");

    strReverseEngineeringToolList->Add("DRWATSON");  // Memory Dump
    strReverseEngineeringToolList->Add("WINDBG");    // Memory Dump
    strReverseEngineeringToolList->Add("DEVENV");    // Visual Studio
    //strReverseEngineeringToolList->Add("BCB");    // Borland C++ Builder
  }

  // 프로세스의 캡션이나 실행파일명이 같을 경우 종료
  if (strReverseEngineeringToolList) {
    EnumWindows((WNDENUMPROC)EnumWindowsProc, (LPARAM)strReverseEngineeringToolList);
    KillReverseEngineeringTool(strReverseEngineeringToolList);
  }
}
//---------------------------------------------------------------------------
/*
int __fastcall TUSBLock::SeedEncode(AnsiString strFileName, int nVersion
  , BYTE *pEncode, DWORD dwEncLen, BYTE **pDecode, unsigned short nIVKeyIndex)
{
  // SEED 알고리즘을 이용한 암호화

  // 주의할 점은 암호화될 데이터(pDecode)의 크기를 미리 알 수 없으므로
  // 인자로 넘어오기전에 할당하는 것이 아니라, 함수 내에서 크기가 정해지고 할당된다는 것이다.
  DWORD dwEnIndex, dwDecLen;
  BYTE *pAccumData = NULL, *pSwapData = NULL;
  BYTE SrcData[1024+32], DstData[1024+32];
  BYTE ProgramKey[SEED_USER_KEY_LEN] = "YoungWooUSBLock"; // 이 부분은 변경되어도 무방하나, 16바이트를 넘지 않도록한다.
  BYTE IVKey[SEED_BLOCK_LEN];
  RET_VAL	ret;
  SEED_ALG_INFO AlgInfo;
  int nAccumNum;


  // Key Data File에서 특정 위치의 키 데이터를 가져온다
  if (LoadFromDataFile(strFileName, nVersion, nIVKeyIndex, IVKey) != nVersion) {
    return -1;
  }

  // 초기화
  memset(SrcData, 0x00, sizeof(BYTE)*(1024+32));
  memset(DstData, 0x00, sizeof(BYTE)*(1024+32));
  nAccumNum = 0;
  dwEnIndex = 0;

  SEED_SetAlgInfo(AI_CBC, AI_PKCS_PADDING, IVKey, &AlgInfo);
  ret = SEED_KeySchedule(ProgramKey, SEED_USER_KEY_LEN, &AlgInfo);

  ret = SEED_EncInit(&AlgInfo);
  if (ret != CTR_SUCCESS)	return -1;

  while (true) {
    if (dwEncLen == 0) break;

    if (dwEncLen > 1024) {
      memcpy(SrcData, pEncode+dwEnIndex, sizeof(BYTE)*1024);
    }
    else {
      memcpy(SrcData, pEncode+dwEnIndex, sizeof(BYTE)*dwEncLen);
    }

    dwDecLen = 1024;
    ret = SEED_EncUpdate(&AlgInfo, SrcData, dwEncLen, DstData, &dwDecLen);

    pSwapData = pAccumData;
    pAccumData = new BYTE[nAccumNum+dwDecLen];
    memcpy(pAccumData, pSwapData, sizeof(BYTE)*nAccumNum);  // 기존 데이터 복사
    memcpy(pAccumData+sizeof(BYTE)*nAccumNum, DstData, sizeof(BYTE)*dwDecLen);     // 데이터 복사
    if (pSwapData) { delete []pSwapData; pSwapData = NULL; }

    nAccumNum += dwDecLen;

    if (ret != CTR_SUCCESS)	{
      if (pAccumData) { delete []pAccumData; pAccumData = NULL; }
      return -1;
    }

    if (dwEncLen > 1024) {
      dwEnIndex += 1024;
      dwEncLen -= 1024;
    }
    else {
      dwEnIndex += dwEncLen;
      dwEncLen = 0;
    }
  }


  dwDecLen = 1024;
  ret = SEED_EncFinal(&AlgInfo, DstData, &dwDecLen);

  if (dwDecLen > 0x100000) {  // 값이 잘 못되어 100KB가 넘어갈 경우
    if (*pDecode) { delete [](*pDecode); }
    if (pAccumData) { delete []pAccumData; pAccumData = NULL; }
    if (pSwapData) { delete []pSwapData; pSwapData = NULL; }
    return -1;
  }
  else if (dwDecLen > 0) {
    pSwapData = pAccumData;
    pAccumData = new BYTE[nAccumNum+dwDecLen];
    memcpy(pAccumData, pSwapData, sizeof(BYTE)*nAccumNum);  // 기존 데이터 복사
    memcpy(pAccumData+sizeof(BYTE)*nAccumNum, DstData, sizeof(BYTE)*dwDecLen);     // 데이터 복사

    nAccumNum += dwDecLen;
  }

  if (*pDecode) { delete [](*pDecode); }
  *pDecode = new BYTE[nAccumNum];
  memcpy(*pDecode, pAccumData, sizeof(BYTE)*nAccumNum);

  if (pAccumData) { delete []pAccumData; pAccumData = NULL; }
  if (pSwapData) { delete []pSwapData; pSwapData = NULL; }

  if (ret != CTR_SUCCESS)	return -1;

  return nAccumNum; // 여기서 return되어야 암호화 성공한 것이다.
}
*/
//---------------------------------------------------------------------------
int __fastcall TUSBLock::SeedDecode(String strFileName, int nVersion
  , BYTE *pDecode, DWORD dwDecLen, BYTE **pEncode, unsigned short nIVKeyIndex)
{
  // SEED 알고리즘을 이용한 복호화
  DWORD dwDeIndex, dwEncLen;
	BYTE *pAccumData = NULL, *pSwapData = NULL;
	BYTE SrcData[1024+32], DstData[1024+32];
  BYTE ProgramKey[SEED_USER_KEY_LEN];
	BYTE IVKey[SEED_BLOCK_LEN];
  RET_VAL	ret;
	SEED_ALG_INFO AlgInfo;
	int nAccumNum;

	if (LoadFromDataFile(strFileName, nVersion, nIVKeyIndex, IVKey) != nVersion) {
    return -1;
  }

  // 초기화
  memset(SrcData, 0x00, sizeof(BYTE)*(1024+32));
  memset(DstData, 0x00, sizeof(BYTE)*(1024+32));
  nAccumNum = 0;
  dwDeIndex = 0;

  SEED_SetAlgInfo(AI_CBC, AI_PKCS_PADDING, IVKey, &AlgInfo);
  ret = SEED_KeySchedule(ProgramKey, SEED_USER_KEY_LEN, &AlgInfo);

  ret = SEED_DecInit(&AlgInfo);
  if (ret != CTR_SUCCESS)	return -1;

  while (true) {
    if (dwDecLen == 0) break;

    if (dwDecLen > 1024) {
      memcpy(SrcData, pDecode+dwDeIndex, sizeof(BYTE)*1024);
    }
    else {
      memcpy(SrcData, pDecode+dwDeIndex, sizeof(BYTE)*dwDecLen);
    }

    dwEncLen = 1024;
    ret = SEED_DecUpdate(&AlgInfo, SrcData, dwDecLen, DstData, &dwEncLen);

    pSwapData = pAccumData;
    pAccumData = new BYTE[nAccumNum+dwEncLen];
    memcpy(pAccumData, pSwapData, sizeof(BYTE)*nAccumNum);  // 기존 데이터 복사
    memcpy(pAccumData+sizeof(BYTE)*nAccumNum, DstData, sizeof(BYTE)*dwEncLen);     // 데이터 복사
    if (pSwapData) { delete []pSwapData; pSwapData = NULL; }

    nAccumNum += dwEncLen;

    if (ret != CTR_SUCCESS)	{
      if (pAccumData) { delete []pAccumData; pAccumData = NULL; }
    }

    if (dwDecLen > 1024) {
      dwDecLen -= 1024;
      dwDeIndex += 1024;
    }
    else {
      dwDeIndex += dwDecLen;
      dwDecLen = 0;
    }
  }


  dwEncLen = 1024;
  ret = SEED_DecFinal(&AlgInfo, DstData, &dwEncLen);

  if (dwEncLen > 0x100000) {  // 값이 잘 못되어 100KB가 넘어갈 경우
    if (*pEncode) { delete [](*pEncode); }
    if (pAccumData) { delete []pAccumData; pAccumData = NULL; }
    if (pSwapData) { delete []pSwapData; pSwapData = NULL; }
    return -1;
  }
  else if (dwEncLen > 0) {
    pSwapData = pAccumData;
    pAccumData = new BYTE[nAccumNum+dwEncLen];
    memcpy(pAccumData, pSwapData, sizeof(BYTE)*nAccumNum);  // 기존 데이터 복사
    memcpy(pAccumData+sizeof(BYTE)*nAccumNum, DstData, sizeof(BYTE)*dwEncLen);     // 데이터 복사
    if (pSwapData) { delete []pSwapData; pSwapData = NULL; }

    nAccumNum += dwEncLen;
  }

  if (*pEncode) { delete [](*pEncode); }
  *pEncode = new BYTE[nAccumNum];
  memcpy(*pEncode, pAccumData, sizeof(BYTE)*nAccumNum);

  if (pAccumData) { delete []pAccumData; pAccumData = NULL; }
  if (pSwapData) { delete []pSwapData; pSwapData = NULL; }

  if (ret != CTR_SUCCESS)	return -1;

  return nAccumNum; // 여기서 return되어야 복호화에 성공한 것이다.
}
//---------------------------------------------------------------------------
/*
bool __fastcall TUSBLock::MixEncode(BYTE *pCode, TUSBInformation *usbinfoData)
{
  // 조합 암호화

  // 섞는 내용은 다음과 같다
  // 1. S : USB Drive의 Serial (Type : DWORD - 4Byte)
  // 2. A : 인증 시간 (Type : FILETIME - 8Byte)
  // 3. E : 인증 만료 시간 (Type : FILETIME - 8Byte)
  // 4. P : Program (Type : unsigned int - 4Byte)

  // ~A[0] A[5] ~S[2] P[3] E[2] A[7] ~S[1] E[7] ~S[0] A[3] P[0] E[5]
  // ~A[1] S[3] E[0] A[4] ~P[2] ~A[2] ~A[6] ~E[3] ~P[1] ~E[1] ~E[6] E[4]
  bool bReturn = false;
  FILETIME ftAuthorizationTime, ftExpireTime;
  BYTE pDrvSerial[4], pAuthorizationTime[8], pExpireTime[8], pProgram[4];

  try {
    if (pCode) {
      memcpy(pDrvSerial, &(usbinfoData->Serial), sizeof(DWORD));
      ftAuthorizationTime = usbinfoData->GetAuthorizationTimeToFileTime();
      ftExpireTime = usbinfoData->GetExpireTimeToFileTime();
      memcpy(pAuthorizationTime, &ftAuthorizationTime, sizeof(FILETIME));
      memcpy(pExpireTime, &ftExpireTime, sizeof(FILETIME));
      memcpy(pProgram, &(usbinfoData->Program), sizeof(unsigned int));

      pCode[0] = ~pAuthorizationTime[0];
      pCode[1] = pAuthorizationTime[5];
      pCode[2] = ~pDrvSerial[2];
      pCode[3] = pProgram[3];
      pCode[4] = pExpireTime[2];
      pCode[5] = pAuthorizationTime[7];
      pCode[6] = ~pDrvSerial[1];
      pCode[7] = pExpireTime[7];
      pCode[8] = ~pDrvSerial[0];
      pCode[9] = pAuthorizationTime[3];
      pCode[10] = pProgram[0];
      pCode[11] = pExpireTime[5];
      pCode[12] = ~pAuthorizationTime[1];
      pCode[13] = pDrvSerial[3];
      pCode[14] = pExpireTime[0];
      pCode[15] = pAuthorizationTime[4];
      pCode[16] = ~pProgram[2];
      pCode[17] = ~pAuthorizationTime[2];
      pCode[18] = ~pAuthorizationTime[6];
      pCode[19] = ~pExpireTime[3];
      pCode[20] = ~pProgram[1];
      pCode[21] = ~pExpireTime[1];
      pCode[22] = ~pExpireTime[6];
      pCode[23] = pExpireTime[4];

      bReturn = true;
    }
  }
  catch (...) {
    return false;
  }

  return bReturn;
}
*/
//---------------------------------------------------------------------------
bool __fastcall TUSBLock::MixDecode(BYTE *pCode, TUSBInformation *usbinfoData)
{
  // 조합 복호화
  
  // 섞는 내용은 다음과 같다
  // 1. S : USB Drive의 Serial (Type : DWORD - 4Byte)
  // 2. A : 인증 시간 (Type : FILETIME - 8Byte)
  // 3. E : 인증 만료 시간 (Type : FILETIME - 8Byte)
  // 4. P : Program (Type : unsigned int - 4Byte)

  // ~A[0] A[5] ~S[2] P[3] E[2] A[7] ~S[1] E[7] ~S[0] A[3] P[0] E[5]
  // ~A[1] S[3] E[0] A[4] ~P[2] ~A[2] ~A[6] ~E[3] ~P[1] ~E[1] ~E[6] E[4]
  bool bReturn = false;
  FILETIME ftAuthorizationTime, ftExpireTime;
  BYTE pDrvSerial[4], pAuthorizationTime[8], pExpireTime[8], pProgram[4];

  try {
    if (pCode) {
      pAuthorizationTime[0] = ~pCode[0];
      pAuthorizationTime[5] = pCode[1];
      pDrvSerial[2] = ~pCode[2];
      pProgram[3] = pCode[3];
      pExpireTime[2] = pCode[4];
      pAuthorizationTime[7] = pCode[5];
      pDrvSerial[1] = ~pCode[6];
      pExpireTime[7] = pCode[7];
      pDrvSerial[0] = ~pCode[8];
      pAuthorizationTime[3] = pCode[9];
      pProgram[0] = pCode[10];
      pExpireTime[5] = pCode[11];
      pAuthorizationTime[1] = ~pCode[12];
      pDrvSerial[3] = pCode[13];
      pExpireTime[0] = pCode[14];
      pAuthorizationTime[4] = pCode[15];
      pProgram[2] = ~pCode[16];
      pAuthorizationTime[2] = ~pCode[17];
      pAuthorizationTime[6] = ~pCode[18];
      pExpireTime[3] = ~pCode[19];
      pProgram[1] = ~pCode[20];
      pExpireTime[1] = ~pCode[21];
      pExpireTime[6] = ~pCode[22];
      pExpireTime[4] = pCode[23];

      memcpy(&(usbinfoData->Serial), pDrvSerial, sizeof(DWORD));
      memcpy(&ftAuthorizationTime, pAuthorizationTime, sizeof(FILETIME));
      memcpy(&ftExpireTime, pExpireTime, sizeof(FILETIME));
      memcpy(&(usbinfoData->Program), pProgram, sizeof(unsigned int));

      usbinfoData->SetAuthorizationTimeFromFileTime(ftAuthorizationTime);
      usbinfoData->SetExpireTimeFromFileTime(ftExpireTime);

      bReturn = true;
    }
  }
  catch (...) {
    return false;
  }

  return bReturn;
}
//---------------------------------------------------------------------------
int __fastcall TUSBLock::LoadFromDataFile(String strFileName, int nVersion, unsigned short nIVKeyIndex, BYTE *pIVKey)
{
	// Key Data File의 특정 위치의 키 데이터를 로드한다 (IVKey)
	HANDLE hFile = NULL;
	DWORD dwRead;
	int nFileVersion; // 처음 시작 버전은 100

	// 읽기 전용으로만 읽으며, 읽기 전용이고 숨겨진 파일도 읽을 수 있도록 한다.
	if ((hFile = CreateFile(strFileName.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING
											, FILE_ATTRIBUTE_HIDDEN	| FILE_ATTRIBUTE_READONLY | FILE_FLAG_WRITE_THROUGH, NULL)) == INVALID_HANDLE_VALUE) {
    goto fail;
  }

  // Version Check
  if (!ReadFile(hFile, &nFileVersion, sizeof(int), &dwRead, NULL)) goto fail;

  if (nFileVersion == nVersion) {
    if (SetFilePointer(hFile, nIVKeyIndex+sizeof(int), NULL, FILE_BEGIN)== 0xFFFFFFFF) goto fail; // sizeof(int)를 더하는 이유는 nFileVersion 때문
    if (!ReadFile(hFile, pIVKey, sizeof(BYTE)*SEED_BLOCK_LEN, &dwRead, NULL)) goto fail; // IVKey
  }

  if (hFile) CloseHandle(hFile);
  hFile = NULL;


  return nFileVersion;


fail:

  if (hFile) CloseHandle(hFile);
  hFile = NULL;
  return nFileVersion;
}
//---------------------------------------------------------------------------
/*
int __fastcall TUSBLock::SaveToDataFile(AnsiString strFileName, int nVersion)
{
  // Key Data를 생성 후 파일로 저장한다
  HANDLE hFile = NULL;
  DWORD dwWrite;
  BYTE KeyData[SEED_BLOCK_LEN];

  // 항상 새로만들며, 숨김 파일로 만든다
  if ((hFile = CreateFile(strFileName.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS
                      , FILE_ATTRIBUTE_HIDDEN	| FILE_FLAG_WRITE_THROUGH, NULL)) == INVALID_HANDLE_VALUE) {
    goto fail;
  }

  if (!WriteFile(hFile, &nVersion, sizeof(int), &dwWrite, NULL)) goto fail;  // Key 파일 버전

  randomize();  // 랜덤

  for (int i = 0; i < 4096; i++) {
    memset(KeyData, 0, sizeof(BYTE)*SEED_BLOCK_LEN);
    for (int j = 0; j < SEED_BLOCK_LEN; j++) {
      KeyData[j] = (BYTE)random(255); // 랜덤값 생성
    }

    if (!WriteFile(hFile, KeyData, sizeof(BYTE)*SEED_BLOCK_LEN, &dwWrite, NULL)) goto fail;  // 65536개의 Key를 저장한다
  }

  if (hFile) CloseHandle(hFile);
  hFile = NULL;

  return true;


fail:

  if (hFile) CloseHandle(hFile);
  hFile = NULL;
  return false;
}
*/
//---------------------------------------------------------------------------
int __fastcall TUSBLock::LoadFromKeyFile(String strUSBRoot, TUSBInformation *usbinfoData)
{
	// USB로부터 Key 파일 로드 후 복호화하여 USB 정보를 얻는다
	String strKeyFileName, strDataFileName;
	HANDLE hFile = NULL;
	DWORD dwRead;
	int nVersion = 0, nDataSize = 0;
	unsigned short nKeyFileIndex = 0;
	BYTE *pEncodedData = NULL, *pData = NULL;

	strDataFileName = strUSBRoot + "\\USB.dat"; // USB에 있는 Key Data 파일
	strKeyFileName = strUSBRoot + "\\USB.key";  // USB에 있는 암호화된 Key 파일

	if (FileExists(strKeyFileName) && FileExists(strDataFileName)) {  // 두 개 파일이 모두 존재하는지 확인
		// "USB.key" 파일을 읽기 전용으로만 읽으며, 읽기 전용이고 숨겨진 파일도 읽을 수 있도록 한다
		if ((hFile = CreateFile(strKeyFileName.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING
			, FILE_ATTRIBUTE_HIDDEN	| FILE_ATTRIBUTE_READONLY | FILE_FLAG_WRITE_THROUGH, NULL)) == INVALID_HANDLE_VALUE) goto fail;

    // 각종 Key 데이터 로드
    if (!ReadFile(hFile, &nVersion, sizeof(int), &dwRead, NULL)) goto fail;                 // Version
    if (!ReadFile(hFile, &nKeyFileIndex, sizeof(unsigned short), &dwRead, NULL)) goto fail; // Key Data File Index
    if (!ReadFile(hFile, &nDataSize, sizeof(int), &dwRead, NULL)) goto fail;                // Data Size
    pEncodedData = new BYTE[nDataSize]; // 복호화될 크기 만큼
    if (!ReadFile(hFile, pEncodedData, sizeof(BYTE)*nDataSize, &dwRead, NULL)) goto fail;    // Data Read

    pData = new BYTE[BLOCK_DATA_SIZE];
    if (SeedDecode(strDataFileName, nVersion, pEncodedData, nDataSize, &pData, nKeyFileIndex) < 0) goto fail; // Seed 복호화
    if (MixDecode(pData, usbinfoData) == false) goto fail;                                 // Mix 복호화

    // 체크 시간
    if (!ReadFile(hFile, &usbinfoData->CheckTime, sizeof(SYSTEMTIME), &dwRead, NULL)) goto fail;    // Check Time Read    

    // 복호화 완료
    usbinfoData->Lock = true;
    usbinfoData->KeyVersion = nVersion;

    if (hFile) CloseHandle(hFile);
  }
  else {
    goto fail;
  }

  if (pEncodedData) delete []pEncodedData;
  if (pData) delete []pData;

  pEncodedData = NULL;
  pData = NULL;
  hFile = NULL;


  return nVersion;


fail:

  memset(usbinfoData, 0, sizeof(TUSBInformation));
  if (hFile) CloseHandle(hFile);
  if (pEncodedData) delete []pEncodedData;
  if (pData) delete []pData;

  pEncodedData = NULL;
  pData = NULL;
  hFile = NULL;
  return nVersion;
}
//---------------------------------------------------------------------------
bool __fastcall TUSBLock::SaveCheckTimeToKeyFile(String strUSBRoot)
{
	// Program의 마지막 실행 시간을 기록한다
	String strKeyFileName;
	HANDLE hFile = NULL;
	DWORD dwRead = 0, dwWrite = 0;
	int nDataSize = 0;
	SYSTEMTIME stCurrent;

	strKeyFileName = strUSBRoot + "\\USB.key";  // USB에 있는 암호화된 Key 파일

	if (FileExists(strKeyFileName)) {  // 두 개 파일이 모두 존재하는지 확인
		// "USB.key" 파일을 읽기/쓰기로 읽으며, 읽기 전용이고 숨겨진 파일도 읽을 수 있도록 한다
		if ((hFile = CreateFile(strKeyFileName.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING
			, FILE_ATTRIBUTE_HIDDEN	| FILE_ATTRIBUTE_READONLY | FILE_FLAG_WRITE_THROUGH, NULL)) == INVALID_HANDLE_VALUE) goto fail;

    // 각종 Key 데이터 로드
    // nVersion, nKeyFileIndex 만큼 건너 띔
    SetFilePointer(hFile, sizeof(int)+sizeof(unsigned short), 0, FILE_BEGIN);
		if (!ReadFile(hFile, &nDataSize, sizeof(int), &dwRead, NULL)) goto fail;                // Data Size
		SetFilePointer(hFile, nDataSize, 0, FILE_CURRENT);
    GetSystemTime(&stCurrent);                                                              // 현재 시간
		if (!WriteFile(hFile, &stCurrent, sizeof(SYSTEMTIME), &dwWrite, NULL)) goto fail;  // Check Time Write
		if (hFile) CloseHandle(hFile);
	}

	hFile = NULL;

	return true;

fail:
	if (hFile) CloseHandle(hFile);
	hFile = NULL;
	return false;
}
//---------------------------------------------------------------------------
/*
bool __fastcall TUSBLock::SaveToKeyFile(AnsiString strProgramRoot, AnsiString strUSBRootName, TUSBInformation *usbinfoData)
{
  // USB의 정보를 암호화하여 Key 파일을 저장하고, Key Data 파일도 저장한다
	AnsiString strDrv, strKeyFileName, strDataFileName;
  HANDLE hFile = NULL;
  DWORD dwWrite;
  int nDataSize = 0;
  unsigned short nKeyFileIndex = 0;
  char pDrvRoot[4] = "C:\\";
  BYTE *pEncodedData = NULL, *pData = NULL;

  // USB Serial Number
  strDrv = strUSBRootName + "\\";
  strncpy(pDrvRoot, strDrv.c_str(), 1);
  GetVolumeInformation(pDrvRoot, NULL, NULL, &(usbinfoData->Serial), NULL, NULL, NULL, 0);

  strDataFileName = strProgramRoot + "\\KeyData\\" + IntToStr(usbinfoData->KeyVersion) + ".dat";  // Key Data 파일
  strKeyFileName = strUSBRootName + "\\USB.key";                                                  // USB에 있는 암호화하여 저장할 Key 파일

  if (FileExists(strDataFileName)) {  // Key Data 파일이 존재할 경우만 만든다
    // 항상 새로만들며, 숨김 파일로 만든다
    if ((hFile = CreateFile(strKeyFileName.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS
      , FILE_ATTRIBUTE_HIDDEN	| FILE_FLAG_WRITE_THROUGH, NULL)) == INVALID_HANDLE_VALUE) goto fail;

    // Version Check
    if (!WriteFile(hFile, &(usbinfoData->KeyVersion), sizeof(int), &dwWrite, NULL)) goto fail;  // Version

    randomize();  // 랜덤
    nKeyFileIndex = (unsigned short)random(0xFFFF-SEED_BLOCK_LEN-sizeof(int));                  // Key File Index

    pData = new BYTE[BLOCK_DATA_SIZE];
    if (MixEncode(pData, usbinfoData) == false) goto fail;                                      // Mix 암호화
    nDataSize = SeedEncode(strDataFileName, usbinfoData->KeyVersion, pData, BLOCK_DATA_SIZE, &pEncodedData, nKeyFileIndex); // Seed 암호화
    if (nDataSize < 0) goto fail;

    if (!WriteFile(hFile, &nKeyFileIndex, sizeof(unsigned short), &dwWrite, NULL)) goto fail;   // Key Data File Index
    if (!WriteFile(hFile, &nDataSize, sizeof(int), &dwWrite, NULL)) goto fail;                  // Data Size
    if (!WriteFile(hFile, pEncodedData, sizeof(BYTE)*nDataSize, &dwWrite, NULL)) goto fail;     // Data Write

    usbinfoData->Lock = true;

    // USB로 Key Data 파일 복사 (기존 파일 존재 시 덮어쓰기)
    if (CopyFile(strDataFileName.c_str(), AnsiString(strUSBRootName + "\\USB.dat").c_str(), FALSE) == FALSE) goto fail;

    if (hFile) CloseHandle(hFile);
  }

  if (pEncodedData) delete []pEncodedData;
  if (pData) delete []pData;

  pEncodedData = NULL;
  pData = NULL;
  hFile = NULL;

  return true;

fail:

  if (hFile) CloseHandle(hFile);
  if (pEncodedData) delete []pEncodedData;
  if (pData) delete []pData;

  pEncodedData = NULL;
  pData = NULL;
  hFile = NULL;
  return false;
}
*/
//---------------------------------------------------------------------------
/*
DWORD __fastcall TUSBLock::CheckUSB(AnsiString strUSBRoot, TUSBInformation *usbinfoData)
{
  // USB 정보 조사
	AnsiString strDrv;
  char pDrvRoot[4] = "C:\\";
  DWORD dwSerial = 0;

  strDrv = ExtractFileDrive(strUSBRoot);
  strncpy(pDrvRoot, strDrv.c_str(), 1);

  if (GetDriveType(pDrvRoot) == DRIVE_REMOVABLE) {  // 이동식 저장 디스크인지 조사
    GetVolumeInformation(pDrvRoot, NULL, NULL, &dwSerial, NULL, NULL, NULL, 0); // USB Serial Number
    LoadFromKeyFile(strDrv, usbinfoData);                                       // USB로부터 Key 파일 로드 후 복호화하여 USB 정보를 얻는다
  }

  return dwSerial;

fail:
  memset(usbinfoData, 0, sizeof(TUSBInformation));

  return 0;
}
*/
//---------------------------------------------------------------------------
bool __fastcall TUSBLock::Check(String strUSBRoot, int nProgram, bool bClear)
{
	// 사용한 가능한 인증 상태인지 체크
	String strDrv, strFileName;
	TUSBInformation *usbinfoData = NULL;
	Char pDrvRoot[4] = L"C:\\";
	DWORD dwSerial = 0;
	SYSTEMTIME stNow;
	TDateTime dtNow;
	bool bReturn = false;

	strDrv = ExtractFileDrive(strUSBRoot);
	_tcsncpy(pDrvRoot, strDrv.c_str(), 1);

	if (DirectoryExists(strDrv) && GetDriveType(pDrvRoot) == DRIVE_REMOVABLE) {  // 이동식 저장 디스크인지 조사
    GetVolumeInformation(pDrvRoot, NULL, NULL, &dwSerial, NULL, NULL, NULL, 0); // USB Serial Number
    usbinfoData = new TUSBInformation;
		if (LoadFromKeyFile(strDrv, usbinfoData)) { // USB로부터 Key 파일 로드 후 복호화하여 USB 정보를 얻는다

			// LocalTime이 아닌 표준시를 구하기 위해 TDateTime::Now()가 아닌 GetSystemTime()을 사용하였다
			GetSystemTime(&stNow);
			dtNow = SystemTimeToDateTime(stNow);
			// USB Drive의 Serial Number가 같은지 비교하고, 프로그램이 포함되어있는지 비교하며
      // 인증일자 이후이고 만료 기간 이전인지 체크한다.
      if (dwSerial == usbinfoData->Serial
        && (usbinfoData->Program & nProgram) > 0
        && CompareDateTime(dtNow, usbinfoData->GetAuthorizationTimeToDateTime()) >= 0
        && CompareDateTime(usbinfoData->GetExpireTimeToDateTime(), dtNow) >= 0
        && CompareDateTime(dtNow, usbinfoData->GetCheckTimeToDateTime()) >= 0) {
        bReturn = true;
      }
    }
  }

  if (!bReturn && bClear) { // 인증 조건이 맞지 않아 삭제해야 하는 경우
    strFileName = strDrv + "\\USB.dat";
    if (FileExists(strFileName.c_str())){
      DeleteFile(strFileName.c_str());
    }
    strFileName = strDrv + "\\USB.key";
    if (FileExists(strFileName.c_str())){
      DeleteFile(strFileName.c_str());
    }
  }
  else {
    SaveCheckTimeToKeyFile(strUSBRoot); // 현재 실행 시간을 기록
  }  

  if (usbinfoData) delete usbinfoData;
  usbinfoData = NULL;

  return bReturn;
}
//---------------------------------------------------------------------------