달력

10

« 2019/10 »

  •  
  •  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  •  
  •  
특정 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
Posted by 현자

댓글을 달아 주세요