비밀번호 전송 암호화 기능 추가:

- RSA-OAEP + AES-GCM 기반 비밀번호 전송 암호화 모듈 구현
- 클라이언트 공개키 발급 및 복호화 처리 로직 개발
- 암호화 설정 속성 및 요청별/세션별/서버별 키 보관소 구성

CLAUDE.md

@@ -185,8 +185,9 @@ com.eactive.apim.portal/
 
 설정: `config/PortalDatasourceConfiguration.java`
 - 각 데이터베이스별 별도 EntityManager
-- Atomikos JTA를 통한 분산 트랜잭션
+- **JTA/XA 미사용**. EntityManagerFactory 별 로컬 트랜잭션 (`config/PortalConfigTransaction.java`)
-- 트랜잭션 로그: `/Log/eapim/portal/`
+  - `transactionManager` (@Primary) → EMS
+  - `gatewayTransactionManager` → Gateway
 
 ### 설정 프로파일
 
@@ -359,7 +360,13 @@ return queryFactory.selectFrom(user)
 적절한 propagation과 함께 `@Transactional` 사용:
 - 기본값: `REQUIRED` (기존 트랜잭션에 참여하거나 새로 생성)
 - 읽기 전용 작업: 최적화를 위해 `@Transactional(readOnly = true)`
-- 다중 데이터베이스: Atomikos JTA가 자동으로 분산 트랜잭션 처리
+- **다중 데이터베이스: 분산 트랜잭션(JTA/XA) 없음.** EMS·Gateway 각각 독립 로컬 트랜잭션이다.
+  - 무지정 `@Transactional` = EMS(`transactionManager`)
+  - **Gateway 엔티티(`com.eactive.apim.gateway.*`, `com.eactive.eai.data.entity.onl.*`)를 다루는 서비스는
+    `@Transactional("gatewayTransactionManager")` 를 명시**한다. 안 하면 게이트웨이 EntityManager 가
+    리포지토리 호출 단위로 닫혀 지연 로딩에서 `LazyInitializationException` 이 난다
+    (예: `ApiServiceService` — `ApiGroup.apiGroupApiList`).
+  - 두 DB 를 한 원자 단위로 묶어야 하는 작업은 만들지 않는다. 현재 Gateway 는 조회 전용이다.
 
 ### 에러 처리
 

Jenkinsfile.security

@@ -0,0 +1,501 @@
+// 보안 검사 통합 파이프라인 — OWASP Dependency-Check(SCA) + SonarQube(SAST).
+//
+// 두 검사는 보는 대상이 다르다. 하나만 돌리면 절반만 본다.
+//   SonarQube          : 우리가 쓴 코드의 결함 (SQL Injection, XSS, 하드코딩 시크릿 …)
+//   Dependency-Check   : 우리가 쓰는 라이브러리의 알려진 취약점 (CVE)
+//
+// 전제 (Jenkins 쪽 설정 이름이 다르면 environment 블록만 고치면 된다)
+//   1) Manage Jenkins > System > SonarQube servers 에 서버 등록 (이름: SONAR_ENV_NAME)
+//   2) Manage Jenkins > Tools > SonarQube Scanner 에 스캐너 등록 (없으면 PATH 탐색)
+//   3) 노드에 Dependency-Check CLI 설치 (DC_HOME) — 설치 방법은 17-보안 가이드 문서 참고
+//   4) NVD API Key 를 Secret text credential 로 등록 (기본 ID: nvd-api-key)
+//      키가 없으면 NVD 갱신이 극심하게 느려진다(수 시간). 폐쇄망은 UPDATE_NVD=false 로 운영.
+//   5) Quality Gate 대기를 쓰려면 SonarQube 에 <JENKINS_URL>/sonarqube-webhook/ 웹훅 등록
+//
+// JDK 분리: 빌드는 JDK 8, 스캐너/Dependency-Check 실행은 JDK 17.
+// (SonarScanner CLI 5.x 는 JRE 17 필수, Dependency-Check 9.x 이상은 JRE 11 이상 필수)
+pipeline {
+  agent { label 'djb-vm' }
+
+  triggers {
+    // 코드 변경 감지
+    pollSCM('H/30 * * * *')
+    // 코드가 그대로여도 새 CVE 는 계속 공개된다 → 야간 정기 재검사
+    cron('H 3 * * *')
+  }
+
+  options {
+    timestamps()
+    disableConcurrentBuilds()
+    buildDiscarder(logRotator(numToKeepStr: '20'))
+  }
+
+  parameters {
+    booleanParam(
+      name: 'RUN_DEPENDENCY_CHECK',
+      defaultValue: true,
+      description: 'OWASP Dependency-Check(SCA) 실행'
+    )
+    booleanParam(
+      name: 'RUN_SONAR',
+      defaultValue: true,
+      description: 'SonarQube 정적 분석(SAST) 실행'
+    )
+    booleanParam(
+      name: 'RUN_TESTS',
+      defaultValue: false,
+      description: '단위 테스트를 함께 실행해 JUnit 결과를 Sonar 로 전송한다(분석 시간 증가).'
+    )
+    booleanParam(
+      name: 'UPDATE_NVD',
+      defaultValue: true,
+      description: 'NVD 취약점 DB 갱신. 폐쇄망(외부 인터넷 불가)이면 반드시 끈다 — 캐시된 DB 로만 검사한다.'
+    )
+    string(
+      name: 'FAIL_ON_CVSS',
+      defaultValue: '11',
+      description: '이 CVSS 점수 이상이면 검사 실패로 표시. 11 = 실패시키지 않음(리포트만). 예: 7 = High 이상'
+    )
+    booleanParam(
+      name: 'FAIL_BUILD_ON_FINDING',
+      defaultValue: false,
+      description: 'FAIL_ON_CVSS 위반 시 빌드를 FAILURE 로 만든다. 끄면 UNSTABLE 로만 표시.'
+    )
+    booleanParam(
+      name: 'SCAN_JS',
+      defaultValue: true,
+      description: '정적 JS 라이브러리(static/js, static/plugins)도 RetireJS 로 검사. 폐쇄망에서 오류나면 끈다.'
+    )
+  }
+
+  environment {
+    // --- Jenkins 설정 이름 (환경에 맞게 수정) ---
+    SONAR_ENV_NAME     = 'SonarQube-Community'
+    SONAR_SCANNER_TOOL = ''
+    // NVD API Key 를 담은 Secret text credential ID. 없으면 키 없이 진행한다(느림).
+    NVD_API_KEY_CRED   = 'nvd-api-key'
+
+    // --- 툴체인 ---
+    JAVA_HOME         = '/apps/opts/jdk8'    // gradle 컴파일용 (프로젝트는 Java 8)
+    JAVA_HOME_SCANNER = '/apps/opts/jdk17'   // sonar-scanner / dependency-check 실행용
+    GRADLE_HOME       = '/apps/opts/gradle-8.7'
+    GRADLE_USER_HOME  = '/apps/opts/gradle-home'
+    PATH = "/apps/opts/jdk8/bin:/apps/opts/gradle-8.7/bin:/apps/opts/bin:${env.PATH}"
+    GIT_SSH_COMMAND = 'ssh -o StrictHostKeyChecking=accept-new'
+
+    // --- Dependency-Check ---
+    // CLI 설치 경로. 비어 있거나 없으면 Jenkins Tools 등록분 > PATH 순으로 탐색한다.
+    DC_HOME = '/apps/opts/dependency-check'
+    // NVD 캐시(H2 DB). 워크스페이스 밖에 두어야 빌드마다 1GB 이상을 다시 받지 않는다.
+    // 여러 Job 이 공유하므로 disableConcurrentBuilds 를 켠 채로 쓴다.
+    DC_DATA = '/apps/opts/dependency-check-data'
+    DC_TOOL_NAME = ''
+    DC_REPORT_DIR = 'build/reports/dependency-check'
+  }
+
+  stages {
+    stage('Checkout') {
+      steps {
+        checkout scm
+      }
+    }
+
+    // eapim-portal 은 elink-portal-common / elink-online-core-jpa 를 subproject 로 참조한다.
+    // 이 둘이 없으면 컴파일도 의존성 해석도 불가능하다.
+    stage('Checkout dependencies') {
+      steps {
+        sh '''
+          set -eu
+          cd "$WORKSPACE/.."
+
+          if [ ! -d elink-portal-common/.git ]; then
+            rm -rf elink-portal-common
+            git clone --depth=1 --branch master \
+              ssh://git@172.30.1.50:2222/djb-eapim/elink-portal-common.git \
+              elink-portal-common
+          else
+            git -C elink-portal-common fetch --depth=1 origin master
+            git -C elink-portal-common reset --hard origin/master
+            git -C elink-portal-common clean -fdx
+          fi
+
+          mkdir -p eapim-online
+          if [ ! -d eapim-online/elink-online-core-jpa/.git ]; then
+            rm -rf eapim-online/elink-online-core-jpa
+            git clone --depth=1 --branch master \
+              ssh://git@172.30.1.50:2222/djb-eapim/elink-online-core-jpa.git \
+              eapim-online/elink-online-core-jpa
+          else
+            git -C eapim-online/elink-online-core-jpa fetch --depth=1 origin master
+            git -C eapim-online/elink-online-core-jpa reset --hard origin/master
+            git -C eapim-online/elink-online-core-jpa clean -fdx
+          fi
+        '''
+      }
+    }
+
+    stage('Verify toolchain') {
+      steps {
+        sh '''
+          set -eu
+          echo "--- build JDK ---"
+          java -version
+          gradle --version
+
+          echo "--- scanner/dependency-check JDK ---"
+          if [ ! -x "$JAVA_HOME_SCANNER/bin/java" ]; then
+            echo "JDK 17 이 없다: $JAVA_HOME_SCANNER"
+            echo "SonarScanner 는 JRE 17, Dependency-Check 는 JRE 11 이상을 요구한다."
+            exit 1
+          fi
+          "$JAVA_HOME_SCANNER/bin/java" -version
+        '''
+      }
+    }
+
+    // build/generated 잔여 산출물이 남으면 MapStruct Impl / QueryDSL Q클래스가
+    // 중복 생성되어 컴파일이 깨진다. clean 이 파일 잠금 등으로 실패하는 경우가 있어
+    // 생성 소스 디렉터리는 별도로 먼저 지운다.
+    stage('Compile') {
+      steps {
+        sh '''
+          set -eu
+          rm -rf build/generated build/classes
+          gradle clean classes testClasses --no-daemon
+        '''
+      }
+    }
+
+    stage('Test') {
+      when { expression { return params.RUN_TESTS } }
+      steps {
+        sh 'gradle test --no-daemon'
+      }
+      post {
+        always {
+          junit allowEmptyResults: true, testResults: 'build/test-results/test/*.xml'
+        }
+      }
+    }
+
+    // 배포본에 실리는 것과 같은 목록(runtimeClasspath)만 모은다.
+    // 이게 없으면 Dependency-Check 가 스캔할 jar 가 없어 "취약점 0건" 이라는 거짓 안심을 준다.
+    stage('Export dependency jars') {
+      when { expression { return params.RUN_DEPENDENCY_CHECK } }
+      steps {
+        sh 'gradle -I ci/dependency-check-classpath.gradle exportDependencyJars --no-daemon'
+        sh '''
+          set -eu
+          COUNT=$(find build/dependency-check/libs -name '*.jar' -type f | wc -l | tr -d ' ')
+          echo "scan target jars: $COUNT"
+          if [ "$COUNT" -eq 0 ]; then
+            echo "수집된 jar 가 0개다. 의존성 해석이 실패했는지 확인할 것."
+            exit 1
+          fi
+        '''
+      }
+    }
+
+    stage('OWASP Dependency-Check') {
+      when { expression { return params.RUN_DEPENDENCY_CHECK } }
+      steps {
+        script {
+          // CLI 위치 결정: DC_HOME > Jenkins Tools 등록분 > PATH
+          def dcHome = null
+          if (env.DC_HOME?.trim() && fileExists("${env.DC_HOME}/bin/dependency-check.sh")) {
+            dcHome = env.DC_HOME.trim()
+            echo "Dependency-Check: ${dcHome} (DC_HOME)"
+          } else {
+            def candidates = env.DC_TOOL_NAME?.trim()
+              ? [env.DC_TOOL_NAME.trim()]
+              : ['dependency-check', 'Dependency-Check', 'OWASP Dependency-Check', 'dependency-check-cli']
+            for (name in candidates) {
+              try {
+                dcHome = tool name: name,
+                  type: 'org.jenkinsci.plugins.DependencyCheck.tools.DependencyCheckInstallation'
+                echo "Dependency-Check tool: '${name}' -> ${dcHome}"
+                break
+              } catch (ignored) {
+                // 등록되지 않은 이름은 건너뛴다
+              }
+            }
+            if (dcHome == null) {
+              echo 'Jenkins Tools 에 등록된 Dependency-Check 가 없다. PATH 의 dependency-check.sh 로 진행한다.'
+            }
+          }
+
+          // NVD API Key credential 이 있는지 먼저 확인한다.
+          // (없는 credential 로 withCredentials 를 감싸면 파이프라인 자체가 죽는다)
+          def hasNvdKey = true
+          try {
+            withCredentials([string(credentialsId: env.NVD_API_KEY_CRED, variable: 'NVD_PROBE')]) {
+              // 존재 확인만 한다
+            }
+          } catch (ignored) {
+            hasNvdKey = false
+          }
+
+          if (!hasNvdKey) {
+            echo "NVD API Key credential('${env.NVD_API_KEY_CRED}') 이 없다. 키 없이 진행한다."
+            echo 'NVD 갱신이 매우 느려진다(수 시간). https://nvd.nist.gov/developers/request-an-api-key 에서 발급 권장.'
+          }
+
+          def dcScript = '''
+            set -eu
+
+            # Dependency-Check 는 JRE 11 이상 필요 (빌드용 JDK 8 과 분리)
+            export JAVA_HOME="$JAVA_HOME_SCANNER"
+            export PATH="$JAVA_HOME/bin:$PATH"
+
+            mkdir -p "$DC_DATA" "$DC_REPORT_DIR"
+
+            if [ -n "${DC_RESOLVED_HOME:-}" ] && [ -x "$DC_RESOLVED_HOME/bin/dependency-check.sh" ]; then
+              DC="$DC_RESOLVED_HOME/bin/dependency-check.sh"
+            elif command -v dependency-check.sh >/dev/null 2>&1; then
+              DC="$(command -v dependency-check.sh)"
+            else
+              echo "dependency-check.sh 를 찾지 못했다."
+              echo "노드에 CLI 를 설치하고 DC_HOME 을 맞추거나, Manage Jenkins > Tools 에 등록할 것."
+              exit 1
+            fi
+            echo "dependency-check: $DC"
+
+            ARGS=""
+
+            # 폐쇄망/오프라인: 캐시된 NVD DB 로만 검사한다.
+            if [ "${UPDATE_NVD_FLAG}" != "true" ]; then
+              ARGS="$ARGS --noupdate"
+              if [ ! -d "$DC_DATA" ] || [ -z "$(ls -A "$DC_DATA" 2>/dev/null)" ]; then
+                echo "NVD 캐시가 비어 있는데 갱신이 꺼져 있다: $DC_DATA"
+                echo "인터넷 되는 곳에서 1회 적재한 data 디렉터리를 복사해 둘 것."
+                exit 1
+              fi
+            fi
+
+            if [ -n "${NVD_API_KEY:-}" ]; then
+              ARGS="$ARGS --nvdApiKey ${NVD_API_KEY}"
+            fi
+
+            # OSS Index 분석기는 외부 서비스(ossindex.sonatype.org)를 호출한다.
+            # 갱신을 끈 환경(=외부 통신 불가)에서는 같이 끈다.
+            if [ "${UPDATE_NVD_FLAG}" != "true" ]; then
+              ARGS="$ARGS --disableOssIndex"
+            fi
+
+            # 자바 프로젝트에 불필요한 분석기 — 실행 시간만 늘린다.
+            ARGS="$ARGS --disableAssembly --disableNodeAudit --disableNodeJS"
+
+            SCAN_ARGS="--scan build/dependency-check/libs"
+            if [ "${SCAN_JS_FLAG}" = "true" ]; then
+              # 번들된 JS 라이브러리(jQuery, summernote 등)의 알려진 취약점 — RetireJS
+              [ -d src/main/resources/static/js ] && SCAN_ARGS="$SCAN_ARGS --scan src/main/resources/static/js"
+              [ -d src/main/resources/static/plugins ] && SCAN_ARGS="$SCAN_ARGS --scan src/main/resources/static/plugins"
+            else
+              ARGS="$ARGS --disableRetireJS"
+            fi
+
+            SUPPRESSION=""
+            if [ -f ci/dependency-check-suppressions.xml ]; then
+              SUPPRESSION="--suppression ci/dependency-check-suppressions.xml"
+            fi
+
+            # 토큰/키가 콘솔에 남지 않도록 실행 명령 자체는 출력하지 않는다.
+            set +x
+            "$DC" \
+              --project "DJB eAPIM Portal" \
+              $SCAN_ARGS \
+              --out "$DC_REPORT_DIR" \
+              --format HTML --format XML --format JSON \
+              --data "$DC_DATA" \
+              --failOnCVSS "${FAIL_ON_CVSS_VALUE}" \
+              $SUPPRESSION \
+              $ARGS
+          '''
+
+          def dcEnv = [
+            "DC_RESOLVED_HOME=${dcHome ?: ''}",
+            "UPDATE_NVD_FLAG=${params.UPDATE_NVD}",
+            "SCAN_JS_FLAG=${params.SCAN_JS}",
+            "FAIL_ON_CVSS_VALUE=${params.FAIL_ON_CVSS}"
+          ]
+
+          // 정책: 기본은 UNSTABLE 로만 표시하고 뒤의 Sonar 분석까지 마친다.
+          // FAIL_BUILD_ON_FINDING 을 켜면 임계치 위반이 빌드 실패가 된다.
+          def onFinding = params.FAIL_BUILD_ON_FINDING ? 'FAILURE' : 'UNSTABLE'
+          catchError(buildResult: onFinding, stageResult: 'FAILURE') {
+            withEnv(dcEnv) {
+              if (hasNvdKey) {
+                withCredentials([string(credentialsId: env.NVD_API_KEY_CRED, variable: 'NVD_API_KEY')]) {
+                  sh dcScript
+                }
+              } else {
+                sh dcScript
+              }
+            }
+          }
+        }
+      }
+      post {
+        always {
+          archiveArtifacts allowEmptyArchive: true,
+            artifacts: 'build/reports/dependency-check/dependency-check-report.*'
+          script {
+            // OWASP Dependency-Check 플러그인이 설치돼 있으면 추이 그래프/경고를 남긴다.
+            // 없어도 리포트는 위에서 아카이브되므로 실패로 보지 않는다.
+            try {
+              dependencyCheckPublisher pattern: 'build/reports/dependency-check/dependency-check-report.xml'
+            } catch (ignored) {
+              echo 'OWASP Dependency-Check 플러그인 미설치 — 아카이브된 HTML 리포트로 확인할 것.'
+            }
+          }
+        }
+      }
+    }
+
+    // sonar.java.libraries 용 클래스패스 덤프.
+    // 없으면 타입 해석이 안 돼 보안 룰 다수가 침묵하므로 실패 시 UNSTABLE 로만 넘기고 분석은 계속한다.
+    stage('Export analysis classpath') {
+      when { expression { return params.RUN_SONAR } }
+      steps {
+        catchError(buildResult: 'UNSTABLE', stageResult: 'FAILURE') {
+          sh 'gradle -I ci/sonar-classpath.gradle exportSonarClasspath --no-daemon'
+        }
+      }
+    }
+
+    stage('SonarQube analysis') {
+      when { expression { return params.RUN_SONAR } }
+      steps {
+        script {
+          // 스캐너 위치 결정: 지정 이름 > 흔한 등록 이름 후보 > PATH 의 sonar-scanner
+          def candidates = env.SONAR_SCANNER_TOOL?.trim()
+            ? [env.SONAR_SCANNER_TOOL.trim()]
+            : ['SonarScanner', 'SonarQube Scanner', 'sonar-scanner', 'SonarScanner CLI', 'sonarqube-scanner']
+
+          def scannerHome = null
+          for (name in candidates) {
+            try {
+              scannerHome = tool name: name, type: 'hudson.plugins.sonar.SonarRunnerInstallation'
+              echo "SonarScanner tool: '${name}' -> ${scannerHome}"
+              break
+            } catch (ignored) {
+              // 등록되지 않은 이름은 건너뛴다
+            }
+          }
+
+          if (scannerHome == null) {
+            echo 'Jenkins Tools 에 등록된 SonarQube Scanner 를 찾지 못했다. PATH 의 sonar-scanner 로 진행한다.'
+            echo '(Manage Jenkins > Tools 에 등록한 뒤 environment 의 SONAR_SCANNER_TOOL 에 그 이름을 넣으면 확실하다.)'
+          }
+
+          withSonarQubeEnv(env.SONAR_ENV_NAME) {
+            withEnv(["SONAR_SCANNER_HOME=${scannerHome ?: ''}"]) {
+              sh '''
+                set -eu
+
+                # 스캐너는 JDK 17 로 실행한다 (빌드용 JDK 8 과 분리)
+                export JAVA_HOME="$JAVA_HOME_SCANNER"
+                export PATH="$JAVA_HOME/bin:$PATH"
+
+                # 토큰은 커맨드라인(-Dsonar.token)에 노출시키지 않고 환경변수로만 넘긴다.
+                if [ -z "${SONAR_TOKEN:-}" ] && [ -n "${SONAR_AUTH_TOKEN:-}" ]; then
+                  export SONAR_TOKEN="$SONAR_AUTH_TOKEN"
+                fi
+
+                LIBS=""
+                if [ -f build/sonar/java-libraries.txt ]; then
+                  LIBS=$(cat build/sonar/java-libraries.txt)
+                else
+                  echo "WARN: build/sonar/java-libraries.txt 없음 - 타입 해석 정확도 저하"
+                fi
+
+                TEST_LIBS=""
+                if [ -f build/sonar/java-test-libraries.txt ]; then
+                  TEST_LIBS=$(cat build/sonar/java-test-libraries.txt)
+                fi
+
+                JUNIT_ARG=""
+                if [ -d build/test-results/test ]; then
+                  JUNIT_ARG="-Dsonar.junit.reportPaths=build/test-results/test"
+                fi
+
+                # SonarQube 에 Dependency-Check 플러그인이 설치돼 있으면 CVE 결과도 함께 올린다.
+                # 플러그인이 없으면 스캐너가 모르는 속성으로 무시한다(경고만).
+                DC_ARG=""
+                if [ -f "$DC_REPORT_DIR/dependency-check-report.json" ]; then
+                  DC_ARG="-Dsonar.dependencyCheck.jsonReportPath=$DC_REPORT_DIR/dependency-check-report.json"
+                  if [ -f "$DC_REPORT_DIR/dependency-check-report.html" ]; then
+                    DC_ARG="$DC_ARG -Dsonar.dependencyCheck.htmlReportPath=$DC_REPORT_DIR/dependency-check-report.html"
+                  fi
+                fi
+
+                if [ -n "${SONAR_SCANNER_HOME:-}" ] && [ -x "$SONAR_SCANNER_HOME/bin/sonar-scanner" ]; then
+                  SCANNER="$SONAR_SCANNER_HOME/bin/sonar-scanner"
+                elif command -v sonar-scanner >/dev/null 2>&1; then
+                  SCANNER="$(command -v sonar-scanner)"
+                else
+                  echo "sonar-scanner 실행 파일을 찾지 못했다."
+                  echo "Manage Jenkins > Tools > SonarQube Scanner 에 등록하거나 노드 PATH 에 설치할 것."
+                  exit 1
+                fi
+                echo "scanner: $SCANNER"
+
+                "$SCANNER" \
+                  -Dsonar.projectVersion="${BUILD_NUMBER}" \
+                  -Dsonar.java.libraries="$LIBS" \
+                  -Dsonar.java.test.libraries="$TEST_LIBS" \
+                  $JUNIT_ARG \
+                  $DC_ARG
+              '''
+            }
+          }
+        }
+      }
+    }
+
+    // SonarQube 웹훅으로 게이트 결과를 받아 판정한다.
+    // 정책: 게이트 실패는 UNSTABLE 로만 표시하고 빌드는 실패시키지 않는다.
+    stage('Quality Gate') {
+      when { expression { return params.RUN_SONAR } }
+      steps {
+        script {
+          def qg = null
+          try {
+            timeout(time: 15, unit: 'MINUTES') {
+              qg = waitForQualityGate abortPipeline: false
+            }
+          } catch (err) {
+            unstable("Quality Gate 결과 대기 실패/타임아웃: ${err}")
+            return
+          }
+
+          if (qg == null) {
+            unstable('Quality Gate 결과를 받지 못했다. SonarQube 웹훅 설정을 확인할 것.')
+          } else if (qg.status != 'OK') {
+            unstable("Quality Gate ${qg.status}")
+          } else {
+            echo 'Quality Gate OK'
+          }
+        }
+      }
+    }
+  }
+
+  post {
+    always {
+      archiveArtifacts allowEmptyArchive: true, artifacts: '.scannerwork/report-task.txt'
+      script {
+        def report = '.scannerwork/report-task.txt'
+        if (fileExists(report)) {
+          def url = readFile(report).readLines().find { it.startsWith('dashboardUrl=') }
+          if (url) {
+            echo "SonarQube: ${url.substring('dashboardUrl='.length())}"
+          }
+        }
+        if (fileExists('build/reports/dependency-check/dependency-check-report.html')) {
+          echo "Dependency-Check 리포트: ${env.BUILD_URL}artifact/build/reports/dependency-check/dependency-check-report.html"
+        }
+      }
+    }
+  }
+}

build.gradle

@@ -60,7 +60,6 @@ dependencies {
 //    implementation project(':kjb-safedb')
 
     implementation('org.springframework.boot:spring-boot-starter')
-    implementation 'org.springframework.boot:spring-boot-starter-jta-atomikos'
     implementation('org.springframework.boot:spring-boot-starter-web')
     implementation('org.springframework.boot:spring-boot-starter-validation')
 
@@ -84,7 +83,10 @@ dependencies {
     implementation group: 'com.fasterxml.woodstox', name: 'woodstox-core', version: '6.5.1'
 
 
-    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
+    // Thymeleaf 3.1 코어가 #temporals 를 내장 제공 → java8time extras 를 함께 두면 표현식 객체가 중복 등록된다.
+    implementation('org.springframework.boot:spring-boot-starter-thymeleaf') {
+        exclude group: 'org.thymeleaf.extras', module: 'thymeleaf-extras-java8time'
+    }
     implementation 'org.springframework.boot:spring-boot-starter-security'
     implementation('org.springframework.boot:spring-boot-starter-cache')
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
@@ -92,33 +94,48 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-jdbc'
 
     developmentOnly  'org.springframework.boot:spring-boot-devtools'
-    implementation 'org.springframework:spring-expression:5.3.30'
+    // spring-expression 개별 pin 제거: 아래 ext 의 spring-framework.version 이 전 모듈을 일괄 관리한다.
+    // 개별 pin 이 남아 있으면 다른 spring-* 모듈보다 낮은 버전으로 고정되어 버전이 어긋난다.
 
     implementation group: 'xalan', name: 'xalan', version: '2.7.3'
 
     implementation 'org.hibernate:hibernate-envers:5.6.15.Final'
-    implementation 'nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect:3.0.0'
+    implementation 'nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect:3.4.0'  // 3.0.0 은 thymeleaf 3.0 전용
     implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity5'
 
-    implementation 'com.github.ua-parser:uap-java:1.5.3'
+    // uap-java 제거: 소스 전체에 ua_parser 참조 0건이고, 1.5.3 은 snakeyaml 2.x 에서 삭제된
+    // SafeConstructor() no-arg 를 호출해 NoSuchMethodError 를 낸다. 되살릴 경우 1.6.1 이상.
     implementation 'org.apache.httpcomponents:httpclient:4.5.14'
     implementation 'com.navercorp.lucy:lucy-xss-servlet:2.0.1'
     implementation 'javax.servlet:javax.servlet-api:4.0.0'
     implementation 'org.jasypt:jasypt:1.9.3'
     implementation 'xerces:xercesImpl:2.12.2'
 
-    implementation 'org.apache.commons:commons-lang3:3.12.0'
+    // weblogic.xml prefer-application-packages 가 com.fasterxml.jackson.* 를 앱 우선으로 강제한다
+    // (oracle_common jackson-databind 2.17.0 vs 앱 2.18.10 split-package 방지, WLog 실사용 확인).
+    // Thymeleaf StandardJavaScriptSerializer 가 ObjectMapper.findAndRegisterModules() 로
+    // jackson-module-jaxb-annotations 를 옵션 모듈로 자동탐색하는데, 이 모듈은 WebLogic 번들에만
+    // 있고 앱엔 없어 ServiceConfigurationError(Provider not found) 발생 → 앱에도 명시 추가해
+    // jackson 전체를 자체 완결시킨다(jackson-bom 2.18.10 로 버전 통일).
+    implementation 'com.fasterxml.jackson.module:jackson-module-jaxb-annotations'
+
+    // Uncontrolled recursion in ClassUtils.getClass(...) on very long inputs. 3.18.0+ 에서 수정.
+    implementation 'org.apache.commons:commons-lang3:3.20.0'
     implementation 'org.apache.commons:commons-collections4:4.4'
 
     implementation 'commons-net:commons-net:3.9.0'
-    implementation('commons-beanutils:commons-beanutils:1.9.4') {
+    // CVE-2025-48734 (PropertyUtilsBean 이 enum 의 declaredClass 프로퍼티 노출 → ClassLoader 접근/RCE).
+    // 1.11.0 부터 SuppressPropertiesBeanIntrospector 가 기본 활성이라 declaredClass 접근이 차단된다.
+    // 이 앱의 호출부(PasswordMatchValidator / PasswordRuleValidator / AuthNumberValidator)는
+    // 어노테이션에 박힌 고정 프로퍼티명만 넘기므로 외부 입력 경로는 없지만 버전은 올려 둔다.
+    // 1.11.0 = Java 8 바이트코드(major 52), PropertyUtils.getProperty/getNestedProperty API 동일.
+    implementation('commons-beanutils:commons-beanutils:1.11.0') {
 //        exclude group: 'commons-collections', module: 'commons-collections'
     }
     implementation 'org.mapstruct:mapstruct:1.5.5.Final'
-    // WS-2026-0003 (jackson-core async parser DoS, CVSS 7.5) — 2.18.6 에서 수정. JDK8 호환.
+    // jackson 개별 pin 제거: 아래 ext 의 jackson-bom.version 이 전 모듈을 일괄 관리한다.
-    implementation 'com.fasterxml.jackson.core:jackson-core:2.18.6'
+    // 개별 pin 은 BOM 보다 우선하므로 남겨 두면 BOM 만 올렸을 때 core/annotations/databind 가
-    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.18.6'
+    // 옛 버전에 고정돼 버전이 어긋난다(실제로 그런 상태였다).
-    implementation 'com.fasterxml.jackson.core:jackson-databind:2.18.6'
 
     implementation group: 'org.apache.velocity', name: 'velocity-engine-core', version: '2.3'
 
@@ -128,7 +145,10 @@ dependencies {
     implementation 'net.bytebuddy:byte-buddy:1.14.5'
 
     // Commons FileUpload (WAS 독립적인 multipart 처리)
-    implementation 'commons-fileupload:commons-fileupload:1.5'
+    // CVE-2025-48976 (멀티파트 파트 헤더 크기 제한 부재 → DoS). 1.6.0 에서 partHeaderSizeMax 도입.
+    // 주의: 1.6 부터 파트 헤더 총량 기본 상한이 10240 → 512 바이트로 줄었다(DEFAULT_PART_HEADER_SIZE_MAX).
+    // 한글 파일명은 UTF-8 로 3바이트/자라 Content-Disposition 이 길어질 수 있어 실측으로 여유를 확인했다.
+    implementation 'commons-fileupload:commons-fileupload:1.6.0'
     implementation 'commons-io:commons-io:2.15.1'
 
 
@@ -146,6 +166,49 @@ ext {
     springMavenArtifactVersion = '5.3.30'
     encoding = 'UTF-8'
     profile = 'local'
+
+    // 내장 Tomcat 버전 상향 (Spring Boot 2.7.18 기본값 9.0.83 → 9.0.120).
+    // Boot BOM 의 tomcat.version 프로퍼티를 덮어써서 tomcat-embed-core/-el/-websocket 이 함께 올라간다.
+    // 9.0.x 계열 유지 = Servlet 4.0 / javax.* 네임스페이스 그대로, JDK8 호환.
+    set('tomcat.version', '9.0.120')
+
+    // CVE-2022-1471 (snakeyaml Constructor 임의 타입 역직렬화 → RCE). Boot 2.7.18 BOM 기본값 1.30 → 2.6.
+    // 앱/프레임워크 실경로는 이미 SafeConstructor 계열(OriginTrackedYamlLoader, spring-beans
+    // FilteringConstructor, swagger-parser DeserializationUtils)이라 익스플로잇 경로는 없었으나
+    // SCA 는 버전으로 판정하므로 2.x 로 올린다. snakeyaml 2.6 = Java 8 바이트코드(major 52).
+    // 2.6 인 이유: swagger-core 2.2.52 / swagger-parser-v3 2.1.45 가 요구하는 버전이라 강등이 없다.
+    // 부수 효과: swagger-parser 가 호출하는 LoaderOptions.setCodePointLimit(1.32+ API) 도 해소.
+    set('snakeyaml.version', '2.6')
+
+    // jackson 전 모듈 버전 통일(Boot 2.7.18 BOM 기본 2.13.5). 2.18.x 는 JDK8 호환 라인이다.
+    // 이유 3가지
+    //   1) snakeyaml 2.x 는 ParserImpl(StreamReader) 를 제거했고 jackson-dataformat-yaml 은
+    //      2.15+ 부터 ParserImpl(StreamReader, LoaderOptions) 를 쓴다 — 위 snakeyaml 상향의 전제.
+    //   2) WS-2026-0003 (jackson-core async parser DoS, CVSS 7.5) — 2.18.6 에서 수정.
+    //   3) jackson-databind PolymorphicTypeValidator 우회(제네릭 타입 인자 미검증) — 2.18.8 에서 수정.
+    //      이 앱은 다형성 역직렬화(activateDefaultTyping/@JsonTypeInfo)를 쓰지 않아 노출 경로는 없다.
+    // 2.18.x 마지막 패치를 쓴다.
+    set('jackson-bom.version', '2.18.10')
+
+    // Thymeleaf SSTI (≤3.1.3.RELEASE: 표현식 접근 객체 제한 우회 → 템플릿 인젝션). 3.0.x 는 EOL 이라
+    // 백포트가 없어 3.1.4 로 올린다. JDK8/Spring5 유지: thymeleaf 3.1.4 / thymeleaf-spring5 3.1.4 /
+    // extras-springsecurity5 3.1.5 / layout-dialect 3.4.0 모두 Java8 바이트코드(major 52), 패키지도
+    // org.thymeleaf.spring5 + javax.servlet 그대로다.
+    // Boot 2.7 ThymeleafAutoConfiguration 이 호출하는 setter 는 3.1.4 에 전부 존재함(확인함).
+    // 주의: 3.1 은 #request/#session/#response/#servletContext 표현식 객체를 제거했다(IllegalArgumentException).
+    set('thymeleaf.version', '3.1.4.RELEASE')
+    set('thymeleaf-extras-springsecurity.version', '3.1.5.RELEASE')
+
+    // Spring Framework 5.3.x OSS 마지막 릴리스로 통일(Boot 2.7.18 BOM 기본 5.3.31, 일부 5.3.30 혼재였음).
+    // 5.3.32~5.3.39 구간 CVE 정리용. 5.3.x 는 OSS EOL 이라 이 위로는 상용(Enterprise) 빌드뿐이다.
+    // 남는 5.3.x 지적(CVE-2026-41855 JMS Jackson 역직렬화, CVE-2016-1000027 HttpInvoker)은
+    // 5.3 계열에 수정본이 없고 앱이 JMS/HttpInvoker 를 쓰지 않으므로 억제 항목으로 따로 관리한다.
+    set('spring-framework.version', '5.3.39')
+
+    // Spring Security 5.7.x OSS 마지막 릴리스(Boot 2.7.18 BOM 기본 5.7.11).
+    // CVE-2026-22732(응답 커밋 후 보안 헤더 미기록)는 수정본이 5.7.22/5.8.24 = Enterprise 전용이라
+    // OSS 로는 올릴 수 없다. 우회책(HeaderWriterFilter.shouldWriteHeadersEagerly=true)은 동작 변경이라 분리 검토.
+    set('spring-security.version', '5.7.14')
 }
 
 

ci/dependency-check-classpath.gradle

@@ -0,0 +1,58 @@
+// OWASP Dependency-Check 가 스캔할 서드파티 jar 를 한 디렉터리로 모은다.
+//
+// build.gradle 을 건드리지 않기 위해 init script(-I) 로만 주입한다.
+//   gradle -I ci/dependency-check-classpath.gradle exportDependencyJars --no-daemon
+//
+// 출력:
+//   build/dependency-check/libs/*.jar   runtimeClasspath 의 외부 의존 jar (원본 파일명 유지)
+//   build/dependency-check/jars.txt     수집 목록(경로 1줄씩) — 진단용
+//
+// 왜 디렉터리로 모으는가
+//   Dependency-Check CLI 는 --scan <경로> 로 파일/디렉터리를 받는다. Gradle 캐시를 통째로 스캔하면
+//   이 프로젝트가 쓰지 않는 버전까지 잡히고, 프로젝트 디렉터리만 스캔하면 의존 jar 가 아예 안 잡힌다.
+//   실제 배포본에 실리는 것과 같은 목록(runtimeClasspath)만 모아야 결과가 배포 산출물과 일치한다.
+//
+// 파일명을 유지해야 하는 이유
+//   Dependency-Check 는 jar 안의 POM/MANIFEST 외에 파일명에서도 CPE(제품/버전)를 추론한다.
+//   이름을 바꾸면 탐지 정확도가 떨어진다.
+
+rootProject { project ->
+    project.plugins.withId('java') {
+        project.tasks.register('exportDependencyJars') {
+            group = 'verification'
+            description = 'Dependency-Check 스캔용 런타임 의존 jar 를 build/dependency-check/libs 에 모은다'
+
+            doLast {
+                def outRoot = new File(project.layout.buildDirectory.get().asFile, 'dependency-check')
+                def outDir = new File(outRoot, 'libs')
+                project.delete(outDir)
+                outDir.mkdirs()
+
+                // 컴포지트/서브프로젝트의 build 디렉터리 산출물(우리가 만든 jar)은 제외한다.
+                // 자체 코드는 SonarQube 가 보는 영역이고, SCA 대상은 외부 라이브러리다.
+                def buildDirs = project.allprojects.collect {
+                    it.layout.buildDirectory.get().asFile.absolutePath
+                }
+                def isOwnArtifact = { File f ->
+                    buildDirs.any { f.absolutePath.startsWith(it + File.separator) }
+                }
+
+                def jars = project.configurations.runtimeClasspath.files
+                        .findAll { it.isFile() && it.name.endsWith('.jar') && !isOwnArtifact(it) }
+                        .unique()
+                        .sort { it.name }
+
+                project.copy {
+                    from jars
+                    into outDir
+                }
+
+                new File(outRoot, 'jars.txt').text =
+                        jars.collect { it.absolutePath }.join(System.lineSeparator()) + System.lineSeparator()
+
+                def totalMb = (jars.sum { it.length() } ?: 0L) / (1024 * 1024)
+                logger.lifecycle("dependency-check scan target: ${jars.size()} jars, ${totalMb as int} MB -> ${outDir}")
+            }
+        }
+    }
+}

ci/dependency-check-suppressions.xml

@@ -0,0 +1,121 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  OWASP Dependency-Check 오탐(false positive) 억제 목록.
+
+  규칙
+    1. 억제는 "오탐"에만 쓴다. 진짜 취약점을 조용히 숨기는 용도로 쓰지 않는다.
+       실제 취약하지만 당장 못 올리는 경우는 억제 대신 만료일(until)을 넣어 재검토를 강제한다.
+    2. 항목마다 <notes> 에 판단 근거와 판단자/일자를 남긴다. 근거 없는 억제는 리뷰에서 거절한다.
+    3. 범위를 좁게 잡는다. cve 단건 + 특정 파일(sha1/packageUrl)이 기본이고,
+       cpe 나 정규식 filePath 로 넓게 억제하지 않는다.
+
+  작성법
+    Dependency-Check HTML 리포트의 각 취약점 옆 "Suppress" 버튼을 누르면 해당 항목의
+    <suppress> 블록이 그대로 생성된다. 그것을 이 파일에 붙여넣고 <notes> 만 채우면 된다.
+
+  참고: https://dependency-check.github.io/DependencyCheck/general/suppression.html
+-->
+<suppressions xmlns="https://jeremylong.github.io/DependencyCheck/dependency-suppression.1.3.xsd">
+
+    <!-- 예시 (실제 억제 시 주석을 풀고 값 교체)
+    <suppress until="2026-12-31Z">
+        <notes><![CDATA[
+            오탐 근거: 해당 CVE 는 X 기능을 사용할 때만 성립하는데 이 앱은 해당 API 를 호출하지 않음.
+            확인: 홍길동 / 2026-08-13 / 호출부 grep 결과 0건.
+        ]]></notes>
+        <packageUrl regex="true">^pkg:maven/org\.example/example-lib@.*$</packageUrl>
+        <cve>CVE-2026-00000</cve>
+    </suppress>
+    -->
+
+    <!-- ================================================================================
+         Spring 계열 Critical 5건 (2026-08-18 리포트 기준).
+
+         공통 배경: Spring Framework 5.3.x / Spring Boot 2.7.x / Spring Security 5.7.x 는 모두 OSS EOL 이라
+         남은 수정본이 상용(Enterprise/Tanzu)뿐이다. JDK 8 유지 제약상 Boot 3 + Spring 6 이관 전까지는
+         버전 상향으로 못 없앤다. 아래는 "코드에 트리거 경로가 없음"을 근거로 한 억제이며 만료일을 둔다.
+         버전 범위를 5.3.x / 2.7.x / 5.7.x 로 고정해 두었으므로, 이관 후에는 억제가 자동으로 풀린다.
+         재검토 시 확인할 것: (1) 각 근거 grep 이 여전히 0건인지 (2) OSS 수정본이 나왔는지.
+         ================================================================================ -->
+
+    <!-- 1. Spring Boot: Cassandra SSL 호스트명 미검증 -->
+    <suppress until="2027-02-28Z">
+        <notes><![CDATA[
+            CVE-2026-40974 는 Spring Boot 의 Cassandra SSL 자동설정이 SSL 번들의 호스트명 검증 설정을
+            드라이버에 전달하지 않는 문제다. 이 앱은 Cassandra 를 쓰지 않는다
+            (runtimeClasspath 에 cassandra/datastax 계열 jar 0건, spring-boot-starter-data-cassandra 미선언).
+            수정본 2.7.33 은 상용(Enterprise) 릴리스라 OSS 로는 올릴 수 없다.
+            devtools/actuator/spring-boot-admin jar 는 스캔 대상(runtimeClasspath)에는 있으나
+            배포 산출물에서는 build.gradle 의 localOnlyLibPrefixes 로 제외되어 WAR 에 실리지 않는다.
+            확인: Rinjae / 2026-08-18 / grep -ri cassandra 0건, WAR 내 devtools/actuator jar 0건.
+        ]]></notes>
+        <packageUrl regex="true">^pkg:maven/org\.springframework\.boot/.*@2\.7\..*$</packageUrl>
+        <cve>CVE-2026-40974</cve>
+    </suppress>
+
+    <!-- 2. Thymeleaf SSTI 2건: starter jar 이름 기준 오탐 -->
+    <suppress>
+        <notes><![CDATA[
+            오탐. CVE-2026-40477 / CVE-2026-40478 은 thymeleaf 본체 3.1.3.RELEASE 이하의 표현식 샌드박스
+            우회 문제이고 3.1.4.RELEASE 에서 수정됐다. 이 프로젝트는 build.gradle 의 ext 에서
+            thymeleaf.version=3.1.4.RELEASE / thymeleaf-extras-springsecurity.version=3.1.5.RELEASE 로
+            올려 두었으므로 실제 실리는 jar 는 thymeleaf-3.1.4.RELEASE.jar 다.
+            Dependency-Check 가 spring-boot-starter-thymeleaf-2.7.18.jar(의존만 선언한 빈 starter)에
+            thymeleaf CPE 를 잘못 매칭한 결과다. thymeleaf 본체 jar 에 대한 탐지는 억제하지 않는다.
+            확인: Rinjae / 2026-08-18 / WAR 내 thymeleaf-3.1.4.RELEASE.jar, thymeleaf-spring5-3.1.4.RELEASE.jar.
+        ]]></notes>
+        <packageUrl regex="true">^pkg:maven/org\.springframework\.boot/spring-boot-starter-thymeleaf@.*$</packageUrl>
+        <cve>CVE-2026-40477</cve>
+        <cve>CVE-2026-40478</cve>
+    </suppress>
+
+    <!-- 3. Spring Framework: JMS Jackson 역직렬화 -->
+    <suppress until="2027-02-28Z">
+        <notes><![CDATA[
+            CVE-2026-41855 는 org.springframework.jms.support.converter.MappingJackson2MessageConverter /
+            JacksonJsonMessageConverter 가 임의 클래스 인스턴스화를 허용하는 문제다(신뢰할 수 없는 JMS 환경 전제).
+            이 앱은 JMS 를 쓰지 않는다: runtimeClasspath 에 spring-jms 0건, 소스에 javax.jms /
+            JmsTemplate / MappingJackson2MessageConverter 참조 0건.
+            5.3.x 는 OSS 수정본이 없다(6.2.19 / 7.0.8 에서만 수정). 이미 5.3.x OSS 마지막인 5.3.39 로 올려 둔 상태다.
+            확인: Rinjae / 2026-08-18 / grep -rn "javax.jms|JmsTemplate|MappingJackson2MessageConverter" src 0건.
+        ]]></notes>
+        <packageUrl regex="true">^pkg:maven/org\.springframework/spring-.*@5\.3\..*$</packageUrl>
+        <cve>CVE-2026-41855</cve>
+    </suppress>
+
+    <!-- 4. spring-web: HttpInvoker 역직렬화 -->
+    <suppress until="2027-02-28Z">
+        <notes><![CDATA[
+            CVE-2016-1000027 은 HttpInvokerServiceExporter 를 노출했을 때만 성립한다. 해당 클래스는
+            Spring 6.0 에서 제거됐고 5.3.x 에는 수정본이 없다(= 5.3.x 를 쓰는 한 계속 탐지된다).
+            이 앱은 HttpInvoker 계열을 쓰지 않는다: 소스에 HttpInvoker 참조 0건이고 외부 호출은
+            RestTemplate / HttpClient 기반이다.
+            근본 해결은 Spring 6(Boot 3, JDK 17) 이관. 이관 전까지 억제한다.
+            확인: Rinjae / 2026-08-18 / grep -rn HttpInvoker src 0건.
+        ]]></notes>
+        <packageUrl regex="true">^pkg:maven/org\.springframework/spring-web@5\.3\..*$</packageUrl>
+        <cve>CVE-2016-1000027</cve>
+    </suppress>
+
+    <!-- 5. Spring Security: 응답 커밋 시 보안 헤더 미기록 -->
+    <suppress until="2027-02-28Z">
+        <notes><![CDATA[
+            CVE-2026-22732 는 응답이 커밋된 뒤 Spring Security 가 보안 헤더를 기록하지 못하는 문제다.
+            트리거는 Content-Length 를 setHeader / setIntHeader / addIntHeader 로 지정하는 경로다
+            (OnCommittedResponseWrapper 는 setContentLength / setContentLengthLong / addHeader 만 추적한다).
+            (1) 이 코드베이스에는 트리거가 없다: portal / elink-portal-common / elink-online-core-jpa 전체에
+                setIntHeader, addIntHeader, setHeader("Content-Length") 0건. 파일 다운로드는
+                response.setContentLength(int) 를 쓰며 실측상 보안 헤더가 정상 기록된다.
+            (2) 그럼에도 안전망으로 PortalConfigSecurity 에서
+                HeaderWriterFilter.setShouldWriteHeadersEagerly(true) 를 적용해(spring.io 권고 우회책)
+                요청 시작 시점에 헤더를 기록하도록 했다.
+            수정본 5.7.22 / 5.8.24 는 Enterprise 전용이라 OSS 로는 올릴 수 없다. 이미 5.7.x OSS 마지막인
+            5.7.14 로 올려 둔 상태다.
+            확인: Rinjae / 2026-08-18 / 동일 스택(Boot 2.7.18 + Security 5.7.14 + Tomcat 9.0.120) 프로브 앱 실측 —
+            우회책 미적용 시 setHeader/setIntHeader/addIntHeader 경로에서 헤더 누락 재현, 적용 후 정상 기록.
+        ]]></notes>
+        <packageUrl regex="true">^pkg:maven/org\.springframework\.security/spring-security-.*@5\.7\..*$</packageUrl>
+        <cve>CVE-2026-22732</cve>
+    </suppress>
+
+</suppressions>

djb-docs/terms/개인정보수집동의서.html

@@ -0,0 +1,17 @@
+<!--
+  editor-content.css 대응 프래그먼트: <!doctype>/<html>/<head>/<style> 없이 순수 태그(h1/h2/h3/p/ul/li/strong)만 사용.
+  admin Summernote 코드뷰에 그대로 붙여넣으면 됨. class/style 속성 없음 -> 붙여넣기(paste-cleaner)든
+  코드뷰 직접 입력이든 태그 정리 과정에서 잘려나갈 것이 없다.
+-->
+<h1>개인정보수집동의서</h1>
+<p><strong>(주)제주은행 귀중</strong></p>
+<p>귀 행과의 Open API Market 회원가입 거래와 관련하여 귀 행이 본인의 개인정보를 수집·이용하고자 하는 경우에는 「개인정보보호법」 등 관계 법령에 따라 본인의 동의가 필요합니다.</p>
+<h2>개인정보</h2>
+<ul>
+<li><strong>일반 개인정보:</strong> 성명, 직장명, 부서명, 연락처(휴대폰 번호, 직장번호), 이메일주소, 아이디, 비밀번호</li>
+</ul>
+<p>□ 동의하지 않음　　□ 동의함</p>
+<p>※ 본 동의 이후 동일한 목적 또는 이용범위 내에서 개인정보의 정확성, 최신성을 유지하기 위해 제공하는 경우에는 별도의 추가 동의가 필요하지 않습니다.</p>
+<p>※ 은행의 고의 또는 과실 등 귀책사유로 인한 개인정보 유출로 고객님에게 발생한 손해에 대해 관계 법령 등에 따라 보상받으실 수 있습니다.</p>
+<h3>위 개인정보 수집·이용에 동의하십니까?</h3>
+<p>제정일자: 2026. 99. 99. 개정</p>

djb-docs/terms/개인정보수집동의서.txt

@@ -0,0 +1,19 @@
+개인정보수집동의서
+
+(주)제주은행 귀중
+
+귀 행과의 Open API Market 회원가입 거래와 관련하여 귀 행이 본인의 개인정보를 수집·이용하고자 하는 경우에는 「개인정보보호법」 등 관계 법령에 따라 본인의 동의가 필요합니다.
+
+개인정보
+  ㄴ 일반 개인정보
+    성명, 직장명, 부서명, 연락처(휴대폰 번호, 직장번호), 이메일주소, 아이디, 비밀번호
+
+    □ 동의하지 않음   □ 동의함
+
+※ 본 동의 이후 동일한 목적 또는 이용범위 내에서 개인정보의 정확성, 최신성을 유지하기 위해 제공하는 경우에는 별도의 추가 동의가 필요하지 않습니다.
+
+※ 은행의 고의 또는 과실 등 귀책사유로 인한 개인정보 유출로 고객님에게 발생한 손해에 대해 관계 법령 등에 따라 보상받으실 수 있습니다.
+
+위 개인정보 수집·이용에 동의하십니까?
+
+제정일자: 2026. 99. 99. 개정

djb-docs/terms/서비스 이용약관.html

@@ -0,0 +1,162 @@
+<!--
+  editor-content.css 대응 프래그먼트: <!doctype>/<html>/<head>/<style> 없이 순수 태그(h2/h3/p)만 사용.
+  admin Summernote 코드뷰에 그대로 붙여넣으면 됨(붙여넣기 시 badTags 정리 대상 없음).
+  약관탭(.content-body.editor-content), 회원가입 동의창, admin .note-editable.editor-content 3곳 모두
+  이 파일 안에서는 정의하지 않는 h2/h3/p 스타일은 공용 editor-content.css 가 담당한다.
+-->
+<h2>제1장 총칙</h2>
+<h3>제1조 (목적)</h3>
+<p>본 약관은 (주)제주은행(이하 “은행”)이 제공하는 Open API 서비스를 이용함에 있어 “은행”과 Open API 서비스를 이용하는 자(이하 “이용기관”)간의 권리, 의무 및 책임 사항, 이용조건 및 절차 등 기본적인 사항을 명확히 규정함을 목적으로 합니다.</p>
+<h3>제2조 (용어의 정의)</h3>
+<p>&nbsp;&nbsp;① 본 약관에서 사용하는 용어의 정의는 다음 각 호와 같습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. “Open API”란 “은행”이 “이용기관”에게 제공하는 API(Application Programming Interface) 기능을 개방형 플랫폼 형태로 이용할 수 있도록 공개한 API</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. “Open API 서비스”(이하 “서비스”)란 “은행”의 서비스 및 데이터를 표준화된 API 형태로 Open API 시스템을 통하여 “이용기관”에 제공하는 것</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. “Open API 시스템”(이하 “시스템”)이란 “서비스”를 제공하기 위하여 “은행”에 설치한 중계시스템과 “이용기관”의 처리시스템을 통신회선으로 연결하여 “은행” 및 “이용기관” 상호간에 정보를 교환하는 시스템</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. “Open API 포탈”(이하 “포털”)이란 “서비스”를 소개하고 가입 절차 및 이용 절차를 제공하며 “이용기관”이 가입 및 “서비스” 이용을 하기 위하여 “은행”이 제공하는 웹사이트</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;5. “이용신청기관”이란 “은행”의 “서비스”를 이용하기 위하여 “서비스” 이용을 신청한 기관(법인, 개인사업자 및 임의단체 등)</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;6. “이용기관”이란 본 약관에 동의하고 “서비스” 이용신청에 대한 “은행”의 승낙을 받은 후, “은행”이 제공하는 Open API를 이용하여 별도의 서비스 또는 프로그램을 개발, 테스트 및 제공하고자 하는 자</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;7. “최종사용자”란 “은행”이 제공한 “서비스”를 결합하여 “이용기관”이 개발한 별도의 서비스 또는 프로그램을 이용하는 고객</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;8. “제휴사”란 “은행”이 “이용기관”에게 “서비스”를 제공하기 위하여 “은행”과 계약을 체결하여 협력하는 제3자</p>
+<h3>제3조 (서비스의 내용)</h3>
+<p>&nbsp;&nbsp;① 조회성 API 서비스(계좌 거래내역 조회, 예금주 실명 조회 등)</p>
+<p>&nbsp;&nbsp;② 거래성 API 서비스(환전, 이체 등)</p>
+<p>&nbsp;&nbsp;③ 기타 “은행” 또는 “제휴사”가 제공하는 API 형태의 “서비스”</p>
+<h3>제4조 (약관의 효력 및 변경)</h3>
+<p>&nbsp;&nbsp;① 본 약관 내용의 효력은 “은행” 인터넷 홈페이지 또는 “포털” 등에 게시되거나 전자우편 등의 방법으로 “이용기관”에 통지됨으로써 발생합니다.</p>
+<p>&nbsp;&nbsp;② 본 약관의 변경은 전자금융거래 기본약관의 내용을 준용합니다.</p>
+<h2>제2장 서비스 이용계약</h2>
+<h3>제5조 (서비스 이용신청)</h3>
+<p>&nbsp;&nbsp;① 서비스 이용신청은 “이용신청기관”이 “포털”에서 “은행”이 정한 가입양식에 회원정보 기입 및 본 약관에 동의함으로써 이루어집니다.</p>
+<p>&nbsp;&nbsp;② 제1항을 완료한 “이용신청기관”은 이용 희망일 전일까지 “은행”이 요청하는 서류를 제출하여야 합니다.</p>
+<h3>제6조 (서비스 이용신청 승인 및 거절)</h3>
+<p>&nbsp;&nbsp;① “은행”은 본 약관 제5조 제2항의 “이용신청기관”이 제출한 서류와 “서비스” 이용목적의 적정성을 검토한 후, “이용신청기관” 서비스 이용신청을 승낙 또는 거절할 수 있습니다.</p>
+<p>&nbsp;&nbsp;② “은행”은 “이용신청기관”이 다음 각 호의 어느 하나에 해당할 경우 이용신청에 대해 거절할 수 있습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 실명이 아니거나, 타인의 명의를 사용하여 신청한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 이용신청 내용을 허위로 기재하거나 허위서류를 첨부한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. 이전에 “이용기관” 자격을 상실한 적이 있거나, 탈퇴, 이용중지 등이 있는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. “이용신청기관”의 업태가 사행행위에 관련이 있거나 금융질서문란 위험이 있는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;5. “이용신청기관”의 사업모델에 위법성이 있는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;6. “이용신청기관”의 재무안정성이 위험한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;7. “이용신청기관”의 전산망이나 정보처리시스템에 보안 취약점이 있거나, “이용신청기관”의 “최종사용자” 정보에 관한 기술적·물리적·관리적 보호조치가 미흡한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;8. “은행”의 평판이나 “최종사용자”의 권리에 위험을 끼칠 가능성이 있는 경우</p>
+<p>&nbsp;&nbsp;③ “은행”은 이용신청에 대한 결과를 “이용신청자”에게 통보하여야 합니다.</p>
+<h2>제3장 서비스의 이용</h2>
+<h3>제7조 (서비스 이용개시)</h3>
+<p>“은행”이 “이용신청기관”의 이용신청을 심사 후 승낙하게 되면 “이용기관”이 요청한 이용 희망일로부터 “서비스”를 개시합니다. 단, 이용 희망일은 “은행”과 협의하여 결정합니다.</p>
+<h3>제8조 (서비스 이용시간)</h3>
+<p>&nbsp;&nbsp;① “서비스”의 이용시간은 연중무휴(24시간)로 하며 “서비스”별 이용시간을 정하여 운영할 수 있습니다. 단, 다음 각 호의 어느 하나에 해당하여 은행이 정상적인 “서비스”를 제공하기 어려운 경우에는 서비스의 전부 또는 일부가 제한 될 수 있습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 은행의 시스템을 점검하는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 은행의 정보통신 설비의 보수점검, 증설, 교체, 이전 등 시스템 관리 작업을 진행하는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. 정전, 제반 설비의 장애 또는 이용량의 폭주 등이 발생하는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. 천재지변, 전쟁, 폭동, 테러, 해킹, Ddos, 국가비상사태 등 불가항력적 사유가 발생하는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;5. 시스템 오류 등 서비스 제공에 관한 기술상 문제가 발생하는 경우</p>
+<p>&nbsp;&nbsp;② 제1항의 사유로 서비스가 일시 중지되는 경우, “은행”은 사전에 이를 공지하여야 합니다. 단, 부득이한 경우 사후에 통보할 수 있습니다.</p>
+<h3>제9조 (서비스 변경 및 중단)</h3>
+<p>&nbsp;&nbsp;① “은행”은 변경될 “서비스”의 내용 및 변경일자를 “이용기관”에게 통지하고 “서비스”를 변경하여 제공할 수 있습니다.</p>
+<p>&nbsp;&nbsp;② “은행”은 “이용기관”이 다음 각 호의 어느 하나에 해당할 경우 “서비스”의 전부 또는 일부를 중단할 수 있습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. “서비스”용 정보통신설비의 보수·교체·고장, 통신두절 등으로 인해 부득이한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 정전, 모든 설비의 장애 또는 이용량의 폭주 등으로 정상적인 서비스 이용에 지장이 있는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. “서비스” 종료 등과 같은 “은행”의 사정으로 “서비스”를 유지할 수 없는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. 기타 천재지변, 국가비상사태 등 불가항력적 사유가 있는 경우</p>
+<p>&nbsp;&nbsp;③ “서비스”를 변경하거나 중단할 경우, “은행”은 그 사실을 사전에 “이용기관”에 통지하여야 합니다. 단, 사전에 통지할 수 없는 부득이한 사유가 있는 경우에는 사후에 그 사유와 함께 통지하여야 합니다. 또한 “포털”에 등록된 연락처가 부정확하거나 “이용기관” 측의 사유로 인하여 “은행”의 통보를 받지 못해 발생하는 손실에 대해서는 “은행”의 고의 또는 과실이 없는 경우 그 책임의 전부 또는 일부를 지지 않습니다.</p>
+<p>&nbsp;&nbsp;④ “은행”은 “서비스”의 변경 혹은 중단으로 발생하는 문제에 대해서는 “은행”의 고의 또는 과실이 없는 경우 그 책임의 전부 또는 일부를 지지 않습니다.</p>
+<h3>제10조 (서비스 이용 제한)</h3>
+<p>&nbsp;&nbsp;① “은행”은 “이용기관”이 다음 각 호의 어느 하나에 해당할 경우 “이용기관”에 대한 “서비스” 이용을 개별 고지 후 제한할 수 있습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 감독당국으로부터 중지 권고가 있는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. “이용기관”이 휴업 또는 폐업을 하는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. 접근권한을 넘어서는 접속을 시도하거나 반복적인 접속을 시도하여 과부하 발생 등 시스템 운영의 안전성을 저해한다고 판단되는 행위가 확인된 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. “이용기관” 수수료 납부계좌에서 부족분이 3회 이상 발생할 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;5. “이용기관”에 본 약관 제6조 제2항 각 호의 사유가 발생한 경우 또는 “서비스” 신청 당시 “이용기관”에 본 약관 제6조 제2항 각 호의 사유가 있었음이 밝혀진 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;6. “시스템” 및 “포털”의 안정적인 운영을 위하여 필요하다고 인정되는 경우</p>
+<p>&nbsp;&nbsp;② “이용기관”이 제1항에 해당할 경우, “은행”은 “서비스” 이용을 제한할 수 있으며 이와 별도로 해당 “이용기관”에 소명자료 제출을 요구할 수 있습니다. “이용기관”은 통지받은 날로부터 15일 이내에 소명자료를 제출하여야 합니다. 단, “은행”은 “이용기관”의 소명자료가 정당하다고 판단하기 전까지 “이용기관”의 “서비스” 이용을 제한할 수 있습니다.</p>
+<h3>제11조 (서비스 이용 해지)</h3>
+<p>&nbsp;&nbsp;① “은행”은 “이용기관”이 다음 각 호의 어느 하나에 해당할 경우 “이용기관”에 대한 “서비스” 이용을 개별 고지 후 해지할 수 있습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 감독당국으로부터 해지권고가 있는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 최근 12개월간 “시스템” 이용 실적이 없는 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. “이용기관” 수수료 납부계좌에서 부족분이 6회 이상 발생할 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. “이용기관”의 정상적인 운영이 불가능하다고 “은행”이 판단할 경우</p>
+<p>&nbsp;&nbsp;② “이용기관”이 제1항에 해당할 경우, “이용기관”에 소명자료 제출을 요구할 수 있습니다. “이용기관”은 통지받은 날로부터 15일 이내에 소명자료를 제출하여야 합니다.</p>
+<p>&nbsp;&nbsp;③ 해지일은 “은행”이 “시스템” 또는 “포털” 원장에 해지 등록한 날로 합니다.</p>
+<h2>제4장 계약당사자의 의무 및 손해배상 등</h2>
+<h3>제12조 (은행의 의무)</h3>
+<p>&nbsp;&nbsp;① “은행”은 본 약관에서 특별히 규정한 사유 외에는 “서비스”를 지속적·안정적으로 제공하여야 합니다.</p>
+<p>&nbsp;&nbsp;② “은행”은 “서비스” 제공과 관련하여 알게 된 “이용기관”의 정보를 업무 이외의 목적으로 사용할 수 없습니다. 단, 관계법령에 따른 수사상의 관계기관으로부터 요구 받은 경우나 정보통신 윤리위원회의 요청이 있는 경우 등 법률의 규정에 따른 적법한 절차에 의한 경우에는 그러하지 않습니다.</p>
+<p>&nbsp;&nbsp;③ “은행”이 제공하는 “서비스”로 인하여 “이용기관”에 손해가 발생한 경우 “서비스”를 제공하는 “은행”과 이용하는 “이용기관”이 상호협의에 의하여 해결합니다. 단, 그러한 손해가 “은행”의 고의나 과실에 기해 발생한 경우에 한하여 “은행”은 그 책임의 전부 또는 일부를 부담합니다.</p>
+<p>&nbsp;&nbsp;④ “은행”은 개인정보보호법, 신용정보의 이용 및 보호에 관한 법률, 금융실명거래 및 비밀보장에 관한 법률, 정보통신망 이용촉진 및 정보보호에 관한 법률, 통신비밀보호법 등 “서비스” 운영, 유지와 관련 있는 법규를 준수하여야 합니다.</p>
+<h3>제13조 (약관 외 준칙)</h3>
+<p>&nbsp;&nbsp;① “이용기관”은 “포털”에서 “은행”이 정한 가입양식에 회원정보를 기입할 때, 사실에 근거하여 정확하게 기입하여야 합니다.</p>
+<p>&nbsp;&nbsp;② “이용기관”은 “은행”에 제공한 사항이 변경될 때, 즉시 “은행”에 변경 신청하여 변경사항을 최신의 정보로 수정해야 합니다. 수정하지 않은 정보로 인하여 발생하는 문제에 대한 책임은 “이용기관”에 있으며 “은행”은 이에 대해 아무런 책임을 지지 않습니다.</p>
+<p>&nbsp;&nbsp;③ “이용기관”은 “시스템”과 관련한 “서비스” 이용의 대가로 수수료를 납부하여야 합니다.</p>
+<p>&nbsp;&nbsp;④ “이용기관”은 “서비스”의 이용 권한, 기타 이용 계약상의 지위를 타인에게 양도, 증여할 수 없으며 게시물에 대한 저작권을 포함한 모든 권리 및 책임은 이를 게시한 “이용기관”에 있습니다.</p>
+<p>&nbsp;&nbsp;⑤ “이용기관”은 “서비스”의 안정적인 이용을 위해 전산시스템의 구축에 필요한 회선, 단말기 및 부대기기를 “이용기관”의 부담으로 설치하여야 하고, 보안상 안전하게 처리할 수 있는 전산시스템을 갖추어야 합니다.</p>
+<p>&nbsp;&nbsp;⑥ “이용기관”은 “은행”이나 “최종사용자”가 업무처리에 대하여 이의를 제기하거나 확인을 요청하면 이를 신속히 처리하여야 합니다.</p>
+<p>&nbsp;&nbsp;⑦ “이용기관”은 본 약관에서 정한 사항을 준수하여야 하며, “은행”이 “이용기관”의 약관 이행여부를 점검하고자 할 경우 적극 협조하여야 합니다.</p>
+<p>&nbsp;&nbsp;⑧ “이용기관”은 “포털”에서 제공하는 “서비스” 이용과 관련하여 다음 각 호의 행위를 하여서는 안 됩니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 다른 “이용기관”의 아이디를 부정 사용하는 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 범죄행위를 목적으로 하거나 기타 범죄행위와 관련된 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. 선량한 풍속, 기타 사회질서를 해하는 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. 타인의 명예를 훼손하거나 모욕하는 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;5. 타인의 지식재산권 등의 권리를 침해하는 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;6. 해킹행위 또는 컴퓨터 바이러스의 유포행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;7. 타인의 의사에 반하여 광고성 정보 등 일정한 내용을 지속적으로 전송하는 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;8. 서비스의 안정적인 운영에 지장을 주거나 줄 우려가 있는 일체의 행위</p>
+<p>&nbsp;&nbsp;⑨ “이용기관”은 개인정보보호법, 신용정보의 이용 및 보호에 관한 법률, 금융실명거래 및 비밀보장에 관한 법률, 정보통신망 이용촉진 및 정보보호에 관한 법률, 통신비밀보호법 등 “서비스” 운영, 유지와 관련 있는 법규를 준수하여야 합니다.</p>
+<h2>제5장 수수료</h2>
+<h3>제14조 (수수료)</h3>
+<p>&nbsp;&nbsp;① “은행”은 “서비스” 제공의 대가로 “이용기관”에게 수수료를 부과합니다.</p>
+<p>&nbsp;&nbsp;② “은행”은 매월 1일~말일까지 발생하는 수수료를 익월 10일(공휴일인 경우에는 익영업일)에 “이용기관”에게 부과하며, “이용기관”이 등록한 수수료 납부계좌에서 예금청구서 및 통장에 의하지 아니하고 대체 출금하기로 합니다.</p>
+<p>&nbsp;&nbsp;③ “은행”은 “이용기관”이 해지 등의 사유로 “서비스” 이용이 불가한 경우, 이용불가 시점까지 발생한 미결제 수수료를 본 “서비스” 해지일에 예금청구서 및 통장에 의하지 아니하고 “이용기관”의 수수료 납부계좌에서 출금하고, 부족액이 발생할 시에 별도 청구합니다.</p>
+<p>&nbsp;&nbsp;④ “은행”은 제2항의 규정에도 불구하고 전산상의 이유 등으로 “이용기관”이 등록한 수수료 납부계좌에서 예금청구서 및 통장에 의하지 아니하고 대체 출금할 수 없는 경우, “이용기관”에 “은행”이 정하는 다른 방법으로 수수료 납부를 요청할 수 있습니다.</p>
+<p>&nbsp;&nbsp;⑤ “이용기관”에게 부과되는 수수료는 “은행”이 정하는 바에 따릅니다. 다만 “은행”이 사업적으로 필요하다고 판단되는 경우 서비스 이용에 따른 수수료를 감면할 수 있습니다.</p>
+<p>&nbsp;&nbsp;⑥ 수수료는 은행의 정책에 따라 변경될 수 있으며, 은행이 수수료를 변경할 경우 전자금융거래 기본약관의 내용을 준용합니다.</p>
+<h2>제6장 보칙</h2>
+<h3>제15조 (최종사용자에 대한 고지 의무)</h3>
+<p>&nbsp;&nbsp;① “이용기관”은 중요사항에 대해 “최종사용자”에게 통보하여야 합니다.</p>
+<p>&nbsp;&nbsp;② “이용기관”은 “서비스” 이용 관련사항을 변경한 경우에 “최종사용자”에게 사전에 통지하여야 합니다.</p>
+<p>&nbsp;&nbsp;③ “은행”은 “이용기관”이 “최종사용자”에게 고지할 필요가 있다고 판단되는 사항을 고지하도록 “이용기관”에게 요구할 수 있습니다.</p>
+<p>&nbsp;&nbsp;④ “이용기관”은 “시스템”과 관련하여 알게 된 “최종사용자” 정보가 제3자에게 유출되었을 경우 즉시 해당 “최종사용자” 및 “은행”에 통지하여 추가적인 피해가 없도록 조치하여야 합니다.</p>
+<h3>제16조 (부정 접속 방지)</h3>
+<p>&nbsp;&nbsp;① “은행”은 부정접속을 방지하기 위하여 “이용기관”의 “포털” 접속용 패스워드 입력오류가 연속 5회를 초과할 경우 업무 이용을 중지시킵니다.</p>
+<p>&nbsp;&nbsp;② 제1항에 따라 업무 이용이 중지된 “이용기관”은 업무 이용을 위하여 “은행”에 해제 요청을 하여야 합니다.</p>
+<h3>제17조 (전산처리 절차)</h3>
+<p>전산처리명세의 송·수신 절차, 방법, 시간, 이체일 등 전산처리와 관련된 사항은 “포털”을 통해 별도 공시합니다.</p>
+<h3>제18조 (보안관리)</h3>
+<p>&nbsp;&nbsp;① “이용기관”은 “은행”에서 제시하는 보안 기준을 준수하여야 하고, “은행”은 “이용기관”의 전산시스템에 대하여 각 호의 사항을 점검 요청할 수 있습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 개인정보 및 금융정보 암호화 운영현황</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 해킹 등에 대비한 정책사항</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. 시스템 운영에 대한 정보보호 체계 등</p>
+<p>&nbsp;&nbsp;② “이용기관”은 “서비스” 이용과 관련하여 감독 당국에서 관련 자료 또는 감독을 요청하면 이에 대하여 적극적으로 협조하여야 합니다.</p>
+<p>&nbsp;&nbsp;③ “이용기관”의 “서비스” 이용에 대한 고객 정보 관리책임은 “이용기관”에게 있으며, “이용기관”의 전산시스템에 대한 해킹 또는 외부의 네트워크 공격 등 위험이 발생한 경우에는 즉시 “은행”에 이를 통지하고, 본 “서비스”의 이용을 중단하여야 합니다.</p>
+<h3>제19조 (기밀유지)</h3>
+<p>&nbsp;&nbsp;① “은행”과 “이용기관”은 “서비스”와 관련되거나 상호정보교환 등 업무처리 과정에서 인지 또는 획득한 정보를 이 업무처리 이외의 목적으로 사용하거나 외부에 유출하여서는 안 됩니다.</p>
+<p>&nbsp;&nbsp;② 제1항에서 정한 의무를 위반하여 상대방 또는 제3자에게 손해가 발생한 경우, 귀책사유 있는 당사자는 상대방 또는 제3자에게 이로 인하여 발생한 손해의 일부 또는 전부를 배상하여야 합니다.</p>
+<h3>제20조 (손해배상 및 면책)</h3>
+<p>&nbsp;&nbsp;① “은행”은 “이용기관”으로부터 접근매체의 분실이나 도난의 통지를 받은 후에 제3자가 그 접근매체를 사용하여 “이용기관”에게 손해가 발생한 경우 그 손해를 배상합니다.</p>
+<p>&nbsp;&nbsp;② “은행”은 다음 각 1호의 사고로 인하여 “이용기관”에게 손해가 발생한 경우 그 손해를 배상합니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 접근매체의 위조나 변조로 발생한 사고</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 계약체결 또는 거래지시의 전자적 전송이나 처리과정에서 발생한 사고</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. 전자금융거래를 위한 전자적 장치 또는 「정보통신망 이용촉진 및 정보보호 등에 관한 법률」 제2조 제1항 제1호에 따른 “은행”의 정보통신망에 침입하여 거짓이나 그 밖의 부정한 방법으로 획득한 접근매체의 이용으로 발생한 사고</p>
+<p>&nbsp;&nbsp;③ 제1항 및 제2항에 의하여 금전적 손해가 발생한 경우 해당 금액 및 이에 대한 1년 만기 정기예금 이율로 계산한 경과이자를 배상합니다. 다만, 손해액이 해당 금액과 1년 만기 정기예금 이율로 계산한 금액을 초과하는 경우에는 실손해액을 배상합니다.</p>
+<p>&nbsp;&nbsp;④ 제2항의 규정에도 불구하고 “은행”은 “이용기관”이 고의 또는 과실로 다음 각 호의 행위를 하여 “이용기관”에게 손해가 생기는 경우 “은행”의 고의 또는 과실이 없다면 “은행”은 그 책임의 전부 또는 일부를 지지 않습니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. “이용기관”이 접근매체를 제3자에게 대여하거나 사용을 위임한 경우 또는 양도나 담보의 목적으로 제공한 경우(「전자금융거래법」제18조에 따라 선불전자지급수단이나 전자화폐를 양도하거나 담보로 제공한 경우를 제외합니다.)</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 제3자가 권한 없이 “이용기관”의 접근매체를 이용하여 전자금융거래를 할 수 있음을 알았거나 쉽게 알 수 있었음에도 불구하고 “이용기관”이 자신의 접근매체를 누설 또는 노출하거나 방치한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;3. “은행”이 접근매체를 통하여 “이용기관”의 신원, 권한 및 거래지시의 내용 등을 확인하는 것 외에 보안강화를 위하여 전자금융거래 시 사전에 요구하는 추가적인 보안조치를 “이용기관”이 정당한 사유 없이 거부하여 사고가 발생한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;4. “이용기관”이 제3호에 따른 추가적인 보안조치에 사용되는 매체·수단 또는 정보에 대하여 다음 각 목의 어느 하나에 해당하는 행위를 하여 사고가 발생한 경우</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;가. 누설·노출 또는 방치한 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;나. 제3자에게 대여하거나 그 사용을 위임한 행위 또는 양도나 담보의 목적으로 제공한 행위</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;5. 법인(「중소기업기본법」제2조 제2항에 의한 소기업을 제외합니다.)인 “이용기관”에게 손해가 발생한 경우로 “은행”이 사고를 방지하기 위하여 보안절차를 수립하고 이를 철저히 준수하는 등 합리적으로 요구되는 충분한 주의의무를 다한 경우</p>
+<h3>제21조 (이의제기 및 협조)</h3>
+<p>&nbsp;&nbsp;① “이용기관”은 전자금융거래의 처리에 관하여 이의가 있을 때에는 “은행”의 분쟁처리기구에 그 해결을 요구하거나 금융감독원 금융분쟁조정위원회, 한국소비자보호원 소비자분쟁조정위원회 등을 통하여 분쟁조정을 신청할 수 있습니다.</p>
+<p>&nbsp;&nbsp;② “이용기관”이 “은행”의 본점이나 영업점 또는 “은행”의 분쟁처리기구에 이의를 제기한 경우 “은행”은 15일 이내에 이에 대한 조사 또는 처리결과를 “이용기관”에게 알려야 합니다.</p>
+<p>&nbsp;&nbsp;③ “은행”은 손해배상 등 분쟁처리를 위한 분쟁처리책임자 및 담당자를 지정하고, 그 연락처를 관련 인터넷 홈페이지에 게시하여야 합니다.</p>
+<p>&nbsp;&nbsp;④ “이용기관”은 제20조 제2항에 정한 사고발생으로 인한 손해배상 등 분쟁처리와 관련한 “은행”의 사고조사 및 관계당국의 수사 또는 조사 절차에 협조하여야 합니다.</p>
+<h3>제22조 (거래기록·자료의 제공)</h3>
+<p>&nbsp;&nbsp;① “은행”은 “이용기관”의 요청이 있을 경우 「금융실명거래 및 비밀보장에 관한 법률」 등 다른 법률에 저촉되지 않는 범위 내에서 “은행”이 보존·관리하고 있는 전자금융거래 관련 기록·자료를 “이용기관”에게 제공하여야 합니다.</p>
+<p>&nbsp;&nbsp;② “이용기관”이 제공 요청을 할 수 있는 거래기록·자료의 범위와 대상기간은 「전자금융거래법」 제22조 제1항 및 제2항에서 정한 기록 및 기간으로 합니다.</p>
+<p>&nbsp;&nbsp;③ “이용기관”이 서면(전자문서를 제외합니다. 이하 같습니다.) 형태의 거래기록·자료(이하 “거래명세서”라 합니다.)를 제공할 것을 “은행”에 요청하는 경우에는 본인이 서면으로 영업점에 신청하여야 하며, “은행”은 신청 가능 영업점의 주소 및 전화번호 등을 인터넷 등을 통하여 “이용기관”이 알 수 있도록 게시하여야 합니다.</p>
+<p>&nbsp;&nbsp;④ “은행”은 “이용기관”으로부터 제3항에 따른 거래명세서의 제공요청을 받은 경우 2주일 이내에 “이용기관”에게 거래명세서를 교부하여야 합니다.</p>
+<p>&nbsp;&nbsp;⑤ “은행”은 불가피한 사유로 인하여 거래기록·자료(거래명세서 포함)의 제공이 불가능한 경우에는 그 사유를 “이용기관”에게 즉시 통보하여야 하며, 해당 사유가 소멸한 경우 다음 각 호에 정한 기한 내에 “이용기관”에게 확인 및 제공하여야 합니다.</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;1. 전자적 장치를 통한 제공의 경우에는 즉시</p>
+<p>&nbsp;&nbsp;&nbsp;&nbsp;2. 제3항에 따른 서면 제공 방식의 경우에는 2주일 이내에 거래명세서를 교부</p>
+<h2>부칙</h2>
+<p>본 약관은 2026. 99. 99.부터 시행합니다.</p>

djb-docs/terms/서비스 이용약관.txt

@@ -0,0 +1,184 @@
+제1장 총칙
+
+제1조 (목적)
+본 약관은 (주)제주은행(이하 “은행”)이 제공하는 Open API 서비스를 이용함에 있어 “은행”과 Open API 서비스를 이용하는 자(이하 “이용기관”)간의 권리, 의무 및 책임 사항, 이용조건 및 절차 등 기본적인 사항을 명확히 규정함을 목적으로 합니다.
+
+제2조 (용어의 정의)
+  ① 본 약관에서 사용하는 용어의 정의는 다음 각 호와 같습니다.
+    1. “Open API”란 “은행”이 “이용기관”에게 제공하는 API(Application Programming Interface) 기능을 개방형 플랫폼 형태로 이용할 수 있도록 공개한 API
+    2. “Open API 서비스”(이하 “서비스”)란 “은행”의 서비스 및 데이터를 표준화된 API 형태로 Open API 시스템을 통하여 “이용기관”에 제공하는 것
+    3. “Open API 시스템”(이하 “시스템”)이란 “서비스”를 제공하기 위하여 “은행”에 설치한 중계시스템과 “이용기관”의 처리시스템을 통신회선으로 연결하여 “은행” 및 “이용기관” 상호간에 정보를 교환하는 시스템
+    4. “Open API 포탈”(이하 “포털”)이란 “서비스”를 소개하고 가입 절차 및 이용 절차를 제공하며 “이용기관”이 가입 및 “서비스” 이용을 하기 위하여 “은행”이 제공하는 웹사이트
+    5. “이용신청기관”이란 “은행”의 “서비스”를 이용하기 위하여 “서비스” 이용을 신청한 기관(법인, 개인사업자 및 임의단체 등)
+    6. “이용기관”이란 본 약관에 동의하고 “서비스” 이용신청에 대한 “은행”의 승낙을 받은 후, “은행”이 제공하는 Open API를 이용하여 별도의 서비스 또는 프로그램을 개발, 테스트 및 제공하고자 하는 자
+    7. “최종사용자”란 “은행”이 제공한 “서비스”를 결합하여 “이용기관”이 개발한 별도의 서비스 또는 프로그램을 이용하는 고객
+    8. “제휴사”란 “은행”이 “이용기관”에게 “서비스”를 제공하기 위하여 “은행”과 계약을 체결하여 협력하는 제3자
+
+제3조 (서비스의 내용)
+  ① 조회성 API 서비스(계좌 거래내역 조회, 예금주 실명 조회 등)
+  ② 거래성 API 서비스(환전, 이체 등)
+  ③ 기타 “은행” 또는 “제휴사”가 제공하는 API 형태의 “서비스”
+
+제4조 (약관의 효력 및 변경)
+  ① 본 약관 내용의 효력은 “은행” 인터넷 홈페이지 또는 “포털” 등에 게시되거나 전자우편 등의 방법으로 “이용기관”에 통지됨으로써 발생합니다.
+  ② 본 약관의 변경은 전자금융거래 기본약관의 내용을 준용합니다.
+
+제2장 서비스 이용계약
+
+제5조 (서비스 이용신청)
+  ① 서비스 이용신청은 “이용신청기관”이 “포털”에서 “은행”이 정한 가입양식에 회원정보 기입 및 본 약관에 동의함으로써 이루어집니다.
+  ② 제1항을 완료한 “이용신청기관”은 이용 희망일 전일까지 “은행”이 요청하는 서류를 제출하여야 합니다.
+
+제6조 (서비스 이용신청 승인 및 거절)
+  ① “은행”은 본 약관 제5조 제2항의 “이용신청기관”이 제출한 서류와 “서비스” 이용목적의 적정성을 검토한 후, “이용신청기관” 서비스 이용신청을 승낙 또는 거절할 수 있습니다.
+  ② “은행”은 “이용신청기관”이 다음 각 호의 어느 하나에 해당할 경우 이용신청에 대해 거절할 수 있습니다.
+    1. 실명이 아니거나, 타인의 명의를 사용하여 신청한 경우
+    2. 이용신청 내용을 허위로 기재하거나 허위서류를 첨부한 경우
+    3. 이전에 “이용기관” 자격을 상실한 적이 있거나, 탈퇴, 이용중지 등이 있는 경우
+    4. “이용신청기관”의 업태가 사행행위에 관련이 있거나 금융질서문란 위험이 있는 경우
+    5. “이용신청기관”의 사업모델에 위법성이 있는 경우
+    6. “이용신청기관”의 재무안정성이 위험한 경우
+    7. “이용신청기관”의 전산망이나 정보처리시스템에 보안 취약점이 있거나, “이용신청기관”의 “최종사용자” 정보에 관한 기술적·물리적·관리적 보호조치가 미흡한 경우
+    8. “은행”의 평판이나 “최종사용자”의 권리에 위험을 끼칠 가능성이 있는 경우
+  ③ “은행”은 이용신청에 대한 결과를 “이용신청자”에게 통보하여야 합니다.
+
+제3장 서비스의 이용
+
+제7조 (서비스 이용개시)
+“은행”이 “이용신청기관”의 이용신청을 심사 후 승낙하게 되면 “이용기관”이 요청한 이용 희망일로부터 “서비스”를 개시합니다. 단, 이용 희망일은 “은행”과 협의하여 결정합니다.
+
+제8조 (서비스 이용시간)
+  ① “서비스”의 이용시간은 연중무휴(24시간)로 하며 “서비스”별 이용시간을 정하여 운영할 수 있습니다. 단, 다음 각 호의 어느 하나에 해당하여 은행이 정상적인 “서비스”를 제공하기 어려운 경우에는 서비스의 전부 또는 일부가 제한 될 수 있습니다.
+    1. 은행의 시스템을 점검하는 경우
+    2. 은행의 정보통신 설비의 보수점검, 증설, 교체, 이전 등 시스템 관리 작업을 진행하는 경우
+    3. 정전, 제반 설비의 장애 또는 이용량의 폭주 등이 발생하는 경우
+    4. 천재지변, 전쟁, 폭동, 테러, 해킹, Ddos, 국가비상사태 등 불가항력적 사유가 발생하는 경우
+    5. 시스템 오류 등 서비스 제공에 관한 기술상 문제가 발생하는 경우
+  ② 제1항의 사유로 서비스가 일시 중지되는 경우, “은행”은 사전에 이를 공지하여야 합니다. 단, 부득이한 경우 사후에 통보할 수 있습니다.
+
+제9조 (서비스 변경 및 중단)
+  ① “은행”은 변경될 “서비스”의 내용 및 변경일자를 “이용기관”에게 통지하고 “서비스”를 변경하여 제공할 수 있습니다.
+  ② “은행”은 “이용기관”이 다음 각 호의 어느 하나에 해당할 경우 “서비스”의 전부 또는 일부를 중단할 수 있습니다.
+    1. “서비스”용 정보통신설비의 보수·교체·고장, 통신두절 등으로 인해 부득이한 경우
+    2. 정전, 모든 설비의 장애 또는 이용량의 폭주 등으로 정상적인 서비스 이용에 지장이 있는 경우
+    3. “서비스” 종료 등과 같은 “은행”의 사정으로 “서비스”를 유지할 수 없는 경우
+    4. 기타 천재지변, 국가비상사태 등 불가항력적 사유가 있는 경우
+  ③ “서비스”를 변경하거나 중단할 경우, “은행”은 그 사실을 사전에 “이용기관”에 통지하여야 합니다. 단, 사전에 통지할 수 없는 부득이한 사유가 있는 경우에는 사후에 그 사유와 함께 통지하여야 합니다. 또한 “포털”에 등록된 연락처가 부정확하거나 “이용기관” 측의 사유로 인하여 “은행”의 통보를 받지 못해 발생하는 손실에 대해서는 “은행”의 고의 또는 과실이 없는 경우 그 책임의 전부 또는 일부를 지지 않습니다.
+  ④ “은행”은 “서비스”의 변경 혹은 중단으로 발생하는 문제에 대해서는 “은행”의 고의 또는 과실이 없는 경우 그 책임의 전부 또는 일부를 지지 않습니다.
+
+제10조 (서비스 이용 제한)
+  ① “은행”은 “이용기관”이 다음 각 호의 어느 하나에 해당할 경우 “이용기관”에 대한 “서비스” 이용을 개별 고지 후 제한할 수 있습니다.
+    1. 감독당국으로부터 중지 권고가 있는 경우
+    2. “이용기관”이 휴업 또는 폐업을 하는 경우
+    3. 접근권한을 넘어서는 접속을 시도하거나 반복적인 접속을 시도하여 과부하 발생 등 시스템 운영의 안전성을 저해한다고 판단되는 행위가 확인된 경우
+    4. “이용기관” 수수료 납부계좌에서 부족분이 3회 이상 발생할 경우
+    5. “이용기관”에 본 약관 제6조 제2항 각 호의 사유가 발생한 경우 또는 “서비스” 신청 당시 “이용기관”에 본 약관 제6조 제2항 각 호의 사유가 있었음이 밝혀진 경우
+    6. “시스템” 및 “포털”의 안정적인 운영을 위하여 필요하다고 인정되는 경우
+  ② “이용기관”이 제1항에 해당할 경우, “은행”은 “서비스” 이용을 제한할 수 있으며 이와 별도로 해당 “이용기관”에 소명자료 제출을 요구할 수 있습니다. “이용기관”은 통지받은 날로부터 15일 이내에 소명자료를 제출하여야 합니다. 단, “은행”은 “이용기관”의 소명자료가 정당하다고 판단하기 전까지 “이용기관”의 “서비스” 이용을 제한할 수 있습니다.
+
+제11조 (서비스 이용 해지)
+  ① “은행”은 “이용기관”이 다음 각 호의 어느 하나에 해당할 경우 “이용기관”에 대한 “서비스” 이용을 개별 고지 후 해지할 수 있습니다.
+    1. 감독당국으로부터 해지권고가 있는 경우
+    2. 최근 12개월간 “시스템” 이용 실적이 없는 경우
+    3. “이용기관” 수수료 납부계좌에서 부족분이 6회 이상 발생할 경우
+    4. “이용기관”의 정상적인 운영이 불가능하다고 “은행”이 판단할 경우
+  ② “이용기관”이 제1항에 해당할 경우, “이용기관”에 소명자료 제출을 요구할 수 있습니다. “이용기관”은 통지받은 날로부터 15일 이내에 소명자료를 제출하여야 합니다.
+  ③ 해지일은 “은행”이 “시스템” 또는 “포털” 원장에 해지 등록한 날로 합니다.
+
+제4장 계약당사자의 의무 및 손해배상 등
+
+제12조 (은행의 의무)
+  ① “은행”은 본 약관에서 특별히 규정한 사유 외에는 “서비스”를 지속적·안정적으로 제공하여야 합니다.
+  ② “은행”은 “서비스” 제공과 관련하여 알게 된 “이용기관”의 정보를 업무 이외의 목적으로 사용할 수 없습니다. 단, 관계법령에 따른 수사상의 관계기관으로부터 요구 받은 경우나 정보통신 윤리위원회의 요청이 있는 경우 등 법률의 규정에 따른 적법한 절차에 의한 경우에는 그러하지 않습니다.
+  ③ “은행”이 제공하는 “서비스”로 인하여 “이용기관”에 손해가 발생한 경우 “서비스”를 제공하는 “은행”과 이용하는 “이용기관”이 상호협의에 의하여 해결합니다. 단, 그러한 손해가 “은행”의 고의나 과실에 기해 발생한 경우에 한하여 “은행”은 그 책임의 전부 또는 일부를 부담합니다.
+  ④ “은행”은 개인정보보호법, 신용정보의 이용 및 보호에 관한 법률, 금융실명거래 및 비밀보장에 관한 법률, 정보통신망 이용촉진 및 정보보호에 관한 법률, 통신비밀보호법 등 “서비스” 운영, 유지와 관련 있는 법규를 준수하여야 합니다.
+
+제13조 (약관 외 준칙)
+  ① “이용기관”은 “포털”에서 “은행”이 정한 가입양식에 회원정보를 기입할 때, 사실에 근거하여 정확하게 기입하여야 합니다.
+  ② “이용기관”은 “은행”에 제공한 사항이 변경될 때, 즉시 “은행”에 변경 신청하여 변경사항을 최신의 정보로 수정해야 합니다. 수정하지 않은 정보로 인하여 발생하는 문제에 대한 책임은 “이용기관”에 있으며 “은행”은 이에 대해 아무런 책임을 지지 않습니다.
+  ③ “이용기관”은 “시스템”과 관련한 “서비스” 이용의 대가로 수수료를 납부하여야 합니다.
+  ④ “이용기관”은 “서비스”의 이용 권한, 기타 이용 계약상의 지위를 타인에게 양도, 증여할 수 없으며 게시물에 대한 저작권을 포함한 모든 권리 및 책임은 이를 게시한 “이용기관”에 있습니다.
+  ⑤ “이용기관”은 “서비스”의 안정적인 이용을 위해 전산시스템의 구축에 필요한 회선, 단말기 및 부대기기를 “이용기관”의 부담으로 설치하여야 하고, 보안상 안전하게 처리할 수 있는 전산시스템을 갖추어야 합니다.
+  ⑥ “이용기관”은 “은행”이나 “최종사용자”가 업무처리에 대하여 이의를 제기하거나 확인을 요청하면 이를 신속히 처리하여야 합니다.
+  ⑦ “이용기관”은 본 약관에서 정한 사항을 준수하여야 하며, “은행”이 “이용기관”의 약관 이행여부를 점검하고자 할 경우 적극 협조하여야 합니다.
+  ⑧ “이용기관”은 “포털”에서 제공하는 “서비스” 이용과 관련하여 다음 각 호의 행위를 하여서는 안 됩니다.
+    1. 다른 “이용기관”의 아이디를 부정 사용하는 행위
+    2. 범죄행위를 목적으로 하거나 기타 범죄행위와 관련된 행위
+    3. 선량한 풍속, 기타 사회질서를 해하는 행위
+    4. 타인의 명예를 훼손하거나 모욕하는 행위
+    5. 타인의 지식재산권 등의 권리를 침해하는 행위
+    6. 해킹행위 또는 컴퓨터 바이러스의 유포행위
+    7. 타인의 의사에 반하여 광고성 정보 등 일정한 내용을 지속적으로 전송하는 행위
+    8. 서비스의 안정적인 운영에 지장을 주거나 줄 우려가 있는 일체의 행위
+  ⑨ “이용기관”은 개인정보보호법, 신용정보의 이용 및 보호에 관한 법률, 금융실명거래 및 비밀보장에 관한 법률, 정보통신망 이용촉진 및 정보보호에 관한 법률, 통신비밀보호법 등 “서비스” 운영, 유지와 관련 있는 법규를 준수하여야 합니다.
+
+제5장 수수료
+
+제14조 (수수료)
+  ① “은행”은 “서비스” 제공의 대가로 “이용기관”에게 수수료를 부과합니다.
+  ② “은행”은 매월 1일~말일까지 발생하는 수수료를 익월 10일(공휴일인 경우에는 익영업일)에 “이용기관”에게 부과하며, “이용기관”이 등록한 수수료 납부계좌에서 예금청구서 및 통장에 의하지 아니하고 대체 출금하기로 합니다.
+  ③ “은행”은 “이용기관”이 해지 등의 사유로 “서비스” 이용이 불가한 경우, 이용불가 시점까지 발생한 미결제 수수료를 본 “서비스” 해지일에 예금청구서 및 통장에 의하지 아니하고 “이용기관”의 수수료 납부계좌에서 출금하고, 부족액이 발생할 시에 별도 청구합니다.
+  ④ “은행”은 제2항의 규정에도 불구하고 전산상의 이유 등으로 “이용기관”이 등록한 수수료 납부계좌에서 예금청구서 및 통장에 의하지 아니하고 대체 출금할 수 없는 경우, “이용기관”에 “은행”이 정하는 다른 방법으로 수수료 납부를 요청할 수 있습니다.
+  ⑤ “이용기관”에게 부과되는 수수료는 “은행”이 정하는 바에 따릅니다. 다만 “은행”이 사업적으로 필요하다고 판단되는 경우 서비스 이용에 따른 수수료를 감면할 수 있습니다.
+  ⑥ 수수료는 은행의 정책에 따라 변경될 수 있으며, 은행이 수수료를 변경할 경우 전자금융거래 기본약관의 내용을 준용합니다.
+
+제6장 보칙
+
+제15조 (최종사용자에 대한 고지 의무)
+  ① “이용기관”은 중요사항에 대해 “최종사용자”에게 통보하여야 합니다.
+  ② “이용기관”은 “서비스” 이용 관련사항을 변경한 경우에 “최종사용자”에게 사전에 통지하여야 합니다.
+  ③ “은행”은 “이용기관”이 “최종사용자”에게 고지할 필요가 있다고 판단되는 사항을 고지하도록 “이용기관”에게 요구할 수 있습니다.
+  ④ “이용기관”은 “시스템”과 관련하여 알게 된 “최종사용자” 정보가 제3자에게 유출되었을 경우 즉시 해당 “최종사용자” 및 “은행”에 통지하여 추가적인 피해가 없도록 조치하여야 합니다.
+
+제16조 (부정 접속 방지)
+  ① “은행”은 부정접속을 방지하기 위하여 “이용기관”의 “포털” 접속용 패스워드 입력오류가 연속 5회를 초과할 경우 업무 이용을 중지시킵니다.
+  ② 제1항에 따라 업무 이용이 중지된 “이용기관”은 업무 이용을 위하여 “은행”에 해제 요청을 하여야 합니다.
+
+제17조 (전산처리 절차)
+전산처리명세의 송·수신 절차, 방법, 시간, 이체일 등 전산처리와 관련된 사항은 “포털”을 통해 별도 공시합니다.
+
+제18조 (보안관리)
+  ① “이용기관”은 “은행”에서 제시하는 보안 기준을 준수하여야 하고, “은행”은 “이용기관”의 전산시스템에 대하여 각 호의 사항을 점검 요청할 수 있습니다.
+    1. 개인정보 및 금융정보 암호화 운영현황
+    2. 해킹 등에 대비한 정책사항
+    3. 시스템 운영에 대한 정보보호 체계 등
+  ② “이용기관”은 “서비스” 이용과 관련하여 감독 당국에서 관련 자료 또는 감독을 요청하면 이에 대하여 적극적으로 협조하여야 합니다.
+  ③ “이용기관”의 “서비스” 이용에 대한 고객 정보 관리책임은 “이용기관”에게 있으며, “이용기관”의 전산시스템에 대한 해킹 또는 외부의 네트워크 공격 등 위험이 발생한 경우에는 즉시 “은행”에 이를 통지하고, 본 “서비스”의 이용을 중단하여야 합니다.
+
+제19조 (기밀유지)
+  ① “은행”과 “이용기관”은 “서비스”와 관련되거나 상호정보교환 등 업무처리 과정에서 인지 또는 획득한 정보를 이 업무처리 이외의 목적으로 사용하거나 외부에 유출하여서는 안 됩니다.
+  ② 제1항에서 정한 의무를 위반하여 상대방 또는 제3자에게 손해가 발생한 경우, 귀책사유 있는 당사자는 상대방 또는 제3자에게 이로 인하여 발생한 손해의 일부 또는 전부를 배상하여야 합니다.
+
+제20조 (손해배상 및 면책)
+  ① “은행”은 “이용기관”으로부터 접근매체의 분실이나 도난의 통지를 받은 후에 제3자가 그 접근매체를 사용하여 “이용기관”에게 손해가 발생한 경우 그 손해를 배상합니다.
+  ② “은행”은 다음 각 1호의 사고로 인하여 “이용기관”에게 손해가 발생한 경우 그 손해를 배상합니다.
+    1. 접근매체의 위조나 변조로 발생한 사고
+    2. 계약체결 또는 거래지시의 전자적 전송이나 처리과정에서 발생한 사고
+    3. 전자금융거래를 위한 전자적 장치 또는 「정보통신망 이용촉진 및 정보보호 등에 관한 법률」 제2조 제1항 제1호에 따른 “은행”의 정보통신망에 침입하여 거짓이나 그 밖의 부정한 방법으로 획득한 접근매체의 이용으로 발생한 사고
+  ③ 제1항 및 제2항에 의하여 금전적 손해가 발생한 경우 해당 금액 및 이에 대한 1년 만기 정기예금 이율로 계산한 경과이자를 배상합니다. 다만, 손해액이 해당 금액과 1년 만기 정기예금 이율로 계산한 금액을 초과하는 경우에는 실손해액을 배상합니다.
+  ④ 제2항의 규정에도 불구하고 “은행”은 “이용기관”이 고의 또는 과실로 다음 각 호의 행위를 하여 “이용기관”에게 손해가 생기는 경우 “은행”의 고의 또는 과실이 없다면 “은행”은 그 책임의 전부 또는 일부를 지지 않습니다.
+    1. “이용기관”이 접근매체를 제3자에게 대여하거나 사용을 위임한 경우 또는 양도나 담보의 목적으로 제공한 경우(「전자금융거래법」제18조에 따라 선불전자지급수단이나 전자화폐를 양도하거나 담보로 제공한 경우를 제외합니다.)
+    2. 제3자가 권한 없이 “이용기관”의 접근매체를 이용하여 전자금융거래를 할 수 있음을 알았거나 쉽게 알 수 있었음에도 불구하고 “이용기관”이 자신의 접근매체를 누설 또는 노출하거나 방치한 경우
+    3. “은행”이 접근매체를 통하여 “이용기관”의 신원, 권한 및 거래지시의 내용 등을 확인하는 것 외에 보안강화를 위하여 전자금융거래 시 사전에 요구하는 추가적인 보안조치를 “이용기관”이 정당한 사유 없이 거부하여 사고가 발생한 경우
+    4. “이용기관”이 제3호에 따른 추가적인 보안조치에 사용되는 매체·수단 또는 정보에 대하여 다음 각 목의 어느 하나에 해당하는 행위를 하여 사고가 발생한 경우
+      가. 누설·노출 또는 방치한 행위
+      나. 제3자에게 대여하거나 그 사용을 위임한 행위 또는 양도나 담보의 목적으로 제공한 행위
+    5. 법인(「중소기업기본법」제2조 제2항에 의한 소기업을 제외합니다.)인 “이용기관”에게 손해가 발생한 경우로 “은행”이 사고를 방지하기 위하여 보안절차를 수립하고 이를 철저히 준수하는 등 합리적으로 요구되는 충분한 주의의무를 다한 경우
+
+제21조 (이의제기 및 협조)
+  ① “이용기관”은 전자금융거래의 처리에 관하여 이의가 있을 때에는 “은행”의 분쟁처리기구에 그 해결을 요구하거나 금융감독원 금융분쟁조정위원회, 한국소비자보호원 소비자분쟁조정위원회 등을 통하여 분쟁조정을 신청할 수 있습니다.
+  ② “이용기관”이 “은행”의 본점이나 영업점 또는 “은행”의 분쟁처리기구에 이의를 제기한 경우 “은행”은 15일 이내에 이에 대한 조사 또는 처리결과를 “이용기관”에게 알려야 합니다.
+  ③ “은행”은 손해배상 등 분쟁처리를 위한 분쟁처리책임자 및 담당자를 지정하고, 그 연락처를 관련 인터넷 홈페이지에 게시하여야 합니다.
+  ④ “이용기관”은 제20조 제2항에 정한 사고발생으로 인한 손해배상 등 분쟁처리와 관련한 “은행”의 사고조사 및 관계당국의 수사 또는 조사 절차에 협조하여야 합니다.
+
+제22조 (거래기록·자료의 제공)
+  ① “은행”은 “이용기관”의 요청이 있을 경우 「금융실명거래 및 비밀보장에 관한 법률」 등 다른 법률에 저촉되지 않는 범위 내에서 “은행”이 보존·관리하고 있는 전자금융거래 관련 기록·자료를 “이용기관”에게 제공하여야 합니다.
+  ② “이용기관”이 제공 요청을 할 수 있는 거래기록·자료의 범위와 대상기간은 「전자금융거래법」 제22조 제1항 및 제2항에서 정한 기록 및 기간으로 합니다.
+  ③ “이용기관”이 서면(전자문서를 제외합니다. 이하 같습니다.) 형태의 거래기록·자료(이하 “거래명세서”라 합니다.)를 제공할 것을 “은행”에 요청하는 경우에는 본인이 서면으로 영업점에 신청하여야 하며, “은행”은 신청 가능 영업점의 주소 및 전화번호 등을 인터넷 등을 통하여 “이용기관”이 알 수 있도록 게시하여야 합니다.
+  ④ “은행”은 “이용기관”으로부터 제3항에 따른 거래명세서의 제공요청을 받은 경우 2주일 이내에 “이용기관”에게 거래명세서를 교부하여야 합니다.
+  ⑤ “은행”은 불가피한 사유로 인하여 거래기록·자료(거래명세서 포함)의 제공이 불가능한 경우에는 그 사유를 “이용기관”에게 즉시 통보하여야 하며, 해당 사유가 소멸한 경우 다음 각 호에 정한 기한 내에 “이용기관”에게 확인 및 제공하여야 합니다.
+    1. 전자적 장치를 통한 제공의 경우에는 즉시
+    2. 제3항에 따른 서면 제공 방식의 경우에는 2주일 이내에 거래명세서를 교부
+
+부칙
+본 약관은 2026. 99. 99.부터 시행합니다.

djb-docs/terms/알림수신동의서.html

@@ -0,0 +1,20 @@
+<!--
+  editor-content.css 대응 프래그먼트: <!doctype>/<html>/<head>/<style> 없이 순수 태그(h1/h2/h3/p/ul/li/strong)만 사용.
+  admin Summernote 코드뷰에 그대로 붙여넣으면 됨. class/style 속성 없음 -> 붙여넣기(paste-cleaner)든
+  코드뷰 직접 입력이든 태그 정리 과정에서 잘려나갈 것이 없다.
+-->
+<h1>알림수신동의서</h1>
+<p><strong>(주)제주은행 귀중</strong></p>
+<p>귀 행의 Open API 포털에서 이용기관(귀 행과 계약을 체결한 법인) 관리자가 개발자 초대를 위하여 입력한 휴대폰 번호로 초대 안내 문자메시지(알림)를 발송하고자 하는 경우에는 「개인정보보호법」 등 관계 법령에 따라 수신자 본인의 동의가 필요합니다.</p>
+<h2>발송정보</h2>
+<ul>
+<li><strong>수집·이용 항목:</strong> 휴대폰 번호</li>
+<li><strong>발송 목적:</strong> Open API 포털 개발자 초대 안내(초대 이용기관명, 초대자명, 인증번호, 가입 진행 링크 포함) 문자메시지 발송</li>
+<li><strong>보유·이용 기간:</strong> 초대 유효기간(발송일로부터 7일) 경과 또는 초대 처리(가입 완료·취소) 시까지 보유 후 파기</li>
+</ul>
+<p>□ 동의하지 않음　　□ 동의함</p>
+<p>※ 이용기관 관리자는 본인이 입력한 휴대폰 번호의 실제 사용자로부터 위 알림 수신에 대한 동의를 사전에 받은 경우에 한하여 초대를 진행하여야 합니다.</p>
+<p>※ 동의하지 않을 경우 초대 신청(등록)은 유지되나 초대 안내 문자메시지는 발송되지 않으며, 이 경우 이용기관 관리자로부터 별도의 방법으로 초대 안내를 받아야 합니다.</p>
+<p>※ 수집된 휴대폰 번호는 문자메시지 발송 업무를 위탁받은 발송대행사에 위 목적 범위 내에서만 제공되며, 목적 외 용도로 이용되지 않습니다.</p>
+<h3>위 알림 수신에 동의하십니까?</h3>
+<p>제정일자: 2026. 99. 99. 제정</p>

djb-docs/terms/알림수신동의서.txt

@@ -0,0 +1,22 @@
+알림수신동의서
+
+(주)제주은행 귀중
+
+귀 행의 Open API 포털에서 이용기관(귀 행과 계약을 체결한 법인) 관리자가 개발자 초대를 위하여 입력한 휴대폰 번호로 초대 안내 문자메시지(알림)를 발송하고자 하는 경우에는 「개인정보보호법」 등 관계 법령에 따라 수신자 본인의 동의가 필요합니다.
+
+발송정보
+  ㄴ 수집·이용 항목: 휴대폰 번호
+  ㄴ 발송 목적: Open API 포털 개발자 초대 안내(초대 이용기관명, 초대자명, 인증번호, 가입 진행 링크 포함) 문자메시지 발송
+  ㄴ 보유·이용 기간: 초대 유효기간(발송일로부터 7일) 경과 또는 초대 처리(가입 완료·취소) 시까지 보유 후 파기
+
+    □ 동의하지 않음   □ 동의함
+
+※ 이용기관 관리자는 본인이 입력한 휴대폰 번호의 실제 사용자로부터 위 알림 수신에 대한 동의를 사전에 받은 경우에 한하여 초대를 진행하여야 합니다.
+
+※ 동의하지 않을 경우 초대 신청(등록)은 유지되나 초대 안내 문자메시지는 발송되지 않으며, 이 경우 이용기관 관리자로부터 별도의 방법으로 초대 안내를 받아야 합니다.
+
+※ 수집된 휴대폰 번호는 문자메시지 발송 업무를 위탁받은 발송대행사에 위 목적 범위 내에서만 제공되며, 목적 외 용도로 이용되지 않습니다.
+
+위 알림 수신에 동의하십니까?
+
+제정일자: 2026. 99. 99. 제정

sonar-project.properties

@@ -51,6 +51,14 @@ sonar.exclusions=\
 
 # 자동 생성 코드(MapStruct Impl, QueryDSL Q클래스)는 build/ 아래라 이미 제외된다.
 
+# Thymeleaf 인라인 표현식([[${...}]], /*[[${...}]]*/)은 JS 파서가 읽지 못해
+# "Failed to parse file ... Unexpected token" 으로 분석이 중단된다.
+# JS 분석에서만 빼고 HTML(web) 센서는 그대로 두어 템플릿 XSS 룰은 유지한다.
+# 기본값이 **/node_modules/** 이므로 재정의 시 함께 명시해야 한다.
+sonar.javascript.exclusions=\
+  **/node_modules/**,\
+  src/main/resources/templates/**
+
 # --- SCM -------------------------------------------------------------------
 # blame 기반 "새 코드" 판정을 위해 Jenkins Job 에서 shallow clone 을 쓰지 않는다.
 sonar.scm.provider=git

src/main/java/com/eactive/apim/gateway/data/statistics/repository/GwAuthClientRepository.java

@@ -22,4 +22,10 @@ public interface GwAuthClientRepository extends JpaRepository<GwAuthClient, Stri
      */
     @Query("SELECT c.clientId FROM GwAuthClient c WHERE c.orgId = :orgId")
     List<String> findClientIdsByOrgId(@Param("orgId") String orgId);
+
+    /**
+     * 다건 org 소속 CLIENTID 목록 (인덱스 페이지 전체 통계 집계용).
+     */
+    @Query("SELECT c.clientId FROM GwAuthClient c WHERE c.orgId IN :orgIds")
+    List<String> findClientIdsByOrgIdIn(@Param("orgIds") List<String> orgIds);
 }

src/main/java/com/eactive/apim/portal/apps/ReadinessController.java

@@ -5,19 +5,36 @@ import java.sql.SQLException;
 
 import javax.sql.DataSource;
 
+import org.jboss.logging.Logger;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
+import org.thymeleaf.spring5.SpringTemplateEngine;
+
+import com.google.common.util.concurrent.Futures;
 
 /**
  * Readiness probe.
  *
  * <p>Distinct from {@link HealthCheckController} (liveness — servlet alive?).
  * This endpoint validates both EMS and Gateway datasources via JDBC
- * {@code Connection.isValid(timeout)} to confirm the app is ready to serve
+ * {@code Connection.isValid(timeout)}, plus three libraries that WebLogic's
- * requests that depend on the database.
+ * oracle_common bundles at a different version from this app (see weblogic.xml
+ * {@code prefer-application-packages}): Thymeleaf's {@link SpringTemplateEngine}
+ * (jackson), jboss-logging, and Guava.
+ *
+ * <p>These exist because this controller bypasses view resolution entirely
+ * (plain {@code @RestController} JSON) — a classpath split between the app's
+ * copy and WebLogic's bundled copy of a preferred package can throw
+ * {@link LinkageError}/{@link java.util.ServiceConfigurationError} only on the
+ * real code paths that touch it, while this probe kept reporting 200. That
+ * already happened once for jackson (Thymeleaf's dialect/module discovery
+ * failed on every real page while /health/ready stayed green) — jboss-logging
+ * and Guava carry the same risk (confirmed version mismatch against
+ * oracle_common, not yet observed failing in production) so they get the same
+ * kind of forced-touch check here.
  *
  * <p>HTTP 200 + JSON when all checks pass.
  * <p>HTTP 503 + JSON when any check fails — body still includes the per-component
@@ -30,24 +47,34 @@ public class ReadinessController {
 
     private final DataSource portalDataSource;
     private final DataSource gatewayDataSource;
+    private final SpringTemplateEngine templateEngine;
 
     public ReadinessController(
             @Qualifier("portalDataSource") DataSource portalDataSource,
-            @Qualifier("gatewayDataSource") DataSource gatewayDataSource) {
+            @Qualifier("gatewayDataSource") DataSource gatewayDataSource,
+            SpringTemplateEngine templateEngine) {
         this.portalDataSource = portalDataSource;
         this.gatewayDataSource = gatewayDataSource;
+        this.templateEngine = templateEngine;
     }
 
     @GetMapping(value = "/health/ready", produces = MediaType.APPLICATION_JSON_VALUE)
     public ResponseEntity<String> ready() {
-        String ems = check(portalDataSource);
+        String ems     = check(portalDataSource);
-        String gw  = check(gatewayDataSource);
+        String gw      = check(gatewayDataSource);
-        boolean ok = "UP".equals(ems) && "UP".equals(gw);
+        String view    = checkTemplateEngine();
+        String logging = checkJbossLogging();
+        String guava   = checkGuava();
+        boolean ok = "UP".equals(ems) && "UP".equals(gw) && "UP".equals(view)
+                && "UP".equals(logging) && "UP".equals(guava);
 
         String body = "{"
-                + "\"status\":\"" + (ok ? "UP" : "DOWN") + "\","
+                + "\"status\":\""  + (ok ? "UP" : "DOWN") + "\","
-                + "\"ems\":\""    + ems + "\","
+                + "\"ems\":\""     + ems     + "\","
-                + "\"gateway\":\""+ gw  + "\""
+                + "\"gateway\":\"" + gw      + "\","
+                + "\"view\":\""    + view    + "\","
+                + "\"logging\":\"" + logging + "\","
+                + "\"guava\":\""   + guava   + "\""
                 + "}";
 
         return ResponseEntity.status(ok ? 200 : 503)
@@ -55,6 +82,49 @@ public class ReadinessController {
                 .body(body);
     }
 
+    /** {@code getConfiguration()} lazily runs Thymeleaf's dialect/module init on first call
+     *  and caches it — so this is cheap once healthy, and reproduces the exact failure path
+     *  a real page render would hit. Catches {@link Throwable}: init failures here have
+     *  surfaced as {@link Error} (ServiceConfigurationError), not just Exception. */
+    private String checkTemplateEngine() {
+        try {
+            templateEngine.getConfiguration();
+            return "UP";
+        } catch (Throwable t) {
+            return down(t);
+        }
+    }
+
+    /** Forces jboss-logging's {@code Logger} + its bound provider (LogManager/JBoss/JUL
+     *  discovery) to load and actually run a log-level check, not just resolve the class. */
+    private static String checkJbossLogging() {
+        try {
+            Logger log = Logger.getLogger(ReadinessController.class);
+            log.isDebugEnabled();
+            return "UP";
+        } catch (Throwable t) {
+            return down(t);
+        }
+    }
+
+    /** {@code Futures.immediateFuture} touches Guava's {@code util.concurrent} machinery
+     *  (AbstractFuture/InternalFutureFailureAccess) — the part backed by the separate
+     *  {@code failureaccess} jar, which is exactly where an app/WebLogic version mismatch
+     *  would split across classloaders. */
+    private static String checkGuava() {
+        try {
+            Futures.immediateFuture(Boolean.TRUE).isDone();
+            return "UP";
+        } catch (Throwable t) {
+            return down(t);
+        }
+    }
+
+    private static String down(Throwable t) {
+        String msg = t.getMessage() == null ? t.getClass().getSimpleName() : t.getMessage();
+        return "DOWN:" + msg.replace('"', '\'').replace('\n', ' ').replace('\r', ' ');
+    }
+
     private static String check(DataSource ds) {
         if (ds == null) return "DOWN:NO_DATASOURCE";
         try (Connection c = ds.getConnection()) {

src/main/java/com/eactive/apim/portal/apps/apis/controller/ApiController.java

@@ -15,6 +15,10 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.ui.ModelMap;
@@ -79,12 +83,17 @@ public class ApiController {
     }
 
     @GetMapping
-    public String apiList(@ModelAttribute ApiGroupSearch search, Model model) {
+    public String apiList(@ModelAttribute ApiGroupSearch search, @PageableDefault Pageable pageable, Model model) {
         Map<String, Object> searchResult = apiSearchFacade.searchApis(search);
 
+        @SuppressWarnings("unchecked")
+        List<ApiSpecInfoDto> allApis = (List<ApiSpecInfoDto>) searchResult.get("apis");
+        Page<ApiSpecInfoDto> apiPage = slicePage(allApis, pageable);
+
         model.addAttribute("search", search);
         model.addAttribute("services", searchResult.get("services"));
-        model.addAttribute("apis", searchResult.get("apis"));
+        model.addAttribute("apis", apiPage.getContent());
+        model.addAttribute("page", apiPage);
         model.addAttribute("totalApiCount", searchResult.get("totalApiCount"));
         model.addAttribute("selectedApiCount", searchResult.get("selectedApiCount"));
         model.addAttribute("selected", search.getGroupIds().size() > 0 ? search.getGroupIds().get(0) : "-1");
@@ -94,6 +103,19 @@ public class ApiController {
         return "apps/apis/mainApiList";
     }
 
+    /**
+     * apiSearchFacade.searchApis() 는 다른 소비처(API Status 필터 목록 등)와 계약을 공유하므로
+     * 항상 전체 List 를 돌려준다. 목록 화면 렌더링에서만 결과를 잘라 Page 로 감싼다.
+     */
+    private Page<ApiSpecInfoDto> slicePage(List<ApiSpecInfoDto> apis, Pageable pageable) {
+        int total = apis == null ? 0 : apis.size();
+        int fromIndex = Math.min(pageable.getPageNumber() * pageable.getPageSize(), total);
+        int toIndex = Math.min(fromIndex + pageable.getPageSize(), total);
+        List<ApiSpecInfoDto> content = total == 0 ? new ArrayList<>() : apis.subList(fromIndex, toIndex);
+
+        return new PageImpl<>(content, pageable, total);
+    }
+
     @GetMapping("/testbed/api")
     public String testbedByApi(@RequestParam(value = "id", required = false) String id, Model model) {
         // 테스트베드는 로그인한 사용자만 접근 가능. 미인증 시 사유와 함께 로그인 페이지로 유도.

src/main/java/com/eactive/apim/portal/apps/apis/dto/ApiSpecInfoDto.java

@@ -46,4 +46,6 @@ public class ApiSpecInfoDto {
     private String displayRoleCode;
 
     private String apiGroupName;
+
+    private String apiGroupId;
 }

src/main/java/com/eactive/apim/portal/apps/apis/service/ApiSearchFacadeImpl.java

@@ -115,7 +115,9 @@ public class ApiSearchFacadeImpl implements ApiSearchFacade {
         filteredApis.forEach(api -> {
             ApiServiceDTO service = apiData.getServicesByApiId().get(api.getApiId());
             if (service != null) {
-                api.setMainIcon(service.getMainIcon());
+                // mainIcon(CLOB, base64)은 카드 수만큼 복제하지 않는다. 렌더링은
+                // apiGroupId 기준 /api-services/{id}/icon 스트리밍 엔드포인트를 사용한다.
+                api.setApiGroupId(service.getId());
                 api.setApiGroupName(service.getGroupName());
             }
         });

src/main/java/com/eactive/apim/portal/apps/apiservice/controller/ApiServiceController.java

@@ -5,8 +5,17 @@ import com.eactive.apim.portal.apps.apiservice.dto.ApiServiceDTO;
 import com.eactive.apim.portal.apps.apiservice.dto.ApiServiceTabInfo;
 import com.eactive.apim.portal.apps.apiservice.service.ApiServiceService;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import lombok.RequiredArgsConstructor;
+import org.springframework.http.CacheControl;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -20,6 +29,10 @@ import org.springframework.web.servlet.ModelAndView;
 @RequiredArgsConstructor
 public class ApiServiceController {
 
+    // ApiGroup.mainIcon 은 "data:image/png;base64,...." 형태의 Data URL 문자열 그대로 저장돼 있다.
+    private static final Pattern DATA_URL_PATTERN = Pattern.compile("^data:(image/[a-zA-Z0-9+.-]+);base64,(.+)$", Pattern.DOTALL);
+    private static final String DEFAULT_ICON_PATH = "/img/api_icon_default.png";
+
     private final ApiServiceService apiServiceService;
 
 
@@ -52,4 +65,28 @@ public class ApiServiceController {
 
         return "apps/apiservice/apiServiceDetail";
     }
+
+    /**
+     * API 그룹 아이콘 스트리밍. mainIcon(CLOB, Data URL 문자열)을 그대로 HTML에 인라인하면
+     * 카드 개수만큼 반복 전송돼 응답 용량이 폭증하므로, 그룹 id 당 1회만 내려주고
+     * 브라우저 캐시로 재사용시킨다.
+     */
+    @GetMapping("/{id}/icon")
+    public ResponseEntity<byte[]> icon(@PathVariable String id) {
+        String mainIcon = apiServiceService.getMainIcon(id);
+        Matcher matcher = mainIcon == null ? null : DATA_URL_PATTERN.matcher(mainIcon);
+
+        if (matcher == null || !matcher.matches()) {
+            return ResponseEntity.status(HttpStatus.FOUND)
+                .header(HttpHeaders.LOCATION, DEFAULT_ICON_PATH)
+                .build();
+        }
+
+        byte[] imageBytes = Base64.getDecoder().decode(matcher.group(2));
+
+        return ResponseEntity.ok()
+            .contentType(MediaType.parseMediaType(matcher.group(1)))
+            .cacheControl(CacheControl.maxAge(1, TimeUnit.DAYS).cachePublic())
+            .body(imageBytes);
+    }
 }

src/main/java/com/eactive/apim/portal/apps/apiservice/service/ApiServiceService.java

@@ -22,8 +22,19 @@ import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+/**
+ * API 그룹(전시) 조회 서비스.
+ *
+ * <p>주 조회 대상 {@link ApiGroup} 은 <b>AGW(게이트웨이) 데이터소스</b> 엔티티라
+ * 트랜잭션 매니저를 {@code gatewayTransactionManager} 로 지정한다. 기본
+ * {@code transactionManager}(EMS) 를 쓰면 게이트웨이 EntityManager 가 리포지토리 호출 단위로
+ * 닫혀 {@code ApiGroup.apiGroupApiList} 지연 로딩에서 LazyInitializationException 이 난다.</p>
+ *
+ * <p>내부에서 호출하는 {@code ApiSpecInfoService} 는 EMS 쪽이며 자체 {@code @Transactional}
+ * (기본 매니저)로 독립 트랜잭션을 연다. {@code ApiSpecInfo} 에는 지연 연관이 없어 문제되지 않는다.</p>
+ */
 @Service("apiServiceService")
-@Transactional
+@Transactional("gatewayTransactionManager")
 @RequiredArgsConstructor
 @Slf4j
 public class ApiServiceService {
@@ -109,5 +120,14 @@ public class ApiServiceService {
             .orElse(null);
     }
 
+    /**
+     * 그룹 아이콘(mainIcon)만 가볍게 조회. {@link #getApiGroupById} 는 apiGroupApiList 까지
+     * 함께 로드해 무거우므로, 아이콘 스트리밍 엔드포인트 전용으로 CLOB 값만 꺼낸다.
+     */
+    public String getMainIcon(String id) {
+        return apiServiceRepository.findById(id)
+            .map(ApiGroup::getMainIcon)
+            .orElse(null);
+    }
 
 }

src/main/java/com/eactive/apim/portal/apps/apiservice/service/ApiSpecService.java

@@ -36,6 +36,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.Strings;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -155,10 +156,10 @@ public class ApiSpecService {
             updateReferences(pathItem, apiId);
 
             String tmpFullPath = StringUtils.isNotEmpty(basePath)
-                ? StringUtils.join(basePath, "/", StringUtils.removeStart(path, "/"))
+                ? StringUtils.join(basePath, "/", Strings.CS.removeStart(path, "/"))
                 : path;
 
-            final String fullPath = StringUtils.replacePattern(tmpFullPath, "//+", "/");
+            final String fullPath = tmpFullPath.replaceAll("//+", "/");
 
             // HTTP 메소드별로 중복 체크
             pathItem.readOperationsMap().forEach((httpMethod, operation) -> {
@@ -294,7 +295,7 @@ public class ApiSpecService {
             return StringUtils.EMPTY;
         }
         Server server = api.getServers().get(0);
-        return StringUtils.removeEnd(server.getUrl(), "/");
+        return Strings.CS.removeEnd(server.getUrl(), "/");
     }
 
     private void mergeComponents(OpenAPI currentAPI, String apiId, String apiName, Map<String, Object> mergedComponents, ObjectMapper objectMapper) {

src/main/java/com/eactive/apim/portal/apps/app/service/AdminGatewayClient.java

@@ -37,7 +37,7 @@ public class AdminGatewayClient {
         String baseUrl = portalPropertyService.getOrCreateProperty(
             PROP_GROUP, PROP_ADMIN_BASE_URL, DEFAULT_ADMIN_BASE_URL, "admin(관리자포털) 내부 API base URL");
 
-        String url = baseUrl.replaceAll("/+$", "") + CLIENT_BLOCK_PATH;
+        String url = stripTrailingSlashes(baseUrl) + CLIENT_BLOCK_PATH;
 
         // 네트워크/HTTP 오류는 RestTemplate 이 예외로 던진다.
         ResponseEntity<Map> response = restTemplate.postForEntity(url, null, Map.class, clientId);
@@ -51,4 +51,18 @@ public class AdminGatewayClient {
 
         log.info("admin GW 차단/리로드 위임 성공 - clientId={}", clientId);
     }
+
+    /**
+     * base URL 끝의 {@code '/'} 를 모두 걷어낸다.
+     *
+     * <p>{@code replaceAll("/+$", "")} 은 백트래킹으로 super-linear 가 될 수 있어(Sonar S5852)
+     * 선형 스캔으로 대체했다. 동작은 동일하다.</p>
+     */
+    private static String stripTrailingSlashes(String url) {
+        int end = url.length();
+        while (end > 0 && url.charAt(end - 1) == '/') {
+            end--;
+        }
+        return url.substring(0, end);
+    }
 }

src/main/java/com/eactive/apim/portal/apps/approval/service/ApprovalService.java

@@ -41,7 +41,13 @@ public class ApprovalService {
             approval.setApprovalType(ApprovalType.APP);
             approval.setTargetId(request.getId());
             approval.setRequester(SecurityUtil.getPortalAuthenticatedUser());
-            approval.setApprovalSubject("[" + request.getOrg().getOrgName() + "] " + request.getType().getDescription() + " 승인");
+            // 동일 법인의 신규/변경/해지 요청이 관리자 목록에서 같은 제목으로 보이면 대상 식별이 불가능하다.
+            // 클라이언트 이름을 제목에 포함해 운영자와 E2E 모두 정확한 승인 건을 검색할 수 있게 한다.
+            String clientName = request.getClientName();
+            String clientNamePart = clientName == null || clientName.trim().isEmpty()
+                ? "" : " [" + clientName.trim() + "]";
+            approval.setApprovalSubject("[" + request.getOrg().getOrgName() + "]" + clientNamePart
+                + " " + request.getType().getDescription() + " 승인");
 
             for (PortalApprovalLineUser user : optLine.get().getPortalApprovalLineUsers()) {
                 this.addApprover(approval, user.getUser(), user.getApprovalOrder());

src/main/java/com/eactive/apim/portal/apps/auth/AuthNoticeProperties.java

@@ -2,8 +2,6 @@ package com.eactive.apim.portal.apps.auth;
 
 import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
 import lombok.RequiredArgsConstructor;
-import org.springframework.core.env.Environment;
-import org.springframework.core.env.Profiles;
 import org.springframework.stereotype.Component;
 
 /**
@@ -12,10 +10,18 @@ import org.springframework.stereotype.Component;
  * <p>그룹 {@code Portal}, 키 {@code auth.test-notice.enabled}(true/false). 값이 참이면 인증 요청
  * 응답에 인증번호를 실어 화면에 노출한다(실제 발송 대신 테스트 확인 용도). 기존 application.yml
  * {@code portal.test-auth-notice-enabled} 설정을 DB PTL_PROPERTY 로 이전한 것으로,
- * {@link TwoFactorProperties} 와 동일한 {@code getOrCreateProperty} 패턴을 따른다.</p>
+ * {@link com.eactive.apim.portal.apps.auth.twofactor.TwoFactorProperties} 와 동일한
+ * {@code getOrCreateProperty} 패턴을 따른다.</p>
  *
- * <p><b>prod 프로파일에서는 DB 값과 무관하게 항상 false</b> 를 반환한다(운영 환경 인증번호 노출 금지).
+ * <p><b>운영(prod)에서도 DB 값만으로 켤 수 있다.</b> 대신 종료일
- * 세션 keepalive 등 다른 비운영 전용 스위치와 동일한 정책이다.</p>
+ * {@code auth.test-notice.prod-until}({@code yyyy-MM-dd})을 함께 지정해야 하며, 날짜가 지나면
+ * {@link TestNoticeWindow} 가 자동으로 닫는다. 종료일 미설정/형식 오류면 운영에서는 열리지 않는다.
+ * 운영 오픈 전 UMS 실발송 미연계 기간을 위한 한시 스위치다.</p>
+ *
+ * <p>이 판정은 {@link com.eactive.apim.portal.common.breadcrumb.GlobalControllerAdvice} 의
+ * {@code @ModelAttribute} 에서 <b>모든 페이지 요청마다</b> 호출된다. PortalPropertyService 에 캐시가
+ * 없어 호출마다 DB 조회가 발생하므로 {@value #CACHE_TTL_MILLIS}ms 짧은 캐시를 둔다.
+ * PTL_PROPERTY 를 바꾸면 최대 그 시간만큼 반영이 늦다.</p>
  */
 @Component
 @RequiredArgsConstructor
@@ -23,21 +29,45 @@ public class AuthNoticeProperties {
 
     public static final String GROUP = "Portal";
     public static final String KEY_TEST_NOTICE_ENABLED = "auth.test-notice.enabled";
+    public static final String KEY_TEST_NOTICE_PROD_UNTIL = "auth.test-notice.prod-until";
+
+    /** 판정 결과 캐시 유효시간(ms) */
+    static final long CACHE_TTL_MILLIS = 30_000L;
 
     private final PortalPropertyService portalPropertyService;
-    private final Environment environment;
+    private final TestNoticeWindow testNoticeWindow;
+
+    private volatile boolean cachedEnabled;
+    /** 캐시 갱신 시각(ms). 0 이면 미조회 */
+    private volatile long cachedAt;
 
     /**
      * 인증 요청 응답에 인증번호를 실어 UI 에 노출할지 여부(개발/테스트 전용).
-     * prod 환경에서는 property 값과 무관하게 항상 false.
+     * 운영에서는 종료일({@link #KEY_TEST_NOTICE_PROD_UNTIL})까지만 참이 된다.
      */
     public boolean isTestNoticeEnabled() {
-        if (environment.acceptsProfiles(Profiles.of("prod"))) {
+        long now = System.currentTimeMillis();
+        long at = cachedAt;
+        if (at != 0L && now - at < CACHE_TTL_MILLIS) {
+            return cachedEnabled;
+        }
+        boolean enabled = resolveEnabled();
+        cachedEnabled = enabled;
+        cachedAt = now;
+        return enabled;
+    }
+
+    private boolean resolveEnabled() {
+        // 기본값 false - row 가 없는 환경(신규 운영 DB 등)에서 자동으로 켜지지 않도록 한다.
+        String value = portalPropertyService.getOrCreateProperty(
+                GROUP, KEY_TEST_NOTICE_ENABLED, "false",
+                "인증(이메일/SMS) 요청 시 인증번호를 화면에 표시할지 여부 (true/false, 테스트 전용)");
+        if (value == null || !"true".equalsIgnoreCase(value.trim())) {
             return false;
         }
-        String value = portalPropertyService.getOrCreateProperty(
+        String until = portalPropertyService.getOrCreateProperty(
-                GROUP, KEY_TEST_NOTICE_ENABLED, "true",
+                GROUP, KEY_TEST_NOTICE_PROD_UNTIL, TestNoticeWindow.UNSET,
-                "인증(이메일/SMS) 요청 시 인증번호를 화면에 표시할지 여부 (true/false, 테스트 전용)");
+                "운영(prod)에서 인증번호 화면 표시를 허용할 종료일 (yyyy-MM-dd, 미사용은 none). 경과 시 자동 차단");
-        return value != null && "true".equalsIgnoreCase(value.trim());
+        return testNoticeWindow.isOpen(until, KEY_TEST_NOTICE_ENABLED);
     }
 }

src/main/java/com/eactive/apim/portal/apps/auth/TestNoticeWindow.java

@@ -0,0 +1,74 @@
+package com.eactive.apim.portal.apps.auth;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+
+/**
+ * 인증번호 화면 노출(테스트 안내) 스위치의 <b>운영 환경 사용 기한</b> 판정기.
+ *
+ * <p>운영 오픈 전에는 UMS/EAI 실발송 연계가 끝나지 않아 인증번호가 실제로 도달하지 않을 수 있다.
+ * 이 기간에는 prod 에서도 인증번호를 화면에 노출해야 테스트가 가능하다. 다만 스위치 끄기를 잊으면
+ * 인증번호가 상시 노출되므로, prod 에서는 <b>종료일을 명시한 경우에만</b> 열어 주고 그 날짜가 지나면
+ * PTL_PROPERTY 값과 무관하게 자동으로 닫는다.</p>
+ *
+ * <ul>
+ *   <li>비운영(!prod) — 항상 열림. 종료일을 보지 않는다.</li>
+ *   <li>운영(prod) — 종료일이 없거나 형식이 잘못되면 <b>닫힘</b>(fail-safe). 종료일 당일까지 열림.</li>
+ * </ul>
+ *
+ * <p>이메일/휴대폰 인증({@link AuthNoticeProperties})과 2차 인증
+ * ({@code TwoFactorProperties})이 같은 규칙을 쓰도록 판정을 이 클래스로 모은다.
+ * 종료일 프로퍼티 값은 {@code yyyy-MM-dd} 형식이며, 미설정을 뜻하는 기본값은 {@value #UNSET}
+ * ({@code PTL_PROPERTY.property_value} 가 NOT NULL 이라 빈 문자열을 기본값으로 쓸 수 없다).</p>
+ */
+@Component
+@Slf4j
+public class TestNoticeWindow {
+
+    /** 종료일 미설정을 뜻하는 기본값. prod 에서는 이 값이면 닫힘 */
+    public static final String UNSET = "none";
+
+    private final Environment environment;
+
+    public TestNoticeWindow(Environment environment) {
+        this.environment = environment;
+    }
+
+    /**
+     * @param untilValue 종료일 문자열({@code yyyy-MM-dd}). PTL_PROPERTY 값 원본
+     * @param subject    로그 식별용 스위치 이름
+     * @return 지금 인증번호를 화면에 노출해도 되는 기간인지 여부
+     */
+    public boolean isOpen(String untilValue, String subject) {
+        if (!environment.acceptsProfiles(Profiles.of("prod"))) {
+            return true;
+        }
+        LocalDate until = parseDate(untilValue);
+        if (until == null) {
+            return false;
+        }
+        if (LocalDate.now().isAfter(until)) {
+            return false;
+        }
+        // 운영에서 인증번호가 화면에 노출되는 상태 - 흔적을 남긴다.
+        log.warn("운영 환경 인증번호 노출 활성 상태 - {} (종료일 {})", subject, until);
+        return true;
+    }
+
+    private static LocalDate parseDate(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            return null;
+        }
+        try {
+            return LocalDate.parse(value.trim());
+        } catch (DateTimeParseException e) {
+            log.warn("인증번호 노출 종료일 형식 오류(yyyy-MM-dd 필요) - {}", value);
+            return null;
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/apps/auth/service/ApiPermissionFilter.java

@@ -64,33 +64,36 @@ public class ApiPermissionFilter {
             .collect(Collectors.toList());
     }
 
-    private static boolean checkServicePermissions(ApiServiceDTO spec, boolean isAuthenticated,
+    /**
+     * org 축과 role 축은 각자 독립적으로 선택적 제한이다(비어있으면 그 축은 통과) — 둘을 AND로 합친다.
+     * (과거 OR 합성은 한쪽 축이 비어있으면 그 축이 무조건 true가 되어 다른 쪽 제한을 무력화시키는
+     * 결함이 있었다 — 예: displayOrg 만 설정하고 displayRoleCode 를 비워두면 roleMatch 가 로그인
+     * 여부만으로 true 가 되어 조직 제한이 사실상 적용되지 않았다.)
+     */
+    static boolean checkServicePermissions(ApiServiceDTO spec, boolean isAuthenticated,
         String org, String roleCode) {
         if (!isAuthenticated) {
             return (spec.getDisplayOrg() == null || spec.getDisplayOrg().isEmpty()) && (spec.getDisplayRoleCode() == null || spec.getDisplayRoleCode().isEmpty());
         }
 
-        boolean orgMatch = org != null && (spec.getDisplayOrg() == null ||
+        boolean orgOk = spec.getDisplayOrg() == null || spec.getDisplayOrg().isEmpty()
-            spec.getDisplayOrg().isEmpty() ||
+            || (org != null && spec.getDisplayOrg().contains(org));
-            spec.getDisplayOrg().contains(org));
+        boolean roleOk = spec.getDisplayRoleCode() == null || spec.getDisplayRoleCode().isEmpty()
-        boolean roleMatch = roleCode != null && (spec.getDisplayRoleCode() == null ||
+            || (roleCode != null && spec.getDisplayRoleCode().contains(roleCode));
-            spec.getDisplayRoleCode().isEmpty() ||
+        return orgOk && roleOk;
-            spec.getDisplayRoleCode().contains(roleCode));
-        return orgMatch || roleMatch;
     }
 
-    private static boolean checkApiPermissions(ApiSpecInfoDto spec, boolean isAuthenticated,
+    /** {@link #checkServicePermissions} 와 동일 규칙(중복 유지 — 대상 DTO 타입만 다름). */
+    static boolean checkApiPermissions(ApiSpecInfoDto spec, boolean isAuthenticated,
         String org, String roleCode) {
         if (!isAuthenticated) {
             return (spec.getDisplayOrg() == null || spec.getDisplayOrg().isEmpty()) && (spec.getDisplayRoleCode() == null || spec.getDisplayRoleCode().isEmpty());
         }
 
-        boolean orgMatch = org != null && (spec.getDisplayOrg() == null ||
+        boolean orgOk = spec.getDisplayOrg() == null || spec.getDisplayOrg().isEmpty()
-            spec.getDisplayOrg().isEmpty() ||
+            || (org != null && spec.getDisplayOrg().contains(org));
-            spec.getDisplayOrg().contains(org));
+        boolean roleOk = spec.getDisplayRoleCode() == null || spec.getDisplayRoleCode().isEmpty()
-        boolean roleMatch = roleCode != null && (spec.getDisplayRoleCode() == null ||
+            || (roleCode != null && spec.getDisplayRoleCode().contains(roleCode));
-            spec.getDisplayRoleCode().isEmpty() ||
+        return orgOk && roleOk;
-            spec.getDisplayRoleCode().contains(roleCode));
-        return orgMatch || roleMatch;
     }
 }

src/main/java/com/eactive/apim/portal/apps/auth/service/AuthNumberServiceImpl.java

@@ -10,6 +10,7 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.time.Duration;
 import java.time.LocalDateTime;
 
 @Service
@@ -104,9 +105,15 @@ public class AuthNumberServiceImpl implements AuthNumberService {
     private void validateResendTime(String recipientKey) {
         storage.getAuthNumber(recipientKey).ifPresent(existingAuth -> {
             LocalDateTime now = LocalDateTime.now();
-            if (existingAuth.getExpiresAt().minusSeconds(authNumberExpirationTime)
+            LocalDateTime resendAvailableAt = existingAuth.getExpiresAt()
-                .plusSeconds(resendLimitSeconds).isAfter(now)) {
+                .minusSeconds(authNumberExpirationTime)
-                throw new AuthNumberException("잠시 후에 다시 시도해 주세요.");
+                .plusSeconds(resendLimitSeconds);
+            if (resendAvailableAt.isAfter(now)) {
+                long remainingMillis = Duration.between(now, resendAvailableAt).toMillis();
+                long remainingSeconds = Math.max(1L, (remainingMillis + 999L) / 1000L);
+                throw new AuthNumberException(
+                    String.format("인증번호 재발송 제한이 적용 중입니다. %d초 후 다시 시도해 주세요.",
+                        remainingSeconds));
             }
         });
     }

src/main/java/com/eactive/apim/portal/apps/auth/twofactor/StepUpPasswordController.java

@@ -1,6 +1,8 @@
 package com.eactive.apim.portal.apps.auth.twofactor;
 
 import com.eactive.apim.portal.apps.user.facade.UserFacade;
+import com.eactive.apim.portal.common.security.PasswordConfirmFailureTracker;
+import com.eactive.apim.portal.common.security.PasswordConfirmFailureTracker.Outcome;
 import com.eactive.apim.portal.common.util.SecurityUtil;
 import lombok.RequiredArgsConstructor;
 import org.springframework.security.access.annotation.Secured;
@@ -11,6 +13,8 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 
 /**
@@ -30,6 +34,7 @@ public class StepUpPasswordController {
 
     private final UserFacade userFacade;
     private final TwoFactorService twoFactorService;
+    private final PasswordConfirmFailureTracker passwordConfirmFailureTracker;
 
     @GetMapping("/password")
     public String page(@RequestParam(required = false) String returnUrl, Model model) {
@@ -44,7 +49,8 @@ public class StepUpPasswordController {
     @PostMapping("/password")
     public String verify(@RequestParam String currentPassword,
                          @RequestParam(required = false) String returnUrl,
-                         HttpSession session, Model model) {
+                         HttpSession session, HttpServletRequest request, HttpServletResponse response,
+                         Model model) {
         String path = pathOf(returnUrl);
         if (!StepUpProtectedPaths.isPasswordGated(path)) {
             return "redirect:/";
@@ -52,12 +58,21 @@ public class StepUpPasswordController {
 
         String loginId = SecurityUtil.getCurrentLoginId();
         if (userFacade.verifyCurrentPassword(loginId, currentPassword)) {
-            // 확인 성공 → 해당 경로 통과권 발급 후 원경로(화이트리스트 경로)로만 복귀
+            // 확인 성공 → 실패 카운트 초기화, 해당 경로 통과권 발급 후 원경로(화이트리스트 경로)로만 복귀
+            passwordConfirmFailureTracker.reset(session);
             twoFactorService.grantStepUpPass(session, path);
             return "redirect:" + path;
         }
 
-        model.addAttribute("error", "현재 비밀번호가 일치하지 않습니다.");
+        // 연속 실패 카운트 증가. 임계치 초과 시 정책(로그아웃/계정 차단)에 따라 조치한다(무차별 대입 방어).
+        Outcome outcome = passwordConfirmFailureTracker.recordFailure(session, request, response);
+        if (outcome.isForcedLogout()) {
+            return outcome.isAccountLocked()
+                ? "redirect:/login?pwFailExceeded=1&locked=1"
+                : "redirect:/login?pwFailExceeded=1";
+        }
+
+        model.addAttribute("error", outcome.getMessage());
         model.addAttribute("returnUrl", path);
         return "apps/auth/stepupPassword";
     }

src/main/java/com/eactive/apim/portal/apps/auth/twofactor/TwoFactorProperties.java

@@ -1,5 +1,6 @@
 package com.eactive.apim.portal.apps.auth.twofactor;
 
+import com.eactive.apim.portal.apps.auth.TestNoticeWindow;
 import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
 import com.eactive.apim.portal.portaluser.entity.PortalUserEnums.RoleCode;
 import lombok.RequiredArgsConstructor;
@@ -25,9 +26,11 @@ public class TwoFactorProperties {
     public static final String KEY_TTL_SECONDS = "two-factor.ttl.seconds";
     public static final String KEY_ATTEMPT_LIMIT = "two-factor.attempt.limit";
     public static final String KEY_TEST_NOTICE_ENABLED = "two-factor.test-notice.enabled";
+    public static final String KEY_TEST_NOTICE_PROD_UNTIL = "two-factor.test-notice.prod-until";
     public static final String KEY_STEPUP_ENABLED = "two-factor.stepup.enabled";
 
     private final PortalPropertyService portalPropertyService;
+    private final TestNoticeWindow testNoticeWindow;
 
     /** 로그인 2FA 활성화 여부 */
     public boolean isLoginEnabled() {
@@ -91,9 +94,21 @@ public class TwoFactorProperties {
         return parseInt(resolve(KEY_ATTEMPT_LIMIT, "5", "2차 인증번호 검증 시도 한도"), 5);
     }
 
-    /** 팝업에 테스트용 인증번호를 노출할지 여부(개발/테스트 전용) */
+    /**
+     * 팝업에 테스트용 인증번호를 노출할지 여부(개발/테스트 전용).
+     *
+     * <p>운영(prod)에서는 종료일 {@link #KEY_TEST_NOTICE_PROD_UNTIL}({@code yyyy-MM-dd})을 함께
+     * 지정한 경우에만 참이 되고, 날짜가 지나면 {@link TestNoticeWindow} 가 자동으로 닫는다.
+     * 종료일 미설정/형식 오류면 운영에서는 열리지 않는다. 이메일/휴대폰 인증
+     * ({@code auth.test-notice.*})과 동일한 규칙이다.</p>
+     */
     public boolean isTestNoticeEnabled() {
-        return parseBool(resolve(KEY_TEST_NOTICE_ENABLED, "false", "2차 인증 팝업에 테스트용 인증번호 표시 여부 (true/false)"));
+        if (!parseBool(resolve(KEY_TEST_NOTICE_ENABLED, "false", "2차 인증 팝업에 테스트용 인증번호 표시 여부 (true/false)"))) {
+            return false;
+        }
+        String until = resolve(KEY_TEST_NOTICE_PROD_UNTIL, TestNoticeWindow.UNSET,
+            "운영(prod)에서 2차 인증번호 화면 표시를 허용할 종료일 (yyyy-MM-dd, 미사용은 none). 경과 시 자동 차단");
+        return testNoticeWindow.isOpen(until, KEY_TEST_NOTICE_ENABLED);
     }
 
     private String resolve(String key, String defaultValue, String description) {

src/main/java/com/eactive/apim/portal/apps/community/partnership/controller/PartnershipApplicationController.java

@@ -2,6 +2,8 @@ package com.eactive.apim.portal.apps.community.partnership.controller;
 
 import com.eactive.apim.portal.apps.community.partnership.dto.PartnershipApplicationDTO;
 import com.eactive.apim.portal.apps.community.partnership.service.PartnershipApplicationFacade;
+import com.eactive.apim.portal.common.security.WriteRateLimitService;
+import com.eactive.apim.portal.common.security.WriteRateLimitService.WriteTarget;
 import com.eactive.apim.portal.common.util.SecurityUtil;
 import com.eactive.apim.portal.common.util.UserTypeUtil;
 import java.io.IOException;
@@ -20,10 +22,13 @@ import javax.validation.Valid;
 public class PartnershipApplicationController {
 
     private final PartnershipApplicationFacade partnershipApplicationFacade;
+    private final WriteRateLimitService writeRateLimitService;
 
     @Autowired
-    public PartnershipApplicationController(PartnershipApplicationFacade partnershipApplicationFacade){
+    public PartnershipApplicationController(PartnershipApplicationFacade partnershipApplicationFacade,
+        WriteRateLimitService writeRateLimitService){
         this.partnershipApplicationFacade = partnershipApplicationFacade;
+        this.writeRateLimitService = writeRateLimitService;
     }
 
 
@@ -52,6 +57,13 @@ public class PartnershipApplicationController {
             return "apps/community/mainPartnershipForm";
         }
 
+        // 무제한 작성 차단 — 폼 전송이라 예외 대신 flash 메시지로 되돌린다.
+        if (writeRateLimitService.isExceeded(WriteTarget.PARTNERSHIP)) {
+            redirectAttributes.addFlashAttribute("error",
+                writeRateLimitService.exceededMessage(WriteTarget.PARTNERSHIP));
+            return "redirect:/partnership";
+        }
+
         partnershipApplicationFacade.createPartnershipApplication(partnershipApplicationDTO);
 
         // 성공 메시지 추가
@@ -61,4 +73,23 @@ public class PartnershipApplicationController {
         return "redirect:/partnership";
     }
 
+    /**
+     * 본인이 작성한 피드백/개선요청 1건 삭제.
+     * 목록(최근 3건)의 삭제 버튼이 항목별 form 을 POST 한다 — 등록과 동일하게 폼 전송 + flash 메시지 방식.
+     */
+    @PostMapping("/{id}/delete")
+    public String deleteMyPartnershipApplication(@PathVariable String id, RedirectAttributes redirectAttributes) {
+        if (!SecurityUtil.isAuthenticated()) {
+            return "redirect:/login?reason=auth&redirect=/partnership";
+        }
+
+        try {
+            partnershipApplicationFacade.deleteMyApplication(id);
+            redirectAttributes.addFlashAttribute("success", "피드백/개선요청이 삭제되었습니다.");
+        } catch (IllegalArgumentException e) {
+            redirectAttributes.addFlashAttribute("error", e.getMessage());
+        }
+        return "redirect:/partnership";
+    }
+
 }

src/main/java/com/eactive/apim/portal/apps/community/partnership/repository/PartnershipApplicationRepository.java

@@ -3,9 +3,12 @@ package com.eactive.apim.portal.apps.community.partnership.repository;
 import com.eactive.apim.portal.partnershipapplication.entity.PartnershipApplication;
 import com.eactive.eai.rms.data.EMSDataSource;
 import java.util.List;
+import java.util.Optional;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
 
 @Repository
 @EMSDataSource
@@ -16,4 +19,26 @@ public interface PartnershipApplicationRepository extends JpaRepository<Partners
      * createdBy 는 PersonalDataEncryptConverter 로 결정적 암호화되므로 평문 사용자 id 로 등가 조회가 가능하다.
      */
     List<PartnershipApplication> findTop3ByCreatedByOrderByCreatedDateDesc(String createdBy);
+
+    /**
+     * 작성 빈도 제한 판정용 — 특정 작성자의 최근 글을 최신순으로 조회한다(Pageable 로 건수 제한).
+     * 등가 조회가 가능한 이유는 위와 동일하다.
+     */
+    List<PartnershipApplication> findByCreatedByOrderByCreatedDateDesc(String createdBy, Pageable pageable);
+
+    /**
+     * 본인 글 삭제용 단건 조회. id 만으로 찾지 않고 createdBy 를 함께 걸어
+     * 남의 글 id 를 넣어도 조회되지 않게 한다(소유자 검증을 쿼리 단계에서 강제).
+     */
+    Optional<PartnershipApplication> findByIdAndCreatedBy(String id, String createdBy);
+
+    /** createdBy = PortalUser.id (평문 등가 조회 가능한 이유는 위와 동일). */
+    @Transactional
+    long deleteByCreatedBy(String createdBy);
+
+    /**
+     * test-cleanup 전용 — 특정 작성자의 글 중 제목이 지정 접두사로 시작하는 것만 조회한다.
+     * (bizSubject 는 암호화 컬럼이 아니라 LIKE 조회가 가능하다.)
+     */
+    List<PartnershipApplication> findAllByCreatedByAndBizSubjectStartingWith(String createdBy, String bizSubjectPrefix);
 }

src/main/java/com/eactive/apim/portal/apps/community/partnership/service/PartnershipApplicationFacade.java

@@ -13,4 +13,10 @@ public interface PartnershipApplicationFacade {
      * 현재 로그인 사용자가 작성한 최근 3건을 조회한다. 미인증이면 빈 목록.
      */
     List<PartnershipApplicationSummaryDTO> getMyRecentApplications();
+
+    /**
+     * 현재 로그인 사용자가 작성한 글 1건을 삭제한다(첨부파일 포함).
+     * 본인 글이 아니거나 이미 삭제된 경우 {@link IllegalArgumentException}.
+     */
+    void deleteMyApplication(String id);
 }

src/main/java/com/eactive/apim/portal/apps/community/partnership/service/PartnershipApplicationFacadeImpl.java

@@ -20,6 +20,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.apache.commons.lang3.StringUtils;
 
 @Service
 @RequiredArgsConstructor
@@ -74,4 +75,23 @@ public class PartnershipApplicationFacadeImpl implements PartnershipApplicationF
         List<PartnershipApplication> recent = partnershipApplicationService.findRecentByCreatedBy(user.getId());
         return partnershipApplicationMapper.toSummaryDtoList(recent);
     }
+
+    @Override
+    public void deleteMyApplication(String id) {
+        PortalAuthenticatedUser user = SecurityUtil.getPortalAuthenticatedUser();
+        if (user == null) {
+            throw new IllegalArgumentException("로그인이 필요합니다.");
+        }
+
+        // id 만으로 조회하지 않고 createdBy 를 함께 걸어 타인 글 삭제를 원천 차단한다.
+        PartnershipApplication target = partnershipApplicationService
+            .findOwnedByCreatedBy(id, user.getId())
+            .orElseThrow(() -> new IllegalArgumentException("삭제할 수 있는 피드백/개선요청이 아닙니다."));
+
+        // 첨부파일도 함께 정리한다(관리자 삭제 PortalPartnershipManService.delete 와 동일 처리).
+        if (StringUtils.isNotBlank(target.getFileId())) {
+            fileService.deleteFile(target.getFileId());
+        }
+        partnershipApplicationService.deletePartnershipApplication(target);
+    }
 }

src/main/java/com/eactive/apim/portal/apps/community/partnership/service/PartnershipApplicationService.java

@@ -3,6 +3,7 @@ package com.eactive.apim.portal.apps.community.partnership.service;
 import com.eactive.apim.portal.apps.community.partnership.repository.PartnershipApplicationRepository;
 import com.eactive.apim.portal.partnershipapplication.entity.PartnershipApplication;
 import java.util.List;
+import java.util.Optional;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -30,4 +31,16 @@ public class PartnershipApplicationService {
     public List<PartnershipApplication> findRecentByCreatedBy(String createdBy) {
         return partnershipApplicationRepository.findTop3ByCreatedByOrderByCreatedDateDesc(createdBy);
     }
+
+    /**
+     * 작성자 본인 글 단건 조회. id 와 createdBy 를 함께 조건으로 걸어 타인 글은 조회되지 않는다.
+     */
+    @Transactional(readOnly = true)
+    public Optional<PartnershipApplication> findOwnedByCreatedBy(String id, String createdBy) {
+        return partnershipApplicationRepository.findByIdAndCreatedBy(id, createdBy);
+    }
+
+    public void deletePartnershipApplication(PartnershipApplication partnershipApplication) {
+        partnershipApplicationRepository.delete(partnershipApplication);
+    }
 }

src/main/java/com/eactive/apim/portal/apps/community/qna/controller/InquiryController.java

@@ -3,6 +3,8 @@ package com.eactive.apim.portal.apps.community.qna.controller;
 import com.eactive.apim.portal.apps.community.qna.dto.InquiryDTO;
 import com.eactive.apim.portal.apps.community.qna.dto.InquirySearch;
 import com.eactive.apim.portal.apps.community.qna.service.InquiryFacade;
+import com.eactive.apim.portal.common.security.WriteRateLimitService;
+import com.eactive.apim.portal.common.security.WriteRateLimitService.WriteTarget;
 import com.eactive.apim.portal.common.user.PortalAuthenticatedUser;
 import com.eactive.apim.portal.common.util.SecurityUtil;
 import com.eactive.apim.portal.common.util.UserTypeUtil;
@@ -37,11 +39,14 @@ public class InquiryController {
     public static final String REDIRECT_INQUIRY = "redirect:/inquiry";
     private final InquiryFacade inquiryFacade;
     private final InquiryCommentFacade inquiryCommentFacade;
+    private final WriteRateLimitService writeRateLimitService;
 
     public InquiryController(InquiryFacade inquiryFacade,
-                             InquiryCommentFacade inquiryCommentFacade) {
+                             InquiryCommentFacade inquiryCommentFacade,
+                             WriteRateLimitService writeRateLimitService) {
         this.inquiryFacade = inquiryFacade;
         this.inquiryCommentFacade = inquiryCommentFacade;
+        this.writeRateLimitService = writeRateLimitService;
     }
 
     /**
@@ -133,6 +138,13 @@ public class InquiryController {
             return APPS_COMMUNITY_MAIN_INQUIRY_FORM;
         }
 
+        // 무제한 작성 차단 — 폼 전송이라 예외 대신 flash 메시지로 되돌린다.
+        if (writeRateLimitService.isExceeded(WriteTarget.INQUIRY)) {
+            redirectAttributes.addFlashAttribute("error",
+                writeRateLimitService.exceededMessage(WriteTarget.INQUIRY));
+            return REDIRECT_INQUIRY;
+        }
+
         inquiryFacade.createInquiry(inquiryDTO, image);
 
         redirectAttributes.addFlashAttribute("success", "Q&A 작성이 완료되었습니다.");

src/main/java/com/eactive/apim/portal/apps/community/qna/repository/InquiryRepository.java

@@ -3,14 +3,29 @@ package com.eactive.apim.portal.apps.community.qna.repository;
 import com.eactive.apim.portal.portaluser.entity.PortalUser;
 import com.eactive.apim.portal.qna.entity.Inquiry;
 import com.eactive.eai.rms.data.EMSDataSource;
+import java.util.List;
 import java.util.Optional;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
 
 @Repository
 @EMSDataSource
 public interface InquiryRepository extends JpaRepository<Inquiry, String>, JpaSpecificationExecutor<Inquiry> {
 
     Optional<Inquiry> findByInquirerAndId(PortalUser inquirer, String id);
+
+    @Transactional
+    long deleteByInquirer_Id(String inquirerId);
+
+    /** 4010 테스트 cleanup 전용 — 작성자 + 제목 접두사로 테스트 문의글만 좁혀 조회한다. */
+    List<Inquiry> findAllByInquirer_IdAndInquirySubjectStartingWith(String inquirerId, String subjectPrefix);
+
+    /**
+     * 작성 빈도 제한 판정용 — 특정 작성자의 최근 글을 최신순으로 조회한다(Pageable 로 건수 제한).
+     * createdBy 는 PersonalDataEncryptConverter 로 결정적 암호화되므로 평문 사용자 id 로 등가 조회가 가능하다.
+     */
+    List<Inquiry> findByCreatedByOrderByCreatedDateDesc(String createdBy, Pageable pageable);
 }

src/main/java/com/eactive/apim/portal/apps/login/service/LoginFinalizer.java

@@ -24,6 +24,8 @@ import com.eactive.apim.portal.portaluser.repository.UserPasswordHistoryReposito
 import com.eactive.apim.portal.template.entity.MessageCode;
 import com.eactive.apim.portal.template.entity.MessageRequest;
 import com.eactive.apim.portal.template.repository.MessageRequestRepository;
+import com.eactive.apim.portal.user.entity.UserLog;
+import com.eactive.apim.portal.user.repository.UserLogRepository;
 import lombok.RequiredArgsConstructor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -74,6 +76,7 @@ public class LoginFinalizer {
     private final PortalOrgRepository portalOrgRepository;
     private final UserSessionService userSessionService;
     private final PortalPropertyService portalPropertyService;
+    private final UserLogRepository userLogRepository;
 
     /**
      * 로그인 확정 후처리를 수행하고 최종 이동 URL 을 반환한다.
@@ -96,11 +99,19 @@ public class LoginFinalizer {
         // 기존 세션이 끊기는 건인지) 기록한다. 현재 세션 등록(registerSession)은 이 뒤에 일어나므로
         // 여기서 조회되는 활성 세션은 항상 "다른 곳"의 세션이다.
         boolean duplicate = userSessionService.getActiveSession(normalizedUsername).isPresent();
+        // 화면 표시용 "직전 로그인" 조회 — 이번 로그인 기록(logSuccess) 삽입 전에 조회해야
+        // 방금 로그인이 아닌 그 이전 성공 로그인을 얻는다.
+        Optional<UserLog> previousLogin = userLogRepository
+            .findFirstByLoginIdAndSuccessOrderByLoginTimeDesc(rawUsername, true);
         userLogService.logSuccess(rawUsername, ip, sessionId, loginType, request.getHeader("User-Agent"),
             duplicate);
 
         String contextPath = request.getContextPath();
         HttpSession session = request.getSession();
+        previousLogin.ifPresent(log -> {
+            session.setAttribute("previousLoginDate", log.getLoginTime());
+            session.setAttribute("previousLoginIp", log.getIp());
+        });
 
         applyPostLoginState(user, session, rawUsername, contextPath);
 

src/main/java/com/eactive/apim/portal/apps/main/dto/IndexStatisticsDTO.java

@@ -9,7 +9,7 @@ import lombok.NoArgsConstructor;
  * 인덱스 페이지 하단 통계 DTO
  * - API 활용 기업: 법인으로 등록된 수의 합계 (정상 상태)
  * - 서비스 이용 수: 전체 법인이 생성한 앱의 합계 (이용 가능 상태)
- * - API 이용 건수: 전체 법인이 생성한 앱의 API 수의 합계 (이용 가능 상태)
+ * - API 이용 건수 (월누적): 전체 법인 소속 게이트웨이 클라이언트의 이번 달 1일~오늘 누적 API 호출 건수
  */
 @Data
 @Builder
@@ -37,8 +37,8 @@ public class IndexStatisticsDTO {
     private int activeAppCount;
 
     /**
-     * API 이용 건수
+     * API 이용 건수 (월누적)
-     * 정상 상태 법인이 생성한 이용 가능 앱에 연결된 API의 총 수
+     * 정상 상태 법인 소속 게이트웨이 클라이언트의 이번 달 1일~오늘 누적 API 호출 건수
      */
     private int totalApiCount;
 }

src/main/java/com/eactive/apim/portal/apps/main/service/IndexStatisticsService.java

@@ -1,14 +1,20 @@
 package com.eactive.apim.portal.apps.main.service;
 
-import com.eactive.apim.portal.app.entity.Credential;
+import com.eactive.apim.gateway.data.statistics.repository.ApiStatsDayRepository;
+import com.eactive.apim.gateway.data.statistics.repository.ApiStatsHourRepository;
+import com.eactive.apim.gateway.data.statistics.repository.GwAuthClientRepository;
 import com.eactive.apim.portal.app.repository.CredentialRepository;
 import com.eactive.apim.portal.apps.main.dto.IndexStatisticsDTO;
+import com.eactive.apim.portal.apps.statistics.dto.ApiStatisticsSummaryDto;
 import com.eactive.apim.portal.apps.user.repository.PortalOrgRepository;
 import com.eactive.apim.portal.portalorg.entity.PortalOrgEnums.ApprovalStatus;
 import com.eactive.apim.portal.portalorg.entity.PortalOrgEnums.OrgStatus;
 import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
+import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
 import java.util.List;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -31,6 +37,9 @@ public class IndexStatisticsService {
 
     private final PortalOrgRepository portalOrgRepository;
     private final CredentialRepository credentialRepository;
+    private final GwAuthClientRepository gwAuthClientRepository;
+    private final ApiStatsDayRepository apiStatsDayRepository;
+    private final ApiStatsHourRepository apiStatsHourRepository;
     private final PortalPropertyService portalPropertyService;
 
     // 캐시된 통계 데이터
@@ -91,11 +100,13 @@ public class IndexStatisticsService {
                 // 3. 서비스 이용 수: 정상 기관의 이용 가능 앱 수
                 activeAppCount = (int) credentialRepository.countActiveAppsByOrgIds(activeOrgIds);
 
-                // 4. API 이용 건수: 정상 기관의 이용 가능 앱에 연결된 API 수
+                // 4. API 이용 건수 (월누적): 정상 기관 소속 게이트웨이 클라이언트의 이번 달 1일~오늘 누적 호출 건수
-                List<Credential> activeApps = credentialRepository.findActiveAppsByOrgIds(activeOrgIds);
+                List<String> clientIds = gwAuthClientRepository.findClientIdsByOrgIdIn(activeOrgIds).stream()
-                totalApiCount = activeApps.stream()
+                        .filter(id -> id != null && !id.trim().isEmpty())
-                        .mapToInt(credential -> credential.getApiList() != null ? credential.getApiList().size() : 0)
+                        .collect(Collectors.toList());
-                        .sum();
+                if (!clientIds.isEmpty()) {
+                    totalApiCount = (int) getMonthlyApiCallCount(clientIds);
+                }
             }
 
             cachedStatistics = IndexStatisticsDTO.builder()
@@ -125,6 +136,30 @@ public class IndexStatisticsService {
         }
     }
 
+    /**
+     * 게이트웨이 클라이언트들의 이번 달 1일~오늘 누적 API 호출 건수(TOTAL_CNT 합산).
+     * 어제까지는 API_STATS_DAY(일별 집계), 오늘은 아직 DAY 미집계이므로 API_STATS_HOUR로 합산한다.
+     * ({@link com.eactive.apim.portal.apps.statistics.service.ApiStatisticsService#combineDayAndToday}와 동일 패턴)
+     */
+    private long getMonthlyApiCallCount(List<String> clientIds) {
+        LocalDate today = LocalDate.now();
+        LocalDate monthStart = today.withDayOfMonth(1);
+        LocalDate dayEnd = today.minusDays(1);
+
+        long total = 0L;
+        if (!monthStart.isAfter(dayEnd)) {
+            total += nz(apiStatsDayRepository.findSummary(clientIds, monthStart, dayEnd).getTotalCount());
+        }
+        ApiStatisticsSummaryDto todaySummary = apiStatsHourRepository.findSummary(
+                clientIds, today.atStartOfDay(), today.atTime(LocalTime.MAX));
+        total += nz(todaySummary.getTotalCount());
+        return total;
+    }
+
+    private static long nz(Long value) {
+        return value != null ? value : 0L;
+    }
+
     /**
      * PortalProperty에서 통계 노출 여부 조회
      * 프로퍼티가 없으면 기본값 "Y"를 DB에 저장 후 반환

src/main/java/com/eactive/apim/portal/apps/user/controller/AccountController.java

@@ -9,6 +9,7 @@ import com.eactive.apim.portal.apps.session.service.UserSessionService;
 import com.eactive.apim.portal.apps.user.dto.*;
 import com.eactive.apim.portal.apps.user.facade.OrgRegisterFacade;
 import com.eactive.apim.portal.apps.user.facade.UserFacade;
+import com.eactive.apim.portal.common.security.PasswordConfirmFailureTracker;
 import com.eactive.apim.portal.common.user.PortalAuthenticatedUser;
 import com.eactive.apim.portal.common.util.PhoneNumberUtil;
 import com.eactive.apim.portal.common.util.SecurityUtil;
@@ -55,6 +56,7 @@ public class AccountController {
     private final UserSessionService userSessionService;
     private final TwoFactorService twoFactorService;
     private final TwoFactorProperties twoFactorProperties;
+    private final PasswordConfirmFailureTracker passwordConfirmFailureTracker;
 
 
     /** 비밀번호 변경 화면 라이브 체크: 입력 중인 비밀번호에 아이디/휴대전화가 포함되는지 (민감정보는 응답에 미포함) */
@@ -65,12 +67,18 @@ public class AccountController {
     }
 
     @PostMapping("/password/confirm")
-    public ResponseEntity<ValidationResponse> confirmPassword(@RequestParam String inputPassword) {
+    public ResponseEntity<ValidationResponse> confirmPassword(@RequestParam String inputPassword,
+        HttpSession session, HttpServletRequest request, HttpServletResponse response) {
         String currentLoginId = SecurityUtil.getCurrentLoginId();
-        boolean isPasswordCorrect = userFacade.verifyCurrentPassword(currentLoginId, inputPassword);
+        if (userFacade.verifyCurrentPassword(currentLoginId, inputPassword)) {
+            passwordConfirmFailureTracker.reset(session);
+            return ResponseEntity.ok(new ValidationResponse(true, "비밀번호가 확인되었습니다."));
+        }
 
-        String message = isPasswordCorrect ? "비밀번호가 확인되었습니다." : "비밀번호가 일치하지 않습니다.";
+        // 무제한 시도 차단 — step-up 확인 페이지와 동일한 카운터/정책을 쓴다.
-        return ResponseEntity.ok(new ValidationResponse(isPasswordCorrect, message));
+        PasswordConfirmFailureTracker.Outcome outcome =
+            passwordConfirmFailureTracker.recordFailure(session, request, response);
+        return ResponseEntity.ok(new ValidationResponse(false, outcome.getMessage()));
     }
 
     @GetMapping("/password/verify")
@@ -96,15 +104,29 @@ public class AccountController {
     }
 
     @PostMapping("/password/verify")
-    public String verifyCurrentPassword(@RequestParam String currentPassword, RedirectAttributes redirectAttributes, HttpSession session, Model model) {
+    public String verifyCurrentPassword(@RequestParam String currentPassword, RedirectAttributes redirectAttributes,
+        HttpSession session, HttpServletRequest request, HttpServletResponse response, Model model) {
         String currentLoginId = SecurityUtil.getCurrentLoginId();
         if (userFacade.verifyCurrentPassword(currentLoginId, currentPassword)) {
+            passwordConfirmFailureTracker.reset(session);
             model.addAttribute("passwordChangeRequest", new PasswordChangeRequestDTO());
+            // GET /password/change 와 동일하게 2FA 필요 여부를 내려준다.
+            // 누락되면 폼 JS 가 제출 가로채기(비밀번호 규칙 게이트 + 2FA 팝업)를 등록하지 않아
+            // 서버가 통과권 없음으로 계속 되돌리고 비밀번호를 바꿀 수 없다.
+            model.addAttribute("twofaRequired", isPwChangeTwofaRequired(session));
             return "apps/mypage/passwordChange";
-        } else {
-            redirectAttributes.addFlashAttribute("error", "현재 비밀번호가 일치하지 않습니다.");
-            return "redirect:/password/verify";
         }
+
+        // 무제한 시도 차단 — 임계 초과 시 정책(로그아웃/계정 차단)에 따라 조치한다.
+        PasswordConfirmFailureTracker.Outcome outcome =
+            passwordConfirmFailureTracker.recordFailure(session, request, response);
+        if (outcome.isForcedLogout()) {
+            return outcome.isAccountLocked()
+                ? "redirect:/login?pwFailExceeded=1&locked=1"
+                : "redirect:/login?pwFailExceeded=1";
+        }
+        redirectAttributes.addFlashAttribute("error", outcome.getMessage());
+        return "redirect:/password/verify";
     }
 
     @PostMapping("/password/change")

src/main/java/com/eactive/apim/portal/apps/user/controller/UserRegisterRestController.java

@@ -35,8 +35,8 @@ public class UserRegisterRestController {
     }
 
     @PostMapping("/check_password_match")
-    public ResponseEntity<ValidationResponse> checkPasswordMatch(@RequestParam String password, @RequestParam String password2) {
+    public ResponseEntity<ValidationResponse> checkPasswordMatch(@RequestParam String password, @RequestParam String confirmPassword) {
-        return ResponseEntity.ok(userRegisterFacade.checkPasswordMatch(password, password2));
+        return ResponseEntity.ok(userRegisterFacade.checkPasswordMatch(password, confirmPassword));
     }
 
     @PostMapping("/register/confirm_password")

src/main/java/com/eactive/apim/portal/apps/user/dto/PortalUserRegistrationDTO.java

@@ -10,7 +10,7 @@ import org.hibernate.validator.constraints.NotEmpty;
 
 
 @AuthNumberMatch(recipient = "loginId", authField = "authNumber")
-@PasswordMatch(input = "password", confirm = "password2")
+@PasswordMatch(input = "password", confirm = "confirmPassword")
 @Data
 @PasswordRule(password = "password", loginId = "loginId", mobile = "mobileNumber")
 public class PortalUserRegistrationDTO {
@@ -31,8 +31,6 @@ public class PortalUserRegistrationDTO {
      */
     private String password;
 
-    private String password2;
-
     @CellPhone
     private String mobileNumber;
 

src/main/java/com/eactive/apim/portal/apps/user/facade/UserFacadeImpl.java

@@ -140,11 +140,11 @@ public class UserFacadeImpl implements UserFacade {
     public void withdrawUser(String userId, String withdrawalReason) {
         PortalUser user = portalUserService.findById(userId);
 
-        // 법인 관리자 탈퇴 제한
+        // 법인 관리자는 권한 이관 전 탈퇴할 수 없다.
         if (user.getRoleCode() == PortalUserEnums.RoleCode.ROLE_CORP_MANAGER) {
-            if(portalUserService.checkOrgHasOtherUsers(user.getPortalOrg())){
+            throw new IllegalArgumentException(
-                throw new IllegalArgumentException("법인 관리자권한을 다른 개발자에게 위임하신 후 탈퇴가 가능합니다.");
+                "법인 관리자는 회원 탈퇴를 할 수 없습니다. "
-            }
+                    + "관리자 권한을 다른 사용자에게 이관하거나 담당자에게 연락해 주세요.");
         }
 
         // 약관 동의 정보 삭제

src/main/java/com/eactive/apim/portal/apps/user/facade/UserRegisterFacade.java

@@ -19,7 +19,7 @@ public interface UserRegisterFacade {
 
     ValidationResponse checkPassword(String password, String loginId, String mobileNumber);
 
-    ValidationResponse checkPasswordMatch(String password, String password2);
+    ValidationResponse checkPasswordMatch(String password, String confirmPassword);
 
     ValidationResponse verifyPassword(String loginId, String confirmPassword);
 

src/main/java/com/eactive/apim/portal/apps/user/facade/UserRegisterFacadeImpl.java

@@ -94,8 +94,8 @@ public class UserRegisterFacadeImpl implements UserRegisterFacade {
     }
 
     @Override
-    public ValidationResponse checkPasswordMatch(String password, String password2) {
+    public ValidationResponse checkPasswordMatch(String password, String confirmPassword) {
-        boolean isMatch = password.equals(password2);
+        boolean isMatch = password.equals(confirmPassword);
         String message = isMatch ? "비밀번호가 일치합니다." : "비밀번호가 일치하지 않습니다.";
         return new ValidationResponse(isMatch, message);
     }

src/main/java/com/eactive/apim/portal/apps/user/service/PasswordService.java

@@ -34,7 +34,8 @@ public class PasswordService {
                 .orElseThrow(() -> new IllegalArgumentException("해당 사용자를 찾을 수 없습니다."));
 
         validatePasswordUpdate(user, newPassword, confirmPassword);
-        checkPasswordHistory(user.getLoginId(), newPassword);
+        // PTL_USER_PASSWORD_HISTORY.USER_ID 에는 loginId가 아닌 PortalUser.id가 저장된다.
+        checkPasswordHistory(user.getId(), newPassword);
 
         List<UserPasswordHistory> histories = passwordHistoryRepository.findRecentPasswordsByUserId(user.getId());
         if(histories.isEmpty()) {
@@ -85,6 +86,17 @@ public class PasswordService {
         return result;
     }
 
+    /**
+     * {@link #updatePassword} 를 거치지 않고 비밀번호 해시를 직접 바꾸는 지점(예: 비밀번호 초기화로
+     * 임시 비밀번호 발급 — PortalUserAuthService.resetPassword)이 <b>덮어쓰기 직전</b>에 호출해,
+     * 지금 버려지는 비밀번호를 이력에 남긴다. 이걸 빼먹으면 재사용 금지(최근 5회) 검증이 그 비밀번호를
+     * 전혀 모른 채로 남아 있어, 초기화 이후 바로 예전 비밀번호로 되돌리는 게 허용되는 보안 허점이 된다.
+     */
+    @Transactional
+    public void recordExternalPasswordChange(String userId, String previousPasswordHash) {
+        savePasswordHistory(userId, previousPasswordHash);
+    }
+
     private void checkPasswordHistory(String userId, String newPassword) {
         List<UserPasswordHistory> passwordHistories = passwordHistoryRepository.findRecentPasswordsByUserId(userId);
 
@@ -115,26 +127,4 @@ public class PasswordService {
 
         passwordHistoryRepository.save(newHistory);
     }
-
-    private boolean isValidPassword(String password) {
-        if (password.length() < 8) {
-            return false;
-        }
-
-        boolean hasLetter = false;
-        boolean hasDigit = false;
-        boolean hasSpecial = false;
-
-        for (char c : password.toCharArray()) {
-            if (Character.isLetter(c)) {
-                hasLetter = true;
-            } else if (Character.isDigit(c)) {
-                hasDigit = true;
-            } else if (!Character.isWhitespace(c)) {
-                hasSpecial = true;
-            }
-        }
-
-        return hasLetter && hasDigit && hasSpecial;
-    }
 }

src/main/java/com/eactive/apim/portal/apps/user/service/PortalUserAuthService.java

@@ -56,6 +56,7 @@ public class PortalUserAuthService implements UserDetailsService {
     private final MessageRequestRepository messageRequestRepository;
     private final EncryptionUtil encryptionUtil;
     private final LoginFinalizer loginFinalizer;
+    private final PasswordService passwordService;
 
     @Override
     @Transactional(noRollbackFor = UsernameNotFoundException.class)
@@ -66,7 +67,9 @@ public class PortalUserAuthService implements UserDetailsService {
             PortalUser portalUser = findByEmailAddr(normalizedUsername);
             return buildAuthenticatedUser(portalUser);
         } catch (UserNotFoundException e) {
-            throw new UsernameNotFoundException("입력하신 사용자 정보가 올바르지 않습니다. 다시 확인해 주세요.");
+            // 계정 열거(user enumeration) 공격 방지: 비밀번호 불일치(BadCredentialsException, PortalAuthenticationManager)와
+            // 동일한 문구를 사용해 아이디 존재 여부가 노출되지 않도록 한다.
+            throw new UsernameNotFoundException("아이디 또는 비밀번호가 일치하지 않습니다.");
         }
     }
 
@@ -162,6 +165,10 @@ public class PortalUserAuthService implements UserDetailsService {
                 .orElseThrow(() -> new UserNotFoundException("일치하는 사용자 정보를 찾을 수 없습니다."));
 
         String tempPassword = EncryptionUtil.generateNewPassword();
+        // 지금 버려지는(임시 비밀번호로 교체되는) 비밀번호를 이력에 남긴다 — 안 남기면 재사용 금지
+        // (최근 5회) 검증이 이 비밀번호를 모른 채로 남아, 초기화 직후 바로 예전 비밀번호로 되돌리는
+        // 것이 허용되는 보안 허점이 생긴다.
+        passwordService.recordExternalPasswordChange(portalUser.getId(), portalUser.getPasswordHash());
         portalUser.setPasswordHash(passwordEncoder.encode(tempPassword));
         // 임시 비밀번호 발급 → 변경일을 null 로 초기화해 로그인 시 강제 비밀번호 변경을 유도한다
         // (LoginFinalizer.applyPostLoginState 의 passwordChangeDate == null 분기)

src/main/java/com/eactive/apim/portal/apps/user/validator/PasswordValidator.java

@@ -1,53 +1,23 @@
 package com.eactive.apim.portal.apps.user.validator;
 
+import com.eactive.apim.portal.common.security.PasswordPolicyProperties;
 import com.eactive.apim.portal.common.validator.PasswordRuleValidator;
+import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 
+/**
+ * 비밀번호 문자열 정책 검사 진입점. 규칙 자체는 정본인 {@link PasswordRuleValidator} 가 갖고,
+ * 여기서는 DB 토글({@link PasswordPolicyProperties})을 얹어 위임만 한다.
+ */
 @Component
+@RequiredArgsConstructor
 public class PasswordValidator {
 
-    public boolean isValidPassword(String password) {
+    private final PasswordPolicyProperties passwordPolicyProperties;
-        if (password == null || password.isEmpty()) {
-            return false;
-        }
-
-        String tmpPw = password.toUpperCase();
-        return isValidLengthAndCharacters(tmpPw) && !containsInvalidPatterns(tmpPw);
-    }
 
     public boolean isValidPassword(String password, String loginId, String mobileNumber) {
         PasswordRuleValidator validator = new PasswordRuleValidator();
-        return validator.isValid(password, loginId, mobileNumber);
+        return validator.isValid(password, loginId, mobileNumber,
-    }
+                passwordPolicyProperties.isKeyboardSequenceBlocked());
-
-    private boolean isValidLengthAndCharacters(String password) {
-        final int MIN = 8;
-        final int MAX = 50;
-        final String REGEX = "^(?=.*\\d)(?=.*[a-zA-Z])(?=.*[\\W]).{" + MIN + "," + MAX + "}$";
-        return password.matches(REGEX);
-    }
-
-    private boolean containsInvalidPatterns(String password) {
-        final String SAMEPT = "(\\w)\\1\\1";
-        final String BLANKPT = "(\\s)";
-
-        if (password.matches(BLANKPT) || password.matches(SAMEPT)) {
-            return true;
-        }
-
-        return containsContinuousCharacters(password);
-    }
-
-    private boolean containsContinuousCharacters(String password) {
-        for (int i = 0; i < password.length() - 2; i++) {
-            if (isContinuous(password.charAt(i), password.charAt(i + 1), password.charAt(i + 2))) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private boolean isContinuous(char a, char b, char c) {
-        return (b - a == 1) && (c - b == 1);
     }
 }

src/main/java/com/eactive/apim/portal/common/breadcrumb/GlobalControllerAdvice.java

@@ -12,9 +12,11 @@ import com.eactive.apim.portal.config.PortalProperties;
 import com.eactive.apim.portal.apps.auth.AuthNoticeProperties;
 import com.eactive.apim.portal.apps.session.service.UserSessionService;
 import com.eactive.apim.portal.common.security.ClientGuardService;
+import com.eactive.apim.portal.common.security.PasswordPolicyProperties;
 import com.eactive.apim.portal.djb.footer.RelatedSite;
 import com.eactive.apim.portal.djb.footer.RelatedSiteService;
 import com.eactive.apim.portal.djb.guide.GuideProperty;
+import com.eactive.apim.portal.common.security.passwordcrypto.PasswordCryptoProperties;
 import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
 
 @ControllerAdvice
@@ -32,6 +34,9 @@ public class GlobalControllerAdvice {
     @Autowired
     private ClientGuardService clientGuardService;
 
+    @Autowired
+    private PasswordPolicyProperties passwordPolicyProperties;
+
     @Autowired
     private PortalPropertyService portalPropertyService;
 
@@ -47,6 +52,9 @@ public class GlobalControllerAdvice {
     @Autowired
     private Environment environment;
 
+    @Autowired
+    private PasswordCryptoProperties passwordCryptoProperties;
+
     @ModelAttribute("breadcrumb")
     public List<Map> addBreadcrumbToModel(HttpServletRequest request) {
         String currentPath = request.getRequestURI();
@@ -111,6 +119,38 @@ public class GlobalControllerAdvice {
         return clientGuardService.isDevtoolsGuardEnabled();
     }
 
+    /**
+     * 비밀번호 정책 - 키보드 배열 연속 문자 차단 여부.
+     * PortalProperty(Portal/password.keyboard-sequence.block)에서 조회.
+     * head 의 window.__PASSWORD_POLICY__ 와 비밀번호 요구사항 체크리스트 노출에 함께 쓴다.
+     */
+    @ModelAttribute("passwordKeyboardSequenceBlock")
+    public boolean passwordKeyboardSequenceBlock() {
+        return passwordPolicyProperties.isKeyboardSequenceBlocked();
+    }
+
+    /**
+     * 비밀번호 전송암호화 사용 여부(yml portal.security.password-encrypt.enabled).
+     * head 의 window.__PASSWORD_CRYPTO__ 로 내려가 password-crypto.js 가 읽는다.
+     * 꺼져 있거나 브라우저가 Web Crypto 를 못 쓰면 화면은 평문으로 폴백한다.
+     */
+    @ModelAttribute("passwordCryptoEnabled")
+    public boolean passwordCryptoEnabled() {
+        return passwordCryptoProperties.isEnabled();
+    }
+
+    /**
+     * 상단 헤더 좌측 노출용 활성 프로파일 배지. prod 프로파일이면 노출하지 않는다(null).
+     */
+    @ModelAttribute("activeProfileBadge")
+    public String activeProfileBadge() {
+        if (environment.acceptsProfiles(Profiles.of("prod"))) {
+            return null;
+        }
+        String[] activeProfiles = environment.getActiveProfiles();
+        return activeProfiles.length == 0 ? "default" : String.join(", ", activeProfiles);
+    }
+
     /**
      * 푸터 고객센터 연락처. PortalProperty(Portal/customer.center.contact)에서 조회.
      * 전화번호가 아닐 수도 있으므로 값 그대로 출력하되 템플릿에서 th:text(HTML escape)로 렌더한다.
@@ -121,6 +161,61 @@ public class GlobalControllerAdvice {
             "Portal", "customer.center.contact", "1588-3388", "고객센터 연락처");
     }
 
+    /**
+     * 메인 페이지 본문에 노출되는 브랜드명. PortalProperty(Portal/brand.name)에서 조회.
+     * 로고 이미지(alt 텍스트)는 별도이며 이 값의 영향을 받지 않는다.
+     */
+    @ModelAttribute("brandName")
+    public String brandName() {
+        return portalPropertyService.getOrCreateProperty(
+            "Portal", "brand.name", "DJBank", "메인 페이지 브랜드명 표기");
+    }
+
+    /**
+     * brandName 뒤에 바로 붙는 주격 조사(이/가). 받침 유무에 따라 관리자가 값을 바꿔도 문법이 깨지지 않도록 계산한다.
+     */
+    @ModelAttribute("brandNameJosaGa")
+    public String brandNameJosaGa() {
+        return hasBatchim(brandName()) ? "이" : "가";
+    }
+
+    /**
+     * brandName 뒤에 바로 붙는 보조사(은/는).
+     */
+    @ModelAttribute("brandNameJosaEun")
+    public String brandNameJosaEun() {
+        return hasBatchim(brandName()) ? "은" : "는";
+    }
+
+    /**
+     * 헤더(GNB) 로고 이미지 경로. PortalProperty(Portal/brand.logo.header.path)에서 조회.
+     */
+    @ModelAttribute("brandLogoHeaderPath")
+    public String brandLogoHeaderPath() {
+        return portalPropertyService.getOrCreateProperty(
+            "Portal", "brand.logo.header.path", "/img/logo/logo-djb.png", "헤더(GNB) 로고 이미지 경로");
+    }
+
+    /**
+     * 푸터 로고 이미지 경로. PortalProperty(Portal/brand.logo.footer.path)에서 조회.
+     */
+    @ModelAttribute("brandLogoFooterPath")
+    public String brandLogoFooterPath() {
+        return portalPropertyService.getOrCreateProperty(
+            "Portal", "brand.logo.footer.path", "/img/logo/logo-jjb.png", "푸터 로고 이미지 경로");
+    }
+
+    private boolean hasBatchim(String word) {
+        if (word == null || word.isEmpty()) {
+            return false;
+        }
+        char last = word.charAt(word.length() - 1);
+        if (last >= 0xAC00 && last <= 0xD7A3) {
+            return (last - 0xAC00) % 28 != 0;
+        }
+        return "AEIOUaeiou".indexOf(last) < 0;
+    }
+
     /**
      * 푸터 관련 사이트 셀렉트 라벨. PortalProperty(Portal/footer.related-sites.label)에서 조회.
      */

src/main/java/com/eactive/apim/portal/common/exception/PortalGlobalExceptionHandler.java

@@ -1,8 +1,7 @@
 package com.eactive.apim.portal.common.exception;
 
 
-import java.util.Arrays;
+import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 import javax.servlet.http.HttpServletRequest;
 
 import com.eactive.apim.portal.apps.login.service.LoginFinalizer;
@@ -36,23 +35,27 @@ import org.springframework.web.servlet.mvc.support.RedirectAttributes;
 @RequiredArgsConstructor
 public class PortalGlobalExceptionHandler {
 
+    private static final String REDIRECT_PREFIX = "redirect:";
+    private static final String REDIRECT_HOME = REDIRECT_PREFIX + "/";
+    private static final String REDIRECT_LOGIN_AUTH = REDIRECT_PREFIX + "/login?reason=auth";
+
     private final Logger log = LoggerFactory.getLogger(getClass());
     private final PortalProperties portalProperties;
     private final Environment environment;
 
     @ExceptionHandler(value = NotFoundException.class)
     public ModelAndView handleINotFoundException(HttpServletRequest request, NotFoundException ex) {
-        return new ModelAndView("redirect:/");
+        return new ModelAndView(REDIRECT_HOME);
     }
 
     @ExceptionHandler(value = MethodArgumentTypeMismatchException.class)
     public ModelAndView handleMethodArgumentTypeMismatchException(HttpServletRequest request, MethodArgumentTypeMismatchException ex) {
-        return new ModelAndView("redirect:/");
+        return new ModelAndView(REDIRECT_HOME);
     }
 
     @ExceptionHandler(value = UserNotLoginException.class)
     public ModelAndView handleUserNotLoginException(HttpServletRequest request, UserNotLoginException ex) {
-        return new ModelAndView("redirect:/login?reason=auth");
+        return new ModelAndView(REDIRECT_LOGIN_AUTH);
     }
 
     @ExceptionHandler(value = AccessDeniedException.class)
@@ -61,7 +64,7 @@ public class PortalGlobalExceptionHandler {
         if (!SecurityUtil.isAuthenticated()) {
             // 원래 요청 페이지를 세션에 저장 → 로그인+2FA 완료 후 LoginFinalizer 가 복귀시킨다.
             savePostLoginRedirect(request);
-            return new ModelAndView("redirect:/login?reason=auth");
+            return new ModelAndView(REDIRECT_LOGIN_AUTH);
         }
         log.warn("접근 권한 없음: loginId={}, uri={}", StringMaskingUtil.maskLoginId(SecurityUtil.getCurrentLoginId()), request.getRequestURI());
         ModelAndView modelAndView = new ModelAndView("error");
@@ -122,9 +125,40 @@ public class PortalGlobalExceptionHandler {
             || path.startsWith("/favicon"));
     }
 
+    /**
+     * 리다이렉트/뷰 이름으로 허용할 문자. 스킴 구분자(:)·중괄호·달러를 막아
+     * 외부 URL 이나 Thymeleaf 표현식이 뷰 이름으로 흘러드는 것을 차단한다.
+     */
+    private static final Pattern SAFE_REDIRECT_TARGET = Pattern.compile("[A-Za-z0-9._/?=&%-]+");
+
     @ExceptionHandler(value = PortalRedirectException.class)
     public ModelAndView handlePortalRedirectException(HttpServletRequest request, PortalRedirectException ex) {
-        return new ModelAndView(ex.getMessage());
+        // PortalRedirectException 은 super(message) 를 호출하지 않으므로 getMessage() 는 항상 null 이다.
+        // 이전 구현은 그 null 을 뷰 이름으로 넘겨(= 뷰 미지정) 요청 URL 기준으로 뷰가 추론되게 만들었다.
+        // 실제 대상은 redirectPage 필드다.
+        String target = ex.getRedirectPage();
+        if (!isSafeRedirectTarget(target)) {
+            log.warn("허용되지 않은 리다이렉트 대상 - uri={}, target={}", request.getRequestURI(), target);
+            return new ModelAndView(REDIRECT_HOME);
+        }
+        return new ModelAndView(target);
+    }
+
+    /** 내부 경로/뷰 이름만 허용(외부 URL·프로토콜 상대 URL·표현식 문자 차단) */
+    private boolean isSafeRedirectTarget(String target) {
+        if (target == null) {
+            return false;
+        }
+        String path = target;
+        if (path.startsWith(REDIRECT_PREFIX)) {
+            path = path.substring(REDIRECT_PREFIX.length());
+        } else if (path.startsWith("forward:")) {
+            path = path.substring("forward:".length());
+        }
+        if (path.isEmpty() || path.startsWith("//")) {   // //evil.example 형태의 외부 리다이렉트 차단
+            return false;
+        }
+        return SAFE_REDIRECT_TARGET.matcher(path).matches();
     }
 
     @ExceptionHandler(value = {IllegalArgumentException.class})
@@ -140,7 +174,7 @@ public class PortalGlobalExceptionHandler {
     public ModelAndView handleHttpRequestMethodNotSupportedException(HttpServletRequest request, HttpRequestMethodNotSupportedException ex) {
         log.error(ex.getMessage());
         ModelAndView modelAndView = new ModelAndView();
-        modelAndView.setViewName("redirect:/");
+        modelAndView.setViewName(REDIRECT_HOME);
         return modelAndView;
     }
 
@@ -159,10 +193,9 @@ public class PortalGlobalExceptionHandler {
      */
     @ExceptionHandler(value = Exception.class)
     public ModelAndView handleException(HttpServletRequest request, Exception ex) {
-        String requestParams = request.getParameterMap().entrySet()
+        // 비밀번호·시크릿·토큰 계열 파라미터는 값을 가린다. 전송암호화가 켜져 있어도
-            .stream()
+        // 이 시점의 파라미터는 이미 복호화된 평문이다.
-            .map(entry -> entry.getKey() + "=" + Arrays.toString(entry.getValue()))
+        String requestParams = StringMaskingUtil.maskParameterMap(request.getParameterMap());
-            .collect(Collectors.joining(", "));
 
         log.error("Exception occurred - url={}, params={}", request.getRequestURL(), requestParams, ex);
 
@@ -184,7 +217,7 @@ public class PortalGlobalExceptionHandler {
     public ModelAndView handleInvalidFileException(HttpServletRequest request, RedirectAttributes redirectAttributes, InvalidFileException ex) {
         ModelAndView modelAndView = new ModelAndView();
         redirectAttributes.addFlashAttribute("error", ex.getMessage());
-        modelAndView.setViewName("redirect:" + request.getRequestURI());
+        modelAndView.setViewName(REDIRECT_PREFIX + request.getRequestURI());
         return modelAndView;
     }
 
@@ -195,7 +228,7 @@ public class PortalGlobalExceptionHandler {
         String errorMessage = "파일 크기가 허용된 최대 용량(" + maxSize + ")을 초과했습니다.";
         redirectAttributes.addFlashAttribute("error", errorMessage);
         ModelAndView modelAndView = new ModelAndView();
-        modelAndView.setViewName("redirect:" + request.getRequestURI());
+        modelAndView.setViewName(REDIRECT_PREFIX + request.getRequestURI());
         return modelAndView;
     }
 }

src/main/java/com/eactive/apim/portal/common/exception/TooManyWriteRequestsException.java

@@ -0,0 +1,14 @@
+package com.eactive.apim.portal.common.exception;
+
+/**
+ * 작성 요청이 허용 빈도를 초과했을 때 던진다(무제한 요청 차단).
+ *
+ * <p>JSON 응답 컨트롤러에서만 사용한다 — 폼 전송 컨트롤러는 예외 대신
+ * flash 메시지로 되돌려야 하므로 {@code isExceeded} 판정을 직접 쓴다.</p>
+ */
+public class TooManyWriteRequestsException extends RuntimeException {
+
+    public TooManyWriteRequestsException(String message) {
+        super(message);
+    }
+}

src/main/java/com/eactive/apim/portal/common/migration/LegacyEncryptionMigrationController.java

@@ -1,258 +0,0 @@
-package com.eactive.apim.portal.common.migration;
-
-import com.eactive.apim.portal.common.util.StringMaskingUtil;
-import com.eactive.apim.portal.jpa.PersonalDataEncryptConverter;
-import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.http.HttpStatus;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.server.ResponseStatusException;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.sql.DataSource;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * [임시] 레거시 평문 데이터를 {@link PersonalDataEncryptConverter} 규칙으로 일괄 정규화(암호화)하는 운영 도구.
- *
- * <p>배경: {@code @Convert} 컬럼이 평문으로 저장된 레거시 행은, derived query가 검색값을 암호화하면서
- * 평문 DB값과 불일치해 검색/로그인이 실패한다. 컨버터는 읽기에서 평문/암호문을 자동 구분하고
- * 쓰기에서 무조건 인코딩하므로, {@code convertToDatabaseColumn(convertToEntityAttribute(x))}는
- * 평문→인코딩, 인코딩→동일값(멱등)으로 정규화된다. 이 값이 기존과 다를 때만 UPDATE 한다.</p>
- *
- * <p>보안: PTL_PROPERTY {@code Portal / migration.internal.allow-ips} 허용 IP 목록(콤마 구분,
- * 기본 loopback)에 포함된 IP 의 직접 호출만 허용한다 ({@code MenuInternalController} 모델).
- * 운영 서버는 bind IP 가 NIC IP 라 loopback 호출이 불가하므로, 실행 전 property 에 호출자 IP 를
- * 추가하고 작업 완료 후 원복한다. 프록시 경유(X-Forwarded-For 존재) 요청은 거부한다.
- * 기본은 dry-run(미변경)이며, 실제 실행은 {@code dryRun=false}를 명시해야 한다.
- * 작업 완료 후 이 클래스는 제거한다.</p>
- *
- * <pre>
- *   # 미리보기(변경 안 함)
- *   curl -X POST 'http://127.0.0.1:39130/internal/migration/encrypt-legacy'
- *   # 실제 실행 (PII 컬럼)
- *   curl -X POST 'http://127.0.0.1:39130/internal/migration/encrypt-legacy?dryRun=false'
- *   # audit 컬럼(created_by/last_modified_by, 19개 테이블)까지 포함
- *   curl -X POST 'http://127.0.0.1:39130/internal/migration/encrypt-legacy?dryRun=false&includeAudit=true'
- * </pre>
- */
-@Slf4j
-@RestController
-@RequestMapping("/internal/migration")
-public class LegacyEncryptionMigrationController {
-
-    /** PII 직접 컬럼 (로그인/검색에 직접 영향). ofctelno 는 admin(UnifbwkManService)이 컨버터를 수동 호출해 암호화하는 컬럼 */
-    private static final List<TargetTable> PII_TARGETS = Arrays.asList(
-            new TargetTable("PTL_USER", Arrays.asList("login_id", "email_addr", "phone_number", "mobile_number")),
-            new TargetTable("PTL_MESSAGE_REQUEST", Arrays.asList("email", "phone")),
-            new TargetTable("tseairm02", Arrays.asList("cphnno", "emad", "ofctelno")),
-            new TargetTable("PTL_USER_LOG", Arrays.asList("login_id")),
-            new TargetTable("PTL_TWO_FACTOR_AUTH", Arrays.asList("recipient")),
-            new TargetTable("PTL_USER_INVITATION", Arrays.asList("INVITATION_MOBILE"))
-    );
-
-    /** Auditable(@MappedSuperclass) 상속 테이블의 감사 컬럼 (옵션) */
-    private static final List<String> AUDIT_TABLES = Arrays.asList(
-            "PTL_USER", "ptl_faq", "ptl_org",
-            "DJB_APISTATUS_INCIDENT", "DJB_APISTATUS_INCIDENT_TIMELINE", "DJB_APISTATUS_INCIDENT_API",
-            "ptl_file", "PTL_MESSAGE_TEMPLATE", "ptl_notice", "ptl_terms",
-            "ptl_user_privacy_policy_agreement", "ptl_approval_line",
-            "PTL_INQUIRY_COMMENT", "ptl_inquiry", "ptl_partnership_application",
-            "PTL_MENU_ITEM", "PTL_MENU_PLACEMENT", "PTL_ROLE", "PTL_ROLE_AUTHORITY"
-    );
-    private static final List<String> AUDIT_COLUMNS = Arrays.asList("created_by", "last_modified_by");
-
-    static final String PROP_GROUP = "Portal";
-    static final String PROP_ALLOW_IPS = "migration.internal.allow-ips";
-    static final String DEFAULT_ALLOW_IPS = "127.0.0.1,::1";
-
-    private final JdbcTemplate jdbcTemplate;
-    private final PortalPropertyService portalPropertyService;
-    private final PersonalDataEncryptConverter converter = new PersonalDataEncryptConverter();
-
-    public LegacyEncryptionMigrationController(@Qualifier("portalDataSource") DataSource emsDataSource,
-                                               PortalPropertyService portalPropertyService) {
-        // EMS(EMSAPP) 스키마 데이터소스. 컨버터 적용 테이블은 모두 EMS에 존재한다.
-        this.jdbcTemplate = new JdbcTemplate(emsDataSource);
-        this.portalPropertyService = portalPropertyService;
-    }
-
-    @PostMapping("/encrypt-legacy")
-    @Transactional("transactionManager")
-    public Map<String, Object> encryptLegacy(HttpServletRequest request,
-                                             @RequestParam(defaultValue = "true") boolean dryRun,
-                                             @RequestParam(defaultValue = "false") boolean includeAudit) {
-        assertAllowedIp(request);
-        assertNotBypass();
-
-        List<TargetTable> targets = new ArrayList<>(PII_TARGETS);
-        if (includeAudit) {
-            for (String table : AUDIT_TABLES) {
-                targets.add(new TargetTable(table, AUDIT_COLUMNS));
-            }
-        }
-
-        List<Map<String, Object>> results = new ArrayList<>();
-        int totalChanged = 0;
-        int totalSkipped = 0;
-        for (TargetTable target : targets) {
-            for (String column : target.columns) {
-                Map<String, Object> r = processColumn(target.table, column, dryRun);
-                results.add(r);
-                totalChanged += (int) r.get("changed");
-                totalSkipped += (int) r.get("skipped");
-            }
-        }
-
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("mode", dryRun ? "dry-run (변경 없음)" : "executed");
-        response.put("damoMode", resolveDamoMode());
-        response.put("includeAudit", includeAudit);
-        response.put("totalChanged", totalChanged);
-        // 정규화 결과가 빈 값이라 UPDATE 를 생략한 건수. 0 이 아니면 원인 조사 후 진행할 것.
-        response.put("totalSkipped", totalSkipped);
-        response.put("results", results);
-        log.info("[레거시 암호화 마이그레이션] mode={} includeAudit={} totalChanged={} totalSkipped={}",
-                dryRun ? "dry-run" : "executed", includeAudit, totalChanged, totalSkipped);
-        return response;
-    }
-
-    private String resolveDamoMode() {
-        if (converter.isBypassMode()) {
-            return "BYPASS";
-        }
-        return converter.isFakeMode() ? "FAKE" : "REAL";
-    }
-
-    /**
-     * 단일 (테이블, 컬럼)의 고유값을 정규화하고, 값이 바뀌는 경우에만 UPDATE.
-     */
-    private Map<String, Object> processColumn(String table, String column, boolean dryRun) {
-        Map<String, Object> r = new LinkedHashMap<>();
-        r.put("table", table);
-        r.put("column", column);
-
-        List<String> values;
-        try {
-            values = jdbcTemplate.queryForList(
-                    "SELECT DISTINCT " + column + " FROM " + table + " WHERE " + column + " IS NOT NULL",
-                    String.class);
-        } catch (Exception e) {
-            log.warn("[마이그레이션] 조회 실패 table={} column={} : {}", table, column, e.toString());
-            r.put("distinct", 0);
-            r.put("changed", 0);
-            r.put("skipped", 0);
-            r.put("error", e.getMessage());
-            return r;
-        }
-
-        int changed = 0;
-        int skipped = 0;
-        for (String value : values) {
-            String normalized;
-            try {
-                // 평문 → 인코딩, 이미 인코딩 → 동일값 (멱등)
-                normalized = converter.convertToDatabaseColumn(converter.convertToEntityAttribute(value));
-            } catch (Exception e) {
-                log.warn("[마이그레이션] 정규화 실패 table={} column={} : {}", table, column, e.toString());
-                continue;
-            }
-            if ((normalized == null || normalized.isEmpty()) && !value.isEmpty()) {
-                // 방어: 원본이 비어있지 않은데 정규화 결과가 빈 값 → 절대 UPDATE 하지 않음 (데이터 소실 방지)
-                skipped++;
-                log.warn("[마이그레이션] 정규화 결과가 빈 값 — UPDATE 생략 table={} column={} valueLen={}",
-                        table, column, value.length());
-                continue;
-            }
-            if (normalized != null && !normalized.equals(value)) {
-                if (!dryRun) {
-                    jdbcTemplate.update(
-                            "UPDATE " + table + " SET " + column + " = ? WHERE " + column + " = ?",
-                            normalized, value);
-                }
-                changed++;
-            }
-        }
-
-        r.put("distinct", values.size());
-        r.put("changed", changed);
-        r.put("skipped", skipped);
-        return r;
-    }
-
-    /**
-     * damo-manager 가 bypass 모드면 실행 자체를 거부한다.
-     * bypass 에서는 {@code encrypt} 가 무변환(원문 그대로)이라 정규화가 평문→평문 no-op 이 되어
-     * 마이그레이션이 의미가 없고, "완료"로 오인될 위험이 있다. real/fake 모드로 기동 후 실행해야 한다.
-     */
-    private void assertNotBypass() {
-        if (converter.isBypassMode()) {
-            log.warn("[마이그레이션] bypass 모드 실행 거부 — 암복호화가 무변환이라 마이그레이션이 무의미함");
-            throw new ResponseStatusException(HttpStatus.CONFLICT,
-                    "damo-manager 가 bypass 모드입니다. 암복호화가 무변환(원문 그대로)이라 마이그레이션이 무의미하므로 거부합니다. "
-                    + "real/fake 모드(-Ddamo-manager.enabled=true)로 기동한 뒤 실행하세요.");
-        }
-    }
-
-    /**
-     * PTL_PROPERTY({@code Portal / migration.internal.allow-ips}) 허용 IP 목록 검사.
-     * 프록시 경유(X-Forwarded-For 존재) 요청은 IP 신뢰 불가로 거부한다. ({@code MenuInternalController} 모델)
-     * 운영 서버는 bind IP 가 NIC IP 라 loopback 기본값으로는 호출 불가 — 실행 전 property 에
-     * 호출자 IP 를 추가하고 완료 후 원복한다.
-     */
-    private void assertAllowedIp(HttpServletRequest request) {
-        String remote = canonicalize(request.getRemoteAddr());
-        boolean viaProxy = request.getHeader("X-Forwarded-For") != null;
-
-        Set<String> allowed = Arrays.stream(resolveAllowIps().split(","))
-                .map(String::trim)
-                .filter(ip -> !ip.isEmpty())
-                .map(LegacyEncryptionMigrationController::canonicalize)
-                .collect(Collectors.toSet());
-
-        if (viaProxy || !allowed.contains(remote)) {
-            log.warn("[마이그레이션] 비허용 접근 차단 remoteAddr={} viaProxy={} xff={}",
-                    StringMaskingUtil.maskIpAddress(remote), viaProxy,
-                    StringMaskingUtil.maskIpAddress(request.getHeader("X-Forwarded-For")));
-            throw new ResponseStatusException(HttpStatus.FORBIDDEN,
-                    "허용되지 않은 접근입니다. (PTL_PROPERTY " + PROP_GROUP + "/" + PROP_ALLOW_IPS + " 확인)");
-        }
-    }
-
-    private String resolveAllowIps() {
-        try {
-            return portalPropertyService.getOrCreateProperty(PROP_GROUP, PROP_ALLOW_IPS,
-                    DEFAULT_ALLOW_IPS, "레거시 암호화 마이그레이션 내부 API 허용 IP 목록(콤마 구분)");
-        } catch (Exception e) {
-            log.warn("[마이그레이션] 허용 IP 목록 조회 실패 - 기본값({}) 사용", DEFAULT_ALLOW_IPS, e);
-            return DEFAULT_ALLOW_IPS;
-        }
-    }
-
-    /** IPv6 loopback 표기 통일 */
-    private static String canonicalize(String ip) {
-        return "0:0:0:0:0:0:0:1".equals(ip) ? "::1" : ip;
-    }
-
-    private static final class TargetTable {
-        final String table;
-        final List<String> columns;
-
-        TargetTable(String table, List<String> columns) {
-            this.table = table;
-            this.columns = columns;
-        }
-    }
-}

src/main/java/com/eactive/apim/portal/common/security/AccountLockService.java

@@ -0,0 +1,52 @@
+package com.eactive.apim.portal.common.security;
+
+import com.eactive.apim.portal.portaluser.entity.PortalUser;
+import com.eactive.apim.portal.portaluser.repository.PortalUserRepository;
+import com.eactive.apim.portal.template.entity.MessageCode;
+import com.eactive.apim.portal.template.service.MessageHandlerService;
+import com.eactive.apim.portal.template.service.MessageRecipient;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.groovy.util.Maps;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * 계정 잠금 처리 단일 지점.
+ *
+ * <p>로그인 연속 실패(`PortalAuthenticationFailureHandler`)와 본인확인 연속 실패
+ * (`PasswordConfirmFailureTracker`)가 같은 방식으로 계정을 잠그도록 로직을 모았다.</p>
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class AccountLockService {
+
+    private final PortalUserRepository portalUserRepository;
+    private final MessageHandlerService messageHandlerService;
+
+    /**
+     * 계정을 잠그고 잠금 알림을 발송한다. 이미 잠긴 계정이면 알림을 중복 발송하지 않는다.
+     *
+     * <p>호출자의 트랜잭션에 참여한다 — 로그인 실패 핸들러는 이미 자신만의
+     * {@code REQUIRES_NEW} 트랜잭션에서 실행되므로 별도 전파를 두면 같은 row 를 두 트랜잭션이
+     * 잠그게 된다.</p>
+     *
+     * @param reason 알림 문구에 실을 잠금 사유
+     */
+    @Transactional
+    public void lock(PortalUser user, String reason) {
+        if (user == null) {
+            return;
+        }
+        if ("Y".equals(user.getAccountLockYn())) {
+            return;
+        }
+
+        user.setAccountLockYn("Y");
+        portalUserRepository.save(user);
+        messageHandlerService.publishEvent(MessageCode.USER_ACCOUNT_LOCKED,
+                MessageRecipient.of(user), Maps.of("reason", reason));
+        log.warn("계정 잠금 처리 userId={} reason={}", user.getId(), reason);
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/PasswordConfirmFailurePolicy.java

@@ -0,0 +1,75 @@
+package com.eactive.apim.portal.common.security;
+
+import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+/**
+ * 중요 페이지 진입용 비밀번호 재인증(본인확인)의 연속 실패 정책을 DB(PortalProperty)에서 조회한다.
+ *
+ * <ul>
+ *   <li>{@code password.confirm.failure.limit} - 연속 실패 허용 횟수 (기본 {@value #DEFAULT_LIMIT})</li>
+ *   <li>{@code password.confirm.failure.action} - 임계 초과 시 조치 ({@code LOGOUT} / {@code LOCK})</li>
+ * </ul>
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PasswordConfirmFailurePolicy {
+
+    private static final String GROUP = "Portal";
+    private static final String NAME_LIMIT = "password.confirm.failure.limit";
+    private static final String NAME_ACTION = "password.confirm.failure.action";
+
+    /** 프로퍼티 미존재/파싱 실패 시 기본 허용 횟수 */
+    public static final int DEFAULT_LIMIT = 5;
+
+    /** 임계 초과 시 조치 */
+    public enum Action {
+        /** 세션만 강제 종료 (기본) */
+        LOGOUT,
+        /** 계정을 잠근 뒤 세션도 종료 — 재로그인 자체가 차단된다 */
+        LOCK;
+
+        public static final Action DEFAULT = LOGOUT;
+
+        public static Action from(String raw) {
+            if (raw == null || raw.trim().isEmpty()) {
+                return DEFAULT;
+            }
+            try {
+                return Action.valueOf(raw.trim().toUpperCase());
+            } catch (IllegalArgumentException e) {
+                log.warn("{} 값이 유효하지 않음('{}') - 기본값 {} 사용", NAME_ACTION, raw, DEFAULT);
+                return DEFAULT;
+            }
+        }
+    }
+
+    private final PortalPropertyService portalPropertyService;
+
+    /** 연속 실패가 이 값 이상이면 {@link #action()} 을 수행한다. */
+    public int limit() {
+        String raw = portalPropertyService.getOrCreateProperty(
+                GROUP, NAME_LIMIT, String.valueOf(DEFAULT_LIMIT),
+                "본인확인(비밀번호 재인증) 연속 실패 허용 횟수 (이 값 이상 실패 시 조치)");
+        try {
+            int parsed = Integer.parseInt(raw.trim());
+            if (parsed > 0) {
+                return parsed;
+            }
+            log.warn("{} 값이 0 이하({}) - 기본값 {} 사용", NAME_LIMIT, parsed, DEFAULT_LIMIT);
+        } catch (NumberFormatException e) {
+            log.warn("{} 값이 숫자가 아님('{}') - 기본값 {} 사용", NAME_LIMIT, raw, DEFAULT_LIMIT);
+        }
+        return DEFAULT_LIMIT;
+    }
+
+    /** 임계 초과 시 조치 */
+    public Action action() {
+        return Action.from(portalPropertyService.getOrCreateProperty(
+                GROUP, NAME_ACTION, Action.DEFAULT.name(),
+                "본인확인 연속 실패 임계 초과 시 조치 (LOGOUT=강제 로그아웃, LOCK=계정 차단 후 로그아웃)"));
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/PasswordConfirmFailureTracker.java

@@ -0,0 +1,131 @@
+package com.eactive.apim.portal.common.security;
+
+import com.eactive.apim.portal.apps.session.service.UserSessionService;
+import com.eactive.apim.portal.common.security.PasswordConfirmFailurePolicy.Action;
+import com.eactive.apim.portal.common.user.PortalAuthenticatedUser;
+import com.eactive.apim.portal.common.util.SecurityUtil;
+import com.eactive.apim.portal.portaluser.entity.PortalUser;
+import com.eactive.apim.portal.portaluser.repository.PortalUserRepository;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;
+import org.springframework.stereotype.Service;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.util.Optional;
+
+/**
+ * 중요 페이지 진입 시 비밀번호 재인증(본인확인)의 연속 실패를 추적하고 임계 초과 시 조치한다.
+ *
+ * <p>무차별 대입 방어. 카운터는 세션 attribute 로 유지하고, 임계 초과 시
+ * {@link PasswordConfirmFailurePolicy.Action} 에 따라 강제 로그아웃하거나 계정을 잠근다.
+ * step-up 확인 페이지·webhook·비밀번호 변경 진입이 모두 이 클래스를 쓴다.</p>
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PasswordConfirmFailureTracker {
+
+    /** 연속 실패 횟수 세션 attribute 키 */
+    public static final String ATTR_FAIL_COUNT = "STEPUP_PW_CONFIRM_FAIL_COUNT";
+
+    private final PasswordConfirmFailurePolicy policy;
+    private final UserSessionService userSessionService;
+    private final AccountLockService accountLockService;
+    private final PortalUserRepository portalUserRepository;
+
+    /** 실패 처리 결과 */
+    @Getter
+    public static class Outcome {
+
+        private final int failCount;
+        private final int limit;
+        private final boolean forcedLogout;
+        private final boolean accountLocked;
+        private final String message;
+
+        Outcome(int failCount, int limit, boolean forcedLogout, boolean accountLocked, String message) {
+            this.failCount = failCount;
+            this.limit = limit;
+            this.forcedLogout = forcedLogout;
+            this.accountLocked = accountLocked;
+            this.message = message;
+        }
+    }
+
+    /** 확인 성공 시 카운터 초기화 */
+    public void reset(HttpSession session) {
+        if (session != null) {
+            session.removeAttribute(ATTR_FAIL_COUNT);
+        }
+    }
+
+    /**
+     * 실패 1회를 기록하고, 임계에 도달했으면 정책에 따라 조치(로그아웃 또는 계정 잠금 후 로그아웃)한다.
+     * 조치가 수행되면 호출자는 로그인 화면으로 보내기만 하면 된다.
+     */
+    public Outcome recordFailure(HttpSession session, HttpServletRequest request, HttpServletResponse response) {
+        int limit = policy.limit();
+        int failCount = increment(session);
+
+        if (failCount < limit) {
+            return new Outcome(failCount, limit, false, false,
+                policy.action() == Action.LOCK
+                    ? "현재 비밀번호가 일치하지 않습니다. 보안을 위해 반복 실패 시 계정 이용이 제한됩니다."
+                    : "현재 비밀번호가 일치하지 않습니다. 보안을 위해 반복 실패 시 자동 로그아웃됩니다.");
+        }
+
+        boolean locked = false;
+        if (policy.action() == Action.LOCK) {
+            locked = lockCurrentUser(limit);
+        }
+
+        forceLogout(session, request, response);
+        log.warn("본인확인 비밀번호 반복 실패로 {} 처리", locked ? "계정 차단" : "강제 로그아웃");
+
+        return new Outcome(failCount, limit, true, locked,
+            locked
+                ? "비밀번호 확인 반복 실패로 계정이 차단되었습니다. 관리자에게 문의해 주세요."
+                : "비밀번호 확인 반복 실패로 로그아웃되었습니다.");
+    }
+
+    private int increment(HttpSession session) {
+        Integer count = (Integer) session.getAttribute(ATTR_FAIL_COUNT);
+        int next = (count == null ? 0 : count) + 1;
+        session.setAttribute(ATTR_FAIL_COUNT, next);
+        return next;
+    }
+
+    /**
+     * 현재 사용자를 잠근다. 로그인 실패 카운트도 임계치로 맞춰 두어야
+     * 세션을 새로 받아도 잠금 상태가 이어진다.
+     */
+    private boolean lockCurrentUser(int limit) {
+        PortalAuthenticatedUser current = SecurityUtil.getPortalAuthenticatedUser();
+        if (current == null) {
+            return false;
+        }
+        Optional<PortalUser> found = portalUserRepository.findById(current.getId());
+        if (!found.isPresent()) {
+            return false;
+        }
+        PortalUser user = found.get();
+        if (user.getLoginFailureCount() == null || user.getLoginFailureCount() < limit) {
+            user.setLoginFailureCount(limit);
+            portalUserRepository.save(user);
+        }
+        accountLockService.lock(user, "본인확인 비밀번호 반복 실패로 인한 계정 차단");
+        return true;
+    }
+
+    private void forceLogout(HttpSession session, HttpServletRequest request, HttpServletResponse response) {
+        // SecurityContextLogoutHandler 는 HTTP 세션만 무효화하므로 DB 세션 레코드를 먼저 정리한다.
+        userSessionService.removeSession(session.getId());
+        new SecurityContextLogoutHandler().logout(request, response,
+            SecurityContextHolder.getContext().getAuthentication());
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/PasswordPolicyProperties.java

@@ -0,0 +1,36 @@
+package com.eactive.apim.portal.common.security;
+
+import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+/**
+ * 비밀번호 문자열 정책 중 DB(PortalProperty)로 on/off 하는 항목을 조회한다.
+ *
+ * <p>group 은 기존 {@code Portal} 을 재사용하여 {@link PortalPropertyService#getOrCreateProperty}
+ * 의 자동 생성이 동작하도록 한다.</p>
+ *
+ * <ul>
+ *   <li>{@code password.keyboard-sequence.block} - 키보드 배열 연속 문자(qwe/asd 등) 사용 금지</li>
+ * </ul>
+ */
+@Service
+@RequiredArgsConstructor
+public class PasswordPolicyProperties {
+
+    private static final String GROUP = "Portal";
+    private static final String NAME_KEYBOARD_SEQUENCE = "password.keyboard-sequence.block";
+
+    /** 프로퍼티 미존재/파싱 실패 시 기본값 (차단) */
+    public static final boolean DEFAULT_KEYBOARD_SEQUENCE_BLOCK = true;
+
+    private final PortalPropertyService portalPropertyService;
+
+    /** 키보드 배열 연속 문자 3자리 이상 사용 금지 여부 */
+    public boolean isKeyboardSequenceBlocked() {
+        return Boolean.parseBoolean(
+                portalPropertyService.getOrCreateProperty(GROUP, NAME_KEYBOARD_SEQUENCE,
+                        String.valueOf(DEFAULT_KEYBOARD_SEQUENCE_BLOCK),
+                        "키보드 배열 연속 문자(qwe·asd 등) 3자리 이상 사용 금지 여부 (true/false)").trim());
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/SecurityPolicyPropertySeeder.java

@@ -0,0 +1,49 @@
+package com.eactive.apim.portal.common.security;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.ApplicationListener;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * 기동 시 보안 정책 PTL_PROPERTY 를 미리 생성한다.
+ *
+ * <p>PTL_PROPERTY 에는 (GROUP, NAME) 유니크 제약이 없어
+ * {@code getOrCreateProperty} 최초 조회가 동시 요청으로 경합하면 같은 키가 중복 INSERT 된다
+ * (중복 시 Hibernate 가 {@code More than one row with the given identifier} 로 실패한다).
+ * 특히 {@link PasswordPolicyProperties} 는 GlobalControllerAdvice 를 통해 <b>매 요청</b> 조회되므로
+ * 기동 직후 동시 접속에서 경합할 가능성이 높다.</p>
+ *
+ * <p>부팅 완료 시점에 단일 스레드로 한 번 조회해 두면 이후 요청은 항상 기존 행을 읽는다.
+ * {@code PortalPropertyDuplicateChecker} 보다 먼저 실행되도록 우선순위를 높인다.</p>
+ */
+@Slf4j
+@Component
+@RequiredArgsConstructor
+@Order(Ordered.HIGHEST_PRECEDENCE)
+public class SecurityPolicyPropertySeeder implements ApplicationListener<ApplicationReadyEvent> {
+
+    private final PasswordPolicyProperties passwordPolicyProperties;
+    private final WriteRateLimitPolicy writeRateLimitPolicy;
+    private final PasswordConfirmFailurePolicy passwordConfirmFailurePolicy;
+
+    @Override
+    @Transactional
+    public void onApplicationEvent(ApplicationReadyEvent event) {
+        try {
+            boolean keyboardSequenceBlock = passwordPolicyProperties.isKeyboardSequenceBlocked();
+            int writeLimit = writeRateLimitPolicy.perMinuteLimit();
+            int confirmLimit = passwordConfirmFailurePolicy.limit();
+            PasswordConfirmFailurePolicy.Action confirmAction = passwordConfirmFailurePolicy.action();
+            log.info("[보안 정책] keyboard-sequence.block={}, write.rate-limit.per-minute={}, "
+                    + "password.confirm.failure.limit={}, password.confirm.failure.action={}",
+                keyboardSequenceBlock, writeLimit, confirmLimit, confirmAction);
+        } catch (Exception e) {
+            log.warn("[보안 정책] PTL_PROPERTY 사전 생성 실패 — 최초 요청 시 생성된다", e);
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/WriteRateLimitPolicy.java

@@ -0,0 +1,46 @@
+package com.eactive.apim.portal.common.security;
+
+import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+/**
+ * 게시물·댓글·피드백 작성의 1분당 허용 건수를 DB(PortalProperty)에서 조회한다.
+ *
+ * <p>PTL_PROPERTY (group={@code Portal}, name={@code write.rate-limit.per-minute}) 값으로 제어한다.
+ * 허용 범위는 {@value #MIN_LIMIT}~{@value #MAX_LIMIT} 이며 벗어나거나 숫자가 아니면 기본값
+ * {@value #DEFAULT_LIMIT} 로 동작한다. {@code 0} 은 제한 없음을 뜻한다.</p>
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class WriteRateLimitPolicy {
+
+    private static final String GROUP = "Portal";
+    private static final String NAME = "write.rate-limit.per-minute";
+
+    /** 프로퍼티 미존재/파싱 실패 시 기본 허용 건수 */
+    public static final int DEFAULT_LIMIT = 1;
+    private static final int MIN_LIMIT = 0;
+    private static final int MAX_LIMIT = 10;
+
+    private final PortalPropertyService portalPropertyService;
+
+    /** 1분당 작성 허용 건수. 0 이면 제한하지 않는다. */
+    public int perMinuteLimit() {
+        String raw = portalPropertyService.getOrCreateProperty(
+                GROUP, NAME, String.valueOf(DEFAULT_LIMIT),
+                "1분당 게시물·댓글·피드백 작성 허용 건수 (" + MIN_LIMIT + "~" + MAX_LIMIT + ", 0=제한없음)");
+        try {
+            int parsed = Integer.parseInt(raw.trim());
+            if (parsed >= MIN_LIMIT && parsed <= MAX_LIMIT) {
+                return parsed;
+            }
+            log.warn("{} 값이 허용 범위({}~{}) 밖({}) - 기본값 {} 사용", NAME, MIN_LIMIT, MAX_LIMIT, parsed, DEFAULT_LIMIT);
+        } catch (NumberFormatException e) {
+            log.warn("{} 값이 숫자가 아님('{}') - 기본값 {} 사용", NAME, raw, DEFAULT_LIMIT);
+        }
+        return DEFAULT_LIMIT;
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/WriteRateLimitService.java

@@ -0,0 +1,119 @@
+package com.eactive.apim.portal.common.security;
+
+import com.eactive.apim.portal.apps.community.partnership.repository.PartnershipApplicationRepository;
+import com.eactive.apim.portal.apps.community.qna.repository.InquiryRepository;
+import com.eactive.apim.portal.common.entity.Auditable;
+import com.eactive.apim.portal.common.exception.TooManyWriteRequestsException;
+import com.eactive.apim.portal.common.user.PortalAuthenticatedUser;
+import com.eactive.apim.portal.common.util.SecurityUtil;
+import com.eactive.apim.portal.djb.community.qna.comment.repository.InquiryCommentRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 작성 요청 빈도 제한(무제한 요청 차단).
+ *
+ * <p>카운터는 대상별로 독립이며 저장소는 DB 다 — 세션 재발급·다중 탭으로 우회할 수 없다.
+ * 허용 건수는 {@link WriteRateLimitPolicy} 가 PortalProperty 에서 읽는다.</p>
+ *
+ * <p>판정은 "최신 N건을 뽑아 N번째가 1분 이내인가" 로 한다. {@code createdDate} 는
+ * {@code LocalDateTimeToStringConverter} 로 문자열 저장되므로 쿼리에서 범위 비교하지 않고
+ * Java 에서 비교한다.</p>
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class WriteRateLimitService {
+
+    /** 빈도 판정 기준 구간 */
+    private static final Duration WINDOW = Duration.ofMinutes(1);
+
+    /** 빈도 제한 대상. 대상별로 카운터가 독립이다. */
+    public enum WriteTarget {
+        INQUIRY("Q&A 문의"),
+        INQUIRY_COMMENT("댓글"),
+        PARTNERSHIP("피드백/개선요청");
+
+        private final String label;
+
+        WriteTarget(String label) {
+            this.label = label;
+        }
+
+        public String getLabel() {
+            return label;
+        }
+    }
+
+    private final WriteRateLimitPolicy writeRateLimitPolicy;
+    private final InquiryRepository inquiryRepository;
+    private final InquiryCommentRepository inquiryCommentRepository;
+    private final PartnershipApplicationRepository partnershipApplicationRepository;
+
+    /** 현재 로그인 사용자 기준으로 허용 빈도를 넘었는지 */
+    public boolean isExceeded(WriteTarget target) {
+        return isExceeded(target, currentUserId());
+    }
+
+    /** 허용 빈도를 넘었는지. userId 가 없으면(비인증) 판정하지 않는다. */
+    @Transactional(readOnly = true)
+    public boolean isExceeded(WriteTarget target, String userId) {
+        int limit = writeRateLimitPolicy.perMinuteLimit();
+        if (limit <= 0 || userId == null || userId.isEmpty()) {
+            return false;
+        }
+
+        List<? extends Auditable> recent = findRecent(target, userId, limit);
+        if (recent.size() < limit) {
+            return false;
+        }
+
+        LocalDateTime oldestOfWindow = recent.get(limit - 1).getCreatedDate();
+        boolean exceeded = oldestOfWindow != null && oldestOfWindow.isAfter(LocalDateTime.now().minus(WINDOW));
+        if (exceeded) {
+            log.warn("작성 빈도 제한 초과 target={} limit={}/분", target, limit);
+        }
+        return exceeded;
+    }
+
+    /** 허용 빈도를 넘었으면 예외. JSON 응답 컨트롤러 전용. */
+    public void assertNotExceeded(WriteTarget target) {
+        if (isExceeded(target)) {
+            throw new TooManyWriteRequestsException(exceededMessage(target));
+        }
+    }
+
+    /** 사용자에게 보여줄 차단 안내 문구 */
+    public String exceededMessage(WriteTarget target) {
+        return target.getLabel() + " 작성은 1분에 " + writeRateLimitPolicy.perMinuteLimit()
+            + "건까지 가능합니다. 잠시 후 다시 시도해 주세요.";
+    }
+
+    /** 감사 필드 createdBy 와 동일한 식별자(PortalUser.id). 비인증이면 null. */
+    private static String currentUserId() {
+        PortalAuthenticatedUser user = SecurityUtil.getPortalAuthenticatedUser();
+        return user == null ? null : user.getId();
+    }
+
+    private List<? extends Auditable> findRecent(WriteTarget target, String userId, int limit) {
+        PageRequest page = PageRequest.of(0, limit);
+        switch (target) {
+            case INQUIRY:
+                return inquiryRepository.findByCreatedByOrderByCreatedDateDesc(userId, page);
+            case INQUIRY_COMMENT:
+                return inquiryCommentRepository.findByCreatedByOrderByCreatedDateDesc(userId, page);
+            case PARTNERSHIP:
+                return partnershipApplicationRepository.findByCreatedByOrderByCreatedDateDesc(userId, page);
+            default:
+                return Collections.emptyList();
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/DecryptingRequestWrapper.java

@@ -0,0 +1,148 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import lombok.extern.slf4j.Slf4j;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletRequestWrapper;
+import java.security.PrivateKey;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 봉투(ENC1) 형식으로 들어온 파라미터 값을 평문으로 되돌리는 요청 래퍼.
+ *
+ * <p><b>지연 복호화가 필수다.</b> 생성자에서 {@code getParameterMap()} 을 부르면 컨테이너가 요청 본문을
+ * 파싱해버려, 본문을 직접 읽는 필터({@code ApiTesterFilter})가 이후 {@code getInputStream()} 을 못 쓴다.
+ * 따라서 값은 {@code getParameter*} 호출 시점에만 건드린다.</p>
+ *
+ * <p>Lucy XSS 필터({@code order = MIN_VALUE + 1})보다 <b>앞</b>에서 이 래퍼가 씌워지므로,
+ * 복호화된 평문이 기존과 똑같이 XSS 이스케이프를 거친다. 순서가 뒤바뀌면 특수문자가 든 비밀번호의
+ * 이스케이프 여부가 달라져 기존 계정 로그인이 깨진다.</p>
+ */
+@Slf4j
+public class DecryptingRequestWrapper extends HttpServletRequestWrapper {
+
+    private final PasswordEnvelopeCodec codec;
+    private final PasswordKeyStore keyStore;
+    private final PasswordCryptoProperties properties;
+
+    /** 봉투 원문 → 평문. 같은 값이 여러 번 조회돼도 RSA 연산은 한 번만 한다. */
+    private final Map<String, String> decrypted = new HashMap<>();
+
+    /** 요청 처리 후 폐기할 keyId(1회용 키 모드). */
+    private final Set<String> usedKeyIds = new LinkedHashSet<>();
+
+    private Map<String, String[]> parameterMapCache;
+
+    public DecryptingRequestWrapper(HttpServletRequest request,
+                                    PasswordEnvelopeCodec codec,
+                                    PasswordKeyStore keyStore,
+                                    PasswordCryptoProperties properties) {
+        super(request);
+        this.codec = codec;
+        this.keyStore = keyStore;
+        this.properties = properties;
+    }
+
+    @Override
+    public String getParameter(String name) {
+        return convert(name, super.getParameter(name));
+    }
+
+    @Override
+    public String[] getParameterValues(String name) {
+        String[] values = super.getParameterValues(name);
+        if (values == null) {
+            return null;
+        }
+        String[] converted = new String[values.length];
+        for (int i = 0; i < values.length; i++) {
+            converted[i] = convert(name, values[i]);
+        }
+        return converted;
+    }
+
+    @Override
+    public Map<String, String[]> getParameterMap() {
+        if (parameterMapCache == null) {
+            Map<String, String[]> source = super.getParameterMap();
+            Map<String, String[]> result = new HashMap<>(Math.max(16, source.size() * 2));
+            for (Map.Entry<String, String[]> entry : source.entrySet()) {
+                String name = entry.getKey();
+                String[] values = entry.getValue();
+                String[] converted = new String[values.length];
+                for (int i = 0; i < values.length; i++) {
+                    converted[i] = convert(name, values[i]);
+                }
+                result.put(name, converted);
+            }
+            parameterMapCache = Collections.unmodifiableMap(result);
+        }
+        return parameterMapCache;
+    }
+
+    /** 요청 처리가 끝난 뒤 필터가 호출한다. 1회용 키를 폐기해 재전송을 막는다. */
+    void consumeUsedKeys() {
+        for (String keyId : usedKeyIds) {
+            keyStore.consume(keyId, (HttpServletRequest) getRequest());
+        }
+        usedKeyIds.clear();
+    }
+
+    private String convert(String name, String value) {
+        if (value == null || value.isEmpty()) {
+            return value;
+        }
+        if (!codec.isEnvelope(value)) {
+            // strict 모드에서는 평문 비밀번호를 받아들이지 않는다. 예외를 던지면 로그인 경로가 500 이 되므로
+            // 빈 값으로 바꿔 기존 인증 실패 흐름(아이디/비밀번호 확인)을 타게 한다.
+            if (properties.isStrict() && PasswordParamNames.isPasswordLike(name)) {
+                log.warn("암호화되지 않은 비밀번호 파라미터 거부(strict) - uri={}, param={}", getRequestURI(), name);
+                return "";
+            }
+            return value;
+        }
+
+        String cached = decrypted.get(value);
+        if (cached != null) {
+            return cached;
+        }
+
+        String keyId = codec.keyIdOf(value);
+        if (keyId == null) {
+            log.warn("봉투 형식 오류 - uri={}, param={}", getRequestURI(), name);
+            return failed(value);
+        }
+
+        PrivateKey privateKey = keyStore.resolve(keyId, (HttpServletRequest) getRequest());
+        if (privateKey == null) {
+            log.warn("전송암호화 키를 찾을 수 없음(만료·인스턴스 불일치) - uri={}, param={}, keyId={}",
+                getRequestURI(), name, keyId);
+            return failed(value);
+        }
+
+        try {
+            String plain = codec.decrypt(value, privateKey);
+            decrypted.put(value, plain);
+            usedKeyIds.add(keyId);
+            return plain;
+        } catch (PasswordDecryptException e) {
+            log.warn("전송암호화 복호화 실패 - uri={}, param={}, keyId={}, reason={}",
+                getRequestURI(), name, keyId, e.getMessage());
+            usedKeyIds.add(keyId);
+            return failed(value);
+        }
+    }
+
+    /**
+     * 복호화 실패 시의 값. 봉투 문자열을 그대로 흘려보내면 비밀번호 정책 검증 등이 엉뚱하게 통과할 수 있어
+     * 빈 값으로 바꾼다. 결과적으로 사용자에게는 일반적인 입력값 오류로 보인다.
+     */
+    private String failed(String rawValue) {
+        decrypted.put(rawValue, "");
+        return "";
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/IssuedKey.java

@@ -0,0 +1,21 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+/**
+ * 클라이언트에 내려줄 공개키 1건. {@code PasswordKeyController} 응답 본문이기도 하다.
+ */
+@Data
+@AllArgsConstructor
+public class IssuedKey {
+
+    /** 봉투(ENC1)의 두 번째 세그먼트로 되돌아오는 키 식별자. */
+    private final String keyId;
+
+    /** X.509 SubjectPublicKeyInfo(SPKI) DER 을 표준 base64 로 인코딩한 값. */
+    private final String publicKey;
+
+    /** 남은 수명(초). 클라이언트 캐시 판단용. */
+    private final int expiresIn;
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordCryptoProperties.java

@@ -0,0 +1,52 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 비밀번호 전송암호화 설정. {@code portal.security.password-encrypt.*}
+ *
+ * <p>브라우저 개발자도구 Network 탭에 비밀번호가 평문으로 보이는 것을 막기 위한 기능이다.
+ * 로컬 개발환경은 HTTP(비 secure context)라 브라우저 {@code crypto.subtle} 을 쓸 수 없으므로
+ * {@link #enabled} 를 꺼둔다. 켜져 있어도 브라우저가 지원하지 못하면 클라이언트가 평문으로 폴백한다.</p>
+ *
+ * <p><b>이 기능은 XSS 방어가 아니다.</b> 스크립트가 주입되면 입력창에서 직접 탈취할 수 있다.
+ * "전송 페이로드 평문 노출" 점검 지적에 대한 대응 범위로만 이해할 것.</p>
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "portal.security.password-encrypt")
+public class PasswordCryptoProperties {
+
+    /**
+     * RSA 개인키 보관 범위.
+     *
+     * <ul>
+     *   <li>{@code REQUEST} - 폼 진입마다 1회용 키를 발급하고 요청 1회 사용 후 폐기. 재전송 공격 차단이 가장 강하다.</li>
+     *   <li>{@code SESSION} - 세션 단위로 키를 보관. 세션 복제 환경에 유리하다.</li>
+     *   <li>{@code SERVER}  - 서버 고정 키쌍 + TTL 로테이션. 무상태라 가장 단순하지만 재전송 방지 수단이 없다.</li>
+     * </ul>
+     */
+    public enum KeyScope {
+        REQUEST, SESSION, SERVER
+    }
+
+    /** 마스터 스위치. 꺼져 있으면 필터·엔드포인트가 모두 무동작이고 화면은 평문 전송한다. */
+    private boolean enabled = false;
+
+    /** 키 보관 범위. */
+    private KeyScope keyScope = KeyScope.REQUEST;
+
+    /** 발급된 키의 수명(초). REQUEST/SESSION 은 만료 기준, SERVER 는 로테이션 주기. */
+    private int keyTtlSeconds = 300;
+
+    /**
+     * true 면 서버가 평문 비밀번호 파라미터를 거부한다(빈 값으로 치환 → 인증 실패).
+     * JS 비활성 사용자나 구형 브라우저가 로그인하지 못하게 되므로 안정화 후에만 켠다.
+     */
+    private boolean strict = false;
+
+    /** RSA 키 길이. */
+    private int rsaKeySize = 2048;
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordDecryptException.java

@@ -0,0 +1,18 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+/**
+ * 봉투 복호화 실패. 화면으로 스택을 올리지 않고 필터에서 흡수한다.
+ * 메시지에 평문이나 키 자료를 담지 않는다.
+ */
+public class PasswordDecryptException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public PasswordDecryptException(String message) {
+        super(message);
+    }
+
+    public PasswordDecryptException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordDecryptFilter.java

@@ -0,0 +1,61 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import org.springframework.stereotype.Component;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import java.io.IOException;
+
+/**
+ * 봉투(ENC1) 파라미터를 평문으로 되돌리는 서블릿 필터.
+ *
+ * <p>{@code PortalConfigSecurity} 에서 order {@code Integer.MIN_VALUE} 로 등록해
+ * Lucy XSS 필터({@code MIN_VALUE + 1})보다 먼저 실행된다. 자세한 이유는
+ * {@link DecryptingRequestWrapper} 주석 참고.</p>
+ *
+ * <p>기능이 꺼져 있거나 POST 가 아니면 아무것도 하지 않는다. 래퍼는 파라미터를 조회할 때만
+ * 복호화하므로, 봉투가 없는 요청에는 사실상 비용이 없다.</p>
+ */
+@Component
+public class PasswordDecryptFilter implements Filter {
+
+    private final PasswordCryptoProperties properties;
+    private final PasswordEnvelopeCodec codec;
+    private final PasswordKeyStore keyStore;
+
+    public PasswordDecryptFilter(PasswordCryptoProperties properties,
+                                 PasswordEnvelopeCodec codec,
+                                 PasswordKeyStore keyStore) {
+        this.properties = properties;
+        this.codec = codec;
+        this.keyStore = keyStore;
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+        throws IOException, ServletException {
+
+        if (!properties.isEnabled() || !(request instanceof HttpServletRequest)) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+        HttpServletRequest httpRequest = (HttpServletRequest) request;
+        if (!"POST".equalsIgnoreCase(httpRequest.getMethod())) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+        DecryptingRequestWrapper wrapper =
+            new DecryptingRequestWrapper(httpRequest, codec, keyStore, properties);
+        try {
+            chain.doFilter(wrapper, response);
+        } finally {
+            wrapper.consumeUsedKeys();
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordEnvelopeCodec.java

@@ -0,0 +1,104 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import org.springframework.stereotype.Component;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.OAEPParameterSpec;
+import javax.crypto.spec.PSource;
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.security.PrivateKey;
+import java.security.spec.MGF1ParameterSpec;
+import java.util.Base64;
+
+/**
+ * 클라이언트가 만든 봉투(envelope) 문자열의 파싱·복호화.
+ *
+ * <pre>
+ * ENC1.&lt;keyId&gt;.&lt;b64url(RSA-OAEP(AES키))&gt;.&lt;b64url(iv 12B)&gt;.&lt;b64url(AES-GCM 암호문+태그)&gt;
+ * </pre>
+ *
+ * <p>세그먼트는 base64<b>url</b>(패딩 없음)이라 Lucy XSS 이스케이프와 urlencode 를 모두 통과해도
+ * 값이 변형되지 않는다.</p>
+ *
+ * <p>RSA-OAEP 는 반드시 MGF1 해시까지 SHA-256 으로 지정해야 한다. SunJCE 는
+ * {@code OAEPWithSHA-256AndMGF1Padding} 만 지정하면 MGF1 에 SHA-1 을 쓰는데,
+ * 브라우저 Web Crypto 의 {@code RSA-OAEP + SHA-256} 은 MGF1 도 SHA-256 이라 그대로 두면
+ * 복호화가 실패한다.</p>
+ */
+@Component
+public class PasswordEnvelopeCodec {
+
+    public static final String PREFIX = "ENC1.";
+
+    /** AES-GCM 인증 태그 길이(비트). Web Crypto 기본값과 동일. */
+    private static final int GCM_TAG_BITS = 128;
+
+    private static final Base64.Decoder URL_DECODER = Base64.getUrlDecoder();
+
+    /** 값이 봉투 형식인지. 파싱 비용 없이 접두사만 본다. */
+    public boolean isEnvelope(String value) {
+        return value != null && value.startsWith(PREFIX);
+    }
+
+    /** 봉투에서 keyId 만 추출. 형식이 어긋나면 {@code null}. */
+    public String keyIdOf(String value) {
+        String[] parts = split(value);
+        return parts == null ? null : parts[1];
+    }
+
+    /**
+     * RSA 개인키로 AES 키를 풀고 AES-GCM 으로 본문을 복호화한다.
+     *
+     * @throws PasswordDecryptException 형식 오류·키 불일치·태그 검증 실패
+     */
+    public String decrypt(String value, PrivateKey privateKey) {
+        String[] parts = split(value);
+        if (parts == null) {
+            throw new PasswordDecryptException("봉투 형식이 올바르지 않다");
+        }
+        try {
+            Key aesKey = unwrapAesKey(URL_DECODER.decode(parts[2]), privateKey);
+            byte[] iv = URL_DECODER.decode(parts[3]);
+            byte[] cipherText = URL_DECODER.decode(parts[4]);
+
+            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
+            cipher.init(Cipher.DECRYPT_MODE, aesKey, new GCMParameterSpec(GCM_TAG_BITS, iv));
+            return new String(cipher.doFinal(cipherText), StandardCharsets.UTF_8);
+        } catch (PasswordDecryptException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new PasswordDecryptException("봉투 복호화 실패", e);
+        }
+    }
+
+    private Key unwrapAesKey(byte[] wrapped, PrivateKey privateKey) {
+        try {
+            Cipher rsa = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
+            rsa.init(Cipher.DECRYPT_MODE, privateKey, new OAEPParameterSpec(
+                "SHA-256", "MGF1", MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT));
+            return new SecretKeySpec(rsa.doFinal(wrapped), "AES");
+        } catch (Exception e) {
+            throw new PasswordDecryptException("AES 키 언랩 실패", e);
+        }
+    }
+
+    /** {@code ENC1.keyId.encKey.iv.cipher} 5개 세그먼트. 어긋나면 null. */
+    private String[] split(String value) {
+        if (!isEnvelope(value)) {
+            return null;
+        }
+        String[] parts = value.split("\\.", 5);
+        if (parts.length != 5) {
+            return null;
+        }
+        for (String part : parts) {
+            if (part.isEmpty()) {
+                return null;
+            }
+        }
+        return parts;
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordKeyController.java

@@ -0,0 +1,57 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import org.springframework.http.CacheControl;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * 비밀번호 전송암호화용 공개키 발급.
+ *
+ * <p>경로를 {@code /api/**} 아래에 둔 이유: {@code PortalConfigWebDispatcherServlet#addInterceptors}
+ * 가 {@code /api/**} 를 인터셉터(비밀번호 변경 강제·step-up 가드)에서 제외한다. 로그인 전 익명 상태에서
+ * 호출되므로 {@code /api/session/csrf} 와 같은 자리에 있어야 리다이렉트에 걸리지 않는다.</p>
+ *
+ * <p>GET 이라 CSRF 대상이 아니고, 공개키만 나가므로 인증도 요구하지 않는다.</p>
+ */
+@RestController
+@RequestMapping("/api/security")
+public class PasswordKeyController {
+
+    private final PasswordCryptoProperties properties;
+    private final PasswordKeyStore keyStore;
+
+    public PasswordKeyController(PasswordCryptoProperties properties, PasswordKeyStore keyStore) {
+        this.properties = properties;
+        this.keyStore = keyStore;
+    }
+
+    @GetMapping("/password-key.json")
+    public ResponseEntity<Map<String, Object>> issue(HttpServletRequest request) {
+        if (!properties.isEnabled()) {
+            // 클라이언트가 조용히 평문 폴백하도록 200 + enabled:false 로 답한다.
+            return noStore().body(Collections.<String, Object>singletonMap("enabled", Boolean.FALSE));
+        }
+
+        IssuedKey key = keyStore.issue(request);
+        Map<String, Object> body = new java.util.LinkedHashMap<>();
+        body.put("enabled", Boolean.TRUE);
+        body.put("alg", "RSA-OAEP-256");
+        body.put("keyId", key.getKeyId());
+        body.put("publicKey", key.getPublicKey());
+        body.put("expiresIn", key.getExpiresIn());
+        // REQUEST 는 1회용이라 클라이언트가 캐시하면 안 된다. 나머지는 만료까지 재사용해
+        // 비밀번호 검증용 ajax 가 호출마다 RSA 키쌍을 만들게 하지 않는다.
+        body.put("keyScope", properties.getKeyScope().name());
+        return noStore().body(body);
+    }
+
+    private ResponseEntity.BodyBuilder noStore() {
+        return ResponseEntity.ok().cacheControl(CacheControl.noStore());
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordKeyPairs.java

@@ -0,0 +1,52 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.util.Base64;
+import java.util.UUID;
+
+/**
+ * RSA 키쌍 생성/인코딩 헬퍼. 키 보관소 구현들이 공유한다.
+ */
+final class PasswordKeyPairs {
+
+    private PasswordKeyPairs() {
+    }
+
+    static KeyPair generate(int keySize) {
+        try {
+            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
+            generator.initialize(keySize);
+            return generator.generateKeyPair();
+        } catch (NoSuchAlgorithmException e) {
+            throw new IllegalStateException("RSA 키쌍 생성 실패", e);
+        }
+    }
+
+    static String newKeyId() {
+        return UUID.randomUUID().toString().replace("-", "");
+    }
+
+    /** 브라우저 {@code crypto.subtle.importKey('spki', ...)} 가 그대로 먹는 형식. */
+    static String toSpkiBase64(PublicKey publicKey) {
+        return Base64.getEncoder().encodeToString(publicKey.getEncoded());
+    }
+
+    /**
+     * PKCS#8 바이트 → PrivateKey. 세션 복제(직렬화) 환경을 고려해
+     * {@link SessionScopedPasswordKeyStore} 는 키 객체 대신 바이트를 보관한다.
+     */
+    static PrivateKey toPrivateKey(byte[] pkcs8) {
+        try {
+            return KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(pkcs8));
+        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
+            throw new IllegalStateException("RSA 개인키 복원 실패", e);
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordKeyStore.java

@@ -0,0 +1,20 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import javax.servlet.http.HttpServletRequest;
+import java.security.PrivateKey;
+
+/**
+ * 비밀번호 전송암호화용 RSA 키쌍 보관소. 구현체는 {@link PasswordCryptoProperties.KeyScope} 별로 존재하며
+ * {@link PasswordKeyStoreRouter} 가 설정값에 따라 위임한다.
+ */
+public interface PasswordKeyStore {
+
+    /** 새 공개키를 발급한다(구현에 따라 기존 키 재사용). */
+    IssuedKey issue(HttpServletRequest request);
+
+    /** keyId 에 대응하는 개인키. 없거나 만료됐으면 {@code null}. */
+    PrivateKey resolve(String keyId, HttpServletRequest request);
+
+    /** 요청 처리가 끝난 뒤 호출. 1회용 키를 폐기하는 구현에서만 의미가 있다. */
+    void consume(String keyId, HttpServletRequest request);
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordKeyStoreRouter.java

@@ -0,0 +1,57 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.http.HttpServletRequest;
+import java.security.PrivateKey;
+
+/**
+ * {@code portal.security.password-encrypt.key-scope} 설정값에 따라 실제 보관소로 위임한다.
+ * 설정은 yml 이므로 기동 시점에 고정된다(런타임 변경 시 재기동 필요).
+ */
+@Primary
+@Component
+public class PasswordKeyStoreRouter implements PasswordKeyStore {
+
+    private final PasswordCryptoProperties properties;
+    private final RequestScopedPasswordKeyStore requestScoped;
+    private final SessionScopedPasswordKeyStore sessionScoped;
+    private final ServerScopedPasswordKeyStore serverScoped;
+
+    public PasswordKeyStoreRouter(PasswordCryptoProperties properties,
+                                  RequestScopedPasswordKeyStore requestScoped,
+                                  SessionScopedPasswordKeyStore sessionScoped,
+                                  ServerScopedPasswordKeyStore serverScoped) {
+        this.properties = properties;
+        this.requestScoped = requestScoped;
+        this.sessionScoped = sessionScoped;
+        this.serverScoped = serverScoped;
+    }
+
+    @Override
+    public IssuedKey issue(HttpServletRequest request) {
+        return delegate().issue(request);
+    }
+
+    @Override
+    public PrivateKey resolve(String keyId, HttpServletRequest request) {
+        return delegate().resolve(keyId, request);
+    }
+
+    @Override
+    public void consume(String keyId, HttpServletRequest request) {
+        delegate().consume(keyId, request);
+    }
+
+    private PasswordKeyStore delegate() {
+        PasswordCryptoProperties.KeyScope scope = properties.getKeyScope();
+        if (scope == PasswordCryptoProperties.KeyScope.SESSION) {
+            return sessionScoped;
+        }
+        if (scope == PasswordCryptoProperties.KeyScope.SERVER) {
+            return serverScoped;
+        }
+        return requestScoped;
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/PasswordParamNames.java

@@ -0,0 +1,22 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+/**
+ * 비밀번호 계열 파라미터명 판별. {@code strict} 모드에서 "평문으로 오면 안 되는 파라미터"를 가리는 데 쓴다.
+ *
+ * <p>실제 사용 중인 이름은 {@code password}, {@code password2}, {@code confirmPassword},
+ * {@code newPassword}, {@code currentPassword}, {@code inputPassword} 로 모두 "password" 를 포함한다.
+ * 향후 축약형이 생길 것을 대비해 {@code passwd}/{@code pwd} 도 함께 본다.</p>
+ */
+final class PasswordParamNames {
+
+    private PasswordParamNames() {
+    }
+
+    static boolean isPasswordLike(String name) {
+        if (name == null) {
+            return false;
+        }
+        String lower = name.toLowerCase();
+        return lower.contains("password") || lower.contains("passwd") || lower.contains("pwd");
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/RequestScopedPasswordKeyStore.java

@@ -0,0 +1,90 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import javax.servlet.http.HttpServletRequest;
+import java.security.KeyPair;
+import java.security.PrivateKey;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 폼 진입마다 1회용 키를 발급하고 요청 1회 사용 후 폐기하는 보관소({@code key-scope: REQUEST}).
+ *
+ * <p>같은 keyId 로 두 번 복호화할 수 없으므로 재전송(replay) 공격이 차단된다. 개인키가 인스턴스
+ * 로컬 메모리에만 있으므로 WebLogic 다중 인스턴스에서는 스티키 세션이 전제다(현재 CSRF·단일세션
+ * 강제가 이미 세션 고정을 전제한다).</p>
+ */
+@Slf4j
+@Component
+public class RequestScopedPasswordKeyStore implements PasswordKeyStore {
+
+    /** 메모리 폭주 방지 상한. 초과 시 만료 스윕 후에도 남으면 발급을 거절하지 않고 가장 오래된 것부터 버린다. */
+    private static final int MAX_ENTRIES = 20_000;
+
+    private final PasswordCryptoProperties properties;
+    private final Map<String, Entry> entries = new ConcurrentHashMap<>();
+
+    public RequestScopedPasswordKeyStore(PasswordCryptoProperties properties) {
+        this.properties = properties;
+    }
+
+    @Override
+    public IssuedKey issue(HttpServletRequest request) {
+        sweep();
+        KeyPair keyPair = PasswordKeyPairs.generate(properties.getRsaKeySize());
+        String keyId = PasswordKeyPairs.newKeyId();
+        int ttl = properties.getKeyTtlSeconds();
+        entries.put(keyId, new Entry(keyPair.getPrivate(), System.currentTimeMillis() + ttl * 1000L));
+        return new IssuedKey(keyId, PasswordKeyPairs.toSpkiBase64(keyPair.getPublic()), ttl);
+    }
+
+    @Override
+    public PrivateKey resolve(String keyId, HttpServletRequest request) {
+        Entry entry = entries.get(keyId);
+        if (entry == null) {
+            return null;
+        }
+        if (entry.expiresAt < System.currentTimeMillis()) {
+            entries.remove(keyId);
+            return null;
+        }
+        return entry.privateKey;
+    }
+
+    @Override
+    public void consume(String keyId, HttpServletRequest request) {
+        entries.remove(keyId);
+    }
+
+    /** 만료 항목 정리. 발급 시점에만 돌리므로 별도 스케줄러가 필요 없다. */
+    private void sweep() {
+        long now = System.currentTimeMillis();
+        Iterator<Map.Entry<String, Entry>> it = entries.entrySet().iterator();
+        while (it.hasNext()) {
+            if (it.next().getValue().expiresAt < now) {
+                it.remove();
+            }
+        }
+        if (entries.size() >= MAX_ENTRIES) {
+            log.warn("비밀번호 전송암호화 키 보관소 상한 초과 - size={}, 오래된 항목을 버린다", entries.size());
+            Iterator<Map.Entry<String, Entry>> overflow = entries.entrySet().iterator();
+            while (overflow.hasNext() && entries.size() >= MAX_ENTRIES) {
+                overflow.next();
+                overflow.remove();
+            }
+        }
+    }
+
+    private static final class Entry {
+        private final PrivateKey privateKey;
+        private final long expiresAt;
+
+        private Entry(PrivateKey privateKey, long expiresAt) {
+            this.privateKey = privateKey;
+            this.expiresAt = expiresAt;
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/ServerScopedPasswordKeyStore.java

@@ -0,0 +1,81 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import org.springframework.stereotype.Component;
+
+import javax.servlet.http.HttpServletRequest;
+import java.security.KeyPair;
+import java.security.PrivateKey;
+
+/**
+ * 서버 고정 키쌍 + TTL 로테이션 구현({@code key-scope: SERVER}).
+ *
+ * <p>직전 키를 1개 유예 보관해, 로테이션 순간에 이미 공개키를 받아 간 폼이 제출돼도 복호화된다.
+ * 재전송 방지 수단은 없으므로(같은 봉투를 여러 번 보내도 복호화됨) 인증 실패횟수 제한·계정 잠금에
+ * 의존한다. 무상태라 다중 인스턴스에서도 각자 동작하지만, 인스턴스마다 키가 달라
+ * 공개키 발급과 폼 제출이 같은 인스턴스로 가야 한다.</p>
+ */
+@Component
+public class ServerScopedPasswordKeyStore implements PasswordKeyStore {
+
+    private final PasswordCryptoProperties properties;
+
+    private volatile Holder current;
+    private volatile Holder previous;
+
+    public ServerScopedPasswordKeyStore(PasswordCryptoProperties properties) {
+        this.properties = properties;
+    }
+
+    @Override
+    public IssuedKey issue(HttpServletRequest request) {
+        Holder holder = currentHolder();
+        int remaining = (int) Math.max(1, (holder.expiresAt - System.currentTimeMillis()) / 1000L);
+        return new IssuedKey(holder.keyId, holder.publicKeySpki, remaining);
+    }
+
+    @Override
+    public PrivateKey resolve(String keyId, HttpServletRequest request) {
+        Holder holder = current;
+        if (holder != null && holder.keyId.equals(keyId)) {
+            return holder.privateKey;
+        }
+        Holder old = previous;
+        if (old != null && old.keyId.equals(keyId)) {
+            return old.privateKey;
+        }
+        return null;
+    }
+
+    @Override
+    public void consume(String keyId, HttpServletRequest request) {
+        // 고정 키라 폐기하지 않는다.
+    }
+
+    private synchronized Holder currentHolder() {
+        long now = System.currentTimeMillis();
+        if (current == null || current.expiresAt < now) {
+            KeyPair keyPair = PasswordKeyPairs.generate(properties.getRsaKeySize());
+            previous = current;
+            current = new Holder(
+                PasswordKeyPairs.newKeyId(),
+                keyPair.getPrivate(),
+                PasswordKeyPairs.toSpkiBase64(keyPair.getPublic()),
+                now + properties.getKeyTtlSeconds() * 1000L);
+        }
+        return current;
+    }
+
+    private static final class Holder {
+        private final String keyId;
+        private final PrivateKey privateKey;
+        private final String publicKeySpki;
+        private final long expiresAt;
+
+        private Holder(String keyId, PrivateKey privateKey, String publicKeySpki, long expiresAt) {
+            this.keyId = keyId;
+            this.privateKey = privateKey;
+            this.publicKeySpki = publicKeySpki;
+            this.expiresAt = expiresAt;
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/security/passwordcrypto/SessionScopedPasswordKeyStore.java

@@ -0,0 +1,84 @@
+package com.eactive.apim.portal.common.security.passwordcrypto;
+
+import org.springframework.stereotype.Component;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpSession;
+import java.io.Serializable;
+import java.security.KeyPair;
+import java.security.PrivateKey;
+
+/**
+ * 세션 단위로 키쌍을 보관하는 구현({@code key-scope: SESSION}).
+ *
+ * <p>개인키를 객체가 아니라 PKCS#8 바이트로 들고 있어 세션 복제(직렬화)에도 안전하다.
+ * 같은 keyId 가 세션 수명 동안 재사용되므로 재전송 방지는 IV 랜덤성과 애플리케이션의
+ * 인증 실패횟수 제한에 의존한다.</p>
+ */
+@Component
+public class SessionScopedPasswordKeyStore implements PasswordKeyStore {
+
+    private static final String SESSION_ATTR = "DJB_PWD_CRYPTO_KEY";
+
+    private final PasswordCryptoProperties properties;
+
+    public SessionScopedPasswordKeyStore(PasswordCryptoProperties properties) {
+        this.properties = properties;
+    }
+
+    @Override
+    public IssuedKey issue(HttpServletRequest request) {
+        HttpSession session = request.getSession(true);
+        Holder holder = (Holder) session.getAttribute(SESSION_ATTR);
+        long now = System.currentTimeMillis();
+        if (holder == null || holder.expiresAt < now) {
+            KeyPair keyPair = PasswordKeyPairs.generate(properties.getRsaKeySize());
+            holder = new Holder(
+                PasswordKeyPairs.newKeyId(),
+                keyPair.getPrivate().getEncoded(),
+                PasswordKeyPairs.toSpkiBase64(keyPair.getPublic()),
+                now + properties.getKeyTtlSeconds() * 1000L);
+            session.setAttribute(SESSION_ATTR, holder);
+        }
+        int remaining = (int) Math.max(1, (holder.expiresAt - now) / 1000L);
+        return new IssuedKey(holder.keyId, holder.publicKeySpki, remaining);
+    }
+
+    @Override
+    public PrivateKey resolve(String keyId, HttpServletRequest request) {
+        HttpSession session = request.getSession(false);
+        if (session == null) {
+            return null;
+        }
+        Holder holder = (Holder) session.getAttribute(SESSION_ATTR);
+        if (holder == null || !holder.keyId.equals(keyId)) {
+            return null;
+        }
+        if (holder.expiresAt < System.currentTimeMillis()) {
+            session.removeAttribute(SESSION_ATTR);
+            return null;
+        }
+        return PasswordKeyPairs.toPrivateKey(holder.privateKeyPkcs8);
+    }
+
+    @Override
+    public void consume(String keyId, HttpServletRequest request) {
+        // 세션 수명 동안 재사용한다.
+    }
+
+    private static final class Holder implements Serializable {
+        private static final long serialVersionUID = 1L;
+
+        private final String keyId;
+        private final byte[] privateKeyPkcs8;
+        private final String publicKeySpki;
+        private final long expiresAt;
+
+        private Holder(String keyId, byte[] privateKeyPkcs8, String publicKeySpki, long expiresAt) {
+            this.keyId = keyId;
+            this.privateKeyPkcs8 = privateKeyPkcs8;
+            this.publicKeySpki = publicKeySpki;
+            this.expiresAt = expiresAt;
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/common/util/StringMaskingUtil.java

@@ -172,6 +172,50 @@ public class StringMaskingUtil {
         return value;
     }
 
+    /** 요청 파라미터 로깅 시 값을 통째로 가릴 키. 부분일치(소문자)로 본다. */
+    private static final String[] SENSITIVE_PARAM_KEYWORDS = {
+            "password", "passwd", "pwd", "secret", "credential", "token"};
+
+    /**
+     * 요청 파라미터 맵을 로그용 문자열로 만든다. 비밀번호·시크릿·토큰 계열 키는 값을 {@code [****]} 로 가린다.
+     *
+     * <p>비밀번호 전송암호화가 켜져 있어도 이 시점의 파라미터는 이미 복호화된 평문이므로,
+     * 마스킹 없이 로깅하면 암호화 조치가 무의미해진다.</p>
+     *
+     * <pre>id=[user@a.com], password=[****]</pre>
+     */
+    public static String maskParameterMap(java.util.Map<String, String[]> parameterMap) {
+        if (parameterMap == null || parameterMap.isEmpty()) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        for (java.util.Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
+            if (sb.length() > 0) {
+                sb.append(", ");
+            }
+            sb.append(entry.getKey()).append('=');
+            if (isSensitiveParamName(entry.getKey())) {
+                sb.append("[****]");
+            } else {
+                sb.append(Arrays.toString(entry.getValue()));
+            }
+        }
+        return sb.toString();
+    }
+
+    private static boolean isSensitiveParamName(String name) {
+        if (!isValidString(name)) {
+            return false;
+        }
+        String lower = name.toLowerCase();
+        for (String keyword : SENSITIVE_PARAM_KEYWORDS) {
+            if (lower.contains(keyword)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     // 폼(application/x-www-form-urlencoded) 본문에서 값을 리댁트할 파라미터 키(소문자 완전일치)
     private static final java.util.Set<String> SENSITIVE_FORM_PARAMS = new java.util.HashSet<>(Arrays.asList(
             "client_secret", "clientsecret", "secret", "password", "passwd", "pwd",

src/main/java/com/eactive/apim/portal/common/validator/CellPhoneValidator.java

@@ -1,6 +1,7 @@
 package com.eactive.apim.portal.common.validator;
 
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.Strings;
 import org.springframework.stereotype.Component;
 
 import javax.validation.ConstraintValidator;
@@ -39,14 +40,8 @@ public class CellPhoneValidator implements ConstraintValidator<CellPhone, String
         }
 
         // 기존의 prefix 체크 로직 유지
-        return StringUtils.startsWith(cellPhone, "+821") ||
+        return Strings.CS.startsWithAny(cellPhone,
-                StringUtils.startsWith(cellPhone, "821") ||
+                "+821", "821", "010", "011", "016", "017", "018", "019");
-                StringUtils.startsWith(cellPhone, "010") ||
-                StringUtils.startsWith(cellPhone, "011") ||
-                StringUtils.startsWith(cellPhone, "016") ||
-                StringUtils.startsWith(cellPhone, "017") ||
-                StringUtils.startsWith(cellPhone, "018") ||
-                StringUtils.startsWith(cellPhone, "019");
     }
 
     private boolean isValidPartLength(String prefix, String middle, String last) {

src/main/java/com/eactive/apim/portal/common/validator/PasswordRuleValidator.java

@@ -1,7 +1,9 @@
 package com.eactive.apim.portal.common.validator;
 
+import com.eactive.apim.portal.common.security.PasswordPolicyProperties;
 import com.eactive.apim.portal.common.util.PhoneNumberUtil;
 import org.apache.commons.beanutils.PropertyUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 
 import javax.validation.ConstraintValidator;
 import javax.validation.ConstraintValidatorContext;
@@ -26,6 +28,23 @@ public class PasswordRuleValidator implements ConstraintValidator<PasswordRule,
     // 공백 문자 정규식
     private static final String BLANKPT = "(\\s)";
 
+    /** 키보드 배열 인접 판정 기준 길이 (기존 연속 문자/숫자 규칙과 동일하게 3자) */
+    private static final int KEYBOARD_SEQUENCE_LENGTH = 3;
+    /** 키보드 배열 행. 대문자 기준으로 비교한다. */
+    private static final String[] KEYBOARD_ROWS = {
+        "QWERTYUIOP",
+        "ASDFGHJKL",
+        "ZXCVBNM",
+        "1234567890"
+    };
+
+    /**
+     * 키보드 연속 문자 차단 여부. Spring 이 관리하는 경로(LocalValidatorFactoryBean)에서만 주입되며,
+     * 순수 {@code new} 로 생성된 경우 null 이라 기본값(차단)으로 동작한다.
+     */
+    @Autowired(required = false)
+    private PasswordPolicyProperties passwordPolicyProperties;
+
     @Override
     public void initialize(PasswordRule constraintAnnotation) {
         this.password = constraintAnnotation.password();
@@ -48,10 +67,21 @@ public class PasswordRuleValidator implements ConstraintValidator<PasswordRule,
             return false;
         }
 
-        return isValid(passwordValue, loginIdValue, mobileNumberValue);
+        return isValid(passwordValue, loginIdValue, mobileNumberValue, keyboardSequenceBlocked());
+    }
+
+    /** 주입이 안 된 경우(순수 new)에는 기본값인 차단으로 동작한다. */
+    private boolean keyboardSequenceBlocked() {
+        return passwordPolicyProperties == null
+            ? PasswordPolicyProperties.DEFAULT_KEYBOARD_SEQUENCE_BLOCK
+            : passwordPolicyProperties.isKeyboardSequenceBlocked();
     }
 
     public boolean isValid(String password, String loginId, String mobileNumber) {
+        return isValid(password, loginId, mobileNumber, PasswordPolicyProperties.DEFAULT_KEYBOARD_SEQUENCE_BLOCK);
+    }
+
+    public boolean isValid(String password, String loginId, String mobileNumber, boolean blockKeyboardSequence) {
         // 영어, 숫자, 특수문자 포함한 MIN to MAX 글자 정규식
         String REGEX = "^((?=.*\\d)(?=.*[a-zA-Z])(?=.*[\\W]).{" + MIN + "," + MAX + "})$";
 
@@ -81,6 +111,11 @@ public class PasswordRuleValidator implements ConstraintValidator<PasswordRule,
             return false;
         }
 
+        // 키보드 배열 연속 문자 체크 (PortalProperty 로 on/off)
+        if (blockKeyboardSequence && hasKeyboardSequence(password)) {
+            return false;
+        }
+
         // 공백 체크
         matcher = Pattern.compile(BLANKPT).matcher(tmpPw);
         if (matcher.find()) {
@@ -118,6 +153,29 @@ public class PasswordRuleValidator implements ConstraintValidator<PasswordRule,
         return true;
     }
 
+    /**
+     * 키보드 배열상 인접한 문자가 {@value #KEYBOARD_SEQUENCE_LENGTH} 자 이상 이어지는지 (정·역방향 모두).
+     *
+     * <p>같은 행(row) 안에서 좌우로 이어지는 경우만 본다. 예) {@code qwe}, {@code asd}, {@code trewq}.
+     * 클라이언트 {@code static/js/password-policy.js} 의 {@code hasKeyboardSequence} 와 동일 규칙이어야 한다.</p>
+     */
+    public static boolean hasKeyboardSequence(String password) {
+        if (password == null || password.length() < KEYBOARD_SEQUENCE_LENGTH) {
+            return false;
+        }
+        String tmpPw = password.toUpperCase();
+        for (int i = 0; i <= tmpPw.length() - KEYBOARD_SEQUENCE_LENGTH; i++) {
+            String chunk = tmpPw.substring(i, i + KEYBOARD_SEQUENCE_LENGTH);
+            String reversed = new StringBuilder(chunk).reverse().toString();
+            for (String row : KEYBOARD_ROWS) {
+                if (row.contains(chunk) || row.contains(reversed)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     /** 아이디(이메일)의 @ 앞 local part 가 비밀번호에 포함되는지 (대소문자 무시) */
     public static boolean containsLoginIdLocalPart(String password, String loginId) {
         if (password == null || loginId == null || loginId.isEmpty()) {

src/main/java/com/eactive/apim/portal/config/BaseDatasourceConfiguration.java

@@ -2,6 +2,7 @@ package com.eactive.apim.portal.config;
 
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
 import java.util.HashMap;
 import javax.naming.NamingException;
 import javax.sql.DataSource;
@@ -58,11 +59,11 @@ public class BaseDatasourceConfiguration {
         //public interface AvailableSettings extends org.hibernate.jpa.AvailableSettings 참고
         properties.put("hibernate.dialect", prop.getHibernateDialect());
         properties.put("hibernate.connection.handling_mode", "DELAYED_ACQUISITION_AND_RELEASE_AFTER_TRANSACTION");
-        properties.put("hibernate.transaction.jta.platform", "org.hibernate.engine.transaction.jta.platform.internal.AtomikosJtaPlatform");
         properties.put("hibernate.physical_naming_strategy", prop.getHibernatePhysicalNamingStrategy());
         properties.put("hibernate.default_schema", prop.getSchema());
         properties.put("javax.persistence.validation.mode", "none");
-        properties.put("javax.persistence.transactionType", "JTA");
+        // JTA/XA 미사용. EMF 별 로컬 트랜잭션(JpaTransactionManager)으로 처리한다 - PortalConfigTransaction 참고
+        properties.put("javax.persistence.transactionType", "RESOURCE_LOCAL");
         properties.put("hibernate.format_sql", "true");
 
         if (prop instanceof EmsDatasourceProperty) {
@@ -110,9 +111,22 @@ public class BaseDatasourceConfiguration {
         return builder
                 .dataSource(dataSource)
                 // entity-package 는 콤마로 복수 지정 가능 (gateway 는 online-core + 포털 통계 엔티티 패키지)
-                .packages(prop.getEntityPackage().split("\\s*,\\s*"))
+                .packages(splitPackages(prop.getEntityPackage()))
                 .persistenceUnit(persistenceUnit)
                 .properties(properties)
                 .build();
     }
+
+    /**
+     * 콤마로 나열된 엔티티 패키지를 분리한다. 앞뒤 공백은 걷어내고 빈 토큰은 버린다.
+     *
+     * <p>구분자 정규식 {@code "\\s*,\\s*"} 은 백트래킹으로 super-linear 가 될 수 있어(Sonar S5852)
+     * 단순 분리 + trim 으로 대체했다.</p>
+     */
+    private static String[] splitPackages(String entityPackage) {
+        return Arrays.stream(entityPackage.split(","))
+                .map(String::trim)
+                .filter(pkg -> !pkg.isEmpty())
+                .toArray(String[]::new);
+    }
 }

src/main/java/com/eactive/apim/portal/config/GatewayDatasourceConfiguration.java

@@ -18,7 +18,8 @@ import javax.sql.DataSource;
 
 @Configuration
 @EntityScan(basePackages = {"com.eactive.apim.gateway"})
-@EnableJpaRepositories(basePackages = "com.eactive.apim.gateway", repositoryBaseClass = BaseRepositoryImpl.class, entityManagerFactoryRef = "gatewayEntityManagerFactory")
+@EnableJpaRepositories(basePackages = "com.eactive.apim.gateway", repositoryBaseClass = BaseRepositoryImpl.class,
+        entityManagerFactoryRef = "gatewayEntityManagerFactory", transactionManagerRef = "gatewayTransactionManager")
 @Slf4j
 public class GatewayDatasourceConfiguration extends BaseDatasourceConfiguration {
     private final Environment env;

src/main/java/com/eactive/apim/portal/config/InternalApiTokenInitializer.java

@@ -0,0 +1,31 @@
+package com.eactive.apim.portal.config;
+
+import com.eactive.apim.portal.common.internal.InternalApiTokenService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * 내부 API 공유 토큰 초기화 — 포탈 기동 시 1회.
+ *
+ * <p>PTL_PROPERTY {@code Portal / internal.api.header-name}, {@code internal.api.token} 이 없으면
+ * 이 시점에 생성된다(토큰은 SecureRandom 난수). eapim-admin 은 이 값을 <b>읽기만</b> 하므로,
+ * 토큰을 처음 만드는 주체는 포탈 한 곳으로 고정된다.</p>
+ *
+ * <p>{@link ApplicationReadyEvent} 를 쓰는 이유: 데이터소스/JTA 초기화가 끝난 뒤여야 프로퍼티를 저장할 수 있다.
+ * WAR 배포(WebLogic)에서도 동일하게 발생한다.</p>
+ *
+ * @see com.eactive.apim.portal.djb.menu.MenuInternalController
+ */
+@Component
+@RequiredArgsConstructor
+public class InternalApiTokenInitializer {
+
+    private final InternalApiTokenService internalApiTokenService;
+
+    @EventListener(ApplicationReadyEvent.class)
+    public void initialize() {
+        internalApiTokenService.initialize();
+    }
+}

src/main/java/com/eactive/apim/portal/config/MultipartConfig.java

@@ -2,6 +2,8 @@ package com.eactive.apim.portal.config;
 
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.fileupload.FileItemFactory;
+import org.apache.commons.fileupload.FileUpload;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.multipart.commons.CommonsMultipartResolver;
@@ -18,6 +20,18 @@ import org.springframework.web.multipart.commons.CommonsMultipartResolver;
 @RequiredArgsConstructor
 public class MultipartConfig {
 
+    /**
+     * 멀티파트 파트 1개의 헤더 구간 최대 바이트.
+     * <p>
+     * commons-fileupload 1.6.0(CVE-2025-48976 수정)부터 이 상한이 생겼고 기본값이 512 바이트다.
+     * 한글 파일명은 UTF-8 로 3바이트/자라 Content-Disposition 이 금방 커진다 — 실측상 기본값 512 로는
+     * 한글 약 137자 이상 파일명에서 업로드가 실패하고, 예외도 "Maximum upload size exceeded" 로 감싸져
+     * 원인 파악이 어렵다. OS 파일명 상한(255자)이 전부 한글이어도 통과하도록 2048 로 둔다.
+     * (1.5 이전에는 사실상 10240 이었으므로 이 값도 그보다 5배 엄격하다.)
+     * </p>
+     */
+    private static final int PART_HEADER_SIZE_MAX = 2048;
+
     private final PortalProperties portalProperties;
 
     /**
@@ -31,7 +45,14 @@ public class MultipartConfig {
      */
     @Bean(name = "filterMultipartResolver")
     public CommonsMultipartResolver filterMultipartResolver() {
-        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
+        CommonsMultipartResolver resolver = new CommonsMultipartResolver() {
+            @Override
+            protected FileUpload newFileUpload(FileItemFactory fileItemFactory) {
+                FileUpload fileUpload = super.newFileUpload(fileItemFactory);
+                fileUpload.setPartHeaderSizeMax(PART_HEADER_SIZE_MAX);
+                return fileUpload;
+            }
+        };
 
         long maxSizeBytes = portalProperties.getFile().getMaxSizeBytes();
         resolver.setMaxUploadSize(maxSizeBytes);
@@ -39,8 +60,8 @@ public class MultipartConfig {
         resolver.setMaxInMemorySize((int) Math.min(maxSizeBytes, Integer.MAX_VALUE));
         resolver.setDefaultEncoding("UTF-8");
 
-        log.info("CommonsMultipartResolver configured with maxUploadSize: {} bytes ({})",
+        log.info("CommonsMultipartResolver configured with maxUploadSize: {} bytes ({}), partHeaderSizeMax: {} bytes",
-                maxSizeBytes, portalProperties.getFile().getMaxSize());
+                maxSizeBytes, portalProperties.getFile().getMaxSize(), PART_HEADER_SIZE_MAX);
 
         return resolver;
     }

src/main/java/com/eactive/apim/portal/config/PortalAuthenticationFailureHandler.java

@@ -4,16 +4,13 @@ import com.eactive.apim.portal.apps.login.constants.LoginConstants;
 import com.eactive.apim.portal.apps.login.constants.LoginFailureReason;
 import com.eactive.apim.portal.apps.user.service.PortalUserLogService;
 import com.eactive.apim.portal.common.exception.UserNotFoundException;
+import com.eactive.apim.portal.common.security.AccountLockService;
 import com.eactive.apim.portal.common.security.LoginLockPolicy;
 import com.eactive.apim.portal.common.util.HttpRequestUtil;
 import com.eactive.apim.portal.common.util.StringMaskingUtil;
 import com.eactive.apim.portal.common.util.StringRepeatUtil;
 import com.eactive.apim.portal.portaluser.entity.PortalUser;
 import com.eactive.apim.portal.portaluser.repository.PortalUserRepository;
-import com.eactive.apim.portal.template.entity.MessageCode;
-import com.eactive.apim.portal.template.service.MessageHandlerService;
-import com.eactive.apim.portal.template.service.MessageRecipient;
-import org.apache.groovy.util.Maps;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.security.authentication.BadCredentialsException;
@@ -47,18 +44,18 @@ public class PortalAuthenticationFailureHandler implements AuthenticationFailure
 
     private final PortalUserRepository portalUserRepository;
     private final PortalUserLogService userLogService;
-    private final MessageHandlerService messageHandlerService;
     private final LoginLockPolicy loginLockPolicy;
+    private final AccountLockService accountLockService;
 
 
     public PortalAuthenticationFailureHandler(PortalUserRepository portalUserRepository,
                                               PortalUserLogService userLogService,
-                                              MessageHandlerService messageHandlerService,
+                                              LoginLockPolicy loginLockPolicy,
-                                              LoginLockPolicy loginLockPolicy) {
+                                              AccountLockService accountLockService) {
         this.portalUserRepository = portalUserRepository;
         this.userLogService = userLogService;
-        this.messageHandlerService = messageHandlerService;
         this.loginLockPolicy = loginLockPolicy;
+        this.accountLockService = accountLockService;
     }
 
     @Override
@@ -79,16 +76,10 @@ public class PortalAuthenticationFailureHandler implements AuthenticationFailure
 
                 int lockCount = loginLockPolicy.lockCount();
                 user.setLoginFailureCount(user.getLoginFailureCount() + 1);
-                if (user.getLoginFailureCount() >= lockCount) {
-                    user.setAccountLockYn("Y");
-
-                    // 계정 잠금 알림
-                    messageHandlerService.publishEvent(
-                            MessageCode.USER_ACCOUNT_LOCKED,
-                            MessageRecipient.of(user),
-                            Maps.of("reason", lockCount + "회 이상 로그인 실패로 인한 계정 잠금"));
-                }
                 portalUserRepository.save(user);
+                if (user.getLoginFailureCount() >= lockCount) {
+                    accountLockService.lock(user, lockCount + "회 이상 로그인 실패로 인한 계정 잠금");
+                }
 
 
 

src/main/java/com/eactive/apim/portal/config/PortalConfigForwardedHeader.java

@@ -33,15 +33,13 @@ import org.springframework.web.filter.ForwardedHeaderFilter;
  *     → getHeader("X-Forwarded-For") = null         (필터가 제거 → viaProxy 판정이 false)
  * </pre>
  *
- * 즉 {@code MenuInternalController#isAllowed} / {@code LegacyEncryptionMigrationController#assertAllowedIp}
+ * 즉 {@code MenuInternalController#isAllowedIp} 의 "프록시 경유 거부 + loopback 허용" 가드가 무력화된다.
- * 의 "프록시 경유 거부 + loopback 허용" 가드가 무력화된다. 필터를 제외해 두면 이 경로만은 <b>원 소켓 IP</b> 로
+ * 필터를 제외해 두면 이 경로만은 <b>원 소켓 IP</b> 로 검사되므로 기존 가드가 설계대로 동작한다.
- * 검사되므로 기존 가드가 설계대로 동작한다.
  *
  * <p><b>전제</b>: {@code framework} 는 신뢰 프록시 목록이 없어 헤더를 무조건 신뢰한다. 앞단(OHS)에서 인바운드
  * {@code X-Forwarded-*} / {@code Forwarded} 를 제거한 뒤 재설정해야 하며, WAS 포트로의 직접 접근 경로도 차단해야 한다.
  *
  * @see com.eactive.apim.portal.djb.menu.MenuInternalController
- * @see com.eactive.apim.portal.common.migration.LegacyEncryptionMigrationController
  */
 @Slf4j
 @Configuration

src/main/java/com/eactive/apim/portal/config/PortalConfigSecurity.java

@@ -2,11 +2,13 @@ package com.eactive.apim.portal.config;
 
 
 import com.eactive.apim.portal.apps.session.filter.SessionValidationFilter;
+import com.eactive.apim.portal.common.security.passwordcrypto.PasswordDecryptFilter;
 import com.navercorp.lucy.security.xss.servletfilter.XssEscapeServletFilter;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.web.servlet.FilterRegistrationBean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.ObjectPostProcessor;
 import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
@@ -16,6 +18,7 @@ import org.springframework.security.web.access.AccessDeniedHandler;
 import org.springframework.security.web.access.AccessDeniedHandlerImpl;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 import org.springframework.security.web.csrf.CsrfException;
+import org.springframework.security.web.header.HeaderWriterFilter;
 import org.springframework.security.web.csrf.HttpSessionCsrfTokenRepository;
 import org.springframework.security.web.session.HttpSessionEventPublisher;
 import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@@ -62,6 +65,20 @@ public class PortalConfigSecurity {
         return registration;
     }
 
+    /**
+     * 비밀번호 전송암호화 복호화 필터. Lucy XSS 필터(order = MIN_VALUE + 1)보다 <b>먼저</b> 실행되어야 한다.
+     * 복호화된 평문이 기존과 똑같이 XSS 이스케이프를 거쳐야 특수문자가 든 비밀번호의 해시 비교 결과가
+     * 지금과 동일하게 유지된다. 순서를 뒤집으면 기존 계정 로그인이 깨진다.
+     */
+    @Bean
+    public FilterRegistrationBean<PasswordDecryptFilter> passwordDecryptFilterRegistration(
+        PasswordDecryptFilter filter) {
+        FilterRegistrationBean<PasswordDecryptFilter> registrationBean = new FilterRegistrationBean<>(filter);
+        registrationBean.setOrder(Integer.MIN_VALUE);
+        registrationBean.addUrlPatterns("/*");
+        return registrationBean;
+    }
+
     @Bean
     public FilterRegistrationBean<XssEscapeServletFilter> xssFilterRegistrationBean() {
         FilterRegistrationBean<XssEscapeServletFilter> registrationBean = new FilterRegistrationBean<>();
@@ -92,6 +109,23 @@ public class PortalConfigSecurity {
 
             http
                 .authenticationManager(portalAuthenticationManager)
+                // CVE-2026-22732 우회책. Spring Security 는 기본적으로 보안 헤더를 "응답 커밋 시점"에
+                // 지연 기록하는데, 응답 래퍼가 Content-Length 를 setHeader/setIntHeader/addIntHeader 로
+                // 지정하는 경로를 추적하지 못해 그 경우 헤더가 통째로 누락된다
+                // (X-Content-Type-Options, X-Frame-Options, Cache-Control, Pragma, Expires, X-XSS-Protection).
+                // 수정본은 5.7.22/5.8.24(Enterprise 전용)뿐이라 OSS 로는 올릴 수 없어 우회책을 적용한다.
+                // 요청 시작 시점에 헤더를 기록하게 만든다. 앱이 나중에 같은 헤더를 지정하면 앱 값이 남는다
+                // (실측: FileDownloadController#viewImage 의 Cache-Control: public, max-age=86400 유지됨).
+                // 현재 앱은 response.setContentLength(int) 만 쓰므로 노출 경로는 없지만,
+                // 새 코드가 위 메서드를 쓰더라도 헤더가 빠지지 않도록 두는 안전망이다.
+                // Spring Security 를 수정본(6.5.9+/7.0.4+ 또는 Enterprise 5.7.22+)으로 올리면 제거 가능.
+                .headers(headers -> headers.addObjectPostProcessor(new ObjectPostProcessor<HeaderWriterFilter>() {
+                    @Override
+                    public <O extends HeaderWriterFilter> O postProcess(O filter) {
+                        filter.setShouldWriteHeadersEagerly(true);
+                        return filter;
+                    }
+                }))
                 .formLogin(form -> form
                     .loginPage("/login")
                     .usernameParameter("id")
@@ -107,9 +141,16 @@ public class PortalConfigSecurity {
                     .logoutSuccessHandler(logoutSuccessHandler))
                 .csrf(csrf -> csrf
                     .csrfTokenRepository(csrfTokenRepository)
-                    .ignoringRequestMatchers(new AntPathRequestMatcher("/_proxy/**/*"))
+                    // /_proxy 는 대응 핸들러가 없어 예외를 해제했다. 경로가 부활하면 아래를 되살릴 것.
-                    .ignoringRequestMatchers(new AntPathRequestMatcher("/internal/migration/**"))
+                    // .ignoringRequestMatchers(new AntPathRequestMatcher("/_proxy/**/*"))
-                    .ignoringRequestMatchers(new AntPathRequestMatcher("/internal/menu/**"))
+                    // /internal/migration 은 LegacyEncryptionMigrationController 제거와 함께 삭제됨.
+                    // /internal/menu 는 브라우저 세션이 없는 서버간 호출(admin → portal)이라 CSRF 토큰을 실을 수 없다.
+                    // 대신 InternalApiTokenService 의 공유 토큰 헤더 + 허용 IP 목록으로 통제한다.
+                    // (커스텀 헤더는 cross-site form POST 로 위조할 수 없어 CSRF 경로가 차단된다)
+                    // /internal/test-cleanup 도 동일 이유(Playwright 등 세션 없는 호출) + 동일 통제 방식.
+                    .ignoringRequestMatchers(
+                        new AntPathRequestMatcher("/internal/menu/**"),
+                        new AntPathRequestMatcher("/internal/test-cleanup/**"))
                 )
                 // 로그인 페이지에 오래 머물러 세션(=CSRF 토큰 저장소)이 타임아웃되면
                 // 로그인 제출 시 CsrfFilter가 AnonymousAuthenticationFilter보다 먼저 예외를 던져

src/main/java/com/eactive/apim/portal/config/PortalConfigTransaction.java

@@ -1,39 +1,44 @@
 package com.eactive.apim.portal.config;
 
-import com.atomikos.icatch.jta.UserTransactionImp;
+import javax.persistence.EntityManagerFactory;
-import com.atomikos.icatch.jta.UserTransactionManager;
+
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.DependsOn;
+import org.springframework.context.annotation.Primary;
+import org.springframework.orm.jpa.JpaTransactionManager;
 import org.springframework.transaction.PlatformTransactionManager;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
-import org.springframework.transaction.jta.JtaTransactionManager;
-
-import javax.transaction.SystemException;
-import javax.transaction.UserTransaction;
 
+/**
+ * 트랜잭션 매니저 설정.
+ *
+ * <p>EMS(포털)·AGW(게이트웨이) 두 데이터소스를 쓰지만 <b>JTA/XA 는 사용하지 않는다</b>.
+ * 두 DB 를 한 트랜잭션으로 묶어 쓰는 지점이 없고(게이트웨이 측은 조회 전용),
+ * 이전 Atomikos 구성도 {@code AtomikosDataSourceBean} 없이 JNDI/Hikari 데이터소스를 그대로 넘겨
+ * XA 리소스가 하나도 enlist 되지 않는 형태였다. 즉 2PC 는 실제로 동작한 적이 없고
+ * {@code com.atomikos.icatch.max_actives} 상한(기본 50)만 병목으로 남았다.</p>
+ *
+ * <p>따라서 EntityManagerFactory 별로 로컬 {@link JpaTransactionManager} 를 둔다.
+ * 게이트웨이 리포지토리는 {@code GatewayDatasourceConfiguration} 의
+ * {@code transactionManagerRef = "gatewayTransactionManager"} 로 연결된다.</p>
+ */
 @Configuration
 @EnableTransactionManagement
 public class PortalConfigTransaction {
 
-    @Bean(name = "userTransaction")
+    /** EMS(포털) 기본 트랜잭션 매니저. {@code @Transactional} 무지정 시 이 매니저가 쓰인다. */
-    public UserTransaction userTransaction() throws SystemException {
+    @Primary
-        UserTransactionImp userTransactionImp = new UserTransactionImp();
-        userTransactionImp.setTransactionTimeout(30000);
-        return userTransactionImp;
-    }
-
-    @Bean(name = "atomikosTransactionManager", initMethod = "init", destroyMethod = "close")
-    public UserTransactionManager atomikosTransactionManager() {
-        UserTransactionManager userTransactionManager = new UserTransactionManager();
-        userTransactionManager.setForceShutdown(false);
-        return userTransactionManager;
-    }
-
     @Bean(name = "transactionManager")
-    @DependsOn({"userTransaction", "atomikosTransactionManager"})
+    public PlatformTransactionManager transactionManager(
-    public PlatformTransactionManager transactionManager(UserTransactionManager atomikosTransactionManager) throws SystemException {
+            @Qualifier("entityManagerFactory") EntityManagerFactory entityManagerFactory) {
-        UserTransaction userTransaction = userTransaction();
+        return new JpaTransactionManager(entityManagerFactory);
-        return new JtaTransactionManager(userTransaction, atomikosTransactionManager);
+    }
+
+    /** AGW(게이트웨이) 트랜잭션 매니저. {@code @Transactional("gatewayTransactionManager")} 로 지정해 쓴다. */
+    @Bean(name = "gatewayTransactionManager")
+    public PlatformTransactionManager gatewayTransactionManager(
+            @Qualifier("gatewayEntityManagerFactory") EntityManagerFactory gatewayEntityManagerFactory) {
+        return new JpaTransactionManager(gatewayEntityManagerFactory);
     }
 }

src/main/java/com/eactive/apim/portal/config/PortalConfigWebDispatcherServlet.java

@@ -57,6 +57,12 @@ public class PortalConfigWebDispatcherServlet implements WebMvcConfigurer {
     @Value("${app.resource-caching.enabled:false}")
     private boolean resourceCachingEnabled;
 
+    // 정적자원 서빙 루트(application.yml: app.web-resources.static-base).
+    // 기본은 classpath(빌드 산출물), local_rinjaemac 프로파일은 file:${user.dir}/src/main/resources/static/
+    // 로 오버라이드해 소스 편집이 재빌드 없이 즉시 반영되도록 한다.
+    @Value("${app.web-resources.static-base:classpath:/static/}")
+    private String staticBase;
+
     public PortalConfigWebDispatcherServlet(Environment environment,
         com.eactive.apim.portal.apps.auth.twofactor.TwoFactorService twoFactorService,
         com.eactive.apim.portal.apps.auth.twofactor.TwoFactorProperties twoFactorProperties,
@@ -151,15 +157,15 @@ public class PortalConfigWebDispatcherServlet implements WebMvcConfigurer {
 
     @Override
     public void addResourceHandlers(ResourceHandlerRegistry registry) {
-        addStaticResourceHandler(registry, "/css/**", "/css/", "classpath:/static/css/");
+        addStaticResourceHandler(registry, "/css/**", "/css/", staticBase + "css/");
-        addStaticResourceHandler(registry, "/webfonts/**", "/webfonts/", "classpath:/static/webfonts/");
+        addStaticResourceHandler(registry, "/webfonts/**", "/webfonts/", staticBase + "webfonts/");
-        addStaticResourceHandler(registry, "/font/**", "/font/", "classpath:/static/font/");
+        addStaticResourceHandler(registry, "/font/**", "/font/", staticBase + "font/");
-        addStaticResourceHandler(registry, "/html/**", "/html/", "classpath:/static/html/");
+        addStaticResourceHandler(registry, "/html/**", "/html/", staticBase + "html/");
-        addStaticResourceHandler(registry, "/images/**", "/images/", "classpath:/static/images/");
+        addStaticResourceHandler(registry, "/images/**", "/images/", staticBase + "images/");
-        addStaticResourceHandler(registry, "/img/**", "/img/", "classpath:/static/img/");
+        addStaticResourceHandler(registry, "/img/**", "/img/", staticBase + "img/");
-        addStaticResourceHandler(registry, "/js/**", "/js/", "classpath:/static/js/");
+        addStaticResourceHandler(registry, "/js/**", "/js/", staticBase + "js/");
-        addStaticResourceHandler(registry, "/plugins/**", "/plugins/", "classpath:/static/plugins/");
+        addStaticResourceHandler(registry, "/plugins/**", "/plugins/", staticBase + "plugins/");
-        addStaticResourceHandler(registry, "/favicon.ico", "/favicon.ico", "classpath:/static/favicon.ico");
+        addStaticResourceHandler(registry, "/favicon.ico", "/favicon.ico", staticBase + "favicon.ico");
     }
 
     /**

src/main/java/com/eactive/apim/portal/djb/apistatus/repository/ApiStatusIncidentQueryRepository.java

@@ -27,13 +27,23 @@ import java.util.Optional;
  *
  * <p>공지 조건을 EXISTS 로 쓰는 이유: 예전처럼 {@code FROM ... , PortalNotice n} 으로 조인하면
  * NOTICE_ID 가 없는 지연 이슈가 행 자체에서 사라진다.</p>
+ *
+ * <p>API 그룹으로 특정 법인에게만 공개된 API 의 이슈는, 그 API 를 조회할 수 없는 사용자에게는
+ * 이슈 자체(제목·요약·타임라인 포함)를 노출하지 않는다. 영향 API 가 하나도 없는 이슈(전사 공지성)는
+ * 그대로 노출한다. {@code visibleApiIds} 는 {@code ApiStatusCatalogService#getVisibleApiIdsForQuery()}
+ * 로 구한, 현재 사용자에게 공개된 API ID 집합이다.</p>
  */
 public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatusIncident, Long> {
 
     String VISIBLE = " i.draftYn = 'N'"
             + " AND (i.noticeId IS NULL"
             + "      OR EXISTS (SELECT 1 FROM PortalNotice n"
-            + "                  WHERE n.id = i.noticeId AND n.useYn = 'Y')) ";
+            + "                  WHERE n.id = i.noticeId AND n.useYn = 'Y'))"
+            + " AND (NOT EXISTS (SELECT 1 FROM DjbApistatusIncidentApi ia"
+            + "                  WHERE ia.incidentId = i.incidentId)"
+            + "      OR EXISTS (SELECT 1 FROM DjbApistatusIncidentApi ia2"
+            + "                  WHERE ia2.incidentId = i.incidentId"
+            + "                    AND ia2.apiId IN :visibleApiIds)) ";
 
     /** 종결 판정이 STATE 로 이뤄지는 종류 (장애·지연). JPQL 리터럴로 써야 해서 FQCN 을 쓴다 */
     String KIND_INCIDENT = "com.eactive.apim.portal.djb.apistatus.incident.entity.IncidentKind.INCIDENT";
@@ -55,7 +65,8 @@ public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatu
             + "   AND i.state NOT IN :closedStates"
             + " ORDER BY i.startedAt DESC")
     List<DjbApistatusIncident> findVisibleOpenIncidents(@Param("kinds") Collection<IncidentKind> kinds,
-                                                       @Param("closedStates") Collection<IncidentState> closedStates);
+                                                       @Param("closedStates") Collection<IncidentState> closedStates,
+                                                       @Param("visibleApiIds") Collection<String> visibleApiIds);
 
     /**
      * 예정/진행 중 점검 (P5). 종료 시각이 없거나 아직 지나지 않은 점검.
@@ -66,7 +77,8 @@ public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatu
             + "   AND (i.endAt IS NULL OR i.endAt >= :now)"
             + " ORDER BY i.startedAt ASC")
     List<DjbApistatusIncident> findVisibleOngoingMaintenance(@Param("kind") IncidentKind kind,
-                                                            @Param("now") LocalDateTime now);
+                                                            @Param("now") LocalDateTime now,
+                                                            @Param("visibleApiIds") Collection<String> visibleApiIds);
 
     /**
      * 종결된 이슈 (P6). 장애·지연은 종결 상태, 점검은 종료 시각 경과.
@@ -80,6 +92,7 @@ public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatu
             + "   AND " + CLOSED_CONDITION)
     Page<DjbApistatusIncident> findVisibleClosedIssues(@Param("closedStates") Collection<IncidentState> closedStates,
                                                       @Param("now") LocalDateTime now,
+                                                      @Param("visibleApiIds") Collection<String> visibleApiIds,
                                                       Pageable pageable);
 
     /**
@@ -92,7 +105,8 @@ public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatu
             + "   AND (i.endAt IS NULL OR i.endAt >= :from)"
             + " ORDER BY i.startedAt DESC")
     List<DjbApistatusIncident> findVisibleOverlapping(@Param("from") LocalDateTime from,
-                                                     @Param("to") LocalDateTime to);
+                                                     @Param("to") LocalDateTime to,
+                                                     @Param("visibleApiIds") Collection<String> visibleApiIds);
 
     /**
      * 기간과 겹치고 특정 API 에 영향을 준 이슈 (P9/P10 의 apiId 필터).
@@ -106,7 +120,8 @@ public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatu
             + " ORDER BY i.startedAt DESC")
     List<DjbApistatusIncident> findVisibleOverlappingByApi(@Param("from") LocalDateTime from,
                                                           @Param("to") LocalDateTime to,
-                                                          @Param("apiId") String apiId);
+                                                          @Param("apiId") String apiId,
+                                                          @Param("visibleApiIds") Collection<String> visibleApiIds);
 
     /**
      * 공개 상세 (P7)
@@ -114,5 +129,6 @@ public interface ApiStatusIncidentQueryRepository extends Repository<DjbApistatu
     @Query("SELECT i FROM DjbApistatusIncident i"
             + " WHERE " + VISIBLE
             + "   AND i.incidentId = :incidentId")
-    Optional<DjbApistatusIncident> findVisibleById(@Param("incidentId") Long incidentId);
+    Optional<DjbApistatusIncident> findVisibleById(@Param("incidentId") Long incidentId,
+                                                  @Param("visibleApiIds") Collection<String> visibleApiIds);
 }

src/main/java/com/eactive/apim/portal/djb/apistatus/service/ApiCurrentStatusService.java

@@ -152,7 +152,8 @@ public class ApiCurrentStatusService {
     /** 진행 중(미종결) 장애·지연 중 API 별로 가장 심각한 한 건 */
     private Map<String, DjbApistatusIncident> mapOpenIncidents(Set<String> apiIds) {
         List<DjbApistatusIncident> openIncidents = incidentQueryRepository
-                .findVisibleOpenIncidents(IncidentKind.DEGRADING, ApiStatusSupport.CLOSED_STATES);
+                .findVisibleOpenIncidents(IncidentKind.DEGRADING, ApiStatusSupport.CLOSED_STATES,
+                        catalogService.getVisibleApiIdsForQuery());
         if (openIncidents.isEmpty()) {
             return Collections.emptyMap();
         }
@@ -178,7 +179,8 @@ public class ApiCurrentStatusService {
     /** 이미 시작된 점검 중 API 별로 가장 먼저 시작된 한 건 (예정 점검은 현재 상태가 아니므로 제외) */
     private Map<String, DjbApistatusIncident> mapStartedMaintenance(Set<String> apiIds, LocalDateTime now) {
         List<DjbApistatusIncident> maintenances = incidentQueryRepository
-                .findVisibleOngoingMaintenance(IncidentKind.MAINTENANCE, now).stream()
+                .findVisibleOngoingMaintenance(IncidentKind.MAINTENANCE, now,
+                        catalogService.getVisibleApiIdsForQuery()).stream()
                 .filter(incident -> incident.getStartedAt() != null && !incident.getStartedAt().isAfter(now))
                 .collect(Collectors.toList());
         if (maintenances.isEmpty()) {
@@ -208,7 +210,8 @@ public class ApiCurrentStatusService {
     private Map<String, LocalDateTime> collectLastIncidentAt(Set<String> apiIds, LocalDateTime now, int windowDays) {
         LocalDateTime windowStart = now.toLocalDate().minusDays(windowDays - 1L).atStartOfDay();
         List<DjbApistatusIncident> incidents = incidentQueryRepository
-                .findVisibleOverlapping(windowStart, now.toLocalDate().plusDays(1).atStartOfDay()).stream()
+                .findVisibleOverlapping(windowStart, now.toLocalDate().plusDays(1).atStartOfDay(),
+                        catalogService.getVisibleApiIdsForQuery()).stream()
                 .filter(incident -> incident.getKind() != null && incident.getKind().isDegrading())
                 .collect(Collectors.toList());
         if (incidents.isEmpty()) {

src/main/java/com/eactive/apim/portal/djb/apistatus/service/ApiStatusCatalogService.java

@@ -16,6 +16,7 @@ import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import java.time.Instant;
 import java.time.LocalDateTime;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedHashMap;
@@ -99,6 +100,19 @@ public class ApiStatusCatalogService {
         return names;
     }
 
+    /** IN 절 바인딩용 API ID 없을 리 없는 더미값. 실제 API ID 는 절대 이 값이 될 수 없다 */
+    private static final List<String> NO_VISIBLE_API = Collections.singletonList("__NO_VISIBLE_API__");
+
+    /**
+     * {@link ApiStatusIncidentQueryRepository} 의 {@code :visibleApiIds} 바인딩용.
+     * Oracle 은 빈 컬렉션으로 {@code IN ()} 을 만들면 구문 오류가 나므로, 조회 가능한 API 가
+     * 하나도 없을 때는 절대 매치되지 않는 더미값으로 대체한다.
+     */
+    public Collection<String> getVisibleApiIdsForQuery() {
+        Map<String, String> names = getVisibleApiNames();
+        return names.isEmpty() ? NO_VISIBLE_API : names.keySet();
+    }
+
     /**
      * API 상태 모니터링 Job(eapim-admin Quartz)의 마지막 실행 시각.
      *

src/main/java/com/eactive/apim/portal/djb/apistatus/service/ApiStatusIssueHistoryService.java

@@ -130,9 +130,10 @@ public class ApiStatusIssueHistoryService {
 
     private List<DjbApistatusIncident> findOverlapping(LocalDateTime from, LocalDateTime to,
                                                       String apiId, String kind) {
+        java.util.Collection<String> visibleApiIds = catalogService.getVisibleApiIdsForQuery();
         List<DjbApistatusIncident> incidents = StringUtils.isBlank(apiId)
-                ? incidentQueryRepository.findVisibleOverlapping(from, to)
+                ? incidentQueryRepository.findVisibleOverlapping(from, to, visibleApiIds)
-                : incidentQueryRepository.findVisibleOverlappingByApi(from, to, apiId);
+                : incidentQueryRepository.findVisibleOverlappingByApi(from, to, apiId, visibleApiIds);
 
         java.util.function.Predicate<DjbApistatusIncident> filter = kindFilter(kind);
         if (filter == null) {

src/main/java/com/eactive/apim/portal/djb/apistatus/service/ApiStatusQueryService.java

@@ -25,19 +25,22 @@ public class ApiStatusQueryService {
 
     private final ApiStatusIncidentQueryRepository incidentQueryRepository;
     private final ApiStatusAssembler assembler;
+    private final ApiStatusCatalogService catalogService;
 
     /** P3 - 진행 중 장애·지연 */
     public List<ActiveIncidentDTO> getActiveIncidents() {
         LocalDateTime now = ApiStatusSupport.now();
         List<DjbApistatusIncident> incidents = incidentQueryRepository
-                .findVisibleOpenIncidents(IncidentKind.DEGRADING, ApiStatusSupport.CLOSED_STATES);
+                .findVisibleOpenIncidents(IncidentKind.DEGRADING, ApiStatusSupport.CLOSED_STATES,
+                        catalogService.getVisibleApiIdsForQuery());
         return assembler.toActiveIncidents(incidents, now);
     }
 
     /** P5 - 예정/진행 중 점검 */
     public List<MaintenanceCardDTO> getOngoingMaintenance() {
         List<DjbApistatusIncident> incidents = incidentQueryRepository
-                .findVisibleOngoingMaintenance(IncidentKind.MAINTENANCE, ApiStatusSupport.now());
+                .findVisibleOngoingMaintenance(IncidentKind.MAINTENANCE, ApiStatusSupport.now(),
+                        catalogService.getVisibleApiIdsForQuery());
         return assembler.toMaintenanceCards(incidents);
     }
 
@@ -46,14 +49,14 @@ public class ApiStatusQueryService {
         int limit = size <= 0 ? 5 : Math.min(size, 50);
         List<DjbApistatusIncident> incidents = incidentQueryRepository
                 .findVisibleClosedIssues(ApiStatusSupport.CLOSED_STATES, ApiStatusSupport.now(),
-                        PageRequest.of(0, limit))
+                        catalogService.getVisibleApiIdsForQuery(), PageRequest.of(0, limit))
                 .getContent();
         return assembler.toPastIssueCards(incidents);
     }
 
     /** P7 - 이슈 공개 상세 */
     public Optional<PastIssueCardDTO> getIssueDetail(Long incidentId) {
-        return incidentQueryRepository.findVisibleById(incidentId)
+        return incidentQueryRepository.findVisibleById(incidentId, catalogService.getVisibleApiIdsForQuery())
                 .map(incident -> assembler.toPastIssueCards(java.util.Collections.singletonList(incident)).get(0));
     }
 }

src/main/java/com/eactive/apim/portal/djb/apistatus/service/ApiStatusUptimeService.java

@@ -34,6 +34,7 @@ public class ApiStatusUptimeService {
 
     private final ApiStatusIncidentQueryRepository incidentQueryRepository;
     private final DjbApistatusIncidentApiRepository incidentApiRepository;
+    private final ApiStatusCatalogService catalogService;
 
     /** P2 - 90일 가동률 */
     public List<DailyStatDTO> getDailyStats(int days) {
@@ -43,7 +44,8 @@ public class ApiStatusUptimeService {
         LocalDate from = today.minusDays(windowDays - 1L);
 
         List<DjbApistatusIncident> incidents = incidentQueryRepository
-                .findVisibleOverlapping(from.atStartOfDay(), today.plusDays(1).atStartOfDay());
+                .findVisibleOverlapping(from.atStartOfDay(), today.plusDays(1).atStartOfDay(),
+                        catalogService.getVisibleApiIdsForQuery());
 
         List<DailyStatDTO> result = new ArrayList<>();
         for (int offset = 0; offset < windowDays; offset++) {
@@ -66,7 +68,8 @@ public class ApiStatusUptimeService {
 
         // 장애와 지연 모두 서비스 저하이므로 가동률에서 차감한다. 점검은 계획된 작업이라 제외.
         List<DjbApistatusIncident> incidents = incidentQueryRepository
-                .findVisibleOverlapping(windowStart, now.toLocalDate().plusDays(1).atStartOfDay()).stream()
+                .findVisibleOverlapping(windowStart, now.toLocalDate().plusDays(1).atStartOfDay(),
+                        catalogService.getVisibleApiIdsForQuery()).stream()
                 .filter(incident -> incident.getKind() != null && incident.getKind().isDegrading())
                 .collect(Collectors.toList());
 

src/main/java/com/eactive/apim/portal/djb/community/qna/comment/controller/InquiryCommentController.java

@@ -1,5 +1,8 @@
 package com.eactive.apim.portal.djb.community.qna.comment.controller;
 
+import com.eactive.apim.portal.common.exception.TooManyWriteRequestsException;
+import com.eactive.apim.portal.common.security.WriteRateLimitService;
+import com.eactive.apim.portal.common.security.WriteRateLimitService.WriteTarget;
 import com.eactive.apim.portal.common.user.PortalAuthenticatedUser;
 import com.eactive.apim.portal.common.util.SecurityUtil;
 import com.eactive.apim.portal.djb.community.qna.comment.dto.InquiryCommentCreateRequest;
@@ -32,6 +35,7 @@ import java.util.Map;
 public class InquiryCommentController {
 
     private final InquiryCommentFacade inquiryCommentFacade;
+    private final WriteRateLimitService writeRateLimitService;
 
     @GetMapping("/{inquiryId}/comments")
     public ResponseEntity<List<InquiryCommentDTO>> list(@PathVariable String inquiryId) {
@@ -42,6 +46,7 @@ public class InquiryCommentController {
     @PostMapping("/{inquiryId}/comments")
     public ResponseEntity<InquiryCommentDTO> create(@PathVariable String inquiryId,
                                                     @Valid @RequestBody InquiryCommentCreateRequest request) {
+        writeRateLimitService.assertNotExceeded(WriteTarget.INQUIRY_COMMENT);
         PortalAuthenticatedUser current = SecurityUtil.getPortalAuthenticatedUser();
         InquiryCommentDTO created = inquiryCommentFacade.createUserComment(
                 inquiryId, request.getContent(), request.getVisibility(), current);
@@ -65,6 +70,12 @@ public class InquiryCommentController {
         return ResponseEntity.status(HttpStatus.FORBIDDEN).body(errorBody("COMMENT_NOT_OWNED", ex.getMessage()));
     }
 
+    @ExceptionHandler(TooManyWriteRequestsException.class)
+    public ResponseEntity<Map<String, String>> handleTooManyRequests(TooManyWriteRequestsException ex) {
+        return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS)
+                .body(errorBody("TOO_MANY_REQUESTS", ex.getMessage()));
+    }
+
     private Map<String, String> errorBody(String code, String message) {
         Map<String, String> body = new HashMap<>();
         body.put("code", code);

src/main/java/com/eactive/apim/portal/djb/community/qna/comment/repository/InquiryCommentRepository.java

@@ -1,9 +1,11 @@
 package com.eactive.apim.portal.djb.community.qna.comment.repository;
 
 import com.eactive.apim.portal.qna.entity.InquiryComment;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Collection;
 import java.util.List;
@@ -17,4 +19,18 @@ public interface InquiryCommentRepository extends JpaRepository<InquiryComment,
             + " group by c.inquiry.id")
     List<Object[]> countActiveGroupByInquiry(@Param("inquiryIds") Collection<String> inquiryIds,
                                              @Param("delYn") String delYn);
+
+    @Transactional
+    long deleteByInquiry_Inquirer_Id(String inquirerId);
+
+    /** 4010 테스트 cleanup 전용 — 삭제 대상 문의글 id 목록에 딸린 댓글을 함께 지운다. */
+    @Transactional
+    long deleteByInquiry_IdIn(Collection<String> inquiryIds);
+
+    /**
+     * 작성 빈도 제한 판정용 — 특정 작성자의 최근 댓글을 최신순으로 조회한다(Pageable 로 건수 제한).
+     * createdBy 는 결정적 암호화라 평문 사용자 id 로 등가 조회가 가능하다.
+     * 삭제(delYn='Y')된 댓글도 포함한다 — 작성 후 지우는 방식의 우회를 막기 위함.
+     */
+    List<InquiryComment> findByCreatedByOrderByCreatedDateDesc(String createdBy, Pageable pageable);
 }

src/main/java/com/eactive/apim/portal/djb/menu/MenuInternalController.java

@@ -1,5 +1,6 @@
 package com.eactive.apim.portal.djb.menu;
 
+import com.eactive.apim.portal.common.internal.InternalApiTokenService;
 import com.eactive.apim.portal.common.util.IpAddressMatcher;
 import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
 import lombok.RequiredArgsConstructor;
@@ -19,14 +20,20 @@ import java.util.Map;
 /**
  * 메뉴 캐시 내부 API — eapim-admin 의 reload 명령 수신용.
  *
- * <p>가드: PTL_PROPERTY {@code Portal / menu.internal.allow-ips} 허용 IP 목록
+ * <p>가드는 두 겹이다.</p>
- * (기본 loopback) + X-Forwarded-For 동반 요청 거부
+ * <ol>
- * ({@code LegacyEncryptionMigrationController.assertLocalOnly} 모델).
+ *   <li><b>공유 토큰 헤더</b> — {@link InternalApiTokenService}. 헤더명/토큰은 PTL_PROPERTY
- * 허용 목록은 {@link IpAddressMatcher} 규칙을 따라 정확 일치 외에
+ *       {@code Portal / internal.api.header-name}, {@code internal.api.token} 으로 관리하며
- * IPv4 CIDR({@code 172.30.1.0/24}) 과 옥텟 와일드카드({@code 172.30.*.*}) 를 지원한다.
+ *       토큰은 포탈 최초 기동 시 자동 생성된다. 이 경로는 CSRF 예외 대상
- * CSRF 는 PortalConfigSecurity 에서 {@code /internal/menu/**} 예외 처리.</p>
+ *       (PortalConfigSecurity {@code /internal/menu/**})이라, 커스텀 헤더 요구가 CSRF 를 대신한다 —
+ *       브라우저의 cross-site form POST 는 커스텀 헤더를 붙일 수 없다.</li>
+ *   <li><b>허용 IP 목록</b> — PTL_PROPERTY {@code Portal / menu.internal.allow-ips}(기본 loopback)
+ *       + X-Forwarded-For 동반 요청 거부. 허용 목록은 {@link IpAddressMatcher} 규칙을 따라 정확 일치 외에
+ *       IPv4 CIDR({@code 172.30.1.0/24}) 과 옥텟 와일드카드({@code 172.30.*.*}) 를 지원한다.</li>
+ * </ol>
  *
- * <pre>curl -X POST http://127.0.0.1:39130/internal/menu/reload</pre>
+ * <pre>curl -X POST -H 'X-Internal-Token: &lt;PTL_PROPERTY Portal/internal.api.token&gt;' \
+ *   http://127.0.0.1:39130/internal/menu/reload</pre>
  */
 @Slf4j
 @RestController
@@ -43,14 +50,18 @@ public class MenuInternalController {
 
     private final MenuService menuService;
     private final PortalPropertyService portalPropertyService;
+    private final InternalApiTokenService internalApiTokenService;
 
     @PostMapping("/reload")
     public ResponseEntity<Map<String, Object>> reload(HttpServletRequest request) {
-        if (!isAllowed(request)) {
+        if (!isAllowedIp(request)) {
-            Map<String, Object> denied = new LinkedHashMap<>();
+            return denied(HttpStatus.FORBIDDEN,
-            denied.put("result", "DENIED");
+                "허용되지 않은 접근입니다. (" + PROP_GROUP + "/" + PROP_ALLOW_IPS + " 확인)");
-            denied.put("message", "허용되지 않은 접근입니다. (menu.internal.allow-ips 확인)");
+        }
-            return ResponseEntity.status(HttpStatus.FORBIDDEN).body(denied);
+        if (!hasValidToken(request)) {
+            return denied(HttpStatus.UNAUTHORIZED,
+                "내부 API 토큰이 유효하지 않습니다. (" + InternalApiTokenService.PROP_GROUP + "/"
+                    + InternalApiTokenService.PROP_TOKEN + " 확인)");
         }
 
         MenuService.MenuSnapshot snapshot = menuService.reload();
@@ -63,12 +74,31 @@ public class MenuInternalController {
         return ResponseEntity.ok(body);
     }
 
+    private ResponseEntity<Map<String, Object>> denied(HttpStatus status, String message) {
+        Map<String, Object> denied = new LinkedHashMap<>();
+        denied.put("result", "DENIED");
+        denied.put("message", message);
+        return ResponseEntity.status(status).body(denied);
+    }
+
+    /**
+     * 공유 토큰 헤더 검사. 헤더명은 PTL_PROPERTY 로 바뀔 수 있으므로 매 요청 조회한다(호출 빈도가 낮다).
+     */
+    private boolean hasValidToken(HttpServletRequest request) {
+        String headerName = internalApiTokenService.ensureHeaderName();
+        if (!internalApiTokenService.matches(request.getHeader(headerName))) {
+            log.warn("메뉴 내부 API 차단 - 토큰 불일치, remote: {}, header: {}", request.getRemoteAddr(), headerName);
+            return false;
+        }
+        return true;
+    }
+
     /**
      * 허용 IP 검사. 프록시 경유(X-Forwarded-For 존재) 요청은 IP 신뢰 불가로 거부한다.
      * (embedded Tomcat 은 forward-headers-strategy: native 로 XFF 가 remoteAddr 에 반영될 수 있으나
      * 그 경우에도 allowlist 검사로 차단된다. WebLogic WAR 배포에서는 원 소켓 IP 로 검사된다.)
      */
-    private boolean isAllowed(HttpServletRequest request) {
+    private boolean isAllowedIp(HttpServletRequest request) {
         String remote = IpAddressMatcher.canonicalize(request.getRemoteAddr());
         boolean viaProxy = request.getHeader("X-Forwarded-For") != null;
 

src/main/java/com/eactive/apim/portal/djb/notitest/NotiTestHistoryEntry.java

@@ -0,0 +1,73 @@
+package com.eactive.apim.portal.djb.notitest;
+
+import com.eactive.apim.portal.djb.notitest.catalog.NotiTestTarget;
+import com.eactive.apim.portal.template.entity.MessageRequest;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * 알림 발송 테스트 이력 1건. HttpSession(속성 {@code NOTI_TEST_HISTORY})에 리스트로 보관한다.
+ *
+ * <p>DB 테이블을 신설하지 않는 요구사항에 따라, 상태는 저장하지 않고 매 폴링마다
+ * {@code requestIds}로 PTL_MESSAGE_REQUEST를 다시 조회해 {@link #refreshStatus} 로 갱신한다.</p>
+ */
+@Getter
+public class NotiTestHistoryEntry implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    private final String entryId;
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
+    private final LocalDateTime requestedAt;
+    private final NotiTestTarget.Category category;
+    private final String targetLabel;
+    private final String messageCode;
+    private final NotiTestTarget.Strategy strategy;
+    private final String recipient;
+    private final List<String> messages;
+    private final List<String> requestIds;
+    private final Map<String, String> statuses = new LinkedHashMap<>();
+    private final String warning;
+    private final String errorMessage;
+
+    private NotiTestHistoryEntry(NotiTestTarget target, String recipient, NotiTestResult result) {
+        this.entryId = UUID.randomUUID().toString();
+        this.requestedAt = LocalDateTime.now();
+        this.category = target.getCategory();
+        this.targetLabel = target.getLabel();
+        this.messageCode = target.getMessageCode().name();
+        this.strategy = target.getStrategy();
+        this.recipient = recipient;
+        this.messages = result.getCreated().stream()
+                .map(MessageRequest::getMessage)
+                .distinct()
+                .collect(Collectors.toList());
+        this.requestIds = result.getCreated().stream().map(MessageRequest::getId).collect(Collectors.toList());
+        this.warning = result.getWarning();
+        this.errorMessage = result.getErrorMessage();
+        for (MessageRequest request : result.getCreated()) {
+            this.statuses.put(request.getId(), request.getRequestStatus());
+        }
+    }
+
+    public static NotiTestHistoryEntry of(NotiTestTarget target, String recipient, NotiTestResult result) {
+        return new NotiTestHistoryEntry(target, recipient, result);
+    }
+
+    /** 폴링 시 최신 상태로 덮어쓴다. 세션에 다시 저장하는 쪽은 호출부 책임이다. */
+    public void refreshStatus(Map<String, MessageRequest> byId) {
+        for (String id : requestIds) {
+            MessageRequest request = byId.get(id);
+            if (request != null) {
+                statuses.put(id, request.getRequestStatus());
+            }
+        }
+    }
+}

src/main/java/com/eactive/apim/portal/djb/notitest/NotiTestProperties.java

@@ -0,0 +1,54 @@
+package com.eactive.apim.portal.djb.notitest;
+
+import com.eactive.apim.portal.portalproperty.service.PortalPropertyService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+/**
+ * 알림 발송 테스트 페이지 관련 {@code PTL_PROPERTY} 접근 래퍼.
+ *
+ * <p>그룹 {@code Portal}, 점 구분 소문자 키 관례를 따른다({@link com.eactive.apim.portal.djb.swing.SwingNotifyProperties} 참고).
+ * {@link PortalPropertyService#getOrCreateProperty} 는 최초 접근 시 기본값으로 DB row 를 생성하므로
+ * 별도 초기 데이터 없이도 동작하며, 운영자는 PTL_PROPERTY 값만 바꿔 재배포 없이 on/off·계정 추가가 가능하다.</p>
+ */
+@Component
+@RequiredArgsConstructor
+public class NotiTestProperties {
+
+    public static final String GROUP = "Portal";
+
+    public static final String KEY_ENABLED = "notification-test.enabled";
+    public static final String KEY_ALLOWED_EMAILS = "notification-test.allowed-emails";
+
+    private static final String LIST_DELIMITERS = "[,;\\r\\n]";
+
+    private final PortalPropertyService portalPropertyService;
+
+    public boolean isEnabled() {
+        String value = resolve(KEY_ENABLED, "false", "알림 발송 테스트 페이지 활성화 여부(true/false)");
+        return "true".equalsIgnoreCase(value == null ? null : value.trim());
+    }
+
+    public boolean isAllowed(String email) {
+        if (email == null || email.trim().isEmpty()) {
+            return false;
+        }
+        String allowList = resolve(KEY_ALLOWED_EMAILS, "",
+                "알림 발송 테스트 페이지 접근 허용 이메일 목록 (콤마/세미콜론/줄바꿈 구분)");
+        if (allowList == null || allowList.trim().isEmpty()) {
+            return false;
+        }
+        String target = email.trim();
+        for (String token : allowList.split(LIST_DELIMITERS)) {
+            String candidate = token.trim();
+            if (!candidate.isEmpty() && candidate.equalsIgnoreCase(target)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private String resolve(String key, String defaultValue, String description) {
+        return portalPropertyService.getOrCreateProperty(GROUP, key, defaultValue, description);
+    }
+}

src/main/java/com/eactive/apim/portal/djb/notitest/NotiTestResult.java

@@ -0,0 +1,35 @@
+package com.eactive.apim.portal.djb.notitest;
+
+import com.eactive.apim.portal.template.entity.MessageRequest;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * {@link NotiTestService#send} 한 번 호출의 결과. 화면/세션에는 이 값을 그대로 담지 않고
+ * {@link NotiTestHistoryEntry}로 변환해서 보관한다(엔티티를 세션에 직렬화하지 않기 위함).
+ */
+@Getter
+public class NotiTestResult {
+
+    private final boolean success;
+    private final List<MessageRequest> created;
+    private final String warning;
+    private final String errorMessage;
+
+    private NotiTestResult(boolean success, List<MessageRequest> created, String warning, String errorMessage) {
+        this.success = success;
+        this.created = created;
+        this.warning = warning;
+        this.errorMessage = errorMessage;
+    }
+
+    public static NotiTestResult of(List<MessageRequest> created, String warning) {
+        return new NotiTestResult(true, created == null ? new ArrayList<>() : created, warning, null);
+    }
+
+    public static NotiTestResult error(String errorMessage) {
+        return new NotiTestResult(false, new ArrayList<>(), null, errorMessage);
+    }
+}

src/main/java/com/eactive/apim/portal/djb/notitest/NotiTestService.java

@@ -0,0 +1,121 @@
+package com.eactive.apim.portal.djb.notitest;
+
+import com.eactive.apim.portal.djb.notitest.catalog.NotiTestTarget;
+import com.eactive.apim.portal.djb.swing.SwingMessageWriter;
+import com.eactive.apim.portal.template.entity.MessageRequest;
+import com.eactive.apim.portal.template.repository.MessageTemplateRepository;
+import com.eactive.apim.portal.template.service.MessageEventHandler;
+import com.eactive.apim.portal.template.service.MessageHandlerService;
+import com.eactive.apim.portal.template.service.MessageRecipient;
+import com.eactive.apim.portal.template.service.MessageSendEvent;
+import com.eactive.apim.portal.template.service.MessageSendService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * 알림 발송 테스트 페이지의 발송 로직. {@link NotiTestTarget.Strategy} 에 따라 세 갈래로 분기한다.
+ *
+ * <p>HANDLER 전략은 {@code MessageHandlerService.publishEvent}(이벤트버스, fire-and-forget)를 쓰지 않는다 —
+ * 반환값을 받을 방법이 없기 때문이다. 대신 핸들러의 {@code createEvent}만 재사용해 파라미터 매핑 로직은
+ * 그대로 살리고, {@code MessageSendService.sendMessage}를 직접 호출해 생성된 {@link MessageRequest} 목록을
+ * 돌려받는다. {@code MessageSendEvent} 구독자는 {@code MessageHandlerService.handleMessageSendEvent} 한
+ * 곳뿐이라 이 우회는 안전하다.</p>
+ */
+@Service
+@RequiredArgsConstructor
+public class NotiTestService {
+
+    private final MessageHandlerService messageHandlerService;
+    private final MessageSendService messageSendService;
+    private final SwingMessageWriter swingMessageWriter;
+    private final MessageTemplateRepository messageTemplateRepository;
+
+    public NotiTestResult send(String messageCodeName, Map<String, String> formParams) {
+        Optional<NotiTestTarget> targetOpt = NotiTestTarget.byMessageCode(messageCodeName);
+        if (!targetOpt.isPresent()) {
+            return NotiTestResult.error("알 수 없는 테스트 대상입니다: " + messageCodeName);
+        }
+        NotiTestTarget target = targetOpt.get();
+        Map<String, String> domainParams = extractDomainParams(target, formParams);
+
+        switch (target.getStrategy()) {
+            case HANDLER:
+                return sendViaHandler(target, buildRecipient(formParams), domainParams);
+            case DIRECT:
+                return sendDirect(target, buildRecipient(formParams), domainParams);
+            case BROADCAST:
+                return sendBroadcast(target, domainParams);
+            default:
+                return NotiTestResult.error("알 수 없는 발송 전략입니다: " + target.getStrategy());
+        }
+    }
+
+    private NotiTestResult sendViaHandler(NotiTestTarget target, MessageRecipient recipient,
+                                           Map<String, String> domainParams) {
+        MessageEventHandler handler = messageHandlerService.getHandlers().get(target.getMessageCode().name());
+        if (handler == null) {
+            // 카탈로그가 HANDLER 로 분류했는데 빈이 없는 방어적 상황(운영 배포 누락 등)
+            return NotiTestResult.error("핸들러 빈이 등록되어 있지 않습니다: " + target.getMessageCode());
+        }
+        Map<String, Object> rawParams = new HashMap<>(domainParams);
+        MessageSendEvent event = handler.createEvent(this, recipient, rawParams);
+        List<MessageRequest> created =
+                messageSendService.sendMessage(event.getMessageCode(), event.getRecipient(), event.getParams());
+        return NotiTestResult.of(created, additionalRecipientWarning(target));
+    }
+
+    private NotiTestResult sendDirect(NotiTestTarget target, MessageRecipient recipient,
+                                       Map<String, String> domainParams) {
+        List<MessageRequest> created =
+                messageSendService.sendMessage(target.getMessageCode(), recipient, new HashMap<>(domainParams));
+        return NotiTestResult.of(created, additionalRecipientWarning(target));
+    }
+
+    private NotiTestResult sendBroadcast(NotiTestTarget target, Map<String, String> domainParams) {
+        Map<String, Object> params = new HashMap<>(domainParams);
+        List<MessageRequest> created = swingMessageWriter.write(target.getMessageCode(), params);
+        return NotiTestResult.of(created, null);
+    }
+
+    /** 실서비스 템플릿에 추가 수신자(PTL_MESSAGE_RECIPIENT)가 등록돼 있으면 테스트 발송에도 함께 나간다는 경고. */
+    private String additionalRecipientWarning(NotiTestTarget target) {
+        return messageTemplateRepository.findById(target.getMessageCode().name())
+                .map(t -> t.getAdditionalRecipients())
+                .filter(list -> list != null && !list.isEmpty())
+                .map(list -> "이 항목은 실서비스 템플릿을 사용합니다. 등록된 추가 수신자 "
+                        + list.size() + "명에게도 함께 발송됩니다.")
+                .orElse(null);
+    }
+
+    /** {@code param_<key>} 폼 필드를 읽되, 비어있으면 카탈로그의 샘플값으로 채운다. */
+    private Map<String, String> extractDomainParams(NotiTestTarget target, Map<String, String> formParams) {
+        Map<String, String> result = new LinkedHashMap<>();
+        for (Map.Entry<String, String> sample : target.getSampleParams().entrySet()) {
+            String value = formParams.get("param_" + sample.getKey());
+            result.put(sample.getKey(), StringUtils.hasText(value) ? value.trim() : sample.getValue());
+        }
+        return result;
+    }
+
+    private MessageRecipient buildRecipient(Map<String, String> formParams) {
+        String email = trimToNull(formParams.get("recipientEmail"));
+        return MessageRecipient.builder()
+                .username(trimToNull(formParams.get("recipientUsername")))
+                .userId(email)
+                .email(email)
+                .phone(trimToNull(formParams.get("recipientPhone")))
+                .messengerId(trimToNull(formParams.get("recipientMessengerId")))
+                .build();
+    }
+
+    private static String trimToNull(String value) {
+        return StringUtils.hasText(value) ? value.trim() : null;
+    }
+}

src/main/java/com/eactive/apim/portal/djb/notitest/catalog/NotiTestTarget.java

@@ -0,0 +1,116 @@
+package com.eactive.apim.portal.djb.notitest.catalog;
+
+import com.eactive.apim.portal.template.entity.MessageCode;
+import lombok.Getter;
+
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * 알림 발송 테스트 페이지가 다루는 16종 테스트 대상 카탈로그.
+ *
+ * <p>발송 경로가 코드 위치에 따라 세 갈래로 갈린다({@link Strategy} 참고). 항목을 추가/변경할 때는
+ * 이 enum 하나만 고치면 된다 — 컨트롤러/서비스/화면은 이 카탈로그를 그대로 순회한다.</p>
+ */
+@Getter
+public enum NotiTestTarget {
+
+    // ---- 전략 HANDLER: elink-portal-common 의 MessageEventHandler 재사용 ----
+    EMAIL_VERIFICATION(Category.EMAIL, "이메일 인증코드", MessageCode.USER_VERIFICATION_EMAIL,
+            Strategy.HANDLER, params("authNumber", "123456")),
+    SMS_VERIFICATION(Category.SMS, "SMS 인증코드", MessageCode.USER_VERIFICATION_MOBILEPHONE,
+            Strategy.HANDLER, params("authNumber", "123456")),
+    SMS_ACCOUNT_LOCKED(Category.SMS, "계정 잠김", MessageCode.USER_ACCOUNT_LOCKED,
+            Strategy.HANDLER, params("reason", "로그인 5회 실패")),
+    SMS_PASSWORD_CHANGED(Category.SMS, "비밀번호 변경", MessageCode.USER_PASSWORD_CHANGED,
+            Strategy.HANDLER, params()),
+    SMS_INVITATION(Category.SMS, "법인 내 초대", MessageCode.USER_INVITATION,
+            Strategy.HANDLER, params(
+                    "corpName", "(주)테스트법인",
+                    "managerName", "홍길동",
+                    "url", "https://example.com/invite",
+                    "authNumber", "123456")),
+    SMS_INVITATION_CANCELED(Category.SMS, "법인 내 초대 취소", MessageCode.USER_INVITATION_CANCELED,
+            Strategy.HANDLER, params(
+                    "corpName", "(주)테스트법인",
+                    "managerName", "홍길동")),
+
+    // ---- 전략 DIRECT: eapim-admin 전용 핸들러(클래스패스 미공유) — MessageSendService 직접 호출 ----
+    SMS_ORG_APPROVED(Category.SMS, "서비스 가입 승인", MessageCode.MANAGER_WITH_ORG_REGISTER_APPROVED,
+            Strategy.DIRECT, params("ORG_NAME", "(주)테스트법인")),
+    SMS_ORG_REJECTED(Category.SMS, "서비스 가입 거절", MessageCode.MANAGER_WITH_ORG_REGISTER_REJECTED,
+            Strategy.DIRECT, params("ORG_NAME", "(주)테스트법인", "REASON", "서류 미비")),
+    SMS_APP_APPROVED(Category.SMS, "클라이언트 승인", MessageCode.APP_APPROVE,
+            Strategy.DIRECT, params("APP_NAME", "테스트앱")),
+    SMS_APP_REJECTED(Category.SMS, "클라이언트 거절", MessageCode.APP_REJECTED,
+            Strategy.DIRECT, params("APP_NAME", "테스트앱", "REASON", "정책 위반")),
+    SMS_ADMIN_LOGIN(Category.SMS, "관리자포탈 로그인", MessageCode.ADMIN_VERIFICATION_MOBILEPHONE,
+            Strategy.DIRECT, params("authNumber", "123456", "userName", "관리자")),
+    MSG_API_STATUS(Category.MESSENGER, "API 상태 감시", MessageCode.API_STATUS_CHANGED,
+            Strategy.DIRECT, params("message", "[테스트] API 상태 변화 알림")),
+    MSG_INFLOW_TOKEN(Category.MESSENGER, "이상 징후 감시", MessageCode.INFLOW_TOKEN_FAILED,
+            Strategy.DIRECT, params("message", "[테스트] 유량제어 토큰 획득 실패")),
+
+    // ---- 전략 BROADCAST: SwingMessageWriter 직접 호출(PTL_PROPERTY 역할의 내부직원 전원에게 발송) ----
+    MSG_QNA_CREATED(Category.MESSENGER, "QnA 질문등록", MessageCode.INQUIRY_CREATED,
+            Strategy.BROADCAST, params(
+                    "inquiryId", "TEST-0001",
+                    "inquirySubject", "[테스트] 문의 제목",
+                    "writerName", "홍길동")),
+    MSG_QNA_COMMENT(Category.MESSENGER, "QnA 댓글 등록", MessageCode.INQUIRY_COMMENT_CREATED,
+            Strategy.BROADCAST, params(
+                    "inquiryId", "TEST-0001",
+                    "inquirySubject", "[테스트] 문의 제목",
+                    "commentContent", "테스트 댓글입니다",
+                    "writerName", "홍길동")),
+    MSG_PARTNERSHIP(Category.MESSENGER, "개선요청 새글 등록", MessageCode.PARTNERSHIP_CREATED,
+            Strategy.BROADCAST, params(
+                    "partnershipId", "TEST-0001",
+                    "bizSubject", "[테스트] 개선요청 제목",
+                    "writerName", "홍길동")),
+    ;
+
+    @Getter
+    public enum Category {
+        EMAIL("이메일"), SMS("SMS"), MESSENGER("메신저");
+
+        private final String label;
+
+        Category(String label) {
+            this.label = label;
+        }
+    }
+
+    public enum Strategy { HANDLER, DIRECT, BROADCAST }
+
+    private final Category category;
+    private final String label;
+    private final MessageCode messageCode;
+    private final Strategy strategy;
+    private final Map<String, String> sampleParams;
+
+    NotiTestTarget(Category category, String label, MessageCode messageCode, Strategy strategy,
+                   Map<String, String> sampleParams) {
+        this.category = category;
+        this.label = label;
+        this.messageCode = messageCode;
+        this.strategy = strategy;
+        this.sampleParams = sampleParams;
+    }
+
+    public static Optional<NotiTestTarget> byMessageCode(String messageCodeName) {
+        return Arrays.stream(values())
+                .filter(t -> t.messageCode.name().equalsIgnoreCase(messageCodeName))
+                .findFirst();
+    }
+
+    private static Map<String, String> params(String... kv) {
+        Map<String, String> map = new LinkedHashMap<>();
+        for (int i = 0; i < kv.length; i += 2) {
+            map.put(kv[i], kv[i + 1]);
+        }
+        return map;
+    }
+}

src/main/java/com/eactive/apim/portal/djb/notitest/controller/NotiTestController.java

@@ -0,0 +1,194 @@
+package com.eactive.apim.portal.djb.notitest.controller;
+
+import com.eactive.apim.portal.common.user.PortalAuthenticatedUser;
+import com.eactive.apim.portal.common.util.SecurityUtil;
+import com.eactive.apim.portal.djb.notitest.NotiTestHistoryEntry;
+import com.eactive.apim.portal.djb.notitest.NotiTestProperties;
+import com.eactive.apim.portal.djb.notitest.NotiTestResult;
+import com.eactive.apim.portal.djb.notitest.NotiTestService;
+import com.eactive.apim.portal.djb.notitest.catalog.NotiTestTarget;
+import com.eactive.apim.portal.template.entity.MessageRequest;
+import com.eactive.apim.portal.template.repository.MessageRequestRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * 알림 발송 테스트 페이지.
+ *
+ * <p>PTL_PROPERTY({@link NotiTestProperties})로 기능 on/off 와 접근 허용 이메일 목록을 관리한다.
+ * 운영에서도 상시 켜둘 수 있도록 GNB 에는 노출하지 않고 직접 URL 로만 접근한다(page.yml/portal.pages
+ * 미등록). 발송 이력은 별도 테이블 없이 HttpSession 에 보관하고, 상태는 기존 PTL_MESSAGE_REQUEST 를
+ * 3초 폴링으로 재조회해 갱신한다.</p>
+ */
+@Slf4j
+@Controller
+@RequestMapping("//notitest")
+@RequiredArgsConstructor
+public class NotiTestController {
+
+    private static final String SESSION_HISTORY_KEY = "NOTI_TEST_HISTORY";
+    private static final int MAX_HISTORY = 50;
+
+    private final NotiTestProperties notiTestProperties;
+    private final NotiTestService notiTestService;
+    private final MessageRequestRepository messageRequestRepository;
+
+    /** 폼 + 이력 렌더 */
+    @GetMapping
+    public ModelAndView index(HttpSession session, HttpServletResponse response) {
+        if (!notiTestProperties.isEnabled()) {
+            response.setStatus(HttpStatus.NOT_FOUND.value());
+            return null;
+        }
+        if (!isAllowedForCurrentUser()) {
+            response.setStatus(HttpStatus.FORBIDDEN.value());
+            return null;
+        }
+
+        PortalAuthenticatedUser me = SecurityUtil.getPortalAuthenticatedUser();
+
+        ModelAndView mav = new ModelAndView("djb/notitest/index");
+        mav.addObject("targetsByCategory", groupByCategory());
+        mav.addObject("history", getHistory(session));
+        mav.addObject("defaultUsername", me.getUserName());
+        mav.addObject("defaultEmail", me.getEmailAddr());
+        mav.addObject("defaultPhone", me.getMobileNumber());
+        return mav;
+    }
+
+    /** 발송(AJAX) */
+    @PostMapping("/send")
+    @ResponseBody
+    public ResponseEntity<?> send(@RequestParam Map<String, String> allParams, HttpSession session) {
+        ResponseEntity<?> denied = guardResponse();
+        if (denied != null) {
+            return denied;
+        }
+
+        String messageCode = allParams.get("messageCode");
+        if (!StringUtils.hasText(messageCode)) {
+            return ResponseEntity.badRequest().body(Collections.singletonMap("error", "messageCode is required"));
+        }
+
+        NotiTestTarget target = NotiTestTarget.byMessageCode(messageCode).orElse(null);
+        if (target == null) {
+            return ResponseEntity.badRequest()
+                    .body(Collections.singletonMap("error", "알 수 없는 테스트 대상입니다: " + messageCode));
+        }
+
+        NotiTestResult result = notiTestService.send(messageCode, allParams);
+        NotiTestHistoryEntry entry = NotiTestHistoryEntry.of(target, resolveRecipient(target, allParams), result);
+        pushHistory(session, entry);
+        return ResponseEntity.ok(entry);
+    }
+
+    /** 상태 폴링(AJAX, 3초 간격) — 별도 테이블 없이 PTL_MESSAGE_REQUEST 만 재조회한다. */
+    @GetMapping("/status")
+    @ResponseBody
+    public ResponseEntity<?> status(HttpSession session) {
+        ResponseEntity<?> denied = guardResponse();
+        if (denied != null) {
+            return denied;
+        }
+
+        List<NotiTestHistoryEntry> history = getHistory(session);
+        Set<String> ids = history.stream()
+                .flatMap(h -> h.getRequestIds().stream())
+                .collect(Collectors.toSet());
+
+        if (!ids.isEmpty()) {
+            Map<String, MessageRequest> byId = messageRequestRepository.findAllById(ids).stream()
+                    .collect(Collectors.toMap(MessageRequest::getId, Function.identity()));
+            history.forEach(h -> h.refreshStatus(byId));
+            session.setAttribute(SESSION_HISTORY_KEY, history);
+        }
+        return ResponseEntity.ok(history);
+    }
+
+    private ResponseEntity<?> guardResponse() {
+        if (!notiTestProperties.isEnabled()) {
+            return ResponseEntity.notFound().build();
+        }
+        if (!isAllowedForCurrentUser()) {
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+        }
+        return null;
+    }
+
+    private boolean isAllowedForCurrentUser() {
+        PortalAuthenticatedUser user = SecurityUtil.getPortalAuthenticatedUser();
+        String email = user == null ? null : user.getEmailAddr();
+        boolean allowed = notiTestProperties.isAllowed(email);
+        if (!allowed) {
+            log.warn("알림 테스트 페이지 접근 거부 - email: {}", email);
+        }
+        return allowed;
+    }
+
+    private Map<NotiTestTarget.Category, List<NotiTestTarget>> groupByCategory() {
+        return Arrays.stream(NotiTestTarget.values())
+                .collect(Collectors.groupingBy(NotiTestTarget::getCategory, LinkedHashMap::new, Collectors.toList()));
+    }
+
+    private String resolveRecipient(NotiTestTarget target, Map<String, String> formParams) {
+        if (target.getStrategy() == NotiTestTarget.Strategy.BROADCAST) {
+            return "실제 담당자 전원";
+        }
+        String phone = formParams.get("recipientPhone");
+        String email = formParams.get("recipientEmail");
+        String messengerId = formParams.get("recipientMessengerId");
+
+        if (target.getCategory() == NotiTestTarget.Category.EMAIL && StringUtils.hasText(email)) {
+            return email;
+        }
+        if (StringUtils.hasText(phone)) {
+            return phone;
+        }
+        if (StringUtils.hasText(email)) {
+            return email;
+        }
+        if (StringUtils.hasText(messengerId)) {
+            return messengerId;
+        }
+        return "-";
+    }
+
+    @SuppressWarnings("unchecked")
+    private void pushHistory(HttpSession session, NotiTestHistoryEntry entry) {
+        List<NotiTestHistoryEntry> history = (List<NotiTestHistoryEntry>) session.getAttribute(SESSION_HISTORY_KEY);
+        history = (history == null) ? new ArrayList<>() : new ArrayList<>(history);
+        history.add(0, entry);
+        if (history.size() > MAX_HISTORY) {
+            history = new ArrayList<>(history.subList(0, MAX_HISTORY));
+        }
+        session.setAttribute(SESSION_HISTORY_KEY, history);
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<NotiTestHistoryEntry> getHistory(HttpSession session) {
+        List<NotiTestHistoryEntry> history = (List<NotiTestHistoryEntry>) session.getAttribute(SESSION_HISTORY_KEY);
+        return (history == null) ? new ArrayList<>() : history;
+    }
+}

src/main/java/com/eactive/apim/portal/djb/swing/SwingMessageWriter.java

@@ -14,6 +14,7 @@ import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;
 
 import java.time.LocalDateTime;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -42,38 +43,43 @@ public class SwingMessageWriter {
     private final SwingNotifyProperties properties;
 
     @Transactional
-    public void write(MessageCode code, Map<String, Object> params) {
+    public List<MessageRequest> write(MessageCode code, Map<String, Object> params) {
         String role = properties.getTargetRole();
         List<UserInfo> staffs = swingStaffRepository.findByRole(role);
         if (staffs == null || staffs.isEmpty()) {
             log.warn("Swing 알림 대상 직원이 없습니다 — role={}, code={}", role, code.name());
-            return;
+            return new ArrayList<>();
         }
 
         MessageTemplate template = messageTemplateRepository.findById(code.name()).orElse(null);
         if (template == null) {
             log.warn("메세지 템플릿이 존재하지 않습니다 — code={}", code.name());
-            return;
+            return new ArrayList<>();
         }
         if (!ENABLED.equalsIgnoreCase(template.getEnableMessenger())) {
             log.warn("메신저 발송이 비활성화된 템플릿입니다 — code={}, enableMessenger={}",
                     code.name(), template.getEnableMessenger());
-            return;
+            return new ArrayList<>();
         }
 
         SwingNotifyProperties.UmsMessengerIds umsIds = properties.getUmsMessengerIds();
         EmployeeIdPolicy policy = properties.getNonEmployeePolicy();
 
+        List<MessageRequest> created = new ArrayList<>();
         for (UserInfo staff : staffs) {
             try {
-                writeOne(code, template, params, staff, umsIds, policy);
+                MessageRequest saved = writeOne(code, template, params, staff, umsIds, policy);
+                if (saved != null) {
+                    created.add(saved);
+                }
             } catch (Exception e) {
                 log.warn("Swing 알림 적재 실패 — userid={}, code={}", staff.getUserid(), code.name(), e);
             }
         }
+        return created;
     }
 
-    private void writeOne(MessageCode code, MessageTemplate template, Map<String, Object> params,
+    private MessageRequest writeOne(MessageCode code, MessageTemplate template, Map<String, Object> params,
                           UserInfo staff, SwingNotifyProperties.UmsMessengerIds umsIds,
                           EmployeeIdPolicy policy) {
 
@@ -83,10 +89,10 @@ public class SwingMessageWriter {
         if (!properties.isEmployeeId(messengerId)) {
             switch (policy) {
                 case REJECT:
-                    return;
+                    return null;
                 case REJECT_LOG:
                     log.info("행번이 아닌 ID — 발송 거부(미적재). userid={}, code={}", messengerId, code.name());
-                    return;
+                    return null;
                 case SKIP:
                     log.info("행번이 아닌 ID — 무시 처리({}). userid={}, code={}",
                             STATUS_SKIPPED, messengerId, code.name());
@@ -124,8 +130,9 @@ public class SwingMessageWriter {
         request.setRequestStatus(requestStatus);
         // email/phone 은 설정하지 않는다 — 메신저 전용 경로라 개인정보를 적재할 이유가 없다.
 
-        messageRequestRepository.save(request);
+        MessageRequest saved = messageRequestRepository.save(request);
         log.debug("Swing 알림 적재 — code={}, userid={}, status={}", code.name(), messengerId, requestStatus);
+        return saved;
     }
 
     /** 수신자별로 파라미터를 복사한다(공유 맵을 오염시키지 않기 위함). */