[유용한 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