//---------------------------------------------------------------------------
#include <vcl.h>
#include <malloc.h>
#include <registry.hpp>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#pragma hdrstop

#include "ProtectCard.h"
#include "Define.h"
#include "Des.h"
#include "Pcilib.h"
#ifndef LOCK_CRYPKEY
  #include "File.h"
#endif
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
#define CPORT               0xE0     // 포트 시작 주소
//---------------------------------------------------------------------------
//v10 = 최초의 PCI버전                //TexTricot 추가
//v11 = 버전정보의 상위4 bits를 빼옴  //Tex3D, TexStylist 추가
#define	MaxIFCVersion	      11
//---------------------------------------------------------------------------

TProtectCard *ProtectCard;
//---------------------------------------------------------------------------
int __fastcall toJulian()
{
  SYSTEMTIME st;
  int jyear, jmonth, jul, greg, curDay, ja;

  GetLocalTime(&st);
  jyear = st.wYear;
  jmonth = st.wMonth;
  if (st.wYear < 0) jyear++;
  if (st.wMonth > 2) jmonth++;
  else {
    jyear--;
    jmonth += 13;
  }
  jul = 365.25*jyear + 30.6001*jmonth + st.wDay + 1720995.0;
  greg = 15 + 31*(10+12*1582);
  curDay = st.wDay + 31*(st.wMonth +12*st.wYear);
  if (curDay >= greg) {
    ja = 0.01*jyear;
    jul += 2-ja+(0.25*ja);
  }
  return jul;
}
//---------------------------------------------------------------------------
static bool __fastcall checkTime()
{
  unsigned char blk[8], k[8] = {'^', '*', 'F', 'S', '0', '>', '?', '['};
  int nowJul, pastJul, due, sumDay;
	TRegIniFile *RegIniFile;
  AnsiString pw;
  int timePass[4];

 	RegIniFile = new TRegIniFile(RegFilename);
  RegIniFile->RootKey = HKEY_LOCAL_MACHINE;
  RegIniFile->OpenKey(RegFilename + "\\",true);   // yw
  if (RegIniFile) {
    pw = RegIniFile->ReadString("Common", "Product No.", "");
    if (pw == "") goto fail;
    sscanf(pw.c_str(), "%d-%d-%d-%d", &timePass[0], &timePass[1], &timePass[2], &timePass[3]);
  	delete RegIniFile;
  } else return false;
  blk[0] = timePass[0] & 0xFF;
  blk[1] = (timePass[0] >> 8) & 0xFF;
  blk[2] = timePass[1] & 0xFF;
  blk[3] = (timePass[1] >> 8) & 0xFF;
  blk[4] = timePass[2] & 0xFF;
  blk[5] = (timePass[2] >> 8) & 0xFF;
  blk[6] = timePass[3] & 0xFF;
  blk[7] = (timePass[3] >> 8) & 0xFF;
  decrypt(k, blk);
  sumDay = blk[0];
  sumDay |= blk[1] << 8;
  sumDay |= blk[2] << 16;
  sumDay |= blk[3] << 24;

  pastJul = sumDay;
  sumDay = blk[4];
  sumDay |= blk[5] << 8;
  sumDay |= blk[6] << 16;
  sumDay |= blk[7] << 24;
  due = sumDay;
  nowJul = toJulian();
  if (nowJul >= pastJul) {
    if (nowJul < (pastJul + due)) return true;
    else return false;
  }
  else return false;
fail :
	delete RegIniFile;
  return true;
}
//---------------------------------------------------------------------------
//#ifndef LOCK_CRYPKEY
#ifdef LOCK_IFC

//---------------------------------------------------------------------------
static Byte __stdcall InportByte(Word port)
{

  if(GetDeviceOK()){
    Byte cc;
    AtWriteB(iatpci.cs[ATPCI_CS3]+0,port);         // port는 CPORT부터 시작한다 //(Byte)port해도 된다
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x10);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x14);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x1D);
    cc = AtReadB(iatpci.cs[ATPCI_CS3]+8);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x00);
    return cc;
  } else {
  	asm {
  	  mov dx, port
    	xor ax, ax
  	  in al, dx
    }
  }

}
//---------------------------------------------------------------------------
static Word __stdcall InportWord(Word port)
{
	asm {
	  mov dx, port
  	in ax, dx
  }
}
//---------------------------------------------------------------------------
static void __stdcall OutportByte(Word port, Byte data)
{

  if(GetDeviceOK()){
    AtWriteB(iatpci.cs[ATPCI_CS3]+0,port);         // port는 CPORT부터 시작한다 //(Byte)port해도 된다
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x10);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x14);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x16);
    AtWriteB(iatpci.cs[ATPCI_CS3]+0,data);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x10);
    AtWriteB(iatpci.cs[ATPCI_CS3]+4,0x00);
  } else {
  	asm {
  	  mov dx, port
    	mov	al, data
  	  out dx, al
    }
  }

}
//---------------------------------------------------------------------------
static void __stdcall OutportWord(Word port, Word data)
{
	asm {
	  mov dx, port
  	mov	ax, data
	  out dx, ax
  }
}
//---------------------------------------------------------------------------

#ifdef ACADEMY

//---------------------------------------------------------------------------
#define OK      0x4F4B

static Word CPort = 0xFEE0;
//---------------------------------------------------------------------------
// Private Function
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::status_chk(Byte d)
{
  int i, lp = 10000;

	for (i=0; i<lp; i++) {    // time delay
    if (!(InportByte(CPort)&4)) {
      if (d==1) {
        OutportByte(CPort, 0x70);
        break;
      } else if (d==2) {
        OutportByte(CPort, 0xf0);
        break;
      } else return false;
    }
  }
  for (; i<lp; i++) {
    if (d==1) {
      if (InportByte(CPort)&4) return true;
    } else if ((InportByte(CPort)&0xc)==0xc) return true;
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::send(Byte cmd, int dt)
{
  int j;

  if ((InportByte(CPort)&0xc)!=0xc) goto fail;
  OutportByte(CPort, ((dt&3)|0xc)<<4);
  OutportByte(CPort, (dt&3)<<4);
  dt >>= 2;
  if (status_chk(1)==false) goto fail;
  for (j=0; j<cmd-2; j++) {
    OutportByte(CPort, ((dt&3)|0x4)<<4);
    OutportByte(CPort, (dt&3)<<4);
    dt >>= 2;
    if (status_chk(1)==false) goto fail;
  }
  OutportByte(CPort, ((dt&3)|0x4)<<4);
  OutportByte(CPort, (((dt&3)|9)&0xb)<<4);
  if (status_chk(2)==false) goto fail;
  OutportByte(CPort, 0xf0);
  return true;
fail:
  OutportByte(CPort, 0xf0);
  return false;
}
//---------------------------------------------------------------------------
int __fastcall TProtectCard::receive()
{
  int i, j, d, dt, lp = 10000;

  for (i=j=dt=0; i<lp; i++) {      // time out check
    do d = InportByte(CPort); while(d!=InportByte(CPort));
    if (!(d&4)) {
      if (!j) {
        OutportByte(CPort, 0x30);
        dt <<= 2;
        dt |= (d&3);
        j = 1;
        if (d&8) {
          for (; i<lp; i++) { // time out check
            if (InportByte(CPort)&4) {
              for(i=0; i<30; i++) OutportByte(CPort, 0xf0);
              return dt;
            }
          }
          OutportByte(CPort, 0xf0);
          return -1;
        }
      }
    } else {
      j = 0;
      OutportByte(CPort, 0xf0);
    }
  }
  OutportByte(CPort, 0xf0);
  return -1;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::password(Byte lp, Word &pw)
{
  if (send(8, 0x5000+lp)) {
    int d = receive();
    if (d>=0) {	pw = d;	return true; }
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::GetData(Word &pw)
{
  if (send(4, 0x64)) {
    int d = receive();
    if (d>=0) {	pw = d;	return true; }
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::PutData(Word d)
{
  return send(12, 0x440000+d) && receive()==OK;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::rand16(Byte lp, Word &seed)
{
  int i, j, k;

  if (password(0, seed)) {
	  for (k=0; k<lp; k++) {
  	  i = ((seed>>9)^seed)>>3;
    	j = ((seed>>1)^seed)>>14;
	    seed <<= 1;
  	  seed |= ((i^j)&1);
	  }
  	return true;
  }
  return false;
}
//---------------------------------------------------------------------------
// Public Function
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::Init()
{
  if (!checkTime()) return false;
  int j = (CPort>>2)&0xfc;
  if (send(12, 0x410000+(j<<8)+j) && receive()==OK) {
  	return WritePassword();
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::SerialNO(Cardinal &no)
{
  if (send(4, 0x4E)) {
    int d = receive();
    if (d>=0) {	no = d;	return true; }
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::Information(Word &infor)
{
  if (send(4, 0x4D)) {
    int d = receive();
    if (d>=0) {	infor = d; return true; }
  }
	return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::ReadPassword()
{
  Word lp, pw1, pw2;

  if (GetData(lp)) {
    if (rand16(lp, pw2)) {
	    if (password(lp, pw1)) {
	      if (pw1==pw2) return true;
      }
    }
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::WritePassword()
{
  Word seed = rand();
  if (PutData(seed&0x0F)) {
	  return send(12, 0x530000+seed) && receive()==OK;
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::CheckPassword()
{
	if (ReadPassword()) {
		if (WritePassword()) return true;
  }
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::SetTimer(Byte msec)
{
  return send(8, 0x5700+msec) && receive()==OK;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::GetTimer(Byte &msec)
{
  if (send(4, 0x52)) {
    int d = receive();
    if (d>=0) { msec = d; return true; }
  }
  return false;
}
//---------------------------------------------------------------------------

#else // ACADEMY

//---------------------------------------------------------------------------

static Word CPort;
static Word CPassL, CPassH;
static Byte vBoard;
static Byte buf;

//---------------------------------------------------------------------------
__fastcall TProtectCard::TProtectCard()
{
  AppStart();
}
//---------------------------------------------------------------------------
__fastcall TProtectCard::~TProtectCard()
{
  AppEnd();
}
//---------------------------------------------------------------------------
// Private Function
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::Check(int id)
{
	int t;
  clock_t c;

	OutportByte(CPort, id);
  c = clock();
	t = 25;
  SetTimer(t);
  while (1) {
  	if (GetTimer()==t) t = t-1;
    if (t==0) break;
    if (clock()-c>=5) break;
  }
  return t<24;
}
//---------------------------------------------------------------------------
// Public Function
//---------------------------------------------------------------------------
int __fastcall TProtectCard::Init(AnsiString rfn)
{
  Byte vb;
  if(GetDeviceOK()){

    if (!checkTime()) return 0;
    CPort = CPORT;
    vb = InportByte(CPort+0x0F);
    vBoard = vb & 0x0F;//하위 4비트는 버전 정보//상위 4비트는 아이템 정보

    if (vBoard<10 || vBoard>MaxIFCVersion) {  // 10은 PCI 버전의 최소값
      return 0;
    } else {
      OutportByte(CPort, 0);// 0 == id

// 			CPassL = CPort+0x110;
//     	CPassH = CPort+0x111;
 			CPassL = CPort+0x10;
     	CPassH = CPort+0x11;

      WritePassword();

    	return ( (vb & 0xF0) << 8 ) + (InportByte(CPort+0x0A) & 0xFF);
    }
  } else {
    try {
    	TRegIniFile *RegIniFile;
      int id;

      if (!checkTime()) return 0;
    	CPort = 0xFDE0;

     	RegIniFile = new TRegIniFile(rfn);
      RegIniFile->RootKey = HKEY_LOCAL_MACHINE;
      RegIniFile->OpenKey(RegFilename + "\\",true);   // yw

      if (RegIniFile) {
        id = RegIniFile->ReadInteger("Device", "IFCid", 0);
        delete RegIniFile;
      } else id = 0;

      if (id>1) {
        switch (id) {
        	case 1: CPort = 0xFEE0; break;
         	case 2: CPort = 0xFE00; break;
    		}
        if (Check(id)==false) {
        	CPort = 0xFDE0; id = 0;
    	    if (Check(id)==false) {
      	    return 0;
          }
        }
      }

      vb = InportByte(CPort+0x0F);
      vBoard = vb & 0x0F;//하위 4비트는 버전 정보//상위 4비트는 아이템 정보

      if (vBoard<8 || vBoard>MaxIFCVersion) return 0;
      else {
    	 	RegIniFile = new TRegIniFile(rfn);
        RegIniFile->RootKey = HKEY_LOCAL_MACHINE;
        RegIniFile->OpenKey(RegFilename + "\\",true);   // yw
        if (RegIniFile) {
          id = RegIniFile->ReadInteger("Device", "IFCid", 0);
    	    delete RegIniFile;
        } else id = 0;
       	if (id>2) id = 0;
        switch (id) {
         	case 1: CPort = 0xFEE0; break;
         	case 2: CPort = 0xFE00; break;
    		}
        OutportByte(CPort, id);
    	 	if (CPort==0xFDE0) {
    			CPassL = CPort+0x110;
        	CPassH = CPort+0x111;
        } else {
    			CPassL = CPort+0x10;
    	   	CPassH = CPort+0x11;
    	  }
        WritePassword();
      	return InportByte(CPort+0x0A) & 0x7F;
        //return ( (vb & 0xF0) << 8 ) + (InportByte(CPort+0x0A) & 0xFF);// ISA 버전에는 0x7F 이상의 아이템은 없다
      }
    } catch(...) {
      return 0;
    }
  }
}
//---------------------------------------------------------------------------
int __fastcall TProtectCard::Version()
{
	return vBoard;
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::ReadPassword()
{
	Word Rand;
  int i, c1, c2;

	buf = InportByte(CPassL);
	Rand = 0x4500+buf;
	if (vBoard<4) {
  	OutportByte(CPassL, 0);
    buf = InportByte(CPassH);
    return buf==0x55;
	} else {
  	while (1) {
    	buf = InportByte(CPassH);
      if ((buf & 0x80)==0) break;
		}
    for (i=0; i<=15; i++) {
    	c1 = ((Rand >> 3) & 1) ^ ((Rand >> 12) & 1);
    	c2 = ((Rand >> 14) & 1) ^ ((Rand >> 15) & 1);
      Rand = Rand << 1;
      Rand = Rand+(c1 ^ c2);
    }
    buf = InportByte(CPassH);
    return buf==(Rand & 0x7F);
  }

}
//---------------------------------------------------------------------------
void __fastcall TProtectCard::WritePassword()
{
	Byte pass;

	if (vBoard<4) {
  	OutportByte(CPassL, 0x55);
  	OutportByte(CPassH, 0x55);
  } else {
  	pass = 0;
  	while (pass==0) {
    	pass = rand()&0xFF;
    }
  	OutportByte(CPassL, pass);
  	OutportByte(CPassH, 0x80);
  }
}
//---------------------------------------------------------------------------
bool __fastcall TProtectCard::CheckPassword()
{
	if (ReadPassword()) {
		WritePassword();
    return true;
  }
  return false;
}
//---------------------------------------------------------------------------
void __fastcall TProtectCard::SetTimer(Byte msec)
{

	OutportByte(CPort+1, msec);

}
//---------------------------------------------------------------------------
Byte __fastcall TProtectCard::GetTimer()
{

	return InportByte(CPort+1);

}
//---------------------------------------------------------------------------

#endif  // ACADEMY

#else // LOCK_IFC

//---------------------------------------------------------------------------
#ifdef NETHASP

#define IS_HASP             			 1
#define GET_HASP_CODE       			41
#define READ_MEMO           			44
#define WRITE_MEMO          			45
#define GET_HASP_STATUS     			 5
#define GET_ID_NUM          			46
#define READ_MEMO_BLOCK     			52
#define WRITE_MEMO_BLOCK    			53

#else

#define IS_HASP             			 1
#define GET_HASP_CODE       			 2
#define READ_MEMO           			 3
#define WRITE_MEMO          			 4
#define GET_HASP_STATUS     			 5
#define GET_ID_NUM          			 6
#define READ_MEMO_BLOCK     			50
#define WRITE_MEMO_BLOCK    			51

#endif
//---------------------------------------------------------------------------
static Byte DesKey[14][13] = {
    "            ",
    "eUvJ-nvh?aq9",
    "EmTxOX'60af#",
    "i'/[E15)'FU9",
    "5sv1Bt<_M,c!",
    "KF/ZPw7<HxQg",
    ".^^_;p89DF}1",
    "979A(R[jkd9s",
    "Cd\\0+[x[T8\\_",
    "$)s~18o1SZu2",
    "PiWy9.F71H(o",
    ";`s.'H/?rKYE",
    "dVlB}dIYB{$=",
    "c%aB(.*?)o)g"
};
//---------------------------------------------------------------------------
__fastcall TProtectCard::TProtectCard()
{
  Pass1 = 7221;
  hasp = NULL;
  hLibrary = LoadLibrary("haspms32.dll");
 	if (hLibrary) hasp = (THASP)GetProcAddress(hLibrary, "hasp");
  isHacking = false;
  Pass2 = 17162;

#ifdef NETHASP
  /*login*/
  int p1,p2,p3,p4;
  hasp(42, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
  hasp(40, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
  if(p1!=0)isHacking=true;
#endif
}
//---------------------------------------------------------------------------
__fastcall TProtectCard::~TProtectCard()
{
#ifdef NETHASP
  /*logout*/
  int p1,p2,p3,p4;
  hasp(43, SeedCode, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif

	if (hLibrary) FreeLibrary(hLibrary);
}
//---------------------------------------------------------------------------
int __fastcall TProtectCard::Init(int *pw)
{
  Byte blk[8], k[8] = { 'T', 'e', 'x', 'p', 'i', 'a', 0, 0 };
  int p1, p2, p3, p4, item;
  pwIndex=0;// by jeegeo

  if (!checkTime()) return -1;
  if (hasp==NULL) return -1;
  blk[0] = pw[0] & 0xFF;
  blk[1] = (pw[0] >> 8) & 0xFF;
  blk[2] = pw[1] & 0xFF;
  blk[3] = (pw[1] >> 8) & 0xFF;
  blk[4] = pw[2] & 0xFF;
  blk[5] = (pw[2] >> 8) & 0xFF;
  blk[6] = pw[3] & 0xFF;
  blk[7] = (pw[3] >> 8)&0xFF;
  decrypt(k, blk);
  SeedCode = (blk[1] << 8) | blk[0];
  Pass[0] = (blk[3] << 8) | blk[2];
  Pass[1] = (blk[5] << 8) | blk[4];
  Pass[2] = (blk[7] << 8) | blk[6];

#ifndef NETHASP
  hasp(IS_HASP, 0, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
  if (p1==0) return -2;
#endif
#ifdef NETHASP
  hasp(GET_HASP_CODE, SeedCode, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
  hasp(GET_HASP_CODE, SeedCode, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
  if (Pass[0]!=p1 || Pass[1]!=p2 || Pass[2]!=p3) return -3;
#ifdef TEXWORK
  p1 = 2;  /* Address */
  p2 = 0;
#ifdef NETHASP
  hasp(READ_MEMO, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
  hasp(READ_MEMO, 0, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
  if (p3!=0) return -4;
  return p2;
#else    
  p1 = 0;  /* Address */
 	p2 = 0;
#ifdef NETHASP
  hasp(READ_MEMO, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
  hasp(READ_MEMO, 0, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
	if (p3!=0) return -4;
  item = p2;
  p1 = 1;  /* Address */
 	p2 = 0;
#ifdef NETHASP
  hasp(READ_MEMO, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
  hasp(READ_MEMO, 0, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
	if (p3!=0) return -5;
  if (p2 == 0xFFFF) p2 = 0;
  return (p2<<14) | item;
#endif  
}
//---------------------------------------------------------------------------
int __fastcall TProtectCard::Init_country(int *pw)
{
  Byte blk[8], k[8] = { 'T', 'e', 'x', 'p', 'i', 'a', 0, 0 };
  int p1, p2, p3, p4, item;
  pwIndex=0;// by jeegeo

  if (!checkTime()) return -1;
  if (hasp==NULL) return -1;
  blk[0] = pw[0] & 0xFF;
  blk[1] = (pw[0] >> 8) & 0xFF;
  blk[2] = pw[1] & 0xFF;
  blk[3] = (pw[1] >> 8) & 0xFF;
  blk[4] = pw[2] & 0xFF;
  blk[5] = (pw[2] >> 8) & 0xFF;
  blk[6] = pw[3] & 0xFF;
  blk[7] = (pw[3] >> 8)&0xFF;
  decrypt(k, blk);
  SeedCode = (blk[1] << 8) | blk[0];
  Pass[0] = (blk[3] << 8) | blk[2];
  Pass[1] = (blk[5] << 8) | blk[4];
  Pass[2] = (blk[7] << 8) | blk[6];

#ifndef NETHASP
  hasp(IS_HASP, 0, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
  if (p1==0) return -2;
#endif
#ifdef NETHASP
  hasp(GET_HASP_CODE, SeedCode, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
  hasp(GET_HASP_CODE, SeedCode, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
  if (Pass[0]!=p1 || Pass[1]!=p2 || Pass[2]!=p3) return -3;

  p1 = 3;  /* Address */
 	p2 = 0;
#ifdef NETHASP
  hasp(READ_MEMO, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
  hasp(READ_MEMO, 0, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
	if (p3!=0) return -4;
  return p2;
}
//---------------------------------------------------------------------------
void __fastcall TProtectCard::Read()
{
  int p1, p2, p3, p4;

  if (hasp && pwIndex==0) {
    pwIndex = 1+rand()%13;
    p1 = pwIndex*4;
    p2 = 4;
    p4 = int(pwData+pwIndex*8);
#ifdef NETHASP
    hasp(READ_MEMO_BLOCK, SeedCode, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
#else
    hasp(READ_MEMO_BLOCK, SeedCode, 0, Pass1, Pass2, &p1, &p2, &p3, &p4);
#endif
  }
}
//---------------------------------------------------------------------------
void __fastcall TProtectCard::Check()
{
  Byte *pw, blk[8];

  if (hasp && pwIndex) {
    pw = (Byte *)malloc(112);
    if (pw) {
      memcpy(pw, pwData, 112);
      memcpy(blk, pw+pwIndex*8, 8);
      strcpy(DesKey[0], DesKey[pwIndex]);
      decrypt(DesKey[0], blk);
      isHacking = (SeedCode==((blk[1]<<8)|blk[0])) &&
                  (Pass[0]==((blk[3]<<8)|blk[2])) &&
                  (Pass[1]==((blk[5]<<8)|blk[4])) &&
                  (Pass[2]==((blk[7]<<8)|blk[6])) ? false : true;
      pwIndex = 0;
      free(pw);
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TProtectCard::Lock_Check()
{
#ifndef LOCK_CRYPKEY        //Configuration이 CrypKey로 Compile 되기 때문에...
#ifdef TEXTILE
  TPException ec = EC_NONE;
  int Items;
//==============================================================================
  unsigned char blk[8], k[8] = { 'T', 'e', 'x', 'p', 'i', 'a', 0, 0 };
  unsigned char blk2[8], k2[8] = { 'T', 'e', 'x', 'p', 'i', 'a', 0, 0 };
  int p1, p2, p3, p4;
  Byte *pw;
  Byte blk_check[8], k_check[8] = { 'T', 'e', 'x', 'p', 'i', 'a', 0, 0 };
  int SeedCode2, Pass_2[3], Password_hasp[4];
	TRegIniFile *RegIniFile;
  AnsiString pw1;

 	RegIniFile = new TRegIniFile(RegFilename);
  RegIniFile->RootKey = HKEY_LOCAL_MACHINE;
  RegIniFile->OpenKey(RegFilename + "\\",true);   // yw
  if (RegIniFile) {
    pw1 = RegIniFile->ReadString("Common", "Serial", "");
    sscanf(pw1.c_str(), "%d-%d-%d-%d", &Password[0], &Password[1], &Password[2], &Password[3]);
  }

  blk_check[0] = Password[0] & 0xFF;
  blk_check[1] = (Password[0] >> 8) & 0xFF;
  blk_check[2] = Password[1] & 0xFF;
  blk_check[3] = (Password[1] >> 8) & 0xFF;
  blk_check[4] = Password[2] & 0xFF;
  blk_check[5] = (Password[2] >> 8) & 0xFF;
  blk_check[6] = Password[3] & 0xFF;
  blk_check[7] = (Password[3] >> 8)&0xFF;
  decrypt(k_check, blk_check);
  SeedCode = (blk_check[1] << 8) | blk_check[0];

  hasp(GET_HASP_CODE, SeedCode, 1, Pass1, Pass2, &Pass[0], &Pass[1], &Pass[2], &p4);

  blk[0] = SeedCode & 0xFF;
  blk[1] = (SeedCode >> 8) & 0xFF;
  blk[2] = Pass[0] & 0xFF;
  blk[3] = (Pass[0] >> 8) & 0xFF;
  blk[4] = Pass[1] & 0xFF;
  blk[5] = (Pass[1] >> 8) & 0xFF;
  blk[6] = Pass[2] & 0xFF;
  blk[7] = (Pass[2] >> 8) & 0xFF;

  encrypt(k, blk);

  Password_hasp[0] = (blk[1]<<8)|blk[0];
  Password_hasp[1] = (blk[3]<<8)|blk[2];
  Password_hasp[2] = (blk[5]<<8)|blk[4];
  Password_hasp[3] = (blk[7]<<8)|blk[6];

  blk2[0] = Password_hasp[0] & 0xFF;
  blk2[1] = (Password_hasp[0] >> 8) & 0xFF;
  blk2[2] = Password_hasp[1] & 0xFF;
  blk2[3] = (Password_hasp[1] >> 8) & 0xFF;
  blk2[4] = Password_hasp[2] & 0xFF;
  blk2[5] = (Password_hasp[2] >> 8) & 0xFF;
  blk2[6] = Password_hasp[3] & 0xFF;
  blk2[7] = (Password_hasp[3] >> 8)&0xFF;

  decrypt(k2, blk2);

  SeedCode2 = (blk2[1] << 8) | blk2[0];
  Pass_2[0] = (blk2[3] << 8) | blk2[2];
  Pass_2[1] = (blk2[5] << 8) | blk2[4];
  Pass_2[2] = (blk2[7] << 8) | blk2[6];

  hasp(GET_HASP_CODE, SeedCode2, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);

  if (Pass_2[0] == p1 && Pass_2[1] == p2 && Pass_2[2] == p3) {
    if (hasp) {
      pwIndex = 1;
      p1 = pwIndex*4;
      p2 = 4;
      p4 = int(pwData+pwIndex*8);
      hasp(READ_MEMO_BLOCK, SeedCode, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
    }
    if (hasp) {
      pw = (Byte *)malloc(112);
      if (pw) {
        memcpy(pw, pwData, 112);
        memcpy(blk2, pw+pwIndex*8, 8);
        strcpy(DesKey[0], DesKey[pwIndex]);
        decrypt(DesKey[0], blk2);
        isHacking = (SeedCode2==((blk2[1]<<8)|blk2[0])) ? false : true;
        free(pw);
      }
    }
    if(isHacking) {
      ec = EC_HASPKEYNOTFOUND;
      goto fail;
    }
  }
//==============================================================================
  p1 = 0;  /* Address */
 	p2 = 0;
  hasp(READ_MEMO, 0, 1, Pass1, Pass2, &p1, &p2, &p3, &p4);
  Items = p2;
  if ((((Items>>14)&3)==3) || Items<1 || (Items&PCN_N3D)!=PCN_N3D) {
    ec = EC_HASPKEYNOTFOUND; goto fail;
  }
  return;
fail:
  EXCEPTION_MESSAGE_OK(ec);
	Application->Terminate();
#endif
#endif
}
//---------------------------------------------------------------------------

#endif  // LOCK_IFC
//#endif  // defined not crypkey.....