마이크로소프트웨어

[유용한 String 관련 java code] String 암호화(Encrypt), 복호화(Decrypt) 기능 java code

특정 string을 암호화 하고
암호화된 string을 다시 복호화 하는 기능
Java code와
C++ code 2개 모듈을 작성하였습니다.
실제 사용하는 코드입니다.
C++로 먼저 개발을 하였고 이를 다시 java로 변경하였습니다.

<%
WCEncrypt enc = new WCEncrypt();
int nKey = 100;
String sSrc = "abcdef";
String sEnc = enc.Encrypt(sSrc.getBytes(),nKey);
String sDec = enc.Decrypt(sEnc.getBytes(),nKey);
%>
<%="sSrc="+sSrc%><br>
<%="sEnc="+sEnc%><br>
<%="sDec="+sDec%><br>

sSrc=abcdef
sEnc=618D7F84B7E4
sDec=abcdef

아래의 code에서 WCPage는 www.webdevlib.net에서 source code를 다운로드 받아 사용이 가능합니다.
만약 WCPage를 사용하지 않고 그냥 사용하고 싶다면 WCPage가 들어간 부분을 모두 제거하면 됩니다.

package wdl;
import java.util.*;
import java.sql.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.text.SimpleDateFormat;

public class WCEncrypt
{

public int m_nC1Key = 74102;

public int m_nC2Key = 12337;

public int m_nC3Key = 100;

public WCPage m_oPage = null;

public void setKey1(int nKey)
{
m_nC1Key = nKey;
}

public void setKey2(int nKey)
{
m_nC2Key = nKey;
}

public WCEncrypt(WCPage oPage)
{
m_oPage = oPage;
}

public WCEncrypt()
{
}

public WCEncrypt(int nKey1,int nKey2)
{
m_nC1Key = nKey1;
m_nC2Key = nKey2;
}

public WCEncrypt(WCPage oPage,int nKey1,int nKey2)
{
m_oPage = oPage;
m_nC1Key = nKey1;
m_nC2Key = nKey2;
}

public void setKey(int nKey1,int nKey2,int nKey3)
{
m_nC1Key = nKey1;
m_nC2Key = nKey2;
m_nC3Key = nKey3;
}

public void setPage(WCPage oPage)
{
m_oPage = oPage;
}

public byte HexaByte(int nVal)
{
byte [] szHexaByte = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
if (nVal > 15)
{
nVal = 0;
}
return szHexaByte[nVal];
}

public String ValueToHex(int szSrc[])
{
if (szSrc == null)
return null;
int nSrcLen = szSrc.length;
byte szBuf[] = new byte[nSrcLen*2];
for (int i=0;i<nSrcLen*2;i++)
{
szBuf[i] = 0;
}
for(int i=0;i<nSrcLen;i++)
{
szBuf[(i*2)+0] = HexaByte(((int)(szSrc[i]))/16);
szBuf[(i*2)+1] = HexaByte(((int)(szSrc[i]))%16);
}
String sRet = new String(szBuf);
return sRet;
}

public byte[] HexToValue(byte[] szSrc)
{
int nLen = szSrc.length;
byte[] szDest = new byte[nLen/2];
char szChar[] = new char[2];
for(int I = 0 ; I < nLen/2; I++)
{
szChar[0] = (char)szSrc[I*2];
szChar[1] = (char)szSrc[I*2+1];
byte btDest = (byte)HexToDecimal(szChar);
int nDest = btDest < 0 ? ( Byte.MAX_VALUE + 1 ) * 2 + btDest : btDest;
szDest[I] = (byte)nDest;
}
String sRet = new String(szDest);
return szDest;
}

public String Encrypt(byte btSrc[], int Key)
{
int nSrcLen = btSrc.length;
long nKey2 = Key;
int FirstResult[] = new int[nSrcLen];
for (int i=0;i<nSrcLen;i++)
{
FirstResult[i] = 0;
}
int nLen = btSrc.length;
for(int i = 0 ; i < nLen ; i++)
{
byte btByte = (byte)btSrc[i];
int cSrc = btByte < 0 ? ( Byte.MAX_VALUE + 1 ) * 2 + btByte : btByte;
long nXor = ((long)nKey2) / ((long)256);
byte btTmp = (byte)(cSrc^nXor);
FirstResult[i] = btTmp < 0 ? ( Byte.MAX_VALUE + 1 ) * 2 + btTmp : btTmp;
byte cFirstResult = (byte)FirstResult[i];
int nFirstResult = cFirstResult < 0 ? ( Byte.MAX_VALUE + 1 ) * 2 + cFirstResult : cFirstResult;
long nFirstResultKey = (long)(nFirstResult + nKey2);
nKey2 = (nFirstResultKey) * m_nC1Key + m_nC2Key;
}
String sRet = "";
sRet = ValueToHex(FirstResult);
return sRet;
}

public int HexToDecimal(char[] szSrc)
{
int nRet = 0;
int nLen = szSrc.length;
for (int i=0;i<nLen;i++)
{
byte cChar = (byte)szSrc[i];
nRet = nRet * 16;
nRet += HexToDecimal(cChar);
}
return nRet;
}

public int HexToDecimal(byte cChar)
{
if (cChar == 'A' || cChar == 'a')
return 10;
if (cChar == 'B' || cChar == 'b')
return 11;
if (cChar == 'C' || cChar == 'c')
return 12;
if (cChar == 'D' || cChar == 'd')
return 13;
if (cChar == 'E' || cChar == 'e')
return 14;
if (cChar == 'F' || cChar == 'f')
return 15;
return (cChar-48);
}

public String Decrypt(byte szSrc[],int Key)
{
if (szSrc == null)
return null;
int nSrcLen = szSrc.length;
byte FirstResult[] = new byte[nSrcLen/2];
for (int i=0;i<nSrcLen/2;i++)
{
FirstResult[i] = 0;
}
int nLen = 0;
FirstResult = HexToValue(szSrc);
byte szFirstResult[] = FirstResult;
byte szBuf[] = new byte[nSrcLen/2];
for (int i=0;i<nSrcLen/2;i++)
{
szBuf[i] = 0;
}
byte szResult[] = new byte[nSrcLen/2];
for (int i=0;i<nSrcLen/2;i++)
{
szResult[i] = 0;
}
int nKey = Key < 0 ? ( Integer.MAX_VALUE + 1 ) * 2 + Key : Key;
long nKey2 = (long)nKey;
for(int I = 0 ; I < nSrcLen/2 ; I++)
{
int nVal = szFirstResult[I] < 0 ? ( Byte.MAX_VALUE + 1 ) * 2 + szFirstResult[I] : szFirstResult[I];
long nFirstResult = ((long)nVal);
long nXor = (nKey2/(long)256);
long nXorResult = nFirstResult ^ nXor;
szResult[I] = (byte)(nXorResult);
byte cFirstResult = ((byte)szFirstResult[I]);
long cFirstResultKey = (nFirstResult + nKey2);
nKey2 = cFirstResultKey * m_nC1Key + m_nC2Key;
}
String sRet = new String(szResult);
return sRet;
}
}

// LEncrypt.h: interface for the CLEncrypt class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_LEncrypt_H__E90C5977_3621_4B32_97AF_68E9CF9A0CC1__INCLUDED_)
#define AFX_LEncrypt_H__E90C5977_3621_4B32_97AF_68E9CF9A0CC1__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CLEncrypt
{
public:
unsigned long m_nC1Key;
unsigned long m_nC2Key;

CLEncrypt();
virtual ~CLEncrypt();

char HexaChar(int nVal);
void ValueToHex(CString &sRet,unsigned char * szSrc,int nLen);
void HexToValue(unsigned char * szDest,int * nDestLen,LPCTSTR szSrc);
void Encrypt(CString &sRet,LPCTSTR szSrc,int Key);
int HexToDecimal(LPCTSTR szSrc);
int HexToDecimal(unsigned char cChar);
void Decrypt(CString &sRet,LPCTSTR szSrc,int Key);

};

#endif // !defined(AFX_LENCRIPT_H__E90C5977_3621_4B32_97AF_68E9CF9A0CC1__INCLUDED_)

// LEncrypt.cpp: implementation of the CLEncrypt class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "LEncrypt.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CLEncrypt::CLEncrypt()
{
m_nC1Key = 74102;
m_nC2Key = 12337;
}

CLEncrypt::~CLEncrypt()
{

}
char CLEncrypt::HexaChar(int nVal)
{
char * szHexaChar = "0123456789ABCDEF";
if (nVal > 15)
nVal = 0;
return szHexaChar[nVal];
}

// Byte로 구성된 데이터를 Hexadecimal 문자열로 변환
void CLEncrypt::ValueToHex(CString &sRet,unsigned char * szSrc,int nLen)
{
// int I;
// SetLength(Result, Length(S)*2); // 문자열 크기를 설정
// for I = 0 to Length(S)-1 do
unsigned char szBuf[1024];
memset(szBuf,0,sizeof(szBuf));
for(int I = 0 ; I < nLen ; I++)
{
szBuf[(I*2)+0] = HexaChar(((unsigned char)szSrc[I]) / 16);
szBuf[(I*2)+1] = HexaChar(((unsigned char)szSrc[I]) % 16);
}
sRet = szBuf;
}

// Hexadecimal로 구성된 문자열을 Byte 데이터로 변환
void CLEncrypt::HexToValue(unsigned char * szDest,int *nDestLen,LPCTSTR szSrc)
{
// int I;
// SetLength(Result, Length(S) div 2);
// for I = 0 to (Length(S) div 2) - 1 do
int nLen = strlen(szSrc);
for(int I = 0 ; I < nLen/2; I++)
{
char szChar[4];
memset(szChar,0,sizeof(szChar));
memcpy(szChar,&szSrc[I*2],2);
szDest[I] = HexToDecimal(szChar);
}
*nDestLen = nLen/2;
}

// 암호걸기
void CLEncrypt::Encrypt(CString & sRet,LPCTSTR szSrc,int Key)
{
unsigned long nKey2 = Key;
// byte I;
// CString FirstResult;
// SetLength(FirstResult, Length(S)); // 문자열의 크기를 설정
unsigned char FirstResult[1024];
memset(FirstResult,0,sizeof(FirstResult));
// for I = 1 to Length(S) do
int nLen = strlen(szSrc);
for(int I = 0 ; I < nLen ; I++)
{
unsigned char cSrc = ((unsigned char)szSrc[I]);
unsigned long nXor = ((unsigned long)nKey2/(unsigned long)256);
// shr : 오른쪽으로 쉬프트 시킴.
FirstResult[I] = (unsigned char)
(
cSrc ^ nXor
); // ^ : xor
unsigned char cFirstResult = ((unsigned char)FirstResult[I]);
unsigned long nFirstResultKey = (unsigned long)(cFirstResult + nKey2);
nKey2 = (nFirstResultKey) * m_nC1Key + m_nC2Key;
}
ValueToHex(sRet,FirstResult,nLen);
}

int CLEncrypt::HexToDecimal(LPCTSTR szSrc)
{
int nRet = 0;
int nLen = strlen(szSrc);
for (int i=0;i<nLen;i++)
{
char cChar = szSrc[i];
nRet = nRet * 16;
nRet += HexToDecimal(cChar);
}
return nRet;
}

int CLEncrypt::HexToDecimal(unsigned char cChar)
{
// 0 : 48
if (cChar == 'A' || cChar == 'a')
return 10;
if (cChar == 'B' || cChar == 'b')
return 11;
if (cChar == 'C' || cChar == 'c')
return 12;
if (cChar == 'D' || cChar == 'd')
return 13;
if (cChar == 'E' || cChar == 'e')
return 14;
if (cChar == 'F' || cChar == 'f')
return 15;
return cChar-48;
}

// 암호풀기
void CLEncrypt::Decrypt(CString &sRet,LPCTSTR szSrc,int Key)
{
// byte I;
// CString FirstResult;
// FirstResult = HexToValue(S);
unsigned char FirstResult[1024];
memset(FirstResult,0,sizeof(FirstResult));
int nLen = 0;
HexToValue(FirstResult,&nLen,szSrc);
// SetLength( Result, Length(FirstResult) );
// for I = 1 to Length(FirstResult) do
LPCTSTR szFirstResult = (LPCTSTR)FirstResult;
unsigned char szBuf[1024];
memset(szBuf,0,sizeof(szBuf));
unsigned char szResult[1024];
memset(szResult,0,sizeof(szResult));
unsigned long nKey2 = Key;
for(int I = 0 ; I < nLen ; I++)
{
unsigned long nFirstResult = ((unsigned long)szFirstResult[I]);
unsigned long nXor = (nKey2/(unsigned long)256);
unsigned long nXorResult = nFirstResult ^ nXor;
szResult[I] = (unsigned char)(nXorResult);
unsigned char cFirstResult = ((unsigned char)szFirstResult[I]);
unsigned long cFirstResultKey = (cFirstResult + nKey2);
nKey2 = cFirstResultKey * m_nC1Key + m_nC2Key;
}
sRet = szResult;
}

출처 : 고급 웹 UI 개발 라이브러리 Web Development Library 소스공개 : http://www.webdevlib.net