//--------------------------------------------------------------------------- #pragma hdrstop #include "Crypt.h" //--------------------------------------------------------------------------- #pragma package(smart_init) //--------------------------------------------------------------------------- TCrypt *Crypt; // sprintf 함수를 사용하여 DWORD 값을 BYTE형 배열에 담을 때와 // BYTE형 배열을 AnsiString::sprintf 함수를 사용하여 AnsiString에 담을 때 배열의 순서가 다름을 유의한다 //--------------------------------------------------------------------------- __fastcall TCrypt::TCrypt() { // 생성자 nCodeLen = 0; // 암호화, 복호화 코드의 문자열 길이 nOddLen = 0; // nCodeLen / 2 // 홀수번째 코드의 문자열 길이 nRetLen = 0; // nCodeLen + 2 // 리턴 코드용으로 '\0'을 붙일 문자열 길이 nHexLen = 0; // nCodeLen*4 // 비트를 뒤집을때 사용 } //--------------------------------------------------------------------------- __fastcall TCrypt::~TCrypt() { // 소멸자 } //--------------------------------------------------------------------------- AnsiString __fastcall TCrypt::OldEnCode(AnsiString strCode, int nKey) { // 암호화 // 암호화 방법 : // 스타일리스트가 설치된 하드디스크 드라이브의 시리얼번호를 AnsiString으로 받는다 // AnsiString으로 받은 값을 Hex값으로 변환한다 // 첫 번째 작업 : Hex 값으로 한자리 마다 짝수일 경우 Not연산을 한다 // 두 번째 작업 : 첫 번쨰 깂을 Hex 값으로 한자리 마다 홀수일 경우 거꾸로 배열한다 // 세 번째 작업 : 두 번째 값의 비트를 뒤집는다 (즉, 첫번째 비트와 마지막 비트를 swap) // 이 값의 Hex값이 결과코드이다 // 예) D04A9883 일 경우 비트화하면 // 1101 0000 0100 1010 1001 1000 1000 0011 // ①홀 ②짝 ③홀 ④짝 ⑤홀 ⑥짝 ⑦홀 ⑧짝 // D 0 4 A 9 8 8 3 // // 1101 1111 0101 0101 1001 0111 1000 1100 - 첫 번째 작업 // ①홀 ②짝 ③홀 ④짝 ⑤홀 ⑥짝 ⑦홀 ⑧짝 // D F 4 5 9 7 8 C // // 1000 1111 1001 0101 0100 0111 1101 1100 - 두 번째 작업 // ⑦홀 ②짝 ⑤홀 ④짝 ③홀 ⑥짝 ①홀 ⑧짝 // 8 F 9 5 4 7 D C // // 0011 1011 1110 0010 1010 1001 1111 0001 - 세 번째 작업 // ⑦홀 ②짝 ⑤홀 ④짝 ③홀 ⑥짝 ①홀 ⑧짝 // 3 B E 2 A 9 F 1 DWORD dwHexCode; DWORD dwEnCode; BYTE *cCode; BYTE *cTempCode; BYTE *cOddCode; BYTE *cHexCode; BYTE *cEnCode; BYTE *cReturnCode; AnsiString strReturnCode = ""; int nPointPosition; // 초기화 strCode = strCode.UpperCase(); // 받은 문자열을 전부 대문자로.. nPointPosition = strCode.Pos("."); strCode = strCode.Delete(nPointPosition, 1); nCodeLen = strCode.Length(); // 암호화, 복호화 코드의 문자열 길이 nOddLen = nCodeLen / 2; // nCodeLen / 2 // 홀수번째 코드의 문자열 길이 nRetLen = nCodeLen + 1; // nCodeLen + 1 // 리턴 코드용으로 '\0'을 붙일 문자열 길이 nHexLen = nCodeLen * 4; // nCodeLen*4 // 비트를 뒤집을때 사용 cCode = new BYTE[nCodeLen]; cTempCode = new BYTE[nCodeLen]; cOddCode = new BYTE[nCodeLen]; cHexCode = new BYTE[nCodeLen]; cEnCode = new BYTE[nCodeLen]; cReturnCode = new BYTE[nRetLen]; memset(cCode, 0, sizeof(BYTE)*nCodeLen); memset(cTempCode, 0, sizeof(BYTE)*nCodeLen); memset(cOddCode, 0, sizeof(BYTE)*nCodeLen); memset(cHexCode, 0, sizeof(BYTE)*nCodeLen); memset(cEnCode, 0, sizeof(BYTE)*nCodeLen); memset(cReturnCode, 0, sizeof(BYTE)*nRetLen); strncpy(cTempCode, strCode.c_str(), nCodeLen); // 일단 복사 for (int i = 0; i < nCodeLen; i++) { // 문자를 HEX 값으로 바꾼다 if ('A' <= cTempCode[i] && cTempCode[i] <= 'F') { cCode[nCodeLen-i-1] = cTempCode[i] - 'A' + 0xA; } else if ('0' <= cTempCode[i] && cTempCode[i] <= '9') { cCode[nCodeLen-i-1] = cTempCode[i] - '0' - 0x00; // 보기 좋으라고 0x00 추가 } else { return strReturnCode; } } for (int i = 0, j = 0; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (첫 번째 작업을 위한 작업) cHexCode[i] = cCode[i]; cOddCode[j] = cCode[i]; j++; } else { // 짝수일 때.. (두 번째 작업) cHexCode[i] = (~cCode[i] & 0x0F); } } for (int i = 0, j = nOddLen - 1; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (첫 번째 작업) cHexCode[i] = cOddCode[j]; j--; } } dwHexCode = 0; // BYTE형 배열의 값을 DWORD에 담는다 for (int i = 1; i <= nCodeLen; i++) { dwHexCode += (cHexCode[nCodeLen-i] & 0x0F); if (i < nCodeLen) dwHexCode = ((dwHexCode << 4) & 0xFFFFFFF0); } dwEnCode = 0; for (int i = 0; i < nHexLen; i++) { // 세 번째 작업 dwEnCode += (dwHexCode >> i) & 1; if (i < nHexLen-1) dwEnCode = (dwEnCode << 1); } //---------------------------------------------------------------------- key if (nKey){ int nTempKey, nQuotient, nRemainder; // 몫과 나머지 int nIntKey, nOrderKey[3] = {0, 0, 0}; DWORD dwMask, dwMask1, dwMask2, dwMask3, dwMask4; // nKey와 상관관계에 의해 나오는 DWORD 값 (네 번째 작업 용) nIntKey = nKey; nQuotient = 1; for (int i = 0, nTempKey = nKey; (nQuotient > 0 && i < 3); i++) { nQuotient = nTempKey / 10; nRemainder = nTempKey % 10; if (nQuotient > 0 || nRemainder > 0){ nTempKey = nQuotient; //if (nRemainder == 0) nRemainder = 1; //1216 nOrderKey[i] = nRemainder; } } // nKey가 세 자리가 아닌 경우 이전 자리의 nOrderKey로 채워준다 for (int i = 1; i < 3; i++){ if (nOrderKey[i] == 0) nOrderKey[i] = nOrderKey[i - 1]; } //1216 /* nIntKey = dKey; nKey1 = dKey; nKey2 = dKey; // 정수 첫번째 자리 (0일 경우는 반드시 피해야한다) nKey3 = dKey; // 소수점 이하 첫째자리 (0일 경우는 반드시 피해야한다) nIntKey = ((int)((dKey * 10) + 0.5)); // 정수 부분 if (nIntKey == 0) nIntKey = 10; nKey1 = ((int)((dKey * 10) + 0.5)); // 정수 둘쨰 자리 if (0 >= nKey1 && nKey1 <= 100) { nKey1 = 10; } else if (10 <= nKey1 && nKey1 < 100) { nKey1 /= 10; } nKey2 = ((int)((dKey * 10) + 0.5)) % 10; // 정수 첫번째 자리 (0일 경우는 반드시 피해야한다) if (nKey2 == 0) nKey2 = 10; nKey3 = (int)(dKey); // 소수점 이하 첫째자리 (0일 경우는 반드시 피해야한다) if (nKey3 == 0) nKey3 = 10; */ dwMask = 0; dwMask1 = 0; dwMask2 = 0; dwMask3 = 0; dwMask4 = 0; for (int i = 0; i < nHexLen; i++) { // 마스크를 만든다 if (!(i % (nOrderKey[0] + 1))) dwMask1 += 1; if (i < nHexLen-1) dwMask1 = (dwMask1 << 1); if (!(i % (nOrderKey[1] + 1))) dwMask2 += 1; if (i < nHexLen-1) dwMask2 = (dwMask2 << 1); if (!(i % (nOrderKey[2] + 1))) dwMask3 += 1; if (i < nHexLen-1) dwMask3 = (dwMask3 << 1); if (!(i == nIntKey)) dwMask4 += 1; if (i < nHexLen-1) dwMask4 = (dwMask4 << 1); } dwMask = (nIntKey << nOrderKey[0]) | (nIntKey >> nOrderKey[1]) | (nIntKey ^ nOrderKey[2]) + ((dwMask1 | dwMask2 | dwMask3 | dwMask4) << nIntKey) + nIntKey; DWORD temp = 0; for (int i = 0; i < nCodeLen; i++){ temp = temp << 4; temp += 0x0F; } dwMask = dwMask & temp; dwEnCode ^= dwMask; } //------------------------------- BYTE *cTempCode2; cTempCode2 = new BYTE[nRetLen]; BYTE ctemp; unsigned long iEnCode = 0, nShift = 1; iEnCode = dwEnCode; nShift = 1 << (nCodeLen - 1)*4; memset(cTempCode2, '\0', sizeof(BYTE)*nRetLen); for (int j = nCodeLen - 1 ; j >= 0; j--){ ctemp = iEnCode / nShift; iEnCode -= ctemp * nShift ; nShift >>= 4; if (10 <= ctemp && ctemp <= 15){ ctemp = ctemp - 0x0A + 'A'; } else { ctemp = ctemp - 0x00 + '0'; } cTempCode2[nCodeLen - 1 - j] = ctemp; } if (nCodeLen >= 8) cTempCode2[8] = '\0'; else cTempCode2[nCodeLen] = '\0'; //sprintf(cReturnCode, "%X", dwEnCode); // DWORD형을 다시 BYTE형 배열에 담는다 strReturnCode = strReturnCode.sprintf(cTempCode2); // 문자열을 AnsiString에 담는다 if (cCode) { delete [] cCode; cCode = NULL; } if (cTempCode) { delete [] cTempCode; cTempCode = NULL; } if (cOddCode) { delete [] cOddCode; cOddCode = NULL; } if (cHexCode) { delete [] cHexCode; cHexCode = NULL; } if (cEnCode) { delete [] cEnCode; cEnCode = NULL; } if (cReturnCode) { delete [] cReturnCode; cReturnCode = NULL; } if (cTempCode2) { delete [] cTempCode2; cTempCode2 = NULL; } if (nPointPosition > 0) { strReturnCode.Insert(".", nPointPosition); } return strReturnCode; // AnsiString형으로 Return } //--------------------------------------------------------------------------- AnsiString __fastcall TCrypt::OldDeCode(AnsiString strCode, int nKey) { // 복호화 (암호화의 역순) // 복호화 방법 : // 스타일리스트가 설치된 하드디스크 드라이브의 암호화된 시리얼번호를 AnsiString으로 받는다 // AnsiString으로 받은 값을 Hex값으로 변환한다 // 첫 번째 작업 : 첫 번째 값의 비트를 뒤집는다 (즉, 첫번째 비트와 마지막 비트를 swap) // 두 번째 작업 : 두 번쨰 깂을 Hex 값으로 한자리 마다 홀수일 경우 거꾸로 배열한다 // 세 번째 작업 : Hex 값으로 한자리 마다 짝수일 경우 Not연산을 한다 // 네 번째 작업 : Hex 값으로 한자리 마다 짝수일 경우 Not연산을 한다 // 암호화의 역순!! DWORD dwCode; DWORD dwHexCode; DWORD dwDeCode; BYTE *cCode; BYTE *cTempCode; BYTE *cOddCode; BYTE *cHexCode; BYTE *cDeCode; BYTE *cReturnCode; int nCount; // DWORD에서 4Bit씩 끊어서 문자열에 담을때 사용 AnsiString strReturnCode = ""; int nPointPosition; // 초기화 strCode = strCode.UpperCase(); // 받은 문자열을 전부 대문자로.. nPointPosition = strCode.Pos("."); strCode = strCode.Delete(nPointPosition, 1); nCodeLen = strCode.Length(); // 암호화, 복호화 코드의 문자열 길이 nOddLen = nCodeLen / 2; // nCodeLen / 2 // 홀수번째 코드의 문자열 길이 nRetLen = nCodeLen + 1; // nCodeLen + 1 // 리턴 코드용으로 '\0'을 붙일 문자열 길이 nHexLen = nCodeLen * 4; // nCodeLen*4 // 비트를 뒤집을때 사용 cCode = new BYTE[nCodeLen]; cTempCode = new BYTE[nCodeLen]; cOddCode = new BYTE[nOddLen]; cHexCode = new BYTE[nCodeLen]; cDeCode = new BYTE[nCodeLen]; cReturnCode = new BYTE[nRetLen]; memset(cCode, 0, sizeof(BYTE)*nCodeLen); memset(cTempCode, 0, sizeof(BYTE)*nCodeLen); memset(cOddCode, 0, sizeof(BYTE)*nOddLen); memset(cHexCode, 0, sizeof(BYTE)*nCodeLen); memset(cDeCode, 0, sizeof(BYTE)*nCodeLen); memset(cReturnCode, 0, sizeof(BYTE)*nRetLen); strncpy(cTempCode, strCode.c_str(), nCodeLen); // 일단 복사 for (int i = 0; i < nCodeLen; i++) { // 문자를 HEX 값으로 바꾼다 if ('A' <= cTempCode[i] && cTempCode[i] <= 'F') { cHexCode[nCodeLen-i-1] = cTempCode[i] - 'A' + 0xA; } else if ('0' <= cTempCode[i] && cTempCode[i] <= '9') { cHexCode[nCodeLen-i-1] = cTempCode[i] - '0' + 0x00; // 보기 좋으라고 0x00 추가 } else { return ""; } } dwHexCode = 0; // BYTE형 배열의 값을 DWORD에 담는다 for (int i = 1; i <= nCodeLen; i++) { dwHexCode += (cHexCode[nCodeLen-i] & 0x0F); if (i < nCodeLen) dwHexCode = ((dwHexCode << 4) & 0xFFFFFFF0); } //------------------ key if (nKey){ int nTempKey, nQuotient, nRemainder; // 몫과 나머지 int nIntKey, nOrderKey[3] = {0, 0, 0}; DWORD dwMask, dwMask1, dwMask2, dwMask3, dwMask4; // nKey와 상관관계에 의해 나오는 DWORD 값 (네 번째 작업 용) nIntKey = nKey; nQuotient = 1; for (int i = 0, nTempKey = nKey; (nQuotient > 0 && i < 3); i++) { nQuotient = nTempKey / 10; nRemainder = nTempKey % 10; if (nQuotient > 0 || nRemainder > 0){ nTempKey = nQuotient; // if (nRemainder == 0) nRemainder = 1; nOrderKey[i] = nRemainder; } } // for (int i = 1; i < 3; i++){ // if (nOrderKey[i] == 0) nOrderKey[i] = nOrderKey[i - 1]; // } /* nIntKey = ((int)((dKey * 10) + 0.5)); // 정수 부분 if (nIntKey == 0) nIntKey = 10; nKey1 = ((int)((dKey * 10) + 0.5)); // 정수 둘쨰 자리 if (0 >= nKey1 && nKey1 <= 100) { nKey1 = 10; } else if (10 <= nKey1 && nKey1 < 100) { nKey1 /= 10; } nKey2 = ((int)((dKey * 10) + 0.5)) % 10; // 정수 첫번째 자리 (0일 경우는 반드시 피해야한다) if (nKey2 == 0) nKey2 = 10; nKey3 = (int)(dKey); // 소수점 이하 첫째자리 (0일 경우는 반드시 피해야한다) if (nKey3 == 0) nKey3 = 10; */ dwMask = 0; dwMask1 = 0; dwMask2 = 0; dwMask3 = 0; dwMask4 = 0; for (int i = 0; i < nHexLen; i++) { // 마스크를 만든다 if (!(i % (nOrderKey[0] + 1))) dwMask1 += 1; if (i < nHexLen-1) dwMask1 = (dwMask1 << 1); if (!(i % (nOrderKey[1] + 1))) dwMask2 += 1; if (i < nHexLen-1) dwMask2 = (dwMask2 << 1); if (!(i % (nOrderKey[2] + 1))) dwMask3 += 1; if (i < nHexLen-1) dwMask3 = (dwMask3 << 1); if (!(i == nIntKey)) dwMask4 += 1; if (i < nHexLen-1) dwMask4 = (dwMask4 << 1); } dwMask = (nIntKey << nOrderKey[0]) | (nIntKey >> nOrderKey[1]) | (nIntKey ^ nOrderKey[2]) + ((dwMask1 | dwMask2 | dwMask3 | dwMask4) << nIntKey) + nIntKey; DWORD temp = 0; for (int i = 0; i < nCodeLen; i++){ temp = temp << 4; temp += 0x0F; } dwMask = dwMask & temp; dwHexCode ^= dwMask; } //------------------------------- dwDeCode = 0; // 첫 번째 작업 for (int i = 0; i < nHexLen; i++) { dwDeCode += (dwHexCode >> i) & 1; if (i> nCount*4) & 0x0F; i++; nCount++; } for (int i = 0, j = 0; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (두 번째 작업을 위한 작업) cDeCode[i] = cCode[i]; cOddCode[j] = cCode[i]; j++; } else { // 짝수일 때.. (세 번째 작업) cDeCode[i] = (~cCode[i] & 0x0F); } } for (int i = 0, j = nOddLen - 1; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (두 번째 작업) cDeCode[i] = cOddCode[j]; j--; } } for (int i = 0; i < nCodeLen; i++) { if (0x00 <= cDeCode[i] && cDeCode[i] <= 0x09) { cReturnCode[nCodeLen-i-1] = cDeCode[i] + '0' - 0x00; // 보기 좋으라고 0x00 추가 } else if (0x0A <= cDeCode[i] && cDeCode[i] <= 0x0F) { cReturnCode[nCodeLen-i-1] = cDeCode[i] + 'A' - 0x0A; } else { return strReturnCode; } } cReturnCode[nCodeLen] = '\0'; // 종료 문자열 추가 strReturnCode = strReturnCode.sprintf(cReturnCode); // 문자열을 AnsiString에 담는다 strReturnCode = strReturnCode.UpperCase(); // 대문자로.. if (cCode) { delete [] cCode; cCode = NULL; } if (cTempCode) { delete [] cTempCode; cTempCode = NULL; } if (cOddCode) { delete [] cOddCode; cOddCode = NULL; } if (cHexCode) { delete [] cHexCode; cHexCode = NULL; } if (cDeCode) { delete [] cDeCode; cDeCode = NULL; } if (cReturnCode) { delete [] cReturnCode; cReturnCode = NULL;} if (nPointPosition > 0) { strReturnCode.Insert(".", nPointPosition); } return strReturnCode; // AnsiString형으로 Return } //--------------------------------------------------------------------------- AnsiString __fastcall TCrypt::EnCode(AnsiString strCode, double dKey1, unsigned int nKey2) { // 암호화 // 암호화 방법 : // 스타일리스트가 설치된 하드디스크 드라이브의 시리얼번호를 AnsiString으로 받는다 // AnsiString으로 받은 값을 Hex값으로 변환한다 // 첫 번째 작업 : Hex 값으로 한자리 마다 짝수일 경우 Not연산을 한다 // 두 번째 작업 : 첫 번쨰 깂을 Hex 값으로 한자리 마다 홀수일 경우 거꾸로 배열한다 // 세 번째 작업 : 두 번째 값의 비트를 뒤집는다 (즉, 첫번째 비트와 마지막 비트를 swap) // 이 값의 Hex값이 결과코드이다 // 예) D04A9883 일 경우 비트화하면 // 1101 0000 0100 1010 1001 1000 1000 0011 // ①홀 ②짝 ③홀 ④짝 ⑤홀 ⑥짝 ⑦홀 ⑧짝 // D 0 4 A 9 8 8 3 // // 1101 1111 0101 0101 1001 0111 1000 1100 - 첫 번째 작업 // ①홀 ②짝 ③홀 ④짝 ⑤홀 ⑥짝 ⑦홀 ⑧짝 // D F 4 5 9 7 8 C // // 1000 1111 1001 0101 0100 0111 1101 1100 - 두 번째 작업 // ⑦홀 ②짝 ⑤홀 ④짝 ③홀 ⑥짝 ①홀 ⑧짝 // 8 F 9 5 4 7 D C // // 0011 1011 1110 0010 1010 1001 1111 0001 - 세 번째 작업 // ⑦홀 ②짝 ⑤홀 ④짝 ③홀 ⑥짝 ①홀 ⑧짝 // 3 B E 2 A 9 F 1 BYTE *cCode; BYTE *cOddCode; BYTE *cEnCode; BYTE *cReturnCode; AnsiString strAddZero, strReturnCode = ""; // 초기화 if (dKey1 == 0.0 && nKey2 == 0) { nCodeLen = strCode.Length(); // 암호화, 복호화 코드의 문자열 길이 } else { nCodeLen = 8; strAddZero = AnsiString::StringOfChar('0', 8-strCode.Length()); strCode = strAddZero + strCode; } nOddLen = nCodeLen / 2; // nCodeLen / 2 // 홀수번째 코드의 문자열 길이 nRetLen = nCodeLen + 1; // nCodeLen + 1 // 리턴 코드용으로 '\0'을 붙일 문자열 길이 nHexLen = nCodeLen * 4; // nCodeLen*4 // 비트를 뒤집을때 사용 cCode = new BYTE[nCodeLen]; cOddCode = new BYTE[nCodeLen]; cEnCode = new BYTE[nCodeLen]; cReturnCode = new BYTE[nRetLen]; memset(cCode, 0, sizeof(BYTE)*nCodeLen); memset(cOddCode, 0, sizeof(BYTE)*nCodeLen); memset(cEnCode, 0, sizeof(BYTE)*nCodeLen); memset(cReturnCode, 0, sizeof(BYTE)*nRetLen); strncpy(cCode, strCode.c_str(), nCodeLen); // 일단 복사 for (int i = 0, j = 0; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (첫 번째 작업을 위한 작업) cEnCode[i] = cCode[i]; cOddCode[j] = cCode[i]; j++; } else { // 짝수일 때.. (두 번째 작업) cEnCode[i] = (~cCode[i] & 0xFF); } } for (int i = 0, j = nOddLen - 1; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (첫 번째 작업) cEnCode[i] = cOddCode[j]; j--; } } //---------------------------------------------------------------------- key if (dKey1 > 0.0 && nKey2 > 0) { int nTempKey, nQuotient, nRemainder; // 몫과 나머지 int nIntKey, nOrderKey[4] = {0, 0, 0, 0}; nIntKey = ((dKey1 + 0.005) * 100) + nKey2; nQuotient = 1; for (int i = 0, nTempKey = nIntKey; (nQuotient > 0 && i < 4); i++) { nQuotient = nTempKey / 10; nRemainder = nTempKey % 10; if (nQuotient > 0 || nRemainder > 0){ nTempKey = nQuotient; nOrderKey[i] = nRemainder; } } cEnCode[0] = BitShift(cEnCode[0], nOrderKey[0], true); cEnCode[1] = BitShift(cEnCode[1], nOrderKey[1], true); cEnCode[2] = BitShift(cEnCode[2], nOrderKey[2], true); cEnCode[3] = BitShift(cEnCode[3], nOrderKey[3], true); cEnCode[4] = BitShift(cEnCode[4], nOrderKey[3], true); cEnCode[5] = BitShift(cEnCode[5], nOrderKey[2], true); cEnCode[6] = BitShift(cEnCode[6], nOrderKey[1], true); cEnCode[7] = BitShift(cEnCode[7], nOrderKey[0], true); } else if (dKey1 > 0.0) { int nTempKey, nQuotient, nRemainder; // 몫과 나머지 int nIntKey, nOrderKey[3] = {0, 0, 0}; nIntKey = (dKey1 + 0.005) * 100 + nKey2; nQuotient = 1; for (int i = 0, nTempKey = nIntKey; (nQuotient > 0 && i < 3); i++) { nQuotient = nTempKey / 10; nRemainder = nTempKey % 10; if (nQuotient > 0 || nRemainder > 0){ nTempKey = nQuotient; nOrderKey[i] = nRemainder; } } cEnCode[0] = BitShift(cEnCode[0], nOrderKey[0], true); cEnCode[1] = BitShift(cEnCode[1], nOrderKey[1], true); cEnCode[2] = BitShift(cEnCode[2], nOrderKey[2], true); cEnCode[3] = BitShift(cEnCode[3], nOrderKey[2], true); cEnCode[4] = BitShift(cEnCode[4], nOrderKey[1], true); cEnCode[5] = BitShift(cEnCode[5], nOrderKey[0], true); cEnCode[6] = BitShift(cEnCode[6], nOrderKey[1], true); cEnCode[7] = BitShift(cEnCode[7], nOrderKey[2], true); } else if (nKey2 > 0) { /* cEnCode[0] = BitShift(cEnCode[0], nKey2, true); cEnCode[1] = BitShift(cEnCode[1], nKey2, true); cEnCode[2] = BitShift(cEnCode[2], nKey2, true); cEnCode[3] = BitShift(cEnCode[3], nKey2, true); cEnCode[4] = BitShift(cEnCode[4], nKey2, true); cEnCode[5] = BitShift(cEnCode[5], nKey2, true); cEnCode[6] = BitShift(cEnCode[6], nKey2, true); cEnCode[7] = BitShift(cEnCode[7], nKey2, true); */ ByteShift(cEnCode, nKey2, true); } if (dKey1 > 0.0 || nKey2 > 0) { strReturnCode = "00000000"; } else { strAddZero = AnsiString::StringOfChar(' ', strCode.Length()); strReturnCode = strAddZero; } for (int i = 0; i < nCodeLen; i++) { strReturnCode.c_str()[i] = cEnCode[i]; } if (cCode) { delete [] cCode; cCode = NULL; } if (cOddCode) { delete [] cOddCode; cOddCode = NULL; } if (cEnCode) { delete [] cEnCode; cEnCode = NULL; } if (cReturnCode) { delete [] cReturnCode; cReturnCode = NULL; } return strReturnCode; // AnsiString형으로 Return } //--------------------------------------------------------------------------- AnsiString __fastcall TCrypt::DeCode(AnsiString strCode, double dKey1, unsigned int nKey2) { // 복호화 (암호화의 역순) // 복호화 방법 : // 스타일리스트가 설치된 하드디스크 드라이브의 암호화된 시리얼번호를 AnsiString으로 받는다 // AnsiString으로 받은 값을 Hex값으로 변환한다 // 첫 번째 작업 : 첫 번째 값의 비트를 뒤집는다 (즉, 첫번째 비트와 마지막 비트를 swap) // 두 번째 작업 : 두 번쨰 깂을 Hex 값으로 한자리 마다 홀수일 경우 거꾸로 배열한다 // 세 번째 작업 : Hex 값으로 한자리 마다 짝수일 경우 Not연산을 한다 // 네 번째 작업 : Hex 값으로 한자리 마다 짝수일 경우 Not연산을 한다 // 암호화의 역순!! BYTE *cCode; BYTE *cOddCode; BYTE *cDeCode; BYTE *cReturnCode; int nCount; // DWORD에서 4Bit씩 끊어서 문자열에 담을때 사용 AnsiString strReturnCode = ""; int nPointPosition; // 초기화 if (dKey1 == 0.0 && nKey2 == 0) { nCodeLen = strCode.Length(); // 암호화, 복호화 코드의 문자열 길이 } else { nCodeLen = 8; } nCodeLen = strCode.Length(); // 암호화, 복호화 코드의 문자열 길이 nOddLen = nCodeLen / 2; // nCodeLen / 2 // 홀수번째 코드의 문자열 길이 nRetLen = nCodeLen + 1; // nCodeLen + 1 // 리턴 코드용으로 '\0'을 붙일 문자열 길이 nHexLen = nCodeLen * 4; // nCodeLen*4 // 비트를 뒤집을때 사용 cCode = new BYTE[nCodeLen]; cOddCode = new BYTE[nOddLen]; cDeCode = new BYTE[nCodeLen]; cReturnCode = new BYTE[nRetLen]; memset(cCode, 0, sizeof(BYTE)*nCodeLen); memset(cOddCode, 0, sizeof(BYTE)*nOddLen); memset(cDeCode, 0, sizeof(BYTE)*nCodeLen); memset(cReturnCode, 0x20, sizeof(BYTE)*nRetLen); // 공백 strncpy(cCode, strCode.c_str(), nCodeLen); // 일단 복사 //---------------------------------------------------------------------- key if (dKey1 > 0.0 && nKey2 > 0) { int nTempKey, nQuotient, nRemainder; // 몫과 나머지 int nIntKey, nOrderKey[4] = {0, 0, 0, 0}; nIntKey = ((dKey1 + 0.005) * 100) + nKey2; nQuotient = 1; for (int i = 0, nTempKey = nIntKey; (nQuotient > 0 && i < 4); i++) { nQuotient = nTempKey / 10; nRemainder = nTempKey % 10; if (nQuotient > 0 || nRemainder > 0){ nTempKey = nQuotient; nOrderKey[i] = nRemainder; } } cCode[0] = BitShift(cCode[0], nOrderKey[0], false); cCode[1] = BitShift(cCode[1], nOrderKey[1], false); cCode[2] = BitShift(cCode[2], nOrderKey[2], false); cCode[3] = BitShift(cCode[3], nOrderKey[3], false); cCode[4] = BitShift(cCode[4], nOrderKey[3], false); cCode[5] = BitShift(cCode[5], nOrderKey[2], false); cCode[6] = BitShift(cCode[6], nOrderKey[1], false); cCode[7] = BitShift(cCode[7], nOrderKey[0], false); } else if (dKey1 > 0.0) { int nTempKey, nQuotient, nRemainder; // 몫과 나머지 int nIntKey, nOrderKey[3] = {0, 0, 0}; nIntKey = (dKey1 + 0.005) * 100; nQuotient = 1; for (int i = 0, nTempKey = nIntKey; (nQuotient > 0 && i < 3); i++) { nQuotient = nTempKey / 10; nRemainder = nTempKey % 10; if (nQuotient > 0 || nRemainder > 0){ nTempKey = nQuotient; nOrderKey[i] = nRemainder; } } cCode[0] = BitShift(cCode[0], nOrderKey[0], false); cCode[1] = BitShift(cCode[1], nOrderKey[1], false); cCode[2] = BitShift(cCode[2], nOrderKey[2], false); cCode[3] = BitShift(cCode[3], nOrderKey[2], false); cCode[4] = BitShift(cCode[4], nOrderKey[1], false); cCode[5] = BitShift(cCode[5], nOrderKey[0], false); cCode[6] = BitShift(cCode[6], nOrderKey[1], false); cCode[7] = BitShift(cCode[7], nOrderKey[2], false); } else if (nKey2 > 0) { /* cCode[0] = BitShift(cCode[0], nKey2, false); cCode[1] = BitShift(cCode[1], nKey2, false); cCode[2] = BitShift(cCode[2], nKey2, false); cCode[3] = BitShift(cCode[3], nKey2, false); cCode[4] = BitShift(cCode[4], nKey2, false); cCode[5] = BitShift(cCode[5], nKey2, false); cCode[6] = BitShift(cCode[6], nKey2, false); cCode[7] = BitShift(cCode[7], nKey2, false); */ ByteShift(cCode, nKey2, false); } for (int i = 0, j = 0; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (두 번째 작업을 위한 작업) cDeCode[i] = cCode[i]; cOddCode[j] = cCode[i]; j++; } else { // 짝수일 때.. (세 번째 작업) cDeCode[i] = (BYTE)(~cCode[i] & 0xFF); } } for (int i = 0, j = nOddLen - 1; i < nCodeLen; i++) { if (i%2) { // 홀수일 때.. (두 번째 작업) cDeCode[i] = cOddCode[j]; j--; } } // '\0' 아닌 순간부터 입력된다. bool bInput = false; for (int i = 0; i < nCodeLen; i++) { if (!bInput && cDeCode[i] != '\0') bInput = true; if (bInput) cReturnCode[i] = cDeCode[i]; } cReturnCode[nCodeLen] = '\0'; // 종료 문자열 추가 strReturnCode = strReturnCode.sprintf(cReturnCode); // 문자열을 AnsiString에 담는다 strReturnCode = strReturnCode.Trim(); if (cCode) { delete [] cCode; cCode = NULL; } if (cOddCode) { delete [] cOddCode; cOddCode = NULL; } if (cDeCode) { delete [] cDeCode; cDeCode = NULL; } if (cReturnCode) { delete [] cReturnCode; cReturnCode = NULL;} return strReturnCode; // AnsiString형으로 Return } //--------------------------------------------------------------------------- BYTE __fastcall TCrypt::BitShift(BYTE cData, int nShiftCount, bool bLeft) { bool bByte[8], bShiftByte[8]; int nRealShiftCnt; BYTE cReturn; memset(bByte, false, sizeof(bByte)); for (int i = 0; i < 8; i++) { if (((cData >> 7-i) & 1) == 1) { bByte[i] = true; } } nRealShiftCnt = nShiftCount % 8; if (bLeft) { // EnCode 시에 <- 쪽으로 비트가 Left Shift한다 for (int i = 0; i < 8; i++) { bShiftByte[(8+i-nRealShiftCnt)%8] = bByte[i]; } } else { // DeCode시에 -> 쪽으로 비트가 Right Shift한다 for (int i = 0; i < 8; i++) { bShiftByte[(i+nRealShiftCnt)%8] = bByte[i]; } } cReturn = 0; for (int i = 0; i < 8; i++) { cReturn = cReturn << 1; if (bShiftByte[i]) { cReturn += 1; } else { cReturn += 0; } } return cReturn; } //--------------------------------------------------------------------------- void __fastcall TCrypt::ByteShift(BYTE *cData, unsigned int nShiftCount, bool bLeft) { bool bByte[64]; bool bShiftByte[64]; int nRealShiftCnt; BYTE ShiftByte[8], cReturn[8]; memset(bByte, false, sizeof(bByte)); for (int i = 0; i < 64; i++){ if (((cData[i/8] >> 7-(i%8)) & 1) == 1) { bByte[i] = true; } } nRealShiftCnt = nShiftCount % 64; if (bLeft) { // EnCode 시에 <- 쪽으로 byte가 Left Shift한다 for (int i = 0; i < 64; i++) { bShiftByte[(64+i-nRealShiftCnt)%64] = bByte[i]; } } else { // DeCode시에 -> 쪽으로 byte가 Right Shift한다 for (int i = 0; i < 64; i++) { bShiftByte[(i+nRealShiftCnt)%64] = bByte[i]; } } memset(cData, 0, 8); for (int i = 0; i < 64; i++) { cData[i/8] = cData[i/8] << 1; if (bShiftByte[i]) { cData[i/8] += 1; } else { cData[i/8] += 0; } } /* for (int i = 0; i < 8; i++) { cData[i] = cData[i] << 8; if (bShiftByte[i]) { cData[i] += 1; } else { cData[i] += 0; } } */ } //---------------------------------------------------------------------------