config: local reposilite 환경으로 변경

2026-04-03 17:22:56 +09:00
210 changed files with 12414 additions and 14706 deletions
@@ -5,7 +5,6 @@ gradle.properties

 src/main/generated
 WebContent/generated
-src/main/resources/version.info

 # Eclipse #
 .metadata
@@ -236,9 +235,3 @@ gradle-app.setting
 # End of https://www.gitignore.io/api/java,macos,gradle,intellij
 /EAISIMWeb/
 /.apt_generated_tests/
-
-# Claude Code
-.claude/
-/작업내역*.md
-/설계서*.md
-/분석서*.md
@@ -1,172 +0,0 @@
-pipeline {
-  agent none
-
-  options {
-    timestamps()
-    disableConcurrentBuilds()
-    skipDefaultCheckout()   // stage별 agent의 자동 SCM checkout 방지 (Deploy 노드는 git 접근 불필요, unstash로만 WAR 수신)
-    buildDiscarder(logRotator(numToKeepStr: '20', artifactNumToKeepStr: '20'))
-  }
-
-  environment {
-    GIT_SSH_COMMAND = 'ssh -o StrictHostKeyChecking=accept-new'
-    WEBHOOK_URL = 'http://172.30.1.50:18000/api/hooks/01ba51b01d3c4c98ae8f3183a23a84ed713197857d024b5da4f303458195eb32'
-  }
-
-  stages {
-    stage('Build (djb-vm)') {
-      agent { label 'djb-vm' }
-      environment {
-        JAVA_HOME = '/apps/opts/jdk8'
-        GRADLE_HOME = '/apps/opts/gradle-8.7'
-        GRADLE_USER_HOME = '/apps/opts/gradle-home'
-        NODE_HOME = '/apps/opts/node-v24'
-        PATH = "/apps/opts/jdk8/bin:/apps/opts/gradle-8.7/bin:/apps/opts/node-v24/bin:/apps/opts/bin:${env.PATH}"
-      }
-      stages {
-        stage('Checkout') {
-          steps { checkout scm }
-        }
-
-        stage('Checkout modules') {
-          steps {
-            sh '''
-              set -eu
-
-              for REPO in elink-online-core elink-online-transformer elink-online-common elink-online-emsclient elink-online-core-jpa; do
-                if [ ! -e "$REPO/.git" ]; then
-                  rm -rf "$REPO"
-                  git clone --depth=1 --branch master \
-                    "ssh://git@172.30.1.50:2222/djb-eapim/$REPO.git" \
-                    "$REPO"
-                else
-                  git -C "$REPO" fetch --depth=1 origin master
-                  git -C "$REPO" reset --hard origin/master
-                  git -C "$REPO" clean -fdx
-                fi
-              done
-            '''
-          }
-        }
-
-        stage('Verify toolchain') {
-          steps {
-            sh '''
-              set -eu
-              java -version
-              gradle --version
-            '''
-          }
-        }
-
-        stage('Build WAR') {
-          steps { sh 'gradle clean build -x test --no-daemon -Pprofile=weblogic' }
-          post {
-            success {
-              sh '''
-                set -eu
-                cd build/libs
-                sha256sum eapim-online.war > eapim-online.war.sha256
-              '''
-              archiveArtifacts artifacts: 'build/libs/eapim-online.war,build/libs/eapim-online.war.sha256', fingerprint: true
-              stash name: 'war', includes: 'build/libs/eapim-online.war'
-            }
-          }
-        }
-
-        // SBOM(CycloneDX) -> xlsx. 산출물 eapim-online-sbom.xlsx 를 아티팩트로 보관.
-        // 실패해도 배포는 진행하도록 UNSTABLE 로만 표시한다.
-        stage('SBOM') {
-          steps {
-            catchError(buildResult: 'UNSTABLE', stageResult: 'FAILURE') {
-              sh 'gradle sbomXlsx --no-daemon -Pprofile=weblogic'
-            }
-          }
-          post {
-            always {
-              archiveArtifacts allowEmptyArchive: true, artifacts: 'build/reports/sbom/*.xlsx', fingerprint: true
-            }
-          }
-        }
-      }
-    }
-
-    stage('Deploy (weblogic)') {
-      agent { label 'weblogic' }
-      environment {
-        JENKINS_NODE_COOKIE = 'dontKillMe'          // background weblogic를 빌드 종료 시 죽이지 않게
-        WL_HOME       = '/app/eapim/apigw'
-        WL_DEPLOY_DIR = '/app/eapim/apigw'
-        WL_WAR_NAME   = 'eapim-online.war'
-        WL_HTTP_PORT  = '39110'
-        WL_NOHUP      = '/logs/weblogic/domains/eapimDomain/nohup.agwSvr11.out'
-      }
-      stages {
-        stage('Stop WebLogic') {
-          steps {
-            sh '"$WL_HOME/stopAgw11.sh"'            // 동기: 완전 종료까지 블록, 미기동 시에도 안전
-          }
-        }
-        stage('Deploy WAR') {
-          steps {
-            unstash 'war'
-            sh '''
-              set -eu
-              cp build/libs/eapim-online.war "$WL_DEPLOY_DIR/$WL_WAR_NAME"
-              ls -la "$WL_DEPLOY_DIR"
-            '''
-          }
-        }
-        stage('Start WebLogic and readiness') {
-          steps {
-            sh '''
-              set -eu
-              "$WL_HOME/startAgw11.sh"              # nohup & 로 백그라운드 기동, 즉시 리턴
-
-              DEADLINE=$(($(date +%s) + 300))
-              STATUS=000
-              while [ "$(date +%s)" -lt "$DEADLINE" ]; do
-                STATUS=$(curl -sS -o /dev/null -w '%{http_code}' --max-time 3 \
-                  "http://localhost:$WL_HTTP_PORT/" 2>/dev/null || echo "000")
-                case "$STATUS" in
-                  200|302|401|403|404) echo "Readiness OK (/ HTTP $STATUS)"; break ;;
-                esac
-                sleep 3
-              done
-
-              case "$STATUS" in
-                200|302|401|403|404) ;;
-                *)
-                  echo "Readiness failed within 300s, last HTTP=$STATUS"
-                  [ -f "$WL_NOHUP" ] && tail -120 "$WL_NOHUP"
-                  exit 1
-                  ;;
-              esac
-            '''
-          }
-        }
-      }
-    }
-  }
-
-  post {
-    success {
-      node('weblogic') {
-        sh '''
-          set +e
-          payload=$(printf '{"text":"[%s #%s](%s) SUCCESS"}' "$JOB_NAME" "$BUILD_NUMBER" "$BUILD_URL")
-          curl -sS --fail --max-time 5 -H 'Content-Type: application/json' -X POST --data "$payload" "$WEBHOOK_URL" >/dev/null || echo "Webhook failed"
-        '''
-      }
-    }
-    failure {
-      node('weblogic') {
-        sh '''
-          set +e
-          payload=$(printf '{"text":"[%s #%s](%s) FAILURE"}' "$JOB_NAME" "$BUILD_NUMBER" "$BUILD_URL")
-          curl -sS --fail --max-time 5 -H 'Content-Type: application/json' -X POST --data "$payload" "$WEBHOOK_URL" >/dev/null || echo "Webhook failed"
-        '''
-      }
-    }
-  }
-}
@@ -66,10 +66,6 @@
        <prop key="hibernate.dialect">${hibernate.dialect:org.hibernate.dialect.Oracle12cDialect}</prop>
        <prop key="hibernate.jdbc.batch_size">100</prop>
        <prop key="hibernate.jdbc.fetch_size">100</prop>
-        <!-- 배치 로그 적재 시 같은 테이블 INSERT끼리 묶이도록 정렬한다.
-             미설정 시 엔티티 종류가 섞이면 배치가 잘게 쪼개진다. -->
-        <prop key="hibernate.order_inserts">true</prop>
-        <prop key="hibernate.order_updates">true</prop>
        <prop key="hibernate.cache.use_second_level_cache">false</prop>
        <prop key="hibernate.cache.use_query_cache">false</prop>
        <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
@@ -25,9 +25,6 @@
 		base-package="com.eactive.eai.adapter" />
 	<context:component-scan
 		base-package="com.eactive.eai.manage" />
-	<context:component-scan
-		base-package="com.eactive.eai.custom.inflow" />
-	
 	<context:annotation-config />
 	<mvc:annotation-driven />
 	<mvc:default-servlet-handler />
@@ -11,12 +11,12 @@ hibernate.dialect=org.hibernate.dialect.Oracle12cDialect
 # eLink default functions
 # set System property in real system
 #inst.Name=${HOSTNAME}
-inst.Name=agwSvr11
+inst.Name=agwSvr63
 eai.jdbc.Name=jdbc/dsOBP_AGW
-eai.rmiport=39111
-eai.rmiserviceport=39112
+eai.rmiport=30111
+eai.rmiserviceport=30112
 eai.systemmode=D
 # EAI FEP MCI GW ...
 eai.systemtype=API
-eai.tableowner=AGWAPP
+eai.tableowner=AGWADM
 eai.server.extractor=[0,2],[0,2],[-2]
@@ -9,12 +9,6 @@ hibernate.dialect=org.hibernate.dialect.Oracle12cDialect

 # eLink default functions

-inst.Name=agwSvr11
-eai.jdbc.Name=jdbc/dsOBP_AGW
-eai.rmiport=39111
-eai.rmiserviceport=39112
-eai.systemmode=P
-# EAI FEP MCI GW ...
 eai.systemtype=API
-eai.tableowner=AGWAPP
-eai.server.extractor=[0,2],[0,2],[-2]
+eai.server.extractor=[0,2],[0,2],[-2]
+
@@ -1,13 +1,10 @@
 # transaction logging
 logger.async.active=true
 logger.async.pool.initonstartup=true
-logger.async.pool.initsize=8
+logger.async.pool.intsize=8
 logger.async.pool.maxsize=10
 logger.async.queue.size=1024
-# worker.size=1 batch, 2~ 1Commit
-logger.async.worker.size=1
-# batch max sizeˆ˜
-logger.async.batch.size=100
+logger.async.worker.size=16

 # cloud option
 scalable=false
@@ -1,2 +1,2 @@
 #\uae30\uc874 ENV \ud56d\ubaa9 \uc678 \uae30\ud0c0 \uc2dc\uc2a4\ud15c \ud504\ub85c\ud37c\ud2f0\ub85c \uc815\uc758\uac00 \ud544\uc694\ud55c \ud544\ub4dc\ub97c \uc815\uc758
-transformer.validation=true
+transformer.validation=false
@@ -19,19 +19,18 @@
        <url-pattern>/agent/*</url-pattern>
        <url-pattern>/common/*</url-pattern>
        <url-pattern>/management/*</url-pattern>
-        <url-pattern>/manage/*</url-pattern>
        <url-pattern>/mgr/*</url-pattern>        
    </filter-mapping>

-	<!-- <filter>
+	<filter>
 		<filter-name>ApiRequestBodyFilter</filter-name>
 		<filter-class>com.eactive.eai.adapter.controller.ApiRequestBodyFilter</filter-class>
 	</filter>
 	<filter-mapping>
 		<filter-name>ApiRequestBodyFilter</filter-name>
-		<url-pattern>/api/*</url-pattern>  필요한 URL 패턴
-		<url-pattern>/dj/*</url-pattern>  필요한 URL 패턴
-	</filter-mapping> -->
+		<url-pattern>/api/*</url-pattern>  <!-- 필요한 URL 패턴 -->
+		<url-pattern>/mapi/*</url-pattern>  <!-- 필요한 URL 패턴 -->
+	</filter-mapping>
    

 	<context-param>
@@ -19,11 +19,10 @@
        <url-pattern>/agent/*</url-pattern>
        <url-pattern>/common/*</url-pattern>
        <url-pattern>/management/*</url-pattern>
-        <url-pattern>/manage/*</url-pattern>
        <url-pattern>/mgr/*</url-pattern>        
    </filter-mapping>

-	<!-- <filter>
+	<filter>
 		<filter-name>ApiRequestBodyFilter</filter-name>
 		<filter-class>com.eactive.eai.adapter.controller.ApiRequestBodyFilter</filter-class>
 	</filter>
@@ -31,7 +30,7 @@
 		<filter-name>ApiRequestBodyFilter</filter-name>
 		<url-pattern>/api/*</url-pattern>
 		<url-pattern>/mapi/*</url-pattern>
-	</filter-mapping> -->
+	</filter-mapping>

 	<context-param>
        <param-name>logbackDisableServletContainerInitializer</param-name>
@@ -5,7 +5,6 @@ plugins {
    id 'groovy'
    id 'war'
 	id 'com.diffplug.eclipse.apt' version '3.41.1'
-    id 'org.cyclonedx.bom' version '3.2.4'
 }

 group 'com.eactvie'
@@ -21,13 +20,17 @@ def queryDslVersion = "5.0.0"
 def hibernateVersion = "5.6.15.Final"

 def generatedJavaDir = "$buildDir/generated/java"
-def nexusUrl = "https://nexus.eactive.synology.me:8090"
+def reposiliteUrl = "http://localhost:8080"

 allprojects {
    repositories {
        maven {
-            url "${nexusUrl}/repository/maven-public/"
+            url "${reposiliteUrl}/private"
            allowInsecureProtocol = true
+            credentials {
+                username = reposiliteUser
+                password = reposilitePassword
+            }
        }
    }
 }
@@ -110,11 +113,7 @@ dependencies {


 		implementation "org.springframework:spring-webmvc:${springVersion}"
-		// bcpkix/bcprov-jdk15on:1.64 전이 차단 — BouncyCastle 은 elink-online-common 이
-		// 제공하는 jdk18on 라인만 사용한다(구버전 클래스 중복 방지).
-		implementation ("org.springframework.security:spring-security-jwt:1.1.1.RELEASE") {
-			exclude group: 'org.bouncycastle'
-		}
+		implementation "org.springframework.security:spring-security-jwt:1.1.1.RELEASE"

 		//implementation "com.eactive:ojdbc8:1.0"
 		//implementation "org.postgresql:postgresql:42.2.23"
@@ -161,28 +160,6 @@ test {
 configurations.all {
 	exclude group: 'log4j', module: 'log4j'
 	exclude group: 'org.codehaus.jackson'
-
-	// commons-fileupload: elink-online-common 이 api 로 선언(build.gradle:85)하지만,
-	// 사용처는 HttpAdapterServiceRest / HttpAdapterServiceVirtualAccount 두 클래스뿐이다.
-	// 두 클래스는 정적 참조가 없고 HttpAdapterServiceFactory 의
-	// Class.forName(DB 설정 클래스명) 으로만 로드되는데, DJB 는 자체 DJBApiAdapterService 를
-	// 사용하므로 이 어댑터 서비스가 기동되지 않는다(= 런타임 미사용).
-	// 공유 모듈인 elink-online-common 에서 의존성을 지우면 타 사이트가 깨지므로,
-	// 루트에서만 배제해 배포 WAR(WEB-INF/lib)에서 제외한다.
-	//   ※ 운영 DB 어댑터 설정에 위 두 클래스가 등록되면 NoClassDefFoundError 가 발생하므로,
-	//     해당 어댑터를 사용하게 되는 시점에 이 exclude 를 반드시 제거할 것.
-	exclude group: 'commons-fileupload'
-
-	// BouncyCastle jdk15on 라인 최종 차단.
-	// jdk15on 과 jdk18on 은 artifactId 가 달라 Gradle 이 같은 라이브러리로 보지 않는다.
-	// 어느 경로로든 유입되면 org.bouncycastle.* 가 WEB-INF/lib 에 중복 적재되므로
-	// 배포 WAR 기준으로 한 번 더 배제한다(사용 버전: bcprov/bcpkix-jdk18on 1.78.1).
-	exclude group: 'org.bouncycastle', module: 'bcprov-jdk15on'
-	exclude group: 'org.bouncycastle', module: 'bcpkix-jdk15on'
-
-	// 구 groupId 의 dom4j(=1.6.1) 최종 차단. org.dom4j:dom4j:2.1.3 만 사용한다.
-	// (groupId 가 달라 Gradle 이 버전 충돌로 인식하지 못하므로 명시적으로 배제)
-	exclude group: 'dom4j', module: 'dom4j'
 }

 task settingEclipseEncoding {
@@ -199,54 +176,6 @@ task initDirs() {
 	file(generatedJavaDir).mkdirs()
 }

-// version.info 를 classpath 리소스로 생성해 WAR의 WEB-INF/classes에 포함시킨다.
-// elink-online-common 등 공유 라이브러리 모듈이 아니라, 실제 배포 아티팩트(eapim-online.war)를
-// 만드는 이 루트 프로젝트에서 생성해야 "지금 배포된 게이트웨이가 정확히 어느 커밋인지"를
-// eapim-online 소스 변경 여부와 무관하게 항상 최신으로 반영한다.
-// ToolsController(/manage/tools/version, elink-online-common 모듈)는 이 파일을
-// Class.getResourceAsStream("/version.info")로 읽는데, WAR는 WEB-INF/classes와
-// WEB-INF/lib 전체가 하나의 클래스로더를 공유하므로 어느 모듈의 클래스에서 조회하든 찾을 수 있다.
-//
-// elink-online-common/elink-online-core/... 는 별도 저장소를 참조하는 git submodule이라
-// 루트(eapim-online)의 describe/dirty 만으로는 "어느 서브모듈이 바뀌었는지"를 알 수 없다
-// (서브모듈 포인터가 커밋되고 나면 루트는 다시 clean 해져서 -dirty 흔적도 사라진다).
-// 그래서 서브모듈 각각에 대해서도 describe를 실행해 module.<이름>=<결과> 형식으로 함께 기록한다.
-def describeGit(File dir) {
-	try {
-		def proc = "git describe --tags --always --dirty".execute(null, dir)
-		// proc.text는 JVM/OS 기본 charset(Windows 환경에선 CP949 등)으로 stdout을 디코딩한다.
-		// git 태그명은 UTF-8 바이트이므로 기본 charset이 UTF-8이 아니면 여기서 한글이 깨진다.
-		// stream을 명시적으로 UTF-8로 읽어서 이 문제를 피한다.
-		def output = proc.inputStream.getText("UTF-8")
-		proc.waitFor()
-		return (proc.exitValue() == 0) ? output.trim() : "unknown"
-	} catch (Exception e) {
-		logger.warn("${dir} git describe 실행 불가, unknown 으로 대체: ${e.message}")
-		return "unknown"
-	}
-}
-
-task generateVersionInfo {
-	doLast {
-		def gitVersion = describeGit(projectDir)
-
-		def sb = new StringBuilder()
-		sb.append("version=${gitVersion}\n")
-		sb.append("buildTime=${new Date().format("yyyy-MM-dd HH:mm:ss")}\n")
-		subprojects.sort { it.name }.each { sub ->
-			if (file("${sub.projectDir}/.git").exists()) {
-				sb.append("module.${sub.name}=${describeGit(sub.projectDir)}\n")
-			}
-		}
-
-		def versionInfoFile = file("$projectDir/src/main/resources/version.info")
-		versionInfoFile.parentFile.mkdirs()
-		versionInfoFile.write(sb.toString(), "UTF-8")
-	}
-}
-
-processResources.dependsOn generateVersionInfo
-
 eclipse {
 	wtp {
 		component {
@@ -276,6 +205,3 @@ eclipse {
 	}
 }

-
-// CycloneDX SBOM -> xlsx 변환 (gradle sbomXlsx)
-apply from: "$projectDir/gradle/sbom-xlsx.gradle"
@@ -0,0 +1,252 @@
+# JWT 서명 검증 및 인증서 관리
+
+## 1. 전체 구조
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│              Authorization Server (elink-oauth)                  │
+│  elink-oauth-dev.jks                                            │
+│  ├── 개인키 (RSA Private Key)  ← JWT 서명 생성용               │
+│  └── 공개키 인증서 (Certificate)                                │
+└─────────────────────────────────────────────────────────────────┘
+                          │ 공개키만 추출
+                          ▼
+┌─────────────────────────────────────────────────────────────────┐
+│              API Gateway (ApiAuthFilter)                         │
+│  elink-oauth-dev.pub                                            │
+│  └── 공개키만 (RSA Public Key)  ← JWT 서명 검증용만            │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 2. JKS vs PUB 파일 차이점
+
+| 항목 | `.jks` (Java KeyStore) | `.pub` (Public Key) |
+|------|----------------------|---------------------|
+| 형식 | 바이너리 (Java 전용) | PEM 텍스트 (`-----BEGIN PUBLIC KEY-----`) |
+| 포함 내용 | 개인키 + 공개키 인증서 | 공개키만 |
+| 보호 | KeyStore 비밀번호 + Key 비밀번호 | 없음 (공개 가능) |
+| 사용처 | AuthorizationServerConfig - **토큰 서명** | ApiAuthFilter - **토큰 검증** |
+| 코드 로딩 | `KeyStoreKeyFactory` → `KeyPair` | `X509EncodedKeySpec` → `RSAPublicKey` |
+| 보안 등급 | **극비** (노출 시 토큰 위조 가능) | 공개 배포 가능 |
+
+### 코드에서의 사용 위치
+
+```java
+// AuthorizationServerConfig.java - JKS로 JWT 서명
+KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(keystore, keystorePassword.toCharArray());
+KeyPair keyPair = keyStoreKeyFactory.getKeyPair(keyAlias, keyPassword.toCharArray());
+converter.setKeyPair(keyPair);  // 개인키로 JWT 서명
+
+// ApiAuthFilter.java - PUB로 JWT 검증
+X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
+KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+jwsVerifier = new RSASSAVerifier((RSAPublicKey) keyFactory.generatePublic(keySpec));  // 공개키로 검증만
+```
+
+---
+
+## 3. JWT 서명 검증 상세 동작 (`signedJWT.verify(jwsVerifier)`)
+
+### JWT 구조
+
+```
+eyJhbGciOiJSUzI1NiJ9  .  eyJzdWIiOiJ1c2VyMSIsImV4cCI6...}  .  MEUCIQDx...
+      Header                        Payload                        Signature
+   (Base64url)                   (Base64url)                    (Base64url)
+```
+
+### 서명 생성 과정 (Authorization 서버 측)
+
+```
+[Header].[Payload]
+       ↓
+  SHA-256 해싱
+       ↓
+  digest (32 bytes)
+       ↓
+  RSA 개인키로 암호화 (PKCS#1 v1.5 패딩)
+       ↓
+  Signature (Base64url 인코딩)
+```
+
+### 서명 검증 과정 (ApiAuthFilter 측)
+
+```
+JWT 수신
+   ↓
+① Header + Payload 분리
+   "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1c2VyMSIs..."
+   ↓
+② Signature 파트를 Base64url 디코딩
+   → 바이너리 서명값 확보
+   ↓
+③ RSA 공개키로 서명값 복호화  ← RSASSAVerifier (Nimbus JOSE)
+   → digest_from_signature 추출
+   ↓
+④ ①의 "Header.Payload" 문자열을 SHA-256 해싱
+   → digest_from_message 계산
+   ↓
+⑤ digest_from_signature == digest_from_message ?
+   → true  : 서명 유효 (개인키 소유자가 서명한 것 확인)
+   → false : 서명 불일치 → Token invalid 예외
+```
+
+### Nimbus JOSE 라이브러리 내부 흐름
+
+```java
+// RSASSAVerifier.verify() 내부
+public boolean verify(JWSHeader header, byte[] signingInput, Base64URL signature) {
+    String jcaAlg = "SHA256withRSA";                 // RS256 알고리즘
+    Signature verifier = Signature.getInstance(jcaAlg);
+    verifier.initVerify(publicKey);                  // RSA 공개키 초기화
+    verifier.update(signingInput);                   // [Header].[Payload] 바이트 입력
+    return verifier.verify(signature.decode());      // Signature 바이트와 대조 검증
+}
+```
+
+### 보안 원리 (RSA 비대칭 키)
+
+| 시도 | 결과 |
+|------|------|
+| Payload 변조 후 전송 | digest 불일치 → 검증 실패 |
+| 개인키 없이 서명 위조 | RSA 수학적으로 불가능 |
+| 공개키로 새 서명 생성 | 공개키로는 암호화 불가 |
+| 만료된 토큰 재사용 | exp 체크에서 차단 |
+
+### ApiAuthFilter 검증 흐름
+
+```
+클라이언트 요청
+    ↓
+Bearer 토큰 추출 (Authorization 헤더 or access_token 파라미터)
+    ↓
+SignedJWT.parse(token)            ← JWT 파싱
+    ↓
+만료시간(exp) 확인
+    ↓
+signedJWT.verify(jwsVerifier)     ← RSA 공개키로 서명 검증
+    ↓
+Scope 검증 (oob/public이면 패스, 아니면 API별 허용 scope 확인)
+    ↓
+client_id 확인 (헤더 vs 토큰 payload 비교)
+    ↓
+등록된 APP 및 API 접근 권한 확인
+```
+
+---
+
+## 4. Self-Signed 인증서 생성 방법
+
+### 사전 요구사항
+
+- **JDK** (keytool 포함)
+- **OpenSSL**
+
+### 1단계: JKS 파일 생성
+
+```bash
+keytool -genkeypair \
+  -alias elink-oauth \
+  -keyalg RSA \
+  -keysize 2048 \
+  -sigalg SHA256withRSA \
+  -validity 3650 \
+  -keystore elink-oauth-dev.jks \
+  -storepass elink1234 \
+  -keypass elink1234 \
+  -dname "CN=elink-oauth, OU=eActive, O=eActive, L=Seoul, ST=Seoul, C=KR"
+```
+
+> 옵션 설명
+> - `-alias` : 키 별칭 (코드의 `certification.keyAlias` 설정값과 일치해야 함)
+> - `-keysize 2048` : RSA 키 길이 (최소 2048 권장)
+> - `-validity 3650` : 유효기간 (일 단위, 3650 = 10년)
+> - `-storepass` : KeyStore 전체 비밀번호 (`certification.keystorePassword`)
+> - `-keypass` : 개별 키 비밀번호 (`certification.keyPassword`)
+
+### 2단계: JKS에서 공개키(.pub) 추출
+
+**방법 A: keytool + openssl 조합**
+
+```bash
+# JKS → 인증서(CER) 추출
+keytool -exportcert \
+  -alias elink-oauth \
+  -keystore elink-oauth-dev.jks \
+  -storepass elink1234 \
+  -file elink-oauth-dev.cer
+
+# CER에서 공개키 추출 → PEM 형식(.pub)
+openssl x509 \
+  -inform DER \
+  -in elink-oauth-dev.cer \
+  -pubkey -noout \
+  -out elink-oauth-dev.pub
+```
+
+**방법 B: JKS → PKCS12 변환 후 openssl**
+
+```bash
+# JKS → PKCS12 변환
+keytool -importkeystore \
+  -srckeystore elink-oauth-dev.jks \
+  -destkeystore elink-oauth-dev.p12 \
+  -deststoretype PKCS12 \
+  -srcalias elink-oauth \
+  -srcstorepass elink1234 \
+  -deststorepass elink1234
+
+# PKCS12에서 공개키 추출
+openssl pkcs12 \
+  -in elink-oauth-dev.p12 \
+  -passin pass:elink1234 \
+  -nokeys \
+  -out temp-cert.pem
+
+openssl x509 \
+  -in temp-cert.pem \
+  -pubkey -noout \
+  -out elink-oauth-dev.pub
+```
+
+### 3단계: 생성 결과 확인
+
+```bash
+# JKS 내용 확인
+keytool -list -v \
+  -keystore elink-oauth-dev.jks \
+  -storepass elink1234
+
+# 공개키 내용 확인
+cat elink-oauth-dev.pub
+# 결과:
+# -----BEGIN PUBLIC KEY-----
+# MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
+# -----END PUBLIC KEY-----
+```
+
+---
+
+## 5. 파일 배치
+
+```
+Authorization Server (elink-oauth)
+└── src/main/resources/certificate/
+    └── elink-oauth-dev.jks       ← 개인키 포함, 절대 외부 노출 금지
+
+API Gateway (elink-online-common)
+└── src/main/resources/certificate/
+    └── elink-oauth-dev.pub       ← 공개키만, 배포 가능
+```
+
+## 6. 설정 파일 (`OAuthServer` PropGroup)
+
+| 프로퍼티 키 | 설명 | 사용 위치 |
+|------------|------|----------|
+| `certification.keystorePath` | JKS 파일 경로 | AuthorizationServerConfig |
+| `certification.keystorePassword` | KeyStore 비밀번호 | AuthorizationServerConfig |
+| `certification.keyAlias` | 키 별칭 | AuthorizationServerConfig |
+| `certification.keyPassword` | 키 비밀번호 | AuthorizationServerConfig |
+| `certification.publicKeyPath` | PUB 파일 경로 | ApiAuthFilter |
@@ -1,326 +0,0 @@
-/*
- * CycloneDX SBOM(bom.json) -> Excel(xlsx) 변환 태스크.
- *
- *   gradle sbomXlsx                       # cyclonedxBom 실행 후 변환
- *   gradle sbomXlsx -PsbomJson=path.json  # 기존 bom.json 사용(cyclonedxBom 생략)
- *   gradle sbomXlsx -PsbomOut=out.xlsx    # 출력 경로 지정
- *
- * buildscript 블록이 이 스크립트에만 적용되므로 POI 의존성이 메인 빌드
- * classpath 나 WAR 산출물에는 포함되지 않는다.
- *
- * 시트: 요약 / WAR 기준
- * 산출 기준은 war 태스크의 classpath(= runtimeClasspath) 이므로
- * test·annotationProcessor·developmentOnly·compileOnly 의존은 모두 제외된다.
- * bom.json 은 라이선스/해시/설명/직접-전이 판별을 위한 메타 소스로만 쓴다.
- */
-buildscript {
-    repositories {
-        maven {
-            url "https://nexus.eactive.synology.me:8090/repository/maven-public/"
-            allowInsecureProtocol = true
-        }
-        mavenCentral()
-    }
-    dependencies {
-        classpath 'org.apache.poi:poi-ooxml:3.17'
-    }
-}
-
-import groovy.json.JsonSlurper
-import org.apache.poi.ss.usermodel.BorderStyle
-import org.apache.poi.ss.usermodel.FillPatternType
-import org.apache.poi.ss.usermodel.HorizontalAlignment
-import org.apache.poi.ss.usermodel.IndexedColors
-import org.apache.poi.ss.usermodel.VerticalAlignment
-import org.apache.poi.ss.util.CellRangeAddress
-import org.apache.poi.xssf.usermodel.XSSFWorkbook
-
-// 엑셀 셀 문자열 상한(32767)보다 여유를 둔 절단 길이
-ext.SBOM_CELL_LIMIT = 32000
-
-task sbomXlsx {
-    group = 'sbom'
-    description = 'CycloneDX bom.json 을 WAR 수록 기준 xlsx 로 변환한다'
-
-    // -PsbomJson 으로 기존 산출물을 지정하면 재생성하지 않는다
-    if (!project.hasProperty('sbomJson')) {
-        dependsOn 'cyclonedxBom'
-    }
-
-    doLast {
-        File src = resolveBomJson(project)
-        File out = project.hasProperty('sbomOut')
-                ? project.file(project.property('sbomOut'))
-                : new File(project.buildDir, "reports/sbom/${sbomFileName(project)}")
-        out.parentFile.mkdirs()
-
-        def bom = new JsonSlurper().parse(src, 'UTF-8')
-        def deploy = collectDeployJars(project)
-        def warRows = joinWarRows(deploy.jars, indexComponents(bom))
-
-        def wb = new XSSFWorkbook()
-        def st = createStyles(wb)
-        writeSummarySheet(wb, st, bom, warRows, src, deploy.label)
-        writeWarSheet(wb, st, warRows)
-
-        out.withOutputStream { os -> wb.write(os) }
-        wb.close()
-
-        int unmatched = warRows.count { it.matched == 'N' }
-        logger.lifecycle("SBOM xlsx 생성: ${out.absolutePath} " +
-                "(배포 수록 ${warRows.size()}개, SBOM 미매칭 ${unmatched}개, 원본 ${src.name})")
-    }
-}
-
-/** 산출 파일명: 배포 패키지명 기준 (war 있으면 war 파일명, 없으면 project 이름[-버전]) */
-String sbomFileName(Project p) {
-    def warTask = p.tasks.findByName('war')
-    if (warTask != null) {
-        String archive = warTask.archiveFileName.get()
-        return archive.replaceAll(/\.(war|jar|ear)$/, '') + '-sbom.xlsx'
-    }
-    String ver = (p.version == null || p.version.toString() in ['', 'unspecified']) ? '' : "-${p.version}"
-    return "${p.name}${ver}-sbom.xlsx"
-}
-
-/** bom.json 위치 결정: -PsbomJson > cyclonedxBom 산출 경로 후보 */
-File resolveBomJson(Project p) {
-    if (p.hasProperty('sbomJson')) {
-        File f = p.file(p.property('sbomJson'))
-        if (!f.exists()) {
-            throw new GradleException("bom.json 없음: ${f.absolutePath}")
-        }
-        return f
-    }
-    def candidates = [
-            new File(p.buildDir, 'reports/cyclonedx/bom.json'),
-            new File(p.buildDir, 'reports/bom.json'),
-    ]
-    File found = candidates.find { it.exists() }
-    if (found == null) {
-        throw new GradleException(
-                "bom.json 을 찾지 못했다. 확인한 경로: " + candidates*.absolutePath.join(', ') +
-                        "\n'gradle cyclonedxBom' 실행 후 재시도하거나 -PsbomJson=<경로> 로 지정한다.")
-    }
-    return found
-}
-
-/**
- * 실제 배포물에 packaging 되는 jar 목록.
- * war 프로젝트는 war 태스크 classpath(= runtimeClasspath), 그 외는 runtimeClasspath 를
- * 기준으로 하므로 test/annotationProcessor/developmentOnly/compileOnly 는 자동으로 빠진다.
- *
- * @return [label: 기준 설명, jars: 행 목록]
- */
-Map collectDeployJars(Project p) {
-    def cfg = p.configurations.findByName('runtimeClasspath')
-    if (cfg == null) {
-        p.logger.warn("[${p.name}] runtimeClasspath 가 없어 배포 기준 시트를 비운다")
-        return [label: '(없음)', jars: []]
-    }
-
-    def warTask = p.tasks.findByName('war')
-    def files
-    String label
-    if (warTask != null) {
-        files = warTask.classpath.files
-        label = 'WAR WEB-INF/lib (war 태스크 classpath)'
-    } else {
-        files = cfg.files
-        label = 'runtimeClasspath (war 태스크 없음)'
-    }
-
-    def coordByFile = [:]
-    cfg.resolvedConfiguration.resolvedArtifacts.each { a ->
-        def id = a.moduleVersion.id
-        coordByFile[a.file] = [group: id.group, name: id.name, version: id.version]
-    }
-    def jars = files.findAll { it.name.endsWith('.jar') }.collect { f ->
-        def c = coordByFile[f]
-        [
-                file   : f.name,
-                group  : c?.group ?: '',
-                name   : c?.name ?: f.name.replaceAll(/\.jar$/, ''),
-                version: c?.version ?: '',
-                coord  : c ? "${c.group}:${c.name}:${c.version}".toString() : '',
-        ]
-    }.sort { it.file }
-
-    return [label: label, jars: jars]
-}
-
-/** bom.json 컴포넌트를 'group:name:version' 키로 색인 (라이선스/해시/설명/직접-전이) */
-Map indexComponents(bom) {
-    String rootRef = bom.metadata?.component?.'bom-ref'
-    Set directRefs = (bom.dependencies?.find { it.ref == rootRef }?.dependsOn ?: []) as Set
-
-    def index = [:]
-    bom.components?.each { c ->
-        def hashes = [:]
-        c.hashes?.each { h -> hashes[h.alg] = h.content }
-
-        def licenses = (c.licenses ?: []).collect { l ->
-            l.license?.id ?: l.license?.name ?: l.expression ?: ''
-        }.findAll { it }
-
-        index["${c.group ?: ''}:${c.name ?: ''}:${c.version ?: ''}".toString()] = [
-                direct     : directRefs.contains(c.'bom-ref') ? '직접' : '전이',
-                licenses   : licenses.join('; '),
-                licenseList: licenses.isEmpty() ? ['(미상)'] : licenses,
-                purl       : c.purl ?: '',
-                sha256     : hashes['SHA-256'] ?: '',
-                sha1       : hashes['SHA-1'] ?: '',
-                description: c.description ?: '',
-        ]
-    }
-    return index
-}
-
-/** WAR jar 목록에 SBOM 메타를 좌표로 결합 */
-List joinWarRows(List warJars, Map index) {
-    def result = []
-    warJars.eachWithIndex { j, i ->
-        def m = j.coord ? index[j.coord] : null
-        result << [
-                no         : i + 1,
-                file       : j.file,
-                group      : j.group,
-                name       : j.name,
-                version    : j.version,
-                direct     : m?.direct ?: '',
-                licenses   : m?.licenses ?: '',
-                licenseList: m?.licenseList ?: ['(미상)'],
-                purl       : m?.purl ?: '',
-                sha256     : m?.sha256 ?: '',
-                sha1       : m?.sha1 ?: '',
-                matched    : (m != null) ? 'Y' : 'N',
-                description: m?.description ?: '',
-        ]
-    }
-    return result
-}
-
-Map createStyles(wb) {
-    def headFont = wb.createFont()
-    headFont.setBold(true)
-    headFont.setColor(IndexedColors.WHITE.getIndex())
-
-    def head = wb.createCellStyle()
-    head.setFont(headFont)
-    head.setFillForegroundColor(IndexedColors.DARK_BLUE.getIndex())
-    head.setFillPattern(FillPatternType.SOLID_FOREGROUND)
-    head.setAlignment(HorizontalAlignment.CENTER)
-    head.setVerticalAlignment(VerticalAlignment.CENTER)
-    head.setBorderBottom(BorderStyle.THIN)
-
-    def body = wb.createCellStyle()
-    body.setVerticalAlignment(VerticalAlignment.TOP)
-
-    def wrap = wb.createCellStyle()
-    wrap.setVerticalAlignment(VerticalAlignment.TOP)
-    wrap.setWrapText(true)
-
-    def labelFont = wb.createFont()
-    labelFont.setBold(true)
-    def label = wb.createCellStyle()
-    label.setFont(labelFont)
-
-    return [head: head, body: body, wrap: wrap, label: label]
-}
-
-/** 헤더 행 생성 + 폭 지정 + 틀고정 */
-def writeHeader(sheet, style, List<String> headers, List<Integer> widths) {
-    def row = sheet.createRow(0)
-    row.setHeightInPoints(20f)
-    headers.eachWithIndex { h, i ->
-        def cell = row.createCell(i)
-        cell.setCellValue(h)
-        cell.setCellStyle(style)
-        sheet.setColumnWidth(i, widths[i] * 256)
-    }
-    sheet.createFreezePane(0, 1)
-}
-
-def cellOf(row, int idx, value, style) {
-    def cell = row.createCell(idx)
-    String s = (value == null) ? '' : value.toString()
-    if (s.length() > SBOM_CELL_LIMIT) {
-        s = s.substring(0, SBOM_CELL_LIMIT) + '…(생략)'
-    }
-    cell.setCellValue(s)
-    cell.setCellStyle(style)
-    return cell
-}
-
-def writeSummarySheet(wb, st, bom, List warRows, File src, String basisLabel) {
-    def sheet = wb.createSheet('요약')
-    def comp = bom.metadata?.component ?: [:]
-    def tool = bom.metadata?.tools?.components?.getAt(0)
-    Set licenseKinds = warRows.collectMany { it.licenseList } as Set
-
-    def items = [
-            ['대상 프로젝트', "${comp.group ?: ''}:${comp.name ?: ''}:${comp.version ?: ''}"],
-            ['산출 기준', "${basisLabel} — test/annotationProcessor/compileOnly 제외"],
-            ['BOM 포맷', "${bom.bomFormat ?: ''} ${bom.specVersion ?: ''}"],
-            ['serialNumber', bom.serialNumber ?: ''],
-            ['생성 시각', bom.metadata?.timestamp ?: ''],
-            ['생성 도구', tool ? "${tool.name} ${tool.version}" : ''],
-            ['원본 파일', src.absolutePath],
-            ['배포 수록 jar', warRows.size()],
-            ['  └ 직접 의존', warRows.count { it.direct == '직접' }],
-            ['  └ 전이 의존', warRows.count { it.direct == '전이' }],
-            ['  └ SBOM 미매칭', warRows.count { it.matched == 'N' }],
-            ['라이선스 종류', licenseKinds.size()],
-            ['라이선스 미상', warRows.count { it.licenses.isEmpty() }],
-    ]
-
-    writeHeader(sheet, st.head, ['항목', '값'], [30, 90])
-    items.eachWithIndex { item, i ->
-        def row = sheet.createRow(i + 1)
-        cellOf(row, 0, item[0], st.label)
-        cellOf(row, 1, item[1], st.body)
-    }
-
-    // 라이선스 분포 (요약 하단)
-    def byLicense = [:].withDefault { 0 }
-    warRows.each { r -> r.licenseList.each { lic -> byLicense[lic] = byLicense[lic] + 1 } }
-    def sorted = byLicense.entrySet().sort { a, b -> (b.value <=> a.value) ?: (a.key <=> b.key) }
-
-    int base = items.size() + 2
-    def hdr = sheet.createRow(base)
-    cellOf(hdr, 0, '라이선스', st.head)
-    cellOf(hdr, 1, 'jar 수', st.head)
-    sorted.eachWithIndex { e, i ->
-        def row = sheet.createRow(base + 1 + i)
-        cellOf(row, 0, e.key, st.body)
-        cellOf(row, 1, e.value, st.body)
-    }
-}
-
-/** 실제 배포물(WAR WEB-INF/lib) 기준 시트 */
-def writeWarSheet(wb, st, List warRows) {
-    def sheet = wb.createSheet('WAR 기준')
-    def headers = ['No', 'jar 파일명', 'Group', 'Name', 'Version', '구분',
-                   'License', 'purl', 'SHA-256', 'SHA-1', 'SBOM매칭', 'Description']
-    def widths = [6, 46, 32, 34, 16, 7, 30, 60, 40, 30, 10, 60]
-    writeHeader(sheet, st.head, headers, widths)
-
-    warRows.eachWithIndex { r, i ->
-        def row = sheet.createRow(i + 1)
-        cellOf(row, 0, r.no, st.body)
-        cellOf(row, 1, r.file, st.body)
-        cellOf(row, 2, r.group, st.body)
-        cellOf(row, 3, r.name, st.body)
-        cellOf(row, 4, r.version, st.body)
-        cellOf(row, 5, r.direct, st.body)
-        cellOf(row, 6, r.licenses, st.body)
-        cellOf(row, 7, r.purl, st.body)
-        cellOf(row, 8, r.sha256, st.body)
-        cellOf(row, 9, r.sha1, st.body)
-        cellOf(row, 10, r.matched, st.body)
-        cellOf(row, 11, r.description, st.wrap)
-    }
-    if (!warRows.isEmpty()) {
-        sheet.setAutoFilter(new CellRangeAddress(0, warRows.size(), 0, headers.size() - 1))
-    }
-}
@@ -1,6 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+#distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=file:///D:/installs/gradle-8.7-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
 networkTimeout=10000
@@ -0,0 +1,104 @@
+# Reposilite 3 연동 가이드
+
+## 구성 개요
+
+기존 Nexus(`https://nexus.eactive.synology.me:8090`) 대신 로컬 Reposilite 3(`http://localhost:8080`)를 통해 의존성을 다운로드한다.
+Reposilite의 `private` 레포지토리에 Nexus `maven-public`을 Mirror로 등록하여 캐싱한다.
+
+---
+
+## 1. Reposilite 3 설정
+
+관리자 패널 → **Repositories** → `private` 저장소 → **Edit**
+
+**Mirrored repositories** 항목에 추가:
+```
+https://nexus.eactive.synology.me:8090/repository/maven-public/
+```
+
+---
+
+## 2. 변경된 파일
+
+### `build.gradle` (루트)
+
+- `nexusUrl` → `reposiliteUrl` 변수명 변경
+- `allprojects.repositories` URL을 Reposilite로 변경
+- credentials를 `gradle.properties` 변수로 참조
+
+```groovy
+def reposiliteUrl = "http://localhost:8080"
+
+allprojects {
+    repositories {
+        maven {
+            url "${reposiliteUrl}/private"
+            allowInsecureProtocol = true
+            credentials {
+                username = reposiliteUser
+                password = reposilitePassword
+            }
+        }
+    }
+}
+```
+
+### `elink-online-core/build.gradle`
+
+- 단독 빌드용 `repositories` 블록의 URL 및 credentials 동일하게 변경
+
+```groovy
+// FOR LOCAL
+repositories {
+    maven {
+        url "${nexusUrl}/private"
+        allowInsecureProtocol = true
+        credentials {
+            username = reposiliteUser
+            password = reposilitePassword
+        }
+    }
+}
+```
+
+### `gradle.properties` (신규 생성)
+
+인증 정보를 별도 파일로 분리. `.gitignore`에 이미 등록되어 있어 git에 올라가지 않는다.
+
+```properties
+reposiliteUser=admin
+reposilitePassword=<reposilite-token>
+```
+
+---
+
+## 3. 서브모듈별 repositories 현황
+
+| 모듈 | repositories 블록 | 비고 |
+|------|------------------|------|
+| `build.gradle` (root) | `allprojects { ... }` | 모든 서브모듈에 상속 |
+| `elink-online-core` | 별도 정의 | 단독 빌드 대응용 (`// FOR LOCAL`) |
+| `elink-online-core-jpa` | 없음 | root 상속 |
+| `elink-online-emsclient` | 없음 | root 상속 |
+| `elink-online-transformer` | 없음 | root 상속 |
+| `elink-online-common` | 없음 | root 상속 |
+| `kjb-errors` | 없음 | root 상속 (기존 `mavenCentral()` 제거) |
+
+---
+
+## 4. 빌드 방법
+
+```bash
+# 캐시 삭제 후 Reposilite에서 새로 받기
+./gradlew build --refresh-dependencies
+
+# 테스트 스킵
+./gradlew build -x test --refresh-dependencies
+```
+
+---
+
+## 참고
+
+- `publishing` 블록(아티팩트 배포)은 각 서브모듈에서 여전히 Nexus URL을 사용 중
+- Reposilite로 배포까지 전환하려면 각 서브모듈의 `nexusUrl` 및 `publishing` 블록 수정 필요
@@ -0,0 +1,26 @@
+# comment start with #
+# level; // 0 : root  ~ n
+# type; // 0: Message, 1: Field, 2:Group 3, Array, 4 : BIZ DATA
+# size // 0 : variable, > 0 fixed
+# fieldType; // 0: ELEMENT, 1: ATTRIBUTE,
+# length;
+# dataType; // 0: String, 1: Number
+#name,level,type,size,fieldType,length,dataType,refPath,refValue,value
+ElinkHeader          ,0,0,1,0, 0,0,,,
+Header               ,1,2,1,1, 0,0,,,
+StndCicsTrncd        ,2,1,1,1,10,0,,,
+StndIntnlStndTelgmLen,2,1,1,1,10,11,,,0
+StndTranBaseYmd      ,2,1,1,1,10,0,,,
+Common               ,1,2,0,0, 0,0,Header.StndCicsTrncd,JI6H,null
+TranInfo             ,2,2,1,0, 0,0,,,
+StndCicsTrncd        ,3,1,1,0, 3,0,,,
+StndTelgmRecvTranCd  ,3,1,1,0,10,0,,,
+StndPrcssRtdTranCd   ,3,1,1,0,10,0,,,
+Array                ,1,3,0,0, 3,0,,,
+Item1                ,2,1,1,0,10,0,,,JI6H
+Group                ,2,3,1,0, 1,0,,,
+gitem1               ,3,1,1,0,10,1,,,726
+gitem2               ,3,1,1,0,10,0,,,20220905
+FArray               ,1,4,0,0,10,0,,,
+bizData              ,1,9,1,0, 0,0,,,
+zzData               ,1,1,1,0, 2,10,,,ZZ
@@ -0,0 +1,41 @@
+#-----------------------------------------------------------------------------
+# comment start with #
+# level; // 0 : root  ~ n
+# type; // 0: Message, 1: Field, 2:Group 3, Grid, 4 : Field Array, 9 : BIZ DATA
+# size // 0 : variable, > 0 fixed
+# fieldType; // 0: ELEMENT, 1: ATTRIBUTE,
+# length;
+# dataType; // 0: String, 1: Number,10: ZZ String, 11: LL Number
+#-----------------------------------------------------------------------------
+# name                  ,level ,type  ,size ,fieldType ,length ,dataType ,,refPath, refValue,value
+#-----------------------------------------------------------------------------
+# name                  ,level ,type  ,size ,fieldType ,length  ,dataType ,refPath, refValue, value
+STD_HNCPHEADER_REQ      ,0     ,0     ,1    ,0         ,0       ,0        ,       ,         ,
+msg_len                 ,1     ,1     ,1    ,0         ,6       ,1        ,       ,         ,199
+global_id               ,1     ,1     ,1    ,0         ,29      ,0        ,       ,         ,GIDNO00000000001111
+service_id              ,1     ,1     ,1    ,0         ,10      ,0        ,       ,         ,ELINKSVC01
+service_cmt             ,1     ,1     ,1    ,0         ,100     ,0        ,       ,         ,ELINK TEST Service
+service_tn              ,1     ,1     ,1    ,0         ,1       ,0        ,       ,         ,0
+Session_id              ,1     ,1     ,1    ,0         ,100     ,0        ,       ,         ,SESSIONID001
+encrypt_yn              ,1     ,1     ,1    ,0         ,2       ,0        ,       ,         ,NO
+http_url                ,1     ,1     ,1    ,0         ,100     ,0        ,       ,         ,
+screen_id               ,1     ,1     ,1    ,0         ,13      ,0        ,       ,         ,SCREEN0000001
+scr_no                  ,1     ,1     ,1    ,0         ,30      ,0        ,       ,         ,000000000100000000020000000003
+scr_dsc                 ,1     ,1     ,1    ,0         ,100     ,0        ,       ,         ,
+usr_id                  ,1     ,1     ,1    ,0         ,10      ,0        ,       ,         ,USER000001
+ip_addr                 ,1     ,1     ,1    ,0         ,47      ,0        ,       ,         ,
+ip_mac                  ,1     ,1     ,1    ,0         ,12      ,0        ,       ,         ,
+com_code                ,1     ,1     ,1    ,0         ,4       ,0        ,       ,         ,EACT
+head_code               ,1     ,1     ,1    ,0         ,7       ,0        ,       ,         ,EACT001
+dept_cd                 ,1     ,1     ,1    ,0         ,7       ,0        ,       ,         ,ELINK01
+conn_tp                 ,1     ,1     ,1    ,0         ,2       ,0        ,       ,         ,CH
+Inter_chn               ,1     ,1     ,1    ,0         ,2       ,0        ,       ,         ,EA
+recv_tm                 ,1     ,1     ,1    ,0         ,17      ,0        ,       ,         ,20220928000000000
+send_tm                 ,1     ,1     ,1    ,0         ,17      ,0        ,       ,         ,
+return_gubun            ,1     ,1     ,1    ,0         ,1       ,0        ,       ,         ,S
+return_value            ,1     ,1     ,1    ,0         ,1       ,0        ,       ,         ,
+msg_id                  ,1     ,1     ,1    ,0         ,7       ,0        ,       ,         ,
+msg_nm                  ,1     ,1     ,1    ,0         ,250     ,0        ,       ,         ,
+filler                  ,1     ,1     ,1    ,0         ,125     ,0        ,       ,         ,
+bizData                 ,1     ,9     ,0    ,0         ,0       ,0        ,       ,         ,
+
@@ -0,0 +1,11 @@
+layout.file.type=CSV
+layout.file.path=./resources/standard-layout-sample.csv
+mapper.class=com.eactive.eai.message.test.TestInterfaceMapper
+mapper.definition=./resources/standard-message-mapping-config.properties
+reader.JSON=com.eactive.eai.message.parser.JsonReader
+reader.JSN=com.eactive.eai.message.parser.JsonReader
+reader.UJN=com.eactive.eai.message.parser.JsonReader
+reader.XML=com.eactive.eai.message.parser.XmlReader
+reader.UXL=com.eactive.eai.message.parser.XmlReader
+reader.ASC=com.eactive.eai.message.parser.FlatReader
+reader.FLAT=com.eactive.eai.message.parser.FlatReader
@@ -0,0 +1,27 @@
+# layout : StandardMessage layout definition
+#layout.file.type=CSV
+layout.file.type=DB
+#layout.file.path=standard-layout-sbi.csv
+#layout.file.path=standard-layout-elk.csv
+#layout.filter.FLAT=com.eactive.eai.custom.message.FlatMessageFilterSBI
+layout.filter.FLAT=com.eactive.eai.message.filter.FlatMessageFilter
+# mapper : StandardMessage's fields getter/setter interface
+#mapper.class=com.eactive.eai.custom.message.InterfaceMapperSBI
+mapper.class=com.eactive.eai.message.service.DefaultInterfaceMapper
+#mapper.definition=standard-message-mapping-config-sbi.properties
+#mapper.definition=standard-message-mapping-config-elk.properties
+mapper.definition=standard-message-mapping-config-elk.properties
+# StandardMessage Coordinator implementation
+#message.coordinator.class=com.eactive.eai.custom.message.StandardMessageCoordinatorSBI
+# RequestProcessor implementation
+#requestProcessor.class=com.eactive.eai.inbound.processor.RequestProcessor
+# reader : parsing input data to StandardMessage
+reader.JSON=com.eactive.eai.message.parser.JsonReader
+reader.JSN=com.eactive.eai.message.parser.JsonReader
+reader.UJN=com.eactive.eai.message.parser.JsonReader
+reader.XML=com.eactive.eai.message.parser.XmlReader
+reader.UXL=com.eactive.eai.message.parser.XmlReader
+reader.ASC=com.eactive.eai.message.parser.FlatReader
+reader.FLAT=com.eactive.eai.message.parser.FlatReader
+encode.flat=euc-kr
+encode.xml=utf-8
@@ -0,0 +1,16 @@
+# layout : StandardMessage layout definition
+layout.file.type=DB
+layout.db.testLayoutName=
+layout.file.path=/development/intellij/elink-4.5/elink-online-multi/resources/standard-layout.csv
+# mapper : StandardMessage's fields getter/setter interface
+mapper.class=com.eactive.eai.message.service.DefaultInterfaceMapper
+mapper.definition=/development/intellij/elink-4.5/elink-online-multi/resources/standard-message-mapping-config-elk.properties
+# reader : parsing input data to StandardMessage
+reader.JSON=com.eactive.eai.message.parser.JsonReader
+reader.JSN=com.eactive.eai.message.parser.JsonReader
+reader.UJN=com.eactive.eai.message.parser.JsonReader
+reader.XML=com.eactive.eai.message.parser.XmlReader
+reader.UXL=com.eactive.eai.message.parser.XmlReader
+reader.ASC=com.eactive.eai.message.parser.FlatReader
+reader.FLAT=com.eactive.eai.message.parser.FlatReader
+
@@ -0,0 +1,26 @@
+REQ_SYS_CODE=commonHeader.firstReqSystemCode
+CHANNEL_TYPE_CD=
+CHANNEL_DETAIL_CD=
+SEND_TIME=
+GUID=commonHeader.globalId
+SYSTEM_TYPE=
+RECV_TIME=
+RETURN_VALUE=
+GUID_ORG=
+GUID_SEQ=commonHeader.traceSeqNo
+SERVICE_ID=commonHeader.serviceCode
+RETURN_SERVICE_ID=
+INTERFACE_ID=commonHeader.serviceCode
+SESSION_ID=
+SEND_RECV_DIVISION=commonHeader.reqResTypeCode
+IN_EX_DIVISION=
+OPERATION_ENV=
+FIRST_REQ_IP=commonHeader.firstReqSystemIp
+RECOVER_YN=
+INST_CODE=
+TIMEOUT=
+ERROR_CODE=commonHeader.msgList[0].resultCode
+ERROR_MSG=commonHeader.msgList[0].resultMsg
+USER_ID=
+RESPONSE_TYPE=
+SYNC_ASYNC_TYPE=
@@ -0,0 +1,29 @@
+REQ_SYS_CODE=systemHeader.DMND_SYS_CD
+CHANNEL_TYPE_CD=stdcommon.chnlTycd
+CHANNEL_DETAIL_CD=stdcommon.chnlDtlsClcd
+SEND_TIME=stdheader.send_tm
+GUID=stdheader.global_id
+SYSTEM_TYPE=stdheader.Inter_chn
+RECV_TIME=stdheader.recv_tm
+RETURN_TYPE=stdheader.return_gubun
+RETURN_VALUE=stdheader.return_value
+GUID_ORG=stdcommon.ortrGuid
+GUID_SEQ=stdheader.global_id
+#SERVICE_ID=stdheader.service_id
+SERVICE_ID=service_id
+RETURN_SERVICE_ID=stdcommon.procsRsltRcmsSrvcId
+INTERFACE_ID=stdheader.service_id
+SESSION_ID=stdheader.Session_id
+#SEND_RECV_DIVISION=stdheader.return_gubun
+SEND_RECV_DIVISION=service_tn
+IN_EX_DIVISION=stdcommon.hmabDvcd
+OPERATION_ENV=stdcommon.sysOprtEnvDvcd
+FIRST_REQ_IP=stdheader.ip_addr
+RECOVER_YN=stdcommon.ortrRestrYn
+INST_CODE=stdheader.com_code
+TIMEOUT=stdheader.gnrzTmotTktm
+ERROR_CODE=stdheader.msg_id
+ERROR_MSG=stdheader.msg_nm
+USER_ID=stdheader.usr_id
+RESPONSE_TYPE=stdcommon.procsRsltDvcd
+SYNC_ASYNC_TYPE=stdcommon.txSynzDvcd
@@ -0,0 +1,27 @@
+REQ_SYS_CODE=Inter_chn
+CHANNEL_TYPE_CD=
+CHANNEL_DETAIL_CD=conn_tp
+SEND_TIME=send_tm
+GUID=global_id
+SYSTEM_TYPE=service_tn
+RECV_TIME=recv_tm
+RETURN_TYPE=return_gubun
+RETURN_VALUE=return_value
+GUID_ORG=stdcommon.ortrGuid
+GUID_SEQ=stdheader.global_id
+SERVICE_ID=service_id
+RETURN_SERVICE_ID=stdcommon.procsRsltRcmsSrvcId
+INTERFACE_ID=stdheader.service_id
+SESSION_ID=Session_id
+SEND_RECV_DIVISION=service_tn
+IN_EX_DIVISION=stdcommon.hmabDvcd
+OPERATION_ENV=stdcommon.sysOprtEnvDvcd
+FIRST_REQ_IP=ip_addr
+RECOVER_YN=stdcommon.ortrRestrYn
+INST_CODE=stdheader.com_code
+TIMEOUT=stdheader.gnrzTmotTktm
+ERROR_CODE=msg_id
+ERROR_MSG=msg_nm
+USER_ID=usr_id
+RESPONSE_TYPE=stdcommon.procsRsltDvcd
+SYNC_ASYNC_TYPE=stdcommon.txSynzDvcd
@@ -0,0 +1,26 @@
+REQ_SYS_CODE=Inter_chn
+CHANNEL_TYPE_CD=
+CHANNEL_DETAIL_CD=conn_tp
+SEND_TIME=send_tm
+GUID=global_id
+SYSTEM_TYPE=service_tn
+RECV_TIME=recv_tm
+RETURN_VALUE=return_value
+GUID_ORG=stdcommon.ortrGuid
+GUID_SEQ=stdheader.global_id
+SERVICE_ID=service_id
+RETURN_SERVICE_ID=stdcommon.procsRsltRcmsSrvcId
+INTERFACE_ID=stdheader.service_id
+SESSION_ID=Session_id
+SEND_RECV_DIVISION=service_tn
+IN_EX_DIVISION=return_gubun
+OPERATION_ENV=stdcommon.sysOprtEnvDvcd
+FIRST_REQ_IP=ip_addr
+RECOVER_YN=stdcommon.ortrRestrYn
+INST_CODE=stdheader.com_code
+TIMEOUT=stdheader.gnrzTmotTktm
+ERROR_CODE=msg_id
+ERROR_MSG=msg_nm
+USER_ID=usr_id
+RESPONSE_TYPE=stdcommon.procsRsltDvcd
+SYNC_ASYNC_TYPE=stdcommon.txSynzDvcd
@@ -0,0 +1,380 @@
+package com.eactive.eai.adapter.controller;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+// jwhong
+import org.json.simple.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.util.AntPathMatcher;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.eactive.eai.adapter.AdapterGroupVO;
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.AdapterPropManager;
+import com.eactive.eai.adapter.AdapterVO;
+import com.eactive.eai.adapter.Keys;
+import com.eactive.eai.adapter.http.HttpStatusException;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterManager;
+import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterUri;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilterFactoryKjb;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.adapter.service.ApiAdapterService;
+import com.eactive.eai.common.TransactionContextKeys;
+import com.eactive.eai.common.exception.ExceptionUtil;
+import com.eactive.eai.common.server.EAIServerManager;
+import com.eactive.eai.common.stdmessage.STDMessageManager;
+import com.eactive.eai.common.stdmessage.STDMsgInfoAddOnVO;
+import com.eactive.eai.common.util.DatetimeUtil;
+import com.eactive.eai.common.util.InboundErrorLogger;
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.common.util.MessageUtil;
+import com.eactive.eai.common.util.UUIDGenerator;
+import com.eactive.eai.inbound.action.ActionException;
+import com.eactive.eai.inbound.action.ActionFactory;
+import com.eactive.eai.inbound.action.RequestAction;
+import com.eactive.eai.inbound.error.InboundErrorInfoVO;
+
+@RestController
+public class ApiAdapterController implements HttpAdapterServiceKey {
+	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+
+	@Autowired
+	ApiAdapterService service;
+
+	/**
+	 * KJBANK 요구사항으로 /mapi/oauth2/token 과 같은 형태로 토큰 발급거래를 수행해야해서 예외처리함
+	 * 
+	 * @See com.eactive.eai.authserver.config.AuthorizationServerConfig.configure(AuthorizationServerEndpointsConfigurer
+	 *      endpoints)
+	 */
+	@RequestMapping(value = { "/api/*", "/mapi/*", "/api/*/{path:^(?!.*oauth).*$}/**",
+			"/mapi/{path:^(?!.*oauth2).*$}/**" })
+//    @RequestMapping(value = {"/api/**"})
+	public ResponseEntity<String> callApi(HttpServletRequest servletRequest, HttpServletResponse servletResponse)
+			throws Exception {
+		// /ONLWeb/api/v1/public/getUserInfo.svc
+		String apiUri = servletRequest.getRequestURI();
+		// /api/v1/public/getUserInfo.svc
+		apiUri = StringUtils.removeStart(apiUri, servletRequest.getContextPath());
+		apiUri = StringUtils.removeEnd(apiUri, "/");
+
+		HttpDynamicInAdapterUri adptUri = findAdptUri(apiUri, HttpDynamicInAdapterManager.getInstance(), "");
+		
+		if (logger.isDebug()) {
+			logger.debug("ApiAdapterController] service request uri : " + servletRequest.getRequestURI());
+		}
+
+		if (adptUri == null) {
+			logError(servletRequest);
+			String errorMsg = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_SERVICE_NOT_FOUND,
+					"can not find Adapter Uri");
+			return ResponseEntity.status(HttpStatus.NOT_FOUND).contentType(MediaType.APPLICATION_JSON).body(errorMsg);
+		}
+
+		// Received time , jwhong
+		long receivedTimeMillis = System.currentTimeMillis(); // 밀리세컨 단위로 보내야함
+		String receivedTimeStr = String.valueOf(receivedTimeMillis);
+
+		String adapterGroupName = adptUri.getAdptGrpName();
+		String adapterName = adptUri.getAdptName();
+		AdapterGroupVO adapterGroupVO = AdapterManager.getInstance().getAdapterGroupVO(adapterGroupName);
+		AdapterVO adapterVO = AdapterManager.getInstance().getAdapterVO(adapterGroupName, adapterName);
+		if (adapterVO == null) {
+			String errorMsg = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_AP_ERROR,
+					"Adapter not found error");
+			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).contentType(MediaType.APPLICATION_JSON)
+					.body(errorMsg);
+		}
+
+		Properties httpProp = AdapterPropManager.getInstance().getProperties(adapterVO.getPropGroupName());
+
+		String adptMsgType = adapterVO.getAdapterGroupVO().getMessageType();
+		String encode = StringUtils.defaultIfBlank(adapterGroupVO.getMessageEncode(), "UTF-8");
+		MediaType mediaType = MediaType.valueOf("application/json;charset=" + encode);
+		String errorResponseFormat = httpProp.getProperty(ERROR_RESPONSE_FORMAT);
+
+		String responseType = httpProp.getProperty(RESPONSE_TYPE, "SYNC");
+		ResponseEntity responseEntity = null;
+		Properties transactionProp = new Properties();
+		// jwhong, put api received time, eaiSvcCode
+		transactionProp.put(INBOUND_REQUESTED_TIME, receivedTimeStr);
+		
+		// ** jwhong TSEAIHS04의 api full path와 비교하여 adapter를 가져온다
+//		String bzwkSvcKeyName = ""; // Adapter Group별 Action Class에 따라 구성이 달라짐. 예)
+//									// _AGW_IN_RST_SyS:POST/account/{acc_no}
+//		String adapterGrpName = ""; // Adapter Group명 예) _AGW_IN_RST_SyS : API_PATH(/api/test)
+		String apiSvcCode = ""; // eaiSvcCd 예) LONNCHCON00005S2
+		String apiFullPathKey = ""; // 예) POST|/api/test/account/list, POST|/api/test/account/{acc_no}
+		Map<String, String> pathVariables = null;
+		try {
+			// PathVariable(ex:/api/test/account/{acc_no}) 대응 및 DAO조회 제거.
+			// /api/test/account/1234567 호출시 /api/test/account/{acc_no} API 로 식별.
+			
+//			String methodAndUri = getRequestRuledPath(servletRequest, apiUri, adapterVO, transactionProp);
+			String methodAndUri = servletRequest.getMethod() + "|" + apiUri;
+			STDMessageManager manager = STDMessageManager.getInstance();
+			STDMsgInfoAddOnVO stdMsgInfo = manager.getStdMsgInfoAddOn(methodAndUri);
+//			bzwkSvcKeyName = stdMsgInfo.getBzwksvckeyname();
+			apiSvcCode = stdMsgInfo.getEaiSvcCd();
+			transactionProp.put(API_SERVICE_CODE, apiSvcCode);
+			
+//			adapterGrpName = stdMsgInfo.gAdapterGroupName();
+			apiFullPathKey = stdMsgInfo.getApiFullPath();
+			if (STDMessageManager.isPathVariable(apiFullPathKey)) {
+				pathVariables = new AntPathMatcher().extractUriTemplateVariables(apiFullPathKey, methodAndUri);
+			}
+
+//			adptUri = findAdptUri(apiUri, HttpDynamicInAdapterManager.getInstance(), adapterGrpName);
+		} catch (Exception e) {
+//			adptUri = null;
+		}
+		// ***
+		if (pathVariables != null) {
+			transactionProp.put(INBOUND_PATH_VARIABLES, pathVariables);
+		}
+
+		try {
+			String responseData = service.callApi(servletRequest, servletResponse, httpProp, adapterGroupVO, adapterVO,
+					transactionProp);
+			// if (RESPONSE_TYPE_ASYNC.equals(responseType)) { // table의 값이 ASYNC 로 들어가 있는데
+			// response_type_async는 ASYN 로 되어 있어 아래처럼 비교함 jwhong 2025
+			if ("ASYNC".equals(responseType)) {
+				// responseEntity = ResponseEntity.ok("dummy"); // comment by jwhong
+				// servletResponse.addHeader("traceId", responseData); // uuid를 response header에
+				servletResponse.addHeader("traceId",
+						transactionProp.getProperty(TransactionContextKeys.TRANSACTION_UUID)); // uuid를 response header에
+				int httpStatus = servletResponse.getStatus();
+				if (httpStatus == 200) {
+					// 업체별 aync response message 가 다르다.
+					String asyncMsgStyle = httpProp.getProperty("ASYNC_RTNMSG_TYPE", "");
+					String responseBody = "";
+					boolean encryptAsyncAckApply = StringUtils
+							.equalsIgnoreCase(httpProp.getProperty("ASYNC_ENCRYPT_ACK", "N"), "Y");
+
+					if (asyncMsgStyle == null || asyncMsgStyle.trim().isEmpty()) {
+						responseBody = makeResponseBodyMsg();
+					} else {
+						responseBody = asyncMsgStyle;
+					}
+					if (encryptAsyncAckApply) {
+						responseBody = service.doPostEncryption(responseBody, transactionProp, servletRequest);
+					}
+ 
+					responseEntity = ResponseEntity.status(httpStatus).contentType(mediaType).body(responseBody);
+					// jwhong
+				} else {
+					responseEntity = ResponseEntity.status(httpStatus).contentType(mediaType).body(responseData);
+				}
+			} else {
+//                responseEntity = ResponseEntity.ok().contentType(mediaType).body(responseData);
+//                버즈빌 포인트 적립 처리하기 위하여 정상응답이더라도 응답코드(apiRsltCd) 값이 200이 아닌 경우 처리를 위하여 수정
+//                Filter에서 설정한 response status값을 responseEntity 생성시 적용 modify by lwk 2025.03.24
+
+				servletResponse.addHeader("traceId",
+						transactionProp.getProperty(TransactionContextKeys.TRANSACTION_UUID)); // uuid를 response header에
+				int httpStatus = servletResponse.getStatus();
+				if (httpStatus != 200) {
+					responseEntity = ResponseEntity.status(httpStatus).contentType(mediaType).body(responseData);
+				} else {
+					responseEntity = ResponseEntity.ok().contentType(mediaType).body(responseData);
+				}
+			}
+
+		} catch (Exception e) {
+			
+		
+			logger.error(adapterGroupName + "-" + adapterName + ">>" + e.getMessage(), e);
+			
+			String errorMsg = null;
+			
+			if( e instanceof HttpStatusException ) {
+				logger.warn("ApiAdapterController] " + adapterGroupName + "-" + adapterName + ">>" + e.getMessage());
+				HttpStatusException e1 = (HttpStatusException) e;
+				errorMsg = MessageUtil.makeErrorMessageByMessageType(adptMsgType, encode,
+						MessageUtil.ERROR_CODE_AP_ERROR, e1.getMessage(), errorResponseFormat);
+				responseEntity = ResponseEntity.status(e1.getStatus()).contentType(mediaType).body(errorMsg);
+			}
+			else if( e instanceof JwtAuthException )
+			{
+				logger.error(adapterGroupName + "-" + adapterName + ">>" + e.getMessage(), e);
+				errorMsg = MessageUtil.makeErrorMessageByMessageType(adptMsgType, encode,
+						MessageUtil.ERROR_CODE_AUTH_FAIL, e.getMessage(), errorResponseFormat);
+				responseEntity = ResponseEntity.status(HttpStatus.UNAUTHORIZED).contentType(mediaType).body(errorMsg);
+			}
+			else 
+			{
+				logger.error(adapterGroupName + "-" + adapterName + ">>" + e.getMessage(), e);
+				errorMsg = MessageUtil.makeErrorMessageByMessageType(adptMsgType, encode,
+						MessageUtil.ERROR_CODE_AP_ERROR, e.getMessage(), errorResponseFormat);
+				responseEntity = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).contentType(mediaType)
+						.body(errorMsg);
+			}
+			String postFilterNames = httpProp.getProperty("POST_FILTERS","");
+			
+			if( postFilterNames.contains("HMAC_SHA256") ) {
+				HttpAdapterFilter filter = HttpAdapterFilterFactoryKjb.createFilter("HMAC_SHA256");
+				filter.doPostFilter(adapterGroupName, postFilterNames, errorMsg, transactionProp, servletRequest, servletResponse);
+			}
+			
+			
+		} finally {
+			/**
+			 * 로깅 인터셉터에 데이터를 전달하기 위한 처리 이미 거래처리가 끝나서 영향도가 없을만한 servletRequest에 Attribute로 전달
+			 * 추후 더 좋은방법이 생길경우 개선 요망
+			 */
+			try {
+
+			    servletRequest.setAttribute(TransactionContextKeys.TRANSACTION_PROP, transactionProp);
+
+			    if (!"ASYNC".equals(responseType)) {
+				String uuid = transactionProp.getProperty(TransactionContextKeys.TRANSACTION_UUID);
+				String url = transactionProp.getProperty(HttpClientAdapterServiceKey.INBOUND_EXTURI);
+				String method = transactionProp.getProperty(HttpClientAdapterServiceKey.INBOUND_METHOD);
+				int httpStatusCode = servletResponse.getStatus();
+
+				Map<Object, Object> headerMap = new HashMap<>();
+				// 응답 헤더 로깅
+				for (String headerName : servletResponse.getHeaderNames()) {
+				    String headerValue = servletResponse.getHeader(headerName);
+				    logger.debug(String.format("httpHeader logging headerKey=%s, headerValue=%s",
+					    headerName, headerValue));
+				    headerMap.put(headerName, headerValue);
+				}
+				//HttpAdapterExtraLogUtil.insertHttpAdapterExtraLog(uuid, 400, adapterGroupName,adapterName, headerMap, url, method, httpStatusCode);
+			    }
+			} catch (Exception e) {
+			    logger.warn("http header db logging fail.", e);
+			}
+		}
+		return responseEntity;
+	}
+
+	/**
+	 * url에서 뒤쪽 /이후를 제거하면서 찾는다.<br>
+	 * /api/v1/public/getUserInfo.svc
+	 *
+	 * @param apiUri
+	 * @return
+	 */
+	private HttpDynamicInAdapterUri findAdptUri(String apiUri, HttpDynamicInAdapterManager manager,
+			String adapterGrpName) throws Exception {
+		if (StringUtils.isBlank(apiUri)) {
+			return null;
+		}
+
+		// * manager 출력
+		logger.warn("===== adptUriMap 상세 내용 =====");
+		for (Map.Entry<String, HttpDynamicInAdapterUri> entry : manager.adptUriMap.entrySet()) {
+			HttpDynamicInAdapterUri uriObj = entry.getValue();
+			logger.warn("GroupName=" + uriObj.getAdptGrpName() + ", AdapterName=" + uriObj.getAdptName() + ", URI="
+					+ uriObj.getUri());
+		}
+		logger.warn("================================");
+
+		//
+		for (int i = 0; i < 10; i++) {
+			HttpDynamicInAdapterUri adptUri = manager.getAdptUri(apiUri);
+			if (adptUri != null) {
+				if (StringUtils.isNotEmpty(adapterGrpName)) {
+					if(adptUri.getAdptGrpName().equals(adapterGrpName)) {
+						return adptUri;
+					}
+				} else {
+					return adptUri;
+				}
+			}
+
+			// /api/v1/public
+			apiUri = StringUtils.substringBeforeLast(apiUri, "/");
+			if (apiUri.length() < 4) { // /api
+				return null;
+			}
+		}
+
+		return null;
+	}
+
+	private void logError(HttpServletRequest request) {
+		InboundErrorInfoVO errorInfoVO = new InboundErrorInfoVO();
+
+		EAIServerManager eaiServerManager = EAIServerManager.getInstance();
+		String serverName = eaiServerManager.getLocalServerName();
+		String uuid = null;
+		StringBuffer sb = new StringBuffer();
+
+		String instanceid1 = serverName.substring(0, 2);
+		String instanceid2 = serverName.substring(serverName.length() - 2, serverName.length());
+		String instid = instanceid1 + instanceid2;
+		uuid = instid + UUIDGenerator.getUUID();
+
+		String[] msgArgs = new String[1];
+		msgArgs[0] = request.getRequestURI();
+
+		String errorCode = "RECEAIIRP010";
+		String errorMsg = ExceptionUtil.make(new Exception("cat not find uri"), errorCode, msgArgs);
+
+		errorInfoVO.setEaiSvcSno(uuid); // EAI서비스일련번호
+		errorInfoVO.setAdptBwkGrpNm("HTTP_IN_NO_URI"); // 어댑터업무그룹명
+		errorInfoVO.setErrCd(errorCode); // 에러코드
+		errorInfoVO.setErrTxt(errorMsg); // 에러내용
+		errorInfoVO.setErrTm(DatetimeUtil.getCurrentTime(new Date().getTime())); // 에러발생시각
+		errorInfoVO.setErrDstcd(" ");
+		sb.append("Remote Addr : ").append(request.getRemoteAddr()).append("\n").append("Request URI : ")
+				.append(request.getRequestURI());
+		errorInfoVO.setBwkDataTxt(sb.toString()); // 업무데이터내용
+		errorInfoVO.setEaiSvrInstNm(serverName); // EAI서버인스턴스명
+
+		InboundErrorLogger.error(errorInfoVO);
+	}
+
+	private String makeResponseBodyMsg() {
+
+		Map<String, Object> dataMap = new HashMap<>();
+		dataMap.put("result", 1);
+		Map<String, Object> map = new HashMap<>();
+
+		map.put("code", "200");
+		map.put("data", dataMap);
+		map.put("message", "정상 처리 되었습니다.");
+
+		JSONObject json = new JSONObject();
+		json.putAll(map);
+
+		return json.toJSONString();
+	}
+
+	/*
+	 * private String makeResponseBodyMsg(String asyncMsgStyle) {
+	 * 
+	 * Map<String, Object> dataMap = new HashMap<>(); dataMap.put("result", 1);
+	 * Map<String, Object> map = new HashMap<>();
+	 * 
+	 * switch (asyncMsgStyle) { case "TB_SUC": map.put("rspCode", "TB_SUC_000");
+	 * map.put("rspMsg", "정상"); map.put("data", dataMap); break; case "ONLYDATA":
+	 * map.put("data", dataMap); map.put("success", "true"); break; default:
+	 * map.put("code", "200"); map.put("data", dataMap); map.put("message",
+	 * "정상 처리 되었습니다."); break; }
+	 * 
+	 * JSONObject json = new JSONObject(); json.putAll(map);
+	 * 
+	 * return json.toJSONString(); }
+	 */
+}
@@ -21,9 +21,6 @@ import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterManager;
 import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterUri;
 import com.eactive.eai.common.stdmessage.STDMessageManager;
 import com.eactive.eai.common.stdmessage.STDMsgInfoAddOnVO;
-import com.fasterxml.jackson.core.JsonFactory;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.core.JsonToken;


 public class ApiRequestBodyFilter extends OncePerRequestFilter {
@@ -35,11 +32,17 @@ public class ApiRequestBodyFilter extends OncePerRequestFilter {
                                    HttpServletResponse response,
                                    FilterChain filterChain)
            throws ServletException, IOException {
-    	if (!isTarget(request)) {
+    	
+        if (!isTarget(request)) {
            filterChain.doFilter(request, response);
            return;
        }

+
+    	String encoding = getInboundGroupAdapterEncoding(request);
+    	
+
+
        //원본 바디를 byte[]로 읽기 (개행 포함 그대로) 왜? 뒤에 필터에서 HMAC값 계산할수도 있어서 변조되면 안됨. 개행문자도 그대로 가야함.
        byte[] rawBody = readBodyAsBytes(request);

@@ -51,16 +54,14 @@ public class ApiRequestBodyFilter extends OncePerRequestFilter {
        byte[] finalBody = rawBody;

        try {
-        	if(isJsonArray(rawBody)) {
-        		String encoding = getInboundGroupAdapterEncoding(request);
-            	String bodyStr = new String(rawBody, encoding);
-            	Object json = JSONValue.parse(bodyStr);

-	            if (json instanceof JSONArray) {
-	            	bodyStr = DJB_ROOTLESS_ARRAY + bodyStr + "}";
-	            	finalBody = bodyStr.getBytes(encoding);
-	            }
-        	}
+            String bodyStr = new String(rawBody, encoding);
+            Object json = JSONValue.parse(bodyStr);
+
+            if (json instanceof JSONArray) {
+            	bodyStr = DJB_ROOTLESS_ARRAY + bodyStr + "}";
+            	finalBody = bodyStr.getBytes(encoding);
+            }

        } catch (Exception e) {
            // JSON 파싱 실패 시 원본 유지
@@ -73,14 +74,6 @@ public class ApiRequestBodyFilter extends OncePerRequestFilter {

        filterChain.doFilter(wrapped, response);
    }
-    
-    public static boolean isJsonArray(byte[] json) {
-        try (JsonParser parser = new JsonFactory().createParser(json)) {
-            return parser.nextToken() == JsonToken.START_ARRAY;
-        } catch (Exception e) {
-            return false;
-        }
-    }

 	private boolean isTarget(HttpServletRequest request) {
 		String uri = request.getRequestURI();
@@ -1,364 +0,0 @@
-package com.eactive.eai.adapter.controller;
-
-import java.util.Date;
-import java.util.Map;
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import com.eactive.eai.adapter.AdapterGroupVO;
-import com.eactive.eai.adapter.AdapterManager;
-import com.eactive.eai.adapter.AdapterPropManager;
-import com.eactive.eai.adapter.AdapterVO;
-import com.eactive.eai.adapter.handler.AdapterErrorMessageHandler;
-import com.eactive.eai.adapter.handler.AdapterErrorMessageHandlerFactory;
-import com.eactive.eai.adapter.http.HttpStatusException;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
-import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterManager;
-import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterUri;
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
-import com.eactive.eai.adapter.service.DJBApiAdapterService;
-import com.eactive.eai.common.TransactionContextKeys;
-import com.eactive.eai.common.exception.ExceptionUtil;
-import com.eactive.eai.common.server.EAIServerManager;
-import com.eactive.eai.common.util.DatetimeUtil;
-import com.eactive.eai.common.util.HttpAdapterExtraLogUtil;
-import com.eactive.eai.common.util.InboundErrorLogger;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.common.util.MessageUtil;
-import com.eactive.eai.common.util.RestSendBodyLogUtils;
-import com.eactive.eai.common.util.TxFileLogger;
-import com.eactive.eai.common.util.TxSiftContext;
-import com.eactive.eai.common.util.UUIDGenerator;
-import com.eactive.eai.inbound.error.InboundErrorInfoVO;
-import com.eactive.eai.util.HexaConverter;
-
-@RestController
-public class DJBApiAdapterController implements HttpAdapterServiceKey {
-	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	@Autowired
-	DJBApiAdapterService service;
-	
-	EAIServerManager eaiServerManager;
-	/**
-	 * DJErp OAuth 조기 적용을 위한 Controller
-	 * 
-	 * @See com.eactive.eai.authserver.config.AuthorizationServerConfig.configure(AuthorizationServerEndpointsConfigurer
-	 *      endpoints)
-	 */
-	@RequestMapping(value = { 
-			"/dj/{path:^(?!oauth).*$}",  "/dj/{path:^(?!oauth).*$}/**",
-			"/kp/{path:^(?!oauth).*$}",  "/kp/{path:^(?!oauth).*$}/**",
-			"/kkb/{path:^(?!oauth).*$}", "/kkb/{path:^(?!oauth).*$}/**",
-			"/nf/{path:^(?!oauth).*$}",  "/nf/{path:^(?!oauth).*$}/**",
-			"/bsd/{path:^(?!oauth).*$}", "/bsd/{path:^(?!oauth).*$}/**",
-			"/tss/{path:^(?!oauth).*$}", "/tss/{path:^(?!oauth).*$}/**",
-			"/tsb/{path:^(?!oauth).*$}", "/tsb/{path:^(?!oauth).*$}/**",
-			"/shb/{path:^(?!oauth).*$}", "/shb/{path:^(?!oauth).*$}/**",
-			"/tst/{path:^(?!oauth).*$}", "/tst/{path:^(?!oauth).*$}/**",
-			"/**/{path:^(?!oauth)(?!favicon\\.ico$).*$}", "/**/{path:^(?!oauth)(?!favicon\\.ico$).*$}/**",
-			})
-	public ResponseEntity<String> callApi(HttpServletRequest servletRequest, HttpServletResponse servletResponse)
-			throws Exception {
-		// /ONLWeb/api/v1/public/getUserInfo.svc
-		String apiUri = servletRequest.getRequestURI();
-		// /api/v1/public/getUserInfo.svc
-		apiUri = StringUtils.removeStart(apiUri, servletRequest.getContextPath());
-		apiUri = StringUtils.removeEnd(apiUri, "/");
-
-		HttpDynamicInAdapterUri adptUri = findAdptUri(apiUri, HttpDynamicInAdapterManager.getInstance(), "");
-		
-		if (logger.isDebug()) {
-			logger.debug("ApiAdapterController] service request uri : " + servletRequest.getRequestURI());
-		}
-
-		// Received time , jwhong
-		long receivedTimeMillis = System.currentTimeMillis(); // 밀리세컨 단위로 보내야함
-		String receivedTimeStr = String.valueOf(receivedTimeMillis);
-
-		ResponseEntity<String> responseEntity = null;
-		Properties transactionProp = new Properties();
-		
-		if(eaiServerManager == null)
-			eaiServerManager = EAIServerManager.getInstance();
-		
-		String instid = eaiServerManager.getGroupInstId();
-		String uuid = instid+UUIDGenerator.getUUID().toString().replaceAll("-", "");
-		
-		transactionProp.setProperty(TransactionContextKeys.TRANSACTION_UUID, uuid);
-		transactionProp.put(INBOUND_REQUESTED_TIME, receivedTimeStr);
-
-		if (adptUri == null) {
-			//logError(servletRequest);
-			String errorMsg = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_SERVICE_NOT_FOUND,
-					"can not find Adapter Uri");
-			logError(servletRequest, "HTTP_IN_NO_URI", MessageUtil.ERROR_CODE_SERVICE_NOT_FOUND,
-					errorMsg, transactionProp, null);
-			return ResponseEntity.status(HttpStatus.NOT_FOUND).contentType(MediaType.APPLICATION_JSON).body(errorMsg);
-		}
-		
-		String adapterGroupName = adptUri.getAdptGrpName();
-		String adapterName = adptUri.getAdptName();
-		AdapterGroupVO adapterGroupVO = AdapterManager.getInstance().getAdapterGroupVO(adapterGroupName);
-		AdapterVO adapterVO = AdapterManager.getInstance().getAdapterVO(adapterGroupName, adapterName);
-		if (adapterVO == null) {
-			String errorMsg = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_AP_ERROR,
-					"Adapter not found error");
-			logError(servletRequest, adapterGroupName, MessageUtil.ERROR_CODE_AP_ERROR,
-					errorMsg, transactionProp, null);
-			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).contentType(MediaType.APPLICATION_JSON)
-					.body(errorMsg);
-		}
-
-		Properties httpProp = AdapterPropManager.getInstance().getProperties(adapterVO.getPropGroupName());
-
-		String adptMsgType = adapterVO.getAdapterGroupVO().getMessageType();
-		String encode = StringUtils.defaultIfBlank(adapterGroupVO.getMessageEncode(), "UTF-8");
-		MediaType mediaType = MediaType.valueOf("application/json;charset=" + encode);
-		String errorResponseFormat = httpProp.getProperty(ERROR_RESPONSE_FORMAT);
-
-		
-		TxSiftContext.begin(uuid);
-		
-		// jwhong, put api received time, eaiSvcCode
-		String responseData = "";
-		try {
-			responseData = service.callApi(servletRequest, servletResponse, httpProp, adapterGroupVO, adapterVO,
-					transactionProp);
-
-			servletResponse.addHeader("traceId",
-					transactionProp.getProperty(TransactionContextKeys.TRANSACTION_UUID)); // uuid를 response header에
-			int httpStatus = servletResponse.getStatus();
-			if (httpStatus != 200) {
-				responseEntity = ResponseEntity.status(httpStatus).contentType(mediaType).body(responseData);
-			} else {
-				responseEntity = ResponseEntity.ok().contentType(mediaType).body(responseData);
-			}
-
-		} catch (Exception e) {
-			logger.error(adapterGroupName + "-" + adapterName + ">>" + e.getMessage(), e);
-			
-			String responseErrorMsg = null;
-			
-			if (e instanceof FilterException) {
-				responseErrorMsg = genErrorResponseMessage(adapterGroupName, adapterName,
-						transactionProp, MessageUtil.ERROR_CODE_AP_ERROR, e, adptMsgType, encode, errorResponseFormat);
-				FilterException e1 = (FilterException) e;
-				this.logError(servletRequest, adapterGroupName, e1.getCode(), responseErrorMsg, transactionProp, e);
-				logger.error("ApiAdapterController] " + adapterGroupName + "-" + adapterName + ">>" + e.getMessage());
-				responseEntity = ResponseEntity.status(e1.getStatus()).contentType(mediaType).body(responseErrorMsg);
-			} else if (e instanceof JwtAuthException) {
-				responseErrorMsg = genErrorResponseMessage(adapterGroupName, adapterName,
-						transactionProp, MessageUtil.ERROR_CODE_AUTH_FAIL, e, adptMsgType, encode, errorResponseFormat);
-				JwtAuthException e1 = (JwtAuthException) e;
-				this.logError(servletRequest, adapterGroupName, e1.getCode(), responseErrorMsg, transactionProp, e);
-				logger.error("ApiAdapterController] " + adapterGroupName + "-" + adapterName + ">>" + e.getMessage(), e);
-				responseEntity = ResponseEntity.status(HttpStatus.UNAUTHORIZED).contentType(mediaType).body(responseErrorMsg);
-			} else if (e instanceof HttpStatusException) {
-				responseErrorMsg = genErrorResponseMessage(adapterGroupName, adapterName,
-						transactionProp, MessageUtil.ERROR_CODE_AP_ERROR, e, adptMsgType, encode, errorResponseFormat);
-				logger.error("ApiAdapterController] " + adapterGroupName + "-" + adapterName + ">>" + e.getMessage());
-				HttpStatusException e1 = (HttpStatusException) e;
-				responseEntity = ResponseEntity.status(e1.getStatus()).contentType(mediaType).body(responseErrorMsg);
-			} else {
-				responseErrorMsg = genErrorResponseMessage(adapterGroupName, adapterName,
-						transactionProp, MessageUtil.ERROR_CODE_AP_ERROR, e, adptMsgType, encode, errorResponseFormat);
-				this.logError(servletRequest, adapterGroupName, MessageUtil.ERROR_CODE_AP_ERROR, responseErrorMsg, transactionProp, e);
-				logger.error(adapterGroupName + "-" + adapterName + ">>" + e.getMessage(), e);
-				responseEntity = ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).contentType(mediaType).body(responseErrorMsg);
-			}
-			responseData = responseErrorMsg;
-			
-		} finally {
-			
-			// 어댑터 HTTP 로그에 응답 body 출력
-			if (RestSendBodyLogUtils.isBodyLoggingApi(transactionProp.getProperty("API_SERVICE_CODE"))) {
-				String trimmedBody = RestSendBodyLogUtils.getBodyByMaxSize(responseData);
-				transactionProp.setProperty(HttpAdapterExtraLogUtil.BODY_FIELD_NAME, trimmedBody);
-			}
-			servletRequest.setAttribute(TransactionContextKeys.TRANSACTION_PROP, transactionProp);
-			
-			/**
-			 * 로깅 인터셉터에 데이터를 전달하기 위한 처리 이미 거래처리가 끝나서 영향도가 없을만한 servletRequest에 Attribute로 전달
-			 * 추후 더 좋은방법이 생길경우 개선 요망
-			 */
-			try {
-				TxFileLogger.logTxFile(transactionProp, responseData, "[IN_SEND]");
-				servletRequest.setAttribute(TransactionContextKeys.TRANSACTION_PROP, transactionProp);
-			} catch (Exception e) {
-			    logger.warn("http header db logging fail.", e);
-			} finally {
-				TxSiftContext.end();
-			}
-		}
-		return responseEntity;
-	}
-	
-	private String genErrorResponseMessage(String adapterGroupName, String adapterName,
-			Properties callProp, String code, Throwable e, String adptMsgType, String encode, String errorResponseFormat) {
-		String errorHandlerClass = AdapterPropManager.getInstance().getProperty(adapterName, "ERR_MSG_HANDLER");
-		if (StringUtils.isNotBlank(errorHandlerClass)) {
-			if (logger.isInfo())
-				logger.info("ExceptionHandler] errorSyncSend ERR_MSG_HANDLER=" + errorHandlerClass);
-			AdapterErrorMessageHandler handler = AdapterErrorMessageHandlerFactory.createHandler(errorHandlerClass);
-			if (handler != null) {
-				Object resposne;
-				try {
-					callProp.put("INBOUND_RESULT_CODE", code);
-					resposne = handler.generateNonStandardInboundErrorResponseMessage(adapterGroupName, adapterName,
-							callProp, null, null, e);
-					return (String)resposne;
-				} catch (Exception e1) {
-					logger.warn("AdapterErrorMessageHandler error.", e);
-					// handler 실패시 아래에서 처리한
-				}
-			}
-		}
-		return MessageUtil.makeErrorMessageByMessageType(adptMsgType, encode,
-				code, e.getMessage(), errorResponseFormat);
-	}
-
-	/**
-	 * url에서 뒤쪽 /이후를 제거하면서 찾는다.<br>
-	 * /api/v1/public/getUserInfo.svc
-	 *
-	 * @param apiUri
-	 * @return
-	 */
-	private HttpDynamicInAdapterUri findAdptUri(String apiUri, HttpDynamicInAdapterManager manager,
-			String adapterGrpName) throws Exception {
-		if (StringUtils.isBlank(apiUri)) {
-			return null;
-		}
-
-		if(logger.isDebug()) {
-			logger.debug("===== adptUriMap 상세 내용 =====");
-			for (Map.Entry<String, HttpDynamicInAdapterUri> entry : manager.adptUriMap.entrySet()) {
-				HttpDynamicInAdapterUri uriObj = entry.getValue();
-				logger.debug("GroupName=" + uriObj.getAdptGrpName() + ", AdapterName=" + uriObj.getAdptName() + ", URI="
-						+ uriObj.getUri());
-			}
-			logger.debug("================================");
-		}
-
-		//
-		for (int i = 0; i < 10; i++) {
-			HttpDynamicInAdapterUri adptUri = manager.getAdptUri(apiUri);
-			if (adptUri != null) {
-				if (StringUtils.isNotEmpty(adapterGrpName)) {
-					if(adptUri.getAdptGrpName().equals(adapterGrpName)) {
-						return adptUri;
-					}
-				} else {
-					return adptUri;
-				}
-			}
-
-			// /api/v1/public
-			apiUri = StringUtils.substringBeforeLast(apiUri, "/");
-			if (apiUri.length() < 3) { // /api
-				return null;
-			}
-		}
-
-		return null;
-	}
-
-	private void logError(HttpServletRequest request) {
-		try {
-			String errorCode = "RECEAIIRP010";
-			String[] msgArgs = new String[1];
-			msgArgs[0] = request.getRequestURI();
-			this.logError(request, "HTTP_IN_NO_URI", errorCode,
-					ExceptionUtil.make(new Exception("cat not find uri"), errorCode, msgArgs), null, null);
-		} catch (Throwable t) {
-			logger.warn("inbound logging failed", t);
-		}
-	}
-	
-	private void logError(HttpServletRequest request, String adapterGroupName, String errorCode,
-			String errorMsg, Properties prop, Exception e) {
-		try {
-			EAIServerManager eaiServerManager = EAIServerManager.getInstance();
-			String serverName = eaiServerManager.getLocalServerName();
-			
-			InboundErrorInfoVO errorInfoVO = new InboundErrorInfoVO();
-			
-			String txId = prop.getProperty(TransactionContextKeys.TRANSACTION_UUID);
-			if (StringUtils.isEmpty(txId)) {
-				String instanceid1 = serverName.substring(0, 2);
-				String instanceid2 = serverName.substring(serverName.length() - 2, serverName.length());
-				String instid = instanceid1 + instanceid2;
-				txId = instid + UUIDGenerator.getUUID();
-			}
-			
-			errorInfoVO.setEaiSvcSno(txId); // EAI서비스일련번호
-			errorInfoVO.setAdptBwkGrpNm(adapterGroupName); // 어댑터업무그룹명
-			errorInfoVO.setErrCd(errorCode); // 에러코드
-			errorInfoVO.setErrTxt(errorMsg); // 에러내용
-			errorInfoVO.setErrTm(DatetimeUtil.getCurrentTime(new Date().getTime())); // 에러발생시각
-			errorInfoVO.setErrDstcd(" ");
-			StringBuffer sb = new StringBuffer();
-			String clientId = prop.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);
-			String hexClientId = clientId != null ? HexaConverter.bytesToHexa(clientId.getBytes()) : "";
-			
-			sb.append(errorMsg).append("\n").append("Remote Addr : ").append(request.getRemoteAddr()).append("\n")
-					.append("Request URI : ").append(request.getRequestURI()).append("\n").append("clientId=")
-					.append(clientId).append(",hexClientId=").append(hexClientId).append(",txProp=").append(prop)
-					.append("\n");
-			if (e != null)
-				sb.append("Exception : ").append(e.getMessage());
-
-			errorInfoVO.setBwkDataTxt(sb.toString()); // 업무데이터내용
-			errorInfoVO.setEaiSvrInstNm(serverName); // EAI서버인스턴스명
-	
-			InboundErrorLogger.error(errorInfoVO);
-		} catch (Throwable t) {
-			logger.warn("inbound logging failed", t);
-		}
-	}
-//	private String makeResponseBodyMsg() {
-//
-//		Map<String, Object> dataMap = new HashMap<>();
-//		dataMap.put("result", 1);
-//		Map<String, Object> map = new HashMap<>();
-//
-//		map.put("code", "200");
-//		map.put("data", dataMap);
-//		map.put("message", "정상 처리 되었습니다.");
-//
-//		JSONObject json = new JSONObject();
-//		json.putAll(map);
-//
-//		return json.toJSONString();
-//	}
-
-	/*
-	 * private String makeResponseBodyMsg(String asyncMsgStyle) {
-	 * 
-	 * Map<String, Object> dataMap = new HashMap<>(); dataMap.put("result", 1);
-	 * Map<String, Object> map = new HashMap<>();
-	 * 
-	 * switch (asyncMsgStyle) { case "TB_SUC": map.put("rspCode", "TB_SUC_000");
-	 * map.put("rspMsg", "정상"); map.put("data", dataMap); break; case "ONLYDATA":
-	 * map.put("data", dataMap); map.put("success", "true"); break; default:
-	 * map.put("code", "200"); map.put("data", dataMap); map.put("message",
-	 * "정상 처리 되었습니다."); break; }
-	 * 
-	 * JSONObject json = new JSONObject(); json.putAll(map);
-	 * 
-	 * return json.toJSONString(); }
-	 */
-}
@@ -0,0 +1,22 @@
+package com.eactive.eai.adapter.controller;
+
+import java.io.IOException;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.PostMapping;
+
+@Controller
+public class TokenRedirectController {
+
+    @PostMapping("/sample/v1/oauth/token")
+    public void redirectPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+        // 포워딩할 URL을 지정
+        String targetUrl = "/api/v1/oauth/token";
+        // 요청과 응답을 다른 URL로 포워딩
+        request.getRequestDispatcher(targetUrl).forward(request, response);
+    }
+}
@@ -1,38 +1,29 @@
 package com.eactive.eai.adapter.interceptor;

-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.apache.commons.lang.StringUtils;
-import org.springframework.web.servlet.HandlerInterceptor;
-
 import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
 import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
 import com.eactive.eai.common.TransactionContextKeys;
-import com.eactive.eai.common.logger.HttpAdapterExtraHeaderVo;
 import com.eactive.eai.common.util.HttpAdapterExtraLogUtil;
 import com.eactive.eai.common.util.Logger;

+import org.apache.commons.lang.StringUtils;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
 public class HttpResponseLoggingInterceptor implements HandlerInterceptor {
 	
 	static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
-	private static boolean httpHeaderLogMode = HttpAdapterExtraLogUtil.isHttpHeaderMode();
 	
-	@Override
+    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    	
    	logger.debug("httpHeader logging Interceptor start");
    	
-    	if (!httpHeaderLogMode) {
-    		logger.info("httpHeader logging off - use.http.header.log");
-    		return;
-    	}
-    	
        Properties transactionProp = (Properties) request.getAttribute(TransactionContextKeys.TRANSACTION_PROP);
        if(transactionProp == null || "ASYN".equals(transactionProp.getProperty(HttpAdapterServiceKey.INBOUND_SYNC_ASYNC_TYPE))){
        	logger.debug("httpHeader logging Interceptor ASYNC");
@@ -58,11 +49,6 @@ public class HttpResponseLoggingInterceptor implements HandlerInterceptor {
            logger.debug(String.format( "httpHeader logging Interceptor headerKey=%s, headerValue=%s", headerName, headerValue));
            headerMap.put(headerName, headerValue);
        }
-        
-        String body = transactionProp.getProperty(HttpAdapterExtraLogUtil.BODY_FIELD_NAME);
-		if (StringUtils.isNotEmpty(body)) {
-			headerMap.put(HttpAdapterExtraLogUtil.BODY_FIELD_NAME, body);
-		}

        int httpStatusCode = response.getStatus();
        HttpAdapterExtraLogUtil.insertHttpAdapterExtraLog(uuid, 400, adapterGroupName, adapterName, headerMap, url, method, httpStatusCode);
@@ -0,0 +1,847 @@
+package com.eactive.eai.adapter.service;
+
+import com.eactive.eai.adapter.AdapterGroupVO;
+import com.eactive.eai.adapter.AdapterPropManager;
+import com.eactive.eai.adapter.AdapterVO;
+import com.eactive.eai.adapter.Keys;
+import com.eactive.eai.adapter.http.HttpMemoryLogger;
+import com.eactive.eai.adapter.http.HttpMethodType;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthFilter;
+import com.eactive.eai.common.exception.ExceptionUtil;
+import com.eactive.eai.common.message.MessageType;
+import com.eactive.eai.common.util.CommonLib;
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.inbound.action.ActionFactory;
+import com.eactive.eai.inbound.action.RequestAction;
+import com.eactive.eai.inbound.processor.Processor;
+import com.eactive.eai.message.StandardMessageUtil;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.apache.mina.common.ByteBuffer;
+import org.json.simple.JSONObject;
+import org.json.simple.JSONValue;
+import org.json.simple.parser.JSONParser;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Service;
+import org.springframework.util.AntPathMatcher;
+
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.net.URLDecoder;
+import java.util.*;
+
+//for encrypt/decrypt jwhong
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.kjbank.encrypt.exchange.crypto.AES256Cipher;
+import com.kjbank.encrypt.exchange.crypto.AESCipher;
+import com.kjbank.encrypt.exchange.crypto.AES256GCMCipher;
+import java.nio.charset.StandardCharsets;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import org.springframework.security.oauth2.provider.ClientDetails;
+import com.nimbusds.jwt.SignedJWT;
+import com.eactive.eai.common.context.ElinkTransactionContext;
+
+
+@Service
+public class ApiAdapterService extends HttpAdapterServiceSupport {
+    static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+
+    public static final String HEADER_GROUP = "HEADER_GROUP";
+	public static final String HTTP_STATUS = "HTTP_STATUS";   // jwhong
+    // HEADER_GROUP JSON에 추가할 항목 정의, 없으면 전체 header 추가
+    public static final String HEADER_KEYS = "HEADER_KEYS";
+    public static final String PROPERTIES_NAME_HTTP_REQUEST_METHOD = "httpRequestMethod";
+
+    private static final String JSON_CONTENT_TYPE = "application/json";
+    private static final String JSON_FIELD_NAME = "json-body";
+    private static final String FILE_GROUP_NAME = "image-file";
+    private static final String UPLOAD_ROOT_PATH = "UPLOAD_ROOT_PATH";
+	public static final String PAYLOAD_PARAM_NAME_CLIENT_ID = "client_id";  // jwhong
+	private boolean encryptResponseApply;   // inbound에 대한 응답 암호화 여부 flag
+    
+    public String callApi(HttpServletRequest request, HttpServletResponse response, Properties httpProp, AdapterGroupVO adapterGroupVO, AdapterVO adapterVO, Properties transactionProp) throws Exception {
+        int traceLevel = 0;
+
+        AdapterPropManager manager = null;
+        String adptGrpName = adapterGroupVO.getName();
+        String adptName = adapterVO.getName();
+
+        String urlDecodeYn = httpProp.getProperty(URL_DECODE_YN, "N");
+        String encode = StringUtils.defaultIfBlank(adapterGroupVO.getMessageEncode(), "UTF-8");
+
+        String traceLevelTemp = httpProp.getProperty(TRACE_LEVEL, "0");
+        String relayRequestHeaderKeys = httpProp.getProperty(HEADER_KEYS);
+        String headerGroupName = httpProp.getProperty(HEADER_GROUP);
+
+        boolean isParameterType = false;
+        String message = null;
+
+        String paramValue = null;
+        String adptMsgType = null;
+        
+        transactionProp.put(INBOUND_METHOD, request.getMethod());
+        transactionProp.put(INBOUND_URI, request.getRequestURI());
+        transactionProp.put(INBOUND_HEADER, getHeaders(request));
+        transactionProp.put(INBOUND_EXTPARAMS, StringUtils.defaultString(request.getQueryString()));
+        if (StringUtils.equals(adapterVO.getAdapterGroupVO().getType(), Keys.TYPE_REST)
+                || StringUtils.equals(adapterVO.getAdapterGroupVO().getType(), Keys.TYPE_HTTP_CUSTOM)) {
+            // /api/v1/public/getUserInfo.svc
+            String extUrl = StringUtils.removeStart(request.getRequestURI(), request.getContextPath());
+            transactionProp.put(INBOUND_EXTURI, extUrl);
+        } else {
+            transactionProp.put(INBOUND_EXTURI, getExtUri(request)); 
+        }
+        transactionProp.put(INBOUND_CLIENT_IP, getClientIp(request));  // Client IP 추가
+        transactionProp.put(Processor.REQUEST_ACTION, adapterVO.getAdapterGroupVO().getRefClass());
+        transactionProp.put(API_PATH, httpProp.getProperty(API_PATH, ""));
+        transactionProp.put(PRE_FILTERS, httpProp.getProperty(PRE_FILTERS, ""));
+        transactionProp.put(POST_FILTERS, httpProp.getProperty(POST_FILTERS, ""));
+        transactionProp.put(PROPERTIES_NAME_HTTP_REQUEST_METHOD, request.getMethod());
+        transactionProp.put(ALLOW_IP, httpProp.getProperty(ALLOW_IP, ""));
+        transactionProp.put("BLOCK_IP", httpProp.getProperty("BLOCK_IP", ""));
+        
+        transactionProp.put(ENC_PATHS, httpProp.getProperty(ENC_PATHS, ""));
+        
+        transactionProp.put(ENCRYPT_ALGORITHM, httpProp.getProperty(ENCRYPT_ALGORITHM, ""));  //jwhong
+        if (getHeaders(request).get(HEADER_NAME_CLIENT_ID) != null) {    // jwhong
+        	transactionProp.put(HEADER_NAME_CLIENT_ID, getHeaders(request).get(HEADER_NAME_CLIENT_ID));  
+        }
+        transactionProp.put(ENCRYPT_BASE_TYPE, httpProp.getProperty(ENCRYPT_BASE_TYPE, ""));  //jwhong
+//        //transactionProp.put(INBOUND_TOKEN, getHeaders(request).get(INBOUND_TOKEN));  // jwhong
+//        transactionProp.put(INBOUND_TOKEN, getHeaders(request).get(INBOUND_TOKEN) != null ? getHeaders(request).get(INBOUND_TOKEN) : "");  //jwhong , null 이면 default로 "" put
+        String inboundToken = getHeaders(request).getOrDefault(INBOUND_TOKEN, "").toString();
+        if (StringUtils.isNotBlank(inboundToken) && StringUtils.startsWith(inboundToken, "Bearer ")) {
+        	inboundToken = inboundToken.substring(7);
+        }
+        transactionProp.put(INBOUND_TOKEN, inboundToken);
+        transactionProp.put(ENCRYPT_AES256_IV, httpProp.getProperty(ENCRYPT_AES256_IV, ""));  //jwhong
+        transactionProp.put(ENCRYPT_AES256_KEY, httpProp.getProperty(ENCRYPT_AES256_KEY, ""));  //jwhong
+      
+        // SEED 컬럼암호하 시  Key로 사용함
+        String seedkey = getHeaders(request).getOrDefault("x-obp-partnercode", "").toString();
+        ElinkTransactionContext.setSeedKey(seedkey);
+
+        try {
+            traceLevel = Integer.parseInt(traceLevelTemp);
+        } catch (Exception e) {
+            traceLevel = 0;
+        }
+
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+
+        logger.debug("시작 >> encode = [" + encode + "]");
+
+        switch (HttpMethodType.getValue(request.getMethod())) {
+            case GET:
+            case DELETE:
+                isParameterType = true;
+                break;
+            case POST:
+            case PUT:
+                if (StringUtils.contains(request.getContentType(), "application/x-www-form-urlencoded")) {
+                    isParameterType = true;
+                } else if ( StringUtils.isNoneBlank(request.getQueryString()) )  { // jwhong
+                	isParameterType = true;
+                } else {
+                    isParameterType = false;
+                }
+                break;
+            default:
+                break;
+        }
+
+        if (isParameterType) {
+            paramValue = request.getQueryString();
+            transactionProp.put(INBOUND_QUERY_STRING, StringUtils.defaultString(paramValue));  // Filter에서 QueryString 검증을 위해 저장 
+            if (paramValue == null)
+                paramValue = "";
+            if (traceLevel >= 3) {
+                HttpMemoryLogger.txlog(adptGrpName + adptName,
+                        "RECV " + "[" + paramValue + "]" + CommonLib.getDumpMessage(paramValue));
+            }
+
+            // json으로 변환
+            StringBuilder sb = new StringBuilder();
+            sb.append("{");
+            Map<String, String[]> paramMap = assignParameterMap(request, adptGrpName, adptName, null, transactionProp);
+            int i = 0;
+            for (Map.Entry<String, String[]> entry : paramMap.entrySet()) {
+                if (i > 0) {
+                    sb.append(",");
+                }
+                sb.append("\"").append(entry.getKey()).append("\":");
+                String[] values = entry.getValue();
+                if (values.length > 1) {
+                    // ["111", "222"]
+                    sb.append("[");
+                    for (int j = 0; j < values.length; j++) {
+                        if (j > 0) {
+                            sb.append(",");
+                        }
+                        sb.append("\"").append(JSONValue.escape(values[j])).append("\"");
+                    }
+                    sb.append("]");
+                } else {
+                    sb.append("\"").append(JSONValue.escape(values[0])).append("\"");
+                }
+
+                i++;
+            }
+
+            sb.append("}");
+
+            paramValue = sb.toString();
+            
+            if (logger.isDebug()) {
+                logger.debug("HttpAdapterServiceRest] RECV (" + adptGrpName + ") = [" + paramValue + "]\n"
+                        + CommonLib.getDumpMessage(paramValue.getBytes(encode)));
+            }
+	} else {
+	    if (request.getContentLength() > 0) {
+		ServletInputStream sis = request.getInputStream();
+		ByteBuffer bb = ByteBuffer.allocate(1024).setAutoExpand(true);
+		int i = 0;
+		byte[] cbuf = new byte[1024];
+		while ((i = sis.read(cbuf, 0, 1024)) != -1) {
+		    if (i == 1024) {
+			bb.put(cbuf);
+		    } else {
+			byte[] tail = new byte[i];
+			System.arraycopy(cbuf, 0, tail, 0, i);
+			bb.put(tail);
+		    }
+		}
+		byte[] data = new byte[bb.position()];
+		bb.position(0);
+		bb.get(data);
+		paramValue = new String(data, encode);
+
+		if (traceLevel >= 3) {
+		    HttpMemoryLogger.txlog(adptGrpName + adptName,
+			    "RECV " + "[" + paramValue + "]" + CommonLib.getDumpMessage(data));
+		}
+
+		if (logger.isDebug()) {
+		    logger.debug("HttpAdapterServiceRest] RECV (" + adptGrpName + ") = [" + paramValue + "]\n"
+			    + CommonLib.getDumpMessage(data));
+		}
+	    }
+	}
+
+        if (paramValue == null) { // parameter가 없는 경우때문에 처리
+            paramValue = "";
+        }
+        // 순수한 Body값을 저장을 위해 위치 변경.
+        transactionProp.put(INBOUND_REQUEST_MESSAGE, paramValue);
+
+        // paramValue가 null이 아닌 빈문자열(""," ")인 경우에 대비하여 조건 수정.
+        if (StringUtils.isNotBlank(paramValue)) {      // jwhong decrypt
+        	paramValue = doPreDecryption(paramValue, transactionProp, request);
+        }
+
+        if ("Y".equals(urlDecodeYn) && isParameterType) {
+            message = URLDecoder.decode(paramValue);
+        } else {
+            message = paramValue;
+        }
+
+        if (logger.isDebug()) {
+            String[] msgArgs = new String[2];
+            msgArgs[0] = adptGrpName;
+            msgArgs[1] = message;
+            String resMsg = ExceptionUtil.make("RICEAIAHA005", msgArgs);
+            logger.debug(resMsg);
+        }
+
+
+        adptMsgType = adapterVO.getAdapterGroupVO().getMessageType();
+//        HttpHeaders responseHeaders = new HttpHeaders();
+//        responseHeaders.setContentType(MediaType.valueOf("application/json;charset=" + encode));
+
+
+        // HEADER_GROUP 셋팅
+        if (MessageType.JSON.equals(adptMsgType) && StringUtils.isNotBlank(headerGroupName)
+                && StringUtils.isNotBlank(relayRequestHeaderKeys)) {
+            JSONObject jsonMessage = (JSONObject) JSONValue.parse(message);
+            JSONObject headerJson = new JSONObject();
+            if (StringUtils.equalsIgnoreCase(relayRequestHeaderKeys, "ALL")) {
+                for (Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements(); ) {
+                    String key = e.nextElement();
+                    headerJson.put(key, request.getHeader(key));
+                }
+            } else {
+                String[] relayKeyArr = org.springframework.util.StringUtils
+                        .tokenizeToStringArray(relayRequestHeaderKeys, ",");
+
+                for (String key : relayKeyArr) {
+                    String headerValue = request.getHeader(key);
+                    if (StringUtils.isNotBlank(headerValue)) {
+                        headerJson.put(key, headerValue);
+                    }
+                }
+            }
+            
+            if (headerJson.size() > 0) {
+                jsonMessage.put(headerGroupName, headerJson);
+                message = jsonMessage.toJSONString();
+            }
+        }
+
+        if (message == null) {
+            message = "";
+        }
+
+        // 위치변경 : 가공되지 않은 Body값을 저장하기 위하여 위쪽으로 이동.
+//        transactionProp.put(INBOUND_REQUEST_MESSAGE, message);
+        // 로컬 서비스 호출 ,encoding 처리 추가
+        String result = (String) service(adptGrpName, adptName, message, transactionProp, request, response);
+
+        if (logger.isDebug()) {
+            logger.debug("HttpAdapterServiceRest] result " + encode + " (" + adptGrpName + ") = [" + result + "]");
+        }
+
+        stopWatch.stop();
+
+        String syncAsyncType = transactionProp.getProperty(INBOUND_SYNC_ASYNC_TYPE);
+
+        if (!"ASYN".equals(syncAsyncType) && MessageType.JSON.equals(adptMsgType) && StringUtils.isNotBlank(headerGroupName)) {
+        	ObjectMapper mapper = new ObjectMapper();
+        	ObjectNode rootNode = (ObjectNode) mapper.readTree(result);
+        	JsonNode headerGroup = rootNode.get(headerGroupName);
+        	if(headerGroup != null) {
+        		for(Iterator<String> it = headerGroup.fieldNames(); it.hasNext();) {
+    				String name = it.next();
+    				String value = headerGroup.get(name).asText();
+    				response.addHeader(name, value);
+        		}
+        		rootNode.remove(headerGroupName);
+        		result = mapper.writeValueAsString(rootNode);
+        	}
+        }
+                        
+        // KJBank는 요청에 대한 응답 (Sync응답, Aync 에 대한 Ack응답) 에 대하여 암호화 하지 않는다. 무조건 안한다. 따라서 아래부분은 구현은 했지만 사용하지 않는다.   
+        // 위 2가지 경우 암호화 하는걸로 요청 변경되어 아래 암호화 수행하도록 수정함
+    	encryptResponseApply = StringUtils.equalsIgnoreCase(httpProp.getProperty("ENCRYPT_RESPONSE_APPLY", "N"), "Y");
+		if ( encryptResponseApply)  {
+			result = doPostEncryption(result, transactionProp, request);   // jwhong Encrypt
+		}
+        return result;
+    }
+    
+    
+    // jwhong decrypt
+
+    private String doPreDecryption(String eaiBody, Properties transactionProp, HttpServletRequest request) throws Exception {
+    	String decryptAlgorithm = transactionProp.getProperty(ENCRYPT_ALGORITHM, "");
+    	String xElinkClientId = transactionProp.getProperty(HEADER_NAME_CLIENT_ID, "");   // 이 값이 OAuth의 client id 값이다 . http header 에 포함되어 온다. jwhong
+		String encryptBaseKeyType = transactionProp.getProperty(ENCRYPT_BASE_TYPE);   
+    	//String inboundToken2 = transactionProp.getProperty(INBOUND_TOKEN, "");   // 이건 token 값이 아니고 authorization 값이다
+		String inboundToken = "";
+    	
+		String secretAES256Iv = transactionProp.getProperty("ENCRYPT_AES256_IV");  
+		String secretAES256Key = transactionProp.getProperty("ENCRYPT_AES256_KEY");  
+		
+    	if ( decryptAlgorithm == "" ) {   // 복호화 대상이 아님
+    		return eaiBody;
+    	}
+
+    	inboundToken = JwtTokenExtractor(request);
+    	xElinkClientId = JwtClientIdExtractor(inboundToken);   // token에서 client id를 추출함
+    	
+    	// 암호화 key를 token 내용으로 할지 client secret 내용으로 할지 결정함. adapter property에 정의함
+    	// ENCRYPT_ALGORITHM 을 설정했는데 ENCRYPT_BASE_TYPE을 설정안하면 Decrypt 수행시 Exception 발생함
+    	String clientSecret = "";
+    	if ("TOKEN".equalsIgnoreCase(encryptBaseKeyType)) {
+    		clientSecret  = inboundToken;
+    	} else if ( "SECRETKEY".equalsIgnoreCase(encryptBaseKeyType)) {
+        	OAuth2Manager manager = OAuth2Manager.getInstance();
+        	ClientDetails clientDetail = manager.getClientDeatilsStore().get(xElinkClientId);
+
+        	if ( clientDetail != null ) {   // 여기서 not null 이라는 것은 apim oauth server에서 발급된 token 임.
+        		                            // 즉 KJBank 에서 요청이 들어온 것이다.
+        		clientSecret = clientDetail.getClientSecret();
+        	}   // 그럼 업체에서 요청이 들어오면?? 업체도 apim oauth server에서 발급된 token을 사용하는것이다.
+    	} 
+    	
+    	byte[] decryptedMessage = null;
+    	decryptedMessage = doInboundPreDecrypt(eaiBody, decryptAlgorithm,clientSecret,secretAES256Iv, secretAES256Key );
+    	
+		if (decryptedMessage == null) {   
+			throw new Exception("[ApiAdapterService] Decrypt Error : Invalid encrypted message");
+		}
+    	
+    	
+    	String resultMessage = new String(decryptedMessage, StandardCharsets.UTF_8 );
+    	return resultMessage;
+    	//return new String(decryptedMessage, StandardCharsets.UTF_8 );
+    }
+    
+    
+    // jwhong encrypt
+    public String doPostEncryption(String eaiBody, Properties transactionProp, HttpServletRequest request) throws Exception {
+		
+    	String decryptAlgorithm = transactionProp.getProperty(ENCRYPT_ALGORITHM, "");
+    	String xElinkClientId = transactionProp.getProperty(HEADER_NAME_CLIENT_ID, "");   // 이 값이 OAuth의 client id 값이다 . http header 에 포함되어 온다. jwhong
+		String encryptBaseKeyType = transactionProp.getProperty(ENCRYPT_BASE_TYPE);   
+		String inboundToken = "";
+    	
+		String secretAES256Iv = transactionProp.getProperty("ENCRYPT_AES256_IV");  
+		String secretAES256Key = transactionProp.getProperty("ENCRYPT_AES256_KEY");  
+		  	
+    	if ( decryptAlgorithm == "" ) {   // 복호화 대상이 아님
+    		return eaiBody;
+    	}
+    	
+    	inboundToken = JwtTokenExtractor(request);
+    	xElinkClientId = JwtClientIdExtractor(inboundToken);   // token에서 client id를 추출함
+
+    	// 암호화 key를 token 내용으로 할지 client secret 내용으로 할지 결정함. adapter property에 정의함
+    	// ENCRYPT_ALGORITHM 을 설정했는데 ENCRYPT_BASE_TYPE을 설정안하면 Decrypt 수행시 Exception 발생함
+    	String clientSecret = "";
+    	if ("TOKEN".equalsIgnoreCase(encryptBaseKeyType)) {
+    		clientSecret  = inboundToken;
+    	} else if ( "SECRETKEY".equalsIgnoreCase(encryptBaseKeyType)) {
+        	OAuth2Manager manager = OAuth2Manager.getInstance();
+        	ClientDetails clientDetail = manager.getClientDeatilsStore().get(xElinkClientId);
+
+        	if ( clientDetail != null ) {
+        		clientSecret = clientDetail.getClientSecret();
+        	}
+    	} 
+    	
+    	String encryptedMessage = null;
+    	encryptedMessage = doInboundPostEncrypt(eaiBody, decryptAlgorithm,clientSecret,secretAES256Iv, secretAES256Key );
+    	
+		if (encryptedMessage == null) {   
+			throw new Exception("[ApiAdapterService] Encrypt Error : Invalid PlainText message");
+		}
+		
+		return encryptedMessage;
+    	//String resultMessage = new String(encryptedMessage, StandardCharsets.UTF_8 );
+    	//return resultMessage;
+    }
+    
+
+ 	private byte[] convertObjectToBytes(Object obj) throws IOException {
+ 	    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ 	    ObjectOutputStream oos = new ObjectOutputStream(bos);
+ 	    oos.writeObject(obj);
+ 	    oos.flush();
+ 	    return bos.toByteArray();
+ 	}
+ 	
+ 	private byte[] convertObjectToBase64Bytes(Object obj) throws IOException {
+ 	    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ 	    ObjectOutputStream oos = new ObjectOutputStream(bos);
+ 	    oos.writeObject(obj);
+ 	    oos.flush();
+ 	    oos.close();
+
+ 	    // 직렬화된 byte[] → Base64 문자열 → 다시 byte[]로 변환
+ 	    String base64String = Base64.getEncoder().encodeToString(bos.toByteArray());
+ 	    return base64String.getBytes(StandardCharsets.UTF_8);
+ 	}
+ 	
+ 	public static Object convertBytesToObject(byte[] bytes) throws IOException, ClassNotFoundException {
+ 	    try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
+ 	         ObjectInputStream ois = new ObjectInputStream(bis)) {
+ 	        return ois.readObject();
+ 	    }
+ 	}
+ 	
+ 	
+ 	private byte[] doInboundPreDecrypt(String eaiStringBody, String decryptAlgorithm, String clientSecretKey, String secretAES256Iv, String secretAES256Key) throws Exception {
+ 	      
+ 		byte[] decryptedMessage = null;
+ 		//String eaiStringBody = new String(eaiBody, StandardCharsets.UTF_8);
+ 		
+ 		eaiStringBody = extractBodyMsg(decryptAlgorithm, eaiStringBody);
+ 		
+		if (eaiStringBody == null) {   
+			throw new Exception("[ApiAdapterService] Cannot decrypt Error : input is plain text");
+		}
+ 		
+ 		//test source
+ 		logger.debug("Base64 문자열: " + eaiStringBody);
+ 		logger.debug("Base64 문자열 길이: " + eaiStringBody.length());
+ 		logger.debug("Base64 문자열 끝: " + eaiStringBody.substring(eaiStringBody.length() - 10));
+
+ 		// Base64 디코딩 테스트
+ 		try {
+ 		    byte[] decoded = Base64.getDecoder().decode(eaiStringBody);
+ 		    logger.debug("디코딩 성공, 길이: " + decoded.length);
+ 		} catch (IllegalArgumentException e) {
+ 		    logger.debug("Base64 디코딩 실패: " + e.getMessage());
+ 		}
+         // end test source
+ 	
+ 		switch (decryptAlgorithm) {
+ 		case "AES128":	
+ 		case "AES128-TOSS":			
+ 		    try {
+ 	 		    String key128 = clientSecretKey.substring(22,38);   //togetherEncoder 경우는 substring(44,60) 이네?? 
+ 		    	//String decryptedStrMessage = AESCipher.decrypt(eaiStringBody, key128);
+ 		    	String decryptedStrMessage = AESCipher.decryptExistException(eaiStringBody, key128);
+ 		    	decryptedMessage =  decryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 		    } catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES128 Decryption error=" + e.getMessage());
+ 		    }
+ 		    break; 
+ 		case "AES128-TOGETHER":			
+ 		    try {
+ 		    	String key128 = clientSecretKey.substring(44,60);   //togetherEncoder 경우는 substring(44,60) 이네?? 
+ 		    	//String decryptedStrMessage = AESCipher.decrypt(eaiStringBody, key128);
+ 		    	String decryptedStrMessage = AESCipher.decryptExistException(eaiStringBody, key128);
+ 		    	decryptedMessage =  decryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 		    } catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES128 Decryption error=" + e.getMessage());
+ 		    }
+ 		    break;
+ 		case "AES256":
+ 			try {
+ 	 			String key = clientSecretKey.substring(10,42);
+ 				String decryptedStrMessage = AES256Cipher.decrypt(eaiStringBody, key);
+ 				decryptedMessage =  decryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES256 Decryption error=" + e.getMessage());
+ 			} 	
+ 			break;
+ 		case "AES256-KAKAO":
+ 			try {
+ 				String decryptedStrMessage = AES256Cipher.decrypt(eaiStringBody, secretAES256Iv, secretAES256Key);
+ 				decryptedMessage =  decryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES256 Decryption error=" + e.getMessage());
+ 			} 	
+ 			break;
+ 		case "AES256-TOSS":
+ 			try {
+ 				String decryptedStrMessage = AES256Cipher.decrypt(eaiStringBody, secretAES256Iv, secretAES256Key);
+ 				decryptedMessage =  decryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES256 Decryption error=" + e.getMessage());
+ 			} 	
+ 			break;
+ 			
+		case "AES256GCM":
+			try {
+				byte[] key = AES256GCMCipher.generateKey();
+				AES256GCMCipher cipher = new AES256GCMCipher(key);
+				byte[] aad = "metadata".getBytes();
+				
+				String decryptedStrMessage = cipher.decrypt(eaiStringBody , aad);
+				decryptedMessage =  decryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+				
+			} catch (Exception e) {
+		        e.printStackTrace();
+		        logger.error("HttpClientAdapterServiceRest] AES256GCM Encryption error=" + e.getMessage());
+			} 		 			
+			break;
+ 		default:
+ 			try {
+ 				decryptedMessage = eaiStringBody.getBytes();
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] doOutboundPostFilter Array copy error=" + e.getMessage());
+ 			} 		 			
+ 			break;
+ 		}
+ 		
+ 		return decryptedMessage;		
+ 	}
+   
+	private String extractBodyMsg(String decryptAlgorithm, String eaiStringBody) {
+
+		String decryptedJsonKey = "";
+		String decryptedBodyMessage = "";
+		
+		decryptedJsonKey = getJsonKey(decryptAlgorithm);
+		
+		try {
+			JSONParser parser = new JSONParser();
+			JSONObject jsonObject = (JSONObject) parser.parse(eaiStringBody);
+			decryptedBodyMessage = (String) jsonObject.get(decryptedJsonKey);	
+		} catch (Exception e) {
+	        e.printStackTrace();
+	        logger.error("HttpClient5AdapterServiceRest] extractBodyMsg error : " + e.getMessage());
+		}
+	
+		return decryptedBodyMessage;
+		
+	}
+	
+	private String getJsonKey(String Algorithm) {
+
+		String jsonKey = "";
+
+		switch (Algorithm) {
+			case "AES128":
+			case "AES128-TOSS":
+				jsonKey = "preScreeningRequest";
+				break;
+			case "AES128-TOGETHER":
+				jsonKey = "obpTxData";
+				break;
+			case "AES256":
+				jsonKey = "preScreeningRequest";
+				break;
+			case "AES256-KAKAO":
+				jsonKey = "encrypted_data";
+				break;
+			case "AES256-TOSS":
+				jsonKey = "encryptedData";
+				break;
+			case "AES256-NICEON":
+				jsonKey = "enc_data";
+				break;
+			case "AES256GCM":
+				break;
+			default:
+				break;
+		}
+		return jsonKey;
+	}
+ 	
+ 	private String doInboundPostEncrypt(String eaiStringBody, String encryptAlgorithm, String clientSecretKey, String secretAES256Iv, String secretAES256Key) {
+	      
+ 		//byte[] encryptedMessage = null;
+ 		String encryptedStrMessage = null;
+ 		String encryptedJsonKey = "";
+
+ 		encryptedJsonKey = getJsonKey(encryptAlgorithm);
+ 			
+ 		switch (encryptAlgorithm) {
+ 		case "AES128":		
+ 		case "AES128-TOSS":			
+ 		    try {
+ 	 		    String key128 = clientSecretKey.substring(22,38);   //togetherEncoder 경우는 substring(44,60) 이네?? 
+ 		    	encryptedStrMessage = AESCipher.encrypt(eaiStringBody, key128);
+ 		    	//encryptedMessage =  encryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 		    } catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES128 Encryption error=" + e.getMessage());
+ 		    }
+ 		    break;
+ 		case "AES128-TOGETHER":			
+ 		    try {
+ 		    	String key128 = clientSecretKey.substring(44,60);   //togetherEncoder 경우는 substring(44,60) 이네?? 
+ 		    	encryptedStrMessage = AESCipher.encrypt(eaiStringBody, key128);
+ 		    	//encryptedMessage =  encryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 		    } catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES128 Encryption error=" + e.getMessage());
+ 		    }
+ 		    break;
+ 		case "AES256":
+ 			try {
+ 	 			String key = clientSecretKey.substring(10,42);
+ 				encryptedStrMessage = AES256Cipher.encrypt(eaiStringBody, key);
+ 				//encryptedMessage =  encryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES256 Encryption error=" + e.getMessage());
+ 			} 	
+ 			break;
+ 		case "AES256-KAKAO":
+ 			try {
+ 				encryptedStrMessage = AES256Cipher.encrypt(eaiStringBody, secretAES256Iv, secretAES256Key);
+ 				//encryptedMessage =  encryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES256 Encryption error=" + e.getMessage());
+ 			} 	
+ 			break;
+ 		case "AES256-TOSS":
+ 			try {
+ 				encryptedStrMessage = AES256Cipher.encrypt(eaiStringBody, secretAES256Iv, secretAES256Key);
+ 				//encryptedMessage =  encryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] AES256 Encryption error=" + e.getMessage());
+ 			} 	
+ 			break;
+ 			
+		case "AES256GCM":
+			try {
+				byte[] key = AES256GCMCipher.generateKey();
+				AES256GCMCipher cipher = new AES256GCMCipher(key);
+				byte[] aad = "metadata".getBytes();
+				
+				encryptedStrMessage = cipher.encrypt(eaiStringBody , aad);
+				//encryptedMessage =  encryptedStrMessage.getBytes(StandardCharsets.UTF_8);
+				
+			} catch (Exception e) {
+		        e.printStackTrace();
+		        logger.error("HttpClientAdapterServiceRest] AES256GCM Encryption error=" + e.getMessage());
+			} 		 			
+			break;
+ 		default:
+ 			try {
+ 				encryptedStrMessage = eaiStringBody;
+ 				//encryptedMessage = eaiStringBody.getBytes();
+ 			} catch (Exception e) {
+ 		        e.printStackTrace();
+ 		        logger.error("HttpClientAdapterServiceRest] doOutboundPostFilter Array copy error=" + e.getMessage());
+ 			} 		 			
+ 			break;
+ 		}
+ 		
+		Map<String, Object> map = new HashMap<>();
+		map.put(encryptedJsonKey, encryptedStrMessage);
+		JSONObject json = new JSONObject();
+		json.putAll(map);
+		return json.toJSONString();
+ 		//return encryptedMessage;		
+ 	}
+ 	
+ 	
+ 	
+ 	private String JwtTokenExtractor(HttpServletRequest request) {
+
+ 		String Token = "";
+ 		try {
+ 			Token = JwtAuthFilter.extractJWTToken(request);
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+		}
+ 		
+ 		logger.debug("Token is: " + Token);
+ 		return Token;
+
+ 	}
+ 	
+ 	private String JwtClientIdExtractor(String inboundToken) {
+
+ 		String tokenClientId ="";
+ 		try {
+ 	 		SignedJWT signedJWT = SignedJWT.parse(inboundToken);
+ 	 		tokenClientId = (String) signedJWT.getJWTClaimsSet().getClaim(PAYLOAD_PARAM_NAME_CLIENT_ID);			
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+			tokenClientId = "";
+		}
+ 		
+ 		logger.debug("Token Client ID: " + tokenClientId);
+ 		return tokenClientId;
+
+ 	}
+ 	
+    // jwhong until here
+
+
+    private Map<String, String[]> assignParameterMap(HttpServletRequest request, String adptGrpName, String adptName,
+                                                     Object requestBytes, Properties prop) {
+        // PathVariable 체크
+        if (StringUtils.equalsAnyIgnoreCase(request.getMethod(), HttpMethod.GET.name(), HttpMethod.DELETE.name())
+                && StringUtils.isBlank(request.getQueryString())) {
+            try {
+                String actionName = prop.getProperty(Processor.REQUEST_ACTION);
+                RequestAction action = ActionFactory.createAction(actionName);
+                action.setAdapterInfo(adptGrpName, adptName, prop);
+                String[] keys = action.perform(requestBytes);
+                String requestPath = keys[0];
+
+                // PathVariable 지원 추가
+                String ruledPath = StandardMessageUtil.getMatchedKey(requestPath, actionName);
+                if (!StringUtils.equals(requestPath, ruledPath) && StringUtils.contains(ruledPath, "{")) {
+                    Map<String, String> paramMap = new AntPathMatcher().extractUriTemplateVariables(ruledPath,
+                            requestPath);
+                    if (paramMap != null && paramMap.size() > 0) {
+                        Map<String, String[]> returnMap = new HashMap<>();
+                        for (String key : paramMap.keySet()) {
+                            if (StringUtils.equalsIgnoreCase(key, "method")) {
+                                continue;
+                            }
+                            returnMap.put(key, new String[] { paramMap.get(key) });
+                        }
+
+                        return returnMap;
+                    }
+                }
+            } catch (Exception e) {
+                logger.error(e.getMessage());
+            }
+        }
+
+        return request.getParameterMap();
+    }
+
+    private Properties getHeaders(HttpServletRequest request) {
+        Properties prop = new Properties();
+
+        Enumeration<String> headerNames = request.getHeaderNames();
+        while (headerNames.hasMoreElements()) {
+            String key = headerNames.nextElement();
+            String value = request.getHeader(key);
+            prop.setProperty(key, value);
+        }
+
+        return prop;
+    }
+
+    private String getExtUri(HttpServletRequest request) {
+        String orgUri = request.getRequestURI().replaceAll(request.getContextPath(), "");
+        String uri = getExtUri(orgUri, 3);
+        if (uri != null && uri.trim().length() > 0) {
+            return "/" + uri;
+        } else {
+            return "";
+        }
+    }
+
+    private static String getExtUri(String url, int length) {
+        String[] urls = url.split("/");
+        List<String> newUrls = new ArrayList<>();
+        Collections.addAll(newUrls, urls);
+        return StringUtils.join(newUrls.subList(length, urls.length).toArray(), "/");
+    }
+
+    @Override
+    @Deprecated
+    public void service(String adptGrpName, String adptName, HttpServletRequest request, HttpServletResponse response) {
+
+    }
+
+    /**
+     * HTTP 요청에서 클라이언트 IP를 추출합니다.
+     * X-Forwarded-For 헤더가 있는 경우 이를 우선적으로 사용하고,
+     * 없는 경우 remoteAddr을 사용합니다.
+     */
+    private String getClientIp(HttpServletRequest request) {
+        String ipAddress = request.getHeader("X-Forwarded-For");
+        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getHeader("Proxy-Client-IP");
+        }
+        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getHeader("WL-Proxy-Client-IP");
+        }
+        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getHeader("HTTP_CLIENT_IP");
+        }
+        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getHeader("HTTP_X_FORWARDED_FOR");
+        }
+        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+            ipAddress = request.getRemoteAddr();
+        }
+        return ipAddress;
+    }
+}
@@ -1,874 +0,0 @@
-package com.eactive.eai.adapter.service;
-
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.UnsupportedEncodingException;
-import java.net.URLDecoder;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Properties;
-
-import javax.servlet.ServletInputStream;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.time.StopWatch;
-import org.apache.hc.core5.http.ContentType;
-import org.apache.mina.common.ByteBuffer;
-import org.dom4j.Document;
-import org.dom4j.DocumentException;
-import org.dom4j.DocumentHelper;
-import org.dom4j.Element;
-import org.dom4j.Node;
-import org.dom4j.io.OutputFormat;
-import org.dom4j.io.XMLWriter;
-import org.json.simple.JSONValue;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.MediaType;
-import org.springframework.stereotype.Service;
-import org.springframework.util.AntPathMatcher;
-
-import com.eactive.eai.adapter.AdapterGroupVO;
-import com.eactive.eai.adapter.AdapterVO;
-import com.eactive.eai.adapter.Keys;
-import com.eactive.eai.adapter.http.HttpMemoryLogger;
-import com.eactive.eai.adapter.http.HttpMethodType;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
-import com.eactive.eai.adapter.http.dynamic.filter.ApiKeyExtractFilter;
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.adapter.http.filter.AbstractCryptoFilter;
-import com.eactive.eai.common.context.ElinkTransactionContext;
-import com.eactive.eai.common.exception.ExceptionUtil;
-import com.eactive.eai.common.message.MessageType;
-import com.eactive.eai.common.stdmessage.STDMessageManager;
-import com.eactive.eai.common.util.CommonLib;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.common.util.TxFileLogger;
-import com.eactive.eai.common.util.XMLUtils;
-import com.eactive.eai.inbound.action.ActionFactory;
-import com.eactive.eai.inbound.action.RequestAction;
-import com.eactive.eai.inbound.processor.Processor;
-import com.eactive.eai.message.StandardMessage;
-import com.eactive.eai.message.manager.StandardMessageManager;
-import com.eactive.eai.util.QueryStringUtils;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-
-@Service
-public class DJBApiAdapterService extends HttpAdapterServiceSupport {
-	
-	public static final String STD_MESSAGE_KEY = "STD_MESSAGE_KEY";
-	public static final String FINAL_STD_MESSAGE_KEY = "FINAL_STD_MESSAGE_KEY";
-	public static final String API_SERVICE_CODE = "API_SERVICE_CODE";
-	
-	// 응답은 헤더그룹 처리를 위해 readTree() 로 파싱한 뒤 writeValueAsString() 으로 다시
-	// 문자열이 되므로, 이 왕복에서 숫자 자릿수가 유실되지 않는 mapper 를 써야 한다.
-	// 기본 ObjectMapper 는 100000000.00 을 1.0E8 로 바꿔버린다.
-	private static final ObjectMapper OBJECT_MAPPER = JacksonUtil.newNumberSafeMapper();
-
-	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-	static Logger siftLogger = Logger.getLogger(Logger.LOGGER_SIFT);
-
-    public static final String HEADER_GROUP = "HEADER_GROUP";
-	public static final String HTTP_STATUS = "HTTP_STATUS";   // jwhong
-    // HEADER_GROUP JSON에 추가할 항목 정의, 없으면 전체 header 추가
-    public static final String HEADER_KEYS = "HEADER_KEYS";
-    public static final String PROPERTIES_NAME_HTTP_REQUEST_METHOD = "httpRequestMethod";
-
-    public static final String PAYLOAD_PARAM_NAME_CLIENT_ID = "client_id";  // jwhong
-	
-    private ObjectMapper mapper = JacksonUtil.newNumberSafeMapper();
-	
-    public String callApi(HttpServletRequest request, HttpServletResponse response, Properties httpProp,
-			AdapterGroupVO adapterGroupVO, AdapterVO adapterVO, Properties transactionProp) throws Exception {
-        int traceLevel = 0;
-
-        String adptGrpName = adapterGroupVO.getName();
-        String adptName = adapterVO.getName();
-
-        String urlDecodeYn = httpProp.getProperty(URL_DECODE_YN, "N");
-        String encode = StringUtils.defaultIfBlank(adapterGroupVO.getMessageEncode(), "UTF-8");
-
-        String traceLevelTemp = httpProp.getProperty(TRACE_LEVEL, "0");
-        String relayRequestHeaderKeys = httpProp.getProperty(HEADER_KEYS);
-        String headerGroupName = httpProp.getProperty(HEADER_GROUP);
-
-        String message = null;
-
-        String paramValue = null;
-        String adptMsgType = null;
-        
-        Properties inboundHeaderProp = getHeaders(request);
-        transactionProp.put(INBOUND_METHOD, request.getMethod());
-        transactionProp.put(INBOUND_URI, request.getRequestURI());
-        transactionProp.put(INBOUND_QUERY_STRING, StringUtils.defaultString(request.getQueryString()));
-        transactionProp.put(INBOUND_HEADER, inboundHeaderProp);
-		transactionProp.put(INBOUND_EXTPARAMS, StringUtils.defaultString(request.getQueryString()));
-        if (StringUtils.equals(adapterVO.getAdapterGroupVO().getType(), Keys.TYPE_REST)
-                || StringUtils.equals(adapterVO.getAdapterGroupVO().getType(), Keys.TYPE_HTTP_CUSTOM)) {
-            // /api/v1/public/getUserInfo.svc
-            String extUrl = StringUtils.removeStart(request.getRequestURI(), request.getContextPath());
-            transactionProp.put(INBOUND_EXTURI, extUrl);
-        } else {
-            transactionProp.put(INBOUND_EXTURI, getExtUri(request)); 
-        }
-        transactionProp.put(INBOUND_CLIENT_IP, getClientIp(request));  // Client IP 추가
-        transactionProp.put(Processor.REQUEST_ACTION, adapterVO.getAdapterGroupVO().getRefClass());
-        transactionProp.put(API_PATH, httpProp.getProperty(API_PATH, ""));
-        
-        //djerp bypass
-        transactionProp.put(INBOUND_REWRITE_PATH,
-				getRewritePath(transactionProp.getProperty(INBOUND_EXTURI), transactionProp.getProperty(API_PATH)));
-        transactionProp.put(INBOUND_REMOTE_ADDR, request.getRemoteAddr());
-        transactionProp.put(INBOUND_SCHEME, request.getScheme());
-		
-		transactionProp.put(PRE_FILTERS, httpProp.getProperty(PRE_FILTERS, ""));
-        transactionProp.put(POST_FILTERS, httpProp.getProperty(POST_FILTERS, ""));
-        transactionProp.put(PROPERTIES_NAME_HTTP_REQUEST_METHOD, request.getMethod());
-        transactionProp.put(ALLOW_IP, httpProp.getProperty(ALLOW_IP, ""));
-        transactionProp.put("BLOCK_IP", httpProp.getProperty("BLOCK_IP", ""));
-        
-        transactionProp.put(ENC_PATHS, httpProp.getProperty(ENC_PATHS, ""));
-        
-        transactionProp.put(ENCRYPT_ALGORITHM, httpProp.getProperty(ENCRYPT_ALGORITHM, ""));  //jwhong
-        if (inboundHeaderProp.get(HEADER_NAME_CLIENT_ID) != null) {    // jwhong
-        	transactionProp.put(HEADER_NAME_CLIENT_ID, inboundHeaderProp.get(HEADER_NAME_CLIENT_ID));  
-        }
-        transactionProp.put(ENCRYPT_BASE_TYPE, httpProp.getProperty(ENCRYPT_BASE_TYPE, ""));  //jwhong
-//        //transactionProp.put(INBOUND_TOKEN, getHeaders(request).get(INBOUND_TOKEN));  // jwhong
-//        transactionProp.put(INBOUND_TOKEN, getHeaders(request).get(INBOUND_TOKEN) != null ? getHeaders(request).get(INBOUND_TOKEN) : "");  //jwhong , null 이면 default로 "" put
-        String inboundToken = inboundHeaderProp.getOrDefault(INBOUND_TOKEN, "").toString();
-        if (StringUtils.isNotBlank(inboundToken) && StringUtils.startsWith(inboundToken, "Bearer ")) {
-        	inboundToken = inboundToken.substring(7);
-        }
-        transactionProp.put(INBOUND_TOKEN, inboundToken);
-        transactionProp.put(ENCRYPT_AES256_IV, httpProp.getProperty(ENCRYPT_AES256_IV, ""));  //jwhong
-        transactionProp.put(ENCRYPT_AES256_KEY, httpProp.getProperty(ENCRYPT_AES256_KEY, ""));  //jwhong
-        
-        transactionProp.put(AbstractCryptoFilter.PROP_MODULE_NAME, httpProp.getProperty(AbstractCryptoFilter.PROP_MODULE_NAME, ""));
-        
-        transactionProp.put(HEADER_GROUP, headerGroupName);
-        transactionProp.put(HEADER_KEYS, relayRequestHeaderKeys);
-        
-        transactionProp.put(ADAPTER_TOKEN_HEADER_NAME, httpProp.getProperty(ADAPTER_TOKEN_HEADER_NAME, ""));  // OAuth 인증 토큰 헤더 이름
-        transactionProp.put(ADAPTER_APIKEY_HEADER_NAME, httpProp.getProperty(ADAPTER_APIKEY_HEADER_NAME, ""));  // API-KEY 인증 헤더 이름
-        // SEED 컬럼암호하 시  Key로 사용함
-        String seedkey = inboundHeaderProp.getOrDefault("x-obp-partnercode", "").toString();
-        ElinkTransactionContext.setSeedKey(seedkey);
-
-        try {
-            traceLevel = Integer.parseInt(traceLevelTemp);
-        } catch (Exception e) {
-            traceLevel = 0;
-        }
-
-        StopWatch stopWatch = new StopWatch();
-        stopWatch.start();
-
-        logger.debug("시작 >> encode = [" + encode + "]");
-        String recvBody = "";
-        if (request.getContentLength() > 0) {
-			ServletInputStream sis = request.getInputStream();
-			ByteBuffer bb = ByteBuffer.allocate(1024).setAutoExpand(true);
-			int i = 0;
-			byte[] cbuf = new byte[1024];
-			while ((i = sis.read(cbuf, 0, 1024)) != -1) {
-			    if (i == 1024) {
-				bb.put(cbuf);
-			    } else {
-				byte[] tail = new byte[i];
-				System.arraycopy(cbuf, 0, tail, 0, i);
-				bb.put(tail);
-			    }
-			}
-			byte[] data = new byte[bb.position()];
-			bb.position(0);
-			bb.get(data);
-			String bodyEncode = encode;
-			String contentTypeHeader = request.getContentType();
-			if (StringUtils.isNotBlank(contentTypeHeader)) {
-				try {
-					MediaType mediaType = MediaType.parseMediaType(contentTypeHeader);
-					if (mediaType.getCharset() != null) {
-						bodyEncode = mediaType.getCharset().name();
-					}
-				} catch (Exception ignored) {
-				}
-			}
-			recvBody = new String(data, bodyEncode);
-	
-			if (traceLevel >= 3) {
-			    HttpMemoryLogger.txlog(adptGrpName + adptName,
-				    "RECV " + "[" + recvBody + "]" + CommonLib.getDumpMessage(data));
-			}
-	
-			if (logger.isDebug()) {
-			    logger.debug("HttpAdapterServiceRest] RECV (" + adptGrpName + ") = [" + recvBody + "]\n"
-				    + CommonLib.getDumpMessage(data));
-			}
-		}
-		// 순수한 Body값을 저장을 위해 위치 변경.
-		transactionProp.put(INBOUND_REQUEST_MESSAGE, recvBody);
-
-		// 요청 URL 에서 서비스키(STD_MESSAGE_KEY/FINAL_STD_MESSAGE_KEY/API_SERVICE_CODE)를 확정한다.
-		assignApiKeys(adptGrpName, adptName, transactionProp.get(INBOUND_REQUEST_MESSAGE), transactionProp);
-
-		// 확정된 서비스키로 PathVariable 을 추출한다. djerp bypass 의 Outbound URL 치환에도 사용된다.
-		Map<String, String> pathVariables = extractPathVariables(transactionProp.getProperty(STD_MESSAGE_KEY),
-				transactionProp.getProperty(FINAL_STD_MESSAGE_KEY));
-		transactionProp.put(INBOUND_PATH_VARIABLES, pathVariables);
-
-
-        boolean isParameterType = isParameterType(HttpMethodType.getValue(request.getMethod()),
-				request.getContentType());
-		if (isParameterType) {
-			Map<String, String[]> paramMap = assignParameterMap(request, adptGrpName, adptName, recvBody,
-					transactionProp, urlDecodeYn, pathVariables);
-			boolean bUrlDecode = "Y".equals(urlDecodeYn);
-			paramValue = QueryStringUtils.makeJson(paramMap, bUrlDecode);
-
-			if (logger.isDebug()) {
-				logger.debug("HttpAdapterServiceRest] RECV (" + adptGrpName + ") = [" + paramValue + "]");
-			}
-		} else {
-			Map<String, String[]> paramMap = convertArrayStringValue(pathVariables);
-			boolean bUrlDecode = "Y".equals(urlDecodeYn);
-			paramValue = mergeParamsToJsonBody(recvBody, paramMap, bUrlDecode);
-		}
-
-        if (paramValue == null) { // parameter가 없는 경우때문에 처리
-            paramValue = "";
-        }
-        // paramValue가 null이 아닌 빈문자열(""," ")인 경우에 대비하여 조건 수정.
-//        if (StringUtils.isNotBlank(paramValue)) {      // jwhong decrypt
-//        	paramValue = doPreDecryption(paramValue, transactionProp, request);
-//        }
-
-//        if ("Y".equals(urlDecodeYn) && isParameterType) {
-//            message = URLDecoder.decode(paramValue);
-//        } else {
-            message = paramValue;
-//        }
-        
-        TxFileLogger.logTxFile(transactionProp, message, "[IN_RECV]");
-
-        if (logger.isDebug()) {
-            String[] msgArgs = new String[2];
-            msgArgs[0] = adptGrpName;
-            msgArgs[1] = message;
-            String resMsg = ExceptionUtil.make("RICEAIAHA005", msgArgs);
-            logger.debug(resMsg);
-        }
-
-
-        adptMsgType = adapterVO.getAdapterGroupVO().getMessageType();
-        
-        Object reqObject = assignHeaderGroupRequestHeaders(adptGrpName, adptName, message,
-        		transactionProp, request, response, adptMsgType);
-
-        // 위치변경 : 가공되지 않은 Body값을 저장하기 위하여 위쪽으로 이동.
-//        transactionProp.put(INBOUND_REQUEST_MESSAGE, message);
-        
-        Object result = service(adptGrpName, adptName, reqObject, transactionProp, request, response);
-        
-		// bypass만 필요
-        applyOutboundResponseHeaders(transactionProp, response);
-        
-        result = applyHeaderGroupResponseHeaders(adptGrpName, adptName, result, transactionProp, request, response, adptMsgType);
-		
-		if (logger.isDebug()) {
-            logger.debug("HttpAdapterServiceRest] result " + encode + " (" + adptGrpName + ") = [" + result + "]");
-        }
-
-        stopWatch.stop();
-
-        String syncAsyncType = transactionProp.getProperty(INBOUND_SYNC_ASYNC_TYPE);
-        
-        if (!"ASYN".equals(syncAsyncType) && MessageType.JSON.equals(adptMsgType) && StringUtils.isNotBlank(headerGroupName)) {
-        	ObjectNode rootNode = (ObjectNode) JacksonUtil.readTree(result, mapper);
-        	JsonNode headerGroup = rootNode.get(headerGroupName);
-        	if(headerGroup != null) {
-        		for(Iterator<String> it = headerGroup.fieldNames(); it.hasNext();) {
-    				String name = it.next();
-    				String value = headerGroup.get(name).asText();
-    				response.addHeader(name, value);
-        		}
-        		rootNode.remove(headerGroupName);
-        		result = rootNode;
-        	}
-        }
-        
-        String strResult = null;
-        if(result instanceof JsonNode)
-        	strResult = OBJECT_MAPPER.writeValueAsString(result);
-        else
-        	strResult = (String) result;
-        
-        return strResult;
-    }
-
-
-	private Object assignHeaderGroupRequestHeaders(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response, String adptMsgType) throws DocumentException, IOException, Exception {
-		// XML 지원 개발
-		String headerGroupName = prop.getProperty(HEADER_GROUP);
-		String relayRequestHeaderKeys = prop.getProperty(HEADER_KEYS);
-        if(StringUtils.isNotBlank(headerGroupName) && StringUtils.isNotBlank(relayRequestHeaderKeys)) {
-			if (MessageType.JSON.equals(adptMsgType)) {
-				if(message instanceof String && StringUtils.isEmpty((String)message))
-					message = "{}";
-				
-				JsonNode jsonMessageNode = JacksonUtil.readTree(message, mapper);
-				if (jsonMessageNode == null || !jsonMessageNode.isObject()) {
-				    jsonMessageNode = OBJECT_MAPPER.createObjectNode();
-				}
-				ObjectNode jsonNode = (ObjectNode) jsonMessageNode;
-
-				JsonNode childNode = jsonNode.get(headerGroupName);
-				ObjectNode headerJson = (childNode != null && childNode.isObject())
-				        ? (ObjectNode) childNode
-				        : OBJECT_MAPPER.createObjectNode();
-
-				if (StringUtils.equalsIgnoreCase(relayRequestHeaderKeys, "ALL")) {
-				    for (Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements(); ) {
-				        String key = e.nextElement();
-				        headerJson.put(StringUtils.lowerCase(key), request.getHeader(key));
-				    }
-				} else {
-				    String[] relayKeyArr = org.springframework.util.StringUtils
-				            .tokenizeToStringArray(relayRequestHeaderKeys, ",");
-
-				    for (String key : relayKeyArr) {
-				        String headerValue = request.getHeader(key);
-				        if (StringUtils.isNotBlank(headerValue)) {
-				            headerJson.put(StringUtils.lowerCase(key), headerValue);
-				        }
-				    }
-				}
-
-				if (!headerJson.isEmpty()) {
-				    jsonNode.set(headerGroupName, headerJson);
-				    message = jsonNode;
-				}
-			} else if(MessageType.XML.equals(adptMsgType)) {
-            	Document document = XMLUtils.convertXmlDocument(message);
-            	if(document != null) {
-            		Element rootElement = document.getRootElement();
-            		Element headerElement = rootElement.element(headerGroupName);
-            		if(headerElement == null)
-            			headerElement = DocumentHelper.createElement(headerGroupName);
-            		
-            		boolean hasHeaderValues = false;
-            		 if (StringUtils.equalsIgnoreCase(relayRequestHeaderKeys, "ALL")) {
-                         for (Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements(); ) {
-                             String key = e.nextElement();
-                             String value = request.getHeader(key);
-                             /*
-                              *  IBK 표준안에 따라 <{key}>{value}</{key}> 형태로 저장, KEY 는 소문자로 변경한다
-                              *  대상 사이트의 표준안에 따라 작성 할 것
-                              *  
-                              *  HTTP 헤더 변환 예시
-                              *  
-                              *  일반적인 HTTP 헤더 변환 예시:
-                              *  Content-Type: application/json
-                              *  X-Forwarded-For: 10.0.0.1
-                              *  
-                              *  <root>
-                              *  	<data> original content </data>
-                              *  	<httpHeaderGroup>
-                              *  		<content-type>application/json</content-type>
-                              *  		<x-forwarded-for>10.0.0.1</x-forwarded-for>
-                              *  	</httpHeaderGroup>
-                              *  </root>
-                              */
-                             if(StringUtils.isNotBlank(value)) {
-                            	 Element headerItem = headerElement.addElement(key);
-                            	 headerItem.setText(value);
-                            	 hasHeaderValues = true;
-                             }
-                         }
-                     } else {
-                         String[] relayKeyArr = org.springframework.util.StringUtils
-                                 .tokenizeToStringArray(relayRequestHeaderKeys, ",");
-
-                         for (String key : relayKeyArr) {
-                             String headerValue = request.getHeader(key);
-                             if (StringUtils.isNotBlank(headerValue)) {
-                                 String value = request.getHeader(key);
-                                 String keyName = StringUtils.lowerCase(key);
-                            	 Element headerItem = headerElement.addElement(keyName);
-                            	 headerItem.setText(value);
-                            	 hasHeaderValues = true;
-                             }
-                         }
-                     }
-            		 
-                     if (hasHeaderValues) {
-                    	 rootElement.add(headerElement);
-                    	 OutputFormat format = OutputFormat.createPrettyPrint();
-                    	 StringWriter writer = new StringWriter();
-                    	 XMLWriter xmlWriter = new XMLWriter(writer, format);
-                    	 xmlWriter.write(document);
-                         message = writer.toString();
-                     }
-            	}
-            }
-		}
-        if (message == null) {
-            message = "";
-        } // XML 지원 개발
-		return message;
-	}
-    
-    
-    /**
-     * HttpClientAdapterServiceBypass.assignRelayDataToInbound() 에서
-     * transactionProp에 저장한 OUTBOUND_RESPONSE_HEADERS를 response에 적용한다.
-     */
-    @SuppressWarnings("unchecked")
-    private void applyOutboundResponseHeaders(Properties transactionProp, HttpServletResponse response) {
-        Map<String, Object> outboundPropertyMap = (Map<String, Object>) transactionProp.get(OUTBOUND_PROPERTY_MAP);
-        if (outboundPropertyMap == null) {
-            return;
-        }
-        Properties headerProp = (Properties) outboundPropertyMap.get(OUTBOUND_RESPONSE_HEADERS);
-        if (headerProp == null) {
-            return;
-        }
-
-        String[] hopByHopHeaders = { "Connection", "Keep-Alive", "Proxy-Authenticate", "Proxy-Authorization",
-                "TE", "Trailers", "Transfer-Encoding", "Upgrade" };
-
-        for (Map.Entry<Object, Object> entry : headerProp.entrySet()) {
-            String key = (String) entry.getKey();
-            String value = (String) entry.getValue();
-
-            if (StringUtils.equalsAnyIgnoreCase(key, hopByHopHeaders)) {
-                continue;
-            }
-            if (StringUtils.equalsIgnoreCase(key, HttpHeaders.CONTENT_LENGTH)) {
-                continue;
-            }
-            if (StringUtils.equalsIgnoreCase(key, HTTP_STATUS)) {
-                if (StringUtils.isNotBlank(value)) {
-                    try {
-                        response.setStatus(Integer.parseInt(value));
-                    } catch (NumberFormatException ex) {
-                        // ignore
-                    }
-                }
-                continue;
-            }
-            response.addHeader(key, value);
-        }
-    }
-
-    private Object applyHeaderGroupResponseHeaders(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response, String adptMsgType) throws Exception {
-		// body headergroup -> http header 세팅
-		String headerGroupName = prop.getProperty(HEADER_GROUP);
-        
-        if (StringUtils.isNotBlank(headerGroupName)) {
-			if (resultMessage instanceof Node) {
-				adptMsgType = MessageType.XML;
-			} else if (resultMessage instanceof String) {
-				String strMessage = (String) resultMessage;
-				if (StringUtils.startsWith(strMessage, "<")) {
-					adptMsgType = MessageType.XML;
-				}
-			} else if (resultMessage instanceof byte[]) {
-				String strMessage = new String((byte[]) resultMessage);
-				if (StringUtils.startsWith(strMessage, "<")) {
-					adptMsgType = MessageType.XML;
-				}
-			}
-
-			if (MessageType.JSON.equals(adptMsgType)) {
-				JsonNode jsonNode = JacksonUtil.readTree(resultMessage, OBJECT_MAPPER); // 또는
-																						// objectMapper.readTree(resultMessage)
-				JsonNode headerGroup = jsonNode.get(headerGroupName);
-
-				if (headerGroup != null && !headerGroup.isNull()) {
-					Iterator<Map.Entry<String, JsonNode>> fieldIterator = headerGroup.fields();
-
-					while (fieldIterator.hasNext()) {
-						Map.Entry<String, JsonNode> fieldEntry = fieldIterator.next();
-						JsonNode valueNode = fieldEntry.getValue();
-
-						logger.info("header group entry : {} , {}", fieldEntry.getKey(), valueNode);
-
-						if (valueNode.isTextual()) {
-							String value = valueNode.asText();
-
-							if (StringUtils.equalsIgnoreCase(fieldEntry.getKey(), "content-type")) {
-								logger.debug("set content-type {}: {}", fieldEntry.getKey(), value);
-								response.setContentType(value);
-							} else if (StringUtils.equalsIgnoreCase(fieldEntry.getKey(), HttpHeaders.CONTENT_LENGTH)) {
-								logger.debug("skip content-length {}: {}", fieldEntry.getKey(), value);
-								continue;
-				            } else {
-								logger.debug("add header {}: {}", fieldEntry.getKey(), value);
-								response.addHeader(fieldEntry.getKey(), value);
-							}
-						} else {
-							logger.info("fieldEntry value is not String. {}", valueNode);
-						}
-					}
-				} else {
-					logger.info("headerGroup is null");
-				}
-
-				((ObjectNode) jsonNode).remove(headerGroupName);
-				return jsonNode;
-        	} else if(MessageType.XML.equals(adptMsgType)) {
-        		Document document = XMLUtils.convertXmlDocument(resultMessage);
-            	if(document != null) {
-            		Element rootElement = document.getRootElement();            		
-            		Element headerGroupElement = rootElement.element(headerGroupName);
-            		
-            		if(headerGroupElement != null) {
-            			//헤더그룹의 모든 하위 엘리먼트를 HTTP 응답 헤더로 설정
-            			for(Iterator<Element> it = headerGroupElement.elementIterator(); it.hasNext();) {
-            				Element headerElement = it.next();
-            				String name = headerElement.getName();
-            				String value = headerElement.getTextTrim();
-
-            				if(StringUtils.isNoneBlank(value)) {
-            					if(StringUtils.equalsIgnoreCase(name, "content-type")) {
-            						logger.debug("set content-type {}: {}", name, value);
-    								response.setContentType(value);
-            					} else if(StringUtils.equalsIgnoreCase(name, "content-length")) {
-            						logger.debug("skip content-length {}: {}", name, value);
-    								continue;
-            					} else {
-            						logger.debug("add header {}: {}", name, value);
-            						response.addHeader(name, value);
-            					}
-            				} else {
-    							logger.info("value is not String. {}", value);
-    						}
-            			}
-            		} else {
-            			logger.info("headerGroup is null");
-            		}
-            		
-            		// 헤더그룹 삭제
-            		rootElement.remove(headerGroupElement);
-            		
-            		return document.asXML();
-            	}
-        	}
-		} else {
-			logger.info("headerGroupName is blank");
-		}
-			
-		return (String)resultMessage;
-	}
-	
-	public static boolean isParameterType(HttpMethodType method, String contentType) {
-		boolean isParameterType = true;
-		switch (method) {
-		case GET:
-		case DELETE:
-			isParameterType = true;
-			break;
-		case POST:
-		case PUT:
-		case PATCH:
-				if (StringUtils.contains(contentType, "application/x-www-form-urlencoded")) {
-				isParameterType = true;
-			} else {
-				isParameterType = false;
-			}
-			break;
-		default:
-			break;
-		}
-		return isParameterType;
-	}
-	
-	private Map<String, String[]> assignParameterMap(HttpServletRequest request, String adptGrpName, String adptName,
-			Object reqMessage, Properties prop, String urlDecode, Map<String, String> variablesMap) throws UnsupportedEncodingException {
-		Map<String, String[]> pathMap = convertArrayStringValue(variablesMap);
-		
-		// param encoding 추가
-		String encoding = null;
-		String reqContentType = request.getContentType();
-		try {
-			ContentType oContentType = ContentType.parse(reqContentType);
-			if (oContentType != null && oContentType.getCharset() != null)
-				encoding = oContentType.getCharset().displayName();
-		} catch (Exception e) {
-			// 지원하지 않는 charset(UnsupportedCharsetException)이 헤더로 들어와도 500 이 나가지 않도록 한다.
-			logger.warn("HttpAdapterServiceRest] invalid Content-Type charset. [" + reqContentType + "]");
-		}
-
-		boolean bUrlDecode = StringUtils.equalsIgnoreCase(urlDecode, "Y");
-		if (encoding == null) {
-			// Content-Type 에 charset 이 없을 때(GET 등)의 기본값은 처리 경로에 따라 다르다.
-			// - %인코딩 복원(URLDecoder) : HTML5/WHATWG 표준이 UTF-8 이므로 UTF-8.
-			//   ISO-8859-1 로 복원하면 %ED%95%9C%EA%B8%80 이 'í•œê¸€' 로 깨진다.
-			// - 그 외 : 컨테이너가 디코딩한 문자열의 원본 바이트를 되찾는 용도(byte latch)이므로
-			//   기존 동작인 ISO-8859-1 을 유지한다.
-			encoding = bUrlDecode ? StandardCharsets.UTF_8.name() : "ISO-8859-1";
-		}
-
-		// POST 방식의 form data
-		if (reqMessage instanceof String) {
-			String formData = (String) reqMessage;
-			Map<String, String[]> formDataParamMap = QueryStringUtils.parseQueryString(formData, encoding, bUrlDecode);
-			pathMap.putAll(formDataParamMap);
-		}
-
-		// GET 방식의 query string
-		String queryString = request.getQueryString();
-		Map<String, String[]> paramMap = QueryStringUtils.parseQueryString(queryString, encoding, bUrlDecode);
-		pathMap.putAll(paramMap);
-
-		return pathMap;
-	}
-
-
-	private Map<String, String[]> convertArrayStringValue(Map<String, String> variablesMap) {
-		Map<String, String[]> pathMap = new HashMap<>();
-		
-		for (String key : variablesMap.keySet()) {
-			if (StringUtils.equalsIgnoreCase(key, "method")) {
-				continue;
-			}
-			pathMap.put(key, new String[] { variablesMap.get(key) });
-		}
-		return pathMap;
-	}
-
-
-	/**
-	 * JSON Body 요청에 PathVariable(및 추가 파라미터)을 병합한다.
-	 *
-	 * <ul>
-	 * <li>추가할 파라미터가 없으면 Body 를 그대로 반환한다.</li>
-	 * <li>Body 가 비어있으면 파라미터만으로 JSON 오브젝트를 만든다.</li>
-	 * <li>Body 가 JSON 오브젝트({...})면 항목을 추가한다. 빈 오브젝트({})도 유효한 JSON 으로 병합한다.</li>
-	 * <li>XML / JSON 배열 등 오브젝트가 아닌 Body 는 훼손하지 않고 그대로 반환한다.
-	 * (PathVariable 은 INBOUND_PATH_VARIABLES 로 Outbound 에 전달된다)</li>
-	 * </ul>
-	 */
-	private String mergeParamsToJsonBody(String body, Map<String, String[]> paramMap, boolean bUrlDecode)
-			throws UnsupportedEncodingException {
-		if (paramMap == null || paramMap.isEmpty()) {
-			return body;
-		}
-
-		StringBuilder addJson = new StringBuilder();
-		for (Entry<String, String[]> entry : paramMap.entrySet()) {
-			if (addJson.length() > 0)
-				addJson.append(",");
-
-			addJson.append("\"").append(JSONValue.escape(entry.getKey())).append("\":");
-
-			String[] values = entry.getValue();
-			if (values.length > 1) {
-				addJson.append("[");
-				for (int j = 0; j < values.length; j++) {
-					if (j > 0) {
-						addJson.append(",");
-					}
-					addJson.append("\"").append(JSONValue.escape(decodeParamValue(values[j], bUrlDecode))).append("\"");
-				}
-				addJson.append("]");
-			} else {
-				addJson.append("\"").append(JSONValue.escape(decodeParamValue(values[0], bUrlDecode))).append("\"");
-			}
-		}
-
-		String trimmedBody = StringUtils.trimToEmpty(body);
-		if (trimmedBody.isEmpty()) {
-			return "{" + addJson + "}";
-		}
-
-		if (!StringUtils.startsWith(trimmedBody, "{") || !StringUtils.endsWith(trimmedBody, "}")) {
-			// JSON 오브젝트가 아니면 Body 를 덮어쓰지 않는다.
-			logger.warn("HttpAdapterServiceRest] body is not a JSON object. skip pathVariable merge.");
-			return body;
-		}
-
-		String innerBody = StringUtils.substring(trimmedBody, 1, trimmedBody.length() - 1);
-		String mergedJson;
-		if (StringUtils.isBlank(innerBody)) {
-			mergedJson = "{" + addJson + "}";
-		} else {
-			mergedJson = "{" + innerBody + "," + addJson + "}";
-		}
-		logger.debug("HttpAdapterServiceRest] add pathVariable : JSON =[" + mergedJson + "] ");
-		return mergedJson;
-	}
-
-	private String decodeParamValue(String value, boolean bUrlDecode) throws UnsupportedEncodingException {
-		return bUrlDecode ? URLDecoder.decode(value, StandardCharsets.UTF_8.name()) : value;
-	}
-    
-    private String getRewritePath(String extUri, String basePath) {
-		return StringUtils.removeStart(extUri, StringUtils.removeEnd(basePath, "/"));
-	}
-    
-	/**
-	 * 요청 URL 로부터 서비스키를 확정해 tx prop 에 세팅한다.
-	 * (기존 {@link ApiKeyExtractFilter#doPreFilter} 가 하던 일)
-	 *
-	 * <ul>
-	 * <li>{@code STD_MESSAGE_KEY} : Action 이 만들어낸 요청 경로 (ex. {@code GET/api/v1/users/123})</li>
-	 * <li>{@code FINAL_STD_MESSAGE_KEY} : 등록된 서비스키 (ex. {@code GET/api/v1/users/{userId}})</li>
-	 * <li>{@code API_SERVICE_CODE} : 서비스키에 매핑된 EAI 서비스 코드</li>
-	 * </ul>
-	 *
-	 * <p>기존에는 이 필터와 PathVariable 추출이 각각 Action 을 생성해 {@code perform()} 을 호출하고
-	 * 서비스키 매칭까지 중복 수행했다. Action 호출은 요청 1건당 한 번이면 충분하므로 여기서만 수행하고,
-	 * PathVariable 추출은 여기서 확정한 서비스키를 {@link #extractPathVariables(String, String)} 에
-	 * 넘겨 처리한다.
-	 */
-	private void assignApiKeys(String adptGrpName, String adptName, Object reqMessage, Properties prop)
-			throws Exception {
-		String actionName = prop.getProperty(Processor.REQUEST_ACTION);
-		RequestAction action = ActionFactory.createAction(actionName);
-		action.setAdapterInfo(adptGrpName, adptName, prop);
-		String[] keys = action.perform(reqMessage);
-		String requestPath = keys[0];
-
-		prop.setProperty(STD_MESSAGE_KEY, requestPath); // action class 통해서 생성
-
-		// PathVariable 지원 추가
-		// ex) /api/bank/account/12345 --> /api/bank/account/{accountNo}
-		String ruledPath = ApiKeyExtractFilter.getMatchedKey(requestPath);
-		if (StringUtils.isBlank(ruledPath)) {
-			throw new FilterException("path not found - " + requestPath, HttpAdapterFilter.ERROR_PRE_FAIL,
-					HttpStatus.FORBIDDEN.value());
-		}
-		prop.setProperty(FINAL_STD_MESSAGE_KEY, ruledPath);
-
-		String apiSvcCode = getEaiSvcCode(ruledPath);
-		if (StringUtils.isBlank(apiSvcCode)) {
-			// Properties 는 null 값을 허용하지 않아 그대로 put 하면 NPE 로 500 이 나간다.
-			logger.warn("HttpAdapterServiceRest] eaiSvcCode not found. apiId=[" + ruledPath + "]");
-		}
-		prop.put(API_SERVICE_CODE, StringUtils.defaultString(apiSvcCode));
-	}
-
-	private String getEaiSvcCode(String apiId) {
-		StandardMessage standardMessage = STDMessageManager.getInstance().getSTDMessage(apiId);
-		return StandardMessageManager.getInstance().getMapper().getEaiSvcCode(standardMessage);
-	}
-
-	/**
-	 * 요청 경로와 매칭된 서비스키를 비교해 PathVariable 을 추출한다.
-	 * ex) {@code GET/api/v1/users/123} + {@code GET/api/v1/users/{userId}} → {@code {userId=123}}
-	 *
-	 * <p>QueryString 유무와 무관하게 추출한다. Outbound(HttpClient5AdapterServiceRest/Bypass)의
-	 * URL 치환에 사용되므로 QueryString 이 있다고 건너뛰면 치환이 불가하거나 NPE 가 발생한다.
-	 *
-	 * @param requestPath 실제 요청 경로 ({@code STD_MESSAGE_KEY})
-	 * @param ruledPath 매칭된 서비스키 ({@code FINAL_STD_MESSAGE_KEY})
-	 * @return PathVariable Map. 없으면 빈 Map (null 아님)
-	 */
-	private Map<String, String> extractPathVariables(String requestPath, String ruledPath) {
-		Map<String, String> pathMap = new HashMap<>();
-
-		if (StringUtils.equals(requestPath, ruledPath) || !StringUtils.contains(ruledPath, "{")) {
-			return pathMap;
-		}
-
-		Map<String, String> variablesMap = new AntPathMatcher().extractUriTemplateVariables(ruledPath, requestPath);
-		if (variablesMap == null) {
-			return pathMap;
-		}
-
-		for (Entry<String, String> entry : variablesMap.entrySet()) {
-			// {method} 는 서비스키를 구성하는 요소일 뿐 업무 파라미터가 아니다.
-			if (StringUtils.equalsIgnoreCase(entry.getKey(), "method")) {
-				continue;
-			}
-			pathMap.put(entry.getKey(), entry.getValue());
-		}
-		return pathMap;
-	}
-	
-    private Properties getHeaders(HttpServletRequest request) {
-        Properties prop = new Properties();
-
-        Enumeration<String> headerNames = request.getHeaderNames();
-        while (headerNames.hasMoreElements()) {
-            String key = headerNames.nextElement();
-            // 동일 이름의 헤더가 여러 개인 경우 콤마로 합침 (RFC 7230)
-            Enumeration<String> values = request.getHeaders(key);
-            StringBuilder sb = new StringBuilder();
-            while (values.hasMoreElements()) {
-                if (sb.length() > 0) sb.append(", ");
-                sb.append(values.nextElement());
-            }
-            prop.setProperty(key.toLowerCase(), sb.toString());
-        }
-
-        return prop;
-    }
-
-    private String getExtUri(HttpServletRequest request) {
-        String orgUri = request.getRequestURI().replaceAll(request.getContextPath(), "");
-        String uri = getExtUri(orgUri, 3);
-        if (uri != null && uri.trim().length() > 0) {
-            return "/" + uri;
-        } else {
-            return "";
-        }
-    }
-
-    private static String getExtUri(String url, int length) {
-        String[] urls = url.split("/");
-        List<String> newUrls = new ArrayList<>();
-        Collections.addAll(newUrls, urls);
-        return StringUtils.join(newUrls.subList(length, urls.length).toArray(), "/");
-    }
-
-    @Override
-    @Deprecated
-    public void service(String adptGrpName, String adptName, HttpServletRequest request, HttpServletResponse response) {
-
-    }
-
-    /**
-     * HTTP 요청에서 클라이언트 IP를 추출합니다.
-     * X-Forwarded-For 헤더가 있는 경우 이를 우선적으로 사용하고,
-     * 없는 경우 remoteAddr을 사용합니다.
-     */
-    private String getClientIp(HttpServletRequest request) {
-        String ipAddress = request.getHeader("X-Forwarded-For");
-        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
-            ipAddress = request.getHeader("Proxy-Client-IP");
-        }
-        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
-            ipAddress = request.getHeader("WL-Proxy-Client-IP");
-        }
-        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
-            ipAddress = request.getHeader("HTTP_CLIENT_IP");
-        }
-        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
-            ipAddress = request.getHeader("HTTP_X_FORWARDED_FOR");
-        }
-        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
-            ipAddress = request.getRemoteAddr();
-        }
-        return ipAddress;
-    }
-    
-}
@@ -1,60 +0,0 @@
-package com.eactive.eai.agent.inflow;
-
-import com.eactive.eai.agent.command.Command;
-import com.eactive.eai.agent.command.CommandException;
-import com.eactive.eai.common.inflow.AbstractInflowControlManager;
-import com.eactive.eai.common.inflow.InflowControlUtil;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.custom.inflow.ClientDualInflowControlManager;
-
-public class ReloadInflowClientControlCommand extends Command {
-
-	private static final long serialVersionUID = 1L;
-
-	public ReloadInflowClientControlCommand() {
-		super("ReloadInflowClientControlCommand");
-	}
-
-	public Object execute() throws CommandException {
-		Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
-		if (logger.isInfo())
-			logger.info(this.name + " is executed");
-
-		if (!(args instanceof String)) {
-			String rspErrorCode = "RECEAIMCM001";
-			String msg = makeException(rspErrorCode, null);
-			if (logger.isError())
-				logger.error(msg);
-			throw new CommandException(msg);
-		}
-
-		String keyName = (String) args;
-		try {
-			AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
-			if (!(base instanceof ClientDualInflowControlManager)) {
-				throw new IllegalStateException("ClientDualInflowControlManager 가 활성화되지 않았습니다.");
-			}
-			ClientDualInflowControlManager manager = (ClientDualInflowControlManager) base;
-
-			if (keyName != null) {
-				if ("ALL".equals(keyName)) {
-					manager.reloadClient();
-					if (logger.isWarn())
-						logger.warn(this.name + "] all rule Reload.");
-				} else {
-					manager.reloadClient(keyName);
-					if (logger.isWarn())
-						logger.warn(this.name + "] " + keyName + " Reload.");
-				}
-			}
-
-		} catch (Exception e) {
-			String rspErrorCode = "RECEAIMCM002";
-			String msg = makeException(rspErrorCode, e);
-			if (logger.isError())
-				logger.error(msg, e);
-			throw new CommandException(msg);
-		}
-		return "success";
-	}
-}
@@ -1,50 +0,0 @@
-package com.eactive.eai.agent.inflow;
-
-import com.eactive.eai.agent.command.Command;
-import com.eactive.eai.agent.command.CommandException;
-import com.eactive.eai.common.inflow.AbstractInflowControlManager;
-import com.eactive.eai.common.inflow.InflowControlUtil;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.custom.inflow.ClientDualInflowControlManager;
-
-public class RemoveInflowClientControlCommand extends Command {
-
-	private static final long serialVersionUID = 1L;
-
-	public RemoveInflowClientControlCommand() {
-		super("RemoveInflowClientControlCommand");
-	}
-
-	public Object execute() throws CommandException {
-		Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
-		if (logger.isInfo())
-			logger.info(this.name + " is executed");
-
-		if (!(args instanceof String)) {
-			String rspErrorCode = "RECEAIMCM001";
-			String msg = makeException(rspErrorCode, null);
-			if (logger.isError())
-				logger.error(msg);
-			throw new CommandException(msg);
-		}
-
-		String key = (String) args;
-		try {
-			AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
-			if (!(base instanceof ClientDualInflowControlManager)) {
-				throw new IllegalStateException("ClientDualInflowControlManager 가 활성화되지 않았습니다.");
-			}
-			ClientDualInflowControlManager manager = (ClientDualInflowControlManager) base;
-			manager.removeClient(key);
-			if (logger.isWarn())
-				logger.warn(this.name + "] " + key + " removed.");
-		} catch (Exception e) {
-			String rspErrorCode = "RECEAIMCM002";
-			String msg = makeException(rspErrorCode, e);
-			if (logger.isError())
-				logger.error(msg, e);
-			throw new CommandException(msg);
-		}
-		return "success";
-	}
-}
@@ -1,8 +1,6 @@
 package com.eactive.eai.authserver.config;

 import java.security.KeyPair;
-import java.security.interfaces.RSAPrivateKey;
-import java.security.interfaces.RSAPublicKey;
 import java.time.LocalDateTime;
 import java.util.Arrays;

@@ -36,9 +34,7 @@ import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenCo
 import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
 import org.springframework.security.oauth2.provider.token.store.KeyStoreKeyFactory;

-import com.eactive.eai.agent.encryption.EncryptionManager;
 import com.eactive.eai.authserver.dao.TokenIssuanceLogDAO;
-import com.eactive.eai.authserver.jwt.PssJwtAccessTokenConverter;
 import com.eactive.eai.authserver.service.OAuth2Manager;
 import com.eactive.eai.authserver.vo.ClientVO;
 import com.eactive.eai.common.dao.DAOException;
@@ -132,11 +128,10 @@ public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdap
 		String keyAlias = "elink-oauth";
 		String keyPassword = "elink1234";
 		if (vo != null) {
-			EncryptionManager encManager = EncryptionManager.getInstance();
-			keystorePath = encManager.decryptDBData(vo.getProperty(PROP_KEYSTORE_PATH));
-			keystorePassword = encManager.decryptDBData(vo.getProperty(PROP_KEYSTORE_PW));
-			keyAlias = encManager.decryptDBData(vo.getProperty(PROP_KEY_ALIAS));
-			keyPassword = encManager.decryptDBData(vo.getProperty(PROP_KEY_PW));
+			keystorePath = vo.getProperty(PROP_KEYSTORE_PATH);
+			keystorePassword = vo.getProperty(PROP_KEYSTORE_PW);
+			keyAlias = vo.getProperty(PROP_KEY_ALIAS);
+			keyPassword = vo.getProperty(PROP_KEY_PW);
 		} else {
 			logger.warn("The properties has not been set.[" + PROP_GROUP_AUTH_SERVER + "]");
 		}
@@ -144,10 +139,9 @@ public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdap
 		Resource keystore = new ClassPathResource(keystorePath);
 		KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(keystore, keystorePassword.toCharArray());
 		KeyPair keyPair = keyStoreKeyFactory.getKeyPair(keyAlias, keyPassword.toCharArray());
-		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
-		RSAPublicKey  publicKey  = (RSAPublicKey)  keyPair.getPublic();
-
-		return new PssJwtAccessTokenConverter(privateKey, publicKey);
+		JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
+		converter.setKeyPair(keyPair);
+		return converter;
 	}

 	
@@ -62,7 +62,7 @@ public class WebMvcConfig {
        request.setAttribute("_authServerStatusCode", HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        String detailMessage =  ex.getMessage();
        if ( StringUtils.isBlank(detailMessage) ) {
-        	detailMessage = "API 관리자에게 문의하세요.";
+        	detailMessage = "광주은행 관리자에게 문의하세요.";
        }
        request.setAttribute("errorMessage", detailMessage);
        return "forward:/error.jsp";
@@ -0,0 +1,200 @@
+package com.eactive.eai.authserver.custom;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang3.StringUtils;
+import org.json.simple.JSONObject;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.oauth2.provider.ClientDetails;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.authserver.config.RequestContextData;
+import com.eactive.eai.authserver.dao.TokenIssuanceLogDAO;
+import com.eactive.eai.authserver.service.BearerTokenService;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.authserver.vo.ClientVO;
+import com.eactive.eai.common.logger.EAIDBLogControl;
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.common.util.MessageUtil;
+import com.eactive.eai.data.entity.onl.authserver.TokenIssuanceLog;
+
+@RestController
+@RequestMapping("/auth/oauth/v2")
+public class BearerTokenController {
+
+	public static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
+    private final BearerTokenService tokenService;
+    
+    @Autowired
+	private TokenIssuanceLogDAO tokenIssuanceLogDAO;
+
+    public BearerTokenController(BearerTokenService tokenService) {
+        this.tokenService = tokenService;
+    }
+
+    @RequestMapping(
+    	    value = "/token",
+    	    method = {RequestMethod.POST, RequestMethod.GET}
+    )
+    public ResponseEntity<?> issueCAToken(HttpServletRequest request, @RequestParam MultiValueMap<String, String> req) throws JwtAuthException {
+		JSONObject resObject = new JSONObject();
+        String clientId = req.getFirst("client_id");
+        String grantType = req.getFirst("grant_type");
+        String clientSecret = req.getFirst("client_secret");
+		String scopes = req.getFirst("scope");
+		
+		try {
+
+			
+			RequestContextData data = new RequestContextData();
+			data.setClientId(request.getParameter("client_id"));
+			data.setIpAddress(extractIpAddress(request));
+			data.setGrantType(request.getParameter("grant_type"));
+			data.setScope(request.getParameter("scope"));
+			data.setUsername(request.getParameter("username"));
+			data.setResource(request.getParameter("resource"));
+			
+			RequestContextData.ThreadLocalRequestContext.set(data);
+			
+			
+			
+	        if (!StringUtils.equals(grantType, "client_credentials") ) {
+				throw new JwtAuthException("unsupported_grant_type", "Unsupported grant type");
+	        }
+	        
+			ClientDetails clientDetails = OAuth2Manager.getInstance().getClientDeatilsStore().get(clientId);
+			if (clientDetails == null) {
+				throw new JwtAuthException("invalid_client", "Bad client credentials(not found)");
+			}
+
+			String tokenType = "Bearer";
+			
+			
+			
+			
+			Long expiresIn = Long.valueOf(clientDetails.getAccessTokenValiditySeconds());
+
+			String[] reqScopeArr = org.springframework.util.StringUtils.tokenizeToStringArray(scopes, " ");
+			Set<String> scopeSet = new HashSet<String>();
+			for (String scope : reqScopeArr) {
+				scopeSet.add(scope);
+			}
+			veryfyClient(clientDetails, clientSecret, scopeSet);
+			
+	        String token = tokenService.generateCAToken(clientId, expiresIn, scopeSet);
+	        
+	        Map<String, Object> tokenMap = new HashMap<>();
+	        tokenMap.put("token_type", tokenType);
+	        tokenMap.put("access_token", token);
+	        tokenMap.put("expires_in", expiresIn);
+	        tokenMap.put("scope", scopes);
+	        // ... and so on for all key-value pairs
+	        resObject.putAll(tokenMap);
+	        
+	        logTokenIssuance(true,false, resObject.toJSONString(), token);
+
+	        return ResponseEntity.ok(resObject);
+		} catch (JwtAuthException e) {
+			logger.error("Token request[/auth/oauth/v2/token] => clientId: {}, grantType: {}, scope: {}", 
+		            clientId, grantType, scopes);
+			logger.error(e);
+			String errorJson = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_AUTH_FAIL, e.getMessage());
+			logTokenIssuance(false ,false, e.getMessage(), null);
+			return ResponseEntity.status(401).body(errorJson);
+		} catch (Exception e) {
+			logger.error("Token request[/auth/oauth/v2/token] => clientId: {}, grantType: {}, scope: {}", 
+		            clientId, grantType, scopes);
+			logger.error(e);
+			String errorJson = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_AP_ERROR, e.getMessage());
+			logTokenIssuance(false ,false, e.getMessage(), null);
+			return ResponseEntity.status(500).body(errorJson);
+		}finally {
+			RequestContextData.ThreadLocalRequestContext.clear();
+		}
+    }
+    
+    private String extractIpAddress(HttpServletRequest request) {
+		String ipAddress = request.getHeader("X-Forwarded-For");
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("Proxy-Client-IP");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("WL-Proxy-Client-IP");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("HTTP_CLIENT_IP");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("HTTP_X_FORWARDED_FOR");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getRemoteAddr();
+		}
+		return ipAddress;
+	}
+    
+    private void logTokenIssuance(boolean isSuccess, boolean isRestrictionExempt, String resultMessage, String accessToken) {
+		try {
+			if (!EAIDBLogControl.isEnable()) {
+				logger.warn("DB logging is disabled. Skipping token issuance logging.");
+				return;
+			}
+			RequestContextData data = RequestContextData.ThreadLocalRequestContext.get();
+			OAuth2Manager.getInstance();
+
+			TokenIssuanceLog log = new TokenIssuanceLog();
+			String clientId = data.getClientId();
+			log.setClientId(clientId);
+
+			if(StringUtils.isNotBlank(clientId)) {
+				ClientVO clientVO = OAuth2Manager.getInstance().getClientInfo(clientId);
+				log.setAppName(clientVO.getClientName());
+				log.setOrgId(clientVO.getOrgId());
+				log.setOrgName(clientVO.getOrgName());
+			}
+
+			log.setGrantType(data.getGrantType());
+			log.setScope(data.getScope());
+			log.setIpAddress(data.getIpAddress());
+			log.setSuccessYn(isSuccess ? "Y" : "N");
+			log.setIssuanceDateTime(LocalDateTime.now());
+			log.setRestrictionExemptYn(isRestrictionExempt ? "Y" : "N");
+			log.setResultMessage(resultMessage);
+			log.setAccessToken(accessToken); // Add access token value to the log
+
+			tokenIssuanceLogDAO.saveTokenIssuanceLog(log);
+		} catch (Throwable th) {
+			logger.error("Error while logging token issuance: " + th.getMessage(), th);
+		}
+	}
+
+	private void veryfyClient(ClientDetails clientDetails, String clientSecret, Set<String> scopeSet) throws JwtAuthException {
+		if (!StringUtils.equals(clientDetails.getClientSecret(), clientSecret)) {
+			throw new JwtAuthException("invalid_client", "Bad client credentials(client_secret is empty or not match)");
+		}
+
+		if (scopeSet.isEmpty()) {
+			throw new JwtAuthException("invalid_client", "Bad client credentials(Scope is empty)");
+		}
+
+		if (!clientDetails.getScope().containsAll(scopeSet)) {
+			throw new JwtAuthException("invalid_client", "Bad client credentials(Include unacceptable scope)");
+		}
+	}
+}
+
@@ -1,79 +0,0 @@
-package com.eactive.eai.authserver.custom;
-
-import java.io.Serializable;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonPropertyOrder;
-import com.fasterxml.jackson.annotation.JsonInclude.Include;
-
-@SuppressWarnings("serial")
-@JsonInclude(Include.NON_NULL)
-@JsonPropertyOrder({ "access_token", "token_type", "expires_in", "scope", "jti", "client_id" })
-public class DJBOAuth2AccessTokenResponse implements Serializable {
-
-	@JsonProperty("access_token")
-	private String accessToken;
-	@JsonProperty("token_type")
-	private String tokenType;
-	@JsonProperty("expires_in")
-	private Long expiresIn;
-	private String scope;
-	private String jti;
-	@JsonProperty("client_id")
-	private String clientId;
-
-	public String getAccessToken() {
-		return accessToken;
-	}
-
-	public void setAccessToken(String accessToken) {
-		this.accessToken = accessToken;
-	}
-
-	public String getTokenType() {
-		return tokenType;
-	}
-
-	public void setTokenType(String tokenType) {
-		this.tokenType = tokenType;
-	}
-
-	public Long getExpiresIn() {
-		return expiresIn;
-	}
-
-	public void setExpiresIn(Long expiresIn) {
-		this.expiresIn = expiresIn;
-	}
-
-	public String getScope() {
-		return scope;
-	}
-
-	public void setScope(String scope) {
-		this.scope = scope;
-	}
-
-	public String getJti() {
-		return jti;
-	}
-
-	public void setJti(String jti) {
-		this.jti = jti;
-	}
-
-	public String getClientId() {
-		return clientId;
-	}
-
-	public void setClientId(String clientId) {
-		this.clientId = clientId;
-	}
-
-	@Override
-	public String toString() {
-		return "DJErpOAuth2AccessTokenResponse [accessToken=" + accessToken + ", tokenType=" + tokenType
-				+ ", expiresIn=" + expiresIn + ", scope=" + scope + ", jti=" + jti + ", clientId=" + clientId + "]";
-	}
-}
@@ -5,14 +5,14 @@ import java.io.Serializable;
 import com.fasterxml.jackson.annotation.JsonProperty;

@SuppressWarnings("serial")
-public class DJBOAuth2AccessTokenRequest implements Serializable {
-
+public class KjbMGOAuth2AccessTokenRequest implements Serializable { 
 	@JsonProperty("grant_type")
 	private String grantType;
 	@JsonProperty("client_id")
 	private String clientId;
 	@JsonProperty("client_secret")
 	private String clientSecret;
+	private String resource;
 	private String scope;

 	public String getGrantType() {
@@ -39,6 +39,14 @@ public class DJBOAuth2AccessTokenRequest implements Serializable {
 		this.clientSecret = clientSecret;
 	}

+	public String getResource() {
+		return resource;
+	}
+
+	public void setResource(String resource) {
+		this.resource = resource;
+	}
+
 	public String getScope() {
 		return scope;
 	}
@@ -49,7 +57,7 @@ public class DJBOAuth2AccessTokenRequest implements Serializable {

 	@Override
 	public String toString() {
-		return "DJErpOAuth2AccessTokenRequest [grantType=" + grantType + ", clientId=" + clientId
-				+ ", clientSecret=" + clientSecret + ", scope=" + scope + "]";
+		return "KjbMGOAuth2AccessTokenRequest [grantType=" + grantType + ", clientId=" + clientId + ", clientSecret="
+				+ clientSecret + ", resource=" + resource + ", scope=" + scope + "]";
 	}
 }
@@ -0,0 +1,105 @@
+package com.eactive.eai.authserver.custom;
+
+import java.io.Serializable;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonInclude.Include;
+
+@SuppressWarnings("serial")
+@JsonInclude(Include.NON_NULL)
+public class KjbMGOAuth2AccessTokenResponse implements Serializable { 
+	private String responseCode;
+	private String responseMessage;
+	@JsonProperty("access_token")
+	private String accessToken;
+	@JsonProperty("refresh_token")
+	private String refreshToken;
+	@JsonProperty("token_type")
+	private String tokenType;
+	@JsonProperty("expires_in")
+	private Long expiresIn;
+	@JsonProperty("expires_on")
+	private Long expiresOn;
+	private String resource;
+	private String scope;
+
+	public String getResponseCode() {
+		return responseCode;
+	}
+
+	public void setResponseCode(String responseCode) {
+		this.responseCode = responseCode;
+	}
+
+	public String getResponseMessage() {
+		return responseMessage;
+	}
+
+	public void setResponseMessage(String responseMessage) {
+		this.responseMessage = responseMessage;
+	}
+
+	public String getAccessToken() {
+		return accessToken;
+	}
+
+	public void setAccessToken(String accessToken) {
+		this.accessToken = accessToken;
+	}
+
+	public String getrefreshToken() {
+		return refreshToken;
+	}
+
+	public void setrefreshToken(String refreshToken) {
+		this.refreshToken = refreshToken;
+	}
+
+	public String getTokenType() {
+		return tokenType;
+	}
+
+	public void setTokenType(String tokenType) {
+		this.tokenType = tokenType;
+	}
+
+	public Long getExpiresIn() {
+		return expiresIn;
+	}
+
+	public void setExpiresIn(Long expiresIn) {
+		this.expiresIn = expiresIn;
+	}
+
+	public Long getExpiresOn() {
+		return expiresOn;
+	}
+
+	public void setExpiresOn(Long expiresOn) {
+		this.expiresOn = expiresOn;
+	}
+
+	public String getResource() {
+		return resource;
+	}
+
+	public void setResource(String resource) {
+		this.resource = resource;
+	}
+
+	public String getScope() {
+		return scope;
+	}
+
+	public void setScope(String scope) {
+		this.scope = scope;
+	}
+
+	@Override
+	public String toString() {
+		return "KjbMGOAuth2AccessTokenResponse [responseCode=" + responseCode + ", responseMessage=" + responseMessage
+				+ ", accessToken=" + accessToken + ", tokenType=" + tokenType + ", expiresIn=" + expiresIn
+				+ ", refreshToken=" + refreshToken+ ", expiresOn=" + expiresOn+ ", resource=" + resource+ ", scope=" + scope + "]";
+	}
+}
@@ -1,13 +1,19 @@
 package com.eactive.eai.authserver.custom;

+import java.nio.charset.StandardCharsets;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
 import java.security.Principal;
+import java.security.SecureRandom;
+import java.security.Signature;
 import java.time.LocalDateTime;
+import java.util.Base64;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
-import java.util.Properties;
 import java.util.Set;

+import javax.crypto.Cipher;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

@@ -22,16 +28,18 @@ import org.springframework.security.oauth2.provider.ClientDetails;
 import org.springframework.security.oauth2.provider.OAuth2Authentication;
 import org.springframework.security.oauth2.provider.OAuth2Request;
 import org.springframework.security.oauth2.provider.endpoint.TokenEndpoint;
+import org.springframework.security.oauth2.provider.token.TokenEnhancer;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.ModelAttribute;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.ResponseBody;

-import com.eactive.eai.adapter.http.dynamic.UnknownMessageLogUtils;
 import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.authserver.config.IssueLimitOAuth2Exception;
 import com.eactive.eai.authserver.config.RequestContextData;
 import com.eactive.eai.authserver.dao.TokenIssuanceLogDAO;
 import com.eactive.eai.authserver.service.OAuth2Manager;
@@ -46,55 +54,65 @@ import com.eactive.eai.data.entity.onl.authserver.TokenIssuanceLog;
 import com.fasterxml.jackson.databind.ObjectMapper;

@Controller
-public class DJBOAuth2Controller {
+public class KjbMGOAuth2Controller { 
 	public static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);

 	private static final String HEADER_TRACEID = "traceId";
-	private static final String SERVICE_CODE_ACCESS_TOKEN = "00";

+	private static final String SERVICE_CODE_ACCESS_TOKEN = "00"; // 임시설정
 	@Autowired
 	private TokenIssuanceLogDAO tokenIssuanceLogDAO;
+	

-	@RequestMapping(value = { "/*/oauth/token", "/*/oauth2/token" }, method = RequestMethod.POST,
-			consumes = "application/json", produces = "application/json; charset=UTF-8")
+	@RequestMapping(value = "/mapi/oauth2/token", method = RequestMethod.POST, consumes = "application/json", produces = "application/json; charset=UTF-8")
 	@ResponseBody
-	public ResponseEntity<?> tokenJson(@RequestBody DJBOAuth2AccessTokenRequest tokenRequest,
+	public ResponseEntity<String> tokenJson(@RequestBody KjbMGOAuth2AccessTokenRequest tokenRequest,
 			HttpServletRequest request, HttpServletResponse response) {
+
 		return issueToken(tokenRequest, request, response);
 	}

-	@RequestMapping(value = { "/*/oauth/token", "/*/oauth2/token" }, method = RequestMethod.POST,
-			consumes = "application/x-www-form-urlencoded", produces = "application/json; charset=UTF-8")
+	@RequestMapping(value = "/mapi/oauth2/token", method = RequestMethod.POST, consumes = "application/x-www-form-urlencoded", produces = "application/json; charset=UTF-8")
 	@ResponseBody
-	public ResponseEntity<?> tokenForm(@RequestParam Map<String, String> params,
-			HttpServletRequest request, HttpServletResponse response) {
-		DJBOAuth2AccessTokenRequest tokenRequest = new DJBOAuth2AccessTokenRequest();
+	public ResponseEntity<String> tokenForm(@RequestParam Map<String, String> params, HttpServletRequest request,
+			HttpServletResponse response) {
+
+		KjbMGOAuth2AccessTokenRequest tokenRequest = new KjbMGOAuth2AccessTokenRequest();
+
 		tokenRequest.setGrantType(params.get("grant_type"));
 		tokenRequest.setClientId(params.get("client_id"));
 		tokenRequest.setClientSecret(params.get("client_secret"));
 		tokenRequest.setScope(params.get("scope"));
+		tokenRequest.setResource(params.get("resource"));
+
 		return issueToken(tokenRequest, request, response);
 	}
-
-	@GetMapping(value = { "/*/oauth/token", "/*/oauth2/token" }, produces = "application/json; charset=UTF-8")
+	
+	@GetMapping(value = "/mapi/oauth2/token", produces = "application/json; charset=UTF-8")
 	@ResponseBody
-	public ResponseEntity<?> tokenGet(@RequestParam Map<String, String> params,
-			HttpServletRequest request, HttpServletResponse response) {
-		DJBOAuth2AccessTokenRequest tokenRequest = new DJBOAuth2AccessTokenRequest();
+	public ResponseEntity<String> tokenGet(@RequestParam Map<String, String> params, HttpServletRequest request,
+			HttpServletResponse response) {
+
+		KjbMGOAuth2AccessTokenRequest tokenRequest = new KjbMGOAuth2AccessTokenRequest();
+
 		tokenRequest.setGrantType(params.get("grant_type"));
 		tokenRequest.setClientId(params.get("client_id"));
 		tokenRequest.setClientSecret(params.get("client_secret"));
 		tokenRequest.setScope(params.get("scope"));
+		tokenRequest.setResource(params.get("resource"));
+
 		return issueToken(tokenRequest, request, response);
 	}

-	private ResponseEntity<?> issueToken(DJBOAuth2AccessTokenRequest tokenRequest,
-			HttpServletRequest request, HttpServletResponse response) {
-
+	private ResponseEntity<String> issueToken(
+	        KjbMGOAuth2AccessTokenRequest tokenRequest,
+	        HttpServletRequest request,
+	        HttpServletResponse response) {
+		
 		if (logger.isDebug()) {
 			logger.debug(tokenRequest.toString());
 		}
-
+		
 		RequestContextData data = new RequestContextData();
 		data.setClientId(tokenRequest.getClientId());
 		data.setIpAddress(extractIpAddress(request));
@@ -102,98 +120,116 @@ public class DJBOAuth2Controller {
 		data.setScope(tokenRequest.getScope());
 		data.setUsername("none");
 		data.setResource("none");
-		RequestContextData.ThreadLocalRequestContext.set(data);

+		RequestContextData.ThreadLocalRequestContext.set(data);
+		
+
+		KjbMGOAuth2AccessTokenResponse responseToken = new KjbMGOAuth2AccessTokenResponse();
+		
 		String grantType = tokenRequest.getGrantType();
 		String clientId = tokenRequest.getClientId();
 		String clientSecret = tokenRequest.getClientSecret();
 		String scopes = tokenRequest.getScope();
-
+		
 		try {
-			if (!StringUtils.equals(grantType, "client_credentials")) {
+			if (!StringUtils.equals(tokenRequest.getGrantType(), "client_credentials")) {
 				throw new JwtAuthException(
 						String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
-						"Invalid Mandatory Field {grant_type}");
+						"Invalid Mandatory Field {grantType}");
 			}

 			String[] scopeArr = org.springframework.util.StringUtils.tokenizeToStringArray(scopes, " ");
-			Set<String> scopeSet = new HashSet<>();
+			Set<String> scopeSet = new HashSet<String>();
 			for (String scope : scopeArr) {
 				scopeSet.add(scope);
 			}

+			String[] resourceArr = org.springframework.util.StringUtils.tokenizeToStringArray(tokenRequest.getResource(), ",");
+			Set<String> resourceSet = new HashSet<String>();
+			for (String resource : resourceArr) {
+				resourceSet.add(resource);
+			}
+
 			ClientDetails clientDetails = OAuth2Manager.getInstance().getClientDeatilsStore().get(clientId);
 			verifyClient(clientDetails, clientId, clientSecret, scopeSet);

 			String traceId = UUID.randomUUID().toString().replace("-", "");
 			response.setHeader(HEADER_TRACEID, traceId);

-			HashMap<String, String> authorizationParameters = new HashMap<>();
+			HashMap<String, String> authorizationParameters = new HashMap<String, String>();
 			authorizationParameters.put(OAuth2Utils.GRANT_TYPE, grantType);
 			authorizationParameters.put(OAuth2Utils.CLIENT_ID, clientId);
 			authorizationParameters.put("client_secret", clientSecret);

-			Set<String> responseType = new HashSet<>();
-			responseType.add(grantType);
+			Set<String> responseType = new HashSet<String>();
+			responseType.add(tokenRequest.getGrantType());

-			OAuth2Request authorizationRequest = new OAuth2Request(authorizationParameters, clientId, null, true,
-					scopeSet, null, "", responseType, null);
+			OAuth2Request authorizationRequest = new OAuth2Request(authorizationParameters, clientId, null, true, scopeSet,
+					resourceSet, "", responseType, null);

 			Principal principal = new OAuth2Authentication(authorizationRequest, null);
-			ResponseEntity<OAuth2AccessToken> result = tokenEndpoint().postAccessToken(principal, authorizationParameters);
+			ResponseEntity<OAuth2AccessToken> result = tokenEndpoint().postAccessToken(principal,
+					authorizationParameters);
 			OAuth2AccessToken token = result.getBody();
-
-			DJBOAuth2AccessTokenResponse responseToken = new DJBOAuth2AccessTokenResponse();
+			if(StringUtils.isNotBlank(token.getTokenType()) && StringUtils.equalsIgnoreCase(token.getTokenType(), "bearer")) {
+				responseToken.setTokenType("Bearer");
+			} else {	responseToken.setTokenType(token.getTokenType()); }
 			responseToken.setAccessToken(token.getValue());
-			responseToken.setTokenType(token.getTokenType());
 			responseToken.setExpiresIn(Long.valueOf(token.getExpiresIn()));
-			responseToken.setScope(StringUtils.join(token.getScope(), " "));
-			responseToken.setJti((String) token.getAdditionalInformation().get("jti"));
-			responseToken.setClientId((String) token.getAdditionalInformation().get("client_id"));
-
-			//logTokenIssuance(true, false, "Token issued successfully", token.getValue());
+			responseToken.setrefreshToken("");
+			responseToken.setExpiresOn(System.currentTimeMillis() + (token.getExpiresIn() * 1000));
+			responseToken.setScope(tokenRequest.getScope());
+			responseToken.setResource(tokenRequest.getResource());

+			// 성공 시 JSON 문자열로 변환하여 반환
 			ObjectMapper mapper = new ObjectMapper();
-			return ResponseEntity.ok(mapper.writeValueAsString(responseToken));
+			String successJson = mapper.writeValueAsString(responseToken);
+
+			return ResponseEntity.ok(successJson);

 		} catch (JwtAuthException e) {
-			logger.info("Token request[/dj/oauth2/token] => clientId: {}, grantType: {}, scope: {}",
-					clientId, grantType, scopes);
+			logger.info("Token request[/mapi/oauth2/token] => clientId: {}, grantType: {}, scope: {}", 
+		            clientId, grantType, scopes);
 			logger.error(e.getMessage());
-			logTokenIssuance(false, false, e.getMessage(), null);
-			
-			Properties logProp = new Properties();
-			if(StringUtils.isNotEmpty(clientId))
-				logProp.put("clientId", clientId);
-			
-			UnknownMessageLogUtils.logUnkownMessage(this.getClass().getSimpleName(), this.getClass().getSimpleName(),
-					tokenRequest.toString(), logProp, request, response, "RECEAIIRP301", e);
-			
 			String errorJson = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_AUTH_FAIL, e.getMessage());
 			int statusCode = NumberUtils.toInt(StringUtils.left(e.getCode(), 3), HttpStatus.UNAUTHORIZED.value());
+			logTokenIssuance(false ,false, e.getMessage(), null);
 			return ResponseEntity.status(statusCode).body(errorJson);

 		} catch (Exception e) {
-			logger.info("Token request[/dj/oauth2/token] => clientId: {}, grantType: {}, scope: {}",
-					clientId, grantType, scopes);
+			logger.info("Token request[/mapi/oauth2/token] => clientId: {}, grantType: {}, scope: {}", 
+		            clientId, grantType, scopes);
 			logger.error(e.getMessage());
-			logTokenIssuance(false, false, e.getMessage(), null);
-			
-			Properties logProp = new Properties();
-			if(StringUtils.isNotEmpty(clientId))
-				logProp.put("clientId", clientId);
-			
-			UnknownMessageLogUtils.logUnkownMessage(this.getClass().getSimpleName(), this.getClass().getSimpleName(),
-					tokenRequest.toString(), logProp, request, response, "RECEAIIRP301", e);
-			
 			String errorJson = MessageUtil.makeJsonErrorMessage(MessageUtil.ERROR_CODE_AUTH_FAIL, "Unauthorized. [Unknown]");
+			logTokenIssuance(false ,false, e.getMessage(), null);
 			return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(errorJson);
-
-		} finally {
+		}finally {
 			RequestContextData.ThreadLocalRequestContext.clear();
 		}
+		
+		
 	}
-
+	
+	private String extractIpAddress(HttpServletRequest request) {
+		String ipAddress = request.getHeader("X-Forwarded-For");
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("Proxy-Client-IP");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("WL-Proxy-Client-IP");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("HTTP_CLIENT_IP");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getHeader("HTTP_X_FORWARDED_FOR");
+		}
+		if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
+			ipAddress = request.getRemoteAddr();
+		}
+		return ipAddress;
+	}
+	
 	private void verifyClient(ClientDetails clientDetails, String clientId, String clientSecret, Set<String> scopeSet)
 			throws JwtAuthException {

@@ -202,41 +238,37 @@ public class DJBOAuth2Controller {
 					String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
 					"Invalid Mandatory Field {client_id}");
 		}
+
 		if (clientDetails == null) {
 			throw new JwtAuthException(
 					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
 					"Unauthorized. [client not found]");
 		}
+		
 		if (StringUtils.isBlank(clientSecret)) {
 			throw new JwtAuthException(
 					String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
 					"Invalid Mandatory Field {client_secret}");
 		}
+		
 		if (!StringUtils.equals(clientDetails.getClientSecret(), clientSecret)) {
 			throw new JwtAuthException(
 					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
 					"Unauthorized. [Bad client credentials(Client Secret is not match)]");
 		}
+		
 		if (scopeSet.isEmpty()) {
 			throw new JwtAuthException(
 					String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
 					"Invalid Mandatory Field {scope}");
 		}
+
 		if (!clientDetails.getScope().containsAll(scopeSet)) {
 			throw new JwtAuthException(
 					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
 					"Unauthorized. [Bad client credentials(Include unacceptable scope)]");
 		}
-	}

-	private String extractIpAddress(HttpServletRequest request) {
-		String ip = request.getHeader("X-Forwarded-For");
-		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) ip = request.getHeader("Proxy-Client-IP");
-		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) ip = request.getHeader("WL-Proxy-Client-IP");
-		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) ip = request.getHeader("HTTP_CLIENT_IP");
-		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) ip = request.getHeader("HTTP_X_FORWARDED_FOR");
-		if (StringUtils.isBlank(ip) || "unknown".equalsIgnoreCase(ip)) ip = request.getRemoteAddr();
-		return ip;
 	}

 	private TokenEndpoint tokenEndpoint() {
@@ -250,20 +282,17 @@ public class DJBOAuth2Controller {
 				return;
 			}
 			RequestContextData data = RequestContextData.ThreadLocalRequestContext.get();
+			OAuth2Manager.getInstance();

 			TokenIssuanceLog log = new TokenIssuanceLog();
 			String clientId = data.getClientId();
 			log.setClientId(clientId);

-			if (StringUtils.isNotBlank(clientId)) {
-				try {
-					ClientVO clientVO = OAuth2Manager.getInstance().getClientInfo(clientId);
-					log.setAppName(clientVO.getClientName());
-					log.setOrgId(clientVO.getOrgId());
-					log.setOrgName(clientVO.getOrgName());
-				} catch (DAOException e) {
-					logger.warn("cannot find clientVO - " + clientId);
-				}
+			if(StringUtils.isNotBlank(clientId)) {
+				ClientVO clientVO = OAuth2Manager.getInstance().getClientInfo(clientId);
+				log.setAppName(clientVO.getClientName());
+				log.setOrgId(clientVO.getOrgId());
+				log.setOrgName(clientVO.getOrgName());
 			}

 			log.setGrantType(data.getGrantType());
@@ -273,11 +302,59 @@ public class DJBOAuth2Controller {
 			log.setIssuanceDateTime(LocalDateTime.now());
 			log.setRestrictionExemptYn(isRestrictionExempt ? "Y" : "N");
 			log.setResultMessage(resultMessage);
-			log.setAccessToken(accessToken);
+			log.setAccessToken(accessToken); // Add access token value to the log

 			tokenIssuanceLogDAO.saveTokenIssuanceLog(log);
 		} catch (Throwable th) {
 			logger.error("Error while logging token issuance: " + th.getMessage(), th);
 		}
 	}
+
+	public static void main(String[] args) throws Exception {
+		// First generate a public/private key pair
+		KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
+		// generator.initialize(512, new SecureRandom());
+		//generator.initialize(1024, new SecureRandom());
+		generator.initialize(2048, new SecureRandom());
+		KeyPair pair = generator.generateKeyPair();
+
+		// The private key can be used to sign (not encrypt!) a message. The public key
+		// holder can then verify the message.
+
+		String message = "sSGJDwlJsel5WeXodzd3J3MQ20KYCZpL|2022-12-21T14:36:19+07:00";
+
+		// Let's sign our message
+		Signature privateSignature = Signature.getInstance("SHA256withRSA");
+		privateSignature.initSign(pair.getPrivate());
+		privateSignature.update(message.getBytes(StandardCharsets.UTF_8));
+		// System.out.println("private key=" + Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));
+		byte[] signature = privateSignature.sign();
+		//System.out.println("signature=" + new String(signature, StandardCharsets.UTF_8));
+		// System.out.println("signature=" + Base64.getEncoder().encodeToString(signature));
+
+		// Let's check the signature
+		Signature publicSignature = Signature.getInstance("SHA256withRSA");
+		publicSignature.initVerify(pair.getPublic());
+		publicSignature.update(message.getBytes(StandardCharsets.UTF_8));
+		boolean isCorrect = publicSignature.verify(signature);
+		// System.out.println("public key=" + Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));
+
+		// System.out.println("Signature correct: " + isCorrect);
+
+		// The public key can be used to encrypt a message, the private key can be used
+		// to decrypt it.
+		// Encrypt the message
+		Cipher encryptCipher = Cipher.getInstance("RSA");
+		encryptCipher.init(Cipher.ENCRYPT_MODE, pair.getPublic());
+
+		byte[] cipherText = encryptCipher.doFinal(message.getBytes(StandardCharsets.UTF_8));
+
+		// Now decrypt it
+		Cipher decriptCipher = Cipher.getInstance("RSA");
+		decriptCipher.init(Cipher.DECRYPT_MODE, pair.getPrivate());
+
+		String decipheredMessage = new String(decriptCipher.doFinal(cipherText), StandardCharsets.UTF_8);
+
+		// System.out.println(decipheredMessage);
+	}
 }
@@ -0,0 +1,49 @@
+package com.eactive.eai.authserver.custom;
+
+import java.io.Serializable;
+
+@SuppressWarnings("serial")
+public class SnapOAuth2AccessTokenRequest implements Serializable {
+	private String grantType;
+	private String authCode;
+	private String refreshToken;
+	private Object additionalInfo;
+
+	public String getGrantType() {
+		return grantType;
+	}
+
+	public void setGrantType(String grantType) {
+		this.grantType = grantType;
+	}
+
+	public String getAuthCode() {
+		return authCode;
+	}
+
+	public void setAuthCode(String authCode) {
+		this.authCode = authCode;
+	}
+
+	public String getRefreshToken() {
+		return refreshToken;
+	}
+
+	public void setRefreshToken(String refreshToken) {
+		this.refreshToken = refreshToken;
+	}
+
+	public Object getAdditionalInfo() {
+		return additionalInfo;
+	}
+
+	public void setAdditionalInfo(Object additionalInfo) {
+		this.additionalInfo = additionalInfo;
+	}
+
+	@Override
+	public String toString() {
+		return "SnapOAuth2AccessTokenRequest [grantType=" + grantType + ", authCode=" + authCode + ", refreshToken="
+				+ refreshToken + ", additionalInfo=" + additionalInfo + "]";
+	}
+}
@@ -0,0 +1,72 @@
+package com.eactive.eai.authserver.custom;
+
+import java.io.Serializable;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonInclude.Include;
+
+@SuppressWarnings("serial")
+@JsonInclude(Include.NON_NULL)
+public class SnapOAuth2AccessTokenResponse implements Serializable {
+	private String responseCode;
+	private String responseMessage;
+	private String accessToken;
+	private String tokenType;
+	private String expiresIn;
+	private Object additionalInfo;
+
+	public String getResponseCode() {
+		return responseCode;
+	}
+
+	public void setResponseCode(String responseCode) {
+		this.responseCode = responseCode;
+	}
+
+	public String getResponseMessage() {
+		return responseMessage;
+	}
+
+	public void setResponseMessage(String responseMessage) {
+		this.responseMessage = responseMessage;
+	}
+
+	public String getAccessToken() {
+		return accessToken;
+	}
+
+	public void setAccessToken(String accessToken) {
+		this.accessToken = accessToken;
+	}
+
+	public String getTokenType() {
+		return tokenType;
+	}
+
+	public void setTokenType(String tokenType) {
+		this.tokenType = tokenType;
+	}
+
+	public String getExpiresIn() {
+		return expiresIn;
+	}
+
+	public void setExpiresIn(String expiresIn) {
+		this.expiresIn = expiresIn;
+	}
+
+	public Object getAdditionalInfo() {
+		return additionalInfo;
+	}
+
+	public void setAdditionalInfo(Object additionalInfo) {
+		this.additionalInfo = additionalInfo;
+	}
+
+	@Override
+	public String toString() {
+		return "SnapOAuth2AccessTokenResponse [responseCode=" + responseCode + ", responseMessage=" + responseMessage
+				+ ", accessToken=" + accessToken + ", tokenType=" + tokenType + ", expiresIn=" + expiresIn
+				+ ", additionalInfo=" + additionalInfo + "]";
+	}
+}
@@ -0,0 +1,222 @@
+package com.eactive.eai.authserver.custom;
+
+import java.nio.charset.StandardCharsets;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.Principal;
+import java.security.PublicKey;
+import java.security.SecureRandom;
+import java.security.Signature;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.crypto.Cipher;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.math.NumberUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.oauth2.common.OAuth2AccessToken;
+import org.springframework.security.oauth2.common.util.OAuth2Utils;
+import org.springframework.security.oauth2.provider.ClientDetails;
+import org.springframework.security.oauth2.provider.OAuth2Authentication;
+import org.springframework.security.oauth2.provider.OAuth2Request;
+import org.springframework.security.oauth2.provider.endpoint.TokenEndpoint;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.authserver.util.BeanUtils;
+import com.eactive.eai.authserver.vo.ClientVO;
+import com.eactive.eai.common.util.Logger;
+
+@Controller
+public class SnapOAuth2Controller {
+	public static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
+
+	private static final String HEADER_TIMESTAMP = "X-TIMESTAMP";
+	private static final String HEADER_CLIENT_ID = "X-CLIENT-KEY";
+	private static final String HEADER_SIGNATURE = "X-SIGNATURE";
+
+	private static final String SERVICE_CODE_ACCESS_TOKEN = "00"; // 임시설정
+
+	@RequestMapping(value = "/bukopin_snap_api/v1.0/access-token/b2b", method = RequestMethod.POST, produces = "application/json; charset=\"UTF-8\"")
+	@ResponseBody
+	public SnapOAuth2AccessTokenResponse token(@RequestBody SnapOAuth2AccessTokenRequest tokenRequest,
+			HttpServletRequest request, HttpServletResponse response) {
+		if (logger.isDebug()) {
+			logger.debug(tokenRequest.toString());
+		}
+
+		SnapOAuth2AccessTokenResponse responseToken = new SnapOAuth2AccessTokenResponse();
+		try {
+			if (!StringUtils.equals(tokenRequest.getGrantType(), "client_credentials")) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
+						"Invalid Mandatory Field {grantType}");
+			}
+
+			String timeStamp = request.getHeader(HEADER_TIMESTAMP);
+			String clientId = request.getHeader(HEADER_CLIENT_ID);
+			String signature = request.getHeader(HEADER_SIGNATURE);
+
+			ClientDetails clientDetails = OAuth2Manager.getInstance().getClientDeatilsStore().get(clientId);
+			verifyClient(clientDetails, timeStamp, clientId, signature);
+
+			response.setHeader(HEADER_TIMESTAMP, timeStamp);
+			response.setHeader(HEADER_CLIENT_ID, clientId);
+
+			HashMap<String, String> authorizationParameters = new HashMap<String, String>();
+			authorizationParameters.put(OAuth2Utils.GRANT_TYPE, tokenRequest.getGrantType());
+			authorizationParameters.put(OAuth2Utils.CLIENT_ID, clientId);
+			authorizationParameters.put("client_secret", clientDetails.getClientSecret());
+
+			Set<String> responseType = new HashSet<String>();
+			responseType.add(tokenRequest.getGrantType());
+
+			OAuth2Request authorizationRequest = new OAuth2Request(authorizationParameters, clientId, null, true, null,
+					null, "", responseType, null);
+
+			Principal principal = new OAuth2Authentication(authorizationRequest, null);
+			ResponseEntity<OAuth2AccessToken> result = tokenEndpoint().postAccessToken(principal,
+					authorizationParameters);
+			OAuth2AccessToken token = result.getBody();
+			responseToken.setAccessToken(token.getValue());
+			responseToken.setExpiresIn(String.valueOf(token.getExpiresIn()));
+			responseToken.setTokenType(token.getTokenType());
+		} catch (JwtAuthException e) {
+			response.setStatus(NumberUtils.toInt(StringUtils.left(e.getCode(), 3), HttpStatus.UNAUTHORIZED.value()));
+			responseToken.setResponseCode(e.getCode());
+			responseToken.setResponseMessage(e.getMessage());
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+			response.setStatus(HttpStatus.UNAUTHORIZED.value());
+			responseToken.setResponseCode(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"));
+			responseToken.setResponseMessage("Unauthorized. [Unknown]");
+		}
+
+		return responseToken;
+	}
+
+	private void verifyClient(ClientDetails clientDetails, String timeStamp, String clientId, String signatureStr)
+			throws JwtAuthException {
+		if (StringUtils.isBlank(timeStamp)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
+					"Invalid Mandatory Field {" + HEADER_TIMESTAMP + "}");
+		}
+
+		if (StringUtils.isBlank(clientId)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
+					"Invalid Mandatory Field {" + HEADER_CLIENT_ID + "}");
+		}
+
+		if (StringUtils.isBlank(signatureStr)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.BAD_REQUEST.value(), SERVICE_CODE_ACCESS_TOKEN, "02"),
+					"Invalid Mandatory Field {" + HEADER_SIGNATURE + "}");
+		}
+
+		if (clientDetails == null) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
+					"Unauthorized. [client not found]");
+		}
+		
+		String publicKeyStr = ((ClientVO) clientDetails).getSecurityKey();
+		if (StringUtils.isBlank(publicKeyStr)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
+					"Unauthorized. [public key not found]");
+		}
+
+		try {
+			String message = clientId + "|" + timeStamp;
+			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyStr));
+			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+			PublicKey publicKey = keyFactory.generatePublic(keySpec);
+
+			Signature signature = Signature.getInstance("SHA256withRSA");
+			signature.initVerify(publicKey);
+			signature.update(message.getBytes(StandardCharsets.UTF_8));
+			if (!signature.verify(Base64.getDecoder().decode(signatureStr))) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
+						"Unauthorized. [Signature not matched]");
+			}
+		} catch (JwtAuthException e) {
+			throw e;
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_ACCESS_TOKEN, "00"),
+					"Unauthorized. [Signature fail]");
+		}
+	}
+
+	private TokenEndpoint tokenEndpoint() {
+		return BeanUtils.getBean("tokenEndpoint", TokenEndpoint.class);
+	}
+
+	public static void main(String[] args) throws Exception {
+		// First generate a public/private key pair
+		KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
+		// generator.initialize(512, new SecureRandom());
+		//generator.initialize(1024, new SecureRandom());
+		generator.initialize(2048, new SecureRandom());
+		KeyPair pair = generator.generateKeyPair();
+
+		// The private key can be used to sign (not encrypt!) a message. The public key
+		// holder can then verify the message.
+
+		String message = "sSGJDwlJsel5WeXodzd3J3MQ20KYCZpL|2022-12-21T14:36:19+07:00";
+
+		// Let's sign our message
+		Signature privateSignature = Signature.getInstance("SHA256withRSA");
+		privateSignature.initSign(pair.getPrivate());
+		privateSignature.update(message.getBytes(StandardCharsets.UTF_8));
+		System.out.println(
+				"private key=" + Base64.getEncoder().encodeToString(pair.getPrivate().getEncoded()));
+
+		byte[] signature = privateSignature.sign();
+		//System.out.println("signature=" + new String(signature, StandardCharsets.UTF_8));
+		System.out.println("signature=" + Base64.getEncoder().encodeToString(signature));
+
+		// Let's check the signature
+		Signature publicSignature = Signature.getInstance("SHA256withRSA");
+		publicSignature.initVerify(pair.getPublic());
+		publicSignature.update(message.getBytes(StandardCharsets.UTF_8));
+		boolean isCorrect = publicSignature.verify(signature);
+		System.out.println("public key=" + Base64.getEncoder().encodeToString(pair.getPublic().getEncoded()));
+
+		System.out.println("Signature correct: " + isCorrect);
+
+		// The public key can be used to encrypt a message, the private key can be used
+		// to decrypt it.
+		// Encrypt the message
+		Cipher encryptCipher = Cipher.getInstance("RSA");
+		encryptCipher.init(Cipher.ENCRYPT_MODE, pair.getPublic());
+
+		byte[] cipherText = encryptCipher.doFinal(message.getBytes(StandardCharsets.UTF_8));
+
+		// Now decrypt it
+		Cipher decriptCipher = Cipher.getInstance("RSA");
+		decriptCipher.init(Cipher.DECRYPT_MODE, pair.getPrivate());
+
+		String decipheredMessage = new String(decriptCipher.doFinal(cipherText), StandardCharsets.UTF_8);
+
+		System.out.println(decipheredMessage);
+	}
+}
@@ -1,101 +0,0 @@
-package com.eactive.eai.custom.adapter.handler;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Properties;
-
-import org.apache.commons.lang3.StringUtils;
-
-import com.eactive.eai.adapter.handler.TemplateCodeConvertAdapterErrorMsgHandler;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
-import com.eactive.eai.common.message.EAIMessage;
-import com.eactive.eai.common.message.EAIMessageKeys;
-import com.eactive.eai.common.util.MessageUtil;
-import com.eactive.eai.custom.message.StandardMessageCoordinatorDJB;
-import com.eactive.eai.message.StandardItem;
-import com.eactive.eai.message.StandardMessage;
-import com.eactive.eai.message.manager.StandardMessageManager;
-import com.eactive.eai.message.service.InterfaceMapper;
-import com.eactive.eai.util.JsonPathUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-
-public class DJbCommonAdapterErrorMsgHandler extends TemplateCodeConvertAdapterErrorMsgHandler {
-
-	/**
-	 * 표준 -> 비표준 거래 아웃바운드 어댑터에서 Exception이 발생했을 때, Outbound Process 응답 메시지 생성
-	 */
-	@Override
-	public Object generateOutboundErrorResponseMessage(String outboundadapterGroupName, String outboundadapterName,
-			Properties callProp, Object outboundRequestData, EAIMessage resEaiMsg) throws Exception {
-
-		StandardMessage standardMessage = resEaiMsg.getStandardMessage();
-
-		@SuppressWarnings("unchecked")
-		Map<String, Object> map = (Map<String, Object>) callProp.get(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP);
-		Object responseMessage = map.get(HttpAdapterServiceKey.OUTBOUND_RESPONSE_MESSAGE);
-		String rspErrCd = resEaiMsg.getRspErrCd();
-		String errorCode = StringUtils.defaultString(MessageUtil.getTobeCode(rspErrCd));
-		String errorMsg  = StringUtils.defaultString(MessageUtil.getTobeMessage(rspErrCd));
-		String errorDesc  = StringUtils.defaultString(MessageUtil.getTobeDesc(rspErrCd));
-		String errorLoc = StringUtils.substring(resEaiMsg.getRspErrMsg(), 0, 200);
-		
-		JsonNode jsonNode = JsonPathUtil.toTree(responseMessage);
-
-		if (jsonNode != null) {
-			if(jsonNode.has("rspCode"))
-				errorCode = jsonNode.get("rspCode").asText();
-			
-			if(jsonNode.has("rspMsg"))
-				errorMsg = jsonNode.get("rspMsg").asText();
-			
-			if(jsonNode.has("outpMsgDesc"))
-				errorDesc = jsonNode.get("outpMsgDesc").asText();
-			
-		}
-
-		// msg_dvcd = EM (에러메시지)
-		standardMessage.setData(StandardMessageCoordinatorDJB.MSG_DVCD, "EM");
-
-		// 출력속성코드 = 1(팝업)
-		standardMessage.setData(StandardMessageCoordinatorDJB.MSG_OUTP_ATRB_CD, "1");
-
-		StandardMessageManager manager = StandardMessageManager.getInstance();
-		InterfaceMapper mapper = manager.getMapper();
-
-		// mapper 에러코드 설정
-		mapper.setErrorCode(standardMessage, errorCode);
-		mapper.setErrorMsg(standardMessage, errorMsg);
-
-		// MSG_LIST 1건 구성
-		StandardItem msgList = standardMessage.findItem(StandardMessageCoordinatorDJB.MSG_LIST);
-		if(msgList == null) {
-			standardMessage.setData(StandardMessageCoordinatorDJB.MSG_LIST_ROWCNT, "1");
-			msgList = standardMessage.findItem(StandardMessageCoordinatorDJB.MSG_LIST);
-		}
-		
-		if (msgList != null) {
-			msgList.setSize(1);
-			LinkedHashMap<String, StandardItem> row = msgList.getArrayChilds(0, true);
-			if (row != null) {
-				if (row.containsKey("outp_msg_cd"))
-					row.get("outp_msg_cd").setValue(errorCode);
-				if (row.containsKey("outp_msg_ctnt"))
-					row.get("outp_msg_ctnt").setValue(errorMsg);
-				if (row.containsKey("outp_msg_desc"))
-					row.get("outp_msg_desc").setValue(errorDesc);
-				if (row.containsKey("err_occu_loct"))
-					row.get("err_occu_loct").setValue(errorLoc);
-			}
-		}
-
-		// 성공 처리 처럼 진행한다.
-		// 단, 거래로그/에러로그는 원본 에러코드 기준으로 남겨야 하므로 별도로 보관한다.
-		resEaiMsg.setOrgRspErrCd(resEaiMsg.getRspErrCd());
-		resEaiMsg.setRspErrCd(EAIMessageKeys.EAI_SUCCESS_CODE, false);
-		
-		// 응답 메시지 리턴
-		return "";
-
-	}
-
-}
@@ -1,53 +0,0 @@
-package com.eactive.eai.custom.adapter.handler;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.handler.TemplateCodeConvertAdapterErrorMsgHandler;
-import com.eactive.eai.common.message.EAIMessage;
-import com.eactive.eai.common.message.EAIMessageKeys;
-import com.eactive.eai.custom.message.StandardMessageCoordinatorDJB;
-import com.eactive.eai.message.StandardItem;
-import com.eactive.eai.message.StandardMessage;
-import com.eactive.eai.message.manager.StandardMessageManager;
-import com.eactive.eai.message.service.InterfaceMapper;
-
-public class ErpAdapterErrorMsgHandler extends TemplateCodeConvertAdapterErrorMsgHandler {
-
-	/**
-	 * 표준 -> 비표준 거래
-	 * 아웃바운드 어댑터에서 Exception이 발생했을 때, Outbound Process 응답 메시지 생성
-	 */
-	@Override
-	public Object generateOutboundErrorResponseMessage(String outboundadapterGroupName,
-			String outboundadapterName, Properties callProp, Object outboundRequestData, EAIMessage resEaiMsg)
-			throws Exception {
-		
-		StandardMessage standardMessage = resEaiMsg.getStandardMessage();
-		// msg_dvcd = EM (에러메시지)
-        standardMessage.setData(StandardMessageCoordinatorDJB.MSG_DVCD, "NM");
-
-        // 출력속성코드 = 1(팝업)
-        standardMessage.setData(StandardMessageCoordinatorDJB.MSG_OUTP_ATRB_CD, "1");
-
-        // MSG_LIST 1건 구성
-        standardMessage.setData(StandardMessageCoordinatorDJB.MSG_LIST_ROWCNT, "0");
-        StandardItem msgPart = standardMessage.findItem("MSG");
-        msgPart.getChilds().remove("MSG_LIST");
-
-        StandardMessageManager manager = StandardMessageManager.getInstance();
-        InterfaceMapper mapper = manager.getMapper();
-        
-        // mapper 에러코드 설정
-        mapper.setErrorCode(standardMessage, "");
-        mapper.setErrorMsg(standardMessage, "처리오류");
-
-        // 성공 처리 처럼 진행한다.
-        // 단, 거래로그/에러로그는 원본 에러코드 기준으로 남겨야 하므로 별도로 보관한다.
-        resEaiMsg.setOrgRspErrCd(resEaiMsg.getRspErrCd());
-        resEaiMsg.setRspErrCd(EAIMessageKeys.EAI_SUCCESS_CODE, false);
-		
-		return null;
-
-	}
-
-}
@@ -1,127 +0,0 @@
-package com.eactive.eai.custom.adapter.handler;
-
-import java.util.Map;
-import java.util.Properties;
-
-import org.apache.commons.lang3.StringUtils;
-
-import com.eactive.eai.adapter.handler.TemplateAdapterErrorMsgHandler;
-import com.eactive.eai.adapter.handler.TemplateCodeConvertAdapterErrorMsgHandler;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
-import com.eactive.eai.common.message.EAIMessage;
-import com.eactive.eai.common.message.EAIMessageKeys;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.custom.message.StandardMessageCoordinatorDJB;
-import com.eactive.eai.message.StandardItem;
-import com.eactive.eai.message.StandardMessage;
-import com.eactive.eai.message.manager.StandardMessageManager;
-import com.eactive.eai.message.service.InterfaceMapper;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-
-public class KakaopayAdapterErrorMsgHandler extends TemplateCodeConvertAdapterErrorMsgHandler {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	// 기본 ObjectMapper 는 응답 JSON 왕복에서 100000000.00 을 1.0E8 로 바꿔버린다.
-	private static final ObjectMapper OBJECT_MAPPER = JacksonUtil.newNumberSafeMapper();
-
-	@Override
-	public Object generateNonStandardErrorResponseMessage(String inboundAdapterGroupName, String inboundAdapterName,
-			Properties callProp, Object outboundRequestData, EAIMessage resEaiMsg) throws Exception {
-
-		Object responseMsessage = super.generateNonStandardErrorResponseMessage(inboundAdapterGroupName,
-				inboundAdapterName, callProp, outboundRequestData, resEaiMsg);
-
-		logger.debug("generateNonStandardErrorResponseMessage - {}", responseMsessage);
-
-		if (!(responseMsessage instanceof String)) {
-			return responseMsessage;
-		}
-
-		String jsonStr = (String) responseMsessage;
-		if (StringUtils.isBlank(jsonStr)) {
-			return responseMsessage;
-		}
-
-		// 제어문자를 이스케이프하지 않고 보내는 상대 시스템 대응 (JacksonUtil.escapeControlChars 주석 참조)
-		JsonNode rootNode = OBJECT_MAPPER.readTree(JacksonUtil.escapeControlChars(jsonStr));
-
-		boolean modified = false;
-
-		if (modified) {
-			responseMsessage = OBJECT_MAPPER.writeValueAsString(rootNode);
-		}
-
-		return responseMsessage;
-	}
-	
-	/**
-	 * 표준 -> 비표준 거래 아웃바운드 어댑터에서 Exception이 발생했을 때, Outbound Process 응답 메시지 생성
-	 */
-	@Override
-	public Object generateOutboundErrorResponseMessage(String outboundadapterGroupName, String outboundadapterName,
-			Properties callProp, Object outboundRequestData, EAIMessage resEaiMsg) throws Exception {
-
-		String msgCd = "error";
-		String msgCtnt = "IF오류";
-		String msgDesc = "";
-		// 에러에 대한 응답메시지
-		if (callProp.get(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP) instanceof Map) {
-			Map<String, Object> map = (Map<String, Object>) callProp.get(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP);
-			Object responseBody = map.get(HttpAdapterServiceKey.OUTBOUND_RESPONSE_MESSAGE);
-
-			if (responseBody instanceof String) {
-				String jsonStr = (String) responseBody;
-				if (!StringUtils.isBlank(jsonStr)) {
-					JsonNode rootNode = OBJECT_MAPPER.readTree(JacksonUtil.escapeControlChars(jsonStr));
-					StringBuffer sb = new StringBuffer();
-					JsonNode errorCode = rootNode.get("error_code");
-					if(errorCode != null)
-						sb.append(errorCode.textValue());
-					
-					sb.append("/");
-					JsonNode errorMessage = rootNode.get("error_message");
-					if(errorMessage != null)
-						sb.append(errorMessage.textValue());
-					
-					msgDesc = sb.toString();
-					msgCd = "BFEX03216";
-					msgCtnt = "참가기관코드 에러입니다.";
-					logger.debug("오류 응답 수신 - {}", jsonStr);
-				}
-			}
-		}
-
-		StandardMessage standardMessage = resEaiMsg.getStandardMessage();
-		// msg_dvcd = EM (에러메시지)
-		standardMessage.setData(StandardMessageCoordinatorDJB.MSG_DVCD, "NM");
-
-		// 출력속성코드 = 1(팝업)
-		standardMessage.setData(StandardMessageCoordinatorDJB.MSG_OUTP_ATRB_CD, "");
-
-		// MSG_LIST 1건 구성
-		standardMessage.setData(StandardMessageCoordinatorDJB.MSG_LIST_ROWCNT, "0");
-		StandardItem msgPart = standardMessage.findItem("MSG");
-		msgPart.getChilds().remove("MSG_LIST");
-
-		StandardMessageManager manager = StandardMessageManager.getInstance();
-		InterfaceMapper mapper = manager.getMapper();
-
-		// mapper 에러코드 설정
-		mapper.setErrorCode(standardMessage, msgCd);
-		mapper.setErrorMsg(standardMessage, msgCtnt);
-		if (StringUtils.isNotEmpty(msgDesc))
-			standardMessage.setData(StandardMessageCoordinatorDJB.MSG_OUTP_MSG_DESC, msgDesc);
-
-		// 성공 처리 처럼 진행한다.
-		// 단, 거래로그/에러로그는 원본 에러코드 기준으로 남겨야 하므로 별도로 보관한다.
-		resEaiMsg.setOrgRspErrCd(resEaiMsg.getRspErrCd());
-		resEaiMsg.setRspErrCd(EAIMessageKeys.EAI_SUCCESS_CODE, false);
-
-		return null;
-
-	}
-
-}
@@ -0,0 +1,52 @@
+package com.eactive.eai.custom.adapter.handler;
+
+import java.util.Properties;
+
+import com.eactive.eai.adapter.AdapterGroupVO;
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.handler.AdapterErrorMessageHandler;
+import com.eactive.eai.common.message.MessageType;
+import com.eactive.eai.message.StandardMessage;
+import com.eactive.eai.message.manager.StandardMessageManager;
+import com.eactive.eai.message.service.InterfaceMapper;
+import com.ext.eai.common.stdmessage.STDMessageKeys;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+public class LonErrorMsgHandler implements AdapterErrorMessageHandler {
+
+	@Override
+	public Object generateNonStandardErrorResponseMessage(String inboudnAdapterGroupName, String inboudnAdapterName,
+			Properties callProp, Object outboundRequestData, StandardMessage resStandardMessage) throws Exception{
+		
+		if(resStandardMessage != null && isErrorMessage(resStandardMessage)) {
+			AdapterGroupVO adapterGroupVO = AdapterManager.getInstance().getAdapterGroupVO(inboudnAdapterGroupName);
+			if(MessageType.JSON.equals(adapterGroupVO.getMessageType())) {
+				ObjectMapper objectMapper = new ObjectMapper();
+				String requestMessage = (String) outboundRequestData;
+				JsonNode requestJson = objectMapper.readTree(requestMessage);
+				String alncInstCd = requestJson.get("dataCmn").get("alncInstCd").asText();
+				
+				ObjectNode responseJson = objectMapper.createObjectNode();
+				ObjectNode dataCmnNode = objectMapper.createObjectNode();
+				responseJson.set("dataCmn", dataCmnNode);
+				dataCmnNode.put("fnclInstCd", "KBK");
+				dataCmnNode.put("alncInstCd", alncInstCd);
+				dataCmnNode.put("tlgrRspnsCd", "0210");
+				
+				return responseJson.toString();
+			}
+		}
+		
+		
+		return "";
+	}
+	
+	private boolean isErrorMessage(StandardMessage standardMessage) {
+		InterfaceMapper mapper = StandardMessageManager.getInstance().getMapper();
+		String responseType = mapper.getResponseType(standardMessage);
+		return STDMessageKeys.RESPONSE_TYPE_CODE_E.equals(responseType);
+	}
+
+}
@@ -1,60 +0,0 @@
-package com.eactive.eai.custom.adapter.handler;
-
-import java.util.Map;
-import java.util.Properties;
-
-import org.apache.commons.lang3.StringUtils;
-
-import com.eactive.eai.adapter.handler.TemplateAdapterErrorMsgHandler;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
-import com.eactive.eai.common.message.EAIMessage;
-import com.eactive.eai.common.message.EAIMessageKeys;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.custom.message.StandardMessageCoordinatorDJB;
-import com.eactive.eai.message.StandardItem;
-import com.eactive.eai.message.StandardMessage;
-import com.eactive.eai.message.manager.StandardMessageManager;
-import com.eactive.eai.message.service.InterfaceMapper;
-
-public class NaverpayAdapterErrorMsgHandler extends TemplateAdapterErrorMsgHandler {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	/**
-	 * 표준 -> 비표준 거래
-	 * 아웃바운드 어댑터에서 Exception이 발생했을 때, Outbound Process 응답 메시지 생성
-	 */
-	@Override
-	public Object generateOutboundErrorResponseMessage(String outboundadapterGroupName,
-			String outboundadapterName, Properties callProp, Object outboundRequestData, EAIMessage resEaiMsg)
-			throws Exception {
-		
-		StandardMessage standardMessage = resEaiMsg.getStandardMessage();
-		// msg_dvcd = EM (에러메시지)
-        standardMessage.setData(StandardMessageCoordinatorDJB.MSG_DVCD, "NM");
-
-        // 출력속성코드 = 1(팝업)
-        standardMessage.setData(StandardMessageCoordinatorDJB.MSG_OUTP_ATRB_CD, "1");
-
-        // MSG_LIST 1건 구성
-        standardMessage.setData(StandardMessageCoordinatorDJB.MSG_LIST_ROWCNT, "0");
-        StandardItem msgPart = standardMessage.findItem("MSG");
-        msgPart.getChilds().remove("MSG_LIST");
-
-        StandardMessageManager manager = StandardMessageManager.getInstance();
-        InterfaceMapper mapper = manager.getMapper();
-        
-        // mapper 에러코드 설정
-        mapper.setErrorCode(standardMessage, "");
-        mapper.setErrorMsg(standardMessage, "처리오류");
-
-        // 성공 처리 처럼 진행한다.
-        // 단, 거래로그/에러로그는 원본 에러코드 기준으로 남겨야 하므로 별도로 보관한다.
-        resEaiMsg.setOrgRspErrCd(resEaiMsg.getRspErrCd());
-        resEaiMsg.setRspErrCd(EAIMessageKeys.EAI_SUCCESS_CODE, false);
-		
-		return null;
-
-	}
-
-}
@@ -0,0 +1,897 @@
+package com.eactive.eai.custom.adapter.http.client.impl;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.hc.client5.http.classic.HttpClient;
+import org.apache.hc.client5.http.classic.methods.HttpDelete;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.classic.methods.HttpPost;
+import org.apache.hc.client5.http.classic.methods.HttpPut;
+import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase;
+import org.apache.hc.client5.http.config.RequestConfig;
+import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.apache.hc.core5.http.*;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.core5.http.io.entity.StringEntity;
+import org.apache.hc.core5.http.message.BasicNameValuePair;
+import org.apache.hc.core5.http.protocol.BasicHttpContext;
+import org.apache.hc.core5.http.protocol.HttpContext;
+import org.apache.hc.core5.net.URIBuilder;
+import org.dom4j.Document;
+import org.dom4j.Element;
+import org.dom4j.io.SAXReader;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.JSONValue;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.springframework.web.util.UriComponents;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import com.eactive.eai.adapter.http.HttpMemoryLogger;
+import com.eactive.eai.adapter.http.HttpMethodType;
+import com.eactive.eai.adapter.http.client.HttpClient5AdapterServiceSupport;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterVO;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.common.TransactionContextKeys;
+import com.eactive.eai.common.authoutbound.AccessTokenManagerByDB;
+import com.eactive.eai.common.exception.ExceptionUtil;
+import com.eactive.eai.common.message.MessageType;
+import com.eactive.eai.common.util.CommonLib;
+import com.jayway.jsonpath.DocumentContext;
+import com.jayway.jsonpath.JsonPath;
+import com.openbanking.eai.common.token.AccessTokenManager;
+import com.openbanking.eai.common.token.AccessTokenVO;
+import com.openbanking.eai.common.token.OAuth2AccessTokenVO;
+
+import com.eactive.eai.common.property.PropManager;
+
+public class HttpClient5AdapterServiceBase64 extends HttpClient5AdapterServiceSupport
+        implements HttpClientAdapterServiceKey {
+
+    public static final String TYPE_VARIABLE_URL_REQUEST = "variableUrlRequest";
+    public static final String TYPE_SIMPLE_REQUEST = "simpleRequest";
+    public static final String REST_OPTION = "REST_OPTION";
+    //public static final String HEADER_CONTENT_TYPE = "Content-Type";
+    public static final String HEADER_GROUP = "HEADER_GROUP";
+    public static final String HTTP_STATUS = "HTTP_STATUS";
+    public static final String HEADER_KEYS = "HEADER_KEYS";
+    public static final String AUTH_TOKEN = "AUTH_TOKEN";
+
+    /**
+     * 1. 기능 : REST API 통신에 사용 <br>
+     * 2. 처리 개요 : - 속성 정보를 설정 하고 수동 시스템 서비스를 호출 한다. <br>
+     * 3. 주의사항 <br>
+     *
+     * @param prop    Http Adapter 속성 정보
+     * @return 반환 된 Object
+     * @exception Exception 수동 시스템 간 통신 중 발생
+     **/
+    @SuppressWarnings({ "unchecked" })
+    public Object execute(Properties prop, Object data, Properties tempProp) throws Exception {
+        HttpClientAdapterVO vo = super.setting(prop, tempProp);
+
+        // 2025.04.09 Authorization 헤더값을 프로퍼티(AUTH_TOKEN)에서 지정하여 설정할 수 있도록 수정
+        String bizCode = "";
+        String authToken = "";
+        try {
+            Properties authProp = PropManager.getInstance().getProperties(AUTH_TOKEN); //Authorization
+            bizCode = vo.getAdapterGroupName().substring(1, 4);
+            authToken = authProp.getProperty(bizCode, "");
+        } catch (Exception e) {
+            logger.debug("Property Group AUTH_TOKEN is not Exist !!");
+        }
+
+        logger.debug("authToken :::::::::::::::::::::::::::::::::::" + authToken);
+
+        String headerGroupName = prop.getProperty(HEADER_GROUP);
+        String relayResponseHeaderKeys = prop.getProperty(HEADER_KEYS, "");
+        boolean useAdapterToken = StringUtils.equalsIgnoreCase(prop.getProperty("ADAPTER_TOKEN_USE_YN", "N"), "Y");
+
+        boolean useForwardProxy = StringUtils.equalsIgnoreCase(prop.getProperty("FORWARD_PROXY_USE_YN", "N"), "Y");
+        String forwardProxyUrl = prop.getProperty("FORWARD_PROXY_URL");
+
+        // ex) $.dataHeader.GW_RSLT_CD
+        String tokenErrorCodeKey = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_KEY");
+        String tokenErrorCodeValues = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_VALUES");
+        String tokenErrorHttpStatusCode = prop.getProperty("ADAPTER_TOKEN_ERROR_HTTP_STATUS_CODE"); // 200 or 400번대
+
+        // 레이아웃 메시지 타입 REST URL 추출 시 활용. Default JSON
+        String messageType = prop.getProperty("MESSAGE_TYPE", MessageType.JSON);
+        String inboundMethod = tempProp.getProperty(HttpAdapterServiceKey.INBOUND_METHOD, "POST");
+
+        /**
+         * @formatter:off
+         * TSEAIHE02.RESTOPTION 정보 => JSON 형태로 구성
+         * - type : simpleRequest, variableUrlRequest
+         * - extraPath : 어댑터 프로퍼티 URL에 추가될 HTTP REST URL
+         * - method : get, delete, post, put
+         * - contentType: application/json(default), application/x-www-form-urlencoded
+         * - adapterTokenUseYn: Y, N(default)
+         * ex)
+         * {"type":"simpleRequest","extraPath":"v2.0/accout/balance","method":"post"}
+         * @formatter:on
+         */
+
+        String restOptionData = tempProp.getProperty(REST_OPTION);
+
+        JSONObject restOptionObject = parseJson(restOptionData);
+        if (restOptionObject == null) {
+            throw new Exception("OptionData parsing result is NULL");
+        }
+
+        String rmethod = (String) restOptionObject.getOrDefault("method", inboundMethod);
+        String contentType = (String) restOptionObject.getOrDefault("contentType", "application/json");
+        String adapterTokenUseYn = (String) restOptionObject.get("adapterTokenUseYn");
+        if (StringUtils.isNotBlank(adapterTokenUseYn)) { // interface 에 설정된게 우선한다.
+            useAdapterToken = StringUtils.equalsIgnoreCase(adapterTokenUseYn, "Y");
+        }
+
+        HttpClient mclient = this.client;
+        String sendData = "";
+        if (data instanceof String) {
+            sendData = (String) data;
+        } else if (data instanceof byte[]) {
+            sendData = new String((byte[]) data, vo.getEncode());
+        }
+
+        ////mclient.getParams().setContentCharset(vo.getEncode());
+
+        JSONObject dataObject = null;
+
+        Object httpHeader = null;
+        Object dataContent = null;
+
+        if (MessageType.JSON.equals(messageType)) {
+
+            Object parsed = parseJsonGeneric(sendData);
+
+            if(parsed instanceof JSONObject) {
+                dataObject = parseJson(sendData);
+                if (dataObject != null && StringUtils.isNotBlank(headerGroupName)) {
+                    httpHeader = dataObject.get(headerGroupName);
+                    dataObject.remove(headerGroupName);
+                }
+
+                dataContent = dataObject;
+                if (dataObject.containsKey("innerList")) {
+                    JSONArray innerList = (JSONArray) dataObject.get("innerList");
+                    dataContent = innerList;
+                }
+            }
+        }
+
+        logger.debug("HttpClientAdapterServiceRest] dataObject1 =  [" + dataObject + "]");
+        logger.debug("HttpClientAdapterServiceRest] dataContent =  [" + dataContent + "]");
+
+        // interface 에 설정된게 우선한다.
+        String uri = null;
+        if (dataObject == null) {
+            uri = changeUrl(messageType, vo.getUrl(), restOptionData, sendData);
+        } else {
+            uri = changeUrl(messageType, vo.getUrl(), restOptionData, dataObject);
+        }
+
+//		////if (vo.getConnectionTimeout() != 0) {
+//			mclient.getHttpConnectionManager().getParams().setConnectionTimeout(vo.getConnectionTimeout());
+//		}
+
+        if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL=[" + vo.getUrl() + "] ");
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") PARAMETER_NAME=[" + vo.getParameterName() + "] ");
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") ENCODE=[" + vo.getEncode() + "] ");
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") RESPONSE_TYPE=[" + vo.getResponseType() + "] ");
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL_ENCODE_YN=[" + vo.getUrlEncodeYn() + "] ");
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") CONNECTION_TIMEOUT=[" + vo.getConnectionTimeout() + "] ");
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") REST_OPTION=["	+ restOptionData + "] ");
+        }
+
+        HttpUriRequestBase method = null;
+
+        // 메소드 타입에 따라 HttpRequestBase 인스턴스 생성
+        switch (HttpMethodType.getValue(rmethod)) {
+            case GET:
+                method = new HttpGet(uri);
+                break;
+            case DELETE:
+                method = new HttpDelete(uri);
+                break;
+            case POST:
+                method = new HttpPost(uri);
+                break;
+            case PUT:
+                method = new HttpPut(uri);
+                break;
+            default:
+                method = new HttpGet(uri);
+                break;
+        }
+
+        RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
+
+        if(useForwardProxy) {
+            java.net.URL url = new java.net.URL(forwardProxyUrl);
+
+            // 프로토콜, 호스트, 포트 추출
+            String protocol = url.getProtocol();
+            String host = url.getHost();
+            int port = url.getPort();
+            HttpHost proxy = new HttpHost(protocol,host, port);
+            requestConfigBuilder.setProxy(proxy);
+        }
+
+        configureHttpClient(requestConfigBuilder, vo, method);
+
+        switch (HttpMethodType.getValue(rmethod)) {
+            case GET:
+            case DELETE:
+                HashMap<String, String> h = getParameters(dataObject);
+                URIBuilder uriBuilder = new URIBuilder(uri);
+                for (Map.Entry<String, String> entry : h.entrySet()) {
+                    uriBuilder.addParameter(entry.getKey(), entry.getValue());
+                }
+                URI fullUri = uriBuilder.build();
+                if (method instanceof HttpGet) {
+                    ((HttpGet) method).setUri(fullUri);
+                } else if (method instanceof HttpDelete) {
+                    ((HttpDelete) method).setUri(fullUri);
+                }
+                if (logger.isDebug()) {
+                    logger.debug("HttpClientAdapterServiceRest] (get Method) QueryString = [" + fullUri.getQuery() + "]");
+                }
+                break;
+            case PUT:
+            case POST:
+                //assignPostBody(dataObject, contentType, vo.getEncode(), method);
+                assignPostBody(dataContent, contentType, vo.getEncode(), method);
+                break;
+            default:
+                break;
+        }
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") method.getParams()=["
+                    + method.getEntity() + "] ");
+        }
+
+        OAuth2AccessTokenVO accessToken = null;
+        if (useAdapterToken) {
+            AccessTokenManagerByDB tokenManager = AccessTokenManagerByDB.getInstance();
+            accessToken = (OAuth2AccessTokenVO) tokenManager.getAccessTokenVO(vo.getAdapterGroupName());
+
+            // 토큰이 없거나 만료 됐으면 재발급
+            if (accessToken == null || accessToken.isExpired()) {
+                String oldToken = accessToken == null ? null : accessToken.getAccessToken();
+                accessToken = (OAuth2AccessTokenVO) tokenManager.retryAccessTokenVO(vo.getAdapterGroupName(), prop,
+                        oldToken);
+            }
+
+            if (logger.isDebug()) {
+                logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") TOKEN = ["
+                        + accessToken + "]");
+            }
+
+            setAuthHeaders(method, accessToken);
+
+            if (logger.isDebug()) {
+                logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
+                        + ") RequestHeader [Authorization=" + method.getHeader("Authorization") + "]");
+            }
+        }
+
+        // 2025.04.09 Authorization 헤더값을 프로퍼티(AUTH_TOKEN)에서 지정하여 설정할 수 있도록 수정
+        if(!StringUtils.isBlank(authToken)) {
+            setAuthHeaders(method, authToken);
+        }
+
+        // 전달 header 셋팅
+        // Adapter 레벨 header 보다 data로 넘어온 httpHeader를 우선 적용(header명이 같다면 덮어씀)
+        assignRequestHeaders(method, httpHeader);
+
+        int status = -1;
+
+        try {
+            byte[] responseMessage = null;
+            Header[] responseHeaders;
+
+            if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+                if (dataContent != null) { //dataObject
+                    logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = ["
+                            + dataContent.toString() + "]");   //dataObject.toJSONString()
+                    logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
+                            + CommonLib.getDumpMessage(dataContent.toString())); //dataObject.toJSONString()
+                } else {
+                    logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = [" + sendData
+                            + "]");
+                    logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
+                            + CommonLib.getDumpMessage(sendData));
+                }
+            }
+            StopWatch stopWatch = new StopWatch();
+            stopWatch.start();
+
+            if (vo.getTraceLevel() >= 3) {
+                HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+                        "SEND [" + sendData + "]" + CommonLib.getDumpMessage(sendData));
+            }
+
+            String uuid = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID);
+            HttpContext context = new BasicHttpContext();
+            context.setAttribute(TransactionContextKeys.TRANSACTION_UUID, uuid);
+            context.setAttribute(HttpClientAdapterServiceKey.ADAPTER_GROUP_NAME, vo.getAdapterGroupName());
+            context.setAttribute(HttpClientAdapterServiceKey.ADAPTER_NAME, vo.getAdapterName());
+            Integer logProcessNo = (Integer) tempProp.get(HttpClientAdapterServiceKey.LOG_PROCESS_NO);
+            if (logProcessNo != null && logProcessNo > 0) {
+                context.setAttribute(HttpClientAdapterServiceKey.LOG_PROCESS_NO, logProcessNo);
+            }
+
+            try {
+                if (logger.isDebug()) {
+                    logger.debug("[method getName]" + method.getMethod());
+                    logger.debug("[method getEntity]" + method.getEntity());
+                    logger.debug("[method getRequestHeaders]" + method.getHeaders().toString());
+                    logger.debug("[method getURI]" + method.getPath());
+                }
+                try (CloseableHttpResponse response = (CloseableHttpResponse) mclient.execute(method, context)) {
+                    status = response.getCode();
+
+                    if (status >= 200 && status <= 207) {
+                        status = 200;
+                    }
+
+//					if (status == 404) {
+//						status = 200;
+//					}
+
+//                  responseMessage = EntityUtils.toByteArray(response.getEntity());
+                    responseHeaders = response.getHeaders();
+                    // 2025/08/06 Response body를 Base64로 Encode 해서 Json으로 만들어서 전달하도록 수정
+                    HttpEntity entity = response.getEntity();
+                    if (entity != null) {
+                        byte[] entityBytes = EntityUtils.toByteArray(response.getEntity());
+                        String b64 = Base64.encodeBase64String(entityBytes);
+                        JSONObject resultJson = new JSONObject();
+                        resultJson.put("base64_file_data", b64);
+                        responseMessage = resultJson.toString().getBytes();
+                    } else {
+                        responseMessage = EntityUtils.toByteArray(response.getEntity());
+                    }
+
+
+                    if (logger.isDebug()) {
+                        logger.debug("[received status]" + status);
+                        logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = [" + responseMessage + "]");
+                    }
+                }
+            } catch (ConnectException e) {
+                if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+                    logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
+                }
+                throw new Exception("excuteMethod java.net.ConnectException = " + e.getMessage());
+            }
+
+            stopWatch.stop();
+
+            /**
+             * @formatter:off
+             * OAuth 토큰 응답 체크(Adapter properties로 설정)
+             * 응답코드에 따라 유효한 토큰 확인(토큰 재발급 여부 확인)
+             * API 서비스 마다 정책이 다름(보통 400대에서 체크하나 200에서도 체크할 수 있음)
+             *
+             * TOKEN_ERROR_CODE_KEY: 응답 json error code key
+             * __ex) $.dataHeader.resultCode
+             * TOKEN_ERROR_CODE_VALUES: 토큰 재발급이 필요한 응답 error codes(ex: O0001,O0002,O0003)
+             * TOKEN_ERROR_HTTP_STATUS_CODE: 보통 400대에서 체크하나 API 제공자에 따라 200에서도 체클할수 있음
+             * ex) TOKEN_ERROR_HTTP_STATUS_CODE = 200
+             * @formatter:on
+             */
+            boolean needReissue = false;
+
+            Properties responseHeaderProp = assignRelayDataToInbound(tempProp, responseHeaders);
+            String responseString = new String(responseMessage, vo.getEncode());
+
+            Map<String, Object> map = new HashMap<String, Object>();
+            tempProp.put(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP, map);
+            map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_HEADERS, responseHeaderProp);
+            map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_MESSAGE, responseString);
+            map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_STATUS, status);
+
+            if (status >= 200 && status <= 207) {
+                if (useAdapterToken && StringUtils.equals(tokenErrorHttpStatusCode, "200")) {
+                    needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
+                            vo.getEncode());
+                }
+            } else if (status == 302) {
+                if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
+                    relayResponseHeaderKeys += ",Location";
+                }
+            } else {
+                String errMsg = String.format(
+                        "http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
+                        status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseString);
+//				logger.error(errMsg);
+
+                if (status >= 400 && status < 500) {
+                    if (useAdapterToken) {
+                        needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
+                                vo.getEncode());
+                    }
+
+//					if (!needReissue) {
+//						throw new Exception(errMsg);
+//					}
+                } else {
+
+                    throw new Exception(errMsg);
+                }
+            }
+
+            // ----------------------------------------------------------
+            if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+                logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
+                logger.debug("HttpClientAdapterServiceRest] RECV " + vo.getEncode() + "(" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode()) + "]");
+//				logger.debug("HttpClientAdapterServiceRest] RECV MS949 (" + vo.getAdapterGroupName() + ") = ["	+ new String(responseMessage, "MS949") + "]");
+//				logger.debug("HttpClientAdapterServiceRest] RECV euc-kr (" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, "euc-kr") + "]");
+                logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = " + CommonLib.getDumpMessage(responseMessage));
+            }
+
+            if (useAdapterToken) {
+                if (responseMessage == null) {
+                    throw new Exception("responseMessage is NULL, HttpStatus=" + status);
+                }
+
+                // OAuth 토큰 재요청 코드 확인
+                if (needReissue) {
+                    if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+                        logger.debug("HttpClientAdapterServiceRest] retry access token response code = ["
+                                + vo.getResponseType() + "] message = [" + new String(responseMessage, vo.getEncode())
+                                + "]");
+                    }
+
+                    // 토큰 재발급
+                    AccessTokenManager tokenManager = AccessTokenManager.getInstance();
+                    String oldToken = accessToken == null ? null : accessToken.getAccessToken();
+                    OAuth2AccessTokenVO newaccessToken = (OAuth2AccessTokenVO) tokenManager
+                            .retryAccessTokenVO(vo.getAdapterGroupName(), prop, oldToken);
+                    method.setHeader("Authorization", newaccessToken.getAuthorization());
+
+                    setAuthHeaders(method, newaccessToken);
+
+                    if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+                        logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
+                                + ") RETRY TOKEN = [" + newaccessToken + "]");
+                    }
+
+                    try (CloseableHttpResponse response = (CloseableHttpResponse) mclient.execute(method)) {
+                        status = response.getCode();
+                        responseMessage = EntityUtils.toByteArray(response.getEntity());
+
+                        if (logger.isDebug()) {
+                            logger.debug("[received status]" + status);
+                            logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode()) + "]");
+                        }
+                    }catch (IOException e){
+                        throw new Exception("retry excuteMethod Exceptioin = " + e.getMessage());
+                    }
+
+
+                    if (status == 302) {
+                        if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
+                            relayResponseHeaderKeys += ",Location";
+                        }
+                    } else {
+                        String errMsg = String.format(
+                                "http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
+                                status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseMessage);
+                        throw new Exception(errMsg);
+                    }
+
+                    // ----------------------------------------------------------
+                    if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+                        logger.debug("HttpClientAdapterServiceRest] RETRY responseType =" + vo.getResponseType());
+                        logger.debug("HttpClientAdapterServiceRest] RETRY RECV " + vo.getEncode() + "("
+                                + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode())
+                                + "]");
+                        logger.debug("HttpClientAdapterServiceRest] RETRY RECV (" + vo.getAdapterGroupName() + ") = "
+                                + CommonLib.getDumpMessage(responseMessage));
+                    }
+                    // ----------------------------------------------------------
+                }
+            }
+
+            if (vo.getTraceLevel() >= 3) {
+                HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+                        "RECV [" + new String(responseMessage, vo.getEncode()) + "]"
+                                + CommonLib.getDumpMessage(responseMessage));
+            }
+
+
+            return assignResponseHeaders(method, responseMessage, headerGroupName, vo.getEncode(), messageType,
+                    relayResponseHeaderKeys, status, responseHeaderProp);
+        } catch (SocketTimeoutException ste) { // Read Timeout :: HttpClient 3.1일 경우
+            if (vo.getTraceLevel() >= 3) {
+                HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
+                        "HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
+                                + ste.toString(),
+                        ste);
+            }
+            logger.error("HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
+                    + ste.toString(), ste);
+            throw ste;
+        } catch (ConnectException ce) {
+            if (vo.getTraceLevel() >= 3) {
+                HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
+                        "HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
+                                + ce.toString(),
+                        ce);
+            }
+            logger.error("HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
+                    + ce.toString(), ce);
+            throw ce;
+        } catch (Exception e) {
+            if (vo.getTraceLevel() >= 3) {
+                HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(), e.toString(), e);
+            }
+            logger.error("HttpClientAdapterServiceRest] Exception (" + vo.getAdapterGroupName() + ") : " + e.toString(),
+                    e);
+            throw e;
+        } finally {
+            if (status != HttpStatus.SC_OK) {
+                String[] msgArgs = new String[1];
+                msgArgs[0] = String.valueOf(status);
+                String resMsg = ExceptionUtil.make("RDCEAIAHA013", msgArgs);
+                if (logger.isDebug()) {
+                    logger.debug(resMsg);
+                }
+            }
+        }
+    }
+
+    private Properties assignRelayDataToInbound(Properties prop, Header[] responseHeaders) {
+        Properties headerProp = new Properties();
+        if (responseHeaders == null || responseHeaders.length == 0) {
+            return headerProp;
+        }
+
+        for (Header header : responseHeaders) {
+            headerProp.put(header.getName(), header.getValue());
+        }
+
+        return headerProp;
+    }
+
+    /**
+     * 현재 1단계 레이아웃에만 적용되도록 구현됨.
+     *
+     * @param method
+     * @param responseMessage
+     * @param headerGroupName
+     * @param encode
+     * @param messageType
+     * @param relayHeaderKeys
+     * @return
+     * @throws Exception
+     */
+    @SuppressWarnings("unchecked")
+    private String assignResponseHeaders(HttpUriRequestBase method, byte[] responseMessage, String headerGroupName,
+                                         String encode, String messageType, String relayHeaderKeys, int status, Properties responseHeaderProp) throws Exception {
+        if (!MessageType.JSON.equals(messageType) || StringUtils.isBlank(headerGroupName)
+                || StringUtils.isBlank(relayHeaderKeys)) {
+            return new String(responseMessage, encode);
+        }
+
+        String[] relayKeyArr = org.springframework.util.StringUtils.tokenizeToStringArray(relayHeaderKeys, ",");
+        JSONObject headerJson = new JSONObject();
+        for (String key : relayKeyArr) {
+            String value = responseHeaderProp.getProperty(key);
+            if (StringUtils.isNotBlank(value)) {
+                headerJson.put(key, value);
+            }
+        }
+
+        headerJson.put(HTTP_STATUS, String.valueOf(status));
+
+        if (headerJson.size() <= 0) {
+            return new String(responseMessage, encode);
+        }
+
+        JSONObject message = null;
+        if (responseMessage == null || responseMessage.length == 0) {
+            message = new JSONObject();
+        } else {
+            message = parseJson(new String(responseMessage, encode));
+            if (message == null) {
+                message = new JSONObject();
+                message.put("Malformed_Response_Message", new String(responseMessage, encode));
+            }
+        }
+
+        if (StringUtils.isNotBlank(headerGroupName) && message != null)
+            message.put(headerGroupName, headerJson);
+
+        logger.info("------------- message --------------- : {} ", message);
+
+        return message.toJSONString();
+    }
+
+    // 2025.04.09 Authorization 헤더값을 프로퍼티(AUTH_TOKEN)에서 지정하여 설정할 수 있도록 수정
+    private void setAuthHeaders(HttpUriRequestBase method, String authorization) throws Exception {
+        method.setHeader("Authorization",
+                String.format("%s", authorization));
+    }
+
+    private void setAuthHeaders(HttpUriRequestBase method, OAuth2AccessTokenVO accessToken) throws Exception {
+        method.setHeader("Authorization",
+                String.format("%s %s", AccessTokenVO.BEARER_TYPE, accessToken.getAccessToken()));
+    }
+
+    private boolean checkTokenRetry(byte[] responseMessage, String tokenErrorCodeKey, String tokenErrorCodeValues,
+                                    String encode) {
+        if (responseMessage == null) {
+            return false;
+        }
+
+        if (StringUtils.isBlank(tokenErrorCodeKey)) {
+            return false;
+        }
+
+        if (StringUtils.isBlank(tokenErrorCodeValues)) {
+            return false;
+        }
+
+        try {
+            DocumentContext jsonContext = JsonPath.parse(new String(responseMessage, encode));
+            String responseCode = jsonContext.read(tokenErrorCodeKey);
+            if (StringUtils.isBlank(responseCode)) {
+                return false;
+            }
+
+            String[] arr = org.springframework.util.StringUtils.tokenizeToStringArray(tokenErrorCodeValues, ",");
+            return ArrayUtils.contains(arr, responseCode);
+        } catch (Exception e) {
+            logger.error("HttpClientAdapterServiceRest] checkTokenRetry error=" + e.getMessage());
+        }
+
+        return false;
+    }
+
+    private void assignRequestHeaders(HttpUriRequestBase method, Object httpHeader) {
+        if (httpHeader == null) {
+            return;
+        }
+
+        if (httpHeader instanceof JSONObject) {
+            JSONObject jsonObject = (JSONObject) httpHeader;
+            for (Object key : jsonObject.keySet()) {
+                Object obj = jsonObject.get(key);
+                if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+                    continue;
+                }
+
+                method.setHeader((String) key, (String) obj);
+
+                if (logger.isDebugEnabled()) {
+                    logger.debug("Request Header :" + (String) key + "=[" + (String) obj + "]");
+                }
+
+            }
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private void assignPostBody(Object eaiBody, String contentType, String charset, HttpUriRequestBase method) {
+        if (eaiBody == null) {
+            return;
+        }
+
+        if (StringUtils.contains(contentType, "application/x-www-form-urlencoded")) {
+            if (eaiBody instanceof JSONObject) {
+                List<NameValuePair> params = new ArrayList<>();
+                JSONObject jsonObject = (JSONObject) eaiBody;
+                for (Object key : jsonObject.keySet()) {
+                    params.add(new BasicNameValuePair((String) key, (String) jsonObject.get(key)));
+                }
+
+                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, StandardCharsets.UTF_8);
+                method.setEntity(entity);
+            }
+
+        } else {
+            ContentType contentTypeObj = ContentType.create(contentType, charset);
+
+            // 요청 본문을 StringEntity 객체로 생성
+            StringEntity entity = new StringEntity(eaiBody.toString(), contentTypeObj);
+
+            // 요청에 본문 추가
+            method.setEntity(entity);
+        }
+    }
+
+    private HashMap<String, String> getParameters(Object message) throws Exception {
+
+        HashMap<String, String> result = new HashMap<String, String>();
+
+        if (message != null) {
+            if (message instanceof JSONObject) {
+                JSONObject jsonObject = (JSONObject) message;
+                for (Object key : jsonObject.keySet()) {
+                    Object obj = jsonObject.get(key);
+                    if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+                        continue;
+                    }
+                    result.put((String) key, getStringValue(obj));
+                }
+            } else {
+                String[] messages = ((String) message).split("&");
+                String[] data = null;
+
+                for (int i = 0; i < messages.length; i++) {
+                    data = messages[i].split("=", 2);
+                    if (data.length == 2) {
+                        result.put(data[0], data[1]);
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public String getStringValue(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+
+        if (obj instanceof String) {
+            return (String) obj;
+        } else if (obj instanceof Long) {
+            return Long.toString((Long) obj);
+        } else if (obj instanceof BigDecimal) {
+            return ((BigDecimal) obj).toPlainString();
+        } else {
+            return (String) obj;
+        }
+    }
+
+    public static Object parseJsonGeneric(String jsonData) {
+        if (StringUtils.isBlank(jsonData)) {
+            return null;
+        }
+
+        try {
+            JSONParser parser = new JSONParser();
+            Object parsedObj = parser.parse(jsonData);
+            return parsedObj;
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private JSONObject parseJson(String message) throws Exception {
+        if (message == null) {
+            return null;
+        }
+
+        return (JSONObject) JSONValue.parse(message);
+    }
+
+    private Document convertXmlDocument(String message) throws Exception {
+        SAXReader builder = new SAXReader();
+        Document document = builder.read(new StringReader(message));
+        return document;
+    }
+
+    @SuppressWarnings("deprecation")
+    private String changeUrl(String messageType, String url, String restOption, Object sendData) {
+        if ((MessageType.JSON.equals(messageType) || MessageType.XML.equals(messageType))) {
+            try {
+                if (StringUtils.isBlank(restOption)) {
+                    return url;
+                }
+                List<String> urlVariableList = new ArrayList<String>();
+                JSONObject restOptionObject = parseJson(restOption);
+
+                if (restOptionObject == null)
+                    throw new Exception("restOption is NULL");
+
+                String type = (String) restOptionObject.get("type");
+                String requestExtraPath = (String) restOptionObject.get("extraPath");
+                url = getUrl(url, requestExtraPath);
+                if (TYPE_VARIABLE_URL_REQUEST.equals(type)) {
+                    Pattern p = Pattern.compile("\\{(.*?)\\}");
+                    Matcher m = p.matcher(requestExtraPath);
+                    List<String> uriVariables = new ArrayList<>();
+                    while(m.find()) {
+                        String fieldName = m.group(1);
+                        uriVariables.add(fieldName);
+                    }
+                    if (MessageType.JSON.equals(messageType)) {
+                        JSONObject jsonObject;
+                        if (sendData instanceof JSONObject) {
+                            jsonObject = (JSONObject) sendData;
+                        } else {
+                            jsonObject = (JSONObject) JSONValue.parse((String) sendData);
+                        }
+                        for (Object tempObject : uriVariables) {
+                            String urlVaribleId = (String) tempObject;
+                            String uriVariable = (String) jsonObject.get(urlVaribleId);
+                            urlVariableList.add(uriVariable);
+                            jsonObject.remove(urlVaribleId);
+                        }
+                    } else if (MessageType.XML.equals(messageType)) {
+                        Document doc;
+                        if (sendData instanceof Document) {
+                            doc = (Document) sendData;
+                        } else {
+                            doc = convertXmlDocument((String) sendData);
+                        }
+                        for (Object tempObject : uriVariables) {
+                            String urlVaribleId = (String) tempObject;
+                            Element element = (Element) doc.selectSingleNode("//" + urlVaribleId);
+                            urlVariableList.add(element.getText());
+                            if (doc.getRootElement() == element) {
+                                doc = null;
+                            } else {
+                                element.getParent().remove(element);
+                            }
+                        }
+                    }
+                    if (urlVariableList.size() > 0) {
+                        UriComponents uriComponents = UriComponentsBuilder.fromUriString(url).build();
+                        Object[] urls = urlVariableList.toArray();
+                        url = uriComponents.expand(urls).toUriString();
+                        logger.debug("HttpClientAdapterServiceRest] after extand url=[" + url + "] ");
+                    }
+                }
+            } catch (Exception e) {
+                logger.error("Failed to change url", e);
+            }
+        }
+        return url;
+    }
+
+    private String getUrl(String baseUrl, String extraPath) {
+        if (StringUtils.isBlank(extraPath)) {
+            return baseUrl;
+        }
+
+        if (StringUtils.contains(extraPath, "http://") || StringUtils.contains(extraPath, "https://")) {
+            return extraPath;
+        }
+
+        String targetUrl = baseUrl;
+        if (!targetUrl.endsWith("/")) {
+            targetUrl += "/";
+        }
+        if (extraPath.startsWith("/")) {
+            targetUrl += extraPath.substring(1);
+        } else {
+            targetUrl += extraPath;
+        }
+
+        logger.debug("HttpClientAdapterServiceRest] after concatenate url=[" + targetUrl + "] ");
+        return targetUrl;
+    }
+
+}
@@ -1,136 +0,0 @@
-package com.eactive.eai.custom.adapter.http.client.impl;
-
-import java.io.UnsupportedEncodingException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.util.Arrays;
-import java.util.Properties;
-
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-
-import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase;
-
-import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
-import com.eactive.eai.adapter.http.client.impl.HttpClient5AdapterServiceRest;
-import com.eactive.eai.common.property.PropManager;
-import com.eactive.eai.common.util.MaskingUtils;
-
-/**
- * 1. 기능 : EAI HTTP OutBound 용 어댑터로 수동 시스템의 HTTP 웹 컴포넌트를 GET/POST 방식으로 호출할 수 있는
- * 기능을 제공한다.<br>
- * 2. 처리 개요 : <br>
- * * - 2020-09-25: Http Header 받아서 처리할 수 있게 기능 추가<br>
- * 3. 주의사항 <br> 
- *
- * @author :
- * @version : v 1.0.0
- * @see : HttpClientAdapterServiceFactory.java,
- *      HttpClientAdapterServiceSupport.java
- * @since :
- *
- */
-public class HttpClient5AdapterServiceBigTech extends HttpClient5AdapterServiceRest
-		implements HttpClientAdapterServiceKey {
-	
-	private static final char[] _HEX_LOWER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
-			'e', 'f' };
-
-	private static String hexEncode(byte[] data) {
-
-		if (data == null) {
-			return null;
-		}
-
-		int length = data.length;
-		char[] encoded = new char[length << 1];
-
-		for (int i = 0, j = 0; i < length; i++) {
-			encoded[j++] = _HEX_LOWER[(0xF0 & data[i]) >>> 4];
-			encoded[j++] = _HEX_LOWER[0x0F & data[i]];
-		}
-
-		return new String(encoded);
-	} // end of hex_encode
-
-	private static final String _BTP_CHARSET = "UTF-8";
-	private static final String _BTP_ALGORITHM = "HmacSHA256";
-	private static final String _BTP_ACCESS_KEY = "{BTP_ACCESS_KEY}";
-	private static final String _BTP_SECRET_KEY = "{BTP_SECRET_KEY}";
-
-	private static byte[] mac(String charset, String algorithm, String timestamp, String accessKey, String secretKey,
-			String url) throws UnsupportedEncodingException, NoSuchAlgorithmException, InvalidKeyException {
-		String message = String.join(" ", Arrays.asList(url, timestamp, accessKey));
-		SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(charset), algorithm);
-		Mac mac = Mac.getInstance(algorithm);
-		mac.init(secretKeySpec);
-
-		return mac.doFinal(message.getBytes(charset));
-	}// end of mac
-
-	private static String macHex(String charset, String algorithm, String timestamp, String accessKey, String secretKey,
-			String url) throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException {
-		return hexEncode(mac(charset, algorithm, timestamp, accessKey, secretKey, url));
-	}// end of macHex
-	
-	protected void assignRequestHeaders(HttpUriRequestBase method, Object httpHeader, Properties prop, Properties tempProp) {
-		super.assignRequestHeaders(method, httpHeader, prop, tempProp);
-
-		try {
-			String adapterGroupName = tempProp.getProperty(ADAPTER_GROUP_NAME);
-			Properties customProp = PropManager.getInstance().getProperties(adapterGroupName);
-			String charset = customProp.getProperty("_BTP_CHARSET", _BTP_CHARSET);
-			String algorithm = customProp.getProperty("_BTP_ALGORITHM", _BTP_ALGORITHM);
-			String timestamp = System.currentTimeMillis() + "";
-			String accessKey = customProp.getProperty("_BTP_ACCESS_KEY", _BTP_ACCESS_KEY);
-			String secretKey = customProp.getProperty("_BTP_SECRET_KEY", _BTP_SECRET_KEY);
-			if(logger.isDebug()) {
-				logger.debug("charset={}", charset);
-				logger.debug("algorithm={}", algorithm);
-				logger.debug("timestamp={}", timestamp);
-				logger.debug("accessKey={}", accessKey);
-				logger.debug("secretKey={}", MaskingUtils.maskPassword(secretKey));
-				logger.debug("url={}", method.getRequestUri());
-			}
-			
-			String signature = macHex(charset// charset
-					, algorithm// algorithm
-					, timestamp// timestamp
-					, accessKey// accessKey
-					, secretKey// secretKey
-					, method.getRequestUri());
-			
-			method.setHeader("x-btp-access-key", accessKey);
-			method.setHeader("x-btp-timestamp", timestamp);
-			method.setHeader("x-btp-signature-v1", signature);
-
-		} catch (InvalidKeyException | UnsupportedEncodingException | NoSuchAlgorithmException e) {
-			throw new RuntimeException("BigTech 헤더 설정 실패", e);
-		}
-	}
-	
-//	public static void main(String[] args) {
-//        try {
-//            String url = "/rest/v1/service?param0=&param1=";
-//            String timestamp = System.currentTimeMillis()+"";
-//            String accessKey = _BTP_ACCESS_KEY;
-//            String secretKey = _BTP_SECRET_KEY;
-//            String signature = macHex(
-//            	  _BTP_CHARSET//charset
-//                , _BTP_ALGORITHM//algorithm
-//                , timestamp// timestamp
-//                , _BTP_ACCESS_KEY//accessKey
-//                , _BTP_SECRET_KEY//secretKey
-//                , url
-//            );
-//            System.out.println(String.format("charset=%s", _BTP_CHARSET));
-//            System.out.println(String.format("algorithm=%s", _BTP_ALGORITHM));
-//            System.out.println(String.format("accessKey=%s", accessKey));
-//            System.out.println(String.format("secretKey=%s", secretKey));
-//            System.out.println(String.format("timestamp=%s", timestamp));
-//            System.out.println(String.format("signature=%s", signature));
-//        } catch (Exception e) {
-//            e.printStackTrace();
-//        }
-//    }// end of main
-}
@@ -0,0 +1,888 @@
+package com.eactive.eai.custom.adapter.http.client.impl;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.apache.hc.client5.http.classic.HttpClient;
+import org.apache.hc.client5.http.classic.methods.HttpDelete;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.classic.methods.HttpPost;
+import org.apache.hc.client5.http.classic.methods.HttpPut;
+import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase;
+import org.apache.hc.client5.http.config.RequestConfig;
+import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.apache.hc.core5.http.ContentType;
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.HttpStatus;
+import org.apache.hc.core5.http.NameValuePair;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.core5.http.io.entity.StringEntity;
+import org.apache.hc.core5.http.message.BasicNameValuePair;
+import org.apache.hc.core5.http.protocol.BasicHttpContext;
+import org.apache.hc.core5.http.protocol.HttpContext;
+import org.apache.hc.core5.net.URIBuilder;
+import org.dom4j.Document;
+import org.dom4j.Element;
+import org.dom4j.io.SAXReader;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.JSONValue;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.springframework.web.util.UriComponents;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import com.eactive.eai.adapter.http.HttpMemoryLogger;
+import com.eactive.eai.adapter.http.HttpMethodType;
+import com.eactive.eai.adapter.http.client.HttpClient5AdapterServiceSupport;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterVO;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.common.TransactionContextKeys;
+import com.eactive.eai.common.authoutbound.AccessTokenManagerByDB;
+import com.eactive.eai.common.exception.ExceptionUtil;
+import com.eactive.eai.common.message.MessageType;
+import com.eactive.eai.common.util.CommonLib;
+import com.jayway.jsonpath.DocumentContext;
+import com.jayway.jsonpath.JsonPath;
+import com.openbanking.eai.common.token.AccessTokenManager;
+import com.openbanking.eai.common.token.AccessTokenVO;
+import com.openbanking.eai.common.token.OAuth2AccessTokenVO;
+
+import com.eactive.eai.common.property.PropManager;
+
+public class HttpClient5AdapterServiceKbank extends HttpClient5AdapterServiceSupport
+		implements HttpClientAdapterServiceKey {
+	
+	public static final String TYPE_VARIABLE_URL_REQUEST = "variableUrlRequest";
+	public static final String TYPE_SIMPLE_REQUEST = "simpleRequest";
+	public static final String REST_OPTION = "REST_OPTION";
+	//public static final String HEADER_CONTENT_TYPE = "Content-Type";
+	public static final String HEADER_GROUP = "HEADER_GROUP";
+	public static final String HTTP_STATUS = "HTTP_STATUS";
+	public static final String HEADER_KEYS = "HEADER_KEYS";
+	public static final String AUTH_TOKEN = "AUTH_TOKEN";
+	
+	/**
+	 * 1. 기능 : REST API 통신에 사용 <br>
+	 * 2. 처리 개요 : - 속성 정보를 설정 하고 수동 시스템 서비스를 호출 한다. <br>
+	 * 3. 주의사항 <br>
+	 *
+	 * @param prop    Http Adapter 속성 정보
+	 * @return 반환 된 Object
+	 * @exception Exception 수동 시스템 간 통신 중 발생
+	 **/
+	@SuppressWarnings({ "unchecked" })
+	public Object execute(Properties prop, Object data, Properties tempProp) throws Exception {
+		HttpClientAdapterVO vo = super.setting(prop, tempProp);
+
+		// 2025.04.09 Authorization 헤더값을 프로퍼티(AUTH_TOKEN)에서 지정하여 설정할 수 있도록 수정
+		String bizCode = "";
+		String authToken = "";
+		try {
+			Properties authProp = PropManager.getInstance().getProperties(AUTH_TOKEN); //Authorization
+			bizCode = vo.getAdapterGroupName().substring(1, 4);
+			authToken = authProp.getProperty(bizCode, "");
+		} catch (Exception e) {
+			logger.debug("Property Group AUTH_TOKEN is not Exist !!");
+		}
+      		
+        logger.debug("authToken :::::::::::::::::::::::::::::::::::" + authToken);
+             
+		String headerGroupName = prop.getProperty(HEADER_GROUP);
+		String relayResponseHeaderKeys = prop.getProperty(HEADER_KEYS, "");
+		boolean useAdapterToken = StringUtils.equalsIgnoreCase(prop.getProperty("ADAPTER_TOKEN_USE_YN", "N"), "Y");
+
+		boolean useForwardProxy = StringUtils.equalsIgnoreCase(prop.getProperty("FORWARD_PROXY_USE_YN", "N"), "Y");
+		String forwardProxyUrl = prop.getProperty("FORWARD_PROXY_URL");
+
+		// ex) $.dataHeader.GW_RSLT_CD
+		String tokenErrorCodeKey = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_KEY");
+		String tokenErrorCodeValues = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_VALUES");
+		String tokenErrorHttpStatusCode = prop.getProperty("ADAPTER_TOKEN_ERROR_HTTP_STATUS_CODE"); // 200 or 400번대
+
+		// 레이아웃 메시지 타입 REST URL 추출 시 활용. Default JSON
+		String messageType = prop.getProperty("MESSAGE_TYPE", MessageType.JSON);
+		String inboundMethod = tempProp.getProperty(HttpAdapterServiceKey.INBOUND_METHOD, "POST");
+
+		/**
+		 * @formatter:off
+		 * TSEAIHE02.RESTOPTION 정보 => JSON 형태로 구성
+		 * - type : simpleRequest, variableUrlRequest
+		 * - extraPath : 어댑터 프로퍼티 URL에 추가될 HTTP REST URL
+		 * - method : get, delete, post, put
+		 * - contentType: application/json(default), application/x-www-form-urlencoded
+		 * - adapterTokenUseYn: Y, N(default)
+		 * ex)
+		 * {"type":"simpleRequest","extraPath":"v2.0/accout/balance","method":"post"}
+		 * @formatter:on
+		 */
+
+		String restOptionData = tempProp.getProperty(REST_OPTION);
+
+		JSONObject restOptionObject = parseJson(restOptionData);
+		if (restOptionObject == null) {
+			throw new Exception("OptionData parsing result is NULL");
+		}
+
+		String rmethod = (String) restOptionObject.getOrDefault("method", inboundMethod);
+		String contentType = (String) restOptionObject.getOrDefault("contentType", "application/json");
+		String adapterTokenUseYn = (String) restOptionObject.get("adapterTokenUseYn");
+		if (StringUtils.isNotBlank(adapterTokenUseYn)) { // interface 에 설정된게 우선한다.
+			useAdapterToken = StringUtils.equalsIgnoreCase(adapterTokenUseYn, "Y");
+		}
+
+		HttpClient mclient = this.client;
+		String sendData = "";
+		if (data instanceof String) {
+			sendData = (String) data;
+		} else if (data instanceof byte[]) {
+			sendData = new String((byte[]) data, vo.getEncode());
+		}
+		
+		////mclient.getParams().setContentCharset(vo.getEncode());
+
+		JSONObject dataObject = null;	
+		
+		Object httpHeader = null;
+	    Object dataContent = null;
+	    
+		if (MessageType.JSON.equals(messageType)) {
+			
+			Object parsed = parseJsonGeneric(sendData);
+			
+			if(parsed instanceof JSONObject) {			
+				dataObject = parseJson(sendData);
+				if (dataObject != null && StringUtils.isNotBlank(headerGroupName)) {
+					httpHeader = dataObject.get(headerGroupName);
+					dataObject.remove(headerGroupName);
+				}
+				
+				dataContent = dataObject;
+				if (dataObject.containsKey("innerList")) {
+					JSONArray innerList = (JSONArray) dataObject.get("innerList");
+					dataContent = innerList;
+                }
+			}
+		}
+
+		logger.debug("HttpClientAdapterServiceRest] dataObject1 =  [" + dataObject + "]");
+		logger.debug("HttpClientAdapterServiceRest] dataContent =  [" + dataContent + "]");
+
+		// interface 에 설정된게 우선한다.
+		String uri = null;
+		if (dataObject == null) {
+			uri = changeUrl(messageType, vo.getUrl(), restOptionData, sendData);
+		} else {
+			uri = changeUrl(messageType, vo.getUrl(), restOptionData, dataObject);
+		}
+
+//		////if (vo.getConnectionTimeout() != 0) {
+//			mclient.getHttpConnectionManager().getParams().setConnectionTimeout(vo.getConnectionTimeout());
+//		}
+
+		if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL=[" + vo.getUrl() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") PARAMETER_NAME=[" + vo.getParameterName() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") ENCODE=[" + vo.getEncode() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") RESPONSE_TYPE=[" + vo.getResponseType() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL_ENCODE_YN=[" + vo.getUrlEncodeYn() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") CONNECTION_TIMEOUT=[" + vo.getConnectionTimeout() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") REST_OPTION=["	+ restOptionData + "] ");
+		}
+
+		HttpUriRequestBase method = null;
+
+		// 메소드 타입에 따라 HttpRequestBase 인스턴스 생성
+		switch (HttpMethodType.getValue(rmethod)) {
+			case GET:
+				method = new HttpGet(uri);
+				break;
+			case DELETE:
+				method = new HttpDelete(uri);
+				break;
+			case POST:
+				method = new HttpPost(uri);
+				break;
+			case PUT:
+				method = new HttpPut(uri);
+				break;
+			default:
+				method = new HttpGet(uri);
+				break;
+		}
+
+		RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
+
+		if(useForwardProxy) {
+			java.net.URL url = new java.net.URL(forwardProxyUrl);
+
+			// 프로토콜, 호스트, 포트 추출
+			String protocol = url.getProtocol();
+			String host = url.getHost();
+			int port = url.getPort();
+			HttpHost proxy = new HttpHost(protocol,host, port);
+			requestConfigBuilder.setProxy(proxy);
+		}
+
+		configureHttpClient(requestConfigBuilder, vo, method);
+
+		switch (HttpMethodType.getValue(rmethod)) {
+			case GET:
+			case DELETE:
+				HashMap<String, String> h = getParameters(dataObject);
+				URIBuilder uriBuilder = new URIBuilder(uri);
+				for (Map.Entry<String, String> entry : h.entrySet()) {
+					uriBuilder.addParameter(entry.getKey(), entry.getValue());
+				}
+				URI fullUri = uriBuilder.build();
+				if (method instanceof HttpGet) {
+					((HttpGet) method).setUri(fullUri);
+				} else if (method instanceof HttpDelete) {
+					((HttpDelete) method).setUri(fullUri);
+				}
+				if (logger.isDebug()) {
+					logger.debug("HttpClientAdapterServiceRest] (get Method) QueryString = [" + fullUri.getQuery() + "]");
+				}
+				break;
+			case PUT:
+			case POST:
+				//assignPostBody(dataObject, contentType, vo.getEncode(), method);
+				assignPostBody(dataContent, contentType, vo.getEncode(), method);
+				break;
+			default:
+				break;
+		}
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") method.getParams()=["
+					+ method.getEntity() + "] ");
+		}
+
+		OAuth2AccessTokenVO accessToken = null;
+		if (useAdapterToken) {
+			AccessTokenManagerByDB tokenManager = AccessTokenManagerByDB.getInstance();
+			accessToken = (OAuth2AccessTokenVO) tokenManager.getAccessTokenVO(vo.getAdapterGroupName());
+
+			// 토큰이 없거나 만료 됐으면 재발급
+			if (accessToken == null || accessToken.isExpired()) {
+				String oldToken = accessToken == null ? null : accessToken.getAccessToken();
+				accessToken = (OAuth2AccessTokenVO) tokenManager.retryAccessTokenVO(vo.getAdapterGroupName(), prop,
+						oldToken);
+			}
+
+			if (logger.isDebug()) {
+				logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") TOKEN = ["
+						+ accessToken + "]");
+			}
+			
+			setAuthHeaders(method, accessToken);
+
+			if (logger.isDebug()) {
+				logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
+						+ ") RequestHeader [Authorization=" + method.getHeader("Authorization") + "]");
+			}
+		}
+
+		// 2025.04.09 Authorization 헤더값을 프로퍼티(AUTH_TOKEN)에서 지정하여 설정할 수 있도록 수정
+		if(!StringUtils.isBlank(authToken)) {	
+			setAuthHeaders(method, authToken);			
+		}
+
+		// 전달 header 셋팅
+		// Adapter 레벨 header 보다 data로 넘어온 httpHeader를 우선 적용(header명이 같다면 덮어씀)
+		assignRequestHeaders(method, httpHeader);
+
+		int status = -1;
+
+		try {
+			byte[] responseMessage = null;
+			Header[] responseHeaders;
+
+			if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+				if (dataContent != null) { //dataObject
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = ["
+							+ dataContent.toString() + "]");   //dataObject.toJSONString()
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
+							+ CommonLib.getDumpMessage(dataContent.toString())); //dataObject.toJSONString()
+				} else {
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = [" + sendData
+							+ "]");
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
+							+ CommonLib.getDumpMessage(sendData));
+				}
+			}
+			StopWatch stopWatch = new StopWatch();
+			stopWatch.start();
+
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"SEND [" + sendData + "]" + CommonLib.getDumpMessage(sendData));
+			}
+
+			String uuid = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID);
+			HttpContext context = new BasicHttpContext();
+			context.setAttribute(TransactionContextKeys.TRANSACTION_UUID, uuid);
+			context.setAttribute(HttpClientAdapterServiceKey.ADAPTER_GROUP_NAME, vo.getAdapterGroupName());
+			context.setAttribute(HttpClientAdapterServiceKey.ADAPTER_NAME, vo.getAdapterName());
+			Integer logProcessNo = (Integer) tempProp.get(HttpClientAdapterServiceKey.LOG_PROCESS_NO);
+			if (logProcessNo != null && logProcessNo > 0) {
+				context.setAttribute(HttpClientAdapterServiceKey.LOG_PROCESS_NO, logProcessNo);
+			}
+
+			try {
+				if (logger.isDebug()) {
+					logger.debug("[method getName]" + method.getMethod());
+					logger.debug("[method getEntity]" + method.getEntity());
+					logger.debug("[method getRequestHeaders]" + method.getHeaders().toString());
+					logger.debug("[method getURI]" + method.getPath());
+				}
+				try (CloseableHttpResponse response = (CloseableHttpResponse) mclient.execute(method, context)) {
+					status = response.getCode();
+					
+					if (status >= 200 && status <= 207) {
+						status = 200;
+					}
+					
+//					if (status == 404) {
+//						status = 200;
+//					}
+					
+					responseMessage = EntityUtils.toByteArray(response.getEntity());
+					responseHeaders = response.getHeaders();
+
+					if (logger.isDebug()) {
+						logger.debug("[received status]" + status);
+						logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = [" + responseMessage + "]");
+					}
+				}
+			} catch (ConnectException e) {
+				if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+					logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
+				}
+				throw new Exception("excuteMethod java.net.ConnectException = " + e.getMessage());
+			}
+
+			stopWatch.stop();
+
+			/**
+			 * @formatter:off
+			 * OAuth 토큰 응답 체크(Adapter properties로 설정)
+			 * 응답코드에 따라 유효한 토큰 확인(토큰 재발급 여부 확인)
+			 * API 서비스 마다 정책이 다름(보통 400대에서 체크하나 200에서도 체크할 수 있음)
+			 * 
+			 * TOKEN_ERROR_CODE_KEY: 응답 json error code key
+			 * __ex) $.dataHeader.resultCode
+			 * TOKEN_ERROR_CODE_VALUES: 토큰 재발급이 필요한 응답 error codes(ex: O0001,O0002,O0003)
+			 * TOKEN_ERROR_HTTP_STATUS_CODE: 보통 400대에서 체크하나 API 제공자에 따라 200에서도 체클할수 있음
+			 * ex) TOKEN_ERROR_HTTP_STATUS_CODE = 200
+			 * @formatter:on
+			 */
+			boolean needReissue = false;
+			
+			Properties responseHeaderProp = assignRelayDataToInbound(tempProp, responseHeaders);
+			String responseString = new String(responseMessage, vo.getEncode());
+			
+			Map<String, Object> map = new HashMap<String, Object>();
+			tempProp.put(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP, map);
+			map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_HEADERS, responseHeaderProp);
+			map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_MESSAGE, responseString);
+			map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_STATUS, status);
+
+			if (status >= 200 && status <= 207) {
+				if (useAdapterToken && StringUtils.equals(tokenErrorHttpStatusCode, "200")) {
+					needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
+							vo.getEncode());
+				}
+			} else if (status == 302) {
+				if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
+					relayResponseHeaderKeys += ",Location";
+				}
+			} else {
+				String errMsg = String.format(
+						"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
+						status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseString);
+//				logger.error(errMsg);
+				
+				if (status >= 400 && status < 500) {
+					if (useAdapterToken) {
+						needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
+								vo.getEncode());
+					}
+
+//					if (!needReissue) {
+//						throw new Exception(errMsg);
+//					}
+				} else {
+		
+					throw new Exception(errMsg);
+				}
+			}
+
+			// ----------------------------------------------------------
+			if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+				logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
+				logger.debug("HttpClientAdapterServiceRest] RECV " + vo.getEncode() + "(" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode()) + "]");
+//				logger.debug("HttpClientAdapterServiceRest] RECV MS949 (" + vo.getAdapterGroupName() + ") = ["	+ new String(responseMessage, "MS949") + "]");
+//				logger.debug("HttpClientAdapterServiceRest] RECV euc-kr (" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, "euc-kr") + "]");
+				logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = " + CommonLib.getDumpMessage(responseMessage));
+			}
+
+			if (useAdapterToken) {
+				if (responseMessage == null) {
+					throw new Exception("responseMessage is NULL, HttpStatus=" + status);
+				}
+
+				// OAuth 토큰 재요청 코드 확인
+				if (needReissue) {
+					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+						logger.debug("HttpClientAdapterServiceRest] retry access token response code = ["
+								+ vo.getResponseType() + "] message = [" + new String(responseMessage, vo.getEncode())
+								+ "]");
+					}
+
+					// 토큰 재발급
+					AccessTokenManager tokenManager = AccessTokenManager.getInstance();
+					String oldToken = accessToken == null ? null : accessToken.getAccessToken();
+					OAuth2AccessTokenVO newaccessToken = (OAuth2AccessTokenVO) tokenManager
+							.retryAccessTokenVO(vo.getAdapterGroupName(), prop, oldToken);
+					method.setHeader("Authorization", newaccessToken.getAuthorization());
+
+					setAuthHeaders(method, newaccessToken);
+
+					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+						logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
+								+ ") RETRY TOKEN = [" + newaccessToken + "]");
+					}
+
+					try (CloseableHttpResponse response = (CloseableHttpResponse) mclient.execute(method)) {
+						status = response.getCode();
+						responseMessage = EntityUtils.toByteArray(response.getEntity());
+
+						if (logger.isDebug()) {
+							logger.debug("[received status]" + status);
+							logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode()) + "]");
+						}
+					}catch (IOException e){
+						throw new Exception("retry excuteMethod Exceptioin = " + e.getMessage());
+					}
+
+
+					if (status == 302) {
+						if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
+							relayResponseHeaderKeys += ",Location";
+						}
+					} else {
+						String errMsg = String.format(
+								"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
+								status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseMessage);
+						throw new Exception(errMsg);
+					}
+
+					// ----------------------------------------------------------
+					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+						logger.debug("HttpClientAdapterServiceRest] RETRY responseType =" + vo.getResponseType());
+						logger.debug("HttpClientAdapterServiceRest] RETRY RECV " + vo.getEncode() + "("
+								+ vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode())
+								+ "]");
+						logger.debug("HttpClientAdapterServiceRest] RETRY RECV (" + vo.getAdapterGroupName() + ") = "
+								+ CommonLib.getDumpMessage(responseMessage));
+					}
+					// ----------------------------------------------------------
+				}
+			}
+
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"RECV [" + new String(responseMessage, vo.getEncode()) + "]"
+								+ CommonLib.getDumpMessage(responseMessage));
+			}
+
+
+			return assignResponseHeaders(method, responseMessage, headerGroupName, vo.getEncode(), messageType,
+					relayResponseHeaderKeys, status, responseHeaderProp);
+		} catch (SocketTimeoutException ste) { // Read Timeout :: HttpClient 3.1일 경우
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
+								+ ste.toString(),
+						ste);
+			}
+			logger.error("HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
+					+ ste.toString(), ste);
+			throw ste;
+		} catch (ConnectException ce) {
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
+								+ ce.toString(),
+						ce);
+			}
+			logger.error("HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
+					+ ce.toString(), ce);
+			throw ce;
+		} catch (Exception e) {
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(), e.toString(), e);
+			}
+			logger.error("HttpClientAdapterServiceRest] Exception (" + vo.getAdapterGroupName() + ") : " + e.toString(),
+					e);
+			throw e;
+		} finally {
+			if (status != HttpStatus.SC_OK) {
+				String[] msgArgs = new String[1];
+				msgArgs[0] = String.valueOf(status);
+				String resMsg = ExceptionUtil.make("RDCEAIAHA013", msgArgs);
+				if (logger.isDebug()) {
+					logger.debug(resMsg);
+				}
+			}
+		}
+	}
+
+	private Properties assignRelayDataToInbound(Properties prop, Header[] responseHeaders) {
+		Properties headerProp = new Properties();
+		if (responseHeaders == null || responseHeaders.length == 0) {
+			return headerProp;
+		}
+		
+		for (Header header : responseHeaders) {
+			headerProp.put(header.getName(), header.getValue());
+		}
+
+		return headerProp;
+	}
+
+	/**
+	 * 현재 1단계 레이아웃에만 적용되도록 구현됨.
+	 * 
+	 * @param method
+	 * @param responseMessage
+	 * @param headerGroupName
+	 * @param encode
+	 * @param messageType
+	 * @param relayHeaderKeys
+	 * @return
+	 * @throws Exception
+	 */
+	@SuppressWarnings("unchecked")
+	private String assignResponseHeaders(HttpUriRequestBase method, byte[] responseMessage, String headerGroupName,
+			String encode, String messageType, String relayHeaderKeys, int status, Properties responseHeaderProp) throws Exception {
+		if (!MessageType.JSON.equals(messageType) || StringUtils.isBlank(headerGroupName)
+				|| StringUtils.isBlank(relayHeaderKeys)) {
+			return new String(responseMessage, encode);
+		}
+
+		String[] relayKeyArr = org.springframework.util.StringUtils.tokenizeToStringArray(relayHeaderKeys, ",");
+		JSONObject headerJson = new JSONObject();
+		for (String key : relayKeyArr) {			
+			String value = responseHeaderProp.getProperty(key);						
+			if (StringUtils.isNotBlank(value)) {
+				headerJson.put(key, value);		
+			}
+		}
+
+		headerJson.put(HTTP_STATUS, String.valueOf(status));
+
+		if (headerJson.size() <= 0) {
+			return new String(responseMessage, encode);
+		}
+
+		JSONObject message = null;
+		if (responseMessage == null || responseMessage.length == 0) {
+			message = new JSONObject();
+		} else {
+			message = parseJson(new String(responseMessage, encode));
+			if (message == null) {
+				message = new JSONObject();
+				message.put("Malformed_Response_Message", new String(responseMessage, encode));
+			}
+		}
+
+		if (StringUtils.isNotBlank(headerGroupName) && message != null)
+			message.put(headerGroupName, headerJson);
+		
+		logger.info("------------- message --------------- : {} ", message);
+		
+		return message.toJSONString();
+	}
+
+	// 2025.04.09 Authorization 헤더값을 프로퍼티(AUTH_TOKEN)에서 지정하여 설정할 수 있도록 수정
+	private void setAuthHeaders(HttpUriRequestBase method, String authorization) throws Exception {
+		method.setHeader("Authorization",
+				String.format("%s", authorization));
+	}
+
+	private void setAuthHeaders(HttpUriRequestBase method, OAuth2AccessTokenVO accessToken) throws Exception {
+		method.setHeader("Authorization",
+				String.format("%s %s", AccessTokenVO.BEARER_TYPE, accessToken.getAccessToken()));
+	}
+
+	private boolean checkTokenRetry(byte[] responseMessage, String tokenErrorCodeKey, String tokenErrorCodeValues,
+			String encode) {
+		if (responseMessage == null) {
+			return false;
+		}
+
+		if (StringUtils.isBlank(tokenErrorCodeKey)) {
+			return false;
+		}
+
+		if (StringUtils.isBlank(tokenErrorCodeValues)) {
+			return false;
+		}
+
+		try {
+			DocumentContext jsonContext = JsonPath.parse(new String(responseMessage, encode));
+			String responseCode = jsonContext.read(tokenErrorCodeKey);
+			if (StringUtils.isBlank(responseCode)) {
+				return false;
+			}
+
+			String[] arr = org.springframework.util.StringUtils.tokenizeToStringArray(tokenErrorCodeValues, ",");
+			return ArrayUtils.contains(arr, responseCode);
+		} catch (Exception e) {
+			logger.error("HttpClientAdapterServiceRest] checkTokenRetry error=" + e.getMessage());
+		}
+
+		return false;
+	}
+
+	private void assignRequestHeaders(HttpUriRequestBase method, Object httpHeader) {
+		if (httpHeader == null) {
+			return;
+		}
+
+		if (httpHeader instanceof JSONObject) {
+			JSONObject jsonObject = (JSONObject) httpHeader;
+			for (Object key : jsonObject.keySet()) {
+				Object obj = jsonObject.get(key);
+				if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+					continue;
+				}
+
+				method.setHeader((String) key, (String) obj);
+
+				if (logger.isDebugEnabled()) {
+					logger.debug("Request Header :" + (String) key + "=[" + (String) obj + "]");
+				}
+
+			}
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	private void assignPostBody(Object eaiBody, String contentType, String charset, HttpUriRequestBase method) {
+		if (eaiBody == null) {
+			return;
+		}
+
+		if (StringUtils.contains(contentType, "application/x-www-form-urlencoded")) {
+			if (eaiBody instanceof JSONObject) {
+				List<NameValuePair> params = new ArrayList<>();
+				JSONObject jsonObject = (JSONObject) eaiBody;
+				for (Object key : jsonObject.keySet()) {
+					params.add(new BasicNameValuePair((String) key, (String) jsonObject.get(key)));
+				}
+
+				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, StandardCharsets.UTF_8);
+				method.setEntity(entity);
+			}
+
+		} else {
+			ContentType contentTypeObj = ContentType.create(contentType, charset);
+
+			// 요청 본문을 StringEntity 객체로 생성
+			StringEntity entity = new StringEntity(eaiBody.toString(), contentTypeObj);
+
+			// 요청에 본문 추가
+			method.setEntity(entity);
+		}
+	}
+
+	private HashMap<String, String> getParameters(Object message) throws Exception {
+
+		HashMap<String, String> result = new HashMap<String, String>();
+
+		if (message != null) {
+			if (message instanceof JSONObject) {
+				JSONObject jsonObject = (JSONObject) message;
+				for (Object key : jsonObject.keySet()) {
+					Object obj = jsonObject.get(key);
+					if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+						continue;
+					}
+					result.put((String) key, getStringValue(obj));
+				}
+			} else {
+				String[] messages = ((String) message).split("&");
+				String[] data = null;
+
+				for (int i = 0; i < messages.length; i++) {
+					data = messages[i].split("=", 2);
+					if (data.length == 2) {
+						result.put(data[0], data[1]);
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+	
+	public String getStringValue(Object obj) {
+		if (obj == null) {
+			return null;
+		}
+
+		if (obj instanceof String) {
+			return (String) obj;
+		} else if (obj instanceof Long) {
+			return Long.toString((Long) obj);
+		} else if (obj instanceof BigDecimal) {
+			return ((BigDecimal) obj).toPlainString();
+		} else {
+			return (String) obj;
+		}
+	}
+	
+	 public static Object parseJsonGeneric(String jsonData) {
+	        if (StringUtils.isBlank(jsonData)) {
+	            return null;
+	        }
+	        
+	        try {
+	            JSONParser parser = new JSONParser();
+	            Object parsedObj = parser.parse(jsonData);
+	            return parsedObj;  
+	        } catch (ParseException e) {
+	            e.printStackTrace();
+	            return null;
+	        }
+	 }
+
+	@SuppressWarnings("deprecation")
+	private JSONObject parseJson(String message) throws Exception {
+		if (message == null) {
+			return null;
+		}
+
+		return (JSONObject) JSONValue.parse(message);
+	}
+
+	private Document convertXmlDocument(String message) throws Exception {
+		SAXReader builder = new SAXReader();
+		Document document = builder.read(new StringReader(message));
+		return document;
+	}
+
+	@SuppressWarnings("deprecation")
+	private String changeUrl(String messageType, String url, String restOption, Object sendData) {
+		if ((MessageType.JSON.equals(messageType) || MessageType.XML.equals(messageType))) {
+			try {
+				if (StringUtils.isBlank(restOption)) {
+					return url;
+				}
+				List<String> urlVariableList = new ArrayList<String>();
+				JSONObject restOptionObject = parseJson(restOption);
+
+				if (restOptionObject == null)
+					throw new Exception("restOption is NULL");
+
+				String type = (String) restOptionObject.get("type");
+				String requestExtraPath = (String) restOptionObject.get("extraPath");
+				url = getUrl(url, requestExtraPath);
+				if (TYPE_VARIABLE_URL_REQUEST.equals(type)) {
+					Pattern p = Pattern.compile("\\{(.*?)\\}");
+					Matcher m = p.matcher(requestExtraPath);
+					List<String> uriVariables = new ArrayList<>();
+					while(m.find()) {
+						String fieldName = m.group(1);
+						uriVariables.add(fieldName);
+					}
+					if (MessageType.JSON.equals(messageType)) {
+						JSONObject jsonObject;
+						if (sendData instanceof JSONObject) {
+							jsonObject = (JSONObject) sendData;
+						} else {
+							jsonObject = (JSONObject) JSONValue.parse((String) sendData);
+						}
+						for (Object tempObject : uriVariables) {
+							String urlVaribleId = (String) tempObject;
+							String uriVariable = (String) jsonObject.get(urlVaribleId);
+							urlVariableList.add(uriVariable);
+							jsonObject.remove(urlVaribleId);
+						}
+					} else if (MessageType.XML.equals(messageType)) {
+						Document doc;
+						if (sendData instanceof Document) {
+							doc = (Document) sendData;
+						} else {
+							doc = convertXmlDocument((String) sendData);
+						}
+						for (Object tempObject : uriVariables) {
+							String urlVaribleId = (String) tempObject;
+							Element element = (Element) doc.selectSingleNode("//" + urlVaribleId);
+							urlVariableList.add(element.getText());
+							if (doc.getRootElement() == element) {
+								doc = null;
+							} else {
+								element.getParent().remove(element);
+							}
+						}
+					}
+					if (urlVariableList.size() > 0) {
+						UriComponents uriComponents = UriComponentsBuilder.fromUriString(url).build();
+						Object[] urls = urlVariableList.toArray();
+						url = uriComponents.expand(urls).toUriString();
+						logger.debug("HttpClientAdapterServiceRest] after extand url=[" + url + "] ");
+					}
+				}
+			} catch (Exception e) {
+				logger.error("Failed to change url", e);
+			}
+		}
+		return url;
+	}
+
+	private String getUrl(String baseUrl, String extraPath) {
+		if (StringUtils.isBlank(extraPath)) {
+			return baseUrl;
+		}
+
+		if (StringUtils.contains(extraPath, "http://") || StringUtils.contains(extraPath, "https://")) {
+			return extraPath;
+		}
+
+		String targetUrl = baseUrl;
+		if (!targetUrl.endsWith("/")) {
+			targetUrl += "/";
+		}
+		if (extraPath.startsWith("/")) {
+			targetUrl += extraPath.substring(1);
+		} else {
+			targetUrl += extraPath;
+		}
+
+		logger.debug("HttpClientAdapterServiceRest] after concatenate url=[" + targetUrl + "] ");
+		return targetUrl;
+	}
+
+}
@@ -0,0 +1,867 @@
+package com.eactive.eai.custom.adapter.http.client.impl;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.httpclient.HttpStatus;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.apache.hc.client5.http.classic.HttpClient;
+import org.apache.hc.client5.http.classic.methods.HttpDelete;
+import org.apache.hc.client5.http.classic.methods.HttpGet;
+import org.apache.hc.client5.http.classic.methods.HttpPost;
+import org.apache.hc.client5.http.classic.methods.HttpPut;
+import org.apache.hc.client5.http.classic.methods.HttpUriRequestBase;
+import org.apache.hc.client5.http.config.RequestConfig;
+import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.apache.hc.core5.http.ContentType;
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.NameValuePair;
+import org.apache.hc.core5.http.io.entity.EntityUtils;
+import org.apache.hc.core5.http.io.entity.StringEntity;
+import org.apache.hc.core5.http.message.BasicNameValuePair;
+import org.apache.hc.core5.http.protocol.BasicHttpContext;
+import org.apache.hc.core5.http.protocol.HttpContext;
+import org.apache.hc.core5.net.URIBuilder;
+import org.dom4j.Document;
+import org.dom4j.Element;
+import org.dom4j.io.SAXReader;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.JSONValue;
+import org.springframework.web.util.UriComponents;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import com.eactive.eai.adapter.AdapterGroupVO;
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.http.HttpMemoryLogger;
+import com.eactive.eai.adapter.http.HttpMethodType;
+import com.eactive.eai.adapter.http.client.HttpClient5AdapterServiceSupport;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterVO;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.authserver.vo.ClientVO;
+import com.eactive.eai.common.TransactionContextKeys;
+import com.eactive.eai.common.authoutbound.AccessTokenManagerByDB;
+import com.eactive.eai.common.dao.DAOException;
+import com.eactive.eai.common.exception.ExceptionUtil;
+import com.eactive.eai.common.message.MessageType;
+import com.eactive.eai.common.util.CommonLib;
+import com.eactive.eai.custom.adapter.http.util.VirtualAccountTransform;
+import com.jayway.jsonpath.DocumentContext;
+import com.jayway.jsonpath.JsonPath;
+import com.openbanking.eai.common.token.AccessTokenManager;
+import com.openbanking.eai.common.token.AccessTokenVO;
+import com.openbanking.eai.common.token.OAuth2AccessTokenVO;
+
+// Kbank 가상계좌 OUTBOUND
+public class HttpClient5AdapterServiceVirtualAccount extends HttpClient5AdapterServiceSupport
+		implements HttpClientAdapterServiceKey {
+	public static final String TYPE_VARIABLE_URL_REQUEST = "variableUrlRequest";
+	public static final String TYPE_SIMPLE_REQUEST = "simpleRequest";
+
+	public static final String REST_OPTION = "REST_OPTION";
+
+////public static final String HEADER_CONTENT_TYPE = "Content-Type";
+	public static final String HEADER_GROUP = "HEADER_GROUP";
+	public static final String HTTP_STATUS = "HTTP_STATUS";
+	public static final String HEADER_KEYS = "HEADER_KEYS";
+
+	private String getSecurityKey(String adapterGroupName) throws DAOException {
+		String clientId = null;
+		String aesKey = null;
+		AdapterGroupVO adapterGroup = null;;
+		adapterGroup = AdapterManager.getInstance().getAdapterGroup(adapterGroupName);
+		
+		clientId = adapterGroup.getClientId();
+		OAuth2Manager manager = OAuth2Manager.getInstance();			
+		try {
+			ClientVO client = manager.getClientInfo(clientId);
+			aesKey = client.getSecurityKey();
+			return aesKey;
+		} catch (DAOException e) {
+			e.printStackTrace();
+			return null;
+		}
+		
+	}
+	
+	public Object execute(Properties prop, Object data, Properties tempProp) throws Exception {
+		HttpClientAdapterVO vo = super.setting(prop, tempProp);
+
+		String headerGroupName = prop.getProperty(HEADER_GROUP);
+		String relayResponseHeaderKeys = prop.getProperty(HEADER_KEYS, "");
+		boolean useAdapterToken = StringUtils.equalsIgnoreCase(prop.getProperty("ADAPTER_TOKEN_USE_YN", "N"), "Y");
+
+		boolean useForwardProxy = StringUtils.equalsIgnoreCase(prop.getProperty("FORWARD_PROXY_USE_YN", "N"), "Y");
+		String forwardProxyUrl = prop.getProperty("FORWARD_PROXY_URL");
+
+// ex) $.dataHeader.GW_RSLT_CD
+		String tokenErrorCodeKey = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_KEY");
+		String tokenErrorCodeValues = prop.getProperty("ADAPTER_TOKEN_ERROR_CODE_VALUES");
+		String tokenErrorHttpStatusCode = prop.getProperty("ADAPTER_TOKEN_ERROR_HTTP_STATUS_CODE"); // 200 or 400번대
+
+// 레이아웃 메시지 타입 REST URL 추출 시 활용. Default JSON
+		String messageType = prop.getProperty("MESSAGE_TYPE", MessageType.JSON);
+		String inboundMethod = tempProp.getProperty(HttpAdapterServiceKey.INBOUND_METHOD, "POST");
+
+		/**
+ * @formatter:off
+ * TSEAIHE02.RESTOPTION 정보 => JSON 형태로 구성
+ * - type : simpleRequest, variableUrlRequest
+ * - extraPath : 어댑터 프로퍼티 URL에 추가될 HTTP REST URL
+ * - method : get, delete, post, put
+ * - contentType: application/json(default), application/x-www-form-urlencoded
+ * - adapterTokenUseYn: Y, N(default)
+ * ex)
+ * {"type":"simpleRequest","extraPath":"v2.0/accout/balance","method":"post"}
+ * @formatter:on
+ */
+
+		String restOptionData = tempProp.getProperty(REST_OPTION);
+
+		JSONObject restOptionObject = parseJson(restOptionData);
+		if (restOptionObject == null) {
+			throw new Exception("OptionData parsing result is NULL");
+		}
+
+		String rmethod = (String) restOptionObject.getOrDefault("method", inboundMethod);
+		String contentType = (String) restOptionObject.getOrDefault("contentType", "application/json");
+		String adapterTokenUseYn = (String) restOptionObject.get("adapterTokenUseYn");
+		if (StringUtils.isNotBlank(adapterTokenUseYn)) { // interface 에 설정된게 우선한다.
+			useAdapterToken = StringUtils.equalsIgnoreCase(adapterTokenUseYn, "Y");
+		}
+
+		HttpClient mclient = this.client;
+		String sendData = "";
+		if (data instanceof String) {
+			sendData = (String) data;
+		} else if (data instanceof byte[]) {
+			sendData = new String((byte[]) data, vo.getEncode());
+		}
+		
+		// 필드암복호화 처리 (dec CubeOne -> enc AES) 
+		String encPaths = prop.getProperty("ENC_PATHS");
+		List<String> encFieldList = null;
+		String aesKey = getSecurityKey(vo.getAdapterGroupName());
+		if (logger.isDebug()) logger.debug("HttpClientAdapterServiceRest] ENC AdapterGroupName[" + vo.getAdapterGroupName()+ "], aesKey["+aesKey+"]");
+		if(StringUtils.isNotBlank(aesKey) && StringUtils.isNotBlank(encPaths)) {
+			String[] items = encPaths.split(",");
+			encFieldList = Arrays.asList(items);
+			sendData = VirtualAccountTransform.toAES(aesKey, encFieldList, sendData);
+			if (logger.isDebug()) logger.debug("HttpClientAdapterServiceRest] after toAES =  [" + sendData + "]");
+		}
+
+		////mclient.getParams().setContentCharset(vo.getEncode());
+
+		JSONObject dataObject = null;
+		Object httpHeader = null;
+		if (MessageType.JSON.equals(messageType)) {
+			dataObject = parseJson(sendData);
+			if (dataObject != null && StringUtils.isNotBlank(headerGroupName)) {
+				httpHeader = dataObject.get(headerGroupName);
+				dataObject.remove(headerGroupName);
+			}
+			if (logger.isDebug()) logger.debug("HttpClientAdapterServiceRest] dataObject1 =  [" + dataObject + "]");
+		}
+		else {
+			if (logger.isDebug()) logger.debug("HttpClientAdapterServiceRest] sendData =  [" + sendData + "]");
+		}
+		
+
+// interface 에 설정된게 우선한다.
+		String uri = null;
+		if (dataObject == null) {
+			uri = changeUrl(messageType, vo.getUrl(), restOptionData, sendData);
+		} else {
+			uri = changeUrl(messageType, vo.getUrl(), restOptionData, dataObject);
+		}
+
+		if (logger.isDebug()) logger.debug("HttpClientAdapterServiceRest] dataObject2 =  [" + dataObject + "]");
+
+//////if (vo.getConnectionTimeout() != 0) {
+//	mclient.getHttpConnectionManager().getParams().setConnectionTimeout(vo.getConnectionTimeout());
+//}
+
+		if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+			logger.debug(
+					"HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL=[" + vo.getUrl() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") PARAMETER_NAME=["
+					+ vo.getParameterName() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") ENCODE=["
+					+ vo.getEncode() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") RESPONSE_TYPE=["
+					+ vo.getResponseType() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") URL_ENCODE_YN=["
+					+ vo.getUrlEncodeYn() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") CONNECTION_TIMEOUT=["
+					+ vo.getConnectionTimeout() + "] ");
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") REST_OPTION=["
+					+ restOptionData + "] ");
+		}
+
+		HttpUriRequestBase method = null;
+
+// 메소드 타입에 따라 HttpRequestBase 인스턴스 생성
+		switch (HttpMethodType.getValue(rmethod)) {
+		case GET:
+			method = new HttpGet(uri);
+			break;
+		case DELETE:
+			method = new HttpDelete(uri);
+			break;
+		case POST:
+			method = new HttpPost(uri);
+			break;
+		case PUT:
+			method = new HttpPut(uri);
+			break;
+		default:
+			method = new HttpGet(uri);
+			break;
+		}
+
+		RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
+
+		if (useForwardProxy) {
+			java.net.URL url = new java.net.URL(forwardProxyUrl);
+
+			// 프로토콜, 호스트, 포트 추출
+			String protocol = url.getProtocol();
+			String host = url.getHost();
+			int port = url.getPort();
+			HttpHost proxy = new HttpHost(protocol, host, port);
+			requestConfigBuilder.setProxy(proxy);
+		}
+
+		configureHttpClient(requestConfigBuilder, vo, method);
+
+		switch (HttpMethodType.getValue(rmethod)) {
+		case GET:
+		case DELETE:
+			HashMap<String, String> h = getParameters(dataObject);
+			URIBuilder uriBuilder = new URIBuilder(uri);
+			for (Map.Entry<String, String> entry : h.entrySet()) {
+				uriBuilder.addParameter(entry.getKey(), entry.getValue());
+			}
+			URI fullUri = uriBuilder.build();
+			if (method instanceof HttpGet) {
+				((HttpGet) method).setUri(fullUri);
+			} else if (method instanceof HttpDelete) {
+				((HttpDelete) method).setUri(fullUri);
+			}
+			if (logger.isDebug()) {
+				logger.debug("HttpClientAdapterServiceRest] (get Method) QueryString = [" + fullUri.getQuery() + "]");
+			}
+			break;
+		case PUT:
+		case POST:
+			assignPostBody(dataObject, contentType, vo.getEncode(), method);
+			break;
+		default:
+			break;
+		}
+
+		if (logger.isDebugEnabled()) {
+			logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") method.getParams()=["
+					+ method.getEntity() + "] ");
+		}
+
+		OAuth2AccessTokenVO accessToken = null;
+		if (useAdapterToken) {
+			AccessTokenManagerByDB tokenManager = AccessTokenManagerByDB.getInstance();
+			accessToken = (OAuth2AccessTokenVO) tokenManager.getAccessTokenVO(vo.getAdapterGroupName());
+
+			// 토큰이 없거나 만료 됐으면 재발급
+			if (accessToken == null || accessToken.isExpired()) {
+				String oldToken = accessToken == null ? null : accessToken.getAccessToken();
+				accessToken = (OAuth2AccessTokenVO) tokenManager.retryAccessTokenVO(vo.getAdapterGroupName(), prop,
+						oldToken);
+			}
+
+			if (logger.isDebug()) {
+				logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") TOKEN = ["
+						+ accessToken + "]");
+			}
+
+			setAuthHeaders(method, accessToken);
+
+			if (logger.isDebug()) {
+				logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
+						+ ") RequestHeader [Authorization=" + method.getHeader("Authorization") + "]");
+			}
+		}
+
+// 전달 header 셋팅
+// Adapter 레벨 header 보다 data로 넘어온 httpHeader를 우선 적용(header명이 같다면 덮어씀)
+		assignRequestHeaders(method, httpHeader);
+
+		int status = -1;
+
+		try {
+			byte[] responseMessage = null;
+			Header[] responseHeaders;
+
+			if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+				if (dataObject != null) {
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = ["
+							+ dataObject.toJSONString() + "]");
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
+							+ CommonLib.getDumpMessage(dataObject.toJSONString()));
+				} else {
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = [" + sendData
+							+ "]");
+					logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName() + ") = "
+							+ CommonLib.getDumpMessage(sendData));
+				}
+			}
+			StopWatch stopWatch = new StopWatch();
+			stopWatch.start();
+
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"SEND [" + sendData + "]" + CommonLib.getDumpMessage(sendData));
+			}
+
+			String uuid = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID);
+			HttpContext context = new BasicHttpContext();
+			context.setAttribute(TransactionContextKeys.TRANSACTION_UUID, uuid);
+			context.setAttribute(HttpClientAdapterServiceKey.ADAPTER_GROUP_NAME, vo.getAdapterGroupName());
+			context.setAttribute(HttpClientAdapterServiceKey.ADAPTER_NAME, vo.getAdapterName());
+
+			try {
+				if (logger.isDebug()) {
+					logger.debug("[method getName]" + method.getMethod());
+					logger.debug("[method getEntity]" + method.getEntity());
+					logger.debug("[method getRequestHeaders]" + method.getHeaders().toString());
+					logger.debug("[method getURI]" + method.getPath());
+				}
+				try (CloseableHttpResponse response = (CloseableHttpResponse) mclient.execute(method, context)) {
+					status = response.getCode();
+					responseMessage = EntityUtils.toByteArray(response.getEntity());
+					responseHeaders = response.getHeaders();
+
+					if (logger.isDebug()) {
+						logger.debug("[received status]" + status);
+						logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = ["
+								+ responseMessage + "]");
+					}
+				}
+			} catch (ConnectException e) {
+				if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+					logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
+				}
+				throw new Exception("excuteMethod java.net.ConnectException = " + e.getMessage());
+			}
+
+			stopWatch.stop();
+
+			/**
+	 * @formatter:off
+	 * OAuth 토큰 응답 체크(Adapter properties로 설정)
+	 * 응답코드에 따라 유효한 토큰 확인(토큰 재발급 여부 확인)
+	 * API 서비스 마다 정책이 다름(보통 400대에서 체크하나 200에서도 체크할 수 있음)
+	 * 
+	 * TOKEN_ERROR_CODE_KEY: 응답 json error code key
+	 * __ex) $.dataHeader.resultCode
+	 * TOKEN_ERROR_CODE_VALUES: 토큰 재발급이 필요한 응답 error codes(ex: O0001,O0002,O0003)
+	 * TOKEN_ERROR_HTTP_STATUS_CODE: 보통 400대에서 체크하나 API 제공자에 따라 200에서도 체클할수 있음
+	 * ex) TOKEN_ERROR_HTTP_STATUS_CODE = 200
+	 * @formatter:on
+	 */
+			boolean needReissue = false;
+
+			Properties responseHeaderProp = assignRelayDataToInbound(tempProp, responseHeaders);
+			String responseString = new String(responseMessage, vo.getEncode());
+
+			Map<String, Object> map = new HashMap<String, Object>();
+			tempProp.put(HttpAdapterServiceKey.OUTBOUND_PROPERTY_MAP, map);
+			map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_HEADERS, responseHeaderProp);
+			map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_MESSAGE, responseString);
+			map.put(HttpAdapterServiceKey.OUTBOUND_RESPONSE_STATUS, status);
+
+			if (status == 200) {
+				if (useAdapterToken && StringUtils.equals(tokenErrorHttpStatusCode, "200")) {
+					needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
+							vo.getEncode());
+				}
+			} else if (status == 302) {
+				if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
+					relayResponseHeaderKeys += ",Location";
+				}
+			} else {
+				String errMsg = String.format(
+						"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
+						status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseString);
+//		logger.error(errMsg);
+
+				if (status >= 400 && status < 500) {
+					if (useAdapterToken) {
+						needReissue = checkTokenRetry(responseMessage, tokenErrorCodeKey, tokenErrorCodeValues,
+								vo.getEncode());
+					}
+
+					if (!needReissue) {
+						throw new Exception(errMsg);
+					}
+				} else {
+
+					throw new Exception(errMsg);
+				}
+			}
+
+			// ----------------------------------------------------------
+			if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+				logger.debug("HttpClientAdapterServiceRest] responseType =" + vo.getResponseType());
+				logger.debug("HttpClientAdapterServiceRest] RECV " + vo.getEncode() + "(" + vo.getAdapterGroupName()
+						+ ") = [" + new String(responseMessage, vo.getEncode()) + "]");
+//		logger.debug("HttpClientAdapterServiceRest] RECV MS949 (" + vo.getAdapterGroupName() + ") = ["	+ new String(responseMessage, "MS949") + "]");
+//		logger.debug("HttpClientAdapterServiceRest] RECV euc-kr (" + vo.getAdapterGroupName() + ") = [" + new String(responseMessage, "euc-kr") + "]");
+				logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = "
+						+ CommonLib.getDumpMessage(responseMessage));
+			}
+
+			if (useAdapterToken) {
+				if (responseMessage == null) {
+					throw new Exception("responseMessage is NULL, HttpStatus=" + status);
+				}
+
+				// OAuth 토큰 재요청 코드 확인
+				if (needReissue) {
+					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+						logger.debug("HttpClientAdapterServiceRest] retry access token response code = ["
+								+ vo.getResponseType() + "] message = [" + new String(responseMessage, vo.getEncode())
+								+ "]");
+					}
+
+					// 토큰 재발급
+					AccessTokenManager tokenManager = AccessTokenManager.getInstance();
+					String oldToken = accessToken == null ? null : accessToken.getAccessToken();
+					OAuth2AccessTokenVO newaccessToken = (OAuth2AccessTokenVO) tokenManager
+							.retryAccessTokenVO(vo.getAdapterGroupName(), prop, oldToken);
+					method.setHeader("Authorization", newaccessToken.getAuthorization());
+
+					setAuthHeaders(method, newaccessToken);
+
+					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+						logger.debug("HttpClientAdapterServiceRest] SEND (" + vo.getAdapterGroupName()
+								+ ") RETRY TOKEN = [" + newaccessToken + "]");
+					}
+
+					try (CloseableHttpResponse response = (CloseableHttpResponse) mclient.execute(method)) {
+						status = response.getCode();
+						responseMessage = EntityUtils.toByteArray(response.getEntity());
+
+						if (logger.isDebug()) {
+							logger.debug("[received status]" + status);
+							logger.debug("HttpClientAdapterServiceRest] RECV (" + vo.getAdapterGroupName() + ") = ["
+									+ new String(responseMessage, vo.getEncode()) + "]");
+						}
+					} catch (IOException e) {
+						throw new Exception("retry excuteMethod Exceptioin = " + e.getMessage());
+					}
+
+					if (status == 302) {
+						if (!StringUtils.contains(relayResponseHeaderKeys, "Location")) {
+							relayResponseHeaderKeys += ",Location";
+						}
+					} else {
+						String errMsg = String.format(
+								"http receive status fail value=%d adapterName=%s.%s uri=%s method=%s  response Data=%s",
+								status, vo.getAdapterGroupName(), vo.getAdapterName(), uri, rmethod, responseMessage);
+						throw new Exception(errMsg);
+					}
+
+					// ----------------------------------------------------------
+					if (logger.isDebug() && "N".equals(vo.getTestCallYn())) {
+						logger.debug("HttpClientAdapterServiceRest] RETRY responseType =" + vo.getResponseType());
+						logger.debug("HttpClientAdapterServiceRest] RETRY RECV " + vo.getEncode() + "("
+								+ vo.getAdapterGroupName() + ") = [" + new String(responseMessage, vo.getEncode())
+								+ "]");
+						logger.debug("HttpClientAdapterServiceRest] RETRY RECV (" + vo.getAdapterGroupName() + ") = "
+								+ CommonLib.getDumpMessage(responseMessage));
+					}
+					// ----------------------------------------------------------
+				}
+			}
+		
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"RECV [" + new String(responseMessage, vo.getEncode()) + "]"
+								+ CommonLib.getDumpMessage(responseMessage));
+			}
+
+			// TODO : toCubeOne
+			if(StringUtils.isNotBlank(aesKey) && encFieldList != null) {
+				responseMessage = VirtualAccountTransform.toCubeOne(aesKey, encFieldList, responseMessage);
+				
+				if (vo.getTraceLevel() >= 3) {
+					HttpMemoryLogger.txlog(vo.getAdapterGroupName() + vo.getAdapterName(),
+							"RECV ENC[" + new String(responseMessage, vo.getEncode()) + "]"
+									+ CommonLib.getDumpMessage(responseMessage));
+				}
+			}
+			
+			return assignResponseHeaders(method, responseMessage, headerGroupName, vo.getEncode(), messageType,
+					relayResponseHeaderKeys, status, responseHeaderProp);
+		} catch (SocketTimeoutException ste) { // Read Timeout :: HttpClient 3.1일 경우
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
+								+ ste.toString(),
+						ste);
+			}
+			logger.error("HttpClientAdapterServiceRest] SocketTimeoutException (" + vo.getAdapterGroupName() + ") : "
+					+ ste.toString(), ste);
+			throw ste;
+		} catch (ConnectException ce) {
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(),
+						"HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
+								+ ce.toString(),
+						ce);
+			}
+			logger.error("HttpClientAdapterServiceRest] Connection Exception (" + vo.getAdapterGroupName() + ") : "
+					+ ce.toString(), ce);
+			throw ce;
+		} catch (Exception e) {
+			if (vo.getTraceLevel() >= 3) {
+				HttpMemoryLogger.error(vo.getAdapterGroupName() + vo.getAdapterName(), e.toString(), e);
+			}
+			logger.error("HttpClientAdapterServiceRest] Exception (" + vo.getAdapterGroupName() + ") : " + e.toString(),
+					e);
+			throw e;
+		} finally {
+			if (status != HttpStatus.SC_OK) {
+				String[] msgArgs = new String[1];
+				msgArgs[0] = String.valueOf(status);
+				String resMsg = ExceptionUtil.make("RDCEAIAHA013", msgArgs);
+				if (logger.isDebug()) {
+					logger.debug(resMsg);
+				}
+			}
+		}
+	}
+
+	private Properties assignRelayDataToInbound(Properties prop, Header[] responseHeaders) {
+		Properties headerProp = new Properties();
+		if (responseHeaders == null || responseHeaders.length == 0) {
+			return headerProp;
+		}
+
+		for (Header header : responseHeaders) {
+			headerProp.put(header.getName(), header.getValue());
+		}
+
+		return headerProp;
+	}
+
+	/**
+	 * 현재 1단계 레이아웃에만 적용되도록 구현됨.
+	 * 
+	 * @param method
+	 * @param responseMessage
+	 * @param headerGroupName
+	 * @param encode
+	 * @param messageType
+	 * @param relayHeaderKeys
+	 * @return
+	 * @throws Exception
+	 */
+	@SuppressWarnings("unchecked")
+	private String assignResponseHeaders(HttpUriRequestBase method, byte[] responseMessage, String headerGroupName,
+			String encode, String messageType, String relayHeaderKeys, int status, Properties responseHeaderProp)
+			throws Exception {
+		if (!MessageType.JSON.equals(messageType) || StringUtils.isBlank(headerGroupName)
+				|| StringUtils.isBlank(relayHeaderKeys)) {
+			return new String(responseMessage, encode);
+		}
+
+		String[] relayKeyArr = org.springframework.util.StringUtils.tokenizeToStringArray(relayHeaderKeys, ",");
+		JSONObject headerJson = new JSONObject();
+		for (String key : relayKeyArr) {
+			String value = responseHeaderProp.getProperty(key);
+			if (StringUtils.isNotBlank(value)) {
+				headerJson.put(key, value);
+			}
+		}
+
+		headerJson.put(HTTP_STATUS, String.valueOf(status));
+
+		if (headerJson.size() <= 0) {
+			return new String(responseMessage, encode);
+		}
+
+		JSONObject message = null;
+		if (responseMessage == null || responseMessage.length == 0) {
+			message = new JSONObject();
+		} else {
+			message = parseJson(new String(responseMessage, encode));
+			if (message == null) {
+				message = new JSONObject();
+				message.put("Malformed_Response_Message", new String(responseMessage, encode));
+			}			
+		}
+
+		if (StringUtils.isNotBlank(headerGroupName) && message != null)
+			message.put(headerGroupName, headerJson);
+		return message.toJSONString();
+	}
+
+	private void setAuthHeaders(HttpUriRequestBase method, OAuth2AccessTokenVO accessToken) throws Exception {
+		method.setHeader("Authorization",
+				String.format("%s %s", AccessTokenVO.BEARER_TYPE, accessToken.getAccessToken()));
+	}
+
+	private boolean checkTokenRetry(byte[] responseMessage, String tokenErrorCodeKey, String tokenErrorCodeValues,
+			String encode) {
+		if (responseMessage == null) {
+			return false;
+		}
+
+		if (StringUtils.isBlank(tokenErrorCodeKey)) {
+			return false;
+		}
+
+		if (StringUtils.isBlank(tokenErrorCodeValues)) {
+			return false;
+		}
+
+		try {
+			DocumentContext jsonContext = JsonPath.parse(new String(responseMessage, encode));
+			String responseCode = jsonContext.read(tokenErrorCodeKey);
+			if (StringUtils.isBlank(responseCode)) {
+				return false;
+			}
+
+			String[] arr = org.springframework.util.StringUtils.tokenizeToStringArray(tokenErrorCodeValues, ",");
+			return ArrayUtils.contains(arr, responseCode);
+		} catch (Exception e) {
+			logger.error("HttpClientAdapterServiceRest] checkTokenRetry error=" + e.getMessage());
+		}
+
+		return false;
+	}
+
+	private void assignRequestHeaders(HttpUriRequestBase method, Object httpHeader) {
+		if (httpHeader == null) {
+			return;
+		}
+
+		if (httpHeader instanceof JSONObject) {
+			JSONObject jsonObject = (JSONObject) httpHeader;
+			for (Object key : jsonObject.keySet()) {
+				Object obj = jsonObject.get(key);
+				if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+					continue;
+				}
+
+				method.setHeader((String) key, (String) obj);
+
+				if (logger.isDebugEnabled()) {
+					logger.debug("Request Header :" + (String) key + "=[" + (String) obj + "]");
+				}
+
+			}
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	private void assignPostBody(Object eaiBody, String contentType, String charset, HttpUriRequestBase method) {
+		if (eaiBody == null) {
+			return;
+		}
+
+		if (StringUtils.contains(contentType, "application/x-www-form-urlencoded")) {
+			if (eaiBody instanceof JSONObject) {
+				List<NameValuePair> params = new ArrayList<>();
+				JSONObject jsonObject = (JSONObject) eaiBody;
+				for (Object key : jsonObject.keySet()) {
+					params.add(new BasicNameValuePair((String) key, (String) jsonObject.get(key)));
+				}
+
+				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, StandardCharsets.UTF_8);
+				method.setEntity(entity);
+			}
+
+		} else {
+			ContentType contentTypeObj = ContentType.create(contentType, charset);
+
+			// 요청 본문을 StringEntity 객체로 생성
+			StringEntity entity = new StringEntity(eaiBody.toString(), contentTypeObj);
+
+			// 요청에 본문 추가
+			method.setEntity(entity);
+		}
+	}
+
+	private HashMap<String, String> getParameters(Object message) throws Exception {
+
+		HashMap<String, String> result = new HashMap<String, String>();
+
+		if (message != null) {
+			if (message instanceof JSONObject) {
+				JSONObject jsonObject = (JSONObject) message;
+				for (Object key : jsonObject.keySet()) {
+					Object obj = jsonObject.get(key);
+					if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+						continue;
+					}
+					result.put((String) key, getStringValue(obj));
+				}
+			} else {
+				String[] messages = ((String) message).split("&");
+				String[] data = null;
+
+				for (int i = 0; i < messages.length; i++) {
+					data = messages[i].split("=", 2);
+					if (data.length == 2) {
+						result.put(data[0], data[1]);
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+
+	public String getStringValue(Object obj) {
+		if (obj == null) {
+			return null;
+		}
+
+		if (obj instanceof String) {
+			return (String) obj;
+		} else if (obj instanceof Long) {
+			return Long.toString((Long) obj);
+		} else if (obj instanceof BigDecimal) {
+			return ((BigDecimal) obj).toPlainString();
+		} else {
+			return (String) obj;
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	private JSONObject parseJson(String message) throws Exception {
+		if (message == null) {
+			return null;
+		}
+
+		return (JSONObject) JSONValue.parse(message);
+	}
+
+	private Document convertXmlDocument(String message) throws Exception {
+		SAXReader builder = new SAXReader();
+		Document document = builder.read(new StringReader(message));
+		return document;
+	}
+
+	@SuppressWarnings("deprecation")
+	private String changeUrl(String messageType, String url, String restOption, Object sendData) {
+		if ((MessageType.JSON.equals(messageType) || MessageType.XML.equals(messageType))) {
+			try {
+				if (StringUtils.isBlank(restOption)) {
+					return url;
+				}
+				List<String> urlVariableList = new ArrayList<String>();
+				JSONObject restOptionObject = parseJson(restOption);
+
+				if (restOptionObject == null)
+					throw new Exception("restOption is NULL");
+
+				String type = (String) restOptionObject.get("type");
+				String requestExtraPath = (String) restOptionObject.get("extraPath");
+				url = getUrl(url, requestExtraPath);
+				if (TYPE_VARIABLE_URL_REQUEST.equals(type)) {
+					Pattern p = Pattern.compile("\\{(.*?)\\}");
+					Matcher m = p.matcher(requestExtraPath);
+					List<String> uriVariables = new ArrayList<>();
+					while (m.find()) {
+						String fieldName = m.group(1);
+						uriVariables.add(fieldName);
+					}
+					if (MessageType.JSON.equals(messageType)) {
+						JSONObject jsonObject;
+						if (sendData instanceof JSONObject) {
+							jsonObject = (JSONObject) sendData;
+						} else {
+							jsonObject = (JSONObject) JSONValue.parse((String) sendData);
+						}
+						for (Object tempObject : uriVariables) {
+							String urlVaribleId = (String) tempObject;
+							String uriVariable = (String) jsonObject.get(urlVaribleId);
+							urlVariableList.add(uriVariable);
+							jsonObject.remove(urlVaribleId);
+						}
+					} else if (MessageType.XML.equals(messageType)) {
+						Document doc;
+						if (sendData instanceof Document) {
+							doc = (Document) sendData;
+						} else {
+							doc = convertXmlDocument((String) sendData);
+						}
+						for (Object tempObject : uriVariables) {
+							String urlVaribleId = (String) tempObject;
+							Element element = (Element) doc.selectSingleNode("//" + urlVaribleId);
+							urlVariableList.add(element.getText());
+							if (doc.getRootElement() == element) {
+								doc = null;
+							} else {
+								element.getParent().remove(element);
+							}
+						}
+					}
+					if (urlVariableList.size() > 0) {
+						UriComponents uriComponents = UriComponentsBuilder.fromUriString(url).build();
+						Object[] urls = urlVariableList.toArray();
+						url = uriComponents.expand(urls).toUriString();
+						logger.debug("HttpClientAdapterServiceRest] after extand url=[" + url + "] ");
+					}
+				}
+			} catch (Exception e) {
+				logger.error("Failed to change url", e);
+			}
+		}
+		return url;
+	}
+
+	private String getUrl(String baseUrl, String extraPath) {
+		if (StringUtils.isBlank(extraPath)) {
+			return baseUrl;
+		}
+
+		if (StringUtils.contains(extraPath, "http://") || StringUtils.contains(extraPath, "https://")) {
+			return extraPath;
+		}
+
+		String targetUrl = baseUrl;
+		if (!targetUrl.endsWith("/")) {
+			targetUrl += "/";
+		}
+		if (extraPath.startsWith("/")) {
+			targetUrl += extraPath.substring(1);
+		} else {
+			targetUrl += extraPath;
+		}
+
+		logger.debug("HttpClientAdapterServiceRest] after concatenate url=[" + targetUrl + "] ");
+		return targetUrl;
+	}
+}
@@ -1,80 +0,0 @@
-package com.eactive.eai.custom.adapter.http.client.impl.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.client.impl.HttpClient5AdapterServiceRest;
-import com.eactive.eai.adapter.http.client.impl.filter.OutCryptoFilter;
-import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.util.JsonPathUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-/**
- * 토스 암복호화에 맟추어 커스텀
- */
-public class DouzoneEncFieldOutCryptoFilter extends EncFieldOutCryptoFilter {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	private final OutCryptoFilter filter = new OutCryptoFilter();
-
-	protected Properties setProp(Properties tempProp) {
-		tempProp.setProperty(OutCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
-		tempProp.setProperty(OutCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
-		return tempProp;
-	}
-	
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
-			throws Exception {
-		String headerGroupName = prop.getProperty(HttpClient5AdapterServiceRest.HEADER_GROUP);
-
-		JsonNode root = JacksonUtil.readTree(message);
-		ObjectNode rootObjectNode = (ObjectNode) root;
-		JsonNode header = (headerGroupName == null) ? null : rootObjectNode.get(headerGroupName);
-
-		// 더존은 헤더의 x-emp-nm(AAD), x-chnl-nm(DYNAMIC 키 도출 컨텍스트)이 있어야 암호화가 가능하다.
-		// 값이 없으면 잘못된 컨텍스트로 암호화되지 않도록 암호화를 스킵하고 원본을 그대로 전달한다.
-		String xEmpNm = getHeaderText(header, "x-emp-nm");
-		String xChnlNm = getHeaderText(header, "x-chnl-nm");
-		if (xEmpNm == null || xChnlNm == null) {
-			logger.warn("더존 암호화 컨텍스트 헤더 없음, 암호화 스킵. adptGrpName={}, adptName={}, headerGroup={}",
-					adptGrpName, adptName, headerGroupName);
-			return message;
-		}
-
-		rootObjectNode.remove(headerGroupName);
-
-		tempProp.setProperty("x-emp-nm", xEmpNm);
-		tempProp.setProperty(InCryptoFilter.PROP_AAD_HEADER, xEmpNm);
-		tempProp.setProperty("x-chnl-nm", xChnlNm);
-
-		Object enc = filter.doPreFilter(adptGrpName, adptName, prop, rootObjectNode, setProp(tempProp));
-
-		ObjectNode encJson = (ObjectNode)JacksonUtil.readTree(enc);
-		encJson.set(headerGroupName, header);
-
-		return encJson;
-	}
-
-	/**
-	 * 헤더 그룹에서 지정한 헤더 값을 조회한다. 헤더 그룹 또는 해당 항목이 없으면 null을 반환한다.
-	 */
-	private String getHeaderText(JsonNode header, String name) {
-		if (header == null) {
-			return null;
-		}
-		JsonNode node = header.get(name);
-		return (node == null) ? null : node.asText();
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
-			Properties tempProp) throws Exception {
-		return filter.doPostFilter(adptGrpName, adptName, setProp(prop), message, setProp(tempProp));
-	}
-	
-}
@@ -1,53 +0,0 @@
-package com.eactive.eai.custom.adapter.http.client.impl.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.client.impl.HttpClient5AdapterServiceRest;
-import com.eactive.eai.adapter.http.client.impl.filter.HttpClientAdapterFilter;
-import com.eactive.eai.adapter.http.client.impl.filter.OutCryptoFilter;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.eactive.eai.util.JsonPathUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-/**
- * 제주은행 Open API 기본 암복호화 필더
- */
-public class EncFieldOutCryptoFilter implements HttpClientAdapterFilter {
-
-	private final OutCryptoFilter filter = new OutCryptoFilter();
-
-	protected Properties setProp(Properties tempProp) {
-		tempProp.setProperty(OutCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
-		tempProp.setProperty(OutCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
-		return tempProp;
-	}
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
-			throws Exception {
-		String headerGroupName = prop.getProperty(HttpClient5AdapterServiceRest.HEADER_GROUP);
-
-		JsonNode root = JacksonUtil.readTree(message);
-		ObjectNode rootObjectNode = (ObjectNode) root;
-		JsonNode header = null;
-		if (headerGroupName != null) {
-			header = rootObjectNode.get(headerGroupName);
-			rootObjectNode.remove(headerGroupName);
-		}
-
-		Object enc = filter.doPreFilter(adptGrpName, adptName, prop, rootObjectNode, setProp(tempProp));
-
-		ObjectNode encJson = (ObjectNode)JacksonUtil.readTree(enc);
-		if (header != null)
-			encJson.set(headerGroupName, header);
-
-		return encJson;
-		
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
-			Properties tempProp) throws Exception {
-		return filter.doPostFilter(adptGrpName, adptName, prop, message, setProp(tempProp));
-	}
-}
@@ -1,18 +0,0 @@
-package com.eactive.eai.custom.adapter.http.client.impl.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.client.impl.filter.OutCryptoFilter;
-
-/**
- * 카카오뱅크 암복호화에 맟추어 커스텀 
- */
-public class KakaobankEncFieldOutCryptoFilter extends EncFieldOutCryptoFilter {
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(OutCryptoFilter.PROP_DEC_FROM_PATH, "/encrypted_data");
-		p.setProperty(OutCryptoFilter.PROP_ENC_TO_PATH, "/encrypted_data");
-		return p;
-	}
-
-}
@@ -1,17 +0,0 @@
-package com.eactive.eai.custom.adapter.http.client.impl.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.client.impl.filter.OutCryptoFilter;
-
-/**
- * 토스 암복호화에 맟추어 커스텀
- */
-public class TossEncFieldOutCryptoFilter extends EncFieldOutCryptoFilter {
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(OutCryptoFilter.PROP_DEC_FROM_PATH, "/encrypted_data");
-		p.setProperty(OutCryptoFilter.PROP_ENC_TO_PATH, "/encrypted_data");
-		return p;
-	}
-}
@@ -1,17 +0,0 @@
-package com.eactive.eai.custom.adapter.http.client.impl.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.client.impl.filter.OutCryptoFilter;
-
-/**
- * 토스뱅크 암복호화에 맟추어 커스텀
- */
-public class TossbankEncFieldOutCryptoFilter extends EncFieldOutCryptoFilter {
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(OutCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
-		p.setProperty(OutCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
-		return p;
-	}
-}
@@ -1,79 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Base64;
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.springframework.http.HttpStatus;
-
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.common.security.AESCryptoModuleExtension;
-import com.eactive.eai.common.security.ARIACryptoModuleExtension;
-import com.eactive.eai.common.security.CryptoModuleExtension;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.util.HexaConverter;
-import com.eactive.eai.util.JsonPathUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-public class DecrytTestFilter implements HttpAdapterFilter {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		try {
-			ObjectNode rootNode = (ObjectNode)JsonPathUtil.toTree(message);
-			
-			JsonNode alg = rootNode.get("alg");
-			JsonNode mode = rootNode.get("mode");
-			JsonNode padding = rootNode.get("padding");
-			JsonNode aadNode = rootNode.get("aad");
-			JsonNode iv = rootNode.get("iv");
-			byte[] binIv = null;
-			if(iv != null) {
-				String strIv = iv.asText();
-				binIv = HexaConverter.hexToBin(strIv);
-			}
-			JsonNode encKey = rootNode.get("encKey");
-			String strEncKey = encKey.asText();
-			byte[] binEncKey = HexaConverter.hexToBin(strEncKey);
-
-			CryptoModuleExtension ext = "ARIA".equalsIgnoreCase(alg.asText()) ? new ARIACryptoModuleExtension()
-					: new AESCryptoModuleExtension();
-			ext.init(alg.asText(), mode.asText(), padding.asText(), binIv, binEncKey, binEncKey);
-
-			JsonNode encryptedData = rootNode.get("encryptedData");
-			byte[] cipherBytes = Base64.getDecoder().decode(encryptedData.asText().trim());
-			
-			byte[] decryptedBytes = null;
-			if(rootNode.has("aad"))
-				decryptedBytes = ext.decrypt(cipherBytes, HexaConverter.hexToBin(aadNode.asText()));
-			else
-				decryptedBytes = ext.decrypt(cipherBytes);
-			
-			rootNode.put("hsmKeyRaw", new String(decryptedBytes));
-
-			String jsonString = OBJECT_MAPPER.writeValueAsString(rootNode);
-			return jsonString;
-
-		} catch (Exception e) {
-			logger.error("복호화 실패", e);
-			throw new FilterException("복호화 실패", ERROR_PRE_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		return resultMessage;
-	}
-
-}
@@ -1,90 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.springframework.http.HttpStatus;
-
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
-import com.eactive.eai.adapter.http.dynamic.filter.FilterCryptoException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
-import com.eactive.eai.adapter.service.DJBApiAdapterService;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-/**
- * 더존 연동용 수신 암복호화 필터.
- *
- * {@code HttpAdapterServiceKey.INBOUND_HEADER} 프로퍼티로 전달된 수신 헤더 Map에서
- * 두 가지 컨텍스트 값을 추출하여 {@link InCryptoFilter}에 위임한다.
- *
- *   x-emp-nm  : GCM AAD 값 ({@code CRYPTO_AAD_HEADER} 프로퍼티에 설정)
- *   x-chnl-nm : DYNAMIC 키 도출 컨텍스트 ({@code contextKey} 프로퍼티에 설정)
- *               → {@code HsmContextSha256KeyDerivationStrategy}가 채널명 기반으로 키를 동적 생성
- *
- * 암복호화 필드 경로: {@code /encryptedData}
- *
- * 필터 타입 등록 (FQCN):
- *   com.eactive.eai.custom.adapter.http.dynamic.filter.DouzoneEncFieldInCryptoFilter
- */
-public class DouzoneEncFieldInCryptoFilter implements HttpAdapterFilter {
-
-	private final InCryptoFilter filter = new InCryptoFilter();
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(InCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
-		p.setProperty(InCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
-		return p;
-	}
-
-	private void setContext(Properties tempProp) {
-		Properties inboundHeaders = (Properties) tempProp.get(HttpAdapterServiceKey.INBOUND_HEADER);
-		String chnlNm = inboundHeaders.getProperty("x-chnl-nm");
-		tempProp.setProperty("x-chnl-nm", chnlNm);
-
-		tempProp.setProperty(InCryptoFilter.PROP_AAD_HEADER, "x-emp-nm");
-	}
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		try {
-			setContext(prop);
-			return filter.doPreFilter(adptGrpName, adptName, message, setProp(prop), request, response);
-		} catch (Exception e) {
-			throw new FilterCryptoException("복호화 오류", InCryptoFilter.ERROR_DEC_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		try {
-			setContext(prop);
-			
-			JsonNode root = JacksonUtil.readTree(resultMessage);
-			ObjectNode rootObjectNode = (ObjectNode) root;
-			String headerGroupName = prop.getProperty(DJBApiAdapterService.HEADER_GROUP);
-			JsonNode header = null;
-			if(headerGroupName != null) {
-				header = rootObjectNode.get(headerGroupName);
-				rootObjectNode.remove(headerGroupName);
-			}
-			
-			Object enc = filter.doPostFilter(adptGrpName, adptName, rootObjectNode, setProp(prop), request, response);
-			ObjectNode encJson = (ObjectNode)JacksonUtil.readTree(enc);
-			if(header != null)
-				encJson.set(headerGroupName, header);
-			
-			return encJson;
-			
-		} catch (Exception e) {
-			throw new FilterCryptoException("암호화 오류", InCryptoFilter.ERROR_ENC_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-	}
-	
-}
@@ -1,66 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.springframework.http.HttpStatus;
-
-import com.eactive.eai.adapter.http.dynamic.filter.FilterCryptoException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
-import com.eactive.eai.adapter.service.DJBApiAdapterService;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-/**
- * InCryptoFilter를 멤버변수로 관리하는 HttpAdapterFilter 구현체.
- *
- * 멤버변수에 세팅된 값을 Properties로 변환하여 {@link InCryptoFilter}에 위임한다.
- * 값이 blank인 멤버변수는 Properties에 포함하지 않으며, InCryptoFilter의 기본값이 적용된다.
- */
-public class EncFieldInCryptoFilter implements HttpAdapterFilter {
-
-    private final InCryptoFilter filter = new InCryptoFilter();
-
-    @Override
-    public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-            HttpServletRequest request, HttpServletResponse response) throws Exception {
-        return filter.doPreFilter(adptGrpName, adptName, message, setProp(prop), request, response);
-    }
-
-    @Override
-    public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-            HttpServletRequest request, HttpServletResponse response) throws Exception {
-    	try {
-    		JsonNode root = JacksonUtil.readTree(resultMessage);
-			ObjectNode rootObjectNode = (ObjectNode) root;
-			String headerGroupName = prop.getProperty(DJBApiAdapterService.HEADER_GROUP);
-			JsonNode header = null;
-			if(headerGroupName != null) {
-				header = rootObjectNode.get(headerGroupName);
-				rootObjectNode.remove(headerGroupName);
-			}
-			
-			Object enc = filter.doPostFilter(adptGrpName, adptName, rootObjectNode, setProp(prop), request, response);
-			ObjectNode encJson = (ObjectNode)JacksonUtil.readTree(enc);
-			if(header != null)
-				encJson.set(headerGroupName, header);
-			
-			return encJson;
-			
-		} catch (Exception e) {
-			throw new FilterCryptoException("암호화 오류", InCryptoFilter.ERROR_ENC_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-    }
-
-    protected Properties setProp(Properties p) {
-    	p.setProperty(InCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
-    	p.setProperty(InCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
-        return p;
-    }
-
-    
-}
@@ -1,138 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.security.KeyStore;
-import java.util.Base64;
-import java.util.Properties;
-
-import javax.crypto.SecretKey;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.springframework.http.HttpStatus;
-
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.common.hsm.HsmManager;
-import com.eactive.eai.common.security.AESCryptoModuleExtension;
-import com.eactive.eai.common.security.ARIACryptoModuleExtension;
-import com.eactive.eai.common.security.CryptoModuleExtension;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.util.HexaConverter;
-import com.eactive.eai.util.JsonPathUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-public class EncrytTestFilter implements HttpAdapterFilter {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		try {
-			ObjectNode rootNode = (ObjectNode)JsonPathUtil.toTree(message);
-			
-			// 1. HSM에서 키 가져오기
-			byte[] hsmKeyBytes = null;
-			JsonNode hsmKeyAlias = rootNode.get("hsmKeyAlias");
-			if (hsmKeyAlias != null) {
-				String hsmKeyAliasValue = hsmKeyAlias.textValue();
-				KeyStore keyStore = HsmManager.getInstance().getKeyStore();
-
-				java.security.Key key = keyStore.getKey(hsmKeyAliasValue, null);
-				if (key instanceof SecretKey) {
-					SecretKey secretKey = (SecretKey) key;
-					hsmKeyBytes = secretKey.getEncoded();
-					if (hsmKeyBytes != null) {
-						String hsmKeyBase64 = Base64.getEncoder().encodeToString(hsmKeyBytes);
-						String hsmKeyHex = HexaConverter.binToHex(hsmKeyBytes);
-						logger.debug("HsmManager] HSM - {} : [{}]", hsmKeyAliasValue, hsmKeyHex);
-						rootNode.put("hsmKeyBase64", hsmKeyBase64);
-						rootNode.put("hsmKeyHex", hsmKeyHex);
-						rootNode.put("hsmKeyRaw", new String(hsmKeyBytes));
-					} else {
-						logger.debug("HsmManager] HSM - secretKey null {} : [{}]", hsmKeyAliasValue, secretKey);
-					}
-					
-				}
-			}
-
-			// 2. 암호화 파라미터가 있으면 암호화 후 복호화 검증
-			JsonNode alg = rootNode.get("alg");
-			JsonNode mode = rootNode.get("mode");
-			JsonNode padding = rootNode.get("padding");
-			
-			JsonNode enc = rootNode.get("enc");
-			String strEnc = "BASE64";
-			if(enc != null)
-				strEnc = enc.asText();
-				
-			JsonNode ivNode = rootNode.get("iv");
-			JsonNode aadNode = rootNode.get("aad");
-			JsonNode encKeyNode = rootNode.get("encKey");
-			JsonNode dataNode = rootNode.get("data");
-
-			if (alg != null && mode != null && padding != null && encKeyNode != null
-					&& dataNode != null) {
-				byte[] binIv = null;
-				if(ivNode != null) {
-					String strIvValue = ivNode.asText();
-					if(strIvValue.length() == 32||strEnc.equalsIgnoreCase("HEX"))
-						binIv = HexaConverter.hexToBin(strIvValue);
-					else
-						binIv = Base64.getDecoder().decode(strIvValue.trim());
-				}
-				
-				String strEncKeyValue = encKeyNode.asText();
-				byte[] binEncKey = null;
-				if(strEnc.equalsIgnoreCase("BASE64"))
-					binEncKey = Base64.getDecoder().decode(strEncKeyValue.trim());
-				else
-					binEncKey = HexaConverter.hexToBin(strEncKeyValue);
-
-				CryptoModuleExtension ext = "ARIA".equalsIgnoreCase(alg.asText()) ? new ARIACryptoModuleExtension()
-						: new AESCryptoModuleExtension();
-				ext.init(alg.asText(), mode.asText(), padding.asText(), binIv, binEncKey, binEncKey);
-
-				byte[] plainBytes = dataNode.asText().getBytes();
-
-				// 암호화
-				byte[] encryptedBytes = null;
-				if(rootNode.has("aad"))
-					encryptedBytes = ext.encrypt(plainBytes, HexaConverter.hexToBin(aadNode.asText()));
-				else
-					encryptedBytes = ext.encrypt(plainBytes);
-				
-				String encryptedBase64 = Base64.getEncoder().encodeToString(encryptedBytes);
-				rootNode.put("encryptedData", encryptedBase64);
-				logger.debug("암호화 결과: [{}]", encryptedBase64);
-
-				// 복호화 검증
-				byte[] decryptedBytes = null;
-				if(rootNode.has("aad"))
-					decryptedBytes = ext.decrypt(encryptedBytes, HexaConverter.hexToBin(aadNode.asText()));
-				else
-					decryptedBytes = ext.decrypt(encryptedBytes);
-				
-				rootNode.put("decryptedVerify", new String(decryptedBytes));
-				logger.debug("복호화 검증: [{}]", new String(decryptedBytes));
-			}
-
-			String jsonString = OBJECT_MAPPER.writeValueAsString(rootNode);
-			return jsonString;
-
-		} catch (Exception e) {
-			throw new FilterException("HSM key 암호화/복호화 검증 실패", ERROR_PRE_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		return resultMessage;
-	}
-
-}
@@ -1,108 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Base64;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.springframework.http.HttpStatus;
-
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.common.security.keyderiv.DerivedKey;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.custom.common.security.keyderiv.HsmContextSha256KeyDerivationStrategy;
-import com.eactive.eai.custom.common.security.keyderiv.HsmKeyAndIvSliceDerivationStrategy;
-import com.eactive.eai.util.HexaConverter;
-import com.eactive.eai.util.JsonPathUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-public class GenKeyFilter implements HttpAdapterFilter {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-
-	private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		try {
-			ObjectNode rootNode = (ObjectNode)JsonPathUtil.toTree(message);
-			
-			JsonNode hsmKey = rootNode.get("hsmKey");
-			JsonNode hsmIv = rootNode.get("hsmIv");
-			JsonNode contextKey = rootNode.get("contextKey");
-			JsonNode type = rootNode.get("type");
-			
-			JsonNode enc = rootNode.get("enc");
-			String strEnc = "BASE64";
-			if(enc != null)
-				strEnc = enc.asText();
-			
-			byte[] binIv = null;
-			if(hsmIv != null) {
-				String strIvValue = hsmIv.asText();
-				if(strIvValue.length() == 32||strEnc.equalsIgnoreCase("HEX"))
-					binIv = HexaConverter.hexToBin(strIvValue);
-				else
-					binIv = Base64.getDecoder().decode(strIvValue.trim());
-			}
-		
-			String strEncKeyValue = hsmKey.asText();
-			byte[] binEncKey = null;
-			if(strEnc.equalsIgnoreCase("BASE64"))
-				binEncKey = Base64.getDecoder().decode(strEncKeyValue.trim());
-			else
-				binEncKey = HexaConverter.hexToBin(strEncKeyValue);
-
-			DerivedKey derivedKey = null;
-			if(type.asText().equals("douzone")) {
-				Map<String, String> params = new HashMap<>();
-				Map<String, String> runtimeContext = new HashMap<>();
-				params.put("contextKey", "contextKey");
-				runtimeContext.put("contextKey", contextKey.asText());
-				HsmContextSha256KeyDerivationStrategy douzoneStrategy = new HsmContextSha256KeyDerivationStrategy();
-				derivedKey = douzoneStrategy.deriveKey(params, runtimeContext, binEncKey);
-			} else if(type.asText().equals("kakaobank")) {
-				HsmKeyAndIvSliceDerivationStrategy kakaobank = new HsmKeyAndIvSliceDerivationStrategy();
-				derivedKey = kakaobank.deriveKey(binEncKey, binIv);
-			}
-			
-			JsonNode aad = rootNode.get("aad");
-			if (aad != null) {
-				rootNode.put("generatedAdd", HexaConverter.binToHex(aad.asText().getBytes()));
-			}
-			
-			String encBase64 = Base64.getEncoder().encodeToString(derivedKey.getDecKey());
-			logger.debug("generated KEY {} : [{}]", type.asText(), encBase64);
-			rootNode.put("generatedKeyBase64", encBase64);
-			rootNode.put("generatedKeyHex", HexaConverter.binToHex(derivedKey.getDecKey()));
-			rootNode.put("generatedKeyRaw", new String(derivedKey.getDecKey()));
-			
-			if(derivedKey.getIv() != null) {
-				String encBase64Iv = Base64.getEncoder().encodeToString(derivedKey.getIv());
-				logger.debug("generated IV {} : [{}]", type.asText(), encBase64Iv);
-				rootNode.put("generatedIvBase64", encBase64Iv);
-				rootNode.put("generatedIvHex", HexaConverter.binToHex(derivedKey.getIv()));
-				rootNode.put("generatedIvRaw", new String(derivedKey.getIv()));
-			}
-			String jsonString = OBJECT_MAPPER.writeValueAsString(rootNode);
-			return jsonString;
-
-		} catch (Exception e) {
-			throw new FilterException("HSM key 암호화/복호화 검증 실패", ERROR_PRE_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		return resultMessage;
-	}
-
-}
@@ -1,80 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.security.KeyStore;
-import java.util.Base64;
-import java.util.Properties;
-
-import javax.crypto.SecretKey;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import org.json.simple.JSONObject;
-import org.springframework.http.HttpStatus;
-
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.common.hsm.HsmManager;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.util.HexaConverter;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-
-public class HSMKeyCryptoFilter implements HttpAdapterFilter {
-
-	private static final Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
-	
-	private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		try {
-			ObjectNode rootNode = null;
-			String jsonStr = null;
-			if (message instanceof String) {
-				jsonStr = (String) message;
-			} else if (message instanceof JSONObject) {
-				jsonStr = ((JSONObject) message).toJSONString();
-			} else if (message instanceof ObjectNode) {
-				rootNode = (ObjectNode) message;
-			} else {
-				return message;
-			}
-			
-			if (rootNode == null)
-				rootNode = (ObjectNode) OBJECT_MAPPER.readTree(jsonStr);
-
-			JsonNode hsmKeyAlias = rootNode.get("hsmKeyAlias");
-			if (hsmKeyAlias != null) {
-				String hsmKeyAliasValue = hsmKeyAlias.textValue();
-				KeyStore keyStore = HsmManager.getInstance().getKeyStore();
-				
-				java.security.Key key = keyStore.getKey(hsmKeyAliasValue, null);
-				if (key instanceof SecretKey) {
-					SecretKey secretKey = (SecretKey) key;
-					byte[] encoded = secretKey.getEncoded();
-					if (encoded != null) {
-						String encBase64 = Base64.getEncoder().encodeToString(encoded);
-						logger.debug("HsmManager] HSM - {} : [{}]", hsmKeyAliasValue, encBase64);
-						rootNode.put("hsmKeyBase64", encBase64);
-						rootNode.put("hsmKeyRaw", HexaConverter.binToHex(encoded));
-					} else {
-						logger.debug("HsmManager] HSM - secretKey null {} : [{}]", hsmKeyAliasValue, secretKey);
-					}
-				}
-			}
-			return rootNode;
-
-		} catch (Exception e) {
-			throw new FilterException("HSM key 가져오기 실패", ERROR_PRE_FAIL, HttpStatus.INTERNAL_SERVER_ERROR.value(), e);
-		}
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		return resultMessage;
-	}
-
-}
@@ -0,0 +1,71 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class JsonToSetStatusFilter implements HttpAdapterFilter {
+    private ObjectMapper mapper = new ObjectMapper();
+
+    @Override
+    public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+                              HttpServletRequest request, HttpServletResponse response) throws Exception {
+        JsonNode rootNode = parseJson(adptGrpName, message);
+
+        int httpStatus = 200;
+
+        if (rootNode.has("apiRsltCd") && !rootNode.get("apiRsltCd").asText().isEmpty()) {
+            try {
+                String statusParam = rootNode.get("apiRsltCd").asText();
+                httpStatus = Integer.parseInt(statusParam);
+            } catch (NumberFormatException e) {
+                httpStatus = 400; // 잘못된 입력일 경우 400 Bad Request 반환
+            }
+            // HTTP 상태 코드 설정
+            response.setStatus(httpStatus);
+        }
+        return message;
+    }
+
+    @Override
+    public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+                               HttpServletRequest request, HttpServletResponse response) throws Exception {
+        JsonNode rootNode = parseJson(adptGrpName, resultMessage);
+        int httpStatus = 200;
+
+        if (rootNode.has("apiRsltCd") && !rootNode.get("apiRsltCd").asText().isEmpty()) {
+            try {
+                String statusParam = rootNode.get("apiRsltCd").asText();
+                httpStatus = Integer.parseInt(statusParam);
+            } catch (NumberFormatException e) {
+                httpStatus = 400; // 잘못된 입력일 경우 400 Bad Request 반환
+            }
+            // HTTP 상태 코드 설정
+            response.setStatus(httpStatus);
+        }
+        return resultMessage;
+    }
+
+    public JsonNode parseJson(String adptGrpName, Object message) throws UnsupportedEncodingException, JsonMappingException, JsonProcessingException {
+        String charset = StringUtils.defaultIfBlank(AdapterManager.getInstance().getAdapterGroupVO(adptGrpName).getMessageEncode(), "UTF-8");
+        String orgMessageString;
+        if(message instanceof byte[]) {
+            orgMessageString = new String((byte[])message, charset);
+        } else {
+            orgMessageString = (String) message;
+        }
+
+        return mapper.readTree(orgMessageString);
+    }
+}
@@ -0,0 +1,110 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+public class JsonToStdConverterFilter implements HttpAdapterFilter {
+    private ObjectMapper mapper = new ObjectMapper();
+
+    @Override
+    public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+                              HttpServletRequest request, HttpServletResponse response) throws Exception {
+        JsonNode rootNode = parseJson(adptGrpName, message);
+
+        if (rootNode.has("header_part")) {
+            JsonNode headerPart = rootNode.path("header_part");
+            if (!headerPart.has("eaiIntfId") || headerPart.get("eaiIntfId").asText().isEmpty()) {
+                // /api/v1/public/getUserInfo.svc
+                String inboundUri = prop.getProperty(HttpAdapterServiceKey.INBOUND_EXTURI);
+                String apiPath = prop.getProperty(HttpAdapterServiceKey.API_PATH) + "/";
+
+                // getUserInfo.svc
+                String eaiIntfId = org.apache.commons.lang.StringUtils.removeStart(inboundUri, apiPath);
+
+                // header_part 아래 eaiIntfId가 추가 또는 수정
+                if (headerPart instanceof ObjectNode) {
+                    ((ObjectNode) headerPart).put("eaiIntfId", eaiIntfId);
+                    // 요청 응답 구분코드 강제 설정 -> API명 찾아갈때 필요
+                    if (!headerPart.has("reqRspnsDscd")) {
+                        ((ObjectNode) headerPart).put("reqRspnsDscd", "S");
+                    }
+
+                    // GUID 강제 설정
+                    String orgnlTx = "";
+                    if (headerPart.has("orgnlTx") &&  !headerPart.get("orgnlTx").asText().isEmpty()) {
+                        orgnlTx = headerPart.get("orgnlTx").asText();
+                    }
+                    if (!headerPart.has("tlgrWrtnDt")) {
+                        ((ObjectNode) headerPart).put("tlgrWrtnDt", orgnlTx);
+                    }
+                    if (!headerPart.has("tlgrCrtnSysNm")) {
+                        ((ObjectNode) headerPart).put("tlgrCrtnSysNm", "");
+                    }
+                    if (!headerPart.has("tlgrSrlNo")) {
+                        ((ObjectNode) headerPart).put("tlgrSrlNo", "");
+                    }
+                }
+            }
+        }
+        else {
+            return message;
+        }
+        return rootNode.toString();
+    }
+
+    @Override
+    public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+                               HttpServletRequest request, HttpServletResponse response) throws Exception {
+        JsonNode rootNode = parseJson(adptGrpName, resultMessage);
+
+        if (rootNode.has("header_part")) {
+            JsonNode headerPart = rootNode.path("header_part");
+            if (!headerPart.has("eaiIntfId") || headerPart.get("eaiIntfId").asText().isEmpty()) {
+                // /api/v1/public/getUserInfo.svc
+                String inboundUri = prop.getProperty(HttpAdapterServiceKey.INBOUND_EXTURI);
+                String apiPath = prop.getProperty(HttpAdapterServiceKey.API_PATH) + "/";
+
+                // getUserInfo.svc
+                String eaiIntfId = org.apache.commons.lang.StringUtils.removeStart(inboundUri, apiPath);
+
+                // header_part 아래 eaiIntfId가 추가 또는 수정
+                if (headerPart instanceof ObjectNode) {
+                    ((ObjectNode) headerPart).put("eaiIntfId", eaiIntfId);
+                    // 요청 응답 구분코드 강제 설정 -> API명 찾아갈때 필요
+                    ((ObjectNode) headerPart).put("reqRspnsDscd", "S");
+                }
+            }
+        }
+        else {
+            return resultMessage;
+        }
+        return rootNode.toString();
+    }
+
+    public JsonNode parseJson(String adptGrpName, Object message) throws UnsupportedEncodingException, JsonMappingException, JsonProcessingException {
+            String charset = StringUtils.defaultIfBlank(AdapterManager.getInstance().getAdapterGroupVO(adptGrpName).getMessageEncode(), "UTF-8");
+        String orgMessageString;
+        if(message instanceof byte[]) {
+            orgMessageString = new String((byte[])message, charset);
+        } else {
+            orgMessageString = (String) message;
+        }
+
+        return mapper.readTree(orgMessageString);
+    }
+
+}
@@ -1,18 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
-
-/**
- * 카카오뱅크 암복호화에 맟추어 커스텀 필요
- */
-public class KakaobankEncFieldInCryptoFilter extends EncFieldInCryptoFilter {
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(InCryptoFilter.PROP_DEC_FROM_PATH, "/encrypted_data");
-		p.setProperty(InCryptoFilter.PROP_ENC_TO_PATH, "/encrypted_data");
-		return p;
-	}
-
-}
@@ -1,43 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Properties;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-import com.eactive.eai.adapter.http.dynamic.filter.FilterException;
-import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
-import com.eactive.eai.common.util.JacksonUtil;
-import com.fasterxml.jackson.databind.JsonNode;
-
-/**
- * 카카오뱅크 암복호화에 맟추어 커스텀 필요
- */
-public class KakaopayFilter implements HttpAdapterFilter {
-
-	@Override
-	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		
-		// 인자 1개 오버로드는 JacksonUtil 내부의 number-safe 싱글턴 mapper 를 쓴다.
-		JsonNode rootNode = JacksonUtil.readTree(message);
-		
-		// term_agreements[0].is_agreed 값이 true 인지 확인
-		boolean firstAgreed = JacksonUtil.getBoolean(rootNode, "term_agreements[0].is_agreed", false);
-		
-		if (!firstAgreed) {
-			throw new FilterException("EB000003", "금리한도조회실패 - 고객 요청으로 인한 CB 조회 실패", 200);
-		}
-		
-		return message;
-
-	}
-
-	@Override
-	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
-			HttpServletRequest request, HttpServletResponse response) throws Exception {
-		return resultMessage;
-	}
-
-}
-
@@ -0,0 +1,68 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Iterator;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+public class KbankEaiJsonParseFilter implements HttpAdapterFilter {
+	
+	private ObjectMapper mapper = new ObjectMapper();
+
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		JsonNode rootNode = parseJson(adptGrpName, message);
+		
+		ObjectNode replacedJson = mapper.createObjectNode();
+		for(Iterator<String> it = rootNode.fieldNames(); it.hasNext();) {
+			String fieldName = it.next();
+			String value = rootNode.get(fieldName).asText();
+			JsonNode jsonNode = mapper.readTree(value);
+			replacedJson.set(fieldName, jsonNode);
+		}
+		
+		return replacedJson.toString();
+	}
+
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		JsonNode rootNode = parseJson(adptGrpName, resultMessage);
+		
+		ObjectNode replacedJson = mapper.createObjectNode();
+		for(Iterator<String> it = rootNode.fieldNames(); it.hasNext();) {
+			String fieldName = it.next();
+			JsonNode childNode = rootNode.get(fieldName);
+			String childString = mapper.writeValueAsString(childNode);
+			replacedJson.put(fieldName, childString);
+		}
+		
+		return replacedJson.toString();
+	}
+	
+	public JsonNode parseJson(String adptGrpName, Object message) throws UnsupportedEncodingException, JsonMappingException, JsonProcessingException {
+		String charset = StringUtils.defaultIfBlank(AdapterManager.getInstance().getAdapterGroupVO(adptGrpName).getMessageEncode(), "UTF-8");
+		String orgMessageString;
+		if(message instanceof byte[]) {
+			orgMessageString = new String((byte[])message, charset);
+		} else {
+			orgMessageString = (String) message;
+		}
+		
+		return mapper.readTree(orgMessageString);
+	}
+
+}
@@ -0,0 +1,215 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Properties;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.text.SimpleDateFormat;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.SecretKeySpec;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.Mac;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.common.property.PropManager;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.apache.commons.net.util.Base64;
+import org.springframework.http.HttpStatus;
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.common.server.Keys;
+import com.eactive.eai.common.util.Logger;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class KbankHmacSha256VerifyFilter implements HttpAdapterFilter {
+	
+	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+	
+	private static final String SERVICE_CODE_UNKNOWN = "00";
+	private static final int TIMESTAMP_EXPIRATION_SECONDS = 60*10*1000;
+	private static final String GROUP_NAME = "HMAC_INFO";
+	
+	private ObjectMapper mapper = new ObjectMapper();
+	
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		
+		try {
+			
+			String hmacSignature = getHeaderCaseInsensitive(request, "hmac_signature");
+			String hmacTimestamp = getHeaderCaseInsensitive(request, "hmac_timestamp");
+						
+			if(StringUtils.isBlank(hmacSignature) || StringUtils.isBlank(hmacTimestamp)) {
+				throw new JwtAuthException(String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"), "Can not find hmac info");
+			}
+			
+			long inputTime = new SimpleDateFormat("yyyyMMddHHmmss").parse(hmacTimestamp).getTime();
+			long currentTime = new Date().getTime();
+			String timeStamp = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
+			
+			logger.debug("### inputTime :"+inputTime);			
+			logger.debug("### currentTime :"+currentTime);
+			logger.debug("### timeStamp :"+timeStamp);
+			
+			String systemMode = System.getProperty(Keys.EAI_SYSTEMMODE);
+			
+			if(currentTime - inputTime > TIMESTAMP_EXPIRATION_SECONDS) {
+				
+				logger.debug("### systemMode:" + systemMode);
+				logger.debug("### currentTime - inputTime:" + (currentTime - inputTime));
+				
+				if("P".equals(systemMode)) {
+					throw new JwtAuthException(
+							String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN,"00"), "Signature verifying failed");
+				}				
+			}
+
+			String sMessage = (String)message;
+
+			sMessage = sMessage.replace(" ","");
+			sMessage = sMessage.replace("\n","");
+			sMessage = sMessage.replace("\r","");
+
+			sMessage = sMessage + hmacTimestamp;
+
+			logger.info("### sMessage:"+sMessage);
+
+			String alCoId = "AL2021012901001";
+
+			JsonNode rootNode = parseJson(adptGrpName, message);
+
+			for(Iterator<String> it = rootNode.fieldNames(); it.hasNext();){
+				String fieldName = it.next();
+				if(fieldName.equals("ALCO_ID")) alCoId = rootNode.get(fieldName).asText();
+			}
+
+			logger.info("### alCoId:"+alCoId);
+
+			Properties hmacProp = PropManager.getInstance().getProperties(GROUP_NAME);
+
+			String hmacKey = hmacProp.getProperty(alCoId+"-hmack-key","");
+			String hmacKek = hmacProp.getProperty(alCoId+"-hmack-kek","");
+			String hmacIvForKey = hmacProp.getProperty(alCoId+"-hmack-iv-for-key","");
+
+			logger.debug("### hmacKey:"+hmacKey);
+			logger.debug("### hmacIvForKey:"+hmacIvForKey);
+			logger.debug("### hmacKek:"+hmacKek);
+
+			//kbank.payment.hmac-key
+			int hmacKeyLen = hmacKey.length();
+			byte[] hmacKeyData = new byte[hmacKeyLen/2];
+			for(int i=0;i<hmacKeyLen;i+=2){
+				hmacKeyData[i/2] = (byte)((Character.digit(hmacKey.charAt(i), 16) << 4) + Character.digit(hmacKey.charAt(i+1), 16));
+			}
+
+			//kbank.payment.hmac-kek
+			int hmacKekLen = hmacKek.length();
+			byte[] hmacKekData = new byte[hmacKekLen/2];
+			for(int i=0;i<hmacKekLen;i+=2){
+				hmacKekData[i/2] = (byte)((Character.digit(hmacKek.charAt(i),16) << 4) + Character.digit(hmacKek.charAt(i+1), 16));
+			}
+
+			//kbank.payment.hmac-iv-for-key
+			int hmacIvForKeyLen = hmacIvForKey.length();
+			byte[] hmacIvForKeyData = new byte[hmacIvForKeyLen/2];
+			for(int i=0;i<hmacIvForKeyLen;i+=2){
+				hmacIvForKeyData[i/2] = (byte)((Character.digit(hmacIvForKey.charAt(i),16) << 4) + Character.digit(hmacIvForKey.charAt(i+1), 16));
+			}
+
+			byte[] decrypedHmacKey = null;
+
+			try{
+				Cipher cp = Cipher.getInstance("AES/CBC/PKCS5Padding");
+				cp.init(Cipher.DECRYPT_MODE, new SecretKeySpec(hmacIvForKeyData,"AES"), new IvParameterSpec(hmacIvForKeyData));
+				decrypedHmacKey = cp.doFinal(hmacKeyData);
+			} catch (Exception e) {
+				logger.debug(e.getMessage());
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"), "Signature verifying failed");
+			}
+
+			SecretKeySpec secretKey = new SecretKeySpec(decrypedHmacKey, "HmacSHA256");
+			String madeSignature = "";
+
+			logger.info("### secretKey:"+secretKey);
+
+			try{
+				Mac mac = Mac.getInstance("HmacSHA256");
+				mac.init(secretKey);
+				madeSignature= Base64.encodeBase64String(mac.doFinal(sMessage.getBytes()));
+			} catch (Exception e) {
+				logger.debug(e.getMessage());
+				throw new JwtAuthException(String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"), "Signature verifying failed");
+			}
+
+			logger.info("### madeSignature:"+madeSignature);
+
+			if(!StringUtils.equals(hmacSignature, madeSignature)){
+				logger.info("### hmacSignature:"+hmacSignature);
+				logger.info("### madeSignature:"+madeSignature);
+
+				throw new JwtAuthException(String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"), "Signature verifying failed" );
+			}
+			
+		} catch (JwtAuthException e) {
+			logger.debug(e.getMessage());
+			throw e;
+		} catch (Exception e) {
+			logger.debug(e.getMessage());
+			throw new JwtAuthException(String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"), "Signature verifying failed(Unknown)" );
+		}
+
+		logger.info("### pass: "+"success");
+				
+		return message;	
+		
+	}
+	
+	/**
+     * 대소문자 구분 없이 HTTP 헤더 값을 가져오는 메소드
+     * @param request HTTP 요청 객체
+     * @param headerName 찾고자 하는 헤더 이름
+     * @return 헤더 값 또는 null
+     */
+    public static String getHeaderCaseInsensitive(HttpServletRequest request, String headerName) {
+        Enumeration<String> headerNames = request.getHeaderNames();
+        while (headerNames.hasMoreElements()) {
+            String header = headerNames.nextElement();
+            if (header != null && header.equalsIgnoreCase(headerName)) {
+                return request.getHeader(header);
+            }
+        }
+        return null;
+    }
+	
+
+	public JsonNode parseJson(String adptGrpName, Object message) throws UnsupportedEncodingException, JsonMappingException,JsonProcessingException {
+		String charset = StringUtils.defaultIfBlank(AdapterManager.getInstance().getAdapterGroupVO(adptGrpName).getMessageEncode(), "UTF-8");
+		String orgMessageString;
+
+		if(message instanceof byte[]) {
+			orgMessageString = new String((byte[])message, charset);
+		} else {
+			orgMessageString = (String) message;
+		}
+
+		return mapper.readTree(orgMessageString);
+	}
+	
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		return resultMessage;
+	}
+
+}
@@ -0,0 +1,205 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.commons.codec.digest.HmacAlgorithms;
+import org.apache.commons.codec.digest.HmacUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.http.HttpStatus;
+
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.authserver.vo.ClientVO;
+import com.eactive.eai.common.util.Logger;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class SnapHmacSha512VerifyFilter implements HttpAdapterFilter {
+	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+
+	private static final String SERVICE_CODE_UNKNOWN = "00";
+	private static final int X_TIMESTAMP_EXPIRATION_SECONDS = 60 * 5;
+
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		// @formatter:off
+		/*
+		 * HMAC_SHA512 (clientSecret, stringToSign)
+		 * 
+		 * stringToSign = HTTPMethod:EndpointUrl:AccessToken
+		 *                :Lowercase(HexEncode(SHA-256(minify(RequestBody)))):TimeStamp
+		 */
+		try {
+			String xSignature = request.getHeader("X-SIGNATURE");
+			if (StringUtils.isBlank(xSignature)) {
+				throw new JwtAuthException(String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"), "Can not find X-SIGNATURE");
+			}
+			
+			String clientSecret = assignClientSecret(prop, request);
+			
+			StringBuilder sb = new StringBuilder();
+			sb.append(request.getMethod())
+					.append(":")
+					.append(getEndpointUrl(request))
+					.append(":")
+					.append(SnapSimpleOauth2Filter.extractToken(request))
+					.append(":")
+					.append(getRequestBody((String)message))
+					.append(":")
+					.append(getTimeStamp(request));
+			// @formatter:on
+
+			if (logger.isDebug()) {
+				logger.debug(sb.toString());
+			}
+
+			String hmac = new HmacUtils(HmacAlgorithms.HMAC_SHA_512, clientSecret).hmacHex(sb.toString());
+
+			if (!StringUtils.equals(xSignature, hmac)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+						"Signature verifying failed");
+			}
+		} catch (JwtAuthException e) {
+			logger.debug(e.getMessage());
+			throw e;
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Signature verifying failed(unkown)");
+		}
+
+		return message;
+	}
+
+	private String assignClientSecret(Properties prop, HttpServletRequest request) throws Exception {
+		String clientId = assignClientId(prop, request);
+		if (StringUtils.isBlank(clientId)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Can not find clientId info");
+		}
+
+		ClientVO client = (ClientVO) OAuth2Manager.getInstance().getClientDeatilsStore().get(clientId);
+		if (client == null) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Can not find client info");
+		}
+
+		return client.getClientSecret();
+	}
+
+	private String assignClientId(Properties prop, HttpServletRequest request) {
+		String clientId = null;
+		try {
+			// 이전 filter에서 셋팅한 clientId 확보
+			clientId = prop.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);
+
+			// 이전 filter에서 셋팅한 값이 없다면 header 정보에서 확보
+			if (StringUtils.isBlank(clientId)) {
+				clientId = request.getHeader(HttpAdapterServiceSupport.HEADER_NAME_CLIENT_ID);
+			}
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+		}
+
+		return clientId;
+	}
+
+	private String getEndpointUrl(HttpServletRequest request) {
+		String servletPath = request.getServletPath();
+		String pathInfo = request.getPathInfo();
+		String queryString = request.getQueryString();
+
+		StringBuilder url = new StringBuilder();
+		url.append(servletPath);
+
+		if (pathInfo != null) {
+			url.append(pathInfo);
+		}
+
+		if (queryString != null) {
+			url.append("?").append(queryString);
+		}
+
+		return url.toString();
+	}
+
+	private String getRequestBody(String message) throws Exception {
+		if (StringUtils.isEmpty(message)) {
+			return "";
+		}
+
+		// Lowercase(HexEncode(SHA-256(minify(RequestBody))))
+		String body = minifyJson(message);
+		try {
+			body = DigestUtils.sha256Hex(body);
+		} catch (Exception e) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"SHA-256 digest error");
+		}
+		return body.toLowerCase();
+	}
+
+	private String minifyJson(String json) {
+		try {
+			ObjectMapper objectMapper = new ObjectMapper();
+			JsonNode jsonNode = objectMapper.readValue(json, JsonNode.class);
+			return jsonNode.toString();
+		} catch (Exception e) {
+			// json이 아닐경우
+			return json;
+		}
+	}
+
+	private String getTimeStamp(HttpServletRequest request) throws Exception {
+		String timeStamp = request.getHeader("X-TIMESTAMP");
+		if (StringUtils.isBlank(timeStamp)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Can not find X-TIMESTAMP");
+		}
+
+		// 2020-12-23T09:10:11+07:00(현재시간이랑 비교로직 추가-보안)
+		ZonedDateTime xTimeStamp = ZonedDateTime.parse(timeStamp, DateTimeFormatter.ISO_DATE_TIME);
+		xTimeStamp = xTimeStamp.plusSeconds(X_TIMESTAMP_EXPIRATION_SECONDS);
+		ZonedDateTime now = ZonedDateTime.now();
+		if (xTimeStamp.isBefore(now.withZoneSameInstant(xTimeStamp.getZone()))) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Too old X-TIMESTAMP");
+		}
+
+		return timeStamp;
+	}
+
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		return resultMessage;
+	}
+
+	public static void main(String[] args) {
+		String str = "POST:/api/test/aaa/type02/555:"
+				+ "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzY29wZSI6WyJzbmFwIl0sImV4cCI6MTY3NjUyNDI1MSwianRpIjoiNzI0MWMyZGUtZjJhNi00NTFmLWExMjQtZGM3NmI0ZGY1OThjIiwiY2xpZW50X2lkIjoic1NHSkR3bEpzZWw1V2VYb2R6ZDNKM01RMjBLWUNacEwifQ.Obe8t8IwuQ3P7i4yCSASYze-9DLmVwXe0g_gBYlwv_Jzc7V8-ooTwp6SVnaNsM6pp1GV-9lxMpAzQO_CRHQq_hdMeiPI_CXHh3gETvjQThn57QGEGdCNp_lUEVYtMPUxi5u3X6Of07o0_OB83WI7rA1zD0DaP8V67pgfq-jMRe_3IXztOYu_nwMgREbGvs9tqcsjxppRKkEHcK1S8Eq4HzaLwjwyHJAhIlTba27yd4T8ELC7IpFphJBfEPF_t0ZpYW15lOrg5pHPjy1xpTV0Kgipog5wycTZlFUeCWWjfxTrpVmt_1XlEOlZH9X6xAefWrH93_fpbt3OcxwP4u9KhA"
+				+ ":424058b889b9d860d13b79d90df52ddcbefba2fc9d27607e999c7c3c4d61d9c8:" + "2023-02-16T09:47:07+07:00";
+
+		String hmac = new HmacUtils(HmacAlgorithms.HMAC_SHA_512,
+				"o3Hre3voTrHbLueDrHC0LYM5effHQZILI8t23htbD12TKD5QJUMONqFqv4494iQS46bzHS0xW1fBC5LHo3D0SzhZvQcPUaJZw0iQ79NnzYFUCTrEsoFJRL300dp3Ql4y")
+				.hmacHex(str);
+
+		// System.out.println(hmac);
+	}
+}
@@ -0,0 +1,237 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.io.IOException;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.X509EncodedKeySpec;
+import java.text.ParseException;
+import java.util.Base64;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.HttpStatus;
+
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthFilter;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.common.property.PropGroupVO;
+import com.eactive.eai.common.property.PropManager;
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.inbound.action.ActionFactory;
+import com.eactive.eai.inbound.action.RequestAction;
+import com.eactive.eai.inbound.processor.Processor;
+import com.eactive.eai.message.StandardMessageUtil;
+import com.nimbusds.jose.JWSVerifier;
+import com.nimbusds.jose.crypto.RSASSAVerifier;
+import com.nimbusds.jose.util.IOUtils;
+import com.nimbusds.jwt.SignedJWT;
+
+public class SnapJwtAuthFilter implements HttpAdapterFilter {
+	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+
+	public static final String PROP_GROUP_AUTH_SERVER = "OAuthServer";
+	public static final String PROP_KEYSTORE_PATH = "certification.publicKeyPath";
+
+	private static final String SERVICE_CODE_UNKNOWN = "00";
+
+	public static final String PAYLOAD_PARAM_NAME_SCOPE = "scope";
+	public static final String PAYLOAD_PARAM_NAME_CLIENT_ID = "client_id";
+
+	private JWSVerifier jwsVerifier;
+
+	public SnapJwtAuthFilter() {
+		super();
+
+		PropGroupVO vo = PropManager.getInstance().getPropGroupVO(PROP_GROUP_AUTH_SERVER);
+		String publicKeyPath = "/certificate/elink-oauth-dev.pub";
+		if (vo != null) {
+			publicKeyPath = vo.getProperty(PROP_KEYSTORE_PATH);
+		} else {
+			logger.warn("The properties has not been set.[" + PROP_GROUP_AUTH_SERVER + "]");
+		}
+
+		Resource resource = new ClassPathResource(publicKeyPath);
+		String publicKey = null;
+		try {
+			publicKey = IOUtils.readInputStreamToString(resource.getInputStream());
+			publicKey = StringUtils.replace(publicKey, "-----BEGIN PUBLIC KEY-----", "");
+			publicKey = StringUtils.replace(publicKey, "-----END PUBLIC KEY-----", "");
+			publicKey = StringUtils.remove(publicKey, "\r");
+			publicKey = StringUtils.remove(publicKey, "\n");
+
+			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
+			KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+			jwsVerifier = new RSASSAVerifier((RSAPublicKey) keyFactory.generatePublic(keySpec));
+		} catch (final IOException | NoSuchAlgorithmException | InvalidKeySpecException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		String apiId = assignApiId(adptGrpName, adptName, message, prop, request);
+		if (StringUtils.isBlank(apiId)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Can not find apiId(apiCode) info");
+		}
+
+		try {
+			String token = JwtAuthFilter.extractJWTToken(request);
+			SignedJWT signedJWT = SignedJWT.parse(token);
+
+			if (new Date().after(signedJWT.getJWTClaimsSet().getExpirationTime())) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+						"Invalid Token - expired (B2B)");
+			}
+
+			if (!signedJWT.verify(jwsVerifier)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+						"Invalid Token (B2B)");
+			}
+
+			OAuth2Manager manager = OAuth2Manager.getInstance();
+			HashSet<String> scopeSet = manager.getApiScopeMap().get(apiId);
+			if (!verifyScope(scopeSet, signedJWT)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+						String.format("Insufficient [Scope](Allowed Scope=%s)", scopeSet.toString()));
+			}
+
+			// header 값으로 전송된 clientId와 토큰 소유 clientId check
+			if (!verifyClientId(prop, signedJWT)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+						"client_id not matched(header/token)");
+			}
+		} catch (JwtAuthException e) {
+			logger.debug(e.getMessage());
+			throw e;
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+					"Invalid Token (B2B)");
+		}
+
+		return message;
+	}
+
+	private boolean verifyClientId(Properties prop, SignedJWT signedJWT) {
+		try {
+			// 이전 filter에서 셋팅한 clientId 확보
+			String headerClientId = prop.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);
+			String tokenClientId = (String) signedJWT.getJWTClaimsSet().getClaim(PAYLOAD_PARAM_NAME_CLIENT_ID);
+
+			// 이전 filter에서 셋팅한 값이 없다면 token 정보에서 확보
+			if (StringUtils.isBlank(headerClientId)) {
+				if (StringUtils.isNotBlank(tokenClientId)) {
+					prop.put(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID, tokenClientId);
+				}
+			} else { // header로 전달된 clientId가 있을때만 비교
+				if (!headerClientId.equals(tokenClientId)) {
+					return false;
+				}
+			}
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+		}
+
+		return true;
+	}
+
+	private String assignApiId(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request) {
+		String apiId = null;
+		try {
+			String actionName = prop.getProperty(Processor.REQUEST_ACTION);
+			RequestAction action = ActionFactory.createAction(actionName);
+			action.setAdapterInfo(adptGrpName, adptName, prop);
+			String[] keys = action.perform(message);
+			apiId = keys[0];
+
+			// PathVariable 지원 추가
+			apiId = StandardMessageUtil.getMatchedKey(apiId, actionName);
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+		}
+
+//		// header 에서 확보
+//		String apiId = request.getHeader(HEADER_NAME_API_CODE);
+//		if (StringUtils.isBlank(apiId)) {
+//			// url에서 확보
+//			// /ONLWeb/api/v1/public/getUserInfo.svc/
+//			apiId = request.getRequestURI();
+//			// /ONLWeb/api/v1/public/getUserInfo.svc
+//			apiId = StringUtils.removeEnd(apiId, "/");
+//			// getUserInfo.svc
+//			apiId = StringUtils.substringAfterLast(apiId, "/");
+//		}
+
+		return apiId;
+	}
+
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		return resultMessage;
+	}
+
+	private boolean verifyScope(HashSet<String> scopeSet, SignedJWT signedJWT) throws ParseException {
+		if (scopeSet == null || scopeSet.isEmpty()) {
+			return true; // If no scope is specified in the api, all are allowed
+		}
+
+		String[] scopeArr = signedJWT.getJWTClaimsSet().getStringArrayClaim(PAYLOAD_PARAM_NAME_SCOPE);
+		if (scopeArr == null || scopeArr.length == 0) {
+			return false;
+		}
+
+		for (String scope : scopeArr) {
+			if (scopeSet.contains(scope)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public static String extractJWTToken(HttpServletRequest request) throws JwtAuthException {
+		String authorization = request.getHeader("Authorization");
+		if (StringUtils.isBlank(authorization)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"No have header info: Authorization");
+		}
+
+		String[] components = authorization.split("\\s");
+
+		if (components.length != 2) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Malformat [Authorization] content");
+		}
+
+		if (!StringUtils.equalsIgnoreCase(components[0], "Bearer")) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"[Bearer] is needed");
+		}
+
+		return components[1].trim();
+	}
+}
@@ -0,0 +1,205 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.util.HashSet;
+import java.util.Properties;
+import java.util.Set;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.oauth2.common.OAuth2AccessToken;
+import org.springframework.security.oauth2.provider.OAuth2Authentication;
+import org.springframework.security.oauth2.provider.token.TokenStore;
+
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.authserver.util.BeanUtils;
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.inbound.action.ActionFactory;
+import com.eactive.eai.inbound.action.RequestAction;
+import com.eactive.eai.inbound.processor.Processor;
+import com.eactive.eai.message.StandardMessageUtil;
+
+public class SnapSimpleOauth2Filter implements HttpAdapterFilter {
+	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+
+	private static final String SERVICE_CODE_UNKNOWN = "00";
+
+	private TokenStore tokenStore;
+
+	public SnapSimpleOauth2Filter() {
+		super();
+		tokenStore = BeanUtils.getBean("tokenStore", TokenStore.class);
+	}
+
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		try {
+			String apiId = assignApiId(adptGrpName, adptName, message, prop, request);
+			if (StringUtils.isBlank(apiId)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+						"Can not find apiId(apiCode) info");
+			}
+
+			String tokenStr = extractToken(request);
+
+			OAuth2AccessToken token = tokenStore.readAccessToken(tokenStr);
+			if (token == null) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "03"),
+						"Token Not Found (B2B)");
+			}
+
+			if (token.isExpired()) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+						"Invalid Token - expired (B2B)");
+			}
+
+			OAuth2Authentication authentication = tokenStore.readAuthentication(token);
+			if (!authentication.isAuthenticated()) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+						"Invalid Token (B2B)");
+			}
+
+			// check scope
+			OAuth2Manager manager = OAuth2Manager.getInstance();
+			HashSet<String> scopeSet = manager.getApiScopeMap().get(apiId);
+			if (!verifyScope(scopeSet, authentication)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+						String.format("Insufficient [Scope](Allowed Scope=%s)", scopeSet.toString()));
+			}
+
+			// header 값으로 전송된 clientId와 토큰 소유 clientId check
+			if (!verifyClientId(prop, authentication)) {
+				throw new JwtAuthException(
+						String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+						"client_id not matched(header/token)");
+			}
+		} catch (JwtAuthException e) {
+			logger.debug(e.getMessage());
+			throw e;
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "01"),
+					"Invalid Token (B2B)");
+		}
+
+		return message;
+	}
+
+	private boolean verifyScope(HashSet<String> scopeSet, OAuth2Authentication auth) {
+		if (scopeSet == null || scopeSet.isEmpty()) {
+			return true; // If no scope is specified in the api, all are allowed
+		}
+
+		Set<String> scopesInToken = auth.getOAuth2Request().getScope();
+
+		if (scopesInToken == null || scopesInToken.isEmpty()) {
+			return false;
+		}
+
+		for (String scope : scopesInToken) {
+			if (scopeSet.contains(scope)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private boolean verifyClientId(Properties prop, Authentication authentication) {
+		try {
+			// 이전 filter에서 셋팅한 clientId 확보
+			String headerClientId = prop.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);
+			String tokenClientId = ((OAuth2Authentication) authentication).getOAuth2Request().getClientId();
+
+			// 이전 filter에서 셋팅한 값이 없다면 token 정보에서 확보
+			if (StringUtils.isBlank(headerClientId)) {
+				if (StringUtils.isNotBlank(tokenClientId)) {
+					prop.put(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID, tokenClientId);
+				}
+			} else { // header로 전달된 clientId가 있을때만 비교
+				if (!headerClientId.equals(tokenClientId)) {
+					return false;
+				}
+			}
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+		}
+
+		return true;
+	}
+
+	private String assignApiId(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request) {
+		String apiId = null;
+		try {
+			String actionName = prop.getProperty(Processor.REQUEST_ACTION);
+			RequestAction action = ActionFactory.createAction(actionName);
+			action.setAdapterInfo(adptGrpName, adptName, prop);
+			String[] keys = action.perform(message);
+			apiId = keys[0];
+
+			// PathVariable 지원 추가
+			apiId = StandardMessageUtil.getMatchedKey(apiId, actionName);
+		} catch (Exception e) {
+			logger.error(e.getMessage());
+		}
+
+//		// header 에서 확보
+//		String apiId = request.getHeader(HEADER_NAME_API_CODE);
+//		if (StringUtils.isBlank(apiId)) {
+//			// url에서 확보
+//			// /ONLWeb/api/v1/public/getUserInfo.svc/
+//			apiId = request.getRequestURI();
+//			// /ONLWeb/api/v1/public/getUserInfo.svc
+//			apiId = StringUtils.removeEnd(apiId, "/");
+//			// getUserInfo.svc
+//			apiId = StringUtils.substringAfterLast(apiId, "/");
+//		}
+
+		return apiId;
+	}
+
+	public static String extractToken(HttpServletRequest request) throws JwtAuthException {
+		String authorization = request.getHeader("Authorization");
+		if (StringUtils.isBlank(authorization)) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"No have header info: Authorization");
+		}
+
+		String[] components = authorization.split("\\s");
+
+		if (components.length != 2) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"Malformat [Authorization] content");
+		}
+
+		if (!StringUtils.equalsIgnoreCase(components[0], "Bearer")) {
+			throw new JwtAuthException(
+					String.format("%d%s%s", HttpStatus.UNAUTHORIZED.value(), SERVICE_CODE_UNKNOWN, "00"),
+					"[Bearer] is needed");
+		}
+
+		return components[1].trim();
+	}
+
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		return resultMessage;
+	}
+}
@@ -1,18 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
-
-/**
- * 토스 암복호화에 맟추어 커스텀 필요
- */
-public class TossEncFieldInCryptoFilter extends EncFieldInCryptoFilter {
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(InCryptoFilter.PROP_DEC_FROM_PATH, "/encrypted_data");
-		p.setProperty(InCryptoFilter.PROP_ENC_TO_PATH, "/encrypted_data");
-		return p;
-	}
-
-}
@@ -1,18 +0,0 @@
-package com.eactive.eai.custom.adapter.http.dynamic.filter;
-
-import java.util.Properties;
-
-import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
-
-/**
- * 토스뱅크 암복호화에 맟추어 커스텀 필요
- */
-public class TossbankEncFieldInCryptoFilter extends EncFieldInCryptoFilter {
-
-	protected Properties setProp(Properties p) {
-		p.setProperty(InCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
-		p.setProperty(InCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
-		return p;
-	}
-
-}
@@ -0,0 +1,120 @@
+package com.eactive.eai.custom.adapter.http.dynamic.filter;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Properties;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
+import com.eactive.eai.authserver.service.OAuth2Manager;
+import com.eactive.eai.authserver.vo.ClientVO;
+import com.eactive.eai.common.dao.DAOException;
+import com.eactive.eai.common.property.PropGroupVO;
+import com.eactive.eai.common.property.PropManager;
+import com.eactive.eai.custom.adapter.http.util.VirtualAccountBatchUtil;
+import com.eactive.eai.custom.adapter.http.util.VirtualAccountTransform;
+
+public class VirtualAccountCryptoFilter implements HttpAdapterFilter {
+	// FIXME : kbank - 프라퍼티 그릅정의 확정
+	private static final String BATCH_CHECK_URL = "/batch/";
+	private static final String BATCH_PROP_GROUP = "VIRTUALACCOUNT_INFO";
+	private static final String BATCH_FILE_PATH = "BATCH_FILE_PATH";
+	private static final String FILE_NAME_PATTERN = "FILE_NAME_PATTERN";
+	
+	private String getAesKey(String clientId) {
+		OAuth2Manager manager = OAuth2Manager.getInstance();			
+		try {
+			ClientVO client = manager.getClientInfo(clientId);
+			return client.getSecurityKey();
+		} catch (DAOException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+	
+	private boolean isBatch(HttpServletRequest request) {
+	    String uri = request.getRequestURI();
+	    return uri != null && uri.contains(BATCH_CHECK_URL);
+	}
+	
+	private String getRootFilePath() {
+		PropGroupVO vo = PropManager.getInstance().getPropGroupVO(BATCH_PROP_GROUP);
+		return vo.getProperty(BATCH_FILE_PATH);
+	}
+	
+	private String getFileNamePattern() {
+		PropGroupVO vo = PropManager.getInstance().getPropGroupVO(BATCH_PROP_GROUP);
+		return vo.getProperty(FILE_NAME_PATTERN);
+	}
+	
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		String charset = StringUtils.defaultIfBlank(AdapterManager.getInstance().getAdapterGroupVO(adptGrpName).getMessageEncode(), "UTF-8");
+		String encPaths = prop.getProperty(HttpAdapterServiceKey.ENC_PATHS);
+		List<String> encFieldList = null;
+		String clientId = prop.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);		
+		String aesKey = getAesKey(clientId);
+	
+		String convertedMessage = null;
+		if(isBatch(request)) {
+			String rootFilePath = getRootFilePath();
+			String fileNamePattern = getFileNamePattern();
+			VirtualAccountBatchUtil batchUtil = new VirtualAccountBatchUtil();
+			if(message instanceof byte[]) {
+				convertedMessage = new String((byte[])message, charset);
+			} else {
+				convertedMessage = (String) message;
+			}
+			batchUtil.unzipAndSave(aesKey, convertedMessage, rootFilePath, fileNamePattern);
+		}
+		else {
+			if(StringUtils.isNotBlank(encPaths)) {
+				String[] items = encPaths.split(",");
+				encFieldList = Arrays.asList(items);
+				if(message instanceof byte[]) {
+					convertedMessage = new String((byte[])message, charset);
+				} else {
+					convertedMessage = (String) message;
+				}
+				convertedMessage = VirtualAccountTransform.toCubeOne(aesKey, encFieldList, convertedMessage);
+			}
+		}
+		return convertedMessage;
+	}
+
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
+			HttpServletRequest request, HttpServletResponse response) throws Exception {
+		String charset = StringUtils.defaultIfBlank(AdapterManager.getInstance().getAdapterGroupVO(adptGrpName).getMessageEncode(), "UTF-8");
+		String encPaths = prop.getProperty(HttpAdapterServiceKey.ENC_PATHS);
+		List<String> encFieldList = null;
+		String clientId = prop.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);		
+		String aesKey = getAesKey(clientId);
+		
+		if(isBatch(request)) {
+			return resultMessage;
+		}
+		else {
+			String resMessageString = null;
+			if(StringUtils.isNotBlank(encPaths)) {
+				String[] items = encPaths.split(",");
+				encFieldList = Arrays.asList(items);
+				if(resultMessage instanceof byte[]) {
+					resMessageString = new String((byte[])resultMessage, charset);
+				} else {
+					resMessageString = (String) resultMessage;
+				}
+				resMessageString = VirtualAccountTransform.toAES(aesKey, encFieldList, resMessageString);
+			}			
+			return resMessageString;
+		}
+	}
+}
@@ -0,0 +1,766 @@
+package com.eactive.eai.custom.adapter.http.dynamic.impl;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.fileupload.FileItem;
+import org.apache.commons.fileupload.disk.DiskFileItemFactory;
+import org.apache.commons.fileupload.servlet.ServletFileUpload;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.apache.mina.common.ByteBuffer;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.JSONValue;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.util.AntPathMatcher;
+
+import com.eactive.eai.adapter.AdapterManager;
+import com.eactive.eai.adapter.AdapterPropManager;
+import com.eactive.eai.adapter.AdapterVO;
+import com.eactive.eai.adapter.Keys;
+import com.eactive.eai.adapter.http.HttpMemoryLogger;
+import com.eactive.eai.adapter.http.HttpMethodType;
+import com.eactive.eai.adapter.http.HttpStatusException;
+import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
+import com.eactive.eai.common.TransactionContextKeys;
+import com.eactive.eai.common.exception.ExceptionUtil;
+import com.eactive.eai.common.message.MessageType;
+import com.eactive.eai.common.util.CommonLib;
+import com.eactive.eai.common.util.HttpAdapterExtraLogUtil;
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.common.util.MessageUtil;
+import com.eactive.eai.env.ElinkConfig;
+import com.eactive.eai.inbound.action.ActionFactory;
+import com.eactive.eai.inbound.action.RequestAction;
+import com.eactive.eai.inbound.processor.Processor;
+import com.eactive.eai.message.StandardMessageUtil;
+
+/*
+* Kbank 가상계좌 INBOUND
+* @see com.eactive.eai.custom.adapter.http.dynamic.filter.VirtualAccountCryptoFilter
+* @Deprecated
+*/
+// FIXME : kbank - kbank에서는 Controller 방식을 사용하므로, 이 어댑터는 사용되지 않음 (VirtualAccountCryptoFilter 로 대체)
+public class HttpAdapterServiceVirtualAccount extends HttpAdapterServiceSupport {
+	public static final String HEADER_GROUP = "HEADER_GROUP";
+	// HEADER_GROUP JSON에 추가할 항목 정의, 없으면 전체 header 추가
+	public static final String HEADER_KEYS = "HEADER_KEYS";
+	public static final String HTTP_STATUS = "HTTP_STATUS";
+	public static final String PROPERTIES_NAME_HTTP_REQUEST_METHOD = "httpRequestMethod";
+
+	static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+	private String logPrefix = "HttpAdapterServiceRest] ";
+
+	private static final String JSON_CONTENT_TYPE = "application/json";
+	private static final String JSON_FIELD_NAME = "json-body";
+	private static final String FILE_GROUP_NAME = "image-file";
+	private static final String UPLOAD_ROOT_PATH = "UPLOAD_ROOT_PATH";
+	
+	private Properties addCryptoFilter(Properties prop) {
+		String cryptoFilterName = "com.eactive.eai.custom.adapter.http.dynamic.filter.VirtualAccountCryptoFilter";
+		String addedPreFilter = prop.getProperty(PRE_FILTERS);
+		String addedPostFilter = prop.getProperty(POST_FILTERS);
+		
+		if(StringUtils.isBlank(addedPreFilter)) {
+			addedPreFilter = cryptoFilterName;
+		}
+		else {
+			addedPreFilter = addedPreFilter + "," +cryptoFilterName;
+		}
+		
+		if(StringUtils.isBlank(addedPostFilter)) {
+			addedPostFilter = cryptoFilterName;
+		}
+		else {
+			addedPostFilter = cryptoFilterName + "," +addedPostFilter;
+		}
+		
+		prop.setProperty(PRE_FILTERS, addedPreFilter);
+		prop.setProperty(POST_FILTERS, addedPostFilter);
+		return prop;
+	}
+	
+	private String readMultipartBody(HttpServletRequest request) throws Exception {
+		String jsonString = null;
+		// Create a factory for disk-based file items
+		DiskFileItemFactory factory = new DiskFileItemFactory();
+
+		// Set the maximum size of the files to be uploaded
+		factory.setSizeThreshold(1024 * 1024);
+
+		// Set the temporary directory to store uploaded files
+		File tempDir = (File) request.getSession().getServletContext().getAttribute("javax.servlet.context.tempdir");
+		factory.setRepository(tempDir);
+
+		ServletFileUpload upload = new ServletFileUpload(factory);
+		Map<String, String> fileMap = new HashMap<>();
+
+		InputStream fin = null;
+		try {
+			byte[] buffer = new byte[1024];
+			int read = 0;
+
+			List<FileItem> items = upload.parseRequest(request);
+			for (FileItem item : items) {
+				if (!item.isFormField()) {
+					// file
+					String fieldName = item.getFieldName();
+					String fileName = item.getName();
+					fin = item.getInputStream();
+					ByteArrayOutputStream fo = new ByteArrayOutputStream();
+					while ((read = fin.read(buffer)) > 0) {
+						fo.write(buffer, 0, read);
+					}
+					int fileSize = fo.size();
+					byte[] fileBytes = fo.toByteArray();
+					String fileContents = new String(fileBytes);
+					if (logger.isInfo()) {
+						logger.info("[FILE]-------------------------------------------------->");
+						logger.info("Field name = " + fieldName);
+						logger.info("File name = " + fileName + " contents length = " + fileSize);
+						logger.info("File Contents [" + fileContents + "]");
+						logger.info("[FILE]<--------------------------------------------------");
+					}
+					fileMap.put(fileName, fileContents);
+					fin.close();
+				} else {
+					// regular form field
+					String fieldName = item.getFieldName();
+					String fieldValue = item.getString();
+					if (logger.isInfo()) {
+						logger.info("[FIELD] " + fieldName + " [" + fieldValue + "]");
+					}
+					if (JSON_CONTENT_TYPE.equalsIgnoreCase(item.getContentType())
+							|| JSON_FIELD_NAME.equals(fieldName)) {
+						jsonString = fieldValue;
+					}
+				}
+			}
+
+			if (logger.isInfo()) {
+				logger.info("Json body [" + jsonString + "]");
+			}
+
+			if (jsonString == null) {
+				jsonString = "{}";
+			} else {
+				// parsing json & add file contents
+				JSONObject jsonObject = (JSONObject) JSONValue.parse(jsonString);
+				if (jsonObject == null) {
+					jsonString = "{}";
+				} else {
+					JSONObject fileGroup = new JSONObject();
+
+					for (Map.Entry<String, String> entry : fileMap.entrySet()) {
+						fileGroup.put("fileName", entry.getKey());
+						fileGroup.put("fileContents", entry.getValue());
+					}
+					jsonObject.put(FILE_GROUP_NAME, fileGroup);
+					jsonString = jsonObject.toJSONString();
+				}
+			}
+
+			if (logger.isInfo()) {
+				logger.info("Json with file [" + jsonString + "]");
+			}
+			return jsonString;
+		} catch (Exception e) {
+			logger.error("Read multipart body error.", e);
+			throw e;
+		} finally {
+			if (fin != null) {
+				try {
+					fin.close();
+				} catch (Exception ex) {
+					// empty
+				}
+			}
+		}
+	}
+
+	private String checkRootPath(String path) {
+		if (StringUtils.isEmpty(path)) {
+			logger.info("upload dir not set(UPLOAD_ROOT_PATH), use system temp " + path);
+			return System.getProperty("java.io.tmpdir");
+		}
+		File file = new File(path);
+		if (!file.exists()) {
+			file.mkdirs();
+		}
+		return path;
+	}
+
+	private String uploadMultipartBody(HttpServletRequest request, String uploadRootPath) throws Exception {
+		String jsonString = null;
+		// Create a factory for disk-based file items
+		DiskFileItemFactory factory = new DiskFileItemFactory();
+
+		// Set the maximum size of the files to be uploaded
+		factory.setSizeThreshold(1024 * 1024);
+
+		// Set the temporary directory to store uploaded files
+		File tempDir = (File) request.getSession().getServletContext().getAttribute("javax.servlet.context.tempdir");
+		factory.setRepository(tempDir);
+
+		ServletFileUpload upload = new ServletFileUpload(factory);
+		try {
+			// if not exist, create folders
+			String uploadDir = checkRootPath(uploadRootPath);
+			List<FileItem> items = upload.parseRequest(request);
+			for (FileItem item : items) {
+				if (!item.isFormField()) {
+					// file
+					String fieldName = item.getFieldName();
+					String fileName = item.getName();
+					String uploadFilePath = uploadDir + File.separator + fileName;
+					File uploadFile = new File(uploadFilePath);
+					item.write(uploadFile);
+
+					if (logger.isInfo()) {
+						logger.info("[FILE]-------------------------------------------------->");
+						logger.info("Field name = " + fieldName);
+						logger.info("File name = " + fileName + " path = " + uploadFile.getAbsolutePath());
+						logger.info("[FILE]<--------------------------------------------------");
+					}
+				} else {
+					// regular form field
+					String fieldName = item.getFieldName();
+					String fieldValue = item.getString();
+					if (logger.isInfo()) {
+						logger.info("[FIELD] " + fieldName + " [" + fieldValue + "]");
+					}
+					if (JSON_CONTENT_TYPE.equalsIgnoreCase(item.getContentType())
+							|| JSON_FIELD_NAME.equals(fieldName)) {
+						jsonString = fieldValue;
+					}
+				}
+			}
+
+			if (logger.isInfo()) {
+				logger.info("Json body [" + jsonString + "]");
+			}
+			return jsonString;
+		} catch (Exception e) {
+			logger.error("Read multipart body error.", e);
+			throw e;
+		}
+	}
+
+	@SuppressWarnings({ "unchecked", "deprecation" })
+	public void service(String adptGrpName, String adptName, HttpServletRequest request, HttpServletResponse response) {
+		int traceLevel = 0;
+
+		AdapterVO adptVO = null;
+		AdapterPropManager manager = null;
+
+		Properties httpProp = null;
+		String responseType = null;
+		String urlDecodeYn = null;
+		String encode = null;
+
+		String traceLevelTemp = null;
+		String relayRequestHeaderKeys = null;
+		String headerGroupName = null;
+
+		boolean isParameterType = false;
+		String message = null;
+
+		StopWatch stopWatch = null;
+		Properties prop = null;
+		String paramValue = null;
+		String adptMsgType = null;
+		String errorResponseFormat = null;
+		String uploadRootPath = null;
+		try {
+			AdapterManager adapterManager = AdapterManager.getInstance();
+			adptVO = adapterManager.getAdapterVO(adptGrpName, adptName);
+			if (adptVO == null) {
+				throw new Exception("Adapter not found error");
+			}
+
+			manager = AdapterPropManager.getInstance();
+
+			httpProp = manager.getProperties(adptVO.getPropGroupName());
+			responseType = httpProp.getProperty(RESPONSE_TYPE, "SYNC");
+			urlDecodeYn = httpProp.getProperty(URL_DECODE_YN, "N");
+			// encode = httpProp.getProperty(ENCODE, "UTF-8");
+			encode = StringUtils.defaultIfBlank(adapterManager.getAdapterGroupVO(adptGrpName).getMessageEncode(),
+					"UTF-8");
+			traceLevelTemp = httpProp.getProperty(TRACE_LEVEL, "0");
+			relayRequestHeaderKeys = httpProp.getProperty(HEADER_KEYS);
+			headerGroupName = httpProp.getProperty(HEADER_GROUP);
+			errorResponseFormat = httpProp.getProperty(ERROR_RESPONSE_FORMAT);
+			uploadRootPath = httpProp.getProperty(UPLOAD_ROOT_PATH);
+			prop = new Properties();
+			prop.put(INBOUND_METHOD, request.getMethod());
+			prop.put(INBOUND_URI, request.getRequestURI());
+			prop.put(INBOUND_HEADER, getHeaders(request));
+			prop.put(INBOUND_EXTPARAMS, StringUtils.defaultString(request.getQueryString()));
+			if (StringUtils.equals(adptVO.getAdapterGroupVO().getType(), Keys.TYPE_REST)
+					|| StringUtils.equals(adptVO.getAdapterGroupVO().getType(), Keys.TYPE_HTTP_CUSTOM)) {
+				// /api/v1/public/getUserInfo.svc
+				String extUrl = StringUtils.removeStart(request.getRequestURI(), request.getContextPath());
+				prop.put(INBOUND_EXTURI, extUrl);
+			} else {
+				prop.put(INBOUND_EXTURI, getExtUri(request));
+			}
+			prop.put(Processor.REQUEST_ACTION, adptVO.getAdapterGroupVO().getRefClass());
+			prop.put(API_PATH, httpProp.getProperty(API_PATH, ""));
+			prop.put(PRE_FILTERS, httpProp.getProperty(PRE_FILTERS, ""));
+			prop.put(POST_FILTERS, httpProp.getProperty(POST_FILTERS, ""));
+			prop.put(PROPERTIES_NAME_HTTP_REQUEST_METHOD, request.getMethod());
+			prop.put(ALLOW_IP, httpProp.getProperty(ALLOW_IP, ""));
+
+			isParameterType = false;
+			try {
+				traceLevel = Integer.parseInt(traceLevelTemp);
+			} catch (Exception e) {
+				traceLevel = 0;
+			}
+
+			stopWatch = new StopWatch();
+			stopWatch.start();
+
+			logger.debug("시작 >> encode = [" + encode + "]");
+
+			switch (HttpMethodType.getValue(request.getMethod())) {
+			case GET:
+			case DELETE:
+				isParameterType = true;
+				break;
+			case POST:
+			case PUT:
+				if (StringUtils.contains(request.getContentType(), "application/x-www-form-urlencoded")) {
+					isParameterType = true;
+				} else {
+					isParameterType = false;
+				}
+				break;
+			default:
+				break;
+			}
+
+			if (isParameterType) {
+				paramValue = request.getQueryString();
+				if (paramValue == null)
+					paramValue = "";
+				if (traceLevel >= 3) {
+					HttpMemoryLogger.txlog(adptGrpName + adptName,
+							"RECV " + "[" + paramValue + "]" + CommonLib.getDumpMessage(paramValue));
+				}
+
+				// json으로 변환
+				StringBuilder sb = new StringBuilder();
+				sb.append("{");
+				Map<String, String[]> paramMap = assignParameterMap(request, adptGrpName, adptName, null, prop);
+				int i = 0;
+				for (Map.Entry<String, String[]> entry : paramMap.entrySet()) {
+					if (i > 0) {
+						sb.append(",");
+					}
+					sb.append("\"").append(entry.getKey()).append("\":");
+					String[] values = entry.getValue();
+					if (values.length > 1) {
+						// ["111", "222"]
+						sb.append("[");
+						for (int j = 0; j < values.length; j++) {
+							if (j > 0) {
+								sb.append(",");
+							}
+							sb.append("\"").append(JSONValue.escape(values[j])).append("\"");
+						}
+						sb.append("]");
+					} else {
+						sb.append("\"").append(JSONValue.escape(values[0])).append("\"");
+					}
+
+					i++;
+				}
+
+				sb.append("}");
+
+				paramValue = sb.toString();
+			} else {
+				if (ServletFileUpload.isMultipartContent(request)) {
+					// TODO : 아래의 로직은 업무에 맞게 수정이 필요함.
+					// 불필요할 경우 제거
+//					if(StringUtils.isEmpty(uploadRootPath)) {
+//						uploadRootPath = System.getProperty("java.io.tmpdir");
+//					}
+
+					// 임시로직 : UPLOAD_ROOT_PATH 가 없는 경우에는 JSON에 추가
+					if (StringUtils.isEmpty(uploadRootPath)) {
+						paramValue = readMultipartBody(request);
+					} else {
+						paramValue = uploadMultipartBody(request, uploadRootPath);
+					}
+					// TEST : 테스트용 임시코드
+//					response.setCharacterEncoding(encode);
+//					response.getWriter().print(paramValue);
+//					return;
+				} else {
+					ServletInputStream sis = request.getInputStream();
+					ByteBuffer bb = ByteBuffer.allocate(1024).setAutoExpand(true);
+					int i = 0;
+					byte[] cbuf = new byte[1024];
+					while ((i = sis.read(cbuf, 0, 1024)) != -1) {
+						if (i == 1024) {
+							bb.put(cbuf);
+						} else {
+							byte[] tail = new byte[i];
+							System.arraycopy(cbuf, 0, tail, 0, i);
+							bb.put(tail);
+						}
+					}
+					byte[] data = new byte[bb.position()];
+					bb.position(0);
+					bb.get(data);
+					paramValue = new String(data, encode);
+
+					if (traceLevel >= 3) {
+						HttpMemoryLogger.txlog(adptGrpName + adptName,
+								"RECV " + "[" + paramValue + "]" + CommonLib.getDumpMessage(paramValue));
+					}
+				}
+			}
+
+			if (paramValue == null) { // parameter가 없는 경우때문에 처리
+				paramValue = "";
+			}
+
+			if (logger.isDebug()) {
+				logger.debug("HttpAdapterServiceRest] RECV (" + adptGrpName + ") = [" + paramValue + "]\n"
+						+ CommonLib.getDumpMessage(paramValue));
+			}
+
+			if ("Y".equals(urlDecodeYn) && isParameterType) {
+				message = URLDecoder.decode(paramValue);
+			} else {
+				message = paramValue;
+			}
+
+			if (logger.isDebug()) {
+				String[] msgArgs = new String[2];
+				msgArgs[0] = adptGrpName;
+				msgArgs[1] = message;
+				String resMsg = ExceptionUtil.make("RICEAIAHA005", msgArgs);
+				logger.debug(logPrefix + resMsg);
+			}
+			
+			adptMsgType = adptVO.getAdapterGroupVO().getMessageType();
+			if (StringUtils.equals(adptMsgType, MessageType.JSON)) {
+				response.setContentType(JSON_CONTENT_TYPE+"; charset="+encode);
+			}
+
+			// HEADER_GROUP 셋팅
+			if (MessageType.JSON.equals(adptMsgType) && StringUtils.isNotBlank(headerGroupName)
+					&& StringUtils.isNotBlank(relayRequestHeaderKeys)) {
+				JSONObject jsonMessage = (JSONObject) JSONValue.parse(message);
+				JSONObject headerJson = new JSONObject();
+				if (StringUtils.equalsIgnoreCase(relayRequestHeaderKeys, "ALL")) {
+					for (Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements();) {
+						String key = e.nextElement();
+						headerJson.put(key, request.getHeader(key));
+					}
+				} else {
+					String[] relayKeyArr = org.springframework.util.StringUtils
+							.tokenizeToStringArray(relayRequestHeaderKeys, ",");
+
+					for (String key : relayKeyArr) {
+						String headerValue = request.getHeader(key);
+						if (StringUtils.isNotBlank(headerValue)) {
+							headerJson.put(key, headerValue);
+						}
+					}
+				}
+
+				if (headerJson.size() > 0) {
+					jsonMessage.put(headerGroupName, headerJson);
+					message = jsonMessage.toJSONString();
+				}
+			}
+
+			if (message == null) {
+				message = "";
+			}
+			
+			// com.eactive.eai.custom.adapter.http.dynamic.filter.VirtualAccountCryptoFilter
+			prop = addCryptoFilter(prop);
+			
+			// 로컬 서비스 호출 ,encoding 처리 추가
+			String result = (String) service(adptGrpName, adptName, message, prop, request, response);
+
+			if (logger.isDebug()) {
+				logger.debug("HttpAdapterServiceRest] result " + encode + " (" + adptGrpName + ") = [" + result + "]");
+			}
+
+			stopWatch.stop();
+
+			String responseData = "";
+			if (RESPONSE_TYPE_ASYNC.equals(responseType)) {
+				if (stopWatch.getTime() > slowTranTime && (logger.isInfo())) {
+					logger.info("HttpAdapterServiceRest] dummy response time = " + stopWatch.toString() + ", message = "
+							+ message);
+
+				}
+				if (result == null) {
+					responseData = ElinkConfig.getAsyncDummyDataForAdapterGroup(adptGrpName);
+				}
+				
+				response.setCharacterEncoding(encode);
+				response.getWriter().print(responseData);
+				if (traceLevel >= 3) {
+					HttpMemoryLogger.txlog(adptGrpName + adptName,
+							"SEND " + "[" + responseData + "]" + CommonLib.getDumpMessage(responseData));
+				}
+			} else {
+				responseData = result;
+				logger.info("종료 >> encode = [" + encode + "]");
+
+				JSONObject dataObject = null;
+				if (MessageType.JSON.equals(adptMsgType)) {
+					dataObject = (JSONObject) JSONValue.parse(responseData);
+				}
+
+				// HEADER_GROUP 하위 필드를 response Header에 세팅한다.
+				HashMap<String, String> header = new HashMap<>();
+				boolean redirect = assignHttpHeaders(header, dataObject, headerGroupName);
+
+				if (logger.isDebug()) {
+					logger.debug("HttpAdapterServiceRest] response header field (" + adptGrpName + ") = ["
+							+ header.toString() + "]");
+				}
+
+				if (redirect) {
+					response.setStatus(302);
+					logger.debug("HttpAdapterServiceRest] set response status_code: 302");
+				} else {
+					String httpStatus = header.get(HTTP_STATUS);
+					if (httpStatus != null && !"".equals(httpStatus))
+						response.setStatus(Integer.parseInt(httpStatus));
+					header.remove(HTTP_STATUS);
+				}
+
+				// response header 셋팅
+				for (Map.Entry<String, String> entry : header.entrySet()) {
+					response.setHeader(entry.getKey(), entry.getValue());
+				}
+
+				if (dataObject != null) {
+					responseData = dataObject.toJSONString();
+				}
+
+				// UI와 통신시(UTF-8) 변환오류로 ENCODE 제거
+				response.setCharacterEncoding(encode);
+				response.getWriter().print(responseData);
+				if (logger.isDebug()) {
+					logger.debug("HttpAdapterServiceRest] SEND (" + adptGrpName + ") = [" + responseData + "]");
+					logger.debug("HttpAdapterServiceRest] SEND (" + adptGrpName + ") = "
+							+ CommonLib.getDumpMessage(responseData));
+				}
+				if (traceLevel >= 3) {
+					HttpMemoryLogger.txlog(adptGrpName + adptName,
+							"SEND " + "[" + responseData + "]" + CommonLib.getDumpMessage(responseData));
+				}
+			}
+		} catch (HttpStatusException e) {
+			if (traceLevel >= 3) {
+				HttpMemoryLogger.error(adptGrpName + adptName, e.toString(), e);
+			}
+			logger.warn("HttpAdapter] " + adptGrpName + "-" + adptName + ">>" + e.getMessage());
+			response.setStatus(e.getStatus());
+			try {
+				String errorMsg = MessageUtil.makeErrorMessageByMessageType(adptMsgType, encode, e.getCode(),
+						e.getMessage(), errorResponseFormat);
+				response.getWriter().println(errorMsg);
+			} catch (Exception ex) {
+				// IGNORE
+			}
+		} catch (JwtAuthException e) {
+			if (traceLevel >= 3) {
+				HttpMemoryLogger.error(adptGrpName + adptName, e.toString(), e);
+			}
+			logger.error(logPrefix + adptGrpName + "-" + adptName + ">>" + e.getMessage(), e);
+			response.setStatus(HttpStatus.UNAUTHORIZED.value());
+			try {
+				String errorMsg = MessageUtil.makeErrorMessageByMessageType(adptMsgType, encode, e.getCode(),
+						e.getMessage(), errorResponseFormat);
+				response.getWriter().println(errorMsg);
+			} catch (Exception ex) {
+				// IGNORE
+			}
+		} catch (Exception e) {
+			if (traceLevel >= 3) {
+				HttpMemoryLogger.error(adptGrpName + adptName, e.toString(), e);
+			}
+			logger.error(logPrefix + adptGrpName + "-" + adptName + ">>" + e.getMessage(), e);
+			response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+			try {
+				response.getWriter().println(e.getMessage());
+				String errCode = ExceptionUtil.getErrorCode(e, "RECEAIAHA003");
+				throw new Exception(errCode);
+			} catch (Exception ex) {
+				// IGNORE
+				logger.warn(logPrefix + adptGrpName + "-" + adptName + ">>" + e.getMessage(), e);
+			}
+		} finally {
+			String uuid = prop.getProperty(TransactionContextKeys.TRANSACTION_UUID);
+			String url = prop.getProperty(HttpClientAdapterServiceKey.INBOUND_EXTURI);
+			String method = prop.getProperty(HttpClientAdapterServiceKey.INBOUND_METHOD);
+			String adapterGroupName = prop.getProperty(HttpClientAdapterServiceKey.ADAPTER_GROUP_NAME);
+			String adapterName = prop.getProperty(HttpClientAdapterServiceKey.ADAPTER_NAME);
+			int httpStatusCode = response.getStatus();
+			HttpAdapterExtraLogUtil.insertHttpAdapterExtraLog(uuid, 400, adapterGroupName, adapterName, new HashMap<>(), url, method, httpStatusCode);
+		}
+	}
+
+	private Map<String, String[]> assignParameterMap(HttpServletRequest request, String adptGrpName, String adptName,
+			Object requestBytes, Properties prop) {
+		// PathVariable 체크
+		if (StringUtils.equalsAnyIgnoreCase(request.getMethod(), HttpMethod.GET.name(), HttpMethod.DELETE.name())
+				&& StringUtils.isBlank(request.getQueryString())) {
+			try {
+				String actionName = prop.getProperty(Processor.REQUEST_ACTION);
+				RequestAction action = ActionFactory.createAction(actionName);
+				action.setAdapterInfo(adptGrpName, adptName, prop);
+				String[] keys = action.perform(requestBytes);
+				String requestPath = keys[0];
+
+				// PathVariable 지원 추가
+				String ruledPath = StandardMessageUtil.getMatchedKey(requestPath, actionName);
+				if (!StringUtils.equals(requestPath, ruledPath) && StringUtils.contains(ruledPath, "{")) {
+					Map<String, String> paramMap = new AntPathMatcher().extractUriTemplateVariables(ruledPath,
+							requestPath);
+					if (paramMap != null && paramMap.size() > 0) {
+						Map<String, String[]> returnMap = new HashMap<>();
+						for (String key : paramMap.keySet()) {
+							if (StringUtils.equalsIgnoreCase(key, "method")) {
+								continue;
+							}
+							returnMap.put(key, new String[] { paramMap.get(key) });
+						}
+
+						return returnMap;
+					}
+				}
+			} catch (Exception e) {
+				logger.error(e.getMessage());
+			}
+		}
+
+		return request.getParameterMap();
+	}
+
+	private void validateServiceAndAdapter(String adptGrpName, String adptName, byte[] requestBytes, Properties prop)
+			throws JwtAuthException {
+
+	}
+
+	/**
+	 * request header 를 hashmap으로 조립
+	 * 
+	 * @param request
+	 * @return
+	 */
+	private Properties getHeaders(HttpServletRequest request) {
+		Properties prop = new Properties();
+
+		Enumeration<String> headerNames = request.getHeaderNames();
+		while (headerNames.hasMoreElements()) {
+			String key = headerNames.nextElement();
+			String value = request.getHeader(key);
+			prop.setProperty(key, value);
+		}
+
+		return prop;
+	}
+
+	/**
+	 * adapter property의 HEADER_GROUP으로 정의된 (MFE_HEADER) 그룹의 하위 필드를 http Header에
+	 * 세팅한다.
+	 * 
+	 * @param header
+	 * @param object
+	 */
+	private boolean assignHttpHeaders(HashMap<String, String> header, Object msg, String headerGroupName) {
+		boolean redirect = false;
+
+		if (msg == null || StringUtils.isBlank(headerGroupName)) {
+			return false;
+		}
+
+		if (msg instanceof JSONObject) {
+			JSONObject headerObject = (JSONObject) ((JSONObject) msg).get(headerGroupName);
+
+			if (headerObject == null) {
+				return false;
+			}
+
+			// List<String> headerKeys = new ArrayList<>();
+			for (Object key : headerObject.keySet()) {
+
+				Object obj = headerObject.get(key);
+				if ((obj instanceof JSONObject) || (obj instanceof JSONArray)) {
+					continue;
+				}
+
+				header.put((String) key, (String) obj);
+
+				if (StringUtils.equalsIgnoreCase((String) key, "Location")) {
+					redirect = true;
+				}
+			}
+
+			((JSONObject) msg).remove(headerGroupName);
+		}
+
+		return redirect;
+	}
+
+	/**
+	 * 어댑터 명 이후의 URI값을 가져온다.
+	 * 
+	 * @param request
+	 * @return
+	 */
+	private String getExtUri(HttpServletRequest request) {
+		String orgUri = request.getRequestURI().replaceAll(request.getContextPath(), "");
+		String uri = getExtUri(orgUri, 3);
+		if (uri != null && uri.trim().length() > 0) {
+			return "/" + uri;
+		} else {
+			return "";
+		}
+	}
+
+	private static String getExtUri(String url, int length) {
+		String[] urls = url.split("/");
+		List<String> newUrls = new ArrayList<>();
+		Collections.addAll(newUrls, urls);
+		return StringUtils.join(newUrls.subList(length, urls.length).toArray(), "/");
+	}
+
+//	public static void main(String[] args) throws Exception {
+//		String orgUri = "/HTT/CbsInNetSys/abcd/123456";
+//		String result = "";
+//		result = getExtUri(orgUri, 3);
+//		System.out.println(result);
+//	}
+}
@@ -0,0 +1,53 @@
+package com.eactive.eai.custom.adapter.http.util;
+
+import com.eactive.eai.util.TestModeChecker;
+
+import com.cubeone.CubeOneAPI;
+
+public class CubeOneCryptoUtil {
+	private static boolean testMode = TestModeChecker.isTestMode();
+
+	public static String encryptPI(String plainText) throws Exception {
+		// FIXME : kbank - kbank내애서는 testMode 체크 제거 검토
+		if (testMode) {
+			return plainText;
+		} else {
+			String encryptedText = null;
+			byte errbyte[] = new byte[5];
+			byte[] inbyte;
+			try {
+				inbyte = plainText.getBytes();
+				encryptedText = CubeOneAPI.coencbytes(inbyte, inbyte.length, "AES_PI", 11, null, null, errbyte);
+			} catch (UnsatisfiedLinkError e) {
+				throw new Exception("encryptPI error - ", e);
+			} catch (Exception e) {
+				throw new Exception("encryptPI error - ", e);
+			}
+			// 
+			
+			if (errbyte[0] != 48) {
+				throw new Exception("encryptPI error - " + new String(errbyte));
+			}
+			return encryptedText;
+		}
+	}
+
+	public static String decryptPI(String encryptedText) throws Exception {
+		// FIXME : kbank - kbank내애서는 testMode 체크 제거 검토
+		if (testMode) {
+			return encryptedText;
+		} else {
+			String decryptedText = null;
+			byte errbyte[] = new byte[5];
+			byte[] decbyte;
+			decbyte = CubeOneAPI.codecbyte(encryptedText, "AES_PI", 11, null, null, errbyte);
+			if (decbyte != null) {
+				decryptedText = new String(decbyte);
+			}
+			if (errbyte[0] != 48) {
+				throw new Exception("decryptPI error - " + new String(errbyte));
+			}
+			return decryptedText;
+		}
+	}
+}
@@ -0,0 +1,66 @@
+package com.eactive.eai.custom.adapter.http.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Base64;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+public class GzipBase64Util {
+	
+	private static final String DEFAULT_CAHRSET = "UTF-8";
+	
+	public static void main(String[] args) {
+		String originalString = "압축하고 인코딩할 문자열입니다.";
+
+		try {
+			String base64EncodedData = compress(originalString);
+
+			// System.out.println("Original String: " + originalString);
+			// System.out.println("Base64 Encoded String: " + base64EncodedData);
+
+			// Base64 디코딩 후 gzip 압축 해제
+			String decodedString = decompress(base64EncodedData);
+
+			// System.out.println("Decoded String: " + decodedString);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static String compress(String plainText) throws IOException {
+		if (plainText == null || plainText.isEmpty()) {
+			return null;
+		}
+
+		try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
+			try (GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream)) {
+				gzipOutputStream.write(plainText.getBytes(DEFAULT_CAHRSET));
+			}
+			byte[] compressedData = byteArrayOutputStream.toByteArray();
+			return Base64.getEncoder().encodeToString(compressedData);
+		}
+	}
+
+	public static String decompress(String base64EncodedData) throws IOException {
+
+		if (base64EncodedData == null || base64EncodedData.length() == 0) {
+			return null;
+		}
+		byte[] compressedData = Base64.getDecoder().decode(base64EncodedData);
+
+		try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
+			try (ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(compressedData);
+					GZIPInputStream gzipInputStream = new GZIPInputStream(byteArrayInputStream)) {
+
+				byte[] buffer = new byte[1024];
+				int len;
+				while ((len = gzipInputStream.read(buffer)) > 0) {
+					byteArrayOutputStream.write(buffer, 0, len);
+				}
+			}
+			return byteArrayOutputStream.toString(DEFAULT_CAHRSET);
+		}
+	}
+}
@@ -0,0 +1,29 @@
+package com.eactive.eai.custom.adapter.http.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.eactive.eai.util.CryptoUtil;
+import com.eactive.eai.util.json.transformer.ValueTransformer;
+
+public class ToAesTransformer implements ValueTransformer<String, String> {
+	public static final String AESKEY = "AESKEY";
+	public static final String PLAIN_VALUE = "PLAIN_VALUE";
+	private final Map<String, Object> properties = new HashMap<>();
+
+	@Override
+	public void setProperty(String propertyName, Object value) {
+		properties.put(propertyName, value);
+	}
+	@Override
+	public String getProperty(String propertyName) {
+		return (String)properties.get(propertyName);
+	}
+	@Override
+	public String transform(String value) throws Exception {
+		String apiKey = (String) properties.get(ToAesTransformer.AESKEY);
+		String text = CubeOneCryptoUtil.decryptPI(value);
+		properties.put(PLAIN_VALUE, text);
+		return CryptoUtil.encryptAES(apiKey, text);
+	}
+}
@@ -0,0 +1,30 @@
+package com.eactive.eai.custom.adapter.http.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.eactive.eai.util.CryptoUtil;
+import com.eactive.eai.util.json.transformer.ValueTransformer;
+
+public class ToCubeOneTransformer implements ValueTransformer<String, String> {
+	public static final String AESKEY = "AESKEY";
+	public static final String PLAIN_VALUE = "PLAIN_VALUE";
+	private final Map<String, Object> properties = new HashMap<>();
+
+	@Override
+	public void setProperty(String propertyName, Object value) {
+		properties.put(propertyName, value);
+	}
+	@Override
+	public String getProperty(String propertyName) {
+		return (String)properties.get(propertyName);
+	}
+	
+	@Override
+	public String transform(String value) throws Exception {
+		String apiKey = (String) properties.get(ToCubeOneTransformer.AESKEY);
+		String text = CryptoUtil.decryptAES(apiKey, value);
+		properties.put(PLAIN_VALUE, text);
+		return CubeOneCryptoUtil.encryptPI(text);
+	}
+}
@@ -0,0 +1,81 @@
+package com.eactive.eai.custom.adapter.http.util;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.eactive.eai.util.CryptoUtil;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+public class VirtualAccountBatchUtil {
+	private ObjectMapper mapper = new ObjectMapper();
+
+	public String getGzipValue(String jsonString, String path) {
+		try {
+			JsonNode rootNode = mapper.readTree(jsonString);
+			JsonNode childNode = rootNode.get(path);
+			String gzippedValue = childNode.asText();
+			return gzippedValue;
+		}
+		catch(Exception ex) {
+			ex.printStackTrace();
+			return null;
+		}
+	}
+	
+	// AZZ22-%d{yyyyMMdd}-%d{hhmmss}.enc -> AZZ22-20240924-093257.enc
+	public static String updateDatePattern(String patterm) {
+		String str[] = patterm.split("%d");
+		String converted = "";
+		for(int i=0; i<str.length; i++){
+			if(i<1){
+				converted = str[i];
+			}else{
+				String newMsg = "%d"+str[i];
+				Matcher matcher = Pattern.compile("%d\\{([a-zA-Z \\-]+)\\}").matcher(newMsg);
+				if (matcher.find()) {
+					String datePattern = matcher.group(1);
+					DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern(datePattern);
+					converted = converted + newMsg.replaceAll("%d\\{([a-zA-Z \\-]+)\\}", dateFormat.format(ZonedDateTime.now()));
+				}
+			}
+		}
+		return converted;
+	}
+	
+	// FIXME : kbank - 배치 파일명 생성 규칙에 따라 수정
+	public String unzipAndSave(String aesKey, String jsonString, String rootFilePath, String fileNamePattern) throws Exception {
+	    // gzippedValue 추출
+	    String gzippedValue = getGzipValue(jsonString, "encData");
+	    // System.out.println("gzippedValue[" + gzippedValue + "]");
+
+	    // 압축 해제
+	    String unziped = GzipBase64Util.decompress(gzippedValue);
+	    // AES 복호화
+	    String text = CryptoUtil.decryptAES(aesKey, unziped);
+	    
+	    // 현재 처리 시각을 기반으로 파일명 생성
+//	    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
+//	    String fileName = LocalDateTime.now().format(formatter) + ".txt";
+
+	    String fileName = updateDatePattern(fileNamePattern);
+	    // TODO : Add additional pattern logic
+	    
+	    String filePath = Paths.get(rootFilePath, fileName).toString();
+	    
+	    Files.write(Paths.get(filePath), text.getBytes(), StandardOpenOption.CREATE);
+
+	    // 결과 JSON 구성
+	    ObjectNode replacedJson = mapper.createObjectNode();
+	    replacedJson.put("filePath", filePath);
+	    replacedJson.put("fileName", fileName);
+	    return replacedJson.toString();
+	}
+}
@@ -0,0 +1,71 @@
+package com.eactive.eai.custom.adapter.http.util;
+
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.eactive.eai.common.util.Logger;
+import com.eactive.eai.util.json.JsonPathsTransform;
+import com.eactive.eai.util.json.transformer.ValueTransformer;
+
+public class VirtualAccountTransform {
+	protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+	
+	public static String toAES(String aesKey, List<String> encFieldPaths, String message) {
+		ToAesTransformer encTramsformer = new ToAesTransformer();
+		encTramsformer.setProperty("AESKEY", aesKey);
+
+		Map<String, ValueTransformer<String, String>> pathTransformerMap = new HashMap<>();
+		for (String path : encFieldPaths) {
+			pathTransformerMap.put(path.trim(), encTramsformer);
+		}
+		String modifiedJsonString = JsonPathsTransform.modifyValuesAtPaths(message, pathTransformerMap, false);
+
+		return modifiedJsonString;
+	}
+
+	public static byte[] toCubeOne(String aesKey, List<String> encFieldPaths, byte[] messageBytes) {
+		String defaultCharset = "utf-8";
+		try {
+			String message = new String(messageBytes, defaultCharset);
+			String retMessage = toCubeOne(aesKey, encFieldPaths, message);
+			return retMessage.getBytes(defaultCharset);
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+			return messageBytes;
+		}
+	}
+
+	public static String toCubeOne(String aesKey, List<String> encFieldPaths, String message) {
+		ToCubeOneTransformer encTramsformer = new ToCubeOneTransformer();
+		
+		if(logger.isDebug()) {
+			logger.debug("AESKEY=" + aesKey);
+		}
+		encTramsformer.setProperty("AESKEY", aesKey);
+
+		Map<String, ValueTransformer<String, String>> pathTransformerMap = new HashMap<>();
+		for (String path : encFieldPaths) {
+			pathTransformerMap.put(path.trim(), encTramsformer);
+		}
+		String modifiedJsonString = JsonPathsTransform.modifyValuesAtPaths(message, pathTransformerMap, false);
+
+		return modifiedJsonString;
+	}
+
+	public static void main(String[] args) {
+		String aesKey = "ONAuROzlqWB4VuBwO5C/FA==";
+		String text = "Hello AES 한글";
+		String encText = "3hQyg4xrUrFQt09XKLkmutQ4pZyuKc242LGQ1dyDMTg=";
+		String json = "{\"encAccount\":\"3hQyg4xrUrFQt09XKLkmutQ4pZyuKc242LGQ1dyDMTg=\"}";
+		List<String> list = new ArrayList<>();
+		list.add(" $.encAccount ");
+		list.add(" $.accounts$.encAccount ");
+		String cubeOneJson = toCubeOne(aesKey, list, json);
+		// System.out.println(cubeOneJson);
+		// System.out.println(toAES(aesKey, list, cubeOneJson));
+	}
+
+}
@@ -1,336 +0,0 @@
-
-package com.eactive.eai.custom.authoutbound.client.impl;
- 
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.security.KeyManagementException;
-import java.security.KeyStoreException;
-import java.security.NoSuchAlgorithmException;
-import java.security.UnrecoverableKeyException;
-import java.security.cert.CertificateException;
-import java.util.Date;
-import java.util.Properties;
-import java.util.concurrent.ConcurrentHashMap;
-
-import javax.net.ssl.SSLContext;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.hc.client5.http.classic.methods.HttpPost;
-import org.apache.hc.client5.http.config.RequestConfig;
-import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
-import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
-import org.apache.hc.client5.http.impl.classic.HttpClients;
-import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
-import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
-import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
-import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
-import org.apache.hc.client5.http.ssl.TrustAllStrategy;
-import org.apache.hc.core5.http.HttpEntity;
-import org.apache.hc.core5.http.HttpHost;
-import org.apache.hc.core5.http.io.entity.EntityUtils;
-import org.apache.hc.core5.ssl.SSLContextBuilder;
-import org.apache.hc.core5.util.Timeout;
-import org.springframework.security.web.util.UrlUtils;
-
-import com.eactive.eai.adapter.AdapterGroupVO;
-import com.eactive.eai.adapter.AdapterManager;
-import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
-import com.eactive.eai.adapter.http.secure.HttpClient5SSLContextFactory;
-import com.eactive.eai.authoutbound.OutboundOAuthCredentialVo;
-import com.eactive.eai.authoutbound.client.HttpClientAccessTokenServiceByDB;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.httpouttlsinfo.HttpOutTlsInfoManager;
-import com.eactive.eai.httpouttlsinfo.HttpOutTlsInfoVO;
-import com.eactive.eai.util.TestModeChecker;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.openbanking.eai.common.token.AccessTokenVO;
-import com.openbanking.eai.common.token.OAuth2AccessTokenVO;
-
-/**
- * 1. 기능 : HTTP 웹 컴포넌트를 POST 방식으로 호출할 수 있는 기능을 제공한다. 2. 처리 개요 : * - 2009.11.24
- * retry 로직 제거 : 요청 3. 주의사항
- *
- * @author :
- * @version : v 1.0.0
- * @see : WLIAdapterFactory.java, WLIAdapter.java, WLIDefaultAdapter.java
- * @since :
- * 
- */
-public class DJBErpNsmapiAccessTokenService implements HttpClientAccessTokenServiceByDB {
-
-	public static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
-
-	private static boolean testMode = TestModeChecker.isTestMode();
-
-	/**
-	 * mTLS 여부/clientId 조합별로 CloseableHttpClient(및 내부 PoolingHttpClientConnectionManager)를
-	 * 1회만 생성해 재사용한다. 이 서비스 인스턴스는 HttpClientAccessTokenServiceFactoryByDB에
-	 * className 기준으로 캐시되어 재사용되므로, 이 필드도 인스턴스 생명주기 동안 안전하게 재사용된다.
-	 */
-	private final ConcurrentHashMap<String, CloseableHttpClient> httpClientCache = new ConcurrentHashMap<>();
-
-	/**
-	 * 1. 기능 : 법인검증 토큰 발급에 사용 2. 처리 개요 : - 속성 정보를 설정 하고 토큰 발급 URL 호출 한다. 3. 주의사항
-	 *  - JSON 방식
-	 *  - ( Header	Authorization	Basic <base64_Encode(client_id:client_secret)> ) 으로 구성
-	 * @param adapterProp Http Adapter 속성 정보
-	 * @return 반환 된 AccessTokenVO
-	 * @exception Exception 수동 시스템 간 통신 중 발생
-	 **/
-	public AccessTokenVO execute(String name, Properties adapterProp, OutboundOAuthCredentialVo oAuthCredentialVo)
-			throws Exception {
-		AdapterGroupVO gvo = AdapterManager.getInstance().getAdapterGroupVO(name);
-		String adapterUrl = adapterProp.getProperty("URL");
-		String encode = gvo.getMessageEncode();
-		String timeoutTemp = adapterProp.getProperty("HTTP_TIME_OUT");
-		if (StringUtils.isBlank(timeoutTemp)) {
-			timeoutTemp = "30000";
-		}
-		String connectionTimeoutTemp = adapterProp.getProperty("CONNECTION_TIMEOUT");
-		if (StringUtils.isBlank(connectionTimeoutTemp)) {
-			connectionTimeoutTemp = "3000";
-		}
-
-		int timeout = Integer.parseInt(timeoutTemp);
-		int connectionTimeout = Integer.parseInt(connectionTimeoutTemp);
-		long currentTime = System.currentTimeMillis();
-
-		String uri = oAuthCredentialVo.getUrl();
-
-		if (!UrlUtils.isAbsoluteUrl(uri)) {
-			uri = appendPath(adapterUrl, uri);
-		}
-		String contentType = "application/json;";
-
-		Charset charset;
-		if (StringUtils.isNotBlank(encode)) {
-			charset = Charset.forName(encode);
-		} else {
-			charset = Charset.defaultCharset();
-			encode = charset.toString();
-		}
-
-		boolean useForwardProxy = StringUtils.equalsIgnoreCase(adapterProp.getProperty("FORWARD_PROXY_USE_YN"), "Y");
-		String forwardProxyUrl = adapterProp.getProperty("FORWARD_PROXY_URL");
-
-		logger.debug(
-				"uri:{}, charset:{}, transactionTimeout:{}, connectionTimeout:{}, useForwardProxy:{}, forwardProxyUrl:{}",
-				uri, encode, timeout, connectionTimeout, useForwardProxy, forwardProxyUrl);
-
-		
-		// mTLS config with default connection parameters
-		boolean useMtls = StringUtils.equalsIgnoreCase(adapterProp.getProperty(HttpClientAdapterServiceKey.USE_MTLS),
-				"Y");
-		AdapterGroupVO adapterGroup = AdapterManager.getInstance().getAdapterGroup(name);
-		String clientId = adapterGroup.getClientId();
-
-		if (logger.isInfo()) {
-			logger.info("adapterGroupName. : {}, useMtls. : {}, clientId : {}", name, useMtls, clientId);
-		}
-
-		// mTLS 여부(및 clientId)별로 CloseableHttpClient를 재사용한다. 매 호출마다 새로 만들면
-		// PoolingHttpClientConnectionManager를 쓰는 의미가 없어지고 SSL 핸드셰이크 비용만 반복된다.
-		String httpClientCacheKey = useMtls ? "mtls:" + clientId : "default";
-		CloseableHttpClient httpClient = httpClientCache.computeIfAbsent(httpClientCacheKey,
-				key -> buildHttpClient(useMtls, clientId, name));
-
-		//json body setting
-//		Map<String,Object> jsonMap = new HashMap<>();
-//		jsonMap.put("scope",oAuthCredentialVo.getScope());
-//		jsonMap.put("grant_type",oAuthCredentialVo.getGrantType());
-//		ObjectMapper objMapper = new ObjectMapper();
-//		String authJsonBody = objMapper.writeValueAsString(jsonMap);
-
-		{
-			HttpPost httpPost = new HttpPost(uri);
-//			httpPost.setEntity(new StringEntity(authJsonBody));
-			httpPost.setHeader("Content-Type", contentType+" charset=" + encode);
-
-			//HTTP HEADER에 client id, client secret를 base64Encode 한 후 추가
-//			String cId = oAuthCredentialVo.getClientId();
-//			String cSecret = oAuthCredentialVo.getClientSecret();
-//			String authValue = cId + ":" + cSecret;
-//			String encodedAuth = Base64.getEncoder().encodeToString(authValue.getBytes(StandardCharsets.UTF_8));
-			
-			String encodedAuth = oAuthCredentialVo.getClientId();
-			httpPost.setHeader("Authorization","Basic "+ encodedAuth);
-
-
-			RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
-
-			if (useForwardProxy) {
-				java.net.URL url = new java.net.URL(forwardProxyUrl);
-
-				// 프로토콜, 호스트, 포트 추출
-				String protocol = url.getProtocol();
-				String host = url.getHost();
-				int port = url.getPort();
-				HttpHost proxy = new HttpHost(protocol, host, port);
-				requestConfigBuilder.setProxy(proxy);
-			}
-
-			RequestConfig requestConfig = requestConfigBuilder
-					.setConnectTimeout(Timeout.ofMilliseconds(connectionTimeout))
-					.setResponseTimeout(Timeout.ofMilliseconds(timeout)).build();
-			httpPost.setConfig(requestConfig);
-
-			logger.debug("uri               = [" + uri + "]");
-			logger.debug("oauthClientId     = [" + oAuthCredentialVo.getClientId() + "]");
-			logger.debug("oauthClientSecret = [" + oAuthCredentialVo.getClientSecret() + "]");
-			logger.debug("oauthScope        = [" + oAuthCredentialVo.getScope() + "]");
-			logger.debug("oauthGrantType    = [" + oAuthCredentialVo.getGrantType() + "]");
-			logger.debug("oauthauthValue    = [" + encodedAuth + "]");
-			logger.debug("contentType       = [" + contentType + "]");
-			logger.debug("encode            = [" + encode + "]");
-
-			OAuth2AccessTokenVO accessToken = null;
-			try (CloseableHttpResponse response = httpClient.execute(httpPost)) {
-				if (response.getCode() != 200) {
-					throw new Exception("OAuth token receive status fail value= " + response.getCode());
-				}
-				
-				logger.info("DJBErpNsmapiAccessTokenService==>" + response.getCode());
-
-				HttpEntity entity = response.getEntity();
-				String responseString = EntityUtils.toString(entity, encode);
-				logger.debug("Base64Header oauthToken RECV = [" + responseString + "]");
-
-				if (StringUtils.isNotBlank(responseString)) {
-
-					ObjectMapper objectMapper = new ObjectMapper();
-					JsonNode responseJSON = objectMapper.readTree(responseString);
-					
-					if (responseJSON.has("data")) {
-						JsonNode data = responseJSON.path("data");
-						if(data.has("access_token")) {
-							String token = data.path("access_token").asText();
-							long intervalSec = oAuthCredentialVo.getIntervalSec() > 0
-									? oAuthCredentialVo.getIntervalSec()
-									: 24 * 60 * 60;
-							accessToken = new OAuth2AccessTokenVO();
-							accessToken.setAccessToken(token);
-							accessToken.setExpiration(new Date(currentTime + intervalSec * 1000L));
-							logger.debug("oauthToken =" + accessToken.toString());
-							return accessToken;
-						} else {
-							throw new Exception("oauth token return null");
-						}
-					} else {
-						throw new Exception("oauth token return null");
-					}
-				} else {
-					throw new Exception("oauth token return null");
-				}
-			} catch (Exception e) {
-				logger.error("[DJBErpNsmapiAccessTokenService] retrieve accessToken exception :" + e.getMessage(), e);
-				throw e;
-			}
-		}
-	}
-
-	/**
-	 * mTLS 여부/clientId 조합에 맞는 SSLContext로 PoolingHttpClientConnectionManager와
-	 * CloseableHttpClient를 생성한다. httpClientCache에 의해 조합당 1회만 호출되며, 반환된
-	 * CloseableHttpClient는 재사용을 위해 닫지 않는다(닫으면 커넥션 풀이 함께 종료된다).
-	 */
-	private CloseableHttpClient buildHttpClient(boolean useMtls, String clientId, String adapterGroupName) {
-		int maxTotalConnections = HttpClientAdapterServiceKey.DEFAULT_MAX_TOTAL_CONNECTIONS;
-		int maxHostConnections = HttpClientAdapterServiceKey.DEFAULT_MAX_CONNECTION_PER_HOST;
-
-		HttpOutTlsInfoVO mtlsInfo = null;
-		SSLContext sslContext = null;
-		PoolingHttpClientConnectionManagerBuilder cmBuilder = PoolingHttpClientConnectionManagerBuilder.create();
-
-		try {
-			if (useMtls) {
-				HttpOutTlsInfoManager tlsManager = HttpOutTlsInfoManager.getInstance();
-				if (StringUtils.isNotEmpty(clientId)) {
-					mtlsInfo = tlsManager.getHttpOutTlsInfo(clientId);
-				}
-			}
-
-			if (useMtls && mtlsInfo != null) {
-				String storeType = mtlsInfo.getStoreType();
-				String keyStoreInfo = mtlsInfo.getKeystoreInfo();
-				String keyStorePassword = mtlsInfo.getKeystorePassword();
-				String trustStoreInfo = mtlsInfo.getTruststoreInfo();
-				String trustStorePassword = mtlsInfo.getTruststorePassword();
-
-				String[] tlsVersions = null;
-				String[] cipherSuites = null;
-
-				if (StringUtils.isAnyEmpty(keyStoreInfo, keyStorePassword)) {
-					throw new Exception("mTLS keyStore config error");
-				}
-
-				boolean skipTrust = false;
-				if (StringUtils.isAnyEmpty(trustStoreInfo, trustStorePassword)) {
-					if (logger.isWarn())
-						logger.warn("Skip trustStore validation adapterGroupName : " + adapterGroupName);
-					skipTrust = true;
-				}
-
-				sslContext = HttpClient5SSLContextFactory.createMTLSContextFromContent(storeType, keyStoreInfo,
-						keyStorePassword, trustStoreInfo, trustStorePassword, skipTrust, tlsVersions, cipherSuites);
-
-				SSLConnectionSocketFactory sslSocketFactory = null;
-				if (testMode) {
-					sslSocketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
-				} else {
-					sslSocketFactory = new SSLConnectionSocketFactory(sslContext);
-				}
-				cmBuilder.setSSLSocketFactory(sslSocketFactory);
-			} else {
-				sslContext = SSLContextBuilder.create().loadTrustMaterial(new TrustAllStrategy()).build();
-				SSLConnectionSocketFactory sslSocketFactory = null;
-		        if(testMode) {
-		        	// Hostname verifier 비활성화 (테스트용)
-					sslSocketFactory = new SSLConnectionSocketFactory(
-					    sslContext
-					    , NoopHostnameVerifier.INSTANCE
-					);
-		        }
-		        else {
-		        	sslSocketFactory = new SSLConnectionSocketFactory(
-						    sslContext
-						);
-		        }
-		        cmBuilder.setSSLSocketFactory(sslSocketFactory);
-			}
-		} catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | CertificateException
-				| IOException | UnrecoverableKeyException e) {
-			throw new RuntimeException(e);
-		} catch (Exception e) {
-			throw new RuntimeException(e);
-		}
-
-		PoolingHttpClientConnectionManager connectionManager = cmBuilder.build();
-		connectionManager.setMaxTotal(maxTotalConnections);
-		connectionManager.setDefaultMaxPerRoute(maxHostConnections);
-
-		if (logger.isInfo()) {
-			logger.info("DJBErpNsmapiAccessTokenService] HttpClient(재사용) 생성. adapterGroupName={}, useMtls={}, clientId={}",
-					adapterGroupName, useMtls, clientId);
-		}
-
-		return HttpClients.custom().setConnectionManager(connectionManager).build();
-	}
-
-	/**
-	 * URL에 경로를 추가합니다. 중복되는 슬래시를 방지합니다.
-	 *
-	 * @param baseUrl   기본 URL
-	 * @param pathToAdd 추가할 경로
-	 * @return 완성된 URL 문자열
-	 */
-	public static String appendPath(String baseUrl, String pathToAdd) {
-		if (!baseUrl.endsWith("/") && !pathToAdd.startsWith("/")) {
-			return baseUrl + "/" + pathToAdd;
-		} else if (baseUrl.endsWith("/") && pathToAdd.startsWith("/")) {
-			return baseUrl + pathToAdd.substring(1);
-		} else {
-			return baseUrl + pathToAdd;
-		}
-	}
-}
@@ -1,58 +0,0 @@
-package com.eactive.eai.custom.common.security.keyderiv;
-
-import java.nio.charset.StandardCharsets;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.Map;
-
-import com.eactive.eai.common.security.keyderiv.DerivedKey;
-import com.eactive.eai.common.security.keyderiv.strategy.BaseHsmKeyDerivationStrategy;
-
-/**
- * HSM 마스터키 + 런타임 컨텍스트값을 연결(concatenate)한 뒤 SHA-256 해싱으로 키를 도출하는 전략.
- * SHA-256 출력은 항상 32바이트(AES-256)이므로 별도 keyLength 파라미터가 불필요하다.
- *
- * key_deriv_params (JSON) 예시:
- * {
- *   "hsmKeyAlias" : "MASTER_KEY_AES",
- *   "contextKey"  : "X-Api-Group-Seq"  -- runtimeContext에서 꺼낼 키 이름
- * }
- */
-public class HsmContextSha256KeyDerivationStrategy extends BaseHsmKeyDerivationStrategy {
-
-	@Override
-	public DerivedKey deriveKey(Map<String, String> params, Map<String, String> runtimeContext) throws Exception {
-		byte[] masterKeyBytes = super.getHsmKey(params);
-		
-		return deriveKey(params, runtimeContext, masterKeyBytes);
-	}
-
-	public DerivedKey deriveKey(Map<String, String> params, Map<String, String> runtimeContext, byte[] masterKeyBytes)
-			throws NoSuchAlgorithmException {
-		String contextKey  = required(params, PARAM_CONTEXT_KEY);
-		byte[] contextBytes   = runtimeContext.getOrDefault(contextKey, "")
-				.getBytes(StandardCharsets.UTF_8);
-
-		byte[] combined = new byte[masterKeyBytes.length + contextBytes.length];
-		System.arraycopy(masterKeyBytes, 0, combined, 0, masterKeyBytes.length);
-		System.arraycopy(contextBytes,  0, combined, masterKeyBytes.length, contextBytes.length);
-
-		byte[] derived = MessageDigest.getInstance("SHA-256").digest(combined);
-		return new DerivedKey(derived, derived);
-	}
-
-	@Override
-	public String buildCacheKey(String cryptoName, Map<String, String> params, Map<String, String> runtimeContext) {
-		String contextKey   = params.getOrDefault(PARAM_CONTEXT_KEY, "");
-		String contextValue = runtimeContext.getOrDefault(contextKey, "");
-		return cryptoName + ":" + contextValue;
-	}
-
-	private String required(Map<String, String> params, String key) {
-		String value = params.get(key);
-		if (value == null || value.trim().isEmpty()) {
-			throw new IllegalArgumentException("key_deriv_params 필수값 누락: " + key);
-		}
-		return value;
-	}
-}
@@ -1,45 +0,0 @@
-package com.eactive.eai.custom.common.security.keyderiv;
-
-import java.util.Map;
-
-import javax.xml.bind.DatatypeConverter;
-
-import com.eactive.eai.common.security.keyderiv.DerivedKey;
-import com.eactive.eai.common.security.keyderiv.strategy.BaseHsmKeyDerivationStrategy;
-
-/**
- * HSM에서 키와 IV를 각각 가져오는 전략.
- * IV는 HSM에서 가져온 바이트 배열을 hex 문자열로 변환한 뒤 substring(32, 64)를 적용하여 사용한다.
- * (32바이트 HSM 키 → 64자 hex → substring(32,64) → 16바이트 IV)
- *
- * key_deriv_params (JSON) 예시:
- * { "hsmKeyAlias" : "MASTER_KEY_AES", "hsmIvAlias" : "MASTER_IV_AES" }
- */
-public class HsmKeyAndIvSliceDerivationStrategy extends BaseHsmKeyDerivationStrategy {
-
-    private static final int IV_HEX_OFFSET = 32;
-    private static final int IV_HEX_END    = 64;
-
-    @Override
-    public DerivedKey deriveKey(Map<String, String> params, Map<String, String> runtimeContext) throws Exception {
-        byte[] keyBytes = super.getHsmKey(params);
-        byte[] rawIv    = super.getHsmIv(params);
-        return deriveKey(keyBytes, rawIv);
-    }
-
-	public DerivedKey deriveKey(byte[] keyBytes, byte[] rawIv) {
-		String ivHex    = DatatypeConverter.printHexBinary(rawIv);
-        if (ivHex.length() < IV_HEX_END) {
-            throw new IllegalArgumentException(
-                    "hsmIvAlias hex 길이 부족: 최소 " + IV_HEX_END + "자 필요, 실제=" + ivHex.length()
-                    + " (" + rawIv.length + "바이트)");
-        }
-        byte[] iv = DatatypeConverter.parseHexBinary(ivHex.substring(IV_HEX_OFFSET, IV_HEX_END));
-        return new DerivedKey(keyBytes, keyBytes, iv);
-	}
-
-    @Override
-    public String buildCacheKey(String cryptoName, Map<String, String> params, Map<String, String> runtimeContext) {
-        return cryptoName;
-    }
-}
@@ -1,104 +0,0 @@
-package com.eactive.eai.custom.inbound.action;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.apache.commons.lang3.StringUtils;
-
-import com.eactive.eai.adapter.AdapterGroupVO;
-import com.eactive.eai.adapter.AdapterManager;
-import com.eactive.eai.adapter.Keys;
-import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
-import com.eactive.eai.adapter.http.dynamic.impl.HttpAdapterServiceRest;
-import com.eactive.eai.common.exception.ExceptionUtil;
-import com.eactive.eai.common.stdmessage.STDMessageManager;
-import com.eactive.eai.common.util.MessageKeyExtractor;
-import com.eactive.eai.inbound.action.ActionException;
-import com.eactive.eai.inbound.action.RequestActionSupport;
-
-public class RestAdapterMethodUrlFallbackRequestAction extends RequestActionSupport {
-
-    /**
-     * 1. 기능 : Inbound Adapter를 통해 전달받은 비표준메시지에서 표준메시지를 생성하기 위한 키값을 추출
-     * 2. 처리 개요 :
-     *     - TYPE_HTTP_CUSTOM / TYPE_REST: 전체 URI로 키를 먼저 조회하고,
-     *       없으면 뒤 경로를 하나씩 제거하면서 일치하는 키를 탐색한다.
-     *     - 그 외: MessageKeyExtractor를 통해 추출
-     *
-     * @param message Object 타입의 요청메시지
-     * @return String 비표준메시지의 메시지키값
-     **/
-    public String[] perform(Object message) throws ActionException {
-        String[] key = null;
-
-        AdapterManager adapterManager = AdapterManager.getInstance();
-        AdapterGroupVO adptGrpVO = adapterManager.getAdapterGroupVO(adapterGroupName);
-        String adptGrpName = adptGrpVO.getName();
-
-        if (StringUtils.equals(adptGrpVO.getType(), Keys.TYPE_HTTP_CUSTOM)
-                || StringUtils.equals(adptGrpVO.getType(), Keys.TYPE_REST)) {
-            try {
-                String requestMethod = prop
-                        .getProperty(HttpAdapterServiceRest.PROPERTIES_NAME_HTTP_REQUEST_METHOD);
-
-                // /api/v1/public/getUserInfo.svc
-                String inboundUri = prop.getProperty(HttpAdapterServiceKey.INBOUND_EXTURI);
-                String apiPath = prop.getProperty(HttpAdapterServiceKey.API_PATH);
-
-                // /getUserInfo.svc
-                String apiUri = org.apache.commons.lang.StringUtils.removeStart(inboundUri, apiPath);
-
-                Set<String> allKeys = new HashSet<>(Arrays.asList(
-                        STDMessageManager.getInstance().getAllSTDMessageKeys()));
-
-                // 전체 URI부터 시작해서 뒤 경로를 하나씩 제거하며 일치하는 키를 탐색
-                String searchUri = apiUri;
-                for (int i = 0; i < 10; i++) {
-                    String candidateKey = adptGrpName + ":" + requestMethod + "|"
-                            + StringUtils.removeStart(searchUri, "/");
-                    if (allKeys.contains(candidateKey)) {
-                        return new String[] { candidateKey };
-                    }
-                    String shortened = StringUtils.substringBeforeLast(searchUri, "/");
-                    if (StringUtils.isBlank(shortened)) {
-                        break;
-                    }
-                    searchUri = shortened;
-                }
-
-                // 일치하는 키가 없으면 원래 키로 fallback
-                String apiKey = adptGrpName + ":" + requestMethod + "|"
-                        + StringUtils.removeStart(apiUri, "/");
-                return new String[] { apiKey };
-
-            } catch (Exception e) {
-                throw new ActionException(ExceptionUtil.getErrorCode(e, "RECEAIIRA001"));
-            }
-        }
-
-        if (message instanceof byte[]) {
-            try {
-                key = MessageKeyExtractor.getMessageKeyValueForRest(this.adapterGroupName, message, prop, "url", true);
-            } catch (Exception e) {
-                throw new ActionException(ExceptionUtil.getErrorCode(e, "RECEAIIRA001"));
-            }
-            if (logger.isDebug())
-                logger.debug(adapterName + "] received data >> [" + new String((byte[]) message) + "]");
-        } else {
-            try {
-                key = MessageKeyExtractor.getMessageKeyValueForRest(this.adapterGroupName, message, prop, "url", true);
-            } catch (Exception e) {
-                throw new ActionException(ExceptionUtil.getErrorCode(e, "RECEAIIRA001"));
-            }
-            if (logger.isDebug())
-                logger.debug(adapterName + "] received data >> [" + message + "]");
-        }
-
-        for (int i = 0; i < key.length; i++) {
-            key[i] = adptGrpName.trim() + key[i];
-        }
-
-        return key;
-    }
-}
@@ -1,169 +0,0 @@
-package com.eactive.eai.custom.inbound.processor;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Properties;
-import java.util.Set;
-
-import org.apache.commons.lang3.StringUtils;
-
-import com.eactive.eai.common.inflow.Bucket;
-import com.eactive.eai.common.inflow.InflowTargetVO;
-import com.eactive.eai.common.inflow.dual.DualBucket;
-import com.eactive.eai.common.inflow.dual.DualCustomBucket;
-import com.eactive.eai.common.message.EAIMessage;
-import com.eactive.eai.common.property.PropManager;
-import com.eactive.eai.common.util.Logger;
-import com.eactive.eai.custom.inflow.ClientDualBucket;
-import com.eactive.eai.inbound.processor.ProcessVO;
-import com.eactive.eai.inbound.processor.RequestProcessor;
-import com.eactive.eai.message.StandardItem;
-import com.eactive.eai.message.StandardMessage;
-
-/**
- * 어댑터/인터페이스/클라이언트 유량제어 차단 시 어느 버킷(PER_SECOND/THRESHOLD)에서
- * 차단됐는지 에러 메시지에 포함하는 RequestProcessor 확장.
- *
- * <p>ClientDualInflowControlManager와 함께 사용:
- * <pre>
- * inflow.control.bucket.className=com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager
- * </pre>
- *
- * <p>Spring Bean 등록 후 기존 RequestProcessor 대신 이 클래스를 어댑터에 설정한다.
- */
-public class DJBRequestProcessor extends RequestProcessor {
-	
-	static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
-	
-	@Override
-	protected void afterFoundEaiMessage(EAIMessage eaiMsg, ProcessVO vo, Properties prop) {
-		logger.debug("DJBRequestProcessor interface found.");
-		try {
-			this.resolveStandardHeaderMapping(eaiMsg, prop);
-		} catch (Exception e) {
-			logger.warn("DJBRequestProcessor header set failed.", e);
-		}
-	}
-	
-	private void resolveStandardHeaderMapping(EAIMessage eaiMsg, Properties prop) {
-		StandardMessage standardMessage = eaiMsg.getStandardMessage();
-		HashMap<String, String> headerMapping = getPropertyMap("DJB_IN_HTTHEAD_STDHEAD_MAPPING", eaiMsg.getSngSysItfTp());
-
-		for (Entry<String, String> entry : headerMapping.entrySet()) {
-			String stdHeaderPath = entry.getKey();
-			int dotIdx = stdHeaderPath.indexOf('.');
-			if(dotIdx > 0) {
-				String firstPath = stdHeaderPath.substring(0, dotIdx);
-				StandardItem topLevelItem = standardMessage.findItem(firstPath);
-				topLevelItem.setHidden(false);
-			}
-			StandardItem item = standardMessage.findItem(entry.getKey());
-
-			String value = resolveNestedValue(prop, entry.getValue());
-			if (item != null && value != null)
-				item.setValue(value);
-			else
-				logger.debug("header mapping item not found : {} ", entry);
-		}
-	}
-
-	private HashMap<String, String> getPropertyMap(String propertyGroupName, String prefix) {
-		Properties prop = PropManager.getInstance().getProperties(propertyGroupName);
-		Set<String> keys = prop.stringPropertyNames();
-		HashMap<String, String> tmpToJsonArrayInterface = new HashMap<>();
-		for (String key : keys) {
-			if (StringUtils.startsWith(key, prefix + ".")) {
-				String propValue = prop.getProperty(key);
-				String replacedKey = StringUtils.replace(key, prefix + ".", "");
-				tmpToJsonArrayInterface.put(replacedKey, propValue);
-			}
-		}
-		return tmpToJsonArrayInterface;
-	}
-
-	private String resolveNestedValue(Map<?, ?> map, String keyPath) {
-		int dotIdx = keyPath.indexOf('.');
-		if (dotIdx < 0) {
-			Object val = map.get(keyPath);
-			if (val == null)
-				return null;
-			if (val instanceof String)
-				return (String) val;
-			return val.toString();
-		}
-
-		String first = keyPath.substring(0, dotIdx);
-		String rest = keyPath.substring(dotIdx + 1);
-		Object val = map.get(first);
-		if (val instanceof Map) {
-			return resolveNestedValue((Map<?, ?>) val, rest);
-		}
-
-		// 폴백: 전체 keyPath를 단일 키로 조회
-		Object direct = map.get(keyPath);
-		if (direct == null)
-			return null;
-		if (direct instanceof String)
-			return (String) direct;
-		return direct.toString();
-	}
-
-    @Override
-    protected String checkCustomInflow(Bucket bucket, EAIMessage eaiMsg, Properties prop) {
-        String clientId = eaiMsg.getClientId();
-        if (StringUtils.isBlank(clientId)) return null;
-        if (bucket instanceof ClientDualBucket) {
-            return ((ClientDualBucket) bucket).isClientPassDetail(clientId);
-        }
-        return null;
-    }
-
-    @Override
-    protected InflowTargetVO resolveCustomInflowThreshold(Bucket bucket, EAIMessage eaiMsg, Properties prop) {
-        if (bucket instanceof ClientDualBucket) {
-            return ((ClientDualBucket) bucket).getClientInflowThreshold(eaiMsg.getClientId());
-        }
-        return null;
-    }
-
-    @Override
-    protected String checkAdapterInflow(Bucket bucket, String adapterGroupName) {
-        if (bucket instanceof DualBucket) {
-            return ((DualBucket) bucket).isAdapterPassDetail(adapterGroupName);
-        }
-        return super.checkAdapterInflow(bucket, adapterGroupName);
-    }
-
-    @Override
-    protected String checkInterfaceInflow(Bucket bucket, String eaiSvcCd) {
-        if (bucket instanceof DualBucket) {
-            return ((DualBucket) bucket).isInterfacePassDetail(eaiSvcCd);
-        }
-        return super.checkInterfaceInflow(bucket, eaiSvcCd);
-    }
-
-    /**
-     * 차단 원인에 따라 에러 메시지에 한도 정보를 포함.
-     * <ul>
-     *   <li>PER_SECOND: "API 호출 한도 초과 [name: Nreq/sec]"</li>
-     *   <li>THRESHOLD:  "API 호출 한도 초과 [name: Nreq/UNIT]"</li>
-     *   <li>그 외:      "API 호출 한도 초과 [name]" (기존 동작)</li>
-     * </ul>
-     */
-    @Override
-    protected String buildInflowTargetErrorMsg(InflowTargetVO inflowTargetVO, String blockedType) {
-        if (DualCustomBucket.RESULT_BLOCKED_PER_SECOND.equals(blockedType)) {
-            return String.format("API 호출 한도 초과 [%s: %dreq/sec]",
-                    inflowTargetVO.getName(),
-                    inflowTargetVO.getThresholdPerSecond());
-        }
-        if (DualCustomBucket.RESULT_BLOCKED_THRESHOLD.equals(blockedType)) {
-            return String.format("API 호출 한도 초과 [%s: %dreq/%s]",
-                    inflowTargetVO.getName(),
-                    inflowTargetVO.getThreshold(),
-                    inflowTargetVO.getThresholdTimeUnit());
-        }
-        return super.buildInflowTargetErrorMsg(inflowTargetVO, blockedType);
-    }
-}
@@ -1,23 +0,0 @@
-package com.eactive.eai.custom.inflow;
-
-import com.eactive.eai.common.inflow.InflowTargetVO;
-import com.eactive.eai.common.inflow.dual.DualBucket;
-
-/**
- * DualBucket에 클라이언트 유량제어 메서드를 추가한 인터페이스.
- * {@link ClientDualInflowControlManager}가 구현한다.
- */
-public interface ClientDualBucket extends DualBucket {
-
-    /**
-     * 클라이언트 유량제어 체크 — 차단 원인 포함.
-     * @return null이면 통과, "PER_SECOND" 또는 "THRESHOLD"이면 해당 버킷에서 차단
-     */
-    String isClientPassDetail(String clientId);
-
-    /**
-     * 클라이언트 유량제어 설정 조회 — 에러 메시지 생성용.
-     * @return 등록된 설정이 없으면 null
-     */
-    InflowTargetVO getClientInflowThreshold(String clientId);
-}
@@ -1,114 +0,0 @@
-package com.eactive.eai.custom.inflow;
-
-import java.util.Collections;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.springframework.stereotype.Component;
-
-import com.eactive.eai.common.inflow.Bucket;
-import com.eactive.eai.common.inflow.InflowTargetVO;
-import com.eactive.eai.common.inflow.InflowType;
-import com.eactive.eai.common.inflow.dual.DualCustomBucket;
-import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
-import com.eactive.eai.common.lifecycle.LifecycleException;
-import com.eactive.eai.common.util.ApplicationContextProvider;
-import com.eactive.eai.common.util.Logger;
-
-/**
- * 어댑터/인터페이스 이중 버킷(DualInflowControlManager)에 클라이언트 유량제어를 추가한 관리자.
- *
- * <p>적용 방법: INFLOW.properties에 아래 한 줄 추가.
- * <pre>inflow.control.bucket.className=com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager</pre>
- */
-@Component
-public class ClientDualInflowControlManager extends DualInflowControlManager implements ClientDualBucket {
-
-    private static final Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
-
-    public static synchronized Bucket getBucket() {
-        return ApplicationContextProvider.getContext().getBean(ClientDualInflowControlManager.class);
-    }
-
-    private volatile Map<String, DualCustomBucket> clientBucketMap = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<String, TargetMetrics> clientMetricsMap = new ConcurrentHashMap<>();
-
-    // -------------------------------------------------------------------------
-    // Lifecycle
-    // -------------------------------------------------------------------------
-
-    @Override
-    public void start() throws LifecycleException {
-        super.start();
-        try {
-            initClients();
-        } catch (Exception e) {
-            throw new LifecycleException("ClientDualInflowControlManager init failed: " + e.getMessage());
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // 초기화 / 리로드
-    // -------------------------------------------------------------------------
-
-    private void initClients() throws Exception {
-        this.clientBucketMap = loadBucketMap(InflowType.CLIENT);
-        if (logger.isInfo()) logger.info("ClientDualInflowControlManager] initClients: " + clientBucketMap.size() + " buckets");
-    }
-
-    public synchronized void reloadClient() throws Exception {
-        initClients();
-        clientMetricsMap.clear();
-    }
-
-    public synchronized void reloadClient(String clientId) throws Exception {
-        reloadBucketMap(clientBucketMap, InflowType.CLIENT, clientId);
-        TargetMetrics m = clientMetricsMap.get(clientId);
-        if (m != null) m.reset();
-    }
-
-    public synchronized void removeClient(String clientId) {
-        clientBucketMap.remove(clientId);
-        clientMetricsMap.remove(clientId);
-    }
-
-    // -------------------------------------------------------------------------
-    // 클라이언트 메트릭 접근자
-    // -------------------------------------------------------------------------
-
-    public TargetMetrics getClientMetrics(String clientId)    { return clientMetricsMap.get(clientId); }
-    public Map<String, TargetMetrics> getAllClientMetrics()    { return Collections.unmodifiableMap(clientMetricsMap); }
-    public void resetClientMetrics(String clientId)           { TargetMetrics m = clientMetricsMap.get(clientId); if (m != null) m.reset(); }
-    public void resetAllClientMetrics()                       { clientMetricsMap.values().forEach(TargetMetrics::reset); }
-
-    // -------------------------------------------------------------------------
-    // ClientDualBucket — 클라이언트 유량제어
-    // -------------------------------------------------------------------------
-
-    @Override
-    public String isClientPassDetail(String clientId) {
-        DualCustomBucket b = clientBucketMap.get(clientId);
-        if (b == null) return DualCustomBucket.RESULT_PASS;
-        String result = b.tryConsume();
-        recordMetrics(clientMetricsMap, clientId, result);
-        return result;
-    }
-
-    @Override
-    public InflowTargetVO getClientInflowThreshold(String clientId) {
-        DualCustomBucket b = clientBucketMap.get(clientId);
-        return (b == null) ? null : b.getInflowTargetVo();
-    }
-
-    // -------------------------------------------------------------------------
-    // 모니터링용 접근자
-    // -------------------------------------------------------------------------
-
-    public DualCustomBucket getClientBucket(String clientId) {
-        return clientBucketMap.get(clientId);
-    }
-
-    public Map<String, DualCustomBucket> getClientBucketMap() {
-        return clientBucketMap;
-    }
-}
@@ -1,63 +0,0 @@
-package com.eactive.eai.custom.inflow;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
-
-/**
- * 클라이언트 버킷 상태 모니터링 API.
- *
- * ClientDualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
- *
- * GET /manage/inflow/client/bucket-status             → 전체 클라이언트 버킷 상태
- * GET /manage/inflow/client/{clientId}/bucket-status  → 특정 클라이언트 버킷 상태
- */
-@RestController
-@RequestMapping("/manage/inflow")
-public class ClientInflowTargetBucketController {
-
-    @Autowired
-    private ClientInflowTargetBucketService bucketService;
-
-    @GetMapping("/client/bucket-status")
-    public ResponseEntity<?> getAllClientBucketStatus() {
-        List<TargetBucketStatusDTO> list = bucketService.getAllClientBucketStatus();
-        return ok(list);
-    }
-
-    @GetMapping("/client/{clientId}/bucket-status")
-    public ResponseEntity<?> getClientBucketStatus(@PathVariable String clientId) {
-        TargetBucketStatusDTO dto = bucketService.getClientBucketStatus(clientId);
-        return single(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
-    }
-
-    private ResponseEntity<?> ok(List<TargetBucketStatusDTO> list) {
-        Map<String, Object> result = new HashMap<>();
-        result.put("success", true);
-        result.put("data", list);
-        result.put("count", list.size());
-        return ResponseEntity.ok(result);
-    }
-
-    private ResponseEntity<?> single(TargetBucketStatusDTO dto, String notFoundMsg) {
-        if (dto == null) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", notFoundMsg);
-            return ResponseEntity.ok(error);
-        }
-        Map<String, Object> result = new HashMap<>();
-        result.put("success", true);
-        result.put("data", dto);
-        return ResponseEntity.ok(result);
-    }
-}
@@ -1,78 +0,0 @@
-package com.eactive.eai.custom.inflow;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import org.springframework.stereotype.Service;
-
-import com.eactive.eai.common.inflow.AbstractInflowControlManager;
-import com.eactive.eai.common.inflow.InflowControlUtil;
-import com.eactive.eai.common.inflow.InflowTargetVO;
-import com.eactive.eai.common.inflow.dual.DualCustomBucket;
-import com.eactive.eai.manage.inflow.GroupBucketStatusDTO;
-import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
-
-/**
- * 클라이언트 버킷 상태 조회 서비스.
- *
- * ClientDualInflowControlManager 가 활성화된 경우에만 동작한다.
- */
-@Service
-public class ClientInflowTargetBucketService {
-
-    public TargetBucketStatusDTO getClientBucketStatus(String clientId) {
-        ClientDualInflowControlManager manager = getClientDualManager();
-        if (manager == null) return null;
-        DualCustomBucket bucket = manager.getClientBucket(clientId);
-        if (bucket == null) return null;
-        return toDto(clientId, "CLIENT", bucket);
-    }
-
-    public List<TargetBucketStatusDTO> getAllClientBucketStatus() {
-        ClientDualInflowControlManager manager = getClientDualManager();
-        if (manager == null) return new ArrayList<>();
-        return toDtoList("CLIENT", manager.getClientBucketMap());
-    }
-
-    protected ClientDualInflowControlManager getClientDualManager() {
-        AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
-        return (base instanceof ClientDualInflowControlManager) ? (ClientDualInflowControlManager) base : null;
-    }
-
-    private TargetBucketStatusDTO toDto(String targetId, String targetType, DualCustomBucket bucket) {
-        InflowTargetVO vo = bucket.getInflowTargetVo();
-        List<GroupBucketStatusDTO.BucketInfo> buckets = new ArrayList<>();
-
-        if (vo.getThresholdPerSecond() > 0) {
-            long capacity  = vo.getThresholdPerSecond();
-            long available = bucket.getPerSecondAvailableTokens();
-            if (available < 0) available = capacity;
-            buckets.add(new GroupBucketStatusDTO.BucketInfo(
-                    "perSecond", capacity, Math.min(available, capacity), "SEC"));
-        }
-
-        if (vo.getThreshold() > 0) {
-            long capacity  = vo.getThreshold();
-            long available = bucket.getThresholdAvailableTokens();
-            if (available < 0) available = capacity;
-            buckets.add(new GroupBucketStatusDTO.BucketInfo(
-                    "threshold", capacity, Math.min(available, capacity), vo.getThresholdTimeUnit()));
-        }
-
-        TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
-        dto.setTargetId(targetId);
-        dto.setTargetType(targetType);
-        dto.setActivate(vo.isActivate());
-        dto.setBuckets(buckets);
-        return dto;
-    }
-
-    private List<TargetBucketStatusDTO> toDtoList(String targetType, Map<String, DualCustomBucket> bucketMap) {
-        List<TargetBucketStatusDTO> result = new ArrayList<>();
-        for (Map.Entry<String, DualCustomBucket> entry : bucketMap.entrySet()) {
-            result.add(toDto(entry.getKey(), targetType, entry.getValue()));
-        }
-        return result;
-    }
-}
@@ -1,94 +0,0 @@
-package com.eactive.eai.custom.inflow;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import com.eactive.eai.manage.inflow.TargetMetricDTO;
-
-/**
- * 클라이언트 유량제어 메트릭 API.
- *
- * ClientDualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
- *
- * GET  /manage/inflow/client/metric                       → 전체 클라이언트 메트릭
- * GET  /manage/inflow/client/{clientId}/metric            → 특정 클라이언트 메트릭
- * POST /manage/inflow/client/metric/reset                 → 전체 클라이언트 메트릭 초기화
- * POST /manage/inflow/client/{clientId}/metric/reset      → 특정 클라이언트 메트릭 초기화
- */
-@RestController
-@RequestMapping("/manage/inflow")
-public class ClientInflowTargetMetricController {
-
-    @Autowired
-    private ClientInflowTargetMetricService metricService;
-
-    @GetMapping("/client/metric")
-    public ResponseEntity<?> getAllClientMetrics() {
-        List<TargetMetricDTO> list = metricService.getAllClientMetrics();
-        return okList(list);
-    }
-
-    @GetMapping("/client/{clientId}/metric")
-    public ResponseEntity<?> getClientMetric(@PathVariable String clientId) {
-        TargetMetricDTO dto = metricService.getClientMetric(clientId);
-        return okSingle(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
-    }
-
-    @PostMapping("/client/metric/reset")
-    public ResponseEntity<?> resetAllClientMetrics() {
-        metricService.resetAllClientMetrics();
-        return okReset("전체 클라이언트 메트릭 초기화 완료");
-    }
-
-    @PostMapping("/client/{clientId}/metric/reset")
-    public ResponseEntity<?> resetClientMetric(@PathVariable String clientId) {
-        boolean ok = metricService.resetClientMetric(clientId);
-        return okResetSingle(ok, clientId, "클라이언트");
-    }
-
-    private ResponseEntity<?> okList(List<TargetMetricDTO> list) {
-        Map<String, Object> result = new HashMap<>();
-        result.put("success", true);
-        result.put("data", list);
-        result.put("count", list.size());
-        return ResponseEntity.ok(result);
-    }
-
-    private ResponseEntity<?> okSingle(TargetMetricDTO dto, String notFoundMsg) {
-        if (dto == null) {
-            Map<String, Object> error = new HashMap<>();
-            error.put("success", false);
-            error.put("message", notFoundMsg);
-            return ResponseEntity.ok(error);
-        }
-        Map<String, Object> result = new HashMap<>();
-        result.put("success", true);
-        result.put("data", dto);
-        return ResponseEntity.ok(result);
-    }
-
-    private ResponseEntity<?> okReset(String message) {
-        Map<String, Object> result = new HashMap<>();
-        result.put("success", true);
-        result.put("message", message);
-        return ResponseEntity.ok(result);
-    }
-
-    private ResponseEntity<?> okResetSingle(boolean ok, String targetId, String targetLabel) {
-        Map<String, Object> result = new HashMap<>();
-        result.put("success", ok);
-        result.put("message", ok
-            ? "초기화 완료: " + targetId
-            : targetLabel + "를 찾을 수 없습니다: " + targetId);
-        return ResponseEntity.ok(result);
-    }
-}
@@ -1,78 +0,0 @@
-package com.eactive.eai.custom.inflow;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.springframework.stereotype.Service;
-
-import com.eactive.eai.common.inflow.AbstractInflowControlManager;
-import com.eactive.eai.common.inflow.InflowControlUtil;
-import com.eactive.eai.common.inflow.InflowTargetVO;
-import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
-import com.eactive.eai.manage.inflow.TargetMetricDTO;
-
-@Service
-public class ClientInflowTargetMetricService {
-
-    public TargetMetricDTO getClientMetric(String clientId) {
-        ClientDualInflowControlManager manager = getClientDualManager();
-        if (manager == null) return null;
-        InflowTargetVO vo = manager.getClientInflowThreshold(clientId);
-        if (vo == null) return null;
-        return buildDTO(clientId, "CLIENT", vo, manager.getClientMetrics(clientId));
-    }
-
-    public List<TargetMetricDTO> getAllClientMetrics() {
-        ClientDualInflowControlManager manager = getClientDualManager();
-        if (manager == null) return new ArrayList<>();
-        List<TargetMetricDTO> result = new ArrayList<>();
-        for (String id : manager.getClientBucketMap().keySet()) {
-            TargetMetricDTO dto = getClientMetric(id);
-            if (dto != null) result.add(dto);
-        }
-        return result;
-    }
-
-    public boolean resetClientMetric(String clientId) {
-        ClientDualInflowControlManager manager = getClientDualManager();
-        if (manager == null) return false;
-        if (manager.getClientInflowThreshold(clientId) == null) return false;
-        manager.resetClientMetrics(clientId);
-        return true;
-    }
-
-    public void resetAllClientMetrics() {
-        ClientDualInflowControlManager manager = getClientDualManager();
-        if (manager != null) manager.resetAllClientMetrics();
-    }
-
-    protected ClientDualInflowControlManager getClientDualManager() {
-        AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
-        return (base instanceof ClientDualInflowControlManager) ? (ClientDualInflowControlManager) base : null;
-    }
-
-    private TargetMetricDTO buildDTO(String targetId, String targetType,
-                                     InflowTargetVO vo,
-                                     DualInflowControlManager.TargetMetrics m) {
-        TargetMetricDTO dto = new TargetMetricDTO();
-        dto.setTargetId(targetId);
-        dto.setTargetType(targetType);
-        dto.setActivate(vo.isActivate());
-
-        if (m != null) {
-            long allowed = m.allowed.get();
-            long rejPs   = m.rejectedPerSecond.get();
-            long rejTh   = m.rejectedThreshold.get();
-            long total   = allowed + rejPs + rejTh;
-            dto.setAllowed(allowed);
-            dto.setRejectedPerSecond(rejPs);
-            dto.setRejectedThreshold(rejTh);
-            dto.setTotalRequests(total);
-            dto.setRejectRatio(total > 0
-                ? Math.round((double)(rejPs + rejTh) / total * 10000) / 100.0
-                : 0.0);
-            dto.setLastResetTime(m.lastResetTime);
-        }
-        return dto;
-    }
-}
@@ -0,0 +1,123 @@
+package com.eactive.eai.custom.kjb.adapter.http.client.filter;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
+import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
+import com.eactive.eai.common.TransactionContextKeys;
+import com.eactive.eai.common.property.PropManager;
+import com.eactive.eai.common.util.Logger;
+
+public class AllHeaderFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
+	protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
+	
+	public static final String PROPERTIES_GROUP_NAME = "HttpHeaderFilter";
+	public static final String HEADER_KEY_NAMES = "AllHeaderFilter.blackList";
+
+
+	String[] HttpHeaderRelayBlackList = {
+			"Content-Length",
+			"Transfer-Encoding",
+			"Host",
+			"Authorization",
+			"Accept",
+			"Host",
+			"Cookie",
+			"Connection",
+			"Keep-Alive",
+			"Proxy-Authenticate",
+			"Proxy-Authorization",
+			"TE",
+			"Trailer",
+			"Transfer-Encoding",
+			"Upgrade",
+			"Content-Type",
+			"Content-Encoding",
+			"Content-Language",
+			"Content-Location",
+			"Content-MD5",
+			"Expect",
+	};
+	
+	@Override
+	public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
+			throws Exception {
+
+		logger.debug("doPreFilter Processing Start.");
+
+		Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
+		if (filterHeaders == null) {
+			filterHeaders = new Properties();
+			tempProp.put("FILTERHEADER", filterHeaders);
+		}
+		
+		Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
+		
+		String propValue = PropManager.getInstance().getProperty(PROPERTIES_GROUP_NAME, HEADER_KEY_NAMES, "").trim();
+		
+		String[] userSettingBlackList = propValue.split(",");
+		
+		if( userSettingBlackList.length > 0 ) {
+			HttpHeaderRelayBlackList = Stream
+			        .concat(Arrays.stream(HttpHeaderRelayBlackList), Arrays.stream(userSettingBlackList))
+			        .toArray(String[]::new);
+		}
+		
+		
+		for(String keyName : inboundHeaderMap.keySet() ) {
+			
+			if( StringUtils.equalsAnyIgnoreCase( keyName, HttpHeaderRelayBlackList ) ) {
+				logger.debug("Skip Processing Key ["+keyName+"], value ["+inboundHeaderMap.get(keyName)+"] in HttpHeaderRelayBlackList");
+				continue;
+			}
+			
+			filterHeaders.put(keyName, inboundHeaderMap.get(keyName));
+			logger.debug("Processing Key ["+keyName+"], value ["+inboundHeaderMap.get(keyName)+"]");
+		}
+		
+		logger.debug("doPreFilter Processing End.");
+		
+		return message;
+	}
+	
+	public Map<String, String> getInboundHeaderProp(Properties prop) {
+		Properties header = new Properties();
+		Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+		try {
+			Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
+			if (headerObj instanceof Properties) {    //tomcat
+				header = (Properties) headerObj;
+				for (String name : header.stringPropertyNames()) {
+					inboundHeaderMap.put(name, header.getProperty(name));
+				}
+			} else if (headerObj instanceof String) {  //weblogic
+				String str = (String) headerObj;
+				str = str.substring(1, str.length() - 1);
+				// key=value 쌍 분리
+				String[] entries = str.split(",");
+				for (String entry : entries) {
+				    String[] kv = entry.split("=", 2);
+				    if (kv.length == 2) {
+				    	inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
+				    }
+				}
+			}	
+		} catch (Exception  e) {
+		    e.printStackTrace();
+		}
+		return inboundHeaderMap;
+	}
+
+	@Override
+	public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
+			Properties tempProp) throws Exception {
+		return message;
+	}
+
+}
--- a/Show More
+++ b/Show More