//---------------------------------------------------------------------------
#pragma hdrstop
#include "TexLock.h"
//---------------------------------------------------------------------------
#include "seed.h"
#include "CRC.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
BYTE *pMessage01, *pMessage02, *pMessage03, *pMessage04, *pMessage05, *pMessage06;  // ¸Þ½ÃÁö¸¦ º¹È£È­Çؼ­ ´ãÀ» Àü¿ª º¯¼ö
//---------------------------------------------------------------------------
// ½ÇÇà ÁßÀÎ ÇÁ·Î¼¼½ºÀÇ ¸ñ·ÏÀ» ¾ò¾î¿Â´Ù
bool CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lpParam)
{
  HANDLE hSnapshot = NULL;
  HANDLE hProcess = NULL;
  PROCESSENTRY32 pe32;
  bool bContinue = false;
  DWORD dwPID;
  char *WindowTitle = NULL;
  char *WindowClass = NULL;
  AnsiString strWindowTitle;
  //AnsiString strWindowClass;
  TStringList *TitleList = 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];
    //WindowClass = new char[256];

    GetWindowText(hWnd, WindowTitle, 255);  // ÇÁ·Î¼¼½ºÀÇ Ä¸¼ÇÀ» ¾ò¾î¿Â´Ù
    //GetClassName(hWnd, WindowClass, 255);   // ÇÁ·Î¼¼½ºÀÇ Å¬·¡½º¸íÀ» ¾ò¾î¿Â´Ù

    strWindowTitle = WindowTitle;
    //strWindowClass = AnsiString(WindowClass);

    strWindowTitle = strWindowTitle.UpperCase();
    //strWindowClass = strWindowClass.UpperCase();

    bFind = false;
    TitleList = (TStringList *)lpParam;
    for (int i = 0; i < TitleList->Count; i++) {
      if (strWindowTitle.Pos(TitleList->Strings[i].UpperCase()) > 0) {
        bFind = true;
        break;
      }
    }

    if (WindowTitle) { delete []WindowTitle; WindowTitle = NULL; }
    if (WindowClass) { delete []WindowClass; WindowClass = 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 TTexLock::TTexLock(TApplication *App, AnsiString strPath, unsigned int nDoubleLock)
{
  HANDLE hFile = NULL;
  AnsiString strLockFileName;
  WIN32_FIND_DATA FileData;
  BYTE *pMessage = NULL, *pEncode = NULL, *pDecode = NULL;
  DWORD dwMessageSize;
  unsigned short nIVKeyIndex;
  int nEncodeSize;

  Application = App;

  pAuthorizationKey = NULL;
  pVerificationKey = NULL;
  dwAuthorizationKeySize = 0;
  dwVerificationKeySize = 0;
  KeyVersion = 1;
  FileVersion = 100;

  FullPath = strPath;
  DoubleLock = nDoubleLock;


  // Message º¹È£È­
  // (µÚ¿¡ 2Byte : IV Key) Index·Î »ç¿ë)
  dwMessageSize = BitShiftStringToCode(4, TEXLOCK_MESSAGE01, &pMessage);
  nIVKeyIndex = ((pMessage[dwMessageSize-2] & 0x00FF) << 8) | (pMessage[dwMessageSize-1] & 0x00FF);
  pEncode = new BYTE[dwMessageSize-2];
  memcpy(pEncode, pMessage, dwMessageSize-2);
  nEncodeSize = DeCode(pEncode, dwMessageSize-2, &pDecode, nIVKeyIndex);
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  pMessage01 = new BYTE[nEncodeSize+1];
  memset(pMessage01, '\0', sizeof(BYTE)*nEncodeSize+1);
  memcpy(pMessage01, pDecode, nEncodeSize);

  dwMessageSize = BitShiftStringToCode(4, TEXLOCK_MESSAGE02, &pMessage);
  nIVKeyIndex = ((pMessage[dwMessageSize-2] & 0x00FF) << 8) | (pMessage[dwMessageSize-1] & 0x00FF);
  pEncode = new BYTE[dwMessageSize-2];
  memcpy(pEncode, pMessage, dwMessageSize-2);
  nEncodeSize = DeCode(pEncode, dwMessageSize-2, &pDecode, nIVKeyIndex);
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  pMessage02 = new BYTE[nEncodeSize+1];
  memset(pMessage02, '\0', sizeof(BYTE)*nEncodeSize+1);
  memcpy(pMessage02, pDecode, nEncodeSize);

  dwMessageSize = BitShiftStringToCode(4, TEXLOCK_MESSAGE03, &pMessage);
  nIVKeyIndex = ((pMessage[dwMessageSize-2] & 0x00FF) << 8) | (pMessage[dwMessageSize-1] & 0x00FF);
  pEncode = new BYTE[dwMessageSize-2];
  memcpy(pEncode, pMessage, dwMessageSize-2);
  nEncodeSize = DeCode(pEncode, dwMessageSize-2, &pDecode, nIVKeyIndex);
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  pMessage03 = new BYTE[nEncodeSize+1];
  memset(pMessage03, '\0', sizeof(BYTE)*nEncodeSize+1);
  memcpy(pMessage03, pDecode, nEncodeSize);

  dwMessageSize = BitShiftStringToCode(4, TEXLOCK_MESSAGE04, &pMessage);
  nIVKeyIndex = ((pMessage[dwMessageSize-2] & 0x00FF) << 8) | (pMessage[dwMessageSize-1] & 0x00FF);
  pEncode = new BYTE[dwMessageSize-2];
  memcpy(pEncode, pMessage, dwMessageSize-2);
  nEncodeSize = DeCode(pEncode, dwMessageSize-2, &pDecode, nIVKeyIndex);
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  pMessage04 = new BYTE[nEncodeSize+1];
  memset(pMessage04, '\0', sizeof(BYTE)*nEncodeSize+1);
  memcpy(pMessage04, pDecode, nEncodeSize);

  dwMessageSize = BitShiftStringToCode(4, TEXLOCK_MESSAGE05, &pMessage);
  nIVKeyIndex = ((pMessage[dwMessageSize-2] & 0x00FF) << 8) | (pMessage[dwMessageSize-1] & 0x00FF);
  pEncode = new BYTE[dwMessageSize-2];
  memcpy(pEncode, pMessage, dwMessageSize-2);
  nEncodeSize = DeCode(pEncode, dwMessageSize-2, &pDecode, nIVKeyIndex);
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  pMessage05 = new BYTE[nEncodeSize+1];
  memset(pMessage05, '\0', sizeof(BYTE)*nEncodeSize+1);
  memcpy(pMessage05, pDecode, nEncodeSize);

  dwMessageSize = BitShiftStringToCode(4, TEXLOCK_MESSAGE06, &pMessage);
  nIVKeyIndex = ((pMessage[dwMessageSize-2] & 0x00FF) << 8) | (pMessage[dwMessageSize-1] & 0x00FF);
  pEncode = new BYTE[dwMessageSize-2];
  memcpy(pEncode, pMessage, dwMessageSize-2);
  nEncodeSize = DeCode(pEncode, dwMessageSize-2, &pDecode, nIVKeyIndex);
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  pMessage06 = new BYTE[nEncodeSize+1];
  memset(pMessage06, '\0', sizeof(BYTE)*nEncodeSize+1);
  memcpy(pMessage06, pDecode, nEncodeSize);

  if (pMessage) { delete []pMessage; pMessage = NULL; }
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  if (pDecode) { delete []pDecode; pDecode = NULL; }

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  if (FileExists(strLockFileName) == false) {
    hFile = CreateFile(strLockFileName.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS
                      , FILE_ATTRIBUTE_HIDDEN, NULL);

    GetFileTime(hFile, &CreateTime, &AccessTime, &WriteTime);
    if (hFile) { CloseHandle(hFile); hFile = NULL; }
  }
  else {
    hFile = FindFirstFile(strLockFileName.c_str(), &FileData);
    CreateTime = FileData.ftCreationTime;
    AccessTime = FileData.ftLastAccessTime;
    WriteTime = FileData.ftLastWriteTime;
    FindClose(hFile);
  }

  // Reverse Engineering ToolÀÌ °¨ÁöµÇ¸é ÇÁ·Î±×·¥ Á¾·á
  CheckingReverseEngineeringTools();
}
//---------------------------------------------------------------------------
__fastcall TTexLock::~TTexLock()
{
  HANDLE hFile = NULL;
  AnsiString strLockFileName;

  if (pMessage01) { delete []pMessage01; pMessage01 = NULL; }
  if (pMessage02) { delete []pMessage02; pMessage02 = NULL; }
  if (pMessage03) { delete []pMessage03; pMessage03 = NULL; }
  if (pMessage04) { delete []pMessage04; pMessage04 = NULL; }
  if (pMessage05) { delete []pMessage05; pMessage05 = NULL; }
  if (pMessage06) { delete []pMessage06; pMessage06 = NULL; }

  if (pAuthorizationKey) { delete []pAuthorizationKey; pAuthorizationKey = NULL; }
  if (pVerificationKey) { delete []pVerificationKey; pVerificationKey = NULL; }

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  if (FileExists(strLockFileName)) {
    hFile = CreateFile(strLockFileName.c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING
                      , FILE_ATTRIBUTE_HIDDEN, NULL);

    SetFileTime(hFile, &CreateTime, &AccessTime, &WriteTime);
    if (hFile) { CloseHandle(hFile); hFile = NULL; }
  }
}
//---------------------------------------------------------------------------
void __fastcall TTexLock::KillReverseEngineeringTool(TStringList *strExcutionNameList)
{
  HANDLE hSnapshot = NULL;
  HANDLE hProcess = NULL;
  PROCESSENTRY32 pe32;
  bool bContinue = false;
  AnsiString strWindowsCaption;
  bool bFind;
  DWORD ProcessID = 0;

  pe32.dwSize = sizeof(PROCESSENTRY32);

  // ÇÁ·Î±×·¥ÀÇ À̸§°ú °°À» °æ¿ì Á¾·á
  if (strExcutionNameList) {
    hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    bContinue = Process32First(hSnapshot, &pe32);
    while (bContinue) {
      strWindowsCaption = pe32.szExeFile;
      strWindowsCaption = strWindowsCaption.UpperCase();

      bFind = false;
      for (int i = 0; i < strExcutionNameList->Count; i++) {
        if (strWindowsCaption.Pos(strExcutionNameList->Strings[i].UpperCase()) > 0) {
          bFind = true;
          break;
        }
      }
      if (bFind) {
        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; }
  }
}
//---------------------------------------------------------------------------
int __fastcall TTexLock::LoadFromKeyFile(unsigned short nIVKeyIndex, BYTE *pIVKey)
{
  HANDLE hFile = NULL;
  DWORD dwRead;
  AnsiString strKeyFileName;
  int nVersion = 0;

  // IVKey
  strKeyFileName = ExtractFilePath(FullPath) + "Key.dat";
  if ((hFile = CreateFile(strKeyFileName.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING
                      , FILE_ATTRIBUTE_HIDDEN	| FILE_ATTRIBUTE_READONLY, NULL)) == INVALID_HANDLE_VALUE) {
    goto fail;
  }

  // Version Check
  if (!ReadFile(hFile, &nVersion, sizeof(int), &dwRead, NULL)) goto fail;

  if (FileVersion == nVersion) {
    if (SetFilePointer(hFile, nIVKeyIndex+sizeof(int), NULL, FILE_BEGIN)== 0xFFFFFFFF) goto fail;
    if (!ReadFile(hFile, pIVKey, sizeof(BYTE)*SEED_BLOCK_LEN, &dwRead, NULL)) goto fail; // IVKey
  }

  if (hFile) { CloseHandle(hFile); hFile = NULL; }


  return 0;


fail:

  if (hFile) { CloseHandle(hFile); hFile = NULL; }
  return nVersion;
}
//---------------------------------------------------------------------------
int __fastcall TTexLock::DeCode(BYTE *pDecode, DWORD dwDecLen, BYTE **pEncode, unsigned short nIVKeyIndex)
{
  DWORD dwDeIndex, dwEncLen;
  BYTE *pAccumData = NULL, *pSwapData = NULL;
  BYTE SrcData[1024+32], DstData[1024+32];
  BYTE ProgramKey[SEED_USER_KEY_LEN] = "YoungWooCnIProg";
  BYTE IVKey[SEED_BLOCK_LEN];
  RET_VAL	ret;
  SEED_ALG_INFO AlgInfo;
  int nAccumNum;

  if (LoadFromKeyFile(nIVKeyIndex, IVKey) != 0) {
    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;
}
//---------------------------------------------------------------------------
int __fastcall TTexLock::CharNumToIntNum(char cNumber)
{
  int nNumber = 0;

  if ('A' <= cNumber && cNumber <= 'Z') {
    nNumber = cNumber - 'A' + 10;
  }
  else if ('a' <= cNumber && cNumber <= 'z') {
    nNumber = cNumber - 'a' + 10;
  }
  else if ('0' <= cNumber && cNumber <= '9') {
    nNumber = cNumber - '0';
  }

  return nNumber;
}
//---------------------------------------------------------------------------
AnsiString __fastcall TTexLock::CodeToAnsiString(BYTE *pCode, int nLength, bool bSpace)
{
  AnsiString strKeyCode;
  int nCount = 0;

  while (nCount < nLength) {
    if (bSpace && (nCount != 0 && (nCount % 4) == 0)) {
      strKeyCode += " ";
    }
    switch (pCode[nCount]) {
      case 0x00:
      case 0x01:
      case 0x02:
      case 0x03:
      case 0x04:
      case 0x05:
      case 0x06:
      case 0x07:
      case 0x08:
      case 0x09:
        strKeyCode += IntToStr((int)pCode[nCount]);
        break;
      case 0x0A:
        strKeyCode += "A";
        break;
      case 0x0B:
        strKeyCode += "B";
        break;
      case 0x0C:
        strKeyCode += "C";
        break;
      case 0x0D:
        strKeyCode += "D";
        break;
      case 0x0E:
        strKeyCode += "E";
        break;
      case 0x0F:
        strKeyCode += "F";
        break;
    }
    nCount++;
  }

  return strKeyCode;
}
//---------------------------------------------------------------------------
int __fastcall TTexLock::AnsiStringToCode(AnsiString strCode, BYTE **pCode)
{
  int nLength = strCode.Length();
  int nCount = 0;

  if (strCode.IsEmpty()) return -1;

  strCode = strCode.UpperCase();

  if (*pCode) { delete [](*pCode); *pCode = NULL; }

  *pCode = new BYTE[nLength];
  memset(*pCode, 0, sizeof(BYTE)*nLength);

  while (nCount < nLength) {
    if ('0' <= strCode.c_str()[nCount] && strCode.c_str()[nCount] <= '9') {
      *((*pCode)+nCount) = (strCode.c_str()[nCount] - '0');   // '0' => 0x00
    }
    else if ('A' <= strCode.c_str()[nCount] && strCode.c_str()[nCount] <= 'Z') {
      *((*pCode)+nCount) = (strCode.c_str()[nCount] - 0x37);  // 'A' => 0x0A
    }
    nCount++;
  }

  return nLength;
}
//---------------------------------------------------------------------------
int __fastcall TTexLock::BitShiftStringToCode(BYTE cBit, AnsiString strShifted, BYTE **pCode)
{
  BYTE cShiftMask, *pShiftString = NULL, *pPointer = NULL;
  int nByteCount, nLength, nPreInc, nCount;

  cShiftMask = 0;
  nCount = 0;
  while (nCount < cBit) {
    cShiftMask <<= 1;
    cShiftMask |= 1;
    nCount++;
  }

  if (strShifted.IsEmpty() || AnsiStringToCode(strShifted, &pShiftString) < 0) return -1;

  nLength = strShifted.Length();
  nByteCount = (sizeof(BYTE)*nLength*cBit+7)/8;

  if (*pCode) { delete [](*pCode); }
  *pCode = new BYTE[nByteCount];
  memset(*pCode, 0, sizeof(BYTE)*nByteCount);

  nCount = 0;
  pPointer = *pCode;
  nPreInc = 0;
  while (nCount < nLength) {
    if (nPreInc != (cBit*nCount/8)) {
      nPreInc = cBit*nCount/8;
      pPointer = pPointer+1;
    }
    *pPointer <<= ((cBit*nCount)%8);
    *pPointer |= (pShiftString[nCount] & cShiftMask);
    nCount++;
  }

  if (pShiftString) { delete []pShiftString; pShiftString = NULL; }

  return nByteCount;
}
//---------------------------------------------------------------------------
AnsiString __fastcall TTexLock::MakeCRC(BYTE **pCode, DWORD *dwCodeSize)
{
  unsigned short nCrc16;
  BYTE CRC16[5];
  AnsiString strCRC;

  memset(CRC16, 0, sizeof(BYTE)*5);

  nCrc16 = 0;
  nCrc16 = Crc16(*pCode, *dwCodeSize);

  // ½ÇÁ¦·Î ¼ø¼­°¡ ¿ª¼øÀÌ µÇ¾ßÇÏÁö¸¸ ½±°Ô ÁüÀÛÇÒ ¼ö ¾øµµ·Ï ÀÌ·¸°Ô µÐ´Ù
  CRC16[0] = nCrc16 & 0x0F;
  CRC16[1] = (nCrc16 >> 4) & 0x0F;
  CRC16[2] = (nCrc16 >> 8) & 0x0F;
  CRC16[3] = (nCrc16 >> 12) & 0x0F;
  CRC16[4] = '\0';

  strCRC = CodeToAnsiString(CRC16, 4, false);

  return strCRC;
}
//---------------------------------------------------------------------------
AnsiString __fastcall TTexLock::MakeCombinationKey(BYTE **pCombinationKey, DWORD *dwCombinationKeySize)
{
  AnsiString strKeyCode;
  HANDLE hFile = NULL;
  DWORD dwVolumeSerialNumber;
  AnsiString strDrv;
  AnsiString strLockFileName;
  unsigned int nDoubleLock;
  BYTE *KeyCode = NULL;
  int nCount;

  strDrv = ExtractFileDrive(FullPath) + "\\";

  // ½ÇÇàÆÄÀÏ°ú °°ÀÌ ÀÖ´Â µð½ºÅ©µå¶óÀ̺êÀÇ ¼Ó¼ºÀ» ±¸ÇÔ (¹Ýµå½Ã Çϵåµð½ºÅ© µå¶óÀ̺꿡¼­¸¸ ±¸µ¿)
  switch (GetDriveType(strDrv.c_str())) {
    case DRIVE_FIXED:	// The disk cannot be removed from the drive.
      break;
    case 0: //The drive type cannot be determined.
    case 1:	// The root directory does not exist.
    case DRIVE_REMOVABLE: //	The drive can be removed from the drive.
    case DRIVE_REMOTE: //	The drive is a remote (network) drive.
    case DRIVE_CDROM: //	The drive is a CD-ROM drive.
    case DRIVE_RAMDISK: //	The drive is a RAM disk.
      Application->MessageBox(pMessage06, pMessage01, MB_ICONSTOP);
      goto fail;
  }

  // ÇÁ·Î±×·¥ÀÌ ¼³Ä¡µÇ¾î ÀÖ´Â DriveÀÇ Hard Disk Serial Number¸¦ ¾ò¾î¿È
  GetVolumeInformation(strDrv.c_str(), NULL, 0, &dwVolumeSerialNumber, NULL, NULL, NULL, 0);

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  if ((hFile = CreateFile(strLockFileName.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING
                      , FILE_ATTRIBUTE_HIDDEN, NULL)) == INVALID_HANDLE_VALUE) {
    goto fail;
  }

  nDoubleLock = DoubleLock;

  // ¹æ¹ý 1.
  /*
  // KeyCode ¾Ïȣȭ (15¹ÙÀÌÆ®¸¦ ÃÊ°úÇÒ °æ¿ì, CryptCode°¡ µÎ ¹è·Î ´Ã¾î³ª±â¶§¹®¿¡ 15¹ÙÀÌÆ®¸¸ »ç¿ëÇÑ´Ù)
  // S : HDD Serial Number
  // V : Key Version
  // D : DoubleLockNumber
  // [] : Position
  //
  //   0     1     2    3    4     5    6    7     8    9    10     11   12   13   14
  //  D[2] ~S[7] ~D[5] D[1] S[1] ~D[4] S[6] V[0] S[0] ~S[5] ~S[4] ~D[3] S[2] ~D[0] S[3]
  KeyCode = new BYTE[COMBINATIONKEY_LENGTH];

  KeyCode[0] = ((nDoubleLock >> 8) & 0x0F);
  KeyCode[1] = ((~dwVolumeSerialNumber >> 28) & 0x0F);
  KeyCode[2] = ((~nDoubleLock >> 20) & 0x0F);
  KeyCode[3] = ((nDoubleLock >> 4) & 0x0F);
  KeyCode[4] = ((dwVolumeSerialNumber >> 4) & 0x0F);
  KeyCode[5] = ((~nDoubleLock >> 16) & 0x0F);
  KeyCode[6] = ((dwVolumeSerialNumber >> 24) & 0x0F);
  KeyCode[7] = (KeyVersion & 0x0F);
  KeyCode[8] = (dwVolumeSerialNumber & 0x0F);
  KeyCode[9] = ((~dwVolumeSerialNumber >> 20) & 0x0F);
  KeyCode[10] = ((~dwVolumeSerialNumber >> 16) & 0x0F);
  KeyCode[11] = ((~nDoubleLock >> 12) & 0x0F);
  KeyCode[12] = ((dwVolumeSerialNumber >> 8) & 0x0F);
  KeyCode[13] = ((~nDoubleLock) & 0x0F);
  KeyCode[14] = ((dwVolumeSerialNumber >> 12) & 0x0F);
  */
  // ¹æ¹ý 2.
  // KeyCode ¾Ïȣȭ (15¹ÙÀÌÆ®¸¦ ÃÊ°úÇÒ °æ¿ì, CryptCode°¡ µÎ ¹è·Î ´Ã¾î³ª±â¶§¹®¿¡ 15¹ÙÀÌÆ®¸¸ »ç¿ëÇÑ´Ù)
  // S : HDD Serial Number
  // W : Write File Time
  // V : Key Version
  // D : DoubleLockNumber
  // [] : Position
  //
  //   0     1     2    3    4     5    6    7     8    9    10     11   12   13   14
  //  D[2] ~S[7] ~D[5] D[1] W[2] ~D[4] S[6] V[0] ~W[0] ~S[5] ~S[4] ~D[3] W[4] ~D[0] ~W[6]
  KeyCode = new BYTE[COMBINATIONKEY_LENGTH];

  KeyCode[0] = ((nDoubleLock >> 8) & 0x0F);
  KeyCode[1] = ((~dwVolumeSerialNumber >> 28) & 0x0F);
  KeyCode[2] = ((~nDoubleLock >> 20) & 0x0F);
  KeyCode[3] = ((nDoubleLock >> 4) & 0x0F);
  KeyCode[4] = ((WriteTime.dwLowDateTime >> 8) & 0x0F);
  KeyCode[5] = ((~nDoubleLock >> 16) & 0x0F);
  KeyCode[6] = ((dwVolumeSerialNumber >> 24) & 0x0F);
  KeyCode[7] = (KeyVersion & 0x0F);
  KeyCode[8] = (~WriteTime.dwLowDateTime & 0x0F);
  KeyCode[9] = ((~dwVolumeSerialNumber >> 20) & 0x0F);
  KeyCode[10] = ((~dwVolumeSerialNumber >> 16) & 0x0F);
  KeyCode[11] = ((~nDoubleLock >> 12) & 0x0F);
  KeyCode[12] = ((WriteTime.dwLowDateTime >> 16) & 0x0F);
  KeyCode[13] = ((~nDoubleLock) & 0x0F);
  KeyCode[14] = ((~WriteTime.dwLowDateTime >> 24) & 0x0F);

  if (pCombinationKey && dwCombinationKeySize) {
    if (*pCombinationKey) { delete [](*pCombinationKey); }
    *dwCombinationKeySize = COMBINATIONKEY_LENGTH;
    *pCombinationKey = new BYTE[(*dwCombinationKeySize)];
    // Á¶ÇÕÅ° ÀúÀå
    memcpy(*pCombinationKey, KeyCode, sizeof(BYTE)*(*dwCombinationKeySize));
  }

  strKeyCode = CodeToAnsiString(KeyCode, COMBINATIONKEY_LENGTH, true);

  if (hFile) { CloseHandle(hFile); hFile = NULL; }
  if (KeyCode) { delete []KeyCode; KeyCode = NULL; }

  return strKeyCode;

fail:
  if (hFile) { CloseHandle(hFile); hFile = NULL; }
  if (KeyCode) { delete []KeyCode; KeyCode = NULL; }

  return "";
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CheckFileTime(FILETIME ftCreateTime, FILETIME ftAccessTime, FILETIME ftWriteTime)
{
  // AccessTimeÀ¸·Î üũÇϰԵǸé Á¤¸» °­·ÂÇØÁöÁö¸¸,
  // V3 µî ¹é½Å/º¸¾È ÇÁ·Î±×·¥ÀÌ °Ë»çÀÇ ¸ñÀûÀ¸·Î Á¢±ÙÇßÀ» ¶§
  // AccessTimeÀÌ º¯°æµÇ¾î ´Ù½Ã ÀÎÁõ ¹Þ¾Æ¾ßÇÏ´Â °æ¿ì°¡ »ý±ä´Ù
  // AccessTimeÀº ÀÏ´Ü Ã¼Å©ÇÏÁö ¾Ê´Â °ÍÀ¸·Î ÇÑ´Ù.
  if (CreateTime.dwLowDateTime == ftCreateTime.dwLowDateTime
    /*&& AccessTime.dwLowDateTime == ftAccessTime.dwLowDateTime*/
    && WriteTime.dwLowDateTime == ftWriteTime.dwLowDateTime) {
    return true;
  }
  else {
    return false;
  }
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CheckWriteFileTime(FILETIME ftWriteTime)
{
  if ((WriteTime.dwLowDateTime & 0x0F0F0F0F) == (ftWriteTime.dwLowDateTime & 0x0F0F0F0F)) {
    return true;
  }
  else {
    return false;
  }
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CheckVolumeSerialNumber(DWORD dwVolSerialNum, bool bAll)
{
  DWORD dwVolumeSerialNumber;
  AnsiString strDrv;

  strDrv = ExtractFileDrive(FullPath) + "\\";

  // ½ÇÇàÆÄÀÏ°ú °°ÀÌ ÀÖ´Â µð½ºÅ©µå¶óÀ̺êÀÇ ¼Ó¼ºÀ» ±¸ÇÔ (¹Ýµå½Ã Çϵåµð½ºÅ© µå¶óÀ̺꿡¼­¸¸ ±¸µ¿)
  switch (GetDriveType(strDrv.c_str())) {
    case DRIVE_FIXED:	// The disk cannot be removed from the drive.
      break;
    case 0: //The drive type cannot be determined.
    case 1:	// The root directory does not exist.
    case DRIVE_REMOVABLE: //	The drive can be removed from the drive.
    case DRIVE_REMOTE: //	The drive is a remote (network) drive.
    case DRIVE_CDROM: //	The drive is a CD-ROM drive.
    case DRIVE_RAMDISK: //	The drive is a RAM disk.
      Application->MessageBox(pMessage06, pMessage01, MB_ICONSTOP);
      return false;
  }

  // ÇÁ·Î±×·¥ÀÌ ¼³Ä¡µÇ¾î ÀÖ´Â DriveÀÇ Hard Disk Serial Number¸¦ ¾ò¾î¿È
  GetVolumeInformation(strDrv.c_str(), NULL, 0, &dwVolumeSerialNumber, NULL, NULL, NULL, 0);

  if (bAll) {
    if (dwVolumeSerialNumber == dwVolSerialNum) {
      return true;
    }
    else {
      return false;
    }
  }
  else {
    if ((dwVolumeSerialNumber & 0xFFFF0000) == (dwVolSerialNum & 0xFFFF0000)) {
      return true;
    }
    else {
      return false;
    }
  }
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CheckProtectCardNumber(unsigned int nDBL)
{
  if ((nDBL & DoubleLock) == DoubleLock) {
    return true;
  }
  else {
    return false;
  }
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CompareCombinationKeyAndAuthorizationKey(AnsiString strAuthorizationKey)
{
  BYTE *pCombinationKey = NULL, *pEncode =  NULL, *pDecode = NULL, *pTemp = NULL;
  //BYTE cProgramKeyIndex, cIVKeyIndex;
  unsigned short nProgramKeyIndex, nIVKeyIndex;
  unsigned int nDoubleLock;
  DWORD dwCombinationKeySize, dwTempKeySize, dwCombiKeySize, dwVoulmeSerialNumber;
  FILETIME ftWriteFimeTime;
  BYTE cKeyVersion;
  int nEncodeSize;
  AnsiString strCombinationKey;
  int nCount, nIndex;
  bool bReturn = true;


  if (strAuthorizationKey.IsEmpty()) goto fail;

  // Á¶ÇÕÅ° »ý¼º
  MakeCombinationKey(&pCombinationKey, &dwCombinationKeySize);

  if (pCombinationKey && dwCombinationKeySize > 0) {
    // °ø¹éÁ¦°Å
    nIndex = 0;
    nCount = strAuthorizationKey.Length();
    while (nIndex < nCount) {
      if (strAuthorizationKey.c_str()[nIndex] == ' ') {
        strAuthorizationKey = strAuthorizationKey.SubString(1, nIndex) + strAuthorizationKey.SubString(nIndex+2, nCount-nIndex);
        nCount = strAuthorizationKey.Length();
        nIndex--;
      }
      nIndex++;
    }

    if (strAuthorizationKey.Length() != AUTHORIZATIONKEY_LENGTH) goto fail;

    strAuthorizationKey = strAuthorizationKey.UpperCase();

    // ÀÎÁõÅ° ÀúÀå (µÚ¿¡ 2Byte : IV Key) Index·Î »ç¿ë)
    dwAuthorizationKeySize = BitShiftStringToCode(4, strAuthorizationKey.c_str(), &pAuthorizationKey);
    nIVKeyIndex = ((pAuthorizationKey[dwAuthorizationKeySize-2] & 0x00FF) << 8) | (pAuthorizationKey[dwAuthorizationKeySize-1] & 0x00FF);
    pEncode = new BYTE[dwAuthorizationKeySize-2];
    memcpy(pEncode, pAuthorizationKey, dwAuthorizationKeySize-2);
    nEncodeSize = DeCode(pEncode, dwAuthorizationKeySize-2, &pDecode, nIVKeyIndex);


    // Á¶ÇÕÅ°¿Í ÀÎÁõÅ°ÀÇ ºñ±³
    if (nEncodeSize > 0) {
      strCombinationKey = CodeToAnsiString(pCombinationKey, dwCombinationKeySize, false);
      if (nEncodeSize == (int)dwCombinationKeySize) {
        nIndex = 0;
        nCount = dwCombinationKeySize;
        nDoubleLock = 0;
        while (nIndex < nEncodeSize) {
          // TexProÀÇ °æ¿ì Textile, Weave, Knit, Pile, CarpetÀ¸·Î ±¸¼ºµÇ¾î Àִµ¥ 3PackÀ̾ú´Ù°¡ 5PackÀ¸·Î ´Ã·Á¼­ ÀÎÁõÀÌ
          // ÇÊ¿äÇÒ °æ¿ìµµ ÀÖ´Ù. (Áï, ³Ñ°ÜÁØ ÇÁ·Î±×·¥ ProtectCardNumber¸¦ Æ÷ÇÔÇÏ´Â ´õ Å« °ªÀÌ ¿Ã ¼öµµ ÀÖ´Ù)
          // À̸¦ ÀúÀåÇϱâ À§ÇØ °Ç³Ê¶Ú´Ù
          if (nIndex == 0 || nIndex == 2 || nIndex == 3 || nIndex == 5 || nIndex == 11 || nIndex == 13) {
            nIndex++;
            continue;
          }
          else if ((bReturn &= (strCombinationKey.c_str()[nIndex] == pDecode[nIndex])) == true) {
            nIndex++;
          }
          else {
            goto fail;
          }
        }

        // ¹æ¹ý 1.
        /*
        pTemp = new BYTE[8];
        pTemp[0] = CharNumToIntNum(pDecode[13]);
        pTemp[1] = CharNumToIntNum(pDecode[3]);
        pTemp[2] = CharNumToIntNum(pDecode[0]);
        pTemp[3] = CharNumToIntNum(pDecode[11]);
        pTemp[4] = CharNumToIntNum(pDecode[5]);
        pTemp[5] = CharNumToIntNum(pDecode[2]);

        nDoubleLock = (~pTemp[0] & 0x0F);
        nDoubleLock |= ((pTemp[1] & 0x0F) << 4);
        nDoubleLock |= ((pTemp[2] & 0x0F) << 8);
        nDoubleLock |= ((~pTemp[3] & 0x0F) << 12);
        nDoubleLock |= ((~pTemp[4] & 0x0F) << 16);
        nDoubleLock |= ((~pTemp[5] & 0x0F) << 20);

        bReturn &= CheckProtectCardNumber(nDoubleLock);




        pTemp[0] = CharNumToIntNum(pDecode[7]);

        cKeyVersion = (pTemp[0] & 0x0F);

        bReturn &= (KeyVersion == cKeyVersion);





        pTemp[0] = CharNumToIntNum(pDecode[8]);
        pTemp[1] = CharNumToIntNum(pDecode[4]);
        pTemp[2] = CharNumToIntNum(pDecode[12]);
        pTemp[3] = CharNumToIntNum(pDecode[14]);
        pTemp[4] = CharNumToIntNum(pDecode[10]);
        pTemp[5] = CharNumToIntNum(pDecode[9]);
        pTemp[6] = CharNumToIntNum(pDecode[6]);
        pTemp[7] = CharNumToIntNum(pDecode[1]);

        dwVoulmeSerialNumber = (pTemp[0] & 0x0F);
        dwVoulmeSerialNumber |= ((pTemp[1] & 0x0F) << 4);
        dwVoulmeSerialNumber |= ((pTemp[2] & 0x0F) << 8);
        dwVoulmeSerialNumber |= ((pTemp[3] & 0x0F) << 12);
        dwVoulmeSerialNumber |= ((~pTemp[4] & 0x0F) << 16);
        dwVoulmeSerialNumber |= ((~pTemp[5] & 0x0F) << 20);
        dwVoulmeSerialNumber |= ((pTemp[6] & 0x0F) << 24);
        dwVoulmeSerialNumber |= ((~pTemp[7] & 0x0F) << 28);
        */
        // ¹æ¹ý 2.
        pTemp = new BYTE[8];
        pTemp[0] = CharNumToIntNum(pDecode[13]);
        pTemp[1] = CharNumToIntNum(pDecode[3]);
        pTemp[2] = CharNumToIntNum(pDecode[0]);
        pTemp[3] = CharNumToIntNum(pDecode[11]);
        pTemp[4] = CharNumToIntNum(pDecode[5]);
        pTemp[5] = CharNumToIntNum(pDecode[2]);

        nDoubleLock = (~pTemp[0] & 0x0F);
        nDoubleLock |= ((pTemp[1] & 0x0F) << 4);
        nDoubleLock |= ((pTemp[2] & 0x0F) << 8);
        nDoubleLock |= ((~pTemp[3] & 0x0F) << 12);
        nDoubleLock |= ((~pTemp[4] & 0x0F) << 16);
        nDoubleLock |= ((~pTemp[5] & 0x0F) << 20);

        bReturn &= CheckProtectCardNumber(nDoubleLock);




        pTemp[0] = CharNumToIntNum(pDecode[7]);

        cKeyVersion = (pTemp[0] & 0x0F);

        bReturn &= (KeyVersion == cKeyVersion);





        pTemp[0] = CharNumToIntNum(pDecode[10]);
        pTemp[1] = CharNumToIntNum(pDecode[9]);
        pTemp[2] = CharNumToIntNum(pDecode[6]);
        pTemp[3] = CharNumToIntNum(pDecode[1]);

        dwVoulmeSerialNumber = ((~pTemp[0] & 0x0F) << 16);
        dwVoulmeSerialNumber |= ((~pTemp[1] & 0x0F) << 20);
        dwVoulmeSerialNumber |= ((pTemp[2] & 0x0F) << 24);
        dwVoulmeSerialNumber |= ((~pTemp[3] & 0x0F) << 28);


        bReturn &= CheckVolumeSerialNumber(dwVoulmeSerialNumber, false);






        pTemp[0] = CharNumToIntNum(pDecode[8]);
        pTemp[1] = CharNumToIntNum(pDecode[4]);
        pTemp[2] = CharNumToIntNum(pDecode[12]);
        pTemp[3] = CharNumToIntNum(pDecode[14]);

        ftWriteFimeTime.dwLowDateTime = ((~pTemp[0] & 0x0F));
        ftWriteFimeTime.dwLowDateTime |= ((pTemp[1] & 0x0F) << 8);
        ftWriteFimeTime.dwLowDateTime |= ((pTemp[2] & 0x0F) << 16);
        ftWriteFimeTime.dwLowDateTime |= ((~pTemp[3] & 0x0F) << 24);

        bReturn &= CheckWriteFileTime(ftWriteFimeTime);

        if (pTemp) { delete []pTemp; pTemp = NULL; }
      } else {
        bReturn = false;
      }
    }
    else {
      bReturn = false;
    }

    if (pCombinationKey) { delete []pCombinationKey; pCombinationKey = NULL; }
    if (pEncode) { delete []pEncode; pEncode = NULL; }
    if (pDecode) { delete []pDecode; pDecode = NULL; }

    // Verification Key¸¦ ¸¸µç´Ù
    MakeVerificationKey();
  }

  return bReturn;


fail:

  if (pCombinationKey) { delete []pCombinationKey; pCombinationKey = NULL; }
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  if (pDecode) { delete []pDecode; pDecode = NULL; }

  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CompareCombinationKeyAndAuthorizationKey(BYTE **pFileAuthorizationKey, DWORD *dwFileAuthorizationKeySize)
{
  BYTE *pCombinationKey = NULL, *pEncode = NULL, *pDecode = NULL, *pTemp = NULL;
  //BYTE cProgramKeyIndex, cIVKeyIndex;
  unsigned short nProgramKeyIndex, nIVKeyIndex;
  unsigned int nDoubleLock;
  DWORD dwCombinationKeySize, dwTempKeySize, dwCombiKeySize, dwVoulmeSerialNumber;
  FILETIME ftWriteFimeTime;
  BYTE cKeyVersion;
  int nEncodeSize;
  AnsiString strCombinationKey;
  int nIndex;
  bool bReturn = true;

  // Á¶ÇÕÅ° »ý¼º
  MakeCombinationKey(&pCombinationKey, &dwCombinationKeySize);

  if (pCombinationKey && (*pFileAuthorizationKey) && dwCombinationKeySize > 0 && (*dwFileAuthorizationKeySize) > 0) {
    // ÀÎÁõÅ° ÀúÀå (µÚ¿¡ 2Byte : IV Key) Index·Î »ç¿ë)
    nIVKeyIndex = ((*((*pFileAuthorizationKey) + (*dwFileAuthorizationKeySize) - 2) & 0x00FF) << 8)
                  | (*((*pFileAuthorizationKey) + (*dwFileAuthorizationKeySize) - 1) & 0x00FF);
    pEncode = new BYTE[(*dwFileAuthorizationKeySize)-2];
    memcpy(pEncode, (*pFileAuthorizationKey), (*dwFileAuthorizationKeySize)-2);
    nEncodeSize = DeCode(pEncode, (*dwFileAuthorizationKeySize)-2, &pDecode, nIVKeyIndex);


    // Á¶ÇÕÅ°¿Í ÀÎÁõÅ°ÀÇ ºñ±³
    if (nEncodeSize > 0) {
      strCombinationKey = CodeToAnsiString(pCombinationKey, dwCombinationKeySize, false);
      if (nEncodeSize == (int)dwCombinationKeySize) {
        nIndex = 0;
        while (nIndex < nEncodeSize) {
          // TexProÀÇ °æ¿ì Textile, Weave, Knit, Pile, CarpetÀ¸·Î ±¸¼ºµÇ¾î Àִµ¥ 3PackÀ̾ú´Ù°¡ 5PackÀ¸·Î ´Ã·Á¼­ ÀÎÁõÀÌ
          // ÇÊ¿äÇÒ °æ¿ìµµ ÀÖ´Ù. (Áï, ³Ñ°ÜÁØ ÇÁ·Î±×·¥ ProtectCardNumber¸¦ Æ÷ÇÔÇÏ´Â ´õ Å« °ªÀÌ ¿Ã ¼öµµ ÀÖ´Ù)
          // À̸¦ ÀúÀåÇϱâ À§ÇØ °Ç³Ê¶Ú´Ù
          if (nIndex == 0 || nIndex == 2 || nIndex == 3 || nIndex == 5 || nIndex == 11 || nIndex == 13) {
            nIndex++;
            continue;
          }
          else if ((bReturn &= (strCombinationKey.c_str()[nIndex] == pDecode[nIndex])) == true) {
            nIndex++;
          }
          else {
            goto fail;
          }
        }
        // ¹æ¹ý 1.
        /*
        pTemp = new BYTE[8];
        pTemp[0] = CharNumToIntNum(pDecode[13]);
        pTemp[1] = CharNumToIntNum(pDecode[3]);
        pTemp[2] = CharNumToIntNum(pDecode[0]);
        pTemp[3] = CharNumToIntNum(pDecode[11]);
        pTemp[4] = CharNumToIntNum(pDecode[5]);
        pTemp[5] = CharNumToIntNum(pDecode[2]);

        nDoubleLock = (~pTemp[0] & 0x0F);
        nDoubleLock |= ((pTemp[1] & 0x0F) << 4);
        nDoubleLock |= ((pTemp[2] & 0x0F) << 8);
        nDoubleLock |= ((~pTemp[3] & 0x0F) << 12);
        nDoubleLock |= ((~pTemp[4] & 0x0F) << 16);
        nDoubleLock |= ((~pTemp[5] & 0x0F) << 20);

        bReturn &= CheckProtectCardNumber(nDoubleLock);




        pTemp[0] = CharNumToIntNum(pDecode[7]);

        cKeyVersion = (pTemp[0] & 0x0F);

        bReturn &= (KeyVersion == cKeyVersion);





        pTemp[0] = CharNumToIntNum(pDecode[8]);
        pTemp[1] = CharNumToIntNum(pDecode[4]);
        pTemp[2] = CharNumToIntNum(pDecode[12]);
        pTemp[3] = CharNumToIntNum(pDecode[14]);
        pTemp[4] = CharNumToIntNum(pDecode[10]);
        pTemp[5] = CharNumToIntNum(pDecode[9]);
        pTemp[6] = CharNumToIntNum(pDecode[6]);
        pTemp[7] = CharNumToIntNum(pDecode[1]);

        dwVoulmeSerialNumber = (pTemp[0] & 0x0F);
        dwVoulmeSerialNumber |= ((pTemp[1] & 0x0F) << 4);
        dwVoulmeSerialNumber |= ((pTemp[2] & 0x0F) << 8);
        dwVoulmeSerialNumber |= ((pTemp[3] & 0x0F) << 12);
        dwVoulmeSerialNumber |= ((~pTemp[4] & 0x0F) << 16);
        dwVoulmeSerialNumber |= ((~pTemp[5] & 0x0F) << 20);
        dwVoulmeSerialNumber |= ((pTemp[6] & 0x0F) << 24);
        dwVoulmeSerialNumber |= ((~pTemp[7] & 0x0F) << 28);
        */
        // ¹æ¹ý 2.
        pTemp = new BYTE[8];
        pTemp[0] = CharNumToIntNum(pDecode[13]);
        pTemp[1] = CharNumToIntNum(pDecode[3]);
        pTemp[2] = CharNumToIntNum(pDecode[0]);
        pTemp[3] = CharNumToIntNum(pDecode[11]);
        pTemp[4] = CharNumToIntNum(pDecode[5]);
        pTemp[5] = CharNumToIntNum(pDecode[2]);

        nDoubleLock = (~pTemp[0] & 0x0F);
        nDoubleLock |= ((pTemp[1] & 0x0F) << 4);
        nDoubleLock |= ((pTemp[2] & 0x0F) << 8);
        nDoubleLock |= ((~pTemp[3] & 0x0F) << 12);
        nDoubleLock |= ((~pTemp[4] & 0x0F) << 16);
        nDoubleLock |= ((~pTemp[5] & 0x0F) << 20);

        bReturn &= CheckProtectCardNumber(nDoubleLock);




        pTemp[0] = CharNumToIntNum(pDecode[7]);

        cKeyVersion = (pTemp[0] & 0x0F);

        bReturn &= (KeyVersion == cKeyVersion);





        pTemp[0] = CharNumToIntNum(pDecode[10]);
        pTemp[1] = CharNumToIntNum(pDecode[9]);
        pTemp[2] = CharNumToIntNum(pDecode[6]);
        pTemp[3] = CharNumToIntNum(pDecode[1]);

        dwVoulmeSerialNumber = ((~pTemp[0] & 0x0F) << 16);
        dwVoulmeSerialNumber |= ((~pTemp[1] & 0x0F) << 20);
        dwVoulmeSerialNumber |= ((pTemp[2] & 0x0F) << 24);
        dwVoulmeSerialNumber |= ((~pTemp[3] & 0x0F) << 28);


        bReturn &= CheckVolumeSerialNumber(dwVoulmeSerialNumber, false);






        pTemp[0] = CharNumToIntNum(pDecode[8]);
        pTemp[1] = CharNumToIntNum(pDecode[4]);
        pTemp[2] = CharNumToIntNum(pDecode[12]);
        pTemp[3] = CharNumToIntNum(pDecode[14]);

        ftWriteFimeTime.dwLowDateTime = ((~pTemp[0] & 0x0F));
        ftWriteFimeTime.dwLowDateTime |= ((pTemp[1] & 0x0F) << 8);
        ftWriteFimeTime.dwLowDateTime |= ((pTemp[2] & 0x0F) << 16);
        ftWriteFimeTime.dwLowDateTime |= ((~pTemp[3] & 0x0F) << 24);

        bReturn &= CheckWriteFileTime(ftWriteFimeTime);

        if (pTemp) { delete []pTemp; pTemp = NULL; }
      } else {
        bReturn = false;
      }
    }
    else {
      bReturn = false;
    }
  }

  if (pCombinationKey) { delete []pCombinationKey; pCombinationKey = NULL; }
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  if (pDecode) { delete []pDecode; pDecode = NULL; }

  return bReturn;


fail:

  if (pCombinationKey) { delete []pCombinationKey; pCombinationKey = NULL; }
  if (pEncode) { delete []pEncode; pEncode = NULL; }
  if (pDecode) { delete []pDecode; pDecode = NULL; }

  return false;
}
//---------------------------------------------------------------------------
AnsiString __fastcall TTexLock::MakeAdditionKey(BYTE **pAdditionKey, DWORD *dwAdditionKeySize)
{
  AnsiString strKeyCode;
  HANDLE hFile = NULL;
  DWORD dwVolumeSerialNumber;
  AnsiString strDrv;
  AnsiString strLockFileName;
  unsigned int nDoubleLock;
  BYTE *KeyCode = NULL;

  strDrv = ExtractFileDrive(FullPath) + "\\";

  // ½ÇÇàÆÄÀÏ°ú °°ÀÌ ÀÖ´Â µð½ºÅ©µå¶óÀ̺êÀÇ ¼Ó¼ºÀ» ±¸ÇÔ (¹Ýµå½Ã Çϵåµð½ºÅ© µå¶óÀ̺꿡¼­¸¸ ±¸µ¿)
  switch (GetDriveType(strDrv.c_str())) {
    case DRIVE_FIXED:	// The disk cannot be removed from the drive.
      break;
    case 0: //The drive type cannot be determined.
    case 1:	// The root directory does not exist.
    case DRIVE_REMOVABLE: //	The drive can be removed from the drive.
    case DRIVE_REMOTE: //	The drive is a remote (network) drive.
    case DRIVE_CDROM: //	The drive is a CD-ROM drive.
    case DRIVE_RAMDISK: //	The drive is a RAM disk.
      Application->MessageBox(pMessage06, pMessage01, MB_ICONSTOP);
      goto fail;
  }

  // ÇÁ·Î±×·¥ÀÌ ¼³Ä¡µÇ¾î ÀÖ´Â DriveÀÇ Hard Disk Serial Number¸¦ ¾ò¾î¿È
  GetVolumeInformation(strDrv.c_str(), NULL, 0, &dwVolumeSerialNumber, NULL, NULL, NULL, 0);

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  if ((hFile = CreateFile(strLockFileName.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING
                      , FILE_ATTRIBUTE_HIDDEN, NULL)) == INVALID_HANDLE_VALUE) {
    goto fail;
  }

  // KeyCode ¾Ïȣȭ
  // S : HDD Serial Number
  // C : Create File Time
  // W : Write File Time
  // [] : Position
  //   0     1     2     3     4    5    6    7     8    9
  // ~C[6] W[3] ~S[4] ~S[3]  S[0] W[0] ~W[7] C[0] C[1] ~W[1]

  //  10    11    12   13    14    15    16   17    18   19
  // ~W[2] S[7] S[2] ~C[4]  C[3] W[4] ~S[6] S[1] ~W[6] ~S[5]

  //  20    21   22    23
  // ~C[2] ~C[5] W[5] ~C[7]

  KeyCode = new BYTE[ADDITIONKEY_LENGTH];

  KeyCode[0] = ((~CreateTime.dwLowDateTime >> 24) & 0x0F);
  KeyCode[1] = ((WriteTime.dwLowDateTime >> 12) & 0x0F);
  KeyCode[2] = ((~dwVolumeSerialNumber >> 16) & 0x0F);
  KeyCode[3] = ((~dwVolumeSerialNumber >> 12) & 0x0F);
  KeyCode[4] = ((dwVolumeSerialNumber) & 0x0F);
  KeyCode[5] = ((WriteTime.dwLowDateTime) & 0x0F);
  KeyCode[6] = ((~WriteTime.dwLowDateTime >> 28) & 0x0F);
  KeyCode[7] = ((CreateTime.dwLowDateTime) & 0x0F);
  KeyCode[8] = ((CreateTime.dwLowDateTime >> 4) & 0x0F);
  KeyCode[9] = ((~WriteTime.dwLowDateTime >> 4) & 0x0F);
  KeyCode[10] = ((~WriteTime.dwLowDateTime >> 8) & 0x0F);
  KeyCode[11] = ((dwVolumeSerialNumber >> 28) & 0x0F);
  KeyCode[12] = ((dwVolumeSerialNumber >> 8) & 0x0F);
  KeyCode[13] = ((~CreateTime.dwLowDateTime >> 16) & 0x0F);
  KeyCode[14] = ((CreateTime.dwLowDateTime >> 12) & 0x0F);
  KeyCode[15] = ((WriteTime.dwLowDateTime >> 16) & 0x0F);
  KeyCode[16] = ((~dwVolumeSerialNumber >> 24) & 0x0F);
  KeyCode[17] = ((dwVolumeSerialNumber >> 4) & 0x0F);
  KeyCode[18] = ((~WriteTime.dwLowDateTime >> 24) & 0x0F);
  KeyCode[19] = ((~dwVolumeSerialNumber >> 20) & 0x0F);
  KeyCode[20] = ((~CreateTime.dwLowDateTime >> 8) & 0x0F);
  KeyCode[21] = ((~CreateTime.dwLowDateTime >> 20) & 0x0F);
  KeyCode[22] = ((WriteTime.dwLowDateTime >> 20) & 0x0F);
  KeyCode[23] = ((~CreateTime.dwLowDateTime >> 28) & 0x0F);


  if (pAdditionKey && dwAdditionKeySize) {
    if (*pAdditionKey) { delete [](*pAdditionKey); }
    *dwAdditionKeySize = ADDITIONKEY_LENGTH;
    *pAdditionKey = new BYTE[(*dwAdditionKeySize)];
    // Ãß°¡Å° ÀúÀå
    memcpy(*pAdditionKey, KeyCode, sizeof(BYTE)*(*dwAdditionKeySize));
  }

  strKeyCode = CodeToAnsiString(KeyCode, ADDITIONKEY_LENGTH, true);

  if (hFile) { CloseHandle(hFile); hFile = NULL; }
  if (KeyCode) { delete []KeyCode; KeyCode = NULL; }

  return strKeyCode;

fail:
  if (hFile) { CloseHandle(hFile); hFile = NULL; }
  if (KeyCode) { delete []KeyCode; KeyCode = NULL; }
  if (*pAdditionKey) { delete [](*pAdditionKey); *pAdditionKey = NULL; }

  return strKeyCode;
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::MakeVerificationKey()
{
  BYTE *pAdditionKey = NULL;
  DWORD dwAdditionKeySize;
  int nAuthorizationKeyIndex;

  MakeAdditionKey(&pAdditionKey, &dwAdditionKeySize);

  if (pAuthorizationKey && pAdditionKey && dwAuthorizationKeySize > 0 &&  dwAdditionKeySize > 0) {
    if (pVerificationKey) { delete []pVerificationKey; }
    dwVerificationKeySize = dwAdditionKeySize;
    pVerificationKey = new BYTE[dwVerificationKeySize];

    nAuthorizationKeyIndex = 0;
    for (int i = 0; i < (int)dwVerificationKeySize; i++) {
      if (nAuthorizationKeyIndex >= (int)dwAuthorizationKeySize) nAuthorizationKeyIndex = 0;

      switch (pAdditionKey[i]%4) {
        case 0: // AdditionKey ^ AuthorizationKey ¿¬»ê
          pVerificationKey[i] = pAdditionKey[i] ^ pAuthorizationKey[nAuthorizationKeyIndex];
          break;
        case 1: // pAdditionKey¸¦ ȯÇüÅ¥¶ó »ý°¢ÇÏ°í (AuthorizationKey[nIndex] % 8)¸¸Å­ RightShift ÇÔ
          pVerificationKey[i] = (pAdditionKey[i] >> (pAuthorizationKey[nAuthorizationKeyIndex] % 8)) | (pAdditionKey[i] << (8-(pAuthorizationKey[nAuthorizationKeyIndex] % 8)));
          break;
        case 2: // pAdditionKey ^ ~AuthorizationKey ¿¬»ê
          pVerificationKey[i] = pAdditionKey[i] ^ ~(pAuthorizationKey[nAuthorizationKeyIndex]);
          break;
        case 3: // pAdditionKey¸¦ ȯÇüÅ¥¶ó »ý°¢ÇÏ°í (AuthorizationKey[nIndex] % 8)¸¸Å­ LeftShift ÇÔ
          pVerificationKey[i] = (pAdditionKey[i] << (pAuthorizationKey[nAuthorizationKeyIndex] % 8)) | (pAdditionKey[i] >> (8-(pAuthorizationKey[nAuthorizationKeyIndex] % 8)));
          break;
      }
      nAuthorizationKeyIndex++;
    }

    if (pAdditionKey) { delete []pAdditionKey; pAdditionKey = NULL; }

    return true;
  }
  else {
    if (pAdditionKey) { delete []pAdditionKey; pAdditionKey = NULL; }

    return false;
  }
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::CompareAdditionKeyAndVerificationKey(BYTE **pFileAuthorizationKey, DWORD *dwFileAuthorizationKeySize, BYTE **pFileVerificationKey, DWORD *dwFileVerificationKeySize)
{
  BYTE *pAdditionKey = NULL, *pCheckVerificationKey = NULL;
  DWORD dwAdditionKeySize, dwCheckVerificationKeySize, dwVolumeSerialNumber;
  int nAuthorizationKeyIndex;
  FILETIME ftKeyCreateTime, ftKeyAccessTime, ftKeyWriteTime;

  MakeAdditionKey(&pAdditionKey, &dwAdditionKeySize);

  if (pAdditionKey && (*pFileAuthorizationKey) && (*pFileVerificationKey) && dwAdditionKeySize > 0 && (*dwFileAuthorizationKeySize) > 0 && (*dwFileVerificationKeySize) > 0) {

    if (pCheckVerificationKey) { delete []pCheckVerificationKey; }
    dwCheckVerificationKeySize = dwAdditionKeySize;
    pCheckVerificationKey = new BYTE[dwCheckVerificationKeySize];

    nAuthorizationKeyIndex = 0;
    for (int i = 0; i < (int)dwCheckVerificationKeySize; i++) {
      if (nAuthorizationKeyIndex >= (int)(*dwFileAuthorizationKeySize)) nAuthorizationKeyIndex = 0;

      switch (pAdditionKey[i]%4) {
        case 0: // AdditionKey ^ AuthorizationKey ¿¬»ê
          pCheckVerificationKey[i] = pAdditionKey[i] ^ *((*pFileAuthorizationKey)+nAuthorizationKeyIndex);
          break;
        case 1: // AdditionKey¸¦ ȯÇüÅ¥¶ó »ý°¢ÇÏ°í (AuthorizationKey[nIndex] % 8)¸¸Å­ RightShift ÇÔ
          pCheckVerificationKey[i] = (pAdditionKey[i] >> (*((*pFileAuthorizationKey)+nAuthorizationKeyIndex) % 8)) | (pAdditionKey[i] << (8-(*((*pFileAuthorizationKey)+nAuthorizationKeyIndex) % 8)));
          break;
        case 2: // AdditionKey ^ ~AuthorizationKey ¿¬»ê
          pCheckVerificationKey[i] = (pAdditionKey[i]) ^ ~(*((*pFileAuthorizationKey)+nAuthorizationKeyIndex));
          break;
        case 3: // AdditionKey¸¦ ȯÇüÅ¥¶ó »ý°¢ÇÏ°í (AuthorizationKey[nIndex] % 8)¸¸Å­ LeftShift ÇÔ
          pCheckVerificationKey[i] = (pAdditionKey[i] << (*((*pFileAuthorizationKey)+nAuthorizationKeyIndex) % 8)) | (pAdditionKey[i] >> (8-(*((*pFileAuthorizationKey)+nAuthorizationKeyIndex) % 8)));
          break;
      }

      // ÆÄÀÏÀÇ pFileVerificationKey¿Í °°Àº °á°ú°¡ ³ª¿Â´Ù¸é ÇöÀçÀÇ pAdditionKey¿Í µ¿ÀÏÇÏ´Ù´Â °ÍÀÌ º¸ÀåµÈ´Ù
      if (pCheckVerificationKey[i] != *((*pFileVerificationKey)+i)) {
        if (pAdditionKey) { delete []pAdditionKey; pAdditionKey = NULL; }
        if (pCheckVerificationKey) { delete []pCheckVerificationKey; pCheckVerificationKey = NULL; }

        return false;
      }

      nAuthorizationKeyIndex++;
    }

  //   0     1     2     3     4    5    6    7     8    9
  // ~C[6] W[3] ~S[4] ~S[3]  S[0] W[0] ~W[7] C[0] C[1] ~W[1]

  //  10    11    12   13    14    15    16   17    18   19
  // ~W[2] S[7] S[2] ~C[4]  C[3] W[4] ~S[6] S[1] ~W[6] ~S[5]

  //  20    21    22    23
  // ~C[2] ~C[5] W[5] ~C[7]


    // ÆÄÀÏ »ý¼º, Á¢±Ù, ¼öÁ¤ ½Ã°£
    ftKeyCreateTime.dwLowDateTime = (pAdditionKey[7] & 0x0F);
    ftKeyCreateTime.dwLowDateTime |= ((pAdditionKey[8] & 0x0F) << 4);
    ftKeyCreateTime.dwLowDateTime |= ((~pAdditionKey[20] & 0x0F) << 8);
    ftKeyCreateTime.dwLowDateTime |= ((pAdditionKey[14] & 0x0F) << 12);
    ftKeyCreateTime.dwLowDateTime |= ((~pAdditionKey[13] & 0x0F) << 16);
    ftKeyCreateTime.dwLowDateTime |= ((~pAdditionKey[21] & 0x0F) << 20);
    ftKeyCreateTime.dwLowDateTime |= ((~pAdditionKey[0] & 0x0F) << 24);
    ftKeyCreateTime.dwLowDateTime |= ((~pAdditionKey[23] & 0x0F) << 28);

    ftKeyWriteTime.dwLowDateTime = (pAdditionKey[5] & 0x0F);
    ftKeyWriteTime.dwLowDateTime |= ((~pAdditionKey[9] & 0x0F) << 4);
    ftKeyWriteTime.dwLowDateTime |= ((~pAdditionKey[10] & 0x0F) << 8);
    ftKeyWriteTime.dwLowDateTime |= ((pAdditionKey[1] & 0x0F) << 12);
    ftKeyWriteTime.dwLowDateTime |= ((pAdditionKey[15] & 0x0F) << 16);
    ftKeyWriteTime.dwLowDateTime |= ((pAdditionKey[22] & 0x0F) << 20);
    ftKeyWriteTime.dwLowDateTime |= ((~pAdditionKey[18] & 0x0F) << 24);
    ftKeyWriteTime.dwLowDateTime |= ((~pAdditionKey[6] & 0x0F) << 28);

    // ½Ã¸®¾ó ¹øÈ£
    dwVolumeSerialNumber = (pAdditionKey[4] & 0x0F);
    dwVolumeSerialNumber |= ((pAdditionKey[17] & 0x0F) << 4);
    dwVolumeSerialNumber |= ((pAdditionKey[12] & 0x0F) << 8);
    dwVolumeSerialNumber |= ((~pAdditionKey[3] & 0x0F) << 12);
    dwVolumeSerialNumber |= ((~pAdditionKey[2] & 0x0F) << 16);
    dwVolumeSerialNumber |= ((~pAdditionKey[19] & 0x0F) << 20);
    dwVolumeSerialNumber |= ((~pAdditionKey[16] & 0x0F) << 24);
    dwVolumeSerialNumber |= ((pAdditionKey[11] & 0x0F) << 28);

    if (pAdditionKey) { delete []pAdditionKey; pAdditionKey = NULL; }
    if (pCheckVerificationKey) { delete []pCheckVerificationKey; pCheckVerificationKey = NULL; }

    // ÆÄÀÏ »ý¼º ½Ã°£, ¾²±â ½Ã°£, ½Ã¸®¾ó ¹øÈ£
    if (CheckFileTime(ftKeyCreateTime, ftKeyAccessTime, ftKeyWriteTime) && CheckVolumeSerialNumber(dwVolumeSerialNumber)) {
      return true;
    }
    else {
      return false;
    }
  }
  else {
    if (pAdditionKey) { delete []pAdditionKey; pAdditionKey = NULL; }
    if (pCheckVerificationKey) { delete []pCheckVerificationKey; pCheckVerificationKey = NULL; }

    return false;
  }
}
//---------------------------------------------------------------------------
void __fastcall TTexLock::CheckingReverseEngineeringTools()
{
  TStringList *strTitleList = new TStringList;

  // Reverse Engineering Tool Kill
  // http://www.drvi.com/DrVirus/sub02/sub02_01_view.php?no=262 ¿¡ Ç¥±âµÇ¾îÀÖ´Â µð¹ö±ë ÇÁ·Î±×·¥ ¸ñ·Ï
  strTitleList->Add("EXESPY");
  strTitleList->Add("WXR95");
  strTitleList->Add("REGMON");
  strTitleList->Add("FILE MONITOR");
  strTitleList->Add("REGMONEX");
  strTitleList->Add("WINDOW DETECTIVE");
  strTitleList->Add("DEBUGVIEW");
  strTitleList->Add("RESSPY");
  strTitleList->Add("ADVANCED REGISTRY TRACER");
  strTitleList->Add("REGSNAP");
  strTitleList->Add("MEMSPY");
  strTitleList->Add("MEMORY DOCTOR");
  strTitleList->Add("PROCDUMP32");
  strTitleList->Add("MEMORY EDITOR");
  strTitleList->Add("FROGSICE");
  strTitleList->Add("SMU WINSPECTOR");
  strTitleList->Add("MEMORY DUMPER");
  strTitleList->Add("MEMORYMONITOR");
  strTitleList->Add("NUMEGA SOFTICE LOADER");
  strTitleList->Add("URSOFT W32DASM");
  strTitleList->Add("OllyDbg");
  strTitleList->Add("TRW2000");

  strTitleList->Add("DEDE");  // Delphi Decompiler
  strTitleList->Add("HACK");
  strTitleList->Add("CRACK");
  strTitleList->Add("WINICE");

  // ÇÁ·Î¼¼½ºÀÇ Ä¸¼ÇÀ̳ª ½ÇÇàÆÄÀϸíÀÌ °°À» °æ¿ì Á¾·á
  if (strTitleList) {
    EnumWindows((WNDENUMPROC)EnumWindowsProc, (LPARAM)strTitleList);
    KillReverseEngineeringTool(strTitleList);
  }


  if (strTitleList) { strTitleList->Clear(); delete strTitleList; strTitleList = NULL; }
}
//---------------------------------------------------------------------------
AnsiString __fastcall TTexLock::GetCombinationKey()
{
  AnsiString strCombinationKey, strCheckSum, strKey;
  BYTE *pCombinationKey = NULL;
  DWORD dwCombinationKeySize;

  strCombinationKey = MakeCombinationKey(&pCombinationKey, &dwCombinationKeySize);
  strCheckSum = MakeCRC(&pCombinationKey, &dwCombinationKeySize);
  strKey = strCombinationKey + " " + strCheckSum;

  if (pCombinationKey) { delete []pCombinationKey; pCombinationKey = NULL;  }

  return strKey;
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::Check(bool bShowMessage, AnsiString strAuthorizationKey)
{
  BYTE *pFileAuthorizationKey = NULL, *pFileVerificationKey = NULL;
  DWORD dwFileAuthorizationKeySize, dwFileVerificationKeySize;

  CheckingReverseEngineeringTools();

  if (strAuthorizationKey.IsEmpty() == false) {
    if (CompareCombinationKeyAndAuthorizationKey(strAuthorizationKey)) {
      SaveToFile();
      if (bShowMessage) {
        Application->MessageBox(pMessage03, pMessage04, MB_ICONINFORMATION);
      }
      return true;
    }
    else {
      if (bShowMessage) {
        Application->MessageBox(pMessage05, pMessage02, MB_ICONWARNING);
      }
      return false;
    }
  }
  else {
    if (LoadFromFile(&pFileAuthorizationKey, &dwFileAuthorizationKeySize, &pFileVerificationKey, &dwFileVerificationKeySize)) {
      if (CompareCombinationKeyAndAuthorizationKey(&pFileAuthorizationKey, &dwFileAuthorizationKeySize)
          && CompareAdditionKeyAndVerificationKey(&pFileAuthorizationKey, &dwFileAuthorizationKeySize, &pFileVerificationKey, &dwFileVerificationKeySize)) {
        if (pFileAuthorizationKey) { delete []pFileAuthorizationKey; pFileAuthorizationKey = NULL; }
        if (pFileVerificationKey) { delete []pFileVerificationKey; pFileVerificationKey = NULL; }
        if (bShowMessage) {
          Application->MessageBox(pMessage03, pMessage04, MB_ICONINFORMATION);
        }

        return true;
      } else {
        if (pFileAuthorizationKey) { delete []pFileAuthorizationKey; pFileAuthorizationKey = NULL; }
        if (pFileVerificationKey) { delete []pFileVerificationKey; pFileVerificationKey = NULL; }
        if (bShowMessage) {
          Application->MessageBox(pMessage05, pMessage02, MB_ICONWARNING);
        }

        return false;
      }
    } else {
      if (pFileAuthorizationKey) { delete []pFileAuthorizationKey; pFileAuthorizationKey = NULL; }
      if (pFileVerificationKey) { delete []pFileVerificationKey; pFileVerificationKey = NULL; }
      if (bShowMessage) {
        Application->MessageBox(pMessage05, pMessage02, MB_ICONWARNING);
      }

      return false;
    }
  }
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::LoadFromFile(BYTE **pFileAuthorizationKey, DWORD *dwFileAuthorizationKeySize, BYTE **pFileVerificationKey, DWORD *dwFileVerificationKeySize)
{
  AnsiString strLockFileName;
  HANDLE hFile = NULL;
  DWORD dwRead;
  int nVersion;

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  if ((hFile = CreateFile(strLockFileName.c_str(), GENERIC_READ, 0, NULL, OPEN_ALWAYS
                      , FILE_ATTRIBUTE_HIDDEN, NULL)) == INVALID_HANDLE_VALUE) {
    goto fail;
  }

  if (!ReadFile(hFile, &nVersion, sizeof(int), &dwRead, NULL)) goto fail; // Version
  if (FileVersion == nVersion) {
    if (!ReadFile(hFile, dwFileAuthorizationKeySize, sizeof(DWORD), &dwRead, NULL)) goto fail; // AuthorizationData Length
    if (*dwFileAuthorizationKeySize > 0) {
      if (*pFileAuthorizationKey) { delete [](*pFileAuthorizationKey); *pFileAuthorizationKey = NULL; }
      *pFileAuthorizationKey = new BYTE[(*dwFileAuthorizationKeySize)];
      if (!ReadFile(hFile, *pFileAuthorizationKey, sizeof(BYTE)*(*dwFileAuthorizationKeySize), &dwRead, NULL)) goto fail;  // AuthorizationData
    } else {
      goto fail;
    }
    if (dwRead != (*dwFileAuthorizationKeySize)) goto fail;

    if (!ReadFile(hFile, dwFileVerificationKeySize, sizeof(DWORD), &dwRead, NULL)) goto fail; // EncodeData Length
    if ((*dwFileVerificationKeySize) > 0) {
      if ((*pFileVerificationKey)) { delete [](*pFileVerificationKey);  *pFileVerificationKey = NULL; }
      *pFileVerificationKey = new BYTE[(*dwFileVerificationKeySize)];
      if (!ReadFile(hFile, *pFileVerificationKey, sizeof(BYTE)*(*dwFileVerificationKeySize), &dwRead, NULL)) goto fail;  // EncodeData
    } else {
      goto fail;
    }
    if (dwRead != (*dwFileVerificationKeySize)) goto fail;
  } else {
    goto fail;
  }


  if (hFile) { CloseHandle(hFile); hFile = NULL; }

  return true;

fail:
  *dwFileAuthorizationKeySize = 0;
  *dwFileVerificationKeySize = 0;
  if (*pFileAuthorizationKey) { delete [](*pFileAuthorizationKey); *pFileAuthorizationKey = NULL; }
  if (*pFileVerificationKey) { delete [](*pFileVerificationKey); *pFileVerificationKey = NULL; }
  if (hFile) { CloseHandle(hFile); hFile = NULL; }

  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::SaveToFile()
{
  AnsiString strLockFileName;
  HANDLE hFile = NULL;
  DWORD dwWrite;

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  // ÆÄÀÏÀ» »õ·Î ¸¸µê
  if (pAuthorizationKey && pVerificationKey && dwAuthorizationKeySize > 0 && dwVerificationKeySize > 0) {
    if ((hFile = CreateFile(strLockFileName.c_str(), GENERIC_WRITE, 0, NULL, OPEN_ALWAYS
                        , FILE_ATTRIBUTE_HIDDEN, NULL)) == INVALID_HANDLE_VALUE) {
      goto fail;
    }

    if (!WriteFile(hFile, &FileVersion, sizeof(int), &dwWrite, NULL)) goto fail; // Version

    if (!WriteFile(hFile, &dwAuthorizationKeySize, sizeof(DWORD), &dwWrite, NULL)) goto fail; // AuthorizationData Length
    if (!WriteFile(hFile, pAuthorizationKey, sizeof(BYTE)*dwAuthorizationKeySize, &dwWrite, NULL)) goto fail; // AuthorizationData
    if (dwWrite != dwAuthorizationKeySize) goto fail;

    if (!WriteFile(hFile, &dwVerificationKeySize, sizeof(DWORD), &dwWrite, NULL)) goto fail; // EncodeData Length
    if (!WriteFile(hFile, pVerificationKey, sizeof(BYTE)*dwVerificationKeySize, &dwWrite, NULL)) goto fail;  // EncodeData
    if (dwWrite != dwVerificationKeySize) goto fail;

    if (hFile) { CloseHandle(hFile); hFile = NULL; }

    return true;
  }
  else {
    return false;
  }

fail:
  if (pAuthorizationKey) { delete []pAuthorizationKey; pAuthorizationKey = NULL; }
  if (pVerificationKey) { delete []pVerificationKey; pVerificationKey = NULL; }
  if (hFile) { CloseHandle(hFile); hFile = NULL; }

  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TTexLock::ClearFile()
{
  AnsiString strLockFileName;
  HANDLE hFile = NULL;

  strLockFileName = ExtractFilePath(FullPath) + "YoungWooCnI.DLL";

  // ÆÄÀÏÀ» »õ·Î ¸¸µê
  if (FileExists(strLockFileName)) {
    if ((hFile = CreateFile(strLockFileName.c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING
                        , FILE_ATTRIBUTE_HIDDEN, NULL)) == INVALID_HANDLE_VALUE) {
      goto fail;
    }

    if (hFile) { CloseHandle(hFile); hFile = NULL; }


    if ((hFile = CreateFile(strLockFileName.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS
                        , FILE_ATTRIBUTE_HIDDEN, NULL)) == INVALID_HANDLE_VALUE) {
      goto fail;
    }

    if (hFile) { CloseHandle(hFile); hFile = NULL; }
  }
  return true;


fail:
  if (hFile) { CloseHandle(hFile); hFile = NULL; }

  return false;
}
//---------------------------------------------------------------------------