From 7edaa1fb754eb40556de612d17239cd8f03faca9 Mon Sep 17 00:00:00 2001
From: JIWOO <dlwldn1024@iten.co.kr>
Date: Wed, 17 Jul 2024 11:59:31 +0900
Subject: [PATCH] =?UTF-8?q?=EC=9D=B4=EC=A7=80=EC=9A=B0=20-=20=EA=B4=80?=
 =?UTF-8?q?=EB=A6=AC=EC=9E=90=20=EB=A1=9C=EA=B7=B8=EC=9D=B8=EC=97=90=20?=
 =?UTF-8?q?=EB=B6=84=EC=9F=81=EC=A1=B0=EC=A0=95=20=EC=95=94=ED=98=B8?=
 =?UTF-8?q?=ED=99=94(MD5)=20=EC=A0=81=EC=9A=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../service/impl/EgovLoginServiceImpl.java    |    8 +-
 src/main/java/seed/utils/SeedCookieUtil.java  |   63 +
 src/main/java/seed/utils/SeedKISA.java        |  810 +++++++++++++
 src/main/java/seed/utils/SeedUtils.java       | 1066 +++++++++++++++++
 4 files changed, 1945 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/seed/utils/SeedCookieUtil.java
 create mode 100644 src/main/java/seed/utils/SeedKISA.java
 create mode 100644 src/main/java/seed/utils/SeedUtils.java

diff --git a/src/main/java/kcc/let/uat/uia/service/impl/EgovLoginServiceImpl.java b/src/main/java/kcc/let/uat/uia/service/impl/EgovLoginServiceImpl.java
index f145e518..1e2a7f47 100644
--- a/src/main/java/kcc/let/uat/uia/service/impl/EgovLoginServiceImpl.java
+++ b/src/main/java/kcc/let/uat/uia/service/impl/EgovLoginServiceImpl.java
@@ -15,6 +15,7 @@ import kcc.let.uat.uia.service.EgovLoginService;
 import kcc.let.utl.fcc.service.EgovNumberUtil;
 import kcc.let.utl.fcc.service.EgovStringUtil;
 import kcc.let.utl.sim.service.EgovFileScrty;
+import seed.utils.SeedUtils;
 
 /**
  * 일반 로그인, 인증서 로그인을 처리하는 비즈니스 구현 클래스
@@ -54,9 +55,12 @@ public class EgovLoginServiceImpl extends EgovAbstractServiceImpl implements
     @Override
 	public LoginVO actionLogin(LoginVO vo) throws Exception {
     	
-		String enpassword = EgovFileScrty.encryptPassword(vo.getPassword(), vo.getId());
+		//String enpassword = EgovFileScrty.encryptPassword(vo.getPassword(), vo.getId());
+    	
+    	//분쟁조정의 MD5 암호화 사용
+    	String enpassword = SeedUtils.getSeedMD5Code(vo.getPassword());
+    	enpassword = SeedUtils.getSeedSHA256Code(enpassword);
     	vo.setPassword(enpassword);
-    	vo.setPassword("72ddc97081262e52953e0a75db05eff2108cfb9b2745083de7fedb65c20e0b85");
 		
     	// 2. 아이디와 암호화된 비밀번호가 DB와 일치하는지 확인한다.
     	LoginVO loginVO = loginDAO.actionLogin(vo);
diff --git a/src/main/java/seed/utils/SeedCookieUtil.java b/src/main/java/seed/utils/SeedCookieUtil.java
new file mode 100644
index 00000000..a25ffd56
--- /dev/null
+++ b/src/main/java/seed/utils/SeedCookieUtil.java
@@ -0,0 +1,63 @@
+package seed.utils;
+
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+public class SeedCookieUtil {
+	
+	/**
+	 * 쿠키를 생성하는 메소드
+	 * @param HttpServletResponse response response객체
+	 * @param Integer maxAge 시간설정 60*60*24*365 1년œ
+	 * @param String cookiePath 쿠키가 저장되는 경로 기본 / 입력
+	 * @param String key 쿠키 key값
+	 * @param Stirng value 쿠키 value
+	 * */
+	public void setCookie(HttpServletResponse response, Integer maxAge, String cookiePath, String key, String value, boolean httpOnly){
+		if(httpOnly){
+			response.setHeader("Set-Cookie", key+"="+value+"; path=/; HttpOnly");
+		}
+
+		Cookie cookie = new Cookie(key, value);
+		cookie.setMaxAge(maxAge);
+		cookie.setSecure(true);
+		cookie.setPath(cookiePath);
+		response.addCookie(cookie);
+	}
+	
+	/**
+	 * key에 해당하는 쿠키 정보를 가지고 오는 메소드
+	 * @param HttpServletRequest request 객체
+	 * @param String key 쿠키 key값
+	 * @param String 쿠키 정보
+	 * */
+	public String getCookie(HttpServletRequest request, String key){
+		Cookie[] cookies 		= request.getCookies();
+		String cookieValue 	= "";
+		if(cookies!=null){
+			int iLoop = cookies.length;
+			for (int i=0; i<iLoop; i++){
+				if(key.equals(cookies[i].getName())){
+					cookieValue = cookies[i].getValue();
+					break;
+				}
+			}
+		}
+		return cookieValue;
+	}
+	
+	/**
+	 * 쿠키 정보를 삭제 하는 메소드
+	 * @param HttpServletResponse response 객체
+	 * @param String cookiePath 쿠키경로 설정
+	 * @param String key 삭제할 key값
+	 * */
+	public void deleteCookie(HttpServletResponse response, String cookiePath, String key){
+		Cookie cookie = new Cookie(key, "");
+		cookie.setMaxAge(0);
+		cookie.setSecure(true);
+		cookie.setPath(cookiePath);
+		response.addCookie(cookie);
+	}
+}
diff --git a/src/main/java/seed/utils/SeedKISA.java b/src/main/java/seed/utils/SeedKISA.java
new file mode 100644
index 00000000..304078cb
--- /dev/null
+++ b/src/main/java/seed/utils/SeedKISA.java
@@ -0,0 +1,810 @@
+package seed.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import sun.misc.BASE64Decoder;
+import sun.misc.BASE64Encoder;
+
+public class SeedKISA {
+	
+	private static final String CHARACTER_SET = "UTF-8";
+
+    //private static final String DEFAULT_IV = "1234567890123456";
+    
+    private static final String DEFAULT_IV = "SeedSecretKISADefaultIv";
+
+    /**
+     * seed로 암호화된 문자열을 복호화
+     * @param encVal - 암호화 대상 string
+     * @param seedKey - encrypt할때 사용한 key
+     * @return
+     * @throws Exception
+     */
+    public static String getSeedDecrypt(String encVal, int[] seedKey) throws Exception{
+
+        // 암호화문 byte 배열 리스트로 변환
+
+        List<byte[]> encByteList = getByteList(encVal, true);
+
+//        System.out.println("복호화할 바이트 시작");
+//        for(int i=0; i<encByteList.size(); i++){
+//            byte[] originalByte = encByteList.get(i);
+//            for(int j=0; j<originalByte.length; j++){
+//                System.out.println("" + (j+(i*16)) + " : " + originalByte[j]);
+//            }
+//        }
+//        System.out.println("복호화할 바이트 종료");
+
+        // 복호화된 byte 배열 저장할 리스트 선언
+        List<byte[]> decByteList = new ArrayList<byte[]>();
+
+        // IV를 저장하라 변수 선언
+
+        byte[] byteIV = DEFAULT_IV.getBytes();
+
+        for(int i=0; i<encByteList.size(); i++){
+
+            byte[] encByte = (byte[])encByteList.get(i);
+
+            byte[] tempDecByte = new byte[16];
+
+            SeedKISA.SeedDecrypt(encByte, seedKey, tempDecByte);
+
+            // CBC 운영모드
+            exclusiveOR(tempDecByte, byteIV);
+            byteIV = encByte;
+            decByteList.add(tempDecByte);
+        }
+
+        return getByteListStr(decByteList, false);
+    }
+
+    /**
+     * seed로 문자열을 암호화
+     * @param strVal - 암호화 할 string
+     * @param seedKey - encrypt에 사용할 key
+     * @return
+     * @throws Exception
+     */
+    public static String getSeedEncrypt(String strVal, int[] seedKey) throws Exception{
+
+        // 원문을 byte[] list로 변환
+        List<byte[]> byteList = getByteList(strVal, false);
+
+//        System.out.println("원본 바이트 시작");
+//        for(int i=0; i<byteList.size(); i++){
+//            byte[] originalByte = byteList.get(i);
+//            for(int j=0; j<originalByte.length; j++){
+//                System.out.println("" + (j+(i*16)) + " : " + originalByte[j]);
+//            }
+//        }
+//        System.out.println("원본 바이트 종료");
+
+//        System.out.println("암호화된 바이트 시작");
+        
+        // 암호화된 byte[]를 저장할 list
+        List<byte[]> encByteList = new ArrayList<byte[]>();
+
+        // IV를 저장하라 변수 선언
+        byte[] byteIV = DEFAULT_IV.getBytes();
+
+        for(int i=0; i<byteList.size(); i++){
+            byte[] byteVal = (byte[])byteList.get(i);
+            byte[] tempEncVal = new byte[16];
+
+            // CBC 운영모드
+            exclusiveOR(byteVal, byteIV);
+
+            SeedKISA.SeedEncrypt(byteVal, seedKey, tempEncVal);
+
+            byteIV = tempEncVal;
+
+//            for(int j=0; j<tempEncVal.length; j++){
+//                System.out.println("" + (j+(i*16)) + " : " + tempEncVal[j]);
+//            }
+            
+            encByteList.add(tempEncVal);
+        }
+
+//        System.out.println("암호화된 바이트 종료");
+        
+        // list에 담긴 enc문을 str형태로 변환하여 반환
+        return getByteListStr(encByteList, true);
+    }
+
+    /**
+     * 암/복호화에 사용할 key값을 생성
+     * @param keyStr - 생성할 key값의 string 값
+     * @return
+     * @throws Exception
+     */
+    public static int[] getSeedRoundKey(String keyStr) throws Exception{
+        int[] seedKey = new int[32];
+        SeedKISA.SeedRoundKey(seedKey, keyStr.getBytes());
+        return seedKey;
+    }
+
+    /**
+     * CBC 운영모드를 사용하기 위한 XOR 연산 메서드
+     * value1과 value2를 OXR 연산 후 그 결과를 value1에 담는다.
+     * 128bit 확정형
+     * @param value1 - 변수1
+     * @param value2 - 변수2
+     */
+    private static void exclusiveOR(byte[] value1, byte[] value2){
+
+    	for(int i=0; i<16; i++){
+            value1[i] = Integer.valueOf(value1[i] ^ value2[i]).byteValue();
+        }
+    }
+
+    /**
+     * seed는 128bit 블록 단위로 암호화 처리한다.
+     * 문자열을 128bit단위로 byte배열을 생성하고, 그 배열을 list형태로 반환한다.
+     * @param nomal
+     * @param isDecode
+     * @return
+     * @throws Exception
+     */
+
+    private static List<byte[]> getByteList(String nomal, boolean isDecode) throws Exception{
+
+        List<byte[]> byteList = new ArrayList<byte[]>();
+
+        byte[] tempByte = null;
+
+        if(isDecode){
+            BASE64Decoder base64Dec = new BASE64Decoder();
+            tempByte = base64Dec.decodeBuffer(nomal);
+        }else{
+            tempByte = nomal.getBytes(CHARACTER_SET);
+        }
+
+        // seed 암호화를 위해선 byte가 무조건 16byte씩 배열이 생성되어야 함으로 빈배열의 공간수를 계산
+        int needBlankLength = 0;
+        
+        if(tempByte.length % 16 != 0){
+            needBlankLength = 16 - (tempByte.length % 16);
+        }
+
+        // 위에서 구한 필요한 빈공간의 수를 더하여 다시 배열 생성
+        byte[] newTempByte = new byte[tempByte.length + needBlankLength];
+
+        for(int i=0; i<tempByte.length; i++){
+            newTempByte[i] = tempByte[i];
+        }
+
+        // 이제 newTempByte를 16의 배수의 사이즈를 갖는 배열이 되었다.
+        // 16개씩 짤라서 List에 add 한다.
+
+        int inListByteIdx = 0;
+
+        byte[] inListByte = new byte[16];
+
+        for(int i=0; i<newTempByte.length; i++){
+
+            inListByte[inListByteIdx] = newTempByte[i];
+
+            inListByteIdx++;
+
+            if((i + 1) % 16 == 0 && i != 0){
+
+                byteList.add(inListByte);
+
+                inListByte = new byte[16];
+
+                inListByteIdx = 0;
+            }
+        }
+
+        return byteList;
+    }
+
+    /**
+     * 128bit단위로 쪼개진 byte배열이 담긴 list를 문자열로 변환해준다
+     * @param byteList
+     * @param isEncode
+     * @return
+     * @throws Exception
+     */
+    private static String getByteListStr(List<byte[]> byteList, boolean isEncode) throws Exception{
+
+        // List에 담긴 byte배열이 16으로 고정임으로 * 16
+        byte[] listByte = new byte[byteList.size() * 16];
+
+        // List에 담긴 byte배열을 하나의 배열(listByte)에 merge
+        for(int i=0; i<byteList.size(); i++){
+            byte[] temp = (byte[])byteList.get(i);
+
+            for(int j=0; j<temp.length; j++){
+                listByte[j + (16 * i)] = temp[j];
+            }
+        }
+
+        // blank byte 카운트 세기
+        int blankCnt = 0;
+
+        for(int i=listByte.length; i>0; i--){
+
+            if(listByte[i - 1] == 0){
+                blankCnt++;
+            }else{
+                break;
+            }
+        }
+       
+        // blank를 제외한 만큼의 데이터만 추출
+        byte[] resultByte = new byte[listByte.length - blankCnt];
+
+        for(int i=0; i<resultByte.length; i++){
+            resultByte[i] = listByte[i];
+        }
+
+        String retStr = null;
+
+        if(isEncode){
+            BASE64Encoder base64Enc = new BASE64Encoder();
+            retStr = base64Enc.encode(resultByte);
+        }else{
+            retStr = new String(resultByte, CHARACTER_SET);
+        }
+
+        return retStr;
+    }
+    
+	
+	private static final int SS0[] = {
+		0x2989a1a8, 0x05858184, 0x16c6d2d4, 0x13c3d3d0, 0x14445054, 0x1d0d111c, 0x2c8ca0ac, 0x25052124,
+		0x1d4d515c, 0x03434340, 0x18081018, 0x1e0e121c, 0x11415150, 0x3cccf0fc, 0x0acac2c8, 0x23436360,
+		0x28082028, 0x04444044, 0x20002020, 0x1d8d919c, 0x20c0e0e0, 0x22c2e2e0, 0x08c8c0c8, 0x17071314,
+		0x2585a1a4, 0x0f8f838c, 0x03030300, 0x3b4b7378, 0x3b8bb3b8, 0x13031310, 0x12c2d2d0, 0x2ecee2ec,
+		0x30407070, 0x0c8c808c, 0x3f0f333c, 0x2888a0a8, 0x32023230, 0x1dcdd1dc, 0x36c6f2f4, 0x34447074,
+		0x2ccce0ec, 0x15859194, 0x0b0b0308, 0x17475354, 0x1c4c505c, 0x1b4b5358, 0x3d8db1bc, 0x01010100,
+		0x24042024, 0x1c0c101c, 0x33437370, 0x18889098, 0x10001010, 0x0cccc0cc, 0x32c2f2f0, 0x19c9d1d8,
+		0x2c0c202c, 0x27c7e3e4, 0x32427270, 0x03838380, 0x1b8b9398, 0x11c1d1d0, 0x06868284, 0x09c9c1c8,
+		0x20406060, 0x10405050, 0x2383a3a0, 0x2bcbe3e8, 0x0d0d010c, 0x3686b2b4, 0x1e8e929c, 0x0f4f434c,
+		0x3787b3b4, 0x1a4a5258, 0x06c6c2c4, 0x38487078, 0x2686a2a4, 0x12021210, 0x2f8fa3ac, 0x15c5d1d4,
+		0x21416160, 0x03c3c3c0, 0x3484b0b4, 0x01414140, 0x12425250, 0x3d4d717c, 0x0d8d818c, 0x08080008,
+		0x1f0f131c, 0x19899198, 0x00000000, 0x19091118, 0x04040004, 0x13435350, 0x37c7f3f4, 0x21c1e1e0,
+		0x3dcdf1fc, 0x36467274, 0x2f0f232c, 0x27072324, 0x3080b0b0, 0x0b8b8388, 0x0e0e020c, 0x2b8ba3a8,
+		0x2282a2a0, 0x2e4e626c, 0x13839390, 0x0d4d414c, 0x29496168, 0x3c4c707c, 0x09090108, 0x0a0a0208,
+		0x3f8fb3bc, 0x2fcfe3ec, 0x33c3f3f0, 0x05c5c1c4, 0x07878384, 0x14041014, 0x3ecef2fc, 0x24446064,
+		0x1eced2dc, 0x2e0e222c, 0x0b4b4348, 0x1a0a1218, 0x06060204, 0x21012120, 0x2b4b6368, 0x26466264,
+		0x02020200, 0x35c5f1f4, 0x12829290, 0x0a8a8288, 0x0c0c000c, 0x3383b3b0, 0x3e4e727c, 0x10c0d0d0,
+		0x3a4a7278, 0x07474344, 0x16869294, 0x25c5e1e4, 0x26062224, 0x00808080, 0x2d8da1ac, 0x1fcfd3dc,
+		0x2181a1a0, 0x30003030, 0x37073334, 0x2e8ea2ac, 0x36063234, 0x15051114, 0x22022220, 0x38083038,
+		0x34c4f0f4, 0x2787a3a4, 0x05454144, 0x0c4c404c, 0x01818180, 0x29c9e1e8, 0x04848084, 0x17879394,
+		0x35053134, 0x0bcbc3c8, 0x0ecec2cc, 0x3c0c303c, 0x31417170, 0x11011110, 0x07c7c3c4, 0x09898188,
+		0x35457174, 0x3bcbf3f8, 0x1acad2d8, 0x38c8f0f8, 0x14849094, 0x19495158, 0x02828280, 0x04c4c0c4,
+		0x3fcff3fc, 0x09494148, 0x39093138, 0x27476364, 0x00c0c0c0, 0x0fcfc3cc, 0x17c7d3d4, 0x3888b0b8,
+		0x0f0f030c, 0x0e8e828c, 0x02424240, 0x23032320, 0x11819190, 0x2c4c606c, 0x1bcbd3d8, 0x2484a0a4,
+		0x34043034, 0x31c1f1f0, 0x08484048, 0x02c2c2c0, 0x2f4f636c, 0x3d0d313c, 0x2d0d212c, 0x00404040,
+		0x3e8eb2bc, 0x3e0e323c, 0x3c8cb0bc, 0x01c1c1c0, 0x2a8aa2a8, 0x3a8ab2b8, 0x0e4e424c, 0x15455154,
+		0x3b0b3338, 0x1cccd0dc, 0x28486068, 0x3f4f737c, 0x1c8c909c, 0x18c8d0d8, 0x0a4a4248, 0x16465254,
+		0x37477374, 0x2080a0a0, 0x2dcde1ec, 0x06464244, 0x3585b1b4, 0x2b0b2328, 0x25456164, 0x3acaf2f8,
+		0x23c3e3e0, 0x3989b1b8, 0x3181b1b0, 0x1f8f939c, 0x1e4e525c, 0x39c9f1f8, 0x26c6e2e4, 0x3282b2b0,
+		0x31013130, 0x2acae2e8, 0x2d4d616c, 0x1f4f535c, 0x24c4e0e4, 0x30c0f0f0, 0x0dcdc1cc, 0x08888088,
+		0x16061214, 0x3a0a3238, 0x18485058, 0x14c4d0d4, 0x22426260, 0x29092128, 0x07070304, 0x33033330,
+		0x28c8e0e8, 0x1b0b1318, 0x05050104, 0x39497178, 0x10809090, 0x2a4a6268, 0x2a0a2228, 0x1a8a9298
+	};
+			
+	private static final int SS1[] = {
+		0x38380830, 0xe828c8e0, 0x2c2d0d21, 0xa42686a2, 0xcc0fcfc3, 0xdc1eced2, 0xb03383b3, 0xb83888b0,
+		0xac2f8fa3, 0x60204060, 0x54154551, 0xc407c7c3, 0x44044440, 0x6c2f4f63, 0x682b4b63, 0x581b4b53,
+		0xc003c3c3, 0x60224262, 0x30330333, 0xb43585b1, 0x28290921, 0xa02080a0, 0xe022c2e2, 0xa42787a3,
+		0xd013c3d3, 0x90118191, 0x10110111, 0x04060602, 0x1c1c0c10, 0xbc3c8cb0, 0x34360632, 0x480b4b43,
+		0xec2fcfe3, 0x88088880, 0x6c2c4c60, 0xa82888a0, 0x14170713, 0xc404c4c0, 0x14160612, 0xf434c4f0,
+		0xc002c2c2, 0x44054541, 0xe021c1e1, 0xd416c6d2, 0x3c3f0f33, 0x3c3d0d31, 0x8c0e8e82, 0x98188890,
+		0x28280820, 0x4c0e4e42, 0xf436c6f2, 0x3c3e0e32, 0xa42585a1, 0xf839c9f1, 0x0c0d0d01, 0xdc1fcfd3,
+		0xd818c8d0, 0x282b0b23, 0x64264662, 0x783a4a72, 0x24270723, 0x2c2f0f23, 0xf031c1f1, 0x70324272,
+		0x40024242, 0xd414c4d0, 0x40014141, 0xc000c0c0, 0x70334373, 0x64274763, 0xac2c8ca0, 0x880b8b83,
+		0xf437c7f3, 0xac2d8da1, 0x80008080, 0x1c1f0f13, 0xc80acac2, 0x2c2c0c20, 0xa82a8aa2, 0x34340430,
+		0xd012c2d2, 0x080b0b03, 0xec2ecee2, 0xe829c9e1, 0x5c1d4d51, 0x94148490, 0x18180810, 0xf838c8f0,
+		0x54174753, 0xac2e8ea2, 0x08080800, 0xc405c5c1, 0x10130313, 0xcc0dcdc1, 0x84068682, 0xb83989b1,
+		0xfc3fcff3, 0x7c3d4d71, 0xc001c1c1, 0x30310131, 0xf435c5f1, 0x880a8a82, 0x682a4a62, 0xb03181b1,
+		0xd011c1d1, 0x20200020, 0xd417c7d3, 0x00020202, 0x20220222, 0x04040400, 0x68284860, 0x70314171,
+		0x04070703, 0xd81bcbd3, 0x9c1d8d91, 0x98198991, 0x60214161, 0xbc3e8eb2, 0xe426c6e2, 0x58194951,
+		0xdc1dcdd1, 0x50114151, 0x90108090, 0xdc1cccd0, 0x981a8a92, 0xa02383a3, 0xa82b8ba3, 0xd010c0d0,
+		0x80018181, 0x0c0f0f03, 0x44074743, 0x181a0a12, 0xe023c3e3, 0xec2ccce0, 0x8c0d8d81, 0xbc3f8fb3,
+		0x94168692, 0x783b4b73, 0x5c1c4c50, 0xa02282a2, 0xa02181a1, 0x60234363, 0x20230323, 0x4c0d4d41,
+		0xc808c8c0, 0x9c1e8e92, 0x9c1c8c90, 0x383a0a32, 0x0c0c0c00, 0x2c2e0e22, 0xb83a8ab2, 0x6c2e4e62,
+		0x9c1f8f93, 0x581a4a52, 0xf032c2f2, 0x90128292, 0xf033c3f3, 0x48094941, 0x78384870, 0xcc0cccc0,
+		0x14150511, 0xf83bcbf3, 0x70304070, 0x74354571, 0x7c3f4f73, 0x34350531, 0x10100010, 0x00030303,
+		0x64244460, 0x6c2d4d61, 0xc406c6c2, 0x74344470, 0xd415c5d1, 0xb43484b0, 0xe82acae2, 0x08090901,
+		0x74364672, 0x18190911, 0xfc3ecef2, 0x40004040, 0x10120212, 0xe020c0e0, 0xbc3d8db1, 0x04050501,
+		0xf83acaf2, 0x00010101, 0xf030c0f0, 0x282a0a22, 0x5c1e4e52, 0xa82989a1, 0x54164652, 0x40034343,
+		0x84058581, 0x14140410, 0x88098981, 0x981b8b93, 0xb03080b0, 0xe425c5e1, 0x48084840, 0x78394971,
+		0x94178793, 0xfc3cccf0, 0x1c1e0e12, 0x80028282, 0x20210121, 0x8c0c8c80, 0x181b0b13, 0x5c1f4f53,
+		0x74374773, 0x54144450, 0xb03282b2, 0x1c1d0d11, 0x24250521, 0x4c0f4f43, 0x00000000, 0x44064642,
+		0xec2dcde1, 0x58184850, 0x50124252, 0xe82bcbe3, 0x7c3e4e72, 0xd81acad2, 0xc809c9c1, 0xfc3dcdf1,
+		0x30300030, 0x94158591, 0x64254561, 0x3c3c0c30, 0xb43686b2, 0xe424c4e0, 0xb83b8bb3, 0x7c3c4c70,
+		0x0c0e0e02, 0x50104050, 0x38390931, 0x24260622, 0x30320232, 0x84048480, 0x68294961, 0x90138393,
+		0x34370733, 0xe427c7e3, 0x24240420, 0xa42484a0, 0xc80bcbc3, 0x50134353, 0x080a0a02, 0x84078783,
+		0xd819c9d1, 0x4c0c4c40, 0x80038383, 0x8c0f8f83, 0xcc0ecec2, 0x383b0b33, 0x480a4a42, 0xb43787b3
+	};
+		
+	private static final int SS2[] = {
+		0xa1a82989, 0x81840585, 0xd2d416c6, 0xd3d013c3, 0x50541444, 0x111c1d0d, 0xa0ac2c8c, 0x21242505,
+		0x515c1d4d, 0x43400343, 0x10181808, 0x121c1e0e, 0x51501141, 0xf0fc3ccc, 0xc2c80aca, 0x63602343,
+		0x20282808, 0x40440444, 0x20202000, 0x919c1d8d, 0xe0e020c0, 0xe2e022c2, 0xc0c808c8, 0x13141707,
+		0xa1a42585, 0x838c0f8f, 0x03000303, 0x73783b4b, 0xb3b83b8b, 0x13101303, 0xd2d012c2, 0xe2ec2ece,
+		0x70703040, 0x808c0c8c, 0x333c3f0f, 0xa0a82888, 0x32303202, 0xd1dc1dcd, 0xf2f436c6, 0x70743444,
+		0xe0ec2ccc, 0x91941585, 0x03080b0b, 0x53541747, 0x505c1c4c, 0x53581b4b, 0xb1bc3d8d, 0x01000101,
+		0x20242404, 0x101c1c0c, 0x73703343, 0x90981888, 0x10101000, 0xc0cc0ccc, 0xf2f032c2, 0xd1d819c9,
+		0x202c2c0c, 0xe3e427c7, 0x72703242, 0x83800383, 0x93981b8b, 0xd1d011c1, 0x82840686, 0xc1c809c9,
+		0x60602040, 0x50501040, 0xa3a02383, 0xe3e82bcb, 0x010c0d0d, 0xb2b43686, 0x929c1e8e, 0x434c0f4f,
+		0xb3b43787, 0x52581a4a, 0xc2c406c6, 0x70783848, 0xa2a42686, 0x12101202, 0xa3ac2f8f, 0xd1d415c5,
+		0x61602141, 0xc3c003c3, 0xb0b43484, 0x41400141, 0x52501242, 0x717c3d4d, 0x818c0d8d, 0x00080808,
+		0x131c1f0f, 0x91981989, 0x00000000, 0x11181909, 0x00040404, 0x53501343, 0xf3f437c7, 0xe1e021c1,
+		0xf1fc3dcd, 0x72743646, 0x232c2f0f, 0x23242707, 0xb0b03080, 0x83880b8b, 0x020c0e0e, 0xa3a82b8b,
+		0xa2a02282, 0x626c2e4e, 0x93901383, 0x414c0d4d, 0x61682949, 0x707c3c4c, 0x01080909, 0x02080a0a,
+		0xb3bc3f8f, 0xe3ec2fcf, 0xf3f033c3, 0xc1c405c5, 0x83840787, 0x10141404, 0xf2fc3ece, 0x60642444,
+		0xd2dc1ece, 0x222c2e0e, 0x43480b4b, 0x12181a0a, 0x02040606, 0x21202101, 0x63682b4b, 0x62642646,
+		0x02000202, 0xf1f435c5, 0x92901282, 0x82880a8a, 0x000c0c0c, 0xb3b03383, 0x727c3e4e, 0xd0d010c0,
+		0x72783a4a, 0x43440747, 0x92941686, 0xe1e425c5, 0x22242606, 0x80800080, 0xa1ac2d8d, 0xd3dc1fcf,
+		0xa1a02181, 0x30303000, 0x33343707, 0xa2ac2e8e, 0x32343606, 0x11141505, 0x22202202, 0x30383808,
+		0xf0f434c4, 0xa3a42787, 0x41440545, 0x404c0c4c, 0x81800181, 0xe1e829c9, 0x80840484, 0x93941787,
+		0x31343505, 0xc3c80bcb, 0xc2cc0ece, 0x303c3c0c, 0x71703141, 0x11101101, 0xc3c407c7, 0x81880989,
+		0x71743545, 0xf3f83bcb, 0xd2d81aca, 0xf0f838c8, 0x90941484, 0x51581949, 0x82800282, 0xc0c404c4,
+		0xf3fc3fcf, 0x41480949, 0x31383909, 0x63642747, 0xc0c000c0, 0xc3cc0fcf, 0xd3d417c7, 0xb0b83888,
+		0x030c0f0f, 0x828c0e8e, 0x42400242, 0x23202303, 0x91901181, 0x606c2c4c, 0xd3d81bcb, 0xa0a42484,
+		0x30343404, 0xf1f031c1, 0x40480848, 0xc2c002c2, 0x636c2f4f, 0x313c3d0d, 0x212c2d0d, 0x40400040,
+		0xb2bc3e8e, 0x323c3e0e, 0xb0bc3c8c, 0xc1c001c1, 0xa2a82a8a, 0xb2b83a8a, 0x424c0e4e, 0x51541545,
+		0x33383b0b, 0xd0dc1ccc, 0x60682848, 0x737c3f4f, 0x909c1c8c, 0xd0d818c8, 0x42480a4a, 0x52541646,
+		0x73743747, 0xa0a02080, 0xe1ec2dcd, 0x42440646, 0xb1b43585, 0x23282b0b, 0x61642545, 0xf2f83aca,
+		0xe3e023c3, 0xb1b83989, 0xb1b03181, 0x939c1f8f, 0x525c1e4e, 0xf1f839c9, 0xe2e426c6, 0xb2b03282,
+		0x31303101, 0xe2e82aca, 0x616c2d4d, 0x535c1f4f, 0xe0e424c4, 0xf0f030c0, 0xc1cc0dcd, 0x80880888,
+		0x12141606, 0x32383a0a, 0x50581848, 0xd0d414c4, 0x62602242, 0x21282909, 0x03040707, 0x33303303,
+		0xe0e828c8, 0x13181b0b, 0x01040505, 0x71783949, 0x90901080, 0x62682a4a, 0x22282a0a, 0x92981a8a
+	};
+		
+	private static final int SS3[] = {
+		0x08303838, 0xc8e0e828, 0x0d212c2d, 0x86a2a426, 0xcfc3cc0f, 0xced2dc1e, 0x83b3b033, 0x88b0b838,
+		0x8fa3ac2f, 0x40606020, 0x45515415, 0xc7c3c407, 0x44404404, 0x4f636c2f, 0x4b63682b, 0x4b53581b,
+		0xc3c3c003, 0x42626022, 0x03333033, 0x85b1b435, 0x09212829, 0x80a0a020, 0xc2e2e022, 0x87a3a427,
+		0xc3d3d013, 0x81919011, 0x01111011, 0x06020406, 0x0c101c1c, 0x8cb0bc3c, 0x06323436, 0x4b43480b,
+		0xcfe3ec2f, 0x88808808, 0x4c606c2c, 0x88a0a828, 0x07131417, 0xc4c0c404, 0x06121416, 0xc4f0f434,
+		0xc2c2c002, 0x45414405, 0xc1e1e021, 0xc6d2d416, 0x0f333c3f, 0x0d313c3d, 0x8e828c0e, 0x88909818,
+		0x08202828, 0x4e424c0e, 0xc6f2f436, 0x0e323c3e, 0x85a1a425, 0xc9f1f839, 0x0d010c0d, 0xcfd3dc1f,
+		0xc8d0d818, 0x0b23282b, 0x46626426, 0x4a72783a, 0x07232427, 0x0f232c2f, 0xc1f1f031, 0x42727032,
+		0x42424002, 0xc4d0d414, 0x41414001, 0xc0c0c000, 0x43737033, 0x47636427, 0x8ca0ac2c, 0x8b83880b,
+		0xc7f3f437, 0x8da1ac2d, 0x80808000, 0x0f131c1f, 0xcac2c80a, 0x0c202c2c, 0x8aa2a82a, 0x04303434,
+		0xc2d2d012, 0x0b03080b, 0xcee2ec2e, 0xc9e1e829, 0x4d515c1d, 0x84909414, 0x08101818, 0xc8f0f838,
+		0x47535417, 0x8ea2ac2e, 0x08000808, 0xc5c1c405, 0x03131013, 0xcdc1cc0d, 0x86828406, 0x89b1b839,
+		0xcff3fc3f, 0x4d717c3d, 0xc1c1c001, 0x01313031, 0xc5f1f435, 0x8a82880a, 0x4a62682a, 0x81b1b031,
+		0xc1d1d011, 0x00202020, 0xc7d3d417, 0x02020002, 0x02222022, 0x04000404, 0x48606828, 0x41717031,
+		0x07030407, 0xcbd3d81b, 0x8d919c1d, 0x89919819, 0x41616021, 0x8eb2bc3e, 0xc6e2e426, 0x49515819,
+		0xcdd1dc1d, 0x41515011, 0x80909010, 0xccd0dc1c, 0x8a92981a, 0x83a3a023, 0x8ba3a82b, 0xc0d0d010,
+		0x81818001, 0x0f030c0f, 0x47434407, 0x0a12181a, 0xc3e3e023, 0xcce0ec2c, 0x8d818c0d, 0x8fb3bc3f,
+		0x86929416, 0x4b73783b, 0x4c505c1c, 0x82a2a022, 0x81a1a021, 0x43636023, 0x03232023, 0x4d414c0d,
+		0xc8c0c808, 0x8e929c1e, 0x8c909c1c, 0x0a32383a, 0x0c000c0c, 0x0e222c2e, 0x8ab2b83a, 0x4e626c2e,
+		0x8f939c1f, 0x4a52581a, 0xc2f2f032, 0x82929012, 0xc3f3f033, 0x49414809, 0x48707838, 0xccc0cc0c,
+		0x05111415, 0xcbf3f83b, 0x40707030, 0x45717435, 0x4f737c3f, 0x05313435, 0x00101010, 0x03030003,
+		0x44606424, 0x4d616c2d, 0xc6c2c406, 0x44707434, 0xc5d1d415, 0x84b0b434, 0xcae2e82a, 0x09010809,
+		0x46727436, 0x09111819, 0xcef2fc3e, 0x40404000, 0x02121012, 0xc0e0e020, 0x8db1bc3d, 0x05010405,
+		0xcaf2f83a, 0x01010001, 0xc0f0f030, 0x0a22282a, 0x4e525c1e, 0x89a1a829, 0x46525416, 0x43434003,
+		0x85818405, 0x04101414, 0x89818809, 0x8b93981b, 0x80b0b030, 0xc5e1e425, 0x48404808, 0x49717839,
+		0x87939417, 0xccf0fc3c, 0x0e121c1e, 0x82828002, 0x01212021, 0x8c808c0c, 0x0b13181b, 0x4f535c1f,
+		0x47737437, 0x44505414, 0x82b2b032, 0x0d111c1d, 0x05212425, 0x4f434c0f, 0x00000000, 0x46424406,
+		0xcde1ec2d, 0x48505818, 0x42525012, 0xcbe3e82b, 0x4e727c3e, 0xcad2d81a, 0xc9c1c809, 0xcdf1fc3d,
+		0x00303030, 0x85919415, 0x45616425, 0x0c303c3c, 0x86b2b436, 0xc4e0e424, 0x8bb3b83b, 0x4c707c3c,
+		0x0e020c0e, 0x40505010, 0x09313839, 0x06222426, 0x02323032, 0x84808404, 0x49616829, 0x83939013,
+		0x07333437, 0xc7e3e427, 0x04202424, 0x84a0a424, 0xcbc3c80b, 0x43535013, 0x0a02080a, 0x87838407,
+		0xc9d1d819, 0x4c404c0c, 0x83838003, 0x8f838c0f, 0xcec2cc0e, 0x0b33383b, 0x4a42480a, 0x87b3b437
+	};
+
+	/************************** Constants for Key schedule ************************/
+	//KC0 = golden ratio; KCi = ROTL(KCi-1, 1) 	
+	private static final int[] KC = {
+		0x9e3779b9, 0x3c6ef373, 0x78dde6e6, 0xf1bbcdcc, 0xe3779b99, 0xc6ef3733, 0x8dde6e67, 0x1bbcdccf,
+		0x3779b99e, 0x6ef3733c, 0xdde6e678, 0xbbcdccf1, 0x779b99e3, 0xef3733c6, 0xde6e678d, 0xbcdccf1b
+	};
+
+	/**************************** Defining Endianness *****************************/
+	// If endianness is not defined correctly, you must modify here.
+
+	 //private static Boolean LITTLE 	 = false;
+	 private static final Boolean BIG		 = true;
+	 	
+	 private static final Boolean ENDIAN	 = BIG;				// Java virtual machine uses big endian as a default
+	//private static Boolean ENDIAN	 = LITTLE;
+	 	
+	/**************************** Constant Definitions ****************************/
+	//private static int  NoRounds = 16;		// the number of rounds
+	//private int  NoRoundKeys     = 32;		// the number of round-keys
+	//private int  SeedBlockSize   = 16;   	// block length in bytes
+	//private int  SeedBlockLen    = 128;  	// block length in bits
+		
+
+	/****************************** Common functions ******************************/
+	private static int GetB0(int A){	return (int)(0x000000ff&(A)    ); };
+	private static int GetB1(int A){	return (int)(0x000000ff&((A)>>>8)); };
+	private static int GetB2(int A){	return (int)(0x000000ff&((A)>>>16)); };
+	private static int GetB3(int A){	return (int)(0x000000ff&((A)>>>24)); };
+	private static void EndianChange(int dws[]) { dws[0] = (dws[0]>>>24) | (dws[0]<<24) | ((dws[0]<<8)&0x00ff0000)|((dws[0]>>>8)&0x0000ff00); };
+	private static int EndianChange(int dws)   { return (dws>>>24) | (dws<<24) | ((dws<<8)&0x00ff0000)|((dws>>>8)&0x0000ff00); };
+	
+	/****************************** Seed 암호화를 위한 멤버필드 **********************/
+	private static final int pdwRoundKey[] = new int[32];
+	// User secret key - mynameisheesungy
+	private static final byte pbUserKey[]  = {(byte)0x6d, (byte)0x79, (byte)0x6e, (byte)0x61, 
+		(byte)0x6d, (byte)0x65, (byte)0x69, (byte)0x73,
+		(byte)0x68, (byte)0x65, (byte)0x65, (byte)0x73, 
+		(byte)0x75, (byte)0x6e, (byte)0x67, (byte)0x79};
+	
+	// 사용자 입력 문자열 저장
+	private static byte pbData[] 	= new byte[16];
+	// input plaintext to be encrypted
+	private static byte pbCipher[]  = new byte[16];
+	private static byte pbPlain[]   = new byte[16];
+
+	/***************************** Static 초기화 ************************************/
+	static{
+		SeedRoundKey(pdwRoundKey, pbUserKey);
+	}
+
+	/***************************** SEED round function ****************************/
+	private static void SeedRound(
+					int L0[], int L1[], 			// [in, out] left-side variable at each round
+					int R0[], int R1[], 			// [in] right-side variable at each round
+					int K[]){						// [in] round keys at each round
+		
+		int  T0, T1;
+		long T00=0, T11=0;
+		
+		// F-function
+		T0 = R0[0] ^ K[0];                              
+		T1 = R1[0] ^ K[1];                              
+		T1 ^= T0;
+		T00 = (T0<0) ? (long)(T0 & 0x7fffffff)|(long)(0x80000000) : (long)(T0);
+		T1 = SS0[GetB0(T1)] ^ SS1[GetB1(T1)] ^ SS2[GetB2(T1)] ^ SS3[GetB3(T1)];          
+		T11 = (T1<0) ? (long)(T1 & 0x7fffffff)|(long)(0x80000000) : (long)(T1);
+		T00 += T11;
+		T0 = SS0[GetB0((int)T00)] ^ SS1[GetB1((int)T00)] ^ SS2[GetB2((int)T00)] ^ SS3[GetB3((int)T00)];          
+		T00 = (T0<0) ? (long)(T0 & 0x7fffffff)|(long)(0x80000000) : (long)(T0);
+		T11 += T00;
+		T1 = SS0[GetB0((int)T11)] ^ SS1[GetB1((int)T11)] ^ SS2[GetB2((int)T11)] ^ SS3[GetB3((int)T11)];          
+		T11 = (T1<0) ? (long)(T1 & 0x7fffffff)|(long)(0x80000000) : (long)(T1);
+		T00 += T11;
+    
+		//output of F function is added to left-side variable
+		L0[0] ^= (int)T00; L1[0] ^= (int)T11;                                     
+	};
+		
+	/************************** SEED encrtyption function *************************/
+	private static void SeedEncrypt(
+					byte pbData[], 					// [in] data to be encrypted
+					int pdwRoundKey[], 			// [in] round keys for encryption
+					byte outData[]){					// [out] encrypted data
+		
+		int L0[] = new int[1];	int L1[] = new int[1];
+		int R0[] = new int[1];	int R1[] = new int[1];
+		L0[0] = 0x0; L1[0] = 0x0; R0[0] = 0x0; R1[0] = 0x0;
+		int K[] = new int[2];
+		int nCount = 0;
+
+		//Set up input values for encryption	  
+		L0[0] = ((int)pbData[0]&0x000000ff);
+		L0[0] = ((L0[0])<<8)^((int)pbData[1]&0x000000ff);
+		L0[0] = ((L0[0])<<8)^((int)pbData[2]&0x000000ff);
+		L0[0] = ((L0[0])<<8)^((int)pbData[3]&0x000000ff);
+
+		L1[0] = ((int)pbData[4]&0x000000ff);
+		L1[0] = ((L1[0])<<8)^((int)pbData[5]&0x000000ff);
+		L1[0] = ((L1[0])<<8)^((int)pbData[6]&0x000000ff);
+		L1[0] = ((L1[0])<<8)^((int)pbData[7]&0x000000ff);
+
+		R0[0] = ((int)pbData[8]&0x000000ff);
+		R0[0] = ((R0[0])<<8)^((int)pbData[9]&0x000000ff);
+		R0[0] = ((R0[0])<<8)^((int)pbData[10]&0x000000ff);
+		R0[0] = ((R0[0])<<8)^((int)pbData[11]&0x000000ff);
+
+		R1[0] = ((int)pbData[12]&0x000000ff);
+		R1[0] = ((R1[0])<<8)^((int)pbData[13]&0x000000ff);
+		R1[0] = ((R1[0])<<8)^((int)pbData[14]&0x000000ff);
+		R1[0] = ((R1[0])<<8)^((int)pbData[15]&0x000000ff);
+
+		//Reorder for little endian 
+		//Because java virtual machine use big endian order in default
+		if (!ENDIAN)  {EndianChange(L0);  EndianChange(L1);  EndianChange(R0);  EndianChange(R1);};
+		  
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*   1 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*   2 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*   3 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*   4 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*   5 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*   6 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*   7 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*   8 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*   9 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*  10 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*  11 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*  12 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*  13 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*  14 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(L0, L1, R0, R1, K); /*  15 */
+		K[0] = pdwRoundKey[nCount++];		K[1] = pdwRoundKey[nCount++];
+		SeedRound(R0, R1, L0, L1, K); /*  16 */
+
+		if (!ENDIAN)  {EndianChange(L0);  EndianChange(L1);  EndianChange(R0);  EndianChange(R1);};
+
+		//Copying output values from last round to outData
+	  	for (int i=0; i<4; i++){
+			outData[i   ] = (byte)(((R0[0])>>>(8*(3-i)))&0xff);
+			outData[4+i ] = (byte)(((R1[0])>>>(8*(3-i)))&0xff);
+			outData[8+i ] = (byte)(((L0[0])>>>(8*(3-i)))&0xff);
+			outData[12+i] = (byte)(((L1[0])>>>(8*(3-i)))&0xff);
+	  	}
+	}
+
+	/************************** SEED decrtyption function *************************/
+	// Same as encrypt, except that round keys are applied in reverse order
+	private static void SeedDecrypt(
+			byte pbData[], 					// [in] encrypted data
+			int pdwRoundKey[], 			// [in] round keys for decryption
+			byte outData[]){				// [out] data to be encrypted
+				
+		int L0[] = new int[1];	int L1[] = new int[1];
+		int R0[] = new int[1];	int R1[] = new int[1];
+		int K[] = new int[2];
+		L0[0] = 0x0; L1[0] = 0x0; R0[0] = 0x0; R1[0] = 0x0;
+		int nCount = 31;
+		
+		// Set up input values for decryption	  
+		L0[0] = ((int)pbData[0]&0x000000ff);
+		L0[0] = ((L0[0])<<8)^((int)pbData[1]&0x000000ff);
+		L0[0] = ((L0[0])<<8)^((int)pbData[2]&0x000000ff);
+		L0[0] = ((L0[0])<<8)^((int)pbData[3]&0x000000ff);
+		
+		L1[0] = ((int)pbData[4]&0x000000ff);
+		L1[0] = ((L1[0])<<8)^((int)pbData[5]&0x000000ff);
+		L1[0] = ((L1[0])<<8)^((int)pbData[6]&0x000000ff);
+		L1[0] = ((L1[0])<<8)^((int)pbData[7]&0x000000ff);
+		
+		R0[0] = ((int)pbData[8]&0x000000ff);
+		R0[0] = ((R0[0])<<8)^((int)pbData[9]&0x000000ff);
+		R0[0] = ((R0[0])<<8)^((int)pbData[10]&0x000000ff);
+		R0[0] = ((R0[0])<<8)^((int)pbData[11]&0x000000ff);
+		
+		R1[0] = ((int)pbData[12]&0x000000ff);
+		R1[0] = ((R1[0])<<8)^((int)pbData[13]&0x000000ff);
+		R1[0] = ((R1[0])<<8)^((int)pbData[14]&0x000000ff);
+		R1[0] = ((R1[0])<<8)^((int)pbData[15]&0x000000ff);
+		
+		// Reorder for little endian 
+		if (!ENDIAN)  {EndianChange(L0);  EndianChange(L1);  EndianChange(R0);  EndianChange(R1);};
+		
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*   1 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*   2 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*   3 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*   4 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*   5 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*   6 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*   7 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*   8 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*   9 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*  10 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*  11 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*  12 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*  13 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(R0, R1, L0, L1, K); /*  14 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount--];
+		SeedRound(L0, L1, R0, R1, K); /*  15 */
+		K[1] = pdwRoundKey[nCount--];		K[0] = pdwRoundKey[nCount];
+		SeedRound(R0, R1, L0, L1, K); /*  16 */
+		
+		if (!ENDIAN)  {EndianChange(L0);  EndianChange(L1);  EndianChange(R0);  EndianChange(R1);};
+		
+		// Copy output values from last round to outData 	
+		for (int i=0; i<4; i++)
+		{
+			outData[i   ] = (byte)(((R0[0])>>>(8*(3-i)))&0xff);
+			outData[4+i ] = (byte)(((R1[0])>>>(8*(3-i)))&0xff);
+			outData[8+i ] = (byte)(((L0[0])>>>(8*(3-i)))&0xff);
+			outData[12+i] = (byte)(((L1[0])>>>(8*(3-i)))&0xff);
+		}
+	}
+
+	/************************ Functions for Key schedule **************************/
+	private static void EncRoundKeyUpdate0(int K[], int A[], int B[], int C[], int D[], int Z){
+		//int T0, T1;
+		int T0;
+		int T00, T11;
+		T0 = A[0];                                      
+		A[0] = (A[0]>>>8) ^ (B[0]<<24);                        
+		B[0] = (B[0]>>>8) ^ (T0<<24);                       
+		T00 = (int)A[0] + (int)C[0] - (int)KC[Z];                             
+		T11 = (int)B[0] + (int)KC[Z] - (int)D[0];                             
+		K[0] = SS0[GetB0((int)T00)] ^ SS1[GetB1((int)T00)] ^ SS2[GetB2((int)T00)] ^ SS3[GetB3((int)T00)];    
+		K[1] = SS0[GetB0((int)T11)] ^ SS1[GetB1((int)T11)] ^ SS2[GetB2((int)T11)] ^ SS3[GetB3((int)T11)];    		
+	}
+
+	private static void EncRoundKeyUpdate1(int K[], int A[], int B[], int C[], int D[], int Z){
+		//int T0, T1;
+		int T0;
+		int T00, T11;
+		T0 = C[0];                                      
+		C[0] = (C[0]<<8) ^ (D[0]>>>24);                        
+		D[0] = (D[0]<<8) ^ (T0>>>24);                       
+		T00 = (int)A[0] + (int)C[0] - (int)KC[Z];                             
+		T11 = (int)B[0] + (int)KC[Z] - (int)D[0];                             
+		K[0] = SS0[GetB0((int)T00)] ^ SS1[GetB1((int)T00)] ^ SS2[GetB2((int)T00)] ^ SS3[GetB3((int)T00)];    
+		K[1] = SS0[GetB0((int)T11)] ^ SS1[GetB1((int)T11)] ^ SS2[GetB2((int)T11)] ^ SS3[GetB3((int)T11)];    		
+	}
+
+	/******************************** Key Schedule ********************************/
+	private static void SeedRoundKey(
+		int pdwRoundKey[], 			// [out] round keys for encryption or decryption
+		byte pbUserKey[]){				// [in]	secret user key
+	
+		int A[] = new int[1];
+		int B[] = new int[1];
+		int C[] = new int[1];
+		int D[] = new int[1];
+		int  K[] = new  int[2];
+		int T0, T1;
+		int nCount = 2;
+	
+		// Set up input values for Key Schedule	
+		A[0] = ((int)pbUserKey[0]&0x000000ff);
+		A[0] = (A[0]<<8)^((int)pbUserKey[1]&0x000000ff);
+		A[0] = (A[0]<<8)^((int)pbUserKey[2]&0x000000ff);
+		A[0] = (A[0]<<8)^((int)pbUserKey[3]&0x000000ff);
+	
+		B[0] = ((int)pbUserKey[4]&0x000000ff);
+		B[0] = (B[0]<<8)^((int)pbUserKey[5]&0x000000ff);
+		B[0] = (B[0]<<8)^((int)pbUserKey[6]&0x000000ff);
+		B[0] = (B[0]<<8)^((int)pbUserKey[7]&0x000000ff);
+	
+		C[0] = ((int)pbUserKey[8]&0x000000ff);
+		C[0] = (C[0]<<8)^((int)pbUserKey[9]&0x000000ff);
+		C[0] = (C[0]<<8)^((int)pbUserKey[10]&0x000000ff);
+		C[0] = (C[0]<<8)^((int)pbUserKey[11]&0x000000ff);
+	
+		D[0] = ((int)pbUserKey[12]&0x000000ff);
+		D[0] = (D[0]<<8)^((int)pbUserKey[13]&0x000000ff);
+		D[0] = (D[0]<<8)^((int)pbUserKey[14]&0x000000ff);
+		D[0] = (D[0]<<8)^((int)pbUserKey[15]&0x000000ff);
+	
+		// reorder for little endian	  
+		if (!ENDIAN)  {A[0]=EndianChange(A[0]);  B[0]=EndianChange(B[0]);  C[0]=EndianChange(C[0]);  D[0]=EndianChange(D[0]);};
+	
+		T0 = (int)A[0] + (int)C[0] - (int)KC[0];
+		T1 = (int)B[0] - (int)D[0] + (int)KC[0];
+	
+		pdwRoundKey[0] = SS0[GetB0((int)T0)] ^ SS1[GetB1((int)T0)] ^ SS2[GetB2((int)T0)] ^ SS3[GetB3((int)T0)];
+		pdwRoundKey[1] = SS0[GetB0((int)T1)] ^ SS1[GetB1((int)T1)] ^ SS2[GetB2((int)T1)] ^ SS3[GetB3((int)T1)];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 1 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 2 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 3 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 4 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 5 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 6 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 7 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 8 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 9 );
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 10);
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 11);
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 12);
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 13);
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate1(K, A, B, C, D, 14);
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	
+		EncRoundKeyUpdate0(K, A, B, C, D, 15);
+		pdwRoundKey[nCount++] = K[0];	pdwRoundKey[nCount++] = K[1];
+	}
+
+	/****************************** 사용자 정의 함수 *******************************/
+	// 암호화 함수
+	public static String getPbCipher(String str){
+		padding(str); // 16 자가 되지 않으면 (byte)0x00 으로 채워준다.
+	
+		SeedEncrypt(pbData, pdwRoundKey, pbCipher);
+	
+		return toString(pbCipher);
+	}
+
+	// 복호화 함수
+	public static String getPbPlain(String str){
+		pbCipher = toByte(str);	// String을 byte[]로 변환
+	
+		SeedDecrypt(pbCipher, pdwRoundKey, pbPlain);
+	
+		return toString(pbPlain);
+	}
+
+	/************** 형변환 함수! 
+	* ( byte 값에 음수 값이 있어서 str.getBytes(), byte.toString()이 
+	* 제데로 동작하지 않아서 만들어 준 함수 )
+	* ***************/
+	// Byte[]을 받아서 String 을 리턴한다.
+	public static String toString(byte[] b){
+		StringBuffer sb = new StringBuffer();
+		for(int i=0; i<b.length; i++){
+			sb.append((char)b[i]);
+		}
+		return sb.toString();
+	}
+	
+	// String을 받아서 Byte[]을 리턴한다.
+	public static byte[] toByte(String str){
+		byte[] b = new byte[str.length()];
+		for(int i=0; i<b.length; i++){
+			b[i] = (byte)str.charAt(i);
+		}
+		return b;
+	}
+
+	// 16자가 되지 않으면 (byte)0x00 으로 채워준다.
+	private static void padding(String str){
+		if(str.length() > pbData.length){
+			pbData = null;
+			return;
+		}
+
+		for(int i=0; i<pbData.length; i++){
+			if(i < str.length()){
+				pbData[i] = (byte)str.charAt(i);
+			}else{
+				pbData[i] = (byte)0x00;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/seed/utils/SeedUtils.java b/src/main/java/seed/utils/SeedUtils.java
new file mode 100644
index 00000000..77c06ffc
--- /dev/null
+++ b/src/main/java/seed/utils/SeedUtils.java
@@ -0,0 +1,1066 @@
+package seed.utils;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+import org.apache.log4j.Logger;
+/*import org.hyperic.sigar.CpuPerc;
+import org.hyperic.sigar.Mem;
+import org.hyperic.sigar.Sigar;
+import org.hyperic.sigar.SigarException;*/
+import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;
+
+public class SeedUtils {
+	
+	private static Logger log = Logger.getLogger(SeedUtils.class);
+	
+	private static MessageDigest md;
+    static {
+    	
+        try{
+            md = MessageDigest.getInstance("MD5");
+        }catch(Exception e){
+            md = null;
+        }
+    }
+    
+    private static byte[] md5(String source) {
+        byte[] bytes = source.getBytes();
+        byte[] digest = md.digest(bytes);
+        return digest;
+    }
+	
+	public static String getSeedMD5Code(String str){
+
+		String MD5 = ""; 
+		
+		 try{
+			 
+			 MessageDigest md = MessageDigest.getInstance("MD5"); 
+			 md.update(str.getBytes()); 
+			 byte byteData[] = md.digest();
+			 StringBuffer sb = new StringBuffer(); 
+			 for(int i = 0 ; i < byteData.length ; i++){
+				 sb.append(Integer.toString((byteData[i]&0xff) + 0x100, 16).substring(1));
+			 }
+			 MD5 = sb.toString();
+		 }catch(NoSuchAlgorithmException e){
+			 log.error("SeedUtils getSeedMD5Code Error");
+			 MD5 = ""; 
+		 }
+		 
+		 return MD5;
+	}
+	
+	public static String getSeedSHA256Code(String str){
+
+		String SHA256 = ""; 
+		
+		 try{
+			 
+			 MessageDigest md = MessageDigest.getInstance("SHA-256"); 
+			 md.update(str.getBytes()); 
+			 byte byteData[] = md.digest();
+			 StringBuffer sb = new StringBuffer(); 
+			 for(int i = 0 ; i < byteData.length ; i++){
+				 sb.append(Integer.toString((byteData[i]&0xff) + 0x100, 16).substring(1));
+			 }
+			 SHA256 = sb.toString();
+		 }catch(NoSuchAlgorithmException e){
+			 log.error("SeedUtils getSeedSHA256Code Error");
+			 SHA256 = ""; 
+		 }
+		 
+		 return SHA256;
+	}
+	
+    public static String getSeedEncrypt(String input, String key){
+        byte[] ivbytes = "SeedSecretMd5ASE".getBytes();
+        IvParameterSpec ips = new IvParameterSpec(ivbytes);
+        byte[] keybytes = md5(key);
+        byte[] crypted = null;
+        
+        try{
+        	
+        	SecretKeySpec skey = new SecretKeySpec(keybytes, "AES");
+            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+            cipher.init(Cipher.ENCRYPT_MODE, skey, ips);
+            byte[] ptext = input.getBytes();
+            crypted = cipher.doFinal(ptext);
+        }catch(NoSuchPaddingException e){
+        	log.error("SeedUtils getSeedEncrypt NoSuchPaddingException");
+        }catch(NoSuchAlgorithmException e){
+        	log.error("SeedUtils getSeedEncrypt NoSuchAlgorithmException");
+        }catch(InvalidKeyException e){
+        	log.error("SeedUtils getSeedEncrypt InvalidKeyException");
+        }catch(InvalidAlgorithmParameterException e){
+        	log.error("SeedUtils getSeedEncrypt InvalidAlgorithmParameterException");
+        }catch(IllegalBlockSizeException e){
+        	log.error("SeedUtils getSeedEncrypt IllegalBlockSizeException");
+        }catch(BadPaddingException e){
+        	log.error("SeedUtils getSeedEncrypt BadPaddingException");
+        }
+        return new String(Hex.encodeHexString(crypted));
+    }
+    
+    public static String getSeedDecrypt(String input, String key){
+        IvParameterSpec ips = new IvParameterSpec("SeedSecretMd5ASE".getBytes());
+        byte[] keybytes = md5(key);
+        byte[] output = null;
+        
+        try{
+        	
+            SecretKeySpec skey = new SecretKeySpec(keybytes, "AES");
+            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+            cipher.init(Cipher.DECRYPT_MODE, skey, ips);
+            output = cipher.doFinal(Hex.decodeHex(input.toCharArray()));
+        }catch(NoSuchPaddingException e){
+        	log.error("SeedUtils getSeedDecrypt NoSuchPaddingException");
+        }catch(NoSuchAlgorithmException e){
+        	log.error("SeedUtils getSeedDecrypt NoSuchAlgorithmException");
+        }catch(InvalidKeyException e){
+        	log.error("SeedUtils getSeedDecrypt InvalidKeyException");
+        }catch(InvalidAlgorithmParameterException e){
+        	log.error("SeedUtils getSeedDecrypt InvalidAlgorithmParameterException");
+        }catch(IllegalBlockSizeException e){
+        	log.error("SeedUtils getSeedDecrypt IllegalBlockSizeException");
+        }catch(BadPaddingException e){
+        	log.error("SeedUtils getSeedDecrypt BadPaddingException");
+        }catch(DecoderException e){
+        	log.error("SeedUtils getSeedDecrypt DecoderException");
+        }
+        return new String(output);
+    }
+    
+    public static String getSeedKisaEncrypt(String input){
+    	
+    	String output = "";
+		
+    	try{
+	        // 암복호화에 사용할 키 배열생성
+	        int[] seedKeyByte = SeedKISA.getSeedRoundKey("SeedSecretKISARoundKey");
+	
+	        output = SeedKISA.getSeedEncrypt(input, seedKeyByte);
+    	}catch (Exception e) {
+        	log.error("SeedUtils getSeedKisaEncrypt Exception");
+		}
+    	
+    	return output;
+    }
+    
+    public static String getSeedKisaDecrypt(String input){
+    	
+    	String output = "";
+		
+    	try{
+	        // 암복호화에 사용할 키 배열생성
+	        int[] seedKeyByte = SeedKISA.getSeedRoundKey("SeedSecretKISARoundKey");
+	
+	        output = SeedKISA.getSeedDecrypt(input, seedKeyByte);
+    	}catch (Exception e) {
+        	log.error("SeedUtils getSeedKisaDecrypt Exception");
+		}
+    	
+    	return output;
+    }
+
+    /**
+     * 전달 받은 경로의 폴더를 생성하는 메소드 mkdirs를 호출함
+     * -> 생성후 해당 폴더에 대한 권한 설정을 실행
+     * 생성된 폴더 및 파일 객체를 위의 메소드로 권한 수정 작업 진행 
+     * 요거 하면 계정에 따라서 권한이 없어서 문제 발생 될수 있음 
+     * Was=서버파일관리 권한이 완전 동일 해야함
+     * @param String dirPath 폴더 경로
+     */
+	public static void setSeedMkDirs(String dirPath){
+		
+		File file = new File(dirPath);
+		
+		if (file.exists() || file.isDirectory()){
+			return;
+		}
+		
+		if(!file.exists()){
+			file.mkdirs();
+		}
+	}
+	
+	public static void setSeedFileCopy(String inFileName, String outFileName){
+		
+		FileInputStream fis = null;
+		FileOutputStream fos = null;
+		
+		try{
+			
+			fis = new FileInputStream(inFileName);
+			fos = new FileOutputStream(outFileName);
+	
+			byte[] buffer = new byte[(int)1024];
+			
+			int i = 0;
+			
+			if (fis != null && fos != null) {
+				while ((i = fis.read(buffer)) != -1) {
+					fos.write(buffer, 0, i);
+				}
+			}
+			
+			fis.close();
+			fos.close();
+	
+		}catch (FileNotFoundException e){
+			log.error(e);
+		}catch (IOException e){
+			log.error(e);
+		}catch (Exception e){
+			log.error(e);
+		}finally{
+			if(fis!=null){try{fis.close();}catch(IOException e){log.error("CHECK ERROR:",e);}}
+			if(fos!=null){try{fos.close();}catch(IOException e){log.error("CHECK ERROR:",e);}}
+		}
+	}
+	
+	public static void setSeedMoveFile(String dirPath, String destPath){
+		
+		File orgFile = new File(dirPath);
+		File destFile = new File(destPath);
+		
+		if(orgFile != null && orgFile.exists()){
+			orgFile.renameTo(destFile);
+		}
+	}
+	
+	public synchronized static void setSeedDeleteFile(String dirPath){
+		
+		File file = new File(dirPath);
+		
+		if(file != null && file.exists()){
+			file.delete();
+		}
+	}
+	
+	public synchronized static void setSeedDeleteFiles(String dirPath, String noFoloder) {
+		
+	    File file = new File(dirPath);
+	    
+		if (!file.exists() || !file.isDirectory()){
+			return;
+		}
+		
+	    String[] fnameList = file.list();
+	    
+	    if(fnameList != null && fnameList.length > 0){
+	    	
+		    int fCnt = fnameList.length;
+		    String childPath = "";
+		    
+		    for(int i = 0; i < fCnt; i++) {
+		    	childPath = dirPath+"/"+fnameList[i];
+		    	File f = new File(childPath);
+	  
+				if(noFoloder != null && !noFoloder.equals("")){
+					if(f.getName().equals(noFoloder)){
+						continue;
+					}
+				}
+				  
+				if(f != null && !f.isDirectory()) {
+					f.delete();   //파일이면 바로 삭제
+				}else {
+					setSeedDeleteFiles(childPath, noFoloder);
+				}
+		    }
+	    }
+	    
+	    File f = new File(dirPath);
+	    f.delete();
+	}
+	
+	public static void setSeedCopyFiles(File sourcelocation , File targetdirectory, String[] noCopyFolders, String[] noCopyFiles) {
+		
+		//디렉토리인 경우
+		if (sourcelocation.isDirectory()) {
+			
+			boolean chkNoFolder = false;
+			
+			for(int i=0; i<noCopyFolders.length; i++){
+				if(sourcelocation.getName().indexOf(noCopyFolders[i]) > -1){
+					chkNoFolder = true;
+					break;
+				}
+			}
+			
+			if(!chkNoFolder){
+				//복사될 Directory가 없으면 만듭니다.
+				if (!targetdirectory.exists()) {
+					targetdirectory.mkdir();
+				}
+	      
+				String[] children = sourcelocation.list();
+				
+				if(children != null && children.length > 0){
+					
+					for (int i=0; i<children.length; i++) {
+						setSeedCopyFiles(new File(sourcelocation, children[i]), new File(targetdirectory, children[i]), noCopyFolders, noCopyFiles);
+					}
+				}
+			}
+			
+		} else {
+			
+			boolean chkNoFile = false;
+			
+			if(noCopyFiles != null && noCopyFiles.length > 0){
+			
+				for(int i=0; i<noCopyFiles.length; i++){
+					
+					if(sourcelocation.getName().indexOf(noCopyFiles[i]) > -1){
+						chkNoFile = true;
+						break;
+					}
+				}
+			}
+			
+			if(!chkNoFile){
+				
+				//파일인 경우
+				InputStream in = null;                
+				OutputStream out = null;
+				
+				try{
+					
+					in = new FileInputStream(sourcelocation);                
+					out = new FileOutputStream(targetdirectory);
+					
+					//Copy the bits from instream to outstream
+					byte[] buf = new byte[1024];
+					int len;
+					while ((len = in.read(buf)) > 0) {
+						out.write(buf, 0, len);
+					}
+					
+					in.close();
+					out.close();
+					
+				}catch (IOException e){
+					log.error("IOException Error");
+				}finally{
+					if (in != null) {
+						try{
+							in.close();
+						}catch (IOException e){
+							log.error("IOException Error");
+						}
+					}
+					
+					if (out != null) {
+						try{
+							out.close();
+						}catch (IOException e){
+							log.error("IOException Error");
+						}
+					}
+				}
+			}
+		}
+	}	
+	
+	public static ArrayList<Map<String, Object>> getSeedDirFiles(String dirPath, String dirType) {
+		
+		ArrayList<Map<String, Object>> arrayList = new ArrayList<Map<String,Object>>();
+		
+		File file = new File(dirPath);
+		
+		if (!file.exists() || !file.isDirectory()){
+			return null;
+		}
+		
+	    String[] fnameList = file.list();
+	    int fCnt = 0;
+	    if(fnameList != null && fnameList.length > 0){
+	    	fCnt = fnameList.length;
+	    }
+	    String childPath = "";
+	    
+	    for(int i = 0; i < fCnt; i++) {
+			childPath = dirPath+"/"+fnameList[i];
+			File f = new File(childPath);
+			
+			if(f != null){
+				
+				Map<String, Object> dirMap = new HashMap<String, Object>(); 
+				
+				if(dirType.equals("D") && f.isDirectory()){
+					dirMap.put("dirName", f.getName());
+					arrayList.add(dirMap);
+				}else if(dirType.equals("F") && !f.isDirectory()){
+					dirMap.put("fileName", f.getName());
+					dirMap.put("fileSize", f.length());
+					dirMap.put("fileSubType", f.getName().substring(f.getName().lastIndexOf(".")+1));
+					arrayList.add(dirMap);
+				}
+			}
+	    }
+	    
+	    return arrayList;
+	}
+	
+	public static String getStandardPBEStringDecrypt(String strEncrypt){
+		
+		String strDecrypt = strEncrypt.substring(4, strEncrypt.length()-1);
+		
+		StandardPBEStringEncryptor pbeEnc = new StandardPBEStringEncryptor();
+	    pbeEnc.setPassword("web"); // PBE 값(XML PASSWORD설정)
+	    
+	    return pbeEnc.decrypt(strDecrypt);
+	}
+	
+	public static String setReplaceNull(Object strOriginal){
+		
+		if(strOriginal == null || strOriginal.equals("")){
+			strOriginal = "";
+		}
+		
+//		//주민번호 형태 인 경우 해당 *로 치환
+//		strOriginal = strOriginal.toString().replaceAll("\\d{6}(|\\p{Z}|\\p{Z}\\p{Z})\\-(|\\p{Z}|\\p{Z}\\p{Z})[1-4]\\d{6}", "******-*******");
+//		strOriginal = strOriginal.toString().replaceAll("\\d{6}(|\\p{Z}|\\p{Z}\\p{Z})\\~(|\\p{Z}|\\p{Z}\\p{Z})[1-4]\\d{6}", "******~*******");
+//		
+//		//휴대폰 번호 인 경우 해당 *로 치환
+//		strOriginal = strOriginal.toString().replaceAll("^01(?:0|1|[6-9])(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})(?:\\d{3}|\\d{4}) - \\d{4}$", "***-****-****");
+//		strOriginal = strOriginal.toString().replaceAll("^01(?:0|1|[6-9])(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})(?:\\d{3}|\\d{4}) ~ \\d{4}$", "***~****~****");
+//		
+//		//일반전화 번호, 팩스 번호 인 경우 해당 *로 치환
+//		strOriginal = strOriginal.toString().replaceAll("^\\d{2,3}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{3,4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}$", "***-****-****");
+//		strOriginal = strOriginal.toString().replaceAll("^\\d{2,3}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{3,4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}$", "***~****~****");
+//		
+//		//카드번호 인 경우 해당 *로 치환
+//		strOriginal = strOriginal.toString().replaceAll("\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})-(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}", "****-****-****-****");
+//		strOriginal = strOriginal.toString().replaceAll("\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}(|\\p{Z}|\\p{Z}\\p{Z})~(|\\p{Z}|\\p{Z}\\p{Z})\\d{4}", "****~****~****~****");
+
+		return strOriginal.toString();
+	}
+	
+	public static String setReplaceNull(Object strOriginal, Object strReplace){
+		
+		if(strOriginal == null || strOriginal.equals("") || strOriginal.equals("null")){
+			return strReplace.toString();
+		}
+		
+		return strOriginal.toString();
+	}
+	
+	public static void getZipFile(String path, String fileName) {
+		
+		File f = new File(path);  //파일이름미포함
+		String files[] = f.list(); // f object 에 있는 파일목록
+
+		String outFilename = path + "/" + fileName + ".zip";
+		int number = 1;
+		
+		while (true) {
+			File newFile = new File(outFilename);
+			if (newFile != null && newFile.exists()) {
+				outFilename = path + "/" + fileName + "_" + number + ".txt";
+				number++;
+			} else {
+				break;
+			}
+		}
+
+		int size = 1024;
+		//Create a buffer for reading the files
+		byte[] buf = new byte[size];
+
+		//Create the ZIP file
+		ZipOutputStream zos = null;
+		FileInputStream fis = null;
+
+		try{
+			
+			zos = new ZipOutputStream(new FileOutputStream(outFilename));
+			
+			//Compress the files
+			if(files != null && files.length > 0){
+				
+				for (int i = 0; i < files.length; i++) {
+					fis = new FileInputStream(path + "/" + files[i]);
+	
+					//Add ZIP entry to output stream.
+					zos.putNextEntry(new ZipEntry(files[i])); // Zip 파일에 경로를 정하여 저장할수 있다.
+					//Transfer bytes from the file to the ZIP file
+	
+					int len;
+					while ((len = fis.read(buf, 0, size)) > 0) {
+						zos.write(buf, 0, len);
+					}
+					
+					//Complete the entry
+					zos.closeEntry();
+					fis.close();
+				}
+			}
+			
+			//Complete the ZIP file
+			zos.close();
+		}catch (FileNotFoundException e){
+			log.error("FileNotFoundException Error");
+		}catch (IOException e){
+			log.error("IOException Error");
+		}finally{
+			if (fis != null) {
+				try{
+					fis.close();
+				}catch (IOException e){
+					log.error("IOException Error");
+				}
+			}
+			
+			if (zos != null) {
+				try{
+					zos.close();
+				}catch (IOException e){
+					log.error("IOException Error");
+				}
+			}
+		}
+	}
+
+	 public static void setUnZipFile(String zipPath, String unzipPath) {
+		 
+		  File zipFile = new File(zipPath);   //파일이름포함
+		  File targetDir = new File(unzipPath);  //미포함
+
+		  FileInputStream fis = null;
+		  ZipInputStream zis = null;
+		  FileOutputStream fos = null;
+
+		  try{
+			  
+			  fis = new FileInputStream(zipFile);
+			  zis = new ZipInputStream(fis); // ZipInputStream
+			  
+			  ZipEntry zentry = null;
+
+			  while ((zentry = zis.getNextEntry()) != null) {
+				  String fileNameToUnzip = zentry.getName();
+				  File targetFile = new File(targetDir, fileNameToUnzip);
+
+				  if (zentry.isDirectory()) {// Directory 인 경우
+					  File newDir = new File(targetFile.getAbsolutePath());
+					  newDir.mkdirs();
+				  } else { // File 인 경우
+					  //parent Directory 생성
+					  File newFile = new File(targetFile.getParent());
+					  newFile.mkdirs();
+					  
+					  fos = new FileOutputStream(targetFile);
+					  byte[] buffer = new byte[1024];
+					  int len = 0;
+					  
+					  while ((len = zis.read(buffer)) != -1) {
+						  fos.write(buffer, 0, len);
+					  }
+					  fos.close();
+				  }
+			  }
+			  
+			  zis.close();
+			  fis.close();
+			  
+		  }catch (FileNotFoundException e){
+			  log.error("FileNotFoundException Error");
+		  }catch (IOException e){
+			  log.error("IOException Error");
+		  }finally{
+			  
+			  if (fos != null) {
+				  try{
+					  fos.close();
+				  }catch (IOException e){
+					  log.error("IOException Error");
+				  }
+			  }
+			  
+			  if (zis != null) {
+				  try{
+					  zis.close();
+				  }catch (IOException e){
+					  log.error("IOException Error");
+				  }
+			  }
+			  
+			  if (fis != null) {
+				  try{
+					  fis.close();
+				  }catch (IOException e){
+					  log.error("IOException Error");
+				  }
+			  }
+		  }
+	 }
+	 
+	public static String getRandomData (int length) {
+		int index = 0;
+		char[] charSet = new char[] {
+			    '0','1','2','3','4','5','6','7','8','9'
+				,'A','B','C','D','E','F','G','H','I','J','K','L','M'
+				,'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
+				,'a','b','c','d','e','f','g','h','i','j','k','l','m'
+				,'n','o','p','q','r','s','t','u','v','w','x','y','z'};
+		
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<length; i++) {
+			index =  getRandom(62,0);
+			if(index > 0){
+				sb.append(charSet[index]);
+			}
+		}
+		
+		return sb.toString();
+	}
+	
+	/**
+	 * random한 값을 얻고자 할때 사용하는 메소드
+	 * 보안 관련 체크를 위해서 Math.random 이 아닌 SecureRandom을 이용해서 작업을 진행함
+	 * 결과 값이 min값보다 작은경우 rendom함수 재호출 해서 값을 넘겨주는 방식
+	 * @param int max 난수 최대값
+	 * @param int min 난수 최소값
+	 * @return int 난수값
+	 * */
+	public static int getRandom(int max, int min){
+		int result = 0;
+		SecureRandom ran = new SecureRandom();
+		result = ran.nextInt(max);
+		return result < min ? getRandom(max,min) : result;
+	}
+	
+	public static String getSeedWE8DECtoKor(String strData){
+		
+		//ex.) UTL_RAW.CAST_TO_RAW(columnName)
+		
+		if (strData.length() % 2 != 0) {
+			return "";
+		}
+		
+		StringBuffer buff = new StringBuffer();
+		
+		int i = 0;
+		
+		while( i < strData.length() ){
+			buff.append((char)Integer.parseInt(strData.substring(i, i+2),16));
+			i = i + 2;
+		}
+		
+		try{
+			
+			if(buff.toString() != null){
+				return new String(buff.toString().getBytes("8859_1"), "EUC_KR");
+			}else{
+				return buff.toString();
+			}
+			
+		 }catch(Exception ex){
+			  return ex.toString();
+		 }
+	}
+	
+	public static String setTagRemove(String strOriginal){
+		
+		String strRemove = "";
+		
+		if(strOriginal != null && !"".equals(strOriginal)){
+			strRemove = strOriginal.replaceAll("<(/)?([a-zA-Z]*)(\\s[a-zA-Z]*=[^>]*)?(\\s)*(/)?>", "");
+		}
+		
+		return strRemove;
+	}
+	
+	public static boolean setChkFilePath(String filePath){
+		
+		boolean chk = false;
+		
+		if(filePath != null && !"".equals(filePath)){
+			if(filePath.indexOf(".") >= 0){
+				chk = true;
+			}
+		}
+		
+		return chk;
+	}
+	
+	public static Long getFolderSize(File file, Long volume){
+		
+		File[] listFile = file.listFiles();
+		
+		if(listFile != null && listFile.length > 0){
+	
+			for(int i=0;i<listFile.length;i++){
+				if(listFile[i].isFile()){
+					volume += listFile[i].length();
+				}else{
+					volume = getFolderSize(listFile[i], volume);
+				}
+			}
+		}
+		
+		return volume;
+	}
+	
+	public static void getMemory(){
+		
+		Runtime runtime = Runtime.getRuntime();
+		
+		DecimalFormat format = new DecimalFormat("###,###,###.##");
+		
+		long max = runtime.maxMemory();
+		
+		long total = runtime.totalMemory();
+		
+		long free = runtime.freeMemory();
+		
+		log.error("=============================================");
+		log.error("=============================================");
+		
+		log.error("Max : " + format.format(max));
+		log.error("Total : " + format.format(total));
+		log.error("Free : " + format.format(free));
+	}
+
+	 /**
+	 * 행안부 보안취약점 점검 조치 방안.
+	 *
+	 * @param value
+	 * @return
+	 */
+ 	public static String setFilePathReplaceAll(String value) {
+ 		
+ 		String returnValue = value;
+ 		
+ 		if (returnValue == null || returnValue.trim().equals("")) {
+ 			return "";
+ 		}
+
+ 		returnValue = returnValue.replaceAll("[.][.]/", "");
+ 		returnValue = returnValue.replaceAll("[.]/", "");
+ 		returnValue = returnValue.replaceAll("[.]\\\\\\\\", "");
+ 		returnValue = returnValue.replaceAll("[.][.]\\\\\\\\", "");
+ 		returnValue = returnValue.replaceAll("\\\\\\\\", "");
+ 		returnValue = returnValue.replaceAll("\\\\[.]\\\\[.]", ""); // ..
+ 		returnValue = returnValue.replaceAll("&", "");
+
+ 		return returnValue;
+ 	}
+ 	
+	public static String replaceXss(String s){
+		
+		if(s != null && !"".equals(s)){
+			s = s
+			.replaceAll("(?i)script", "s-c-r-i-p-t")
+			.replaceAll("(?i)javascript", "j-v-a-s-c-r-i-p-t")
+			.replaceAll("(?i)expression", "e-x-p-r-e-s-s-i-o-n")
+			.replaceAll("(?i)vbscript", "v-b-s-c-r-i-p-t")
+			.replaceAll("(?i)onabort", "0nabort")
+			.replaceAll("(?i)onactivate", "0nactivate")
+			.replaceAll("(?i)onafter", "0nafter")
+			.replaceAll("(?i)onbefore", "0nbefore")
+			.replaceAll("(?i)onblur", "0nblur")
+			.replaceAll("(?i)onbounce", "0nbounce")
+			.replaceAll("(?i)oncellchange", "0ncellchange")
+			.replaceAll("(?i)onchange", "0nchange")
+			.replaceAll("(?i)onclick", "0nclick")
+			.replaceAll("(?i)oncontextmenu", "0ncontextmenu")
+			.replaceAll("(?i)oncontrolselect", "0ncontrolselect")
+			.replaceAll("(?i)oncopy", "0ncopy")
+			.replaceAll("(?i)oncut", "0ncut")
+			.replaceAll("(?i)ondataavailable", "0ndataavailable")
+			.replaceAll("(?i)ondataset", "0ndataset")
+			.replaceAll("(?i)ondblclick", "0ndblclick")
+			.replaceAll("(?i)ondeactivate", "0ndeactivate")
+			.replaceAll("(?i)ondrag", "0ndrag")
+			.replaceAll("(?i)ondrop", "0ndrop")
+			.replaceAll("(?i)onerror", "0nerror")
+			.replaceAll("(?i)onfilterchange", "0nfilterchange")
+			.replaceAll("(?i)onfinish", "0nfinish")
+			.replaceAll("(?i)onfocus", "0nfocus")
+			.replaceAll("(?i)onhelp", "0nhelp")
+			.replaceAll("(?i)onkeydown", "0nkeydown")
+			.replaceAll("(?i)onkeypress", "0nkeypress")
+			.replaceAll("(?i)onkeyup", "0nkeyup")
+			.replaceAll("(?i)onload", "0nload")
+			.replaceAll("(?i)onlosecapture", "0nlosecapture")
+			.replaceAll("(?i)onmouse", "0nmouse")
+			.replaceAll("(?i)onmove", "0nmove")
+			.replaceAll("(?i)onpaste", "0npaste")
+			.replaceAll("(?i)onpropertychange", "0npropertychange")
+			.replaceAll("(?i)onreadystatechange", "0nreadystatechange")
+			.replaceAll("(?i)onreset", "0nreset")
+			.replaceAll("(?i)onresize", "0nresize")
+			.replaceAll("(?i)onrow", "0nrow")
+			.replaceAll("(?i)onscroll", "0nscroll")
+			.replaceAll("(?i)onselect", "0nselect")
+			.replaceAll("(?i)onselectionchange", "0nselectionchange")
+			.replaceAll("(?i)onselectstart", "0nselectstart")
+			.replaceAll("(?i)onstart", "0nstart")
+			.replaceAll("(?i)onstop", "0nstop")
+			.replaceAll("(?i)onsubmit", "0nsubmit")
+			.replaceAll("(?i)onunload", "0nunload");
+		}
+		
+		return s;
+	}
+ 	
+	public static String fileSizeConvert(String fileSize, String convertUnit){
+		String unitStr 				= "Mbyte";
+		long longFileSize 			= Long.parseLong(fileSize);
+		double doubleFileSize 	= (double)longFileSize;
+		
+		doubleFileSize = doubleFileSize/1024/1024;
+		
+		DecimalFormat df = new DecimalFormat("#,##0.00");
+		
+		return df.format(doubleFileSize)+unitStr;
+	}
+	
+	/**
+	 * 정규식을 이용해서 넘겨받은 숫자형 String데이터를 3자리마다 ,를 찍어주는 메소드
+	 * @param String objectData 변경할 데이터
+	 * @return String 변경된 데이터
+	 * */
+	public static String stringDecimalWork(String objectData){
+		if(objectData!=null){
+			return objectData.replaceAll("(?<=[0-9])(?=([0-9][0-9][0-9])+(?![0-9]))", ",");
+		}else{
+			return "";
+		}
+	}
+	
+	public static String getByteCut(String str, int length, int chkLen){
+		
+		String returnStr = "";
+		
+		if(str != null && !str.equals("")){
+			int iLoop = str.length();
+			
+			if(iLoop > length){
+				int chkLoop = 0;
+				for(int i=0; i<iLoop; i++){
+					if(chkLoop >= length){
+						returnStr = returnStr + "...";
+						break;
+					}
+					char ch = str.charAt(i);
+					Character.UnicodeBlock unicodeBlock = Character.UnicodeBlock.of(ch);
+					if(Character.UnicodeBlock.HANGUL_SYLLABLES.equals(unicodeBlock) || 
+							Character.UnicodeBlock.HANGUL_JAMO.equals(unicodeBlock) ||
+							Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO.equals(unicodeBlock)){
+						returnStr = returnStr+String.valueOf(ch);
+						chkLoop = chkLoop+chkLen;
+					}else{
+						returnStr = returnStr+String.valueOf(ch);
+						chkLoop = chkLoop+1;
+					}
+				}
+			}else{
+				returnStr = str;
+			}
+		}
+		
+		return returnStr;
+	}
+	
+	public static String getJspContentTypeStr(){
+		return "<%@ page language=\"java\" contentType=\"text/html; charset=UTF-8\" pageEncoding=\"UTF-8\"%>";
+	}
+	
+	public static void setFileMkdirAuthSet(File dir){
+		if(dir != null){
+			dir.setExecutable(false, true);
+			dir.setReadable(true);
+			dir.setWritable(true, true);
+		}
+	}
+	
+	public static boolean getBrowserHtml5(String userAgent){
+		
+		boolean success = true;
+		
+		//IE 버전일때 체크
+		if(userAgent.indexOf("msie") > -1 || userAgent.indexOf("trident/") > -1){
+			
+			//IE6, IE7은 Trident 없음
+			if(userAgent.indexOf("trident/") <= -1){
+				success = false;
+			}else{
+				if(userAgent.indexOf("trident/5.0") > -1){
+					//IE 9
+					success = false;
+				}else if(userAgent.indexOf("trident/4.0") > -1){
+					//IE 8
+					success = false;
+				}
+			}
+		}
+		
+		return success;
+	}
+	
+	public static boolean getBrowserIE(String userAgent){
+		
+		boolean success = false;
+		
+		//IE 버전일때 체크
+		if(userAgent.indexOf("msie") > -1 || userAgent.indexOf("trident/") > -1){
+			success = true;
+		}
+		
+		return success;
+	}
+	
+	/**
+	 * long형태의 데이터를 int형태로 변경하는 메소드
+	 * 변경 실패시 IllegalArgumentException 발생
+	 * */
+	public static int safeLongToInt(long l) {
+	    int i = (int)l;
+	    if ((long)i != l) {
+	        throw new IllegalArgumentException(l + " safeLongToInt에서 에러 발생");
+	    }
+	    return i;
+	}
+	
+	public static boolean isMobile(String userAgent){
+		boolean isMobile = false;
+		userAgent 			= userAgent.toLowerCase();
+		
+		String[] mobileKeyWord = {"iphone","ipod","android","blackberry","opera mini","opera mobi","skyfire","maemo","windows phone","palm","iemobile","symbian","symbianos","fennec"};
+		for(int i=0; i<mobileKeyWord.length; i++){
+			String chkKeyWord = mobileKeyWord[i];
+			if(userAgent.indexOf(chkKeyWord)>-1){
+				isMobile = true;
+				break;
+			}
+		}
+		return isMobile;
+	}
+	
+	public static boolean isTablet(String userAgent){
+		boolean isTablet = false;
+		userAgent 			= userAgent.toLowerCase();
+		String[] mobileKeyWord = {"ipad","android 3","sch-i800","playbook","tablet","kindle","gt-p1000","sgh-t849","shw-m180s","a510","a511","a100","dell streak","silk"};
+		for(int i=0; i<mobileKeyWord.length; i++){
+			String chkKeyWord = mobileKeyWord[i];
+			if(userAgent.indexOf(chkKeyWord)>-1){
+				isTablet = true;
+				break;
+			}
+		}
+		return isTablet;
+	}
+	
+	public static String encodeURIComponent(String s) {
+	    String result = null;
+	    try{
+	      result = URLEncoder.encode(s, "UTF-8")
+	                         .replaceAll("\\+", "%20")
+	                         .replaceAll("\\%21", "!")
+	                         .replaceAll("\\%27", "'")
+	                         .replaceAll("\\%28", "(")
+	                         .replaceAll("\\%29", ")")
+	                         .replaceAll("\\%7E", "~");
+	    }catch (UnsupportedEncodingException e){result = s;}
+	    return result;
+	}
+
+	public static boolean isCookieChk(String cookieKey, int cookieHour, HttpServletRequest request, HttpServletResponse response){
+		
+		try {
+			
+			if(cookieHour == 0){
+				return true;
+			}
+			
+			SeedCookieUtil seedCookieUtil = new SeedCookieUtil();
+			
+			String cookieVal = seedCookieUtil.getCookie(request, cookieKey);
+
+			if (!("Y".equals(cookieVal))) {
+				seedCookieUtil.setCookie(response, cookieHour * 24 * 60 * 60, "/", cookieKey, "Y", true);
+				return true;
+			}
+			
+		}catch (Exception localException){
+			log.error("Exception localException");
+		}
+		
+		return false;
+	}
+	
+/*	public static String getCpuInfo() {
+		
+		String cpuInfo = "";
+		
+		Sigar sigar = new Sigar();
+
+        CpuPerc cpu;
+        
+		try {
+			cpu = sigar.getCpuPerc();
+			cpuInfo = CpuPerc.format(cpu.getUser());
+		} catch (SigarException e) {
+			log.error("CHECK ERROR:",e);
+		}
+
+        return cpuInfo;
+   }
+	
+	public static String getMemoryInfo() {
+		
+		String memoryInfo = "";
+		
+		Sigar sigar = new Sigar();
+        
+        Mem mem;
+		try {
+			mem = sigar.getMem();
+			memoryInfo = format(mem.getTotal()) + ":" + format(mem.getUsed()) + ":" + format(mem.getFree());
+		} catch (SigarException e) {
+			log.error("CHECK ERROR:",e);
+		}
+      
+        return memoryInfo;
+	}*/
+	
+	public static String format(Long value) {
+    	return Long.toString(new Long(value / 1024));
+    }
+}
\ No newline at end of file