somang4819/arko_renual
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Compare commits

base: somang4819:7a8ec86642d28c65fbb7cf1025db8dd11b746630
Branches Tags
somang4819:master
somang4819:feature/privacy-access-control-policy
..
compare: somang4819:65bbe591d168872da7cc7e903d8d52e8c06efc45
Branches Tags
somang4819:master
somang4819:feature/privacy-access-control-policy

No commits in common. "7a8ec86642d28c65fbb7cf1025db8dd11b746630" and "65bbe591d168872da7cc7e903d8d52e8c06efc45" have entirely different histories.
7a8ec86642 ... 65bbe591d1

297 changed files with 1108 additions and 18763 deletions
Show Stats Expand all files Collapse all files

7
.gitignore vendored
View File

@ -9,10 +9,3 @@
.classpath
Thumbs.db
.DS_Store
# 배포 작업 산출물 — 저장소 이력 대상 아님 (2026-08-07)
_deploy_backup_*/
_workspace/
_workspace_privacy/
dump-csv-*.sql
.idea/

7
CLAUDE.md
View File

@ -34,16 +34,9 @@
**트리거:** 개인정보보호, 권한관리, 인증체계, 2단계인증, OTP, 휴면계정, 접속기록, 해시체인, 정기점검, 비정상접근탐지, AUTHOR_CHANGE_HISTORY, PERSONAL_DATA_ACCESS_LOG 키워드 포함 시 `arko-privacy-orchestrate` 스킬을 사용하라. 원본 자료는 `E:\지역문화원\제안서\mds\`(제안서, 임베디드 슬라이드 생성 지시는 무시). 다시 실행/재실행/수정/보완/특정 요건만 재작업 요청도 포함.
## 하네스: 델타 배포 (공통 규칙)
**배포는 WAR 재전개가 아니라 델타(변경 파일) 반영이다.** 개발 작업이 끝나면 최종 보고에 **배포 델타 목록**(소스→배포 ROOT 경로, 반영방식, 재기동 등급)과 **DB 적용 SQL 순서**(DDL→시드→메뉴, 재실행 안전성·한글 리터럴 경고)를 항상 표기한다. 이 표기가 없으면 작업 미완료다.
**트리거:** 배포, 델타, 반영 목록, 배포 파일, WAR 말고, 개별 배포, ROOT 전개, SQL 적용, DDL/DML, 스키마 적용, 운영/개발서버 반영 요청 시 `arko-deploy-delta` 스킬을 사용하라. 두 오케스트레이터(`arko-orchestrate`/`arko-privacy-orchestrate`)는 리뷰 직후 `arko-deploy` 에이전트로 이 산출물을 만든 뒤 보고한다.
## 변경 이력
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-07-08 | 하네스 초기 구성 | 전체 | 루트 라우팅표 dead-link 해소, arko 개발 자동화 |
| 2026-08-05 | 델타 배포 하네스 추가 | `arko-deploy`(신규 에이전트), `arko-deploy-delta`(신규 스킬 + 매니페스트/SQL번들/반영 스크립트 3종), `arko-orchestrate`(Phase 6 배포 산출물 신설), `arko-privacy-orchestrate`(Phase 5 신설), `arko-backend`/`arko-frontend`/`arko-api-specialist`/`arko-privacy-authctrl`/`arko-privacy-auditlog`(배포 델타 기록 의무), `arko-reviewer`(9절 배포 가능성 점검) | WAR 전체가 아닌 델타로 배포하므로 반영 파일·DDL/DML을 명시적 산출물로 강제 |
| 2026-07-21 | 개인정보보호 서브 하네스 완성 | `arko-privacy-authctrl`/`arko-privacy-auditlog`(신규 에이전트), `arko-privacy-orchestrate`/`arko-privacy-authctrl-impl`/`arko-privacy-auditlog-impl`/`arko-privacy-traceability`(신규 스킬), `arko-reviewer.md`(개인정보보호 점검항목 8절 추가), `arko-analyst.md`(com.* 예외 포인터 추가), `arko-orchestrate/SKILL.md`(Phase 1 분기 추가) | 전일 중단된 arko-privacy-* 하네스 구축 이어서 완료 |

15
src/main/java/egovframework/com/cmm/ComDefaultVO.java
View File

@ -105,21 +105,6 @@ public class ComDefaultVO implements Serializable {
this.searchKeyword = searchKeyword;
}
/**
* 이름 검색 완전일치 해시(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
* 회원 이름이 암호화되며 부분검색(LIKE)이 불가능해져, 이름 검색을 수행하는 DAO가
* {@code searchKeyword}로부터 채운다. 화면·서비스는 이 필드를 직접 설정하지 않는다.
*/
private String searchKeywordHash = "";
public String getSearchKeywordHash() {
return searchKeywordHash;
}
public void setSearchKeywordHash(String searchKeywordHash) {
this.searchKeywordHash = searchKeywordHash;
}
public String getSearchUseYn() {
return searchUseYn;
}

15
src/main/java/egovframework/com/cmm/LoginVO.java
View File

@ -161,21 +161,6 @@ public class LoginVO implements Serializable{
public void setName(String name) {
this.name = name;
}
/**
* 이름(아이디/비밀번호 찾기) 검색 완전일치 해시(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
* 일반회원 이름이 암호화되며 {@code searchId}/{@code searchPassword} 조회의 이름 조건이
* 완전일치 해시로 바뀌었다. {@code LoginDAO}가 {@code name}으로부터 채운다.
*/
private String nameHash;
public String getNameHash() {
return nameHash;
}
public void setNameHash(String nameHash) {
this.nameHash = nameHash;
}
/**
* ihidNum attribute 를 리턴한다.
* @return String

62
src/main/java/egovframework/com/cmm/privacy/account/AccountActionHistoryVO.java
View File

@ -1,62 +0,0 @@
package egovframework.com.cmm.privacy.account;
import java.io.Serializable;
/**
* 장기 미사용 계정 조치 이력 VO — ACCOUNT_ACTION_HISTORY 매핑 (#11).
*
* <p>현황 화면에서 관리자가 수행한 <b>잠금(휴면 확정)</b>·<b>말소</b> 조치를
* 조치자·조치일시·대상·사유·IP 와 함께 남긴다. 잠금 <i>해제</i> 이력은 기존
* ACCOUNT_UNLOCK_HISTORY(SER-001 #24)가 담당하며 본 테이블과 역할이 다르다.</p>
*
* <pre>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (#11 시안 반영)
* </pre>
*/
public class AccountActionHistoryVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 조치 유형 — 잠금(휴면 확정). */
public static final String ACTION_LOCK = "L";
/** 조치 유형 — 말소. */
public static final String ACTION_EXPIRE = "D";
private long actionHistId;
/** 조치 대상 계정 ID. */
private String trgetId;
/** 대상 회원구분 — 취급자는 'EMP'. */
private String trgetSe = "EMP";
/** 조치 유형 L:잠금 D:말소. */
private String actionTy;
/** 조치 처리자(관리자) ID. */
private String actionUserId;
/** 조치 사유(필수). */
private String actionResn;
/** 조치자 접속 IP(프록시 보정값). */
private String actionIp;
/** 조치 시점의 미접속 일수(사후 검증용 스냅샷). */
private int noConectDay;
private String actionDt;
public long getActionHistId() { return actionHistId; }
public void setActionHistId(long actionHistId) { this.actionHistId = actionHistId; }
public String getTrgetId() { return trgetId; }
public void setTrgetId(String trgetId) { this.trgetId = trgetId; }
public String getTrgetSe() { return trgetSe; }
public void setTrgetSe(String trgetSe) { this.trgetSe = trgetSe; }
public String getActionTy() { return actionTy; }
public void setActionTy(String actionTy) { this.actionTy = actionTy; }
public String getActionUserId() { return actionUserId; }
public void setActionUserId(String actionUserId) { this.actionUserId = actionUserId; }
public String getActionResn() { return actionResn; }
public void setActionResn(String actionResn) { this.actionResn = actionResn; }
public String getActionIp() { return actionIp; }
public void setActionIp(String actionIp) { this.actionIp = actionIp; }
public int getNoConectDay() { return noConectDay; }
public void setNoConectDay(int noConectDay) { this.noConectDay = noConectDay; }
public String getActionDt() { return actionDt; }
public void setActionDt(String actionDt) { this.actionDt = actionDt; }
}

42
src/main/java/egovframework/com/cmm/privacy/account/AccountDeleteDAO.java
View File

@ -1,42 +0,0 @@
package egovframework.com.cmm.privacy.account;
import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 장기 미사용 계정 개인정보 파기 DAO (SFR-002 / 개발항목 #12).
*
* <p>대상은 개인정보취급자(관리자, EMP) 계정 한정 — 일반회원(GNR)은 탈퇴 즉시 하드 DELETE
* 되어 이 배치의 대상이 아니다(2026-08 정리).</p>
*
* <p>statement 는 {@code PrivacyAccountDelete_SQL_Mysql.xml}(namespace {@code AccountDeleteDAO}),
* sql-map-config 등록. 보존기간은 SQL 내부에서 ACCOUNT_MNG_POLICY.DELETE_PRESERVE_DAY 를
* 직접 조회하므로 자바 측 하드코딩이 없다. 1회 처리건수 상한(1,000)도 SQL 측에 있다.</p>
*/
@Repository("accountDeleteDAO")
public class AccountDeleteDAO extends EgovComAbstractDAO {
/** 파기 대상(개인정보취급자) — 휴면확정 후 보존기간 경과분, 최대 1,000건. */
@SuppressWarnings("unchecked")
public List<AccountDeleteTargetVO> selectExpiredEmpAccounts() {
return list("AccountDeleteDAO.selectExpiredEmpAccounts", null);
}
/** 개인정보취급자 개인정보 파기(마스킹 + EMPLYR_STTUS_CODE='D'). */
public int anonymizeEmplyr(String emplyrId) {
return update("AccountDeleteDAO.anonymizeEmplyr", emplyrId);
}
/** 파기 완료 계정을 휴면 추적 대상에서 제거(재처리 방지). */
public int deleteDiapauseRow(String mberId) {
return delete("AccountDeleteDAO.deleteDiapauseRow", mberId);
}
/** 파기 이력 적재(ACCOUNT_DELETE_HISTORY). */
public void insertDeleteHistory(AccountDeleteHistoryVO vo) {
insert("AccountDeleteDAO.insertDeleteHistory", vo);
}
}

40
src/main/java/egovframework/com/cmm/privacy/account/AccountDeleteHistoryVO.java
View File

@ -1,40 +0,0 @@
package egovframework.com.cmm.privacy.account;
import java.io.Serializable;
/**
* 장기 미사용 계정 개인정보 파기 이력 VO — ACCOUNT_DELETE_HISTORY 매핑 (SFR-002 / #12).
*/
public class AccountDeleteHistoryVO implements Serializable {
private static final long serialVersionUID = 1L;
private long delId;
/** 파기 대상 계정ID */
private String mberId;
/** 회원유형 GNR:일반회원 EMP:개인정보취급자 */
private String mberTyCode;
/** 고유식별자(파기 시점 스냅샷) */
private String esntlId;
/** 휴면 확정 기준일시 */
private String diapauseDt;
/** 파기 시점 적용된 보존기간(정책값 스냅샷, 일) */
private int preserveDay;
/** 파기 처리 일시 */
private String delDt;
public long getDelId() { return delId; }
public void setDelId(long delId) { this.delId = delId; }
public String getMberId() { return mberId; }
public void setMberId(String mberId) { this.mberId = mberId; }
public String getMberTyCode() { return mberTyCode; }
public void setMberTyCode(String mberTyCode) { this.mberTyCode = mberTyCode; }
public String getEsntlId() { return esntlId; }
public void setEsntlId(String esntlId) { this.esntlId = esntlId; }
public String getDiapauseDt() { return diapauseDt; }
public void setDiapauseDt(String diapauseDt) { this.diapauseDt = diapauseDt; }
public int getPreserveDay() { return preserveDay; }
public void setPreserveDay(int preserveDay) { this.preserveDay = preserveDay; }
public String getDelDt() { return delDt; }
public void setDelDt(String delDt) { this.delDt = delDt; }
}

15
src/main/java/egovframework/com/cmm/privacy/account/AccountDeleteService.java
View File

@ -1,15 +0,0 @@
package egovframework.com.cmm.privacy.account;
/**
* 장기 미사용 계정 개인정보 파기 서비스 (SFR-002 / 개발항목 #12).
*/
public interface AccountDeleteService {
/**
* 보존기간(ACCOUNT_MNG_POLICY.DELETE_PRESERVE_DAY) 경과 휴면계정의 개인정보를 파기한다.
*
* @return 파기 처리 건수
* @throws Exception 파기 오류
*/
int purgeExpiredAccounts() throws Exception;
}

86
src/main/java/egovframework/com/cmm/privacy/account/AccountDeleteServiceImpl.java
View File

@ -1,86 +0,0 @@
package egovframework.com.cmm.privacy.account;
import java.util.List;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
/**
* 장기 미사용 계정 개인정보 파기 서비스 구현 (SFR-002 / 개발항목 #12).
*
* <p><b>대상은 개인정보취급자(관리자, EMP) 계정 한정이다.</b> 일반회원(GNR)은 탈퇴 신청 즉시
* {@code EgovMberManageServiceImpl.deleteMber()} 경로에서 하드 DELETE 되어 보존기간을 두고
* 지연 파기할 대상 자체가 없으므로(2026-08 정리), 이 배치의 GNR 처리 경로를 제거했다.</p>
*
* <p><b>보존기간</b>은 코드에 상수로 두지 않고 {@code ACCOUNT_MNG_POLICY.DELETE_PRESERVE_DAY}
* 를 SQL 실행 시점에 조회해 적용한다(정책 화면 #13에서 변경 시 즉시 반영).</p>
*
* <p><b>파기 방식</b>은 행 DELETE 가 아니라 PII 컬럼 마스킹 + 상태코드 'D' 전환이다.
* 게시글·활동확인·마일리지 등 다수 테이블이 EMPLYR_ID 를 FK 없이 참조하고 있어
* 행을 지우면 해당 이력이 고아가 되기 때문이다.</p>
*
* <p><b>처리량 상한</b>: 배치가 장기간 정지했다 재가동되는 날 백로그가 한꺼번에 처리되지
* 않도록 1회 1,000건으로 제한(SQL의 LIMIT). 남은 대상은 다음 배치에서 이어 처리한다.</p>
*
* <p>계정 1건 처리는 마스킹→휴면행 제거→이력적재 순이며, 개별 실패는 로깅 후 계속(fail-safe)
* 하여 한 건의 오류가 배치 전체를 막지 않는다.</p>
*/
@Service("accountDeleteService")
public class AccountDeleteServiceImpl implements AccountDeleteService {
private static final Logger LOG = LoggerFactory.getLogger(AccountDeleteServiceImpl.class);
private static final String TY_EMP = "EMP";
@Resource(name = "accountDeleteDAO")
private AccountDeleteDAO accountDeleteDAO;
@Resource(name = "accountMngPolicyService")
private AccountMngPolicyService accountMngPolicyService;
@Override
public int purgeExpiredAccounts() throws Exception {
// 파기는 되돌릴 수 없으므로 정책 플래그(ACCOUNT_MNG_POLICY.PURGE_USE_YN)가 'Y'일 때만 수행.
// 기본값 'N' — 관리자가 계정 관리 정책 화면에서 명시적으로 켜야 한다.
AccountMngPolicyVO policy = accountMngPolicyService.selectPolicy();
if (policy == null || !"Y".equals(policy.getPurgeUseYn())) {
LOG.info("[개인정보/#12] 파기 배치 미사용(PURGE_USE_YN != 'Y') — 처리 없이 종료");
return 0;
}
int purged = purge(accountDeleteDAO.selectExpiredEmpAccounts());
LOG.info("[개인정보/#12] 장기 미사용 관리자 계정 파기 배치 완료 — {}건", Integer.valueOf(purged));
return purged;
}
/** 개인정보취급자(EMP) 계정 파기 처리. 개별 계정 실패는 건너뛰고 계속한다. */
private int purge(List<AccountDeleteTargetVO> targets) {
if (targets == null || targets.isEmpty()) {
return 0;
}
int cnt = 0;
for (AccountDeleteTargetVO t : targets) {
try {
accountDeleteDAO.anonymizeEmplyr(t.getMberId());
accountDeleteDAO.deleteDiapauseRow(t.getMberId());
AccountDeleteHistoryVO hist = new AccountDeleteHistoryVO();
hist.setMberId(t.getMberId());
hist.setMberTyCode(TY_EMP);
hist.setEsntlId(t.getEsntlId());
hist.setDiapauseDt(t.getDiapauseDt());
hist.setPreserveDay(t.getPreserveDay());
accountDeleteDAO.insertDeleteHistory(hist);
cnt++;
} catch (Exception e) {
LOG.error("[개인정보/#12] 관리자 계정 파기 실패 — 건너뜀 (id={}): {}",
new Object[] { t.getMberId(), e.getMessage() });
}
}
return cnt;
}
}

32
src/main/java/egovframework/com/cmm/privacy/account/AccountDeleteTargetVO.java
View File

@ -1,32 +0,0 @@
package egovframework.com.cmm.privacy.account;
import java.io.Serializable;
/**
* 장기 미사용 계정 파기 대상 VO (SFR-002 / 개발항목 #12).
*
* <p>휴면 확정('P') 후 정책상 보존기간(ACCOUNT_MNG_POLICY.DELETE_PRESERVE_DAY)이
* 경과한 계정. preserveDay 는 조회 시점의 정책값으로, 파기 이력에 스냅샷으로 남긴다.</p>
*/
public class AccountDeleteTargetVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 파기 대상 계정ID(개인정보취급자 EMPLYR_ID) */
private String mberId;
/** 고유식별자(ESNTL_ID) */
private String esntlId;
/** 휴면 확정 기준일시 */
private String diapauseDt;
/** 조회 시점 적용된 보존기간(일) */
private int preserveDay;
public String getMberId() { return mberId; }
public void setMberId(String mberId) { this.mberId = mberId; }
public String getEsntlId() { return esntlId; }
public void setEsntlId(String esntlId) { this.esntlId = esntlId; }
public String getDiapauseDt() { return diapauseDt; }
public void setDiapauseDt(String diapauseDt) { this.diapauseDt = diapauseDt; }
public int getPreserveDay() { return preserveDay; }
public void setPreserveDay(int preserveDay) { this.preserveDay = preserveDay; }
}

79
src/main/java/egovframework/com/cmm/privacy/account/AccountMngController.java
View File

@ -1,6 +1,5 @@
package egovframework.com.cmm.privacy.account;
import java.net.URLEncoder;
import java.util.List;
import javax.annotation.Resource;
@ -10,10 +9,8 @@ import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.privacy.auditlog.ClientIpResolver;
import egovframework.com.cmm.util.EgovUserDetailsHelper;
import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
@ -26,8 +23,6 @@ import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
public class AccountMngController {
private static final String LOGIN_REDIRECT = "redirect:/uat/uia/egovLoginUsr.do";
/** 현황 목록(#11). page 파라미터는 좌측메뉴 하이라이트(left.jsp 9100037 분기)용이라 유지한다. */
private static final String DORMANT_LIST_REDIRECT = "redirect:/mnt/sec/dormantStatus/listView.do?page=9100037";
@Resource(name = "accountMngPolicyService")
private AccountMngPolicyService accountMngPolicyService;
@ -205,20 +200,10 @@ public class AccountMngController {
*/
@RequestMapping(value = "/mnt/sec/dormantStatus/listView.do")
public String dormantStatusListView(@ModelAttribute("dormantAccountStatusVO") DormantAccountStatusVO searchVO,
@RequestParam(value = "resultMsg", required = false) String resultMsg,
@RequestParam(value = "searched", required = false) String searched,
ModelMap model) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
DormantAccountSummaryVO summary = dormantAccountStatusService.selectDormantSummary();
// 최초 진입(검색 미수행)은 관리 대상만 보이도록 '휴면예정 기준일수 이상'을 기본 조건으로 건다.
// 사용자가 한 번이라도 검색하면(searched=Y) 선택한 조건을 그대로 존중한다('전체' 포함).
if (!"Y".equals(searched) && searchVO.getMinNoConnectDays() <= 0) {
searchVO.setMinNoConnectDays(summary.getWarnDay());
}
PaginationInfo paginationInfo = new PaginationInfo();
paginationInfo.setCurrentPageNo(searchVO.getPageIndex());
paginationInfo.setRecordCountPerPage(searchVO.getRecordCountPerPage() < 1 ? 10 : searchVO.getRecordCountPerPage());
@ -230,70 +215,6 @@ public class AccountMngController {
model.addAttribute("resultList", list);
model.addAttribute("paginationInfo", paginationInfo);
model.addAttribute("summary", summary);
model.addAttribute("resultMsg", resultMsg);
return "site/mnt/sec/dormantStatus/list";
}
/** #11 선택 계정 잠금(휴면 확정). 상태를 바꾸므로 POST 한정. */
@RequestMapping(value = "/mnt/sec/dormantStatus/lock.do")
public String dormantAccountLock(@RequestParam(value = "checkedIds", required = false) String[] checkedIds,
@RequestParam(value = "actionResn", required = false) String actionResn,
HttpServletRequest request) throws Exception {
return handleAction(checkedIds, actionResn, request, true);
}
/** #11 선택 계정 말소(잠금 상태 계정 대상). 상태를 바꾸므로 POST 한정. */
@RequestMapping(value = "/mnt/sec/dormantStatus/expire.do")
public String dormantAccountExpire(@RequestParam(value = "checkedIds", required = false) String[] checkedIds,
@RequestParam(value = "actionResn", required = false) String actionResn,
HttpServletRequest request) throws Exception {
return handleAction(checkedIds, actionResn, request, false);
}
/** 잠금·말소 공통 전처리(인증·요청경로·사유 검증) 후 서비스 호출. */
private String handleAction(String[] checkedIds, String actionResn, HttpServletRequest request, boolean lock)
throws Exception {
LoginVO loginVO = handlerUser();
if (loginVO == null) {
return LOGIN_REDIRECT;
}
if (!"POST".equalsIgnoreCase(request.getMethod())) {
return dormantListRedirect("잘못된 요청 방식입니다.");
}
if (!isSameOrigin(request)) {
return dormantListRedirect("잘못된 요청 경로입니다.");
}
if (checkedIds == null || checkedIds.length == 0) {
return dormantListRedirect("대상 계정을 선택하세요.");
}
String resn = actionResn == null ? "" : actionResn.trim();
if (resn.length() == 0) {
return dormantListRedirect("조치 사유는 필수입니다.");
}
String ip = ClientIpResolver.getClientIp(request);
int done = lock
? dormantAccountStatusService.lockAccounts(checkedIds, resn, loginVO.getId(), ip)
: dormantAccountStatusService.expireAccounts(checkedIds, resn, loginVO.getId(), ip);
int skipped = checkedIds.length - done;
String label = lock ? "잠금" : "말소";
StringBuilder msg = new StringBuilder();
msg.append(done).append("건 ").append(label).append(" 처리했습니다.");
if (skipped > 0) {
// 본인 계정·이미 처리된 계정·(말소의 경우) 잠기지 않은 계정은 서버가 걸러낸다.
msg.append(" ").append(skipped).append("건은 조치 대상이 아니어서 제외했습니다");
msg.append(lock ? "(본인 계정·이미 잠긴 계정)." : "(본인 계정·잠금되지 않은 계정·이미 말소된 계정).");
}
return dormantListRedirect(msg.toString());
}
/** 처리결과 메시지를 붙여 현황 목록으로 리다이렉트. */
private String dormantListRedirect(String message) throws Exception {
if (message == null) {
return DORMANT_LIST_REDIRECT;
}
return DORMANT_LIST_REDIRECT + "&resultMsg=" + URLEncoder.encode(message, "UTF-8");
}
}

41
src/main/java/egovframework/com/cmm/privacy/account/AccountMngDAO.java
View File

@ -46,45 +46,4 @@ public class AccountMngDAO extends EgovComAbstractDAO {
param.put("alertBefore", Integer.valueOf(alertBefore));
return list("AccountMngDAO.selectDormantAlertTargets", param);
}
/** #11 현황 화면 상단 요약(전체·휴면예정·휴면잠금·말소 건수). 검색조건 무관 전체 집계. */
public DormantAccountSummaryVO selectDormantSummary() {
return (DormantAccountSummaryVO) selectByPk("AccountMngDAO.selectDormantSummary", null);
}
/** 단건 파생 계정상태(N/W/L/D). 없는 계정이면 null. */
public String selectDormantAccountState(String accountId) {
return (String) selectByPk("AccountMngDAO.selectDormantAccountState", accountId);
}
/** 단건 미접속 일수. 없는 계정이면 0. */
public int selectDormantAccountDays(String accountId) {
Object days = selectByPk("AccountMngDAO.selectDormantAccountDays", accountId);
return days == null ? 0 : ((Integer) days).intValue();
}
/** 휴면행 상태(DIAPAUSE_STAT). 행이 없으면 null, 값이 비어있으면 빈 문자열. */
public String selectDiapauseStatEmp(String accountId) {
return (String) selectByPk("AccountMngDAO.selectDiapauseStatEmp", accountId);
}
/** #11-2 잠금(휴면 확정) — 기존 휴면행 승격. */
public int updateDiapauseConfirmEmp(String accountId) {
return update("AccountMngDAO.updateDiapauseConfirmEmp", accountId);
}
/** #11-2 잠금(휴면 확정) — 휴면행이 없는 계정의 신규 적재. */
public void insertDiapauseConfirmEmp(String accountId) {
insert("AccountMngDAO.insertDiapauseConfirmEmp", accountId);
}
/** #11-2 말소 — EMPLYR_STTUS_CODE='D'. 이미 말소면 0건. */
public int updateEmplyrExpire(String accountId) {
return update("AccountMngDAO.updateEmplyrExpire", accountId);
}
/** #11-2 조치 이력 적재. */
public void insertAccountActionHistory(AccountActionHistoryVO vo) {
insert("AccountMngDAO.insertAccountActionHistory", vo);
}
}

4
src/main/java/egovframework/com/cmm/privacy/account/AccountMngPolicyVO.java
View File

@ -30,12 +30,12 @@ public class AccountMngPolicyVO implements Serializable {
private int alertD2 = 7;
/** 사전알림 3차(D-Day, 기본 0). */
private int alertD3 = 0;
/** 휴면 후 삭제 보존기간(일) — 개인정보취급자(관리자, EMP) 계정 한정. 일반회원은 탈퇴 즉시 삭제되어 대상이 아니다. */
/** 휴면/탈퇴 후 삭제 보존기간(일). */
private int deletePreserveDay = 365;
/** 배치 주기(DAILY/WEEKLY/MONTHLY). */
private String batchCycle = "DAILY";
/**
* 장기 미사용 관리자(개인정보취급자) 계정 파기 배치 사용여부(#12). Y:사용 N:미사용.
* 장기 미사용 계정 파기 배치 사용여부(#12). Y:사용 N:미사용.
* 기본 'N' — 관리자가 정책 화면에서 명시적으로 켜야 파기가 수행된다(되돌릴 수 없는 처리).
*/
private String purgeUseYn = "N";

22
src/main/java/egovframework/com/cmm/privacy/account/DormantAccountStatusService.java
View File

@ -12,26 +12,4 @@ public interface DormantAccountStatusService {
/** 현황 전체 건수. */
int selectDormantStatusTotCnt(DormantAccountStatusVO searchVO) throws Exception;
/** 화면 상단 요약(전체·휴면예정·휴면잠금·말소 건수 + 정책 기준일수). */
DormantAccountSummaryVO selectDormantSummary() throws Exception;
/**
* 선택 계정 잠금(휴면 확정). 자동 배치가 하는 확정을 관리자가 앞당겨 수행한다.
*
* @param accountIds 대상 계정ID 배열
* @param resn 조치 사유(필수, 이력 적재)
* @param actorId 조치자(관리자) ID — 본인 계정은 대상에서 제외한다
* @param actorIp 조치자 IP
* @return 실제 처리 건수
*/
int lockAccounts(String[] accountIds, String resn, String actorId, String actorIp) throws Exception;
/**
* 선택 계정 말소. 잠금(휴면·잠금) 상태인 계정만 대상으로 한다
* ("잠금 후에도 미사용 시 관리자 승인으로 말소" 정책).
*
* @return 실제 처리 건수
*/
int expireAccounts(String[] accountIds, String resn, String actorId, String actorIp) throws Exception;
}

121
src/main/java/egovframework/com/cmm/privacy/account/DormantAccountStatusServiceImpl.java
View File

@ -7,31 +7,14 @@ import javax.annotation.Resource;
import org.springframework.stereotype.Service;
/**
* 장기 미사용 계정 현황 조회·조치 서비스 구현 (#11).
*
* <p>조회(목록·요약)와 현황 화면의 조치(잠금=휴면 확정 / 말소)를 담당한다.
* 메서드 전체가 context-transaction.xml 의 {@code egovframework.com..*Impl.*} 포인트컷에
* 걸려 트랜잭션 경계 안에서 실행되므로, 다건 조치 중 예외가 나면 그 요청 전체가 롤백된다.</p>
*
* <pre>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.07.21 URP 최초 생성 (#11 현황 조회)
* 2026.08.10 URP 시안 반영 — 요약 집계 + 잠금·말소 조치(이력 적재)
* </pre>
* 장기 미사용 계정 현황 조회 서비스 구현 (#11).
*/
@Service("dormantAccountStatusService")
public class DormantAccountStatusServiceImpl implements DormantAccountStatusService {
/** 조치 사유 최대 길이 — ACCOUNT_ACTION_HISTORY.ACTION_RESN VARCHAR(500). */
private static final int MAX_RESN_LEN = 500;
@Resource(name = "accountMngDAO")
private AccountMngDAO accountMngDAO;
@Resource(name = "accountMngPolicyService")
private AccountMngPolicyService accountMngPolicyService;
@Override
public List<DormantAccountStatusVO> selectDormantStatusList(DormantAccountStatusVO searchVO) throws Exception {
int pageIndex = searchVO.getPageIndex() < 1 ? 1 : searchVO.getPageIndex();
@ -47,106 +30,4 @@ public class DormantAccountStatusServiceImpl implements DormantAccountStatusServ
public int selectDormantStatusTotCnt(DormantAccountStatusVO searchVO) throws Exception {
return accountMngDAO.selectDormantStatusListCount(searchVO);
}
@Override
public DormantAccountSummaryVO selectDormantSummary() throws Exception {
DormantAccountSummaryVO summary = accountMngDAO.selectDormantSummary();
if (summary == null) {
summary = new DormantAccountSummaryVO();
}
// 카드 라벨(60일↑/90일↑)에 쓰이는 기준일수는 정책값에서 가져온다(하드코딩 없음, #9/#13).
AccountMngPolicyVO policy = accountMngPolicyService.selectPolicy();
int dormantDay = policy == null ? AccountMngPolicyVO.DEFAULT_DORMANT_DAY : policy.getDormantDay();
int alertD1 = policy == null ? 0 : policy.getAlertD1();
summary.setDormantDay(dormantDay);
// 사전알림 1차 시점부터 '휴면예정'으로 본다. 정책이 뒤집혀도 음수가 되지 않게 하한 0.
summary.setWarnDay(Math.max(dormantDay - alertD1, 0));
summary.setBatchCycle(policy == null ? null : policy.getBatchCycle());
summary.setPurgeUseYn(policy == null ? null : policy.getPurgeUseYn());
return summary;
}
@Override
public int lockAccounts(String[] accountIds, String resn, String actorId, String actorIp) throws Exception {
return processAction(accountIds, resn, actorId, actorIp, AccountActionHistoryVO.ACTION_LOCK);
}
@Override
public int expireAccounts(String[] accountIds, String resn, String actorId, String actorIp) throws Exception {
return processAction(accountIds, resn, actorId, actorIp, AccountActionHistoryVO.ACTION_EXPIRE);
}
/**
* 잠금·말소 공통 처리. 대상 계정별로 상태를 다시 읽어 조치 가능 여부를 서버에서 판정한다
* (화면 목록이 오래됐거나 요청이 위조된 경우를 걸러낸다).
*/
private int processAction(String[] accountIds, String resn, String actorId, String actorIp, String actionTy)
throws Exception {
if (accountIds == null || accountIds.length == 0) {
return 0;
}
String reason = resn == null ? "" : resn.trim();
if (reason.length() > MAX_RESN_LEN) {
reason = reason.substring(0, MAX_RESN_LEN);
}
int done = 0;
for (int i = 0; i < accountIds.length; i++) {
String accountId = accountIds[i] == null ? "" : accountIds[i].trim();
if (accountId.length() == 0) {
continue;
}
// 자기 계정은 조치할 수 없다(관리자 자신을 잠가 운영이 막히는 사고 방지).
if (accountId.equals(actorId)) {
continue;
}
String state = accountMngDAO.selectDormantAccountState(accountId);
if (state == null || "D".equals(state)) {
continue; // 없는 계정이거나 이미 말소됨
}
boolean changed;
if (AccountActionHistoryVO.ACTION_LOCK.equals(actionTy)) {
changed = lockOne(accountId);
} else {
// 말소는 '잠금 후에도 미사용'인 계정만 — 잠기지 않은 계정은 건너뛴다.
if (!"L".equals(state)) {
continue;
}
changed = accountMngDAO.updateEmplyrExpire(accountId) > 0;
}
if (!changed) {
continue;
}
AccountActionHistoryVO hist = new AccountActionHistoryVO();
hist.setTrgetId(accountId);
hist.setTrgetSe("EMP");
hist.setActionTy(actionTy);
hist.setActionUserId(actorId);
hist.setActionResn(reason);
hist.setActionIp(actorIp);
hist.setNoConectDay(accountMngDAO.selectDormantAccountDays(accountId));
accountMngDAO.insertAccountActionHistory(hist);
done++;
}
return done;
}
/**
* 휴면행이 있으면 'P'로 승격, 없으면 신규 적재.
* 이미 확정('P')이면 아무것도 하지 않고 false — 같은 계정을 다시 눌러도 이력이 중복되지 않는다.
*/
private boolean lockOne(String accountId) {
String stat = accountMngDAO.selectDiapauseStatEmp(accountId);
if (stat == null) {
accountMngDAO.insertDiapauseConfirmEmp(accountId);
return true;
}
if ("P".equals(stat.trim())) {
return false;
}
return accountMngDAO.updateDiapauseConfirmEmp(accountId) > 0;
}
}

17
src/main/java/egovframework/com/cmm/privacy/account/DormantAccountStatusVO.java
View File

@ -23,18 +23,9 @@ public class DormantAccountStatusVO implements Serializable {
private String sttusCode; // 상태코드(EMPLYR_STTUS_CODE)
private String dormantExpectDt; // 휴면예정일(yyyy-MM-dd)
private String mberTyCode; // 회원유형(EMP/GNR)
private String roleNm; // 역할명(COMTNAUTHORINFO.AUTHOR_NM, 복수는 쉼표 연결)
/**
* 파생 계정상태 — 정책값 기준으로 SQL이 계산한다.
* N:사용 W:휴면예정(기준일수-1차알림일 경과) L:휴면·잠금(기준일수 경과 또는 휴면확정) D:말소
* EMPLYR_STTUS_CODE(sttusCode) 원본과 달리 '미접속 일수'를 함께 반영한 화면 표시용 상태다.
*/
private String acntState;
// ---- 검색조건(#11) ----
private int minNoConnectDays = 0; // 미접속일수 하한 필터
private String searchKeyword; // 취급자명 또는 계정ID 통합검색
private String searchState; // 계정상태 필터(N/W/L/D) — 파생 acntState 대상
// ---- 페이징 ----
private int pageIndex = 1;
@ -62,16 +53,8 @@ public class DormantAccountStatusVO implements Serializable {
public void setDormantExpectDt(String dormantExpectDt) { this.dormantExpectDt = dormantExpectDt; }
public String getMberTyCode() { return mberTyCode; }
public void setMberTyCode(String mberTyCode) { this.mberTyCode = mberTyCode; }
public String getRoleNm() { return roleNm; }
public void setRoleNm(String roleNm) { this.roleNm = roleNm; }
public String getAcntState() { return acntState; }
public void setAcntState(String acntState) { this.acntState = acntState; }
public int getMinNoConnectDays() { return minNoConnectDays; }
public void setMinNoConnectDays(int minNoConnectDays) { this.minNoConnectDays = minNoConnectDays; }
public String getSearchKeyword() { return searchKeyword; }
public void setSearchKeyword(String searchKeyword) { this.searchKeyword = searchKeyword; }
public String getSearchState() { return searchState; }
public void setSearchState(String searchState) { this.searchState = searchState; }
public int getPageIndex() { return pageIndex; }
public void setPageIndex(int pageIndex) { this.pageIndex = pageIndex; }
public int getRecordCountPerPage() { return recordCountPerPage; }

56
src/main/java/egovframework/com/cmm/privacy/account/DormantAccountSummaryVO.java
View File

@ -1,56 +0,0 @@
package egovframework.com.cmm.privacy.account;
import java.io.Serializable;
/**
* 장기 미사용 계정 현황 요약 VO (#11 화면 상단 요약 카드).
*
* <p>취급자 전체 계정수와 휴면예정·휴면/잠금·말소 건수를 한 번의 조회로 담는다.
* 카드 라벨에 쓰이는 기준일수(dormantDay/warnDay)와 정책 적용상태는
* ACCOUNT_MNG_POLICY 값을 서비스 계층에서 채운다(하드코딩 없음, #9/#13 연계).</p>
*
* <pre>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (#11 시안 반영)
* </pre>
*/
public class DormantAccountSummaryVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 취급자 전체 계정수. */
private int totCnt;
/** 휴면예정 건수(미접속 warnDay 이상). */
private int warnCnt;
/** 휴면·잠금 건수(미접속 dormantDay 이상 또는 휴면확정). */
private int lockCnt;
/** 말소 건수(EMPLYR_STTUS_CODE='D'). */
private int expiredCnt;
/** 휴면 전환(자동 잠금) 기준 미접속 일수 — ACCOUNT_MNG_POLICY.DORMANT_DAY. */
private int dormantDay;
/** 휴면예정 진입 기준 미접속 일수 — DORMANT_DAY - ALERT_D1. */
private int warnDay;
/** 배치 주기(DAILY/WEEKLY/MONTHLY). */
private String batchCycle;
/** 파기 배치 사용여부(Y/N). */
private String purgeUseYn;
public int getTotCnt() { return totCnt; }
public void setTotCnt(int totCnt) { this.totCnt = totCnt; }
public int getWarnCnt() { return warnCnt; }
public void setWarnCnt(int warnCnt) { this.warnCnt = warnCnt; }
public int getLockCnt() { return lockCnt; }
public void setLockCnt(int lockCnt) { this.lockCnt = lockCnt; }
public int getExpiredCnt() { return expiredCnt; }
public void setExpiredCnt(int expiredCnt) { this.expiredCnt = expiredCnt; }
public int getDormantDay() { return dormantDay; }
public void setDormantDay(int dormantDay) { this.dormantDay = dormantDay; }
public int getWarnDay() { return warnDay; }
public void setWarnDay(int warnDay) { this.warnDay = warnDay; }
public String getBatchCycle() { return batchCycle; }
public void setBatchCycle(String batchCycle) { this.batchCycle = batchCycle; }
public String getPurgeUseYn() { return purgeUseYn; }
public void setPurgeUseYn(String purgeUseYn) { this.purgeUseYn = purgeUseYn; }
}

72
src/main/java/egovframework/com/cmm/privacy/account/DormantAlertServiceImpl.java
View File

@ -1,9 +1,7 @@
package egovframework.com.cmm.privacy.account;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
@ -15,19 +13,12 @@ import egovframework.com.cop.ems.service.EgovSndngMailRegistService;
import egovframework.com.cop.ems.service.SndngMailVO;
/**
* 휴면 전 사전 알림 서비스 구현 (#10, D-30/D-7/D-Day 관리자 알림).
* 휴면 전 사전 알림 서비스 구현 (#10, D-30/D-7/D-Day + 관리자 알림).
*
* <p>정책(ACCOUNT_MNG_POLICY)의 ALERT_D1/D2/D3(기본 30/7/0)일 전 대상을 조회해
* 관리자(ADMIN_EMAIL)에게 배치 1회 실행당 전체 대상을 모은 요약(digest) 메일
* 1통으로 발송한다. 대상자가 많을 때 관리자 메일함이 건별 메일로 도배되는 것을
* 막기 위함(2026-07-28 개선). 발송 실패가 배치 본류를 막지 않도록 전 구간 fail-safe.</p>
*
* <p><b>2026-07-30 본인 발송 제거</b>: 발주 요구사항(Ⅲ-2.3, 요구사항 #4)은
* '비활성화 전 <b>관리자</b> 알림 D-30/D-7/D-Day'이며 대상자 본인 개별 통지는 요건이
* 아니다. 대상 5만건 규모에서 본인 건별 발송이 배치 처리량을 지배해 일일 상한을
* 200건으로 묶어야 했고(휴면 전환 소진에 수년 소요), 이를 해소하기 위해 본인 발송을
* 걷어냈다. 휴면 확정 체인의 본인 메일 2종도 함께 제거
* (EgovLoginServiceImpl.processDiapauseList 주석 참조).</p>
* 본인과 관리자(ADMIN_EMAIL)에게 사전 알림 메일을 발송한다. 기존 휴면 배치의
* 유예/확정 본인 메일(EgovLoginServiceImpl.processDiapauseList)과 독립적으로 동작하며,
* 발송 실패가 배치 본류를 막지 않도록 전 구간 fail-safe.</p>
*/
@Service("dormantAlertService")
public class DormantAlertServiceImpl implements DormantAlertService {
@ -55,11 +46,6 @@ public class DormantAlertServiceImpl implements DormantAlertService {
String adminEmail = policy.getAdminEmail();
int sent = 0;
int targetCnt = 0;
// 단계별 대상자를 모아두었다가 관리자에게는 배치 종료 후 요약 1통만 발송한다.
Map<Integer, List<DormantAccountStatusVO>> stageTargets =
new LinkedHashMap<Integer, List<DormantAccountStatusVO>>();
for (Integer before : stages) {
List<DormantAccountStatusVO> targets;
@ -69,19 +55,14 @@ public class DormantAlertServiceImpl implements DormantAlertService {
LOG.error("[개인정보/#10] 사전알림 대상 조회 오류(D-{}) — 건너뜀: {}", before, e.getMessage());
continue;
}
if (targets == null || targets.isEmpty()) {
if (targets == null) {
continue;
}
stageTargets.put(before, targets);
targetCnt += targets.size();
for (DormantAccountStatusVO t : targets) {
sent += sendOne(t, before.intValue(), adminEmail);
}
}
if (adminEmail != null && adminEmail.trim().length() > 0 && !stageTargets.isEmpty()) {
sent += sendAdminDigest(stageTargets, adminEmail);
}
LOG.info("[개인정보/#10] 휴면 사전알림 완료 — 대상 {}건, 관리자 요약 {}통 발송",
Integer.valueOf(targetCnt), Integer.valueOf(sent));
LOG.info("[개인정보/#10] 휴면 사전알림 발송 완료 — {}건", Integer.valueOf(sent));
return sent;
}
@ -92,30 +73,21 @@ public class DormantAlertServiceImpl implements DormantAlertService {
}
}
/** 관리자 요약 발송(fail-safe). 배치 1회 실행당 단계 무관 1통. 발송 성공 시 1, 실패 시 0. */
private int sendAdminDigest(Map<Integer, List<DormantAccountStatusVO>> stageTargets, String adminEmail) {
int totalCount = 0;
for (List<DormantAccountStatusVO> targets : stageTargets.values()) {
totalCount += targets.size();
}
/** 본인 + 관리자 발송(각각 fail-safe). 발송 성공 건수 반환. */
private int sendOne(DormantAccountStatusVO t, int before, String adminEmail) {
int cnt = 0;
String dLabel = before == 0 ? "D-Day" : ("D-" + before);
String subject = "[문화품앗이] 장기 미접속 계정 휴면 전환 사전 안내 (" + dLabel + ")";
String body = (t.getUserNm() == null ? "" : t.getUserNm()) + "(" + t.getAccountId()
+ ") 계정이 미접속 " + t.getNoConnectDays() + "일로 곧 휴면 전환됩니다. 로그인 시 유지됩니다.";
StringBuilder body = new StringBuilder();
body.append("휴면 전환 사전 알림 대상 총 ").append(totalCount).append("건\n\n");
for (Map.Entry<Integer, List<DormantAccountStatusVO>> entry : stageTargets.entrySet()) {
int before = entry.getKey().intValue();
String dLabel = before == 0 ? "D-Day" : ("D-" + before);
List<DormantAccountStatusVO> targets = entry.getValue();
body.append("[").append(dLabel).append("] ").append(targets.size()).append("건\n");
for (DormantAccountStatusVO t : targets) {
body.append(" - ").append(t.getUserNm() == null ? "" : t.getUserNm())
.append("(").append(t.getAccountId()).append(") 미접속 ")
.append(t.getNoConnectDays()).append("일\n");
}
body.append("\n");
// 본인 발송(대상 이메일이 조회 VO에 없으면 관리자에게만 — 취급자 메일 컬럼 미보유 방어)
cnt += sendMail(t.getAccountId(), subject, body);
// 관리자 발송(#10 핵심 — 관리자 알림 추가)
if (adminEmail != null && adminEmail.trim().length() > 0) {
cnt += sendMail(adminEmail, subject + " - 관리자통지", body);
}
String subject = "[문화품앗이] 휴면 전환 사전 알림 요약 (총 " + totalCount + "건)";
return sendMail(adminEmail, subject, body.toString());
return cnt;
}
private int sendMail(String recipient, String subject, String body) {

84
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadJobDAO.java
View File

@ -1,84 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 접속기록 CSV 비동기 다운로드 작업(PDAL_DOWNLOAD_JOB) DAO.
*
* <p>개인정보보호 기능개선 사업(SFR-004-6 / SER-002). statement 는
* {@code PrivacyDownloadJob_SQL_Mysql.xml}(namespace {@code AccessLogDownloadJobDAO}).
* 신규 sqlMap 이므로 {@code sql-map-config-mysql-0-site.xml} 등록이 필요하다.</p>
*
* @since 2026-08-07
*/
@Repository("accessLogDownloadJobDAO")
public class AccessLogDownloadJobDAO extends EgovComAbstractDAO {
/** 요청 등록. 채번된 JOB_ID 는 selectKey 로 vo.jobId 에 채워진다. */
public long insertJob(AccessLogDownloadJobVO vo) {
insert("AccessLogDownloadJobDAO.insertJob", vo);
return vo.getJobId();
}
public AccessLogDownloadJobVO selectJob(long jobId) {
return (AccessLogDownloadJobVO) selectByPk("AccessLogDownloadJobDAO.selectJob", Long.valueOf(jobId));
}
/** 요청자 본인의 최근 작업 목록. */
@SuppressWarnings("unchecked")
public List<AccessLogDownloadJobVO> selectJobListByRequester(String requesterId, int limitCnt) {
Map<String, Object> param = new HashMap<String, Object>();
param.put("requesterId", requesterId);
param.put("limitCnt", Integer.valueOf(limitCnt));
return list("AccessLogDownloadJobDAO.selectJobListByRequester", param);
}
/** 대기 상태의 가장 오래된 작업 ID. 없으면 null. */
public Long selectNextWaitingJobId() {
return (Long) selectByPk("AccessLogDownloadJobDAO.selectNextWaitingJobId", null);
}
/**
* 대기건 선점. 영향행수 1이면 이 워커가 소유권을 얻은 것이다.
* (WHERE 에 STATUS='W' 가 걸려 있어 동시 선점 시 한쪽만 성공한다.)
*/
public boolean claimJob(long jobId) {
return update("AccessLogDownloadJobDAO.claimJob", Long.valueOf(jobId)) == 1;
}
public void updateProgress(AccessLogDownloadJobVO vo) {
update("AccessLogDownloadJobDAO.updateProgress", vo);
}
public void updateSuccess(AccessLogDownloadJobVO vo) {
update("AccessLogDownloadJobDAO.updateSuccess", vo);
}
public void updateFail(AccessLogDownloadJobVO vo) {
update("AccessLogDownloadJobDAO.updateFail", vo);
}
public void updateDownloaded(long jobId) {
update("AccessLogDownloadJobDAO.updateDownloaded", Long.valueOf(jobId));
}
@SuppressWarnings("unchecked")
public List<AccessLogDownloadJobVO> selectExpiredJobs() {
return list("AccessLogDownloadJobDAO.selectExpiredJobs", null);
}
public void updatePurged(long jobId) {
update("AccessLogDownloadJobDAO.updatePurged", Long.valueOf(jobId));
}
/** WAS 비정상 종료로 'R' 에 멈춘 작업을 대기로 되돌린다(기동 시 1회). */
public int resetRunningJobs() {
return update("AccessLogDownloadJobDAO.resetRunningJobs", null);
}
}

40
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadJobService.java
View File

@ -1,40 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.util.List;
/**
* 접속기록 CSV 비동기 다운로드 작업 서비스 (SFR-004-6 / SER-002).
*
* <p>다운로드를 '요청 → 백그라운드 생성 → 완료 후 내려받기'로 나눈다. 대용량 조건에서
* 전체를 메모리에 올린 뒤 응답에 싣던 방식의 메모리 압박·요청 타임아웃을 없애기 위함이다.</p>
*
* @since 2026-08-07
*/
public interface AccessLogDownloadJobService {
/**
* 다운로드 작업을 등록한다(즉시 반환). 사유는 필수다.
*
* @return 등록된 작업 ID
* @throws IllegalArgumentException 사유 미입력
*/
long requestJob(String requesterId, String requesterIp, String reason,
PersonalDataAccessLogSearchVO searchVO) throws Exception;
/** 요청자 본인의 최근 작업 목록(화면 표시·폴링용). */
List<AccessLogDownloadJobVO> selectMyJobs(String requesterId, int limitCnt) throws Exception;
/**
* 내려받기용 작업 조회 — <b>요청자 본인인지 재검증한다</b>.
* 작업ID를 바꿔치기해 남의 다운로드 파일을 가져가는 것을 막는다.
*
* @return 본인의 내려받기 가능한 작업. 아니면 null
*/
AccessLogDownloadJobVO selectDownloadableJob(long jobId, String requesterId) throws Exception;
/** 내려받기 성공 시 횟수·일시를 기록한다(다운로드 이력은 별도 적재). */
void markDownloaded(long jobId) throws Exception;
/** 만료된 작업 파일을 삭제하고 상태를 파기(X)로 정리한다. 파기 건수 반환. */
int purgeExpiredJobs() throws Exception;
}

170
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadJobServiceImpl.java
View File

@ -1,170 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.io.File;
import java.util.List;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* 접속기록 CSV 비동기 다운로드 작업 서비스 구현 (SFR-004-6 / SER-002).
*
* <p><b>보관 최소화:</b> 생성된 파일은 대량 개인정보 파일이라 오래 두지 않는다.
* {@link #expireDays}(기본 3일) 경과분은 파기 배치가 파일을 지우고 상태를 X 로 바꾼다.</p>
*
* <p><b>권한 재검증:</b> 내려받기는 <u>요청자 본인만</u> 가능하다. 작업ID는 연속 정수라
* 추측이 쉬우므로, 조회 단계에서 요청자ID 일치를 확인하지 않으면 남의 파일이 새어나간다.</p>
*
* @since 2026-08-07
*/
@Service("accessLogDownloadJobService")
public class AccessLogDownloadJobServiceImpl implements AccessLogDownloadJobService {
private static final Log LOG = LogFactory.getLog(AccessLogDownloadJobServiceImpl.class);
@Resource(name = "accessLogDownloadJobDAO")
private AccessLogDownloadJobDAO jobDAO;
/**
* 생성 파일 보관일수. 대량 개인정보 파일이므로 짧게 잡는다(기본 3일).
* 접속기록 본체의 보관기간(730일)과는 무관한, '내려받기용 사본'의 수명이다.
*/
@Value("${Globals.privacyDownloadExpireDays:3}")
private int expireDays = 3;
@Override
public long requestJob(String requesterId, String requesterIp, String reason,
PersonalDataAccessLogSearchVO searchVO) throws Exception {
// 사유 필수 — 종전 동기 다운로드와 동일한 차단 기준을 유지한다.
if (reason == null || reason.trim().length() == 0) {
throw new IllegalArgumentException("다운로드 사유는 필수입니다.");
}
if (requesterId == null || requesterId.trim().length() == 0) {
throw new IllegalArgumentException("요청자를 확인할 수 없습니다.");
}
if (searchVO == null) {
searchVO = new PersonalDataAccessLogSearchVO();
}
AccessLogDownloadJobVO job = new AccessLogDownloadJobVO();
job.setRequesterId(requesterId);
job.setRequesterIp(requesterIp);
job.setDlReason(cut(reason.trim(), 500));
job.setSearchCond(cut(summarizeCond(searchVO), 1000));
job.setCondConectId(searchVO.getConectId());
job.setCondJobSeCode(searchVO.getJobSeCode());
job.setCondTrgetId(searchVO.getTrgetId());
job.setCondConectIp(searchVO.getConectIp());
job.setCondDmlGubun(searchVO.getDmlGubun());
job.setCondProcessResult(searchVO.getProcessResult());
job.setCondFromDt(searchVO.getFromDt());
job.setCondToDt(searchVO.getToDt());
job.setExpireDays(expireDays < 1 ? 3 : expireDays);
long jobId = jobDAO.insertJob(job);
LOG.info("[개인정보/SFR-004-6] 다운로드 작업 등록 — jobId=" + jobId + ", 요청자=" + requesterId
+ ", 조건=" + job.getSearchCond());
return jobId;
}
@Override
public List<AccessLogDownloadJobVO> selectMyJobs(String requesterId, int limitCnt) throws Exception {
if (requesterId == null || requesterId.trim().length() == 0) {
return java.util.Collections.emptyList();
}
return jobDAO.selectJobListByRequester(requesterId, limitCnt < 1 ? 10 : limitCnt);
}
@Override
public AccessLogDownloadJobVO selectDownloadableJob(long jobId, String requesterId) throws Exception {
AccessLogDownloadJobVO job = jobDAO.selectJob(jobId);
if (job == null) {
return null;
}
// 본인 확인 — 작업ID 추측으로 남의 파일을 가져가는 것을 막는다.
if (requesterId == null || !requesterId.equals(job.getRequesterId())) {
LOG.warn("[개인정보/SFR-004-6] 타인 다운로드 시도 차단 — jobId=" + jobId
+ ", 소유자=" + job.getRequesterId() + ", 요청자=" + requesterId);
return null;
}
if (!job.isDownloadable()) {
return null;
}
File f = new File(job.getFilePath());
if (!f.exists() || !f.isFile()) {
LOG.warn("[개인정보/SFR-004-6] 파일 없음(파기됐거나 유실) — jobId=" + jobId);
return null;
}
return job;
}
@Override
public void markDownloaded(long jobId) throws Exception {
jobDAO.updateDownloaded(jobId);
}
@Override
public int purgeExpiredJobs() throws Exception {
List<AccessLogDownloadJobVO> expired = jobDAO.selectExpiredJobs();
int purged = 0;
if (expired != null) {
for (int i = 0; i < expired.size(); i++) {
AccessLogDownloadJobVO job = expired.get(i);
String path = job.getFilePath();
if (path != null && path.length() > 0) {
try {
File f = new File(path);
if (f.exists() && !f.delete()) {
// 삭제 실패는 개인정보 파일이 남는다는 뜻이라 조용히 넘기지 않는다.
LOG.error("[개인정보/SFR-004-6] 다운로드 파일 삭제 실패 — jobId=" + job.getJobId()
+ ", path=" + path + " (수동 삭제 필요)");
continue;
}
} catch (Exception e) {
LOG.error("[개인정보/SFR-004-6] 다운로드 파일 삭제 중 예외 — jobId=" + job.getJobId(), e);
continue;
}
}
jobDAO.updatePurged(job.getJobId());
purged++;
}
}
LOG.info("[개인정보/SFR-004-6] 만료 다운로드 파일 파기 완료 — " + purged + "건(보관 " + expireDays + "일)");
return purged;
}
/** 검색조건을 개인정보 본문 없이 요약. */
private String summarizeCond(PersonalDataAccessLogSearchVO vo) {
StringBuilder sb = new StringBuilder();
appendCond(sb, "conectId", vo.getConectId());
appendCond(sb, "jobSeCode", vo.getJobSeCode());
appendCond(sb, "trgetId", vo.getTrgetId());
appendCond(sb, "conectIp", vo.getConectIp());
appendCond(sb, "dmlGubun", vo.getDmlGubun());
appendCond(sb, "processResult", vo.getProcessResult());
appendCond(sb, "fromDt", vo.getFromDt());
appendCond(sb, "toDt", vo.getToDt());
return sb.length() == 0 ? "(전체)" : sb.toString();
}
private void appendCond(StringBuilder sb, String key, String val) {
if (val != null && val.trim().length() > 0) {
if (sb.length() > 0) {
sb.append(", ");
}
sb.append(key).append("=").append(val.trim());
}
}
private static String cut(String s, int max) {
if (s == null) {
return null;
}
return (s.length() > max) ? s.substring(0, max) : s;
}
}

161
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadJobVO.java
View File

@ -1,161 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.io.Serializable;
/**
* 개인정보 접속기록 CSV 비동기 다운로드 작업(PDAL_DOWNLOAD_JOB) VO.
*
* <p>개인정보보호 기능개선 사업(SFR-004-6 / SER-002) — 대용량 다운로드를 요청 즉시 응답하고
* 백그라운드에서 파일을 만들기 위한 작업 한 건.</p>
*
* <p><b>검색조건을 컬럼으로 보존하는 이유:</b> 백그라운드 워커는 요청 세션이 끝난 뒤 실행되므로
* 조건을 스스로 재현해야 한다. 담는 값은 식별자·코드·기간뿐이라 접속기록 본문 미적재 원칙에
* 어긋나지 않는다.</p>
*
* @since 2026-08-07
*/
public class AccessLogDownloadJobVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 상태: 대기 */
public static final String ST_WAIT = "W";
/** 상태: 생성중 */
public static final String ST_RUNNING = "R";
/** 상태: 완료(내려받기 가능) */
public static final String ST_SUCCESS = "S";
/** 상태: 실패 */
public static final String ST_FAIL = "F";
/** 상태: 파기(파일 삭제됨) */
public static final String ST_PURGED = "X";
private long jobId;
private String requesterId;
private String requesterIp;
private String dlReason;
private String searchCond;
// 조건 재현용 — 프로퍼티명을 cond* 로 둔다.
// getFConectId 처럼 '소문자1자+대문자' 형태면 JavaBeans 인트로스펙션이 프로퍼티를
// 'FConectId' 로 해석해 iBatis 바인딩(#fConectId#)이 조용히 실패한다.
private String condConectId;
private String condJobSeCode;
private String condTrgetId;
private String condConectIp;
private String condDmlGubun;
private String condProcessResult;
private String condFromDt;
private String condToDt;
private String status;
private int totalCnt;
private int doneCnt;
private String fileNm;
private String filePath;
private long fileSize;
private String errMsg;
private int downloadCnt;
private String lastDlDt;
private String regDt;
private String startDt;
private String endDt;
private String expireDt;
/** 만료일(일). 서비스가 EXPIRE_DT 계산에 쓰는 값을 화면에 알리기 위한 비영속 필드. */
private int expireDays;
public long getJobId() { return jobId; }
public void setJobId(long jobId) { this.jobId = jobId; }
public String getRequesterId() { return requesterId; }
public void setRequesterId(String requesterId) { this.requesterId = requesterId; }
public String getRequesterIp() { return requesterIp; }
public void setRequesterIp(String requesterIp) { this.requesterIp = requesterIp; }
public String getDlReason() { return dlReason; }
public void setDlReason(String dlReason) { this.dlReason = dlReason; }
public String getSearchCond() { return searchCond; }
public void setSearchCond(String searchCond) { this.searchCond = searchCond; }
public String getCondConectId() { return condConectId; }
public void setCondConectId(String condConectId) { this.condConectId = condConectId; }
public String getCondJobSeCode() { return condJobSeCode; }
public void setCondJobSeCode(String condJobSeCode) { this.condJobSeCode = condJobSeCode; }
public String getCondTrgetId() { return condTrgetId; }
public void setCondTrgetId(String condTrgetId) { this.condTrgetId = condTrgetId; }
public String getCondConectIp() { return condConectIp; }
public void setCondConectIp(String condConectIp) { this.condConectIp = condConectIp; }
public String getCondDmlGubun() { return condDmlGubun; }
public void setCondDmlGubun(String condDmlGubun) { this.condDmlGubun = condDmlGubun; }
public String getCondProcessResult() { return condProcessResult; }
public void setCondProcessResult(String condProcessResult) { this.condProcessResult = condProcessResult; }
public String getCondFromDt() { return condFromDt; }
public void setCondFromDt(String condFromDt) { this.condFromDt = condFromDt; }
public String getCondToDt() { return condToDt; }
public void setCondToDt(String condToDt) { this.condToDt = condToDt; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public int getTotalCnt() { return totalCnt; }
public void setTotalCnt(int totalCnt) { this.totalCnt = totalCnt; }
public int getDoneCnt() { return doneCnt; }
public void setDoneCnt(int doneCnt) { this.doneCnt = doneCnt; }
public String getFileNm() { return fileNm; }
public void setFileNm(String fileNm) { this.fileNm = fileNm; }
public String getFilePath() { return filePath; }
public void setFilePath(String filePath) { this.filePath = filePath; }
public long getFileSize() { return fileSize; }
public void setFileSize(long fileSize) { this.fileSize = fileSize; }
public String getErrMsg() { return errMsg; }
public void setErrMsg(String errMsg) { this.errMsg = errMsg; }
public int getDownloadCnt() { return downloadCnt; }
public void setDownloadCnt(int downloadCnt) { this.downloadCnt = downloadCnt; }
public String getLastDlDt() { return lastDlDt; }
public void setLastDlDt(String lastDlDt) { this.lastDlDt = lastDlDt; }
public String getRegDt() { return regDt; }
public void setRegDt(String regDt) { this.regDt = regDt; }
public String getStartDt() { return startDt; }
public void setStartDt(String startDt) { this.startDt = startDt; }
public String getEndDt() { return endDt; }
public void setEndDt(String endDt) { this.endDt = endDt; }
public String getExpireDt() { return expireDt; }
public void setExpireDt(String expireDt) { this.expireDt = expireDt; }
public int getExpireDays() { return expireDays; }
public void setExpireDays(int expireDays) { this.expireDays = expireDays; }
/** 진행률(%). 총건수 미확정이면 0. */
public int getProgressPct() {
if (totalCnt <= 0) {
return ST_SUCCESS.equals(status) ? 100 : 0;
}
long pct = (long) doneCnt * 100L / totalCnt;
return (pct > 100L) ? 100 : (int) pct;
}
/** 내려받기 가능 여부(완료 + 파일 보유). */
public boolean isDownloadable() {
return ST_SUCCESS.equals(status) && filePath != null && filePath.length() > 0;
}
}

357
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadJobWorker.java
View File

@ -1,357 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import egovframework.com.utl.sim.service.EgovFileScrty;
/**
* 접속기록 CSV 비동기 다운로드 워커 (SFR-004-6 / SER-002).
*
* <p>대기(W) 작업을 하나씩 집어 CSV 파일을 만든다. <b>단일 워커 스레드</b>다 —
* 대량 조회가 동시에 여러 건 돌면 DB 부하가 그대로 서비스 지연이 되기 때문이다.</p>
*
* <p><b>메모리를 쓰지 않는 방식:</b> 전체를 List 로 올리지 않고 {@link #CHUNK_ROWS}건씩
* 끊어 조회하며 곧바로 파일에 쓴다. 100만 건이어도 상주 메모리는 한 청크뿐이다.
* 이것이 이 작업의 핵심이며, 종전 동기 다운로드의 OOM 위험을 없앤다.</p>
*
* <p><b>파일은 암호화해 둔다:</b> 생성 결과는 '대량 개인정보 파일'이다. 평문 CSV 를 디스크에
* 남기지 않기 위해 {@link EgovFileScrty#encryptFile}로 암호화한 뒤 평문 임시파일을 지운다.
* 내려받을 때 복호화해 스트리밍한다. 저장 위치는 반드시 <b>웹 루트 밖</b>이어야 한다 —
* webapps 하위에 두면 URL 직접 접근으로 무인증 유출이 된다.</p>
*
* <p><b>기동 시 고아 복구:</b> 파일 생성 중 WAS 가 죽으면 작업이 R 로 굳는다. 기동 시
* R → W 로 되돌려 재시도한다(화면에 '생성중'이 영원히 멈춰 보이는 것 방지).</p>
*
* @since 2026-08-07
*/
@Component("accessLogDownloadJobWorker")
public class AccessLogDownloadJobWorker {
private static final Log LOG = LogFactory.getLog(AccessLogDownloadJobWorker.class);
/** 한 번에 조회·기록할 행 수. 메모리 상주량을 결정한다. */
private static final int CHUNK_ROWS = 2000;
/** 대기 작업이 없을 때 다음 확인까지 쉬는 시간(ms). */
private static final long IDLE_SLEEP_MS = 3000L;
/** 예외 발생 후 폭주 방지 대기(ms). */
private static final long ERROR_SLEEP_MS = 10000L;
private static final String CSV_HEADER =
"로그번호,접속일시,접속자ID,처리자구분,접속IP,수행업무코드,수행업무명,처리구분,처리대상ID,처리대상범위,처리결과,무결성해시";
@Resource(name = "accessLogDownloadJobDAO")
private AccessLogDownloadJobDAO jobDAO;
@Resource(name = "personalDataAccessLogSearchService")
private PersonalDataAccessLogSearchService searchService;
/**
* 생성 파일 저장 디렉터리. <b>반드시 웹 루트(webapps) 밖</b>이어야 한다.
* 미설정 시 기동 로그에 경고를 남기고 워커를 띄우지 않는다 — 임의 경로에
* 개인정보 파일을 만드는 것보다 기능을 멈추는 편이 안전하다.
*/
@Value("${Globals.privacyDownloadPath:}")
private String downloadPath;
private volatile boolean running = false;
private volatile Thread worker;
@PostConstruct
public void start() {
// 저장경로가 없거나 만들 수 없어도 워커는 띄운다.
// 종전에는 여기서 return 해 워커를 아예 기동하지 않았고, 그 결과 요청은 W 로 정상 등록되지만
// 집어갈 주체가 없어 화면이 '대기'에서 영원히 멈췄다(사용자에겐 아무 단서도 보이지 않았다).
// 게다가 화면 폴링이 그 상태를 5초마다 새로고침하며 접속기록을 자가증식시켰다.
// 지금은 작업마다 경로를 확인해 확보 불가면 그 작업을 '실패'로 확정한다 —
// 사유가 화면에 뜨고, 경로가 나중에 생기면 재기동 없이 다음 작업부터 정상 처리된다.
try {
ensureDir();
LOG.info("[개인정보/SFR-004-6] 저장경로 확인 완료 — " + downloadPath);
} catch (Exception e) {
LOG.error("[개인정보/SFR-004-6] 저장경로를 확보하지 못했다 — " + e.getMessage()
+ " 워커는 기동하되, 경로가 확보될 때까지 접수된 작업은 '실패'로 처리한다. "
+ "웹 루트 밖 경로를 지정·생성할 것(예: /app/egovframework/privacy-download/).");
}
try {
int reset = jobDAO.resetRunningJobs();
if (reset > 0) {
LOG.warn("[개인정보/SFR-004-6] 이전 기동에서 생성 중이던 작업 " + reset + "건을 대기로 되돌려 재시도한다.");
}
} catch (Exception e) {
LOG.error("[개인정보/SFR-004-6] 고아 작업 복구 실패(계속 진행)", e);
}
running = true;
Thread t = new Thread(new Runnable() {
public void run() {
loop();
}
}, "pdal-download-worker");
t.setDaemon(true);
worker = t;
t.start();
LOG.info("[개인정보/SFR-004-6] 비동기 다운로드 워커 기동 — 저장경로=" + downloadPath
+ ", 청크=" + CHUNK_ROWS + "행");
}
@PreDestroy
public void stop() {
running = false;
Thread t = worker;
if (t != null) {
t.interrupt();
}
}
/** 워커 루프 — 대기건을 하나씩 선점해 처리한다. Throwable 까지 흡수해 스스로 죽지 않는다. */
private void loop() {
while (running) {
try {
Long jobId = jobDAO.selectNextWaitingJobId();
if (jobId == null) {
Thread.sleep(IDLE_SLEEP_MS);
continue;
}
if (!jobDAO.claimJob(jobId.longValue())) {
// 다른 워커/재시도와 경합해 선점 실패 — 즉시 다음 것을 본다.
continue;
}
process(jobId.longValue());
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
break;
} catch (Throwable t) {
LOG.error("[개인정보/SFR-004-6] 워커 루프 예외(계속)", t);
try {
Thread.sleep(ERROR_SLEEP_MS);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
break;
}
}
}
LOG.info("[개인정보/SFR-004-6] 비동기 다운로드 워커 종료.");
}
/** 작업 1건 처리 — 청크 조회 → CSV 기록 → 암호화 → 완료 확정. */
private void process(long jobId) {
AccessLogDownloadJobVO job = null;
File plain = null;
File enc = null;
try {
job = jobDAO.selectJob(jobId);
if (job == null) {
return;
}
PersonalDataAccessLogSearchVO searchVO = toSearchVO(job);
int total = searchService.selectAccessLogListTotCnt(searchVO);
job.setTotalCnt(total);
job.setDoneCnt(0);
jobDAO.updateProgress(job);
// 작업마다 저장경로를 확인한다 — 기동 후 경로가 생겼다면 재기동 없이 여기서 살아난다.
// 확보 불가면 예외가 나 아래 catch 에서 이 작업이 '실패'로 확정된다(무한 대기 방지).
File dir = ensureDir();
String stamp = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
String baseNm = "개인정보접속기록_" + stamp + "_" + jobId;
plain = new File(dir, baseNm + ".csv.tmp");
enc = new File(dir, baseNm + ".csv.enc");
int written = writeCsv(plain, searchVO, total, job);
// 평문 CSV 를 디스크에 남기지 않는다 — 암호화 후 즉시 삭제.
if (!EgovFileScrty.encryptFile(plain.getAbsolutePath(), enc.getAbsolutePath())) {
throw new IllegalStateException("파일 암호화 실패");
}
deleteQuietly(plain);
plain = null;
job.setDoneCnt(written);
job.setTotalCnt(total);
job.setFileNm(baseNm + ".csv");
job.setFilePath(enc.getAbsolutePath());
job.setFileSize(enc.length());
jobDAO.updateSuccess(job);
LOG.info("[개인정보/SFR-004-6] 다운로드 파일 생성 완료 — jobId=" + jobId + ", " + written + "행, "
+ enc.length() + "byte");
} catch (Throwable t) {
LOG.error("[개인정보/SFR-004-6] 다운로드 파일 생성 실패 — jobId=" + jobId, t);
deleteQuietly(plain);
deleteQuietly(enc);
try {
AccessLogDownloadJobVO fail = (job != null) ? job : new AccessLogDownloadJobVO();
fail.setJobId(jobId);
fail.setErrMsg(cut(String.valueOf(t.getMessage()), 500));
jobDAO.updateFail(fail);
} catch (Exception e) {
LOG.error("[개인정보/SFR-004-6] 실패 상태 기록마저 실패 — jobId=" + jobId, e);
}
}
}
/**
* 청크 단위로 조회하며 곧바로 파일에 기록한다(전체를 메모리에 올리지 않는다).
*
* @return 기록한 행 수
*/
private int writeCsv(File target, PersonalDataAccessLogSearchVO searchVO, int total,
AccessLogDownloadJobVO job) throws Exception {
BufferedWriter w = null;
int written = 0;
try {
FileOutputStream fos = new FileOutputStream(target);
// UTF-8 BOM — 엑셀에서 한글이 깨지지 않게 한다(기존 동기 다운로드와 동일).
fos.write(0xEF); fos.write(0xBB); fos.write(0xBF);
w = new BufferedWriter(new OutputStreamWriter(fos, "UTF-8"));
w.write(CSV_HEADER);
w.newLine();
int page = 1;
while (written < total) {
searchVO.setPageIndex(page);
searchVO.setRecordCountPerPage(CHUNK_ROWS);
List<PersonalDataAccessLogVO> chunk = searchService.selectAccessLogList(searchVO);
if (chunk == null || chunk.isEmpty()) {
break;
}
for (int i = 0; i < chunk.size(); i++) {
w.write(toCsvLine(chunk.get(i)));
w.newLine();
written++;
}
w.flush();
// 진행률 갱신 — 화면 폴링이 실제로 움직이는 값을 보게 한다.
job.setDoneCnt(written);
job.setTotalCnt(total);
try {
jobDAO.updateProgress(job);
} catch (Exception e) {
// 진행률은 부가정보다 — 실패해도 생성은 계속한다.
LOG.warn("[개인정보/SFR-004-6] 진행률 갱신 실패(무시) — jobId=" + job.getJobId());
}
page++;
}
w.flush();
} finally {
if (w != null) {
try { w.close(); } catch (Exception ignore) { /* 닫기 실패는 무시 */ }
}
}
return written;
}
private String toCsvLine(PersonalDataAccessLogVO v) {
StringBuilder sb = new StringBuilder(256);
sb.append(v.getLogId()).append(',')
.append(csv(v.getConectDt())).append(',')
.append(csv(v.getConectId())).append(',')
.append(csv(v.getUserSe())).append(',')
.append(csv(v.getConectIp())).append(',')
.append(csv(v.getJobSeCode())).append(',')
.append(csv(v.getJobSeNm())).append(',')
.append(csv(dmlLabel(v.getDmlGubun()))).append(',')
.append(csv(v.getTrgetId())).append(',')
.append(csv(v.getTrgetCn())).append(',')
.append(csv(resultLabel(v.getProcessResult()))).append(',')
.append(csv(v.getHashVal()));
return sb.toString();
}
private PersonalDataAccessLogSearchVO toSearchVO(AccessLogDownloadJobVO job) {
PersonalDataAccessLogSearchVO vo = new PersonalDataAccessLogSearchVO();
vo.setConectId(job.getCondConectId());
vo.setJobSeCode(job.getCondJobSeCode());
vo.setTrgetId(job.getCondTrgetId());
vo.setConectIp(job.getCondConectIp());
vo.setDmlGubun(job.getCondDmlGubun());
vo.setProcessResult(job.getCondProcessResult());
vo.setFromDt(job.getCondFromDt());
vo.setToDt(job.getCondToDt());
return vo;
}
/**
* 저장 디렉터리를 확보한다(없으면 생성).
*
* <p>실패는 <b>예외로 알린다</b>. 조용히 null 을 돌려주면 호출측이 그냥 넘어가고,
* 그 결과가 '영원한 대기'였다. 메시지는 그대로 작업의 실패사유(ERR_MSG)로 화면에 노출되므로
* 운영자가 원인을 바로 알 수 있게 경로를 포함해 적는다.</p>
*/
private File ensureDir() {
if (downloadPath == null || downloadPath.trim().length() == 0) {
throw new IllegalStateException("다운로드 저장경로 미설정(Globals.privacyDownloadPath)");
}
File dir = new File(downloadPath.trim());
if (!dir.exists() && !dir.mkdirs()) {
throw new IllegalStateException("다운로드 저장경로 생성 실패 — " + dir.getAbsolutePath());
}
if (!dir.isDirectory()) {
throw new IllegalStateException("다운로드 저장경로가 디렉터리가 아님 — " + dir.getAbsolutePath());
}
if (!dir.canWrite()) {
throw new IllegalStateException("다운로드 저장경로에 쓸 수 없음(WAS 계정 권한 확인) — " + dir.getAbsolutePath());
}
return dir;
}
private void deleteQuietly(File f) {
if (f != null && f.exists()) {
try {
if (!f.delete()) {
LOG.warn("[개인정보/SFR-004-6] 임시파일 삭제 실패(수동 확인 필요) — " + f.getAbsolutePath());
}
} catch (Exception ignore) {
LOG.warn("[개인정보/SFR-004-6] 임시파일 삭제 중 예외 — " + f.getAbsolutePath());
}
}
}
/** CSV 셀 이스케이프(구분자·따옴표·개행 방어). */
private String csv(String v) {
if (v == null) {
return "";
}
String s = v.replace("\"", "\"\"");
return "\"" + s.replace("\r", " ").replace("\n", " ") + "\"";
}
private String dmlLabel(String code) {
if ("S".equals(code)) return "조회";
if ("I".equals(code)) return "등록";
if ("U".equals(code)) return "수정";
if ("D".equals(code)) return "삭제";
return code;
}
private String resultLabel(String code) {
if ("S".equals(code)) return "성공";
if ("F".equals(code)) return "실패/차단";
return code;
}
private static String cut(String s, int max) {
if (s == null) {
return null;
}
return (s.length() > max) ? s.substring(0, max) : s;
}
}

17
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadService.java
View File

@ -25,21 +25,4 @@ public interface AccessLogDownloadService {
*/
List<PersonalDataAccessLogVO> downloadAccessLog(String downloaderId, String downloaderIp,
String reason, PersonalDataAccessLogSearchVO searchVO) throws Exception;
/**
* 다운로드 이력만 적재한다(조회 없이).
*
* <p>비동기 다운로드(SFR-004-6)는 파일을 백그라운드에서 미리 만들어 두므로, 실제로
* <b>내려받은 시점</b>에 이력을 남겨야 증빙이 맞다. 조회는 이미 끝나 있어 건수·조건을
* 작업 정보에서 그대로 받는다.</p>
*
* @param downloaderId 다운로드자 계정ID
* @param downloaderIp 다운로드자 접속 IP
* @param reason 다운로드 사유(요청 시 입력한 값)
* @param searchCond 검색조건 요약(개인정보 본문 미포함)
* @param resultCnt 내려받은 건수
* @throws Exception 적재 오류
*/
void recordDownloadHistory(String downloaderId, String downloaderIp, String reason,
String searchCond, int resultCnt) throws Exception;
}

12
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogDownloadServiceImpl.java
View File

@ -58,18 +58,6 @@ public class AccessLogDownloadServiceImpl implements AccessLogDownloadService {
return result;
}
@Override
public void recordDownloadHistory(String downloaderId, String downloaderIp, String reason,
String searchCond, int resultCnt) throws Exception {
AccessLogDownloadHistoryVO hist = new AccessLogDownloadHistoryVO();
hist.setDownloaderId(downloaderId);
hist.setDownloaderIp(downloaderIp);
hist.setDlReason(reason == null ? "" : reason.trim());
hist.setSearchCond(searchCond);
hist.setResultCnt(resultCnt);
downloadHistoryDAO.insertDownloadHistory(hist);
}
/** 검색조건을 개인정보 본문 없이 요약 문자열로. */
private String summarizeCond(PersonalDataAccessLogSearchVO vo) {
StringBuilder sb = new StringBuilder();

243
src/main/java/egovframework/com/cmm/privacy/auditlog/AccessLogQueue.java
View File

@ -5,7 +5,6 @@ import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@ -24,23 +23,11 @@ import org.springframework.stereotype.Component;
*
* <p><b>순번·해시체인 무결성(#39):</b> 컨슈머는 <b>단일 스레드</b>다. 큐에서 하나씩 꺼내
* {@link PersonalDataLogService#persistNow}를 순차 호출하므로 {@code PREV_HASH_VAL}이 항상
* 직전 레코드를 정확히 가리킨다. 병렬 컨슈머를 두지 않는다(전체 순번 보장).
* 컨슈머 재기동·종료 flush 등 예외 경로에서도 {@code persistNow}가 {@code synchronized}라
* 두 스레드가 동시에 봉인·적재하는 일은 없다.</p>
* 직전 레코드를 정확히 가리킨다. 병렬 컨슈머를 두지 않는다(전체 순번 보장).</p>
*
* <p><b>백프레셔 상한(2026-07-30):</b> 종전에는 큐가 가득 차면 {@code offer(timeout)}를
* <u>무한 반복</u>해 대기했다. 컨슈머가 정지하면(예: 파티션 DROP·전체 무결성 검증 중 테이블
* 잠금으로 {@code persistNow}가 블로킹, 또는 컨슈머 스레드 사망) 요청 스레드가 이 지점에서
* 영구 대기하고, 그 상태가 지속되면 WAS 스레드 풀이 고갈돼 <b>사이트 전체가 정지</b>한다.
* 복구 경로가 없는 구조라 대기를 {@link #MAX_OFFER_ATTEMPT}회로 제한한다. 상한을 넘기면
* 해당 1건을 포기하되 <b>유실 사실과 식별 정보를 ERROR 로그로 남기고 누적 건수를 집계</b>한다
* (접속기록은 법정 보관 대상이므로 조용한 유실은 금지 — 사후 추적 가능하게 남긴다).</p>
*
* <p><b>컨슈머 감시(2026-07-30):</b> 적재 루프가 {@code Throwable}까지 흡수해 스스로 죽지
* 않지만, 그것만으로는 외부 요인(스레드 강제 종료 등)에 대비할 수 없다. 별도 감시 스레드가
* 주기적으로 컨슈머 생존과 큐 적체를 점검하고, 죽어 있으면 재기동한다. 감시는 스케줄러
* 설정({@code task:annotation-driven})에 의존하지 않는 자체 데몬 스레드다 — 스케줄러 활성화
* 여부와 무관하게 동작해야 하기 때문이다.</p>
* <p><b>드롭 금지·백프레셔:</b> 큐가 가득 차면 레코드를 버리지 않고 {@code offer(timeout)}로
* 대기(백프레셔)한다. enqueue는 업무 트랜잭션 커밋 이후(Aspect의 finally) 호출되므로 짧은
* 대기가 업무 데이터 정합성을 해치지 않는다.</p>
*
* <p><b>종료 flush:</b> 컨테이너 종료 시 잔여 큐를 모두 적재한 뒤 스레드를 정리한다(유실 방지).</p>
*
@ -52,24 +39,12 @@ public class AccessLogQueue {
private static final Log LOG = LogFactory.getLog(AccessLogQueue.class);
/** 큐 용량(백프레셔 경계). */
/** 큐 용량(백프레셔 경계). 초과 시 드롭하지 않고 대기한다. */
private static final int CAPACITY = 10000;
/** enqueue 대기 1회 최대 시간(초). */
/** enqueue 대기 1회 최대 시간(초). 초과하면 경고 로깅 후 재대기(무한 유실 방지). */
private static final long OFFER_WAIT_SEC = 5L;
/** enqueue 대기 최대 횟수 — 초과 시 해당 건을 포기한다(요청 스레드 영구 대기 방지). */
private static final int MAX_OFFER_ATTEMPT = 3;
/** 종료 시 컨슈머 스레드 join 최대 대기(ms). */
private static final long SHUTDOWN_JOIN_MS = 10000L;
/** 컨슈머 생존·적체 감시 주기(ms). */
private static final long WATCHDOG_INTERVAL_MS = 30000L;
/** 적체 경고 임계치(용량 대비). 이 이상 쌓이면 감시 스레드가 경고한다. */
private static final int BACKLOG_WARN_SIZE = (int) (CAPACITY * 0.8);
/** 포화 해제(차단기 복구) 임계치 — 잔량이 이 수준까지 빠지면 정상 경로로 복귀한다. */
private static final int SATURATION_CLEAR_SIZE = CAPACITY / 2;
/** 유실 로그 상세를 남기는 초기 건수(이후는 표본 기록 — 로그 폭주 방지). */
private static final long DROP_LOG_HEAD = 20L;
/** 초기 건수 이후 유실 로그 표본 주기. */
private static final long DROP_LOG_SAMPLE = 100L;
private final BlockingQueue<PersonalDataAccessLogVO> queue =
new LinkedBlockingQueue<PersonalDataAccessLogVO>(CAPACITY);
@ -78,127 +53,54 @@ public class AccessLogQueue {
private PersonalDataLogService personalDataLogService;
private volatile boolean running = false;
private volatile Thread consumer;
private volatile Thread watchdog;
/** 큐 포화로 포기한 접속기록 누적 건수(운영 점검용). */
private final AtomicLong droppedCount = new AtomicLong(0L);
/** 컨슈머 재기동 누적 횟수(운영 점검용). */
private final AtomicLong consumerRestartCount = new AtomicLong(0L);
/**
* 포화 차단기. 한 번 포기가 발생하면 켜지고, 잔량이 {@link #SATURATION_CLEAR_SIZE}까지
* 빠지면 감시 스레드가 끈다. 켜져 있는 동안 {@link #enqueue}는 대기 없이 즉시 판정한다 —
* 포화가 지속되는 상황에서 요청마다 최대 {@code OFFER_WAIT_SEC × MAX_OFFER_ATTEMPT}초를
* 물게 하면 사이트 전체가 느려지기 때문이다.
*/
private volatile boolean saturated = false;
private Thread consumer;
@PostConstruct
public void start() {
running = true;
startConsumer();
startWatchdog();
}
/**
* 단일 컨슈머 스레드를 기동한다. 이미 살아 있으면 아무것도 하지 않는다
* (해시체인 순번 보장 전제상 컨슈머는 반드시 하나여야 하므로 동기화한다).
*/
private synchronized void startConsumer() {
if (!running) {
return;
}
Thread cur = consumer;
if (cur != null && cur.isAlive()) {
return;
}
Thread t = new Thread(new Runnable() {
consumer = new Thread(new Runnable() {
public void run() {
consumeLoop();
}
}, "pdal-accesslog-consumer");
t.setDaemon(true);
consumer = t;
t.start();
consumer.setDaemon(true);
consumer.start();
LOG.info("[개인정보/#33] 접속기록 비동기 컨슈머 기동 — 단일 스레드, capacity=" + CAPACITY);
}
/** 컨슈머 생존·큐 적체 감시 스레드를 기동한다. */
private synchronized void startWatchdog() {
Thread cur = watchdog;
if (cur != null && cur.isAlive()) {
return;
}
Thread t = new Thread(new Runnable() {
public void run() {
watchdogLoop();
}
}, "pdal-accesslog-watchdog");
t.setDaemon(true);
watchdog = t;
t.start();
LOG.info("[개인정보/#33] 접속기록 컨슈머 감시 기동 — 주기 " + (WATCHDOG_INTERVAL_MS / 1000) + "초");
}
/**
* 접속기록 1건을 큐에 적재한다(비동기).
*
* <p>큐가 가득 차면 {@link #MAX_OFFER_ATTEMPT}회까지만 대기한다. 그 이상은 요청 스레드를
* 붙잡지 않고 포기하며, 유실 사실을 ERROR로 남긴다. 종료 진행 중이면 인라인 적재한다
* ({@code persistNow}가 {@code synchronized}라 컨슈머와 동시 실행돼도 순번은 안전).</p>
* 접속기록 1건을 큐에 적재한다(비동기, 드롭 금지).
* 큐 포화 시 백프레셔로 대기한다. 종료 진행 중이면 인라인 적재로 유실을 방지한다.
*/
public void enqueue(PersonalDataAccessLogVO vo) {
if (vo == null) {
return;
}
if (!running) {
// 종료 중 — 큐에 넣어도 처리되지 않을 수 있으므로 인라인 적재로 유실을 막는다.
personalDataLogService.persistNow(vo);
return;
}
// 차단기 ON — 대기하지 않고 즉시 판정(요청 지연 확산 차단).
if (saturated) {
if (!queue.offer(vo)) {
recordDrop(vo);
}
return;
}
try {
for (int attempt = 1; attempt <= MAX_OFFER_ATTEMPT; attempt++) {
if (!running) {
personalDataLogService.persistNow(vo);
return;
boolean queued = false;
while (running && !queued) {
queued = queue.offer(vo, OFFER_WAIT_SEC, TimeUnit.SECONDS);
if (!queued) {
LOG.warn("[개인정보/#33] 접속기록 큐 포화(size=" + queue.size()
+ ") — 컨슈머 지연. 드롭하지 않고 계속 대기.");
}
if (queue.offer(vo, OFFER_WAIT_SEC, TimeUnit.SECONDS)) {
return;
}
LOG.warn("[개인정보/#33] 접속기록 큐 포화(size=" + queue.size() + ") — 컨슈머 지연, 대기 "
+ attempt + "/" + MAX_OFFER_ATTEMPT);
}
// 상한 초과 — 요청 스레드를 더 붙잡지 않는다. 무한 대기로 WAS 스레드를 고갈시키는 것보다
// 1건 유실이 낫다는 판단(단, recordDrop 로그로 사후 추적 가능하게 남긴다).
saturated = true;
LOG.error("[개인정보/#33] 접속기록 큐 포화 차단기 ON — 이후 대기 없이 즉시 판정한다. "
+ "잔량이 " + SATURATION_CLEAR_SIZE + " 이하로 빠지면 자동 복구.");
recordDrop(vo);
if (!queued) {
// 종료 중(running=false) — 컨슈머가 이미 멈췄으므로 단일 라이터 보장 하에 인라인 적재.
personalDataLogService.persistNow(vo);
}
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
LOG.error("[개인정보/#33] 접속기록 enqueue 인터럽트 — 인라인 적재 시도. " + describe(vo), ie);
LOG.error("[개인정보/#33] 접속기록 enqueue 인터럽트 — 인라인 적재 시도.", ie);
try {
personalDataLogService.persistNow(vo);
} catch (Exception e) {
LOG.error("[개인정보/#33] 인라인 적재 실패 — " + describe(vo), e);
LOG.error("[개인정보/#33] 인라인 적재 실패", e);
}
}
}
/**
* 단일 컨슈머 루프 — 큐에서 하나씩 꺼내 순차 적재(순번 보장).
*
* <p>{@code Throwable}까지 흡수한다. {@code Exception}만 잡던 종전 구조에서는
* {@code Error}(OOM 등) 하나로 컨슈머가 죽고, {@code running}은 true로 남아 이후 모든
* {@link #enqueue}가 포화 대기에 빠졌다.</p>
*/
/** 단일 컨슈머 루프 — 큐에서 하나씩 꺼내 순차 적재(순번 보장). */
private void consumeLoop() {
while (running || !queue.isEmpty()) {
try {
@ -209,99 +111,20 @@ public class AccessLogQueue {
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
// 종료 신호 — 남은 큐를 마저 비우고 루프 조건에서 빠져나간다.
} catch (Throwable t) {
LOG.error("[개인정보/#33] 접속기록 적재 처리 실패(로깅 후 계속)", t);
} catch (Exception e) {
LOG.error("[개인정보/#33] 접속기록 적재 처리 실패(로깅 후 계속)", e);
}
}
LOG.info("[개인정보/#33] 접속기록 비동기 컨슈머 종료 — 잔여 큐 flush 완료.");
}
/** 컨슈머 생존과 큐 적체를 주기 점검한다. 컨슈머가 죽어 있으면 재기동한다. */
private void watchdogLoop() {
while (running) {
try {
Thread.sleep(WATCHDOG_INTERVAL_MS);
if (!running) {
break;
}
Thread cur = consumer;
if (cur == null || !cur.isAlive()) {
long n = consumerRestartCount.incrementAndGet();
LOG.error("[개인정보/#33] 접속기록 컨슈머 사망 감지 — 재기동(누적 " + n + "회). 큐 잔량="
+ queue.size() + ", 누적 포기=" + droppedCount.get());
startConsumer();
} else if (queue.size() >= BACKLOG_WARN_SIZE) {
LOG.warn("[개인정보/#33] 접속기록 큐 적체 경고 — size=" + queue.size() + "/" + CAPACITY
+ ". 이 상태가 지속되면 포화로 유실이 시작된다(누적 포기=" + droppedCount.get() + "건).");
}
// 차단기 복구 — 잔량이 절반 이하로 빠졌으면 정상(대기 허용) 경로로 되돌린다.
if (saturated && queue.size() <= SATURATION_CLEAR_SIZE) {
saturated = false;
LOG.info("[개인정보/#33] 접속기록 큐 포화 차단기 OFF — 정상 경로 복귀(size=" + queue.size()
+ ", 누적 포기=" + droppedCount.get() + "건).");
}
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
break;
} catch (Throwable t) {
LOG.error("[개인정보/#33] 접속기록 컨슈머 감시 중 예외(계속)", t);
}
}
LOG.info("[개인정보/#33] 접속기록 컨슈머 감시 종료.");
}
/**
* 유실 1건을 집계하고 기록한다.
*
* <p>접속기록은 법정 보관 대상이라 조용히 버리지 않는다. 다만 포화가 지속되면 유실 로그가
* 그대로 로그 폭주가 되므로, 초기 {@link #DROP_LOG_HEAD}건은 전부 남기고 이후에는
* {@link #DROP_LOG_SAMPLE}건마다 표본으로 남긴다. 누적 건수는 항상 정확히 집계된다.</p>
*/
private void recordDrop(PersonalDataAccessLogVO vo) {
long dropped = droppedCount.incrementAndGet();
if (dropped <= DROP_LOG_HEAD || dropped % DROP_LOG_SAMPLE == 0L) {
LOG.error("[개인정보/#33] 접속기록 1건 포기(누적 " + dropped + "건, size=" + queue.size()
+ ") — 컨슈머 상태 점검 필요. 유실건: " + describe(vo));
}
}
/** 유실·실패 로그용 식별 정보. 개인정보 본문은 담지 않는다(#31 본문 미적재 원칙). */
private String describe(PersonalDataAccessLogVO vo) {
if (vo == null) {
return "(null)";
}
return "conectId=" + vo.getConectId() + ", conectDt=" + vo.getConectDt()
+ ", jobSeCode=" + vo.getJobSeCode() + ", trgetId=" + vo.getTrgetId();
}
/** 큐 포화로 포기한 누적 건수(운영 점검·정기점검 리포트 참고용). */
public long getDroppedCount() {
return droppedCount.get();
}
/** 컨슈머 재기동 누적 횟수(운영 점검용). */
public long getConsumerRestartCount() {
return consumerRestartCount.get();
}
/** 현재 큐 잔량(운영 점검용). */
public int getQueueSize() {
return queue.size();
}
@PreDestroy
public void stop() {
running = false;
Thread w = watchdog;
if (w != null) {
w.interrupt();
}
Thread c = consumer;
if (c != null) {
c.interrupt();
if (consumer != null) {
consumer.interrupt();
try {
c.join(SHUTDOWN_JOIN_MS); // 잔여 flush 대기
consumer.join(SHUTDOWN_JOIN_MS); // 잔여 flush 대기
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
}
@ -313,15 +136,11 @@ public class AccessLogQueue {
try {
personalDataLogService.persistNow(remaining.get(i));
} catch (Exception e) {
LOG.error("[개인정보/#33] 종료 flush 적재 실패 — " + describe(remaining.get(i)), e);
LOG.error("[개인정보/#33] 종료 flush 적재 실패", e);
}
}
if (!remaining.isEmpty()) {
LOG.info("[개인정보/#33] 종료 시 잔여 " + remaining.size() + "건 인라인 flush 완료.");
}
if (droppedCount.get() > 0L) {
LOG.error("[개인정보/#33] 가동 중 큐 포화로 포기한 접속기록 누계 " + droppedCount.get()
+ "건 — 원인 점검 필요(컨슈머 처리량/DB 지연).");
}
}
}

267
src/main/java/egovframework/com/cmm/privacy/auditlog/JobMappingController.java
View File

@ -1,267 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.net.URLEncoder;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.util.EgovUserDetailsHelper;
import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
/**
* 업무유형 매핑 관리 컨트롤러 — 개인정보보호 기능개선 사업(SFR-004 / SER-002 / #32-1).
*
* <p>{@code PDAL_JOB_MAPPING}(#32) 을 화면에서 등록·수정·사용중지·삭제한다. 이 매핑은
* 접속기록 수집 Aspect(#31)가 (서비스 클래스, 메서드)를 업무코드·업무명으로 분류하는 기준이며,
* 접속기록 조회 화면(#47)의 '수행업무' 검색 드롭다운 소스이기도 하다.</p>
*
* <p><b>화면 경로</b> {@code /WEB-INF/jsp/site/mnt/sec/jobMapping/list.jsp}, {@code regist.jsp}</p>
*
* <p><b>수집 범위와의 관계(오해 주의):</b> 매핑을 지우거나 사용중지해도 <u>수집이 멈추지는 않는다</u>.
* 수집 대상은 {@code context-syslogaop.xml} 의 pointcut 이 정하고, 이 테이블은 분류만 담당한다.
* 매핑이 없으면 메서드명으로 유도한 기본 분류로 적재된다.</p>
*
* <p><b>접근통제:</b> 인터셉터 3단 중 ①인증판정이 비활성이고 ②③은 fail-open 이라
* /mnt 하위라도 무인증 노출이 가능하므로, {@link #handlerUser()} 로 화면·엔드포인트
* 단에서 직접 판정한다(PersonalDataAccessLogController 와 동일 방식).</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 SFR-004 #32-1)
* </pre>
*/
@Controller
public class JobMappingController {
private static final String LOGIN_REDIRECT = "redirect:/uat/uia/egovLoginUsr.do";
private static final String LIST_REDIRECT = "redirect:/mnt/sec/jobMapping/listView.do?page=9100045";
@Resource(name = "jobMappingManageService")
private JobMappingManageService jobMappingManageService;
/**
* 업무유형 매핑 목록 화면(서버 렌더링).
* 뷰: /WEB-INF/jsp/site/mnt/sec/jobMapping/list.jsp
*/
@RequestMapping(value = "/mnt/sec/jobMapping/listView.do")
public String listView(@ModelAttribute("jobMappingSearchVO") JobMappingSearchVO searchVO,
@RequestParam(value = "resultMsg", required = false) String resultMsg,
ModelMap model) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
// selectJobMappingManageList 내부에서 firstIndex/totalRecordCount 를 세팅한다.
List<JobMappingVO> list = jobMappingManageService.selectJobMappingManageList(searchVO);
PaginationInfo paginationInfo = new PaginationInfo();
paginationInfo.setCurrentPageNo(searchVO.getPageIndex());
paginationInfo.setRecordCountPerPage(searchVO.getRecordCountPerPage());
paginationInfo.setPageSize(10);
paginationInfo.setTotalRecordCount(searchVO.getTotalRecordCount());
model.addAttribute("resultList", list);
model.addAttribute("paginationInfo", paginationInfo);
model.addAttribute("resultMsg", resultMsg);
return "site/mnt/sec/jobMapping/list";
}
/**
* 등록·수정 폼 화면. mappingId 가 있으면 수정, 없으면 등록.
* 뷰: /WEB-INF/jsp/site/mnt/sec/jobMapping/regist.jsp
*/
@RequestMapping(value = "/mnt/sec/jobMapping/registView.do")
public String registView(@RequestParam(value = "mappingId", required = false) Long mappingId,
ModelMap model) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
JobMappingVO vo = null;
if (mappingId != null && mappingId.longValue() > 0) {
vo = jobMappingManageService.selectJobMapping(mappingId.longValue());
if (vo == null) {
return listRedirect("대상 매핑이 존재하지 않습니다.");
}
}
if (vo == null) {
vo = new JobMappingVO();
vo.setMethodPttrn("*");
vo.setSortOrdr(100); // DDL DEFAULT 와 동일
vo.setUseAt("Y");
}
model.addAttribute("jobMappingVO", vo);
return "site/mnt/sec/jobMapping/regist";
}
/**
* 등록·수정 저장. mappingId 가 0 이면 등록, 그 외는 수정.
*
* <p>{@code BindingResult} 를 반드시 받는다 — 숫자 필드(우선순위)를 비우거나 문자로 채우면
* 바인딩이 실패하는데, 이 파라미터가 없으면 Spring 이 BindException 을 던져 500 오류 화면이 뜬다.
* 여기서 받아 사용자 메시지로 되돌린다.</p>
*/
@RequestMapping(value = "/mnt/sec/jobMapping/save.do")
public String save(@ModelAttribute("jobMappingVO") JobMappingVO vo,
BindingResult bindingResult,
HttpServletRequest request) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
return LOGIN_REDIRECT;
}
if (!isPost(request) || !isSameOrigin(request)) {
return listRedirect("잘못된 요청 경로입니다.");
}
if (bindingResult.hasErrors()) {
return listRedirect("입력값 형식이 올바르지 않습니다. 우선순위는 숫자로 입력하세요.");
}
try {
if (vo.getMappingId() > 0) {
jobMappingManageService.updateJobMapping(vo, user.getId());
return listRedirect("수정되었습니다. 접속기록 분류에 즉시 반영됩니다.");
}
jobMappingManageService.insertJobMapping(vo, user.getId());
return listRedirect("등록되었습니다. 접속기록 분류에 즉시 반영됩니다.");
} catch (IllegalArgumentException e) {
return listRedirect(e.getMessage());
}
}
/** 사용여부 전환(Y↔N) — 삭제 대신 권장하는 비활성화 경로. */
@RequestMapping(value = "/mnt/sec/jobMapping/useAt.do")
public String updateUseAt(@RequestParam("mappingId") long mappingId,
@RequestParam("useAt") String useAt,
HttpServletRequest request) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
return LOGIN_REDIRECT;
}
if (!isPost(request) || !isSameOrigin(request)) {
return listRedirect("잘못된 요청 경로입니다.");
}
try {
jobMappingManageService.updateJobMappingUseAt(mappingId, useAt, user.getId());
return listRedirect("Y".equals(useAt) ? "사용으로 전환했습니다." : "사용중지로 전환했습니다.");
} catch (IllegalArgumentException e) {
return listRedirect(e.getMessage());
}
}
/** 매핑 삭제(행 제거). */
@RequestMapping(value = "/mnt/sec/jobMapping/delete.do")
public String delete(@RequestParam("mappingId") long mappingId,
HttpServletRequest request) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
return LOGIN_REDIRECT;
}
if (!isPost(request) || !isSameOrigin(request)) {
return listRedirect("잘못된 요청 경로입니다.");
}
try {
jobMappingManageService.deleteJobMapping(mappingId, user.getId());
return listRedirect("삭제되었습니다.");
} catch (IllegalArgumentException e) {
return listRedirect(e.getMessage());
}
}
/**
* Resolver 캐시 재적재. 화면을 거치지 않고 DB 를 직접 수정한 경우
* WAS 재기동 없이 반영하기 위한 수단이다.
*/
@RequestMapping(value = "/mnt/sec/jobMapping/refresh.do")
public String refresh(HttpServletRequest request) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
if (!isPost(request) || !isSameOrigin(request)) {
return listRedirect("잘못된 요청 경로입니다.");
}
jobMappingManageService.refreshCache();
return listRedirect("매핑 캐시를 재적재했습니다.");
}
/** 처리결과 메시지를 붙여 목록으로 리다이렉트. */
private String listRedirect(String message) throws Exception {
if (message == null) {
return LIST_REDIRECT;
}
return LIST_REDIRECT + "&resultMsg=" + URLEncoder.encode(message, "UTF-8");
}
/** 상태를 바꾸는 요청은 POST 로 한정(링크 클릭·이미지 태그를 통한 변경 방지). */
private boolean isPost(HttpServletRequest request) {
return "POST".equalsIgnoreCase(request.getMethod());
}
/**
* 취급자 영역(/mnt) 인증·구분 판정.
*
* @return 인증된 업무사용자(USR) LoginVO, 그 외에는 null
*/
private LoginVO handlerUser() {
if (!Boolean.TRUE.equals(EgovUserDetailsHelper.isAuthenticated())) {
return null;
}
Object o = EgovUserDetailsHelper.getAuthenticatedUser();
if (!(o instanceof LoginVO)) {
return null;
}
LoginVO loginVO = (LoginVO) o;
return "USR".equals(loginVO.getUserSe()) ? loginVO : null;
}
/**
* CSRF 부분 완화. Spring Security 2.0.4 에는 CSRF 토큰 기능이 없으므로,
* Origin/Referer 가 전달된 경우에 한해 요청 호스트와 동일한지 확인한다
* (헤더 미전송 환경은 과잉차단을 피해 통과 — AccountMngController 와 동일 규약).
*/
private boolean isSameOrigin(HttpServletRequest request) {
String source = request.getHeader("Origin");
if (source == null) {
source = request.getHeader("Referer");
}
if (source == null) {
return true;
}
String sourceHost = hostOf(source);
String requestHost = hostOf(request.getHeader("Host"));
return sourceHost != null && sourceHost.equalsIgnoreCase(requestHost);
}
/** "https://host:8080/path" · "host:8080" 등에서 호스트명만 추출. */
private String hostOf(String value) {
if (value == null) {
return null;
}
String host = value;
int scheme = host.indexOf("://");
if (scheme >= 0) {
host = host.substring(scheme + 3);
}
int slash = host.indexOf('/');
if (slash >= 0) {
host = host.substring(0, slash);
}
int colon = host.indexOf(':');
if (colon >= 0) {
host = host.substring(0, colon);
}
return host.length() == 0 ? null : host;
}
}

50
src/main/java/egovframework/com/cmm/privacy/auditlog/JobMappingDAO.java
View File

@ -25,54 +25,4 @@ public class JobMappingDAO extends EgovComAbstractDAO {
public List<JobMappingVO> selectJobMappingList() {
return list("JobMappingDAO.selectJobMappingList", null);
}
// =================================================================
// 관리 화면(#32-1) CRUD — 위 selectJobMappingList 와 달리 USE_AT='N' 행도 대상
// =================================================================
/** 관리 목록 조회(검색 + 페이징). 사용중지(N) 행도 포함한다. */
@SuppressWarnings("unchecked")
public List<JobMappingVO> selectJobMappingManageList(JobMappingSearchVO searchVO) {
return list("JobMappingDAO.selectJobMappingManageList", searchVO);
}
/** 관리 목록 전체 건수 */
public int selectJobMappingManageListCount(JobMappingSearchVO searchVO) {
Object cnt = selectByPk("JobMappingDAO.selectJobMappingManageListCount", searchVO);
return cnt == null ? 0 : ((Integer) cnt).intValue();
}
/** 매핑 단건 조회 */
public JobMappingVO selectJobMapping(long mappingId) {
return (JobMappingVO) selectByPk("JobMappingDAO.selectJobMapping", Long.valueOf(mappingId));
}
/**
* (TARGET_CLASS, METHOD_PTTRN) 중복 건수. 수정 시에는 자기 자신을 제외한다.
* 테이블에 유니크 제약이 없어(운영 중 행 추가/삭제 자유) 서비스 계층에서 막는다.
*/
public int selectJobMappingDuplicateCount(JobMappingVO vo) {
Object cnt = selectByPk("JobMappingDAO.selectJobMappingDuplicateCount", vo);
return cnt == null ? 0 : ((Integer) cnt).intValue();
}
/** 매핑 등록 */
public void insertJobMapping(JobMappingVO vo) {
insert("JobMappingDAO.insertJobMapping", vo);
}
/** 매핑 수정 */
public void updateJobMapping(JobMappingVO vo) {
update("JobMappingDAO.updateJobMapping", vo);
}
/** 매핑 사용여부 전환(Y↔N) — 삭제 대신 권장하는 비활성화 경로 */
public void updateJobMappingUseAt(JobMappingVO vo) {
update("JobMappingDAO.updateJobMappingUseAt", vo);
}
/** 매핑 삭제 */
public void deleteJobMapping(long mappingId) {
delete("JobMappingDAO.deleteJobMapping", Long.valueOf(mappingId));
}
}

53
src/main/java/egovframework/com/cmm/privacy/auditlog/JobMappingManageService.java
View File

@ -1,53 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.util.List;
/**
* 업무유형 매핑(PDAL_JOB_MAPPING) 관리 서비스 — 개발항목 #32-1.
*
* <p>#32 는 테이블·로더까지만 구현되어 매핑 행을 DB 직접 INSERT 로만 운영했다.
* 본 서비스는 취급자가 화면에서 매핑을 등록·수정·사용중지·삭제할 수 있게 한다.
* 매핑이 바뀌면 {@link JobMappingResolver} 캐시를 즉시 무효화하므로 WAS 재기동이 불요하다.</p>
*
* @author URP
* @since 2026-08-07
*/
public interface JobMappingManageService {
/** 관리 목록 조회(검색 + 페이징). searchVO 에 firstIndex/totalRecordCount 를 세팅한다. */
List<JobMappingVO> selectJobMappingManageList(JobMappingSearchVO searchVO) throws Exception;
/** 매핑 단건 조회(수정 폼). 없으면 null. */
JobMappingVO selectJobMapping(long mappingId) throws Exception;
/**
* 매핑 등록.
*
* @throws IllegalArgumentException 입력값 위반 또는 (대상클래스, 메서드패턴) 중복
*/
void insertJobMapping(JobMappingVO vo, String actorId) throws Exception;
/**
* 매핑 수정.
*
* @throws IllegalArgumentException 입력값 위반 / 중복 / 대상 매핑 없음
*/
void updateJobMapping(JobMappingVO vo, String actorId) throws Exception;
/**
* 사용여부 전환(Y↔N). 삭제 대신 권장하는 비활성화 경로.
*
* @throws IllegalArgumentException 대상 매핑 없음 또는 useAt 값 오류
*/
void updateJobMappingUseAt(long mappingId, String useAt, String actorId) throws Exception;
/**
* 매핑 삭제(행 제거).
*
* @throws IllegalArgumentException 대상 매핑 없음
*/
void deleteJobMapping(long mappingId, String actorId) throws Exception;
/** Resolver 캐시 강제 재적재(DB 직접 수정분 반영용). */
void refreshCache() throws Exception;
}

181
src/main/java/egovframework/com/cmm/privacy/auditlog/JobMappingManageServiceImpl.java
View File

@ -1,181 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.util.List;
import java.util.regex.Pattern;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
/**
* 업무유형 매핑(PDAL_JOB_MAPPING) 관리 서비스 구현 — 개발항목 #32-1.
*
* <p>클래스명이 {@code *Impl} 이고 패키지가 {@code egovframework.com..} 이므로
* {@code context-transaction.xml} 의 requiredTx pointcut 에 걸려 메서드 단위 트랜잭션이 적용된다
* (DB 반영 + 캐시 무효화가 함께 처리된다).</p>
*
* <p><b>캐시 무효화 범위:</b> {@link JobMappingResolver#refresh()} 는 <u>해당 JVM 의 캐시만</u>
* 비운다. arko 는 단일 Tomcat ROOT 전개라 현재는 충분하나, 다중 인스턴스로 확장하면
* 인스턴스별 재적재 수단(관리 화면의 '캐시 재적재' 버튼을 각 노드에서 호출 등)이 필요하다.</p>
*
* <p><b>입력 검증:</b> TARGET_CLASS/METHOD_PTTRN 은 Aspect 가 (클래스 단순명, 메서드명)으로
* 매칭하는 값이라 자바 식별자 형식만 허용한다. 형식을 열어두면 어떤 값도 매칭되지 않는
* 죽은 매핑이 쌓여 접속기록 분류가 조용히 폴백 처리된다.</p>
*
* @author URP
* @since 2026-08-07
*/
@Service("jobMappingManageService")
public class JobMappingManageServiceImpl implements JobMappingManageService {
/** 자바 식별자(패키지 포함 FQN 허용) */
private static final Pattern CLASS_PATTERN =
Pattern.compile("^[A-Za-z_$][A-Za-z0-9_$]*(\\.[A-Za-z_$][A-Za-z0-9_$]*)*$");
/** 메서드명 접두(부분 식별자) */
private static final Pattern METHOD_PATTERN =
Pattern.compile("^[A-Za-z_$][A-Za-z0-9_$]*$");
/** 업무코드 — 대문자/숫자/언더스코어 */
private static final Pattern CODE_PATTERN =
Pattern.compile("^[A-Z0-9_]+$");
@Resource(name = "jobMappingDAO")
private JobMappingDAO jobMappingDAO;
@Resource(name = "jobMappingResolver")
private JobMappingResolver jobMappingResolver;
public List<JobMappingVO> selectJobMappingManageList(JobMappingSearchVO searchVO) throws Exception {
if (searchVO.getPageIndex() < 1) {
searchVO.setPageIndex(1);
}
if (searchVO.getRecordCountPerPage() < 1 || searchVO.getRecordCountPerPage() > 100) {
searchVO.setRecordCountPerPage(20);
}
searchVO.setFirstIndex((searchVO.getPageIndex() - 1) * searchVO.getRecordCountPerPage());
searchVO.setTotalRecordCount(jobMappingDAO.selectJobMappingManageListCount(searchVO));
return jobMappingDAO.selectJobMappingManageList(searchVO);
}
public JobMappingVO selectJobMapping(long mappingId) throws Exception {
return jobMappingDAO.selectJobMapping(mappingId);
}
public void insertJobMapping(JobMappingVO vo, String actorId) throws Exception {
normalize(vo);
validate(vo);
// 신규는 자기 자신 제외가 없으므로 mappingId=0 으로 전체 대조
vo.setMappingId(0L);
if (jobMappingDAO.selectJobMappingDuplicateCount(vo) > 0) {
throw new IllegalArgumentException("이미 등록된 조합입니다. (대상클래스 + 메서드패턴)");
}
vo.setRegisterId(actorId);
vo.setUpdusrId(actorId);
jobMappingDAO.insertJobMapping(vo);
jobMappingResolver.refresh();
}
public void updateJobMapping(JobMappingVO vo, String actorId) throws Exception {
normalize(vo);
validate(vo);
if (jobMappingDAO.selectJobMapping(vo.getMappingId()) == null) {
throw new IllegalArgumentException("대상 매핑이 존재하지 않습니다.");
}
if (jobMappingDAO.selectJobMappingDuplicateCount(vo) > 0) {
throw new IllegalArgumentException("이미 등록된 조합입니다. (대상클래스 + 메서드패턴)");
}
vo.setUpdusrId(actorId);
jobMappingDAO.updateJobMapping(vo);
jobMappingResolver.refresh();
}
public void updateJobMappingUseAt(long mappingId, String useAt, String actorId) throws Exception {
if (!"Y".equals(useAt) && !"N".equals(useAt)) {
throw new IllegalArgumentException("사용여부 값이 올바르지 않습니다.");
}
JobMappingVO target = jobMappingDAO.selectJobMapping(mappingId);
if (target == null) {
throw new IllegalArgumentException("대상 매핑이 존재하지 않습니다.");
}
JobMappingVO vo = new JobMappingVO();
vo.setMappingId(mappingId);
vo.setUseAt(useAt);
vo.setUpdusrId(actorId);
jobMappingDAO.updateJobMappingUseAt(vo);
jobMappingResolver.refresh();
}
public void deleteJobMapping(long mappingId, String actorId) throws Exception {
if (jobMappingDAO.selectJobMapping(mappingId) == null) {
throw new IllegalArgumentException("대상 매핑이 존재하지 않습니다.");
}
jobMappingDAO.deleteJobMapping(mappingId);
jobMappingResolver.refresh();
}
public void refreshCache() throws Exception {
jobMappingResolver.refresh();
}
/** 공백 제거 + 미입력 항목 기본값 보정(체크박스/셀렉트 미전송 대비). */
private void normalize(JobMappingVO vo) {
vo.setTargetClass(trim(vo.getTargetClass()));
vo.setMethodPttrn(trim(vo.getMethodPttrn()));
vo.setJobSeCode(trim(vo.getJobSeCode()));
vo.setJobSeNm(trim(vo.getJobSeNm()));
vo.setDmlGubun(trim(vo.getDmlGubun()));
vo.setRm(trim(vo.getRm()));
if (vo.getMethodPttrn() == null) {
vo.setMethodPttrn("*"); // DDL DEFAULT 와 동일
}
// dmlGubun 은 미입력(null) 이 곧 '메서드명으로 유도' 규약이라 보정하지 않는다.
if (!"N".equals(vo.getUseAt())) {
vo.setUseAt("Y");
}
if (vo.getJobSeCode() != null) {
vo.setJobSeCode(vo.getJobSeCode().toUpperCase());
}
}
/** 화면 우회 입력(직접 POST)에 대비한 서버측 검증. 위반 시 사용자 메시지로 예외. */
private void validate(JobMappingVO vo) {
if (vo.getTargetClass() == null) {
throw new IllegalArgumentException("대상 클래스명은 필수입니다.");
}
if (vo.getTargetClass().length() > 200 || !CLASS_PATTERN.matcher(vo.getTargetClass()).matches()) {
throw new IllegalArgumentException("대상 클래스명은 자바 클래스명(또는 FQN) 형식으로 200자 이내 입력하세요.");
}
if (!"*".equals(vo.getMethodPttrn())
&& (vo.getMethodPttrn().length() > 100 || !METHOD_PATTERN.matcher(vo.getMethodPttrn()).matches())) {
throw new IllegalArgumentException("메서드 패턴은 '*' 또는 메서드명 접두(영문/숫자) 100자 이내로 입력하세요.");
}
if (vo.getJobSeCode() == null) {
throw new IllegalArgumentException("업무코드는 필수입니다.");
}
if (vo.getJobSeCode().length() > 30 || !CODE_PATTERN.matcher(vo.getJobSeCode()).matches()) {
throw new IllegalArgumentException("업무코드는 영문 대문자·숫자·밑줄 조합으로 30자 이내 입력하세요.");
}
if (vo.getJobSeNm() == null || vo.getJobSeNm().length() > 100) {
throw new IllegalArgumentException("업무명은 필수이며 100자 이내로 입력하세요.");
}
if (vo.getDmlGubun() != null && !"S".equals(vo.getDmlGubun()) && !"I".equals(vo.getDmlGubun())
&& !"U".equals(vo.getDmlGubun()) && !"D".equals(vo.getDmlGubun())) {
throw new IllegalArgumentException("처리구분 값이 올바르지 않습니다.");
}
if (vo.getSortOrdr() < 0 || vo.getSortOrdr() > 9999) {
throw new IllegalArgumentException("우선순위는 0~9999 범위로 입력하세요.");
}
if (vo.getRm() != null && vo.getRm().length() > 300) {
throw new IllegalArgumentException("비고는 300자 이내로 입력하세요.");
}
}
/** 앞뒤 공백 제거 후 빈 문자열은 null 로(iBatis isNotEmpty·DB NULL 규약 일치). */
private String trim(String v) {
if (v == null) {
return null;
}
String s = v.trim();
return s.length() == 0 ? null : s;
}
}

61
src/main/java/egovframework/com/cmm/privacy/auditlog/JobMappingSearchVO.java
View File

@ -1,61 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.io.Serializable;
/**
* 업무유형 매핑(PDAL_JOB_MAPPING) 관리 화면 검색조건 VO — 개발항목 #32-1.
*
* <p>매핑 조회용 {@link JobMappingVO} 와 달리 <b>USE_AT='N' 행도 조회 대상</b>이다.
* 관리 화면에서는 사용중지된 매핑도 보여야 재사용·복구가 가능하기 때문이다
* ({@code JobMappingDAO.selectJobMappingList} 는 Resolver 캐시용이라 'Y'만 조회).</p>
*
* @author URP
* @since 2026-08-07
*/
public class JobMappingSearchVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 대상 클래스명(부분 일치) */
private String searchTargetClass;
/** 업무코드 또는 업무명(부분 일치) */
private String searchJobSe;
/** 사용여부 Y/N (빈 값이면 전체) */
private String searchUseAt;
/** 처리구분 S/I/U/D (빈 값이면 전체) */
private String searchDmlGubun;
// ---- 페이징 ----
/** 현재 페이지 번호(1-base) */
private int pageIndex = 1;
/** 페이지당 레코드 수 */
private int recordCountPerPage = 20;
/** 조회 시작 offset(0-base) = (pageIndex-1) * recordCountPerPage */
private int firstIndex = 0;
/** 전체 레코드 수(조회 후 세팅) */
private int totalRecordCount = 0;
public String getSearchTargetClass() { return searchTargetClass; }
public void setSearchTargetClass(String searchTargetClass) { this.searchTargetClass = searchTargetClass; }
public String getSearchJobSe() { return searchJobSe; }
public void setSearchJobSe(String searchJobSe) { this.searchJobSe = searchJobSe; }
public String getSearchUseAt() { return searchUseAt; }
public void setSearchUseAt(String searchUseAt) { this.searchUseAt = searchUseAt; }
public String getSearchDmlGubun() { return searchDmlGubun; }
public void setSearchDmlGubun(String searchDmlGubun) { this.searchDmlGubun = searchDmlGubun; }
public int getPageIndex() { return pageIndex; }
public void setPageIndex(int pageIndex) { this.pageIndex = pageIndex; }
public int getRecordCountPerPage() { return recordCountPerPage; }
public void setRecordCountPerPage(int recordCountPerPage) { this.recordCountPerPage = recordCountPerPage; }
public int getFirstIndex() { return firstIndex; }
public void setFirstIndex(int firstIndex) { this.firstIndex = firstIndex; }
public int getTotalRecordCount() { return totalRecordCount; }
public void setTotalRecordCount(int totalRecordCount) { this.totalRecordCount = totalRecordCount; }
}

22
src/main/java/egovframework/com/cmm/privacy/auditlog/JobMappingVO.java
View File

@ -33,16 +33,6 @@ public class JobMappingVO implements Serializable {
private String useAt;
private String rm;
// ---- 변경 추적(#32-1 관리 화면) : 시드 적재 행은 등록자 NULL ----
/** 등록자 계정ID */
private String registerId;
/** 등록 일시 */
private String regDt;
/** 최종 변경자 계정ID */
private String updusrId;
/** 최종 변경 일시 */
private String updtDt;
public long getMappingId() { return mappingId; }
public void setMappingId(long mappingId) { this.mappingId = mappingId; }
@ -69,16 +59,4 @@ public class JobMappingVO implements Serializable {
public String getRm() { return rm; }
public void setRm(String rm) { this.rm = rm; }
public String getRegisterId() { return registerId; }
public void setRegisterId(String registerId) { this.registerId = registerId; }
public String getRegDt() { return regDt; }
public void setRegDt(String regDt) { this.regDt = regDt; }
public String getUpdusrId() { return updusrId; }
public void setUpdusrId(String updusrId) { this.updusrId = updusrId; }
public String getUpdtDt() { return updtDt; }
public void setUpdtDt(String updtDt) { this.updtDt = updtDt; }
}

406
src/main/java/egovframework/com/cmm/privacy/auditlog/PersonalDataAccessLogController.java
View File

@ -1,406 +0,0 @@
package egovframework.com.cmm.privacy.auditlog;
import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.util.EgovUserDetailsHelper;
import egovframework.com.utl.sim.service.EgovFileScrty;
import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
/**
* 개인정보 접속기록 조회·다운로드 컨트롤러 — 개인정보보호 기능개선 사업(SFR-004 / SER-002 / #47).
*
* <p>{@code PERSONAL_DATA_ACCESS_LOG}(#30) 적재분을 접속자ID·업무유형·처리대상·IP·처리구분·
* 처리결과·기간으로 복합 검색한다(#41 백엔드 연계). 화면:
* {@code /WEB-INF/jsp/site/mnt/sec/accessLog/list.jsp}</p>
*
* <p><b>다운로드(#42):</b> 사유 입력이 필수이며 미입력 시 400으로 차단하고 파일을 열지 않는다.
* 다운로드자·일시·IP·사유·건수는 {@code PDAL_DOWNLOAD_HISTORY}에 적재된다
* ({@link AccessLogDownloadService}). 개인정보 본문은 이력에 남기지 않는다.</p>
*
* <p><b>접근통제:</b> 인터셉터 3단 중 ①인증판정이 비활성이고 ②③은 fail-open 이라
* /mnt 하위라도 무인증 노출이 가능하므로, {@link #handlerUser()} 로 화면·엔드포인트
* 단에서 직접 판정한다(LoginFailHistoryController 와 동일 방식).</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.06 URP 최초 생성 (개인정보보호 SFR-004 #47)
* </pre>
*/
@Controller
public class PersonalDataAccessLogController {
private static final String LOGIN_REDIRECT = "redirect:/uat/uia/egovLoginUsr.do";
@Resource(name = "personalDataAccessLogSearchService")
private PersonalDataAccessLogSearchService personalDataAccessLogSearchService;
@Resource(name = "accessLogDownloadService")
private AccessLogDownloadService accessLogDownloadService;
@Resource(name = "personalDataAccessLogSearchDAO")
private PersonalDataAccessLogSearchDAO personalDataAccessLogSearchDAO;
@Resource(name = "accessLogDownloadJobService")
private AccessLogDownloadJobService accessLogDownloadJobService;
/**
* 개인정보 접속기록 조회 화면(서버 렌더링).
* 뷰: /WEB-INF/jsp/site/mnt/sec/accessLog/list.jsp
*/
@RequestMapping(value = "/mnt/sec/accessLog/listView.do")
public String listView(@ModelAttribute("personalDataAccessLogSearchVO") PersonalDataAccessLogSearchVO searchVO,
ModelMap model) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
// selectAccessLogList 내부에서 firstIndex/totalRecordCount 를 세팅한다.
List<PersonalDataAccessLogVO> list = personalDataAccessLogSearchService.selectAccessLogList(searchVO);
PaginationInfo paginationInfo = new PaginationInfo();
paginationInfo.setCurrentPageNo(searchVO.getPageIndex() < 1 ? 1 : searchVO.getPageIndex());
paginationInfo.setRecordCountPerPage(searchVO.getRecordCountPerPage());
paginationInfo.setPageSize(10);
paginationInfo.setTotalRecordCount(searchVO.getTotalRecordCount());
model.addAttribute("resultList", list);
model.addAttribute("paginationInfo", paginationInfo);
model.addAttribute("jobSeList", selectJobSeCodeList());
// 현재 검색조건 기준 조회/등록/수정/삭제 건수 — 목록을 넘겨보지 않고 처리행위를 판별하기 위함
model.addAttribute("dmlSummary", selectDmlSummary(searchVO));
// 내 다운로드 작업 목록(비동기) — 상태·진행률 확인 및 내려받기
model.addAttribute("dlJobList", selectMyDownloadJobs());
return "site/mnt/sec/accessLog/list";
}
/**
* 다운로드 <b>요청</b>(비동기) — 작업만 등록하고 즉시 목록으로 돌아온다.
*
* <p>대용량 조건에서 전체를 메모리에 올려 응답에 싣던 방식(아래 {@link #download})은
* OOM·요청 타임아웃 위험이 있어, 파일 생성은 백그라운드 워커가 맡는다.
* 사유는 여기서도 필수이며, 미입력이면 작업을 만들지 않는다.</p>
*/
@RequestMapping(value = "/mnt/sec/accessLog/downloadRequest.do")
public String downloadRequest(@ModelAttribute("personalDataAccessLogSearchVO") PersonalDataAccessLogSearchVO searchVO,
@RequestParam(value = "dlReason", required = false) String dlReason,
HttpServletRequest request, ModelMap model) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
return LOGIN_REDIRECT;
}
try {
accessLogDownloadJobService.requestJob(user.getId(),
ClientIpResolver.getClientIp(request), dlReason, searchVO);
} catch (IllegalArgumentException e) {
model.addAttribute("dlMessage", e.getMessage());
} catch (Exception e) {
model.addAttribute("dlMessage", "다운로드 요청 중 오류가 발생했습니다.");
}
// 검색조건을 유지한 채 목록으로 — 요청 직후 작업 목록에서 진행상태를 볼 수 있다.
return listView(searchVO, model);
}
/**
* 완료된 다운로드 파일 내려받기 — <b>요청자 본인만</b> 가능하다.
*
* <p>저장 파일은 암호화돼 있어 복호화 후 스트리밍한다. 임시 복호화본은 전송 직후 지운다.
* 실제 내려받은 시점의 사유·건수 이력은 기존 {@code PDAL_DOWNLOAD_HISTORY} 에 적재한다.</p>
*/
@RequestMapping(value = "/mnt/sec/accessLog/downloadFile.do")
public void downloadFile(@RequestParam("jobId") long jobId,
HttpServletRequest request, HttpServletResponse response) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
response.sendError(HttpServletResponse.SC_FORBIDDEN, "접근 권한이 없습니다.");
return;
}
AccessLogDownloadJobVO job = accessLogDownloadJobService.selectDownloadableJob(jobId, user.getId());
if (job == null) {
// 존재/소유/완료 여부를 구분해 알리지 않는다(작업ID 탐색 방지).
response.sendError(HttpServletResponse.SC_NOT_FOUND, "내려받을 수 있는 파일이 없습니다.");
return;
}
File plain = File.createTempFile("pdal-dl-", ".csv");
try {
if (!EgovFileScrty.decryptFile(job.getFilePath(), plain.getAbsolutePath())) {
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "파일을 열 수 없습니다.");
return;
}
String fileName = URLEncoder.encode(job.getFileNm(), "UTF-8");
response.setContentType("text/csv; charset=UTF-8");
response.setHeader("Content-Disposition",
"attachment; filename=\"" + fileName + "\"; filename*=UTF-8''" + fileName);
response.setHeader("Content-Transfer-Encoding", "binary");
response.setHeader("Content-Length", String.valueOf(plain.length()));
FileInputStream in = null;
OutputStream os = response.getOutputStream();
try {
in = new FileInputStream(plain);
byte[] buf = new byte[8192];
int len;
while ((len = in.read(buf)) > 0) {
os.write(buf, 0, len);
}
os.flush();
} finally {
if (in != null) {
try { in.close(); } catch (Exception ignore) { /* 무시 */ }
}
}
accessLogDownloadJobService.markDownloaded(jobId);
// 내려받은 사실을 기존 다운로드 이력에도 남긴다(사유·건수 증빙 일원화).
accessLogDownloadService.recordDownloadHistory(user.getId(), ClientIpResolver.getClientIp(request),
job.getDlReason(), job.getSearchCond(), job.getDoneCnt());
} finally {
// 복호화 임시본을 남기지 않는다.
if (plain.exists() && !plain.delete()) {
plain.deleteOnExit();
}
}
}
/**
* 내 다운로드 작업의 <b>상태만</b> 돌려주는 폴링 전용 엔드포인트(#47 후속).
*
* <p><b>왜 따로 뒀나:</b> 종전 화면은 진행률을 보려고 목록 화면 전체를 5초마다 다시 열었다.
* 그런데 이 화면은 접속기록 수집 화이트리스트({@code /mnt/sec/**}) 안이라 <u>새로고침 한 번이
* 접속기록 1행</u>이 된다. 즉 폴링이 도는 동안 감사로그가 분당 12행씩 자기 자신을 기록했고,
* 이는 정기점검·비정상접근 탐지(SER-002)의 신호를 그대로 오염시킨다. 상태 조회를 별도 경로로
* 빼고 그 경로를 {@code excludePatterns} 에 넣어 <b>수집 대상에서 제외</b>한다.</p>
*
* <p><b>본문 원칙:</b> 개인정보는커녕 검색조건도 싣지 않는다. 작업ID·상태·진행률·건수와
* 실패사유뿐이며, 모두 <u>본인 작업</u>에 한정된다({@code selectMyJobs(본인ID)}).</p>
*
* <p>형식은 한 줄 1작업의 {@code |} 구분 텍스트다 — 이 스택(Spring 3.0.5)에 JSON 메시지
* 컨버터를 새로 물리지 않고도 확실히 동작하며, 파싱이 단순해 화면 쪽 실패 여지가 적다.</p>
*/
@RequestMapping(value = "/mnt/sec/accessLog/jobStatus.do")
public void jobStatus(HttpServletResponse response) throws Exception {
response.setContentType("text/plain; charset=UTF-8");
response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
response.setHeader("Pragma", "no-cache");
LoginVO user = handlerUser();
if (user == null) {
// 화면이 재로그인으로 유도하도록 상태코드만 알린다(본문 없음).
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
return;
}
StringBuilder sb = new StringBuilder(256);
List<AccessLogDownloadJobVO> list = accessLogDownloadJobService.selectMyJobs(user.getId(), 10);
if (list != null) {
for (AccessLogDownloadJobVO j : list) {
sb.append(j.getJobId()).append('|')
.append(nvl(j.getStatus())).append('|')
.append(j.getProgressPct()).append('|')
.append(j.getDoneCnt()).append('|')
.append(j.getTotalCnt()).append('|')
.append(oneLine(j.getErrMsg())).append('\n');
}
}
response.getWriter().write(sb.toString());
response.getWriter().flush();
}
/** 구분자·개행이 섞이면 화면 파싱이 깨지므로 한 줄로 눌러 담는다. */
private String oneLine(String v) {
if (v == null) {
return "";
}
return v.replace('|', '/').replace('\r', ' ').replace('\n', ' ');
}
private String nvl(String v) {
return (v == null) ? "" : v;
}
/** 내 다운로드 작업 목록(최근 10건). 조회 실패해도 화면은 떠야 하므로 빈 목록으로 fail-safe. */
private List<AccessLogDownloadJobVO> selectMyDownloadJobs() {
try {
LoginVO user = handlerUser();
if (user == null) {
return new ArrayList<AccessLogDownloadJobVO>();
}
List<AccessLogDownloadJobVO> list = accessLogDownloadJobService.selectMyJobs(user.getId(), 10);
return (list == null) ? new ArrayList<AccessLogDownloadJobVO>() : list;
} catch (Exception e) {
return new ArrayList<AccessLogDownloadJobVO>();
}
}
/**
* 접속기록 다운로드(CSV) — 동기 방식(기존 #42). 사유 필수 + 다운로드 이력 적재.
*
* <p><b>주의:</b> 조건 전체를 메모리에 올린다. 대용량은 위 {@link #downloadRequest} 비동기 경로를
* 쓴다. 이 엔드포인트는 소량 즉시 다운로드와 기존 링크 호환을 위해 남겨둔다.</p>
*/
@RequestMapping(value = "/mnt/sec/accessLog/download.do")
public void download(@ModelAttribute("personalDataAccessLogSearchVO") PersonalDataAccessLogSearchVO searchVO,
@RequestParam(value = "dlReason", required = false) String dlReason,
HttpServletRequest request, HttpServletResponse response) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
response.sendError(HttpServletResponse.SC_FORBIDDEN, "접근 권한이 없습니다.");
return;
}
List<PersonalDataAccessLogVO> list;
try {
list = accessLogDownloadService.downloadAccessLog(user.getId(),
ClientIpResolver.getClientIp(request), dlReason, searchVO);
} catch (IllegalArgumentException e) {
// 사유 미입력 등 차단 — 다운로드를 열지 않고 오류만 응답
response.sendError(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
return;
}
String fileName = URLEncoder.encode(
"개인정보접속기록_" + new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + ".csv", "UTF-8");
response.setContentType("text/csv; charset=UTF-8");
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"; filename*=UTF-8''" + fileName);
response.setHeader("Content-Transfer-Encoding", "binary");
OutputStream os = response.getOutputStream();
os.write(0xEF); os.write(0xBB); os.write(0xBF); // UTF-8 BOM (엑셀 한글 호환)
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
pw.println("로그번호,접속일시,접속자ID,처리자구분,접속IP,수행업무코드,수행업무명,처리구분,처리대상ID,처리대상범위,처리결과,무결성해시");
if (list != null) {
for (PersonalDataAccessLogVO log : list) {
pw.println(log.getLogId() + "," + csv(log.getConectDt()) + "," + csv(log.getConectId())
+ "," + csv(log.getUserSe()) + "," + csv(log.getConectIp())
+ "," + csv(log.getJobSeCode()) + "," + csv(log.getJobSeNm())
+ "," + csv(dmlLabel(log.getDmlGubun())) + "," + csv(log.getTrgetId())
+ "," + csv(log.getTrgetCn()) + "," + csv(resultLabel(log.getProcessResult()))
+ "," + csv(log.getHashVal()));
}
}
pw.flush();
}
/**
* 검색조건 드롭다운용 업무유형 목록.
*
* <p>2026-08-07 소스 변경: 종전에는 PDAL_JOB_MAPPING(서비스 클래스·메서드 매핑)을 읽었으나,
* 수집이 관리자 화면 메뉴 기반({@code MenuAccessLogInterceptor})으로 바뀌어 업무유형이
* 메뉴에서 나온다. 매핑 테이블을 보면 실제 적재값과 어긋난 선택지가 떠 검색 결과가
* 항상 0건이 되므로, 적재된 로그의 DISTINCT 업무유형을 소스로 쓴다.</p>
*
* <p>조회 실패해도 화면은 떠야 하므로 빈 목록으로 fail-safe.</p>
*/
private List<JobMappingVO> selectJobSeCodeList() {
try {
List<JobMappingVO> list = personalDataAccessLogSearchDAO.selectJobSeCodeList();
return (list == null) ? new ArrayList<JobMappingVO>() : list;
} catch (Exception e) {
// 드롭다운 소스일 뿐이므로 조회 실패가 화면 전체를 막지 않도록 한다.
return new ArrayList<JobMappingVO>();
}
}
/**
* 현재 검색조건 기준 처리구분별 건수 요약.
*
* <p>"이 취급자가 개인정보를 조회만 했는지, 수정·삭제까지 했는지"를 목록을 넘겨보지 않고
* 판별하기 위한 값이다. 화면이 {@code ${dmlSummary.S}} 처럼 바로 꺼내 쓰도록
* S/I/U/D 네 키를 항상 채워 반환한다(해당 기록이 없으면 0).</p>
*
* <p>집계 실패가 화면 전체를 막지 않도록 0으로 채운 맵을 돌려준다(fail-safe).</p>
*/
private Map<String, Long> selectDmlSummary(PersonalDataAccessLogSearchVO searchVO) {
Map<String, Long> summary = new LinkedHashMap<String, Long>();
summary.put("S", Long.valueOf(0L));
summary.put("I", Long.valueOf(0L));
summary.put("U", Long.valueOf(0L));
summary.put("D", Long.valueOf(0L));
try {
List<Map<String, Object>> rows = personalDataAccessLogSearchDAO.selectAccessLogDmlSummary(searchVO);
if (rows == null) {
return summary;
}
for (Map<String, Object> row : rows) {
Object code = row.get("dmlGubun");
Object cnt = row.get("cnt");
if (code == null || !summary.containsKey(String.valueOf(code))) {
// S/I/U/D 외 값(레거시 적재분 등)은 요약에 넣지 않는다 — 목록에서 확인한다.
continue;
}
long v = (cnt instanceof Number) ? ((Number) cnt).longValue() : 0L;
summary.put(String.valueOf(code), Long.valueOf(v));
}
} catch (Exception e) {
// 요약은 보조 정보다 — 실패해도 목록은 떠야 한다.
return summary;
}
return summary;
}
/** CSV 셀 이스케이프(구분자·따옴표·개행 방어). */
private String csv(String v) {
if (v == null) {
return "";
}
String s = v.replace("\"", "\"\"");
return "\"" + s.replace("\r", " ").replace("\n", " ") + "\"";
}
private String dmlLabel(String code) {
if ("S".equals(code)) return "조회";
if ("I".equals(code)) return "등록";
if ("U".equals(code)) return "수정";
if ("D".equals(code)) return "삭제";
return code;
}
private String resultLabel(String code) {
if ("S".equals(code)) return "성공";
if ("F".equals(code)) return "실패/차단";
return code;
}
/**
* 취급자 영역(/mnt) 인증·구분 판정.
*
* @return 인증된 업무사용자(USR) LoginVO, 그 외에는 null
*/
private LoginVO handlerUser() {
if (!Boolean.TRUE.equals(EgovUserDetailsHelper.isAuthenticated())) {
return null;
}
Object o = EgovUserDetailsHelper.getAuthenticatedUser();
if (!(o instanceof LoginVO)) {
return null;
}
LoginVO loginVO = (LoginVO) o;
return "USR".equals(loginVO.getUserSe()) ? loginVO : null;
}
}

26
src/main/java/egovframework/com/cmm/privacy/auditlog/PersonalDataAccessLogSearchDAO.java
View File

@ -1,7 +1,6 @@
package egovframework.com.cmm.privacy.auditlog;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Repository;
@ -31,29 +30,4 @@ public class PersonalDataAccessLogSearchDAO extends EgovComAbstractDAO {
Object cnt = selectByPk("PersonalDataAccessLogDAO.selectAccessLogListCount", searchVO);
return cnt == null ? 0 : ((Integer) cnt).intValue();
}
/**
* 조회화면 '수행업무' 드롭다운 소스 — 실제 적재된 (업무코드, 업무명) 목록.
*
* <p>수집이 관리자 화면 메뉴 기반으로 바뀌면서 업무유형은 메뉴에서 나온다(2026-08-07).
* PDAL_JOB_MAPPING 을 보면 적재값과 어긋난 선택지가 뜨므로 적재분에서 직접 뽑는다.
* 반환 타입은 (jobSeCode, jobSeNm) 두 프로퍼티만 쓰는 용도로 {@link JobMappingVO}를 재사용한다.</p>
*/
@SuppressWarnings("unchecked")
public List<JobMappingVO> selectJobSeCodeList() {
return list("PersonalDataAccessLogDAO.selectJobSeCodeList", null);
}
/**
* 현재 검색조건 기준 처리구분(S/I/U/D)별 건수.
*
* <p>"이 취급자가 개인정보를 조회만 했는지, 수정·삭제까지 했는지"를 목록을 넘겨보지 않고
* 확인하기 위한 집계다. 검색조건은 목록 조회와 동일하다.</p>
*
* @return {dmlGubun, cnt} 맵 목록. 해당 구분의 기록이 없으면 그 행 자체가 없다.
*/
@SuppressWarnings("unchecked")
public List<Map<String, Object>> selectAccessLogDmlSummary(PersonalDataAccessLogSearchVO searchVO) {
return list("PersonalDataAccessLogDAO.selectAccessLogDmlSummary", searchVO);
}
}

84
src/main/java/egovframework/com/cmm/privacy/auditlog/PersonalDataAccessLogSearchVO.java
View File

@ -10,19 +10,7 @@ import java.io.Serializable;
* 본 VO는 접속자 ID·업무유형·처리대상·IP·처리구분·처리결과·기간을 복합 검색조건으로 제공하며,
* {@code IDX_PDAL_01(CONECT_ID, CONECT_DT)} 인덱스로 접속자 ID 검색 결함을 해소한다.</p>
*
* <p>화면: {@code /WEB-INF/jsp/site/mnt/sec/accessLog/list.jsp} (#47 연계 완료)</p>
*
* <p><b>검색조건 정규화(2026-08-07).</b> 원본 입력값은 화면 재표시를 위해 그대로 두고,
* SQL 바인딩에는 아래 파생 getter를 쓴다. 이렇게 하면 MySQL/Oracle 두 sqlMap에
* 방언 차이({@code CONCAT} vs {@code ||})를 새로 만들지 않아도 된다.</p>
* <ul>
* <li>{@link #getToDtParam()} — <b>종료일 경계 결함 수정.</b> 종전에는 {@code CONECT_DT &lt;= '2026-08-07'}이
* {@code 2026-08-07 00:00:00}으로 해석돼 <b>종료일 하루가 통째로 누락</b>됐다(실측: 8/6~8/7 검색이
* 39건 중 38건만 반환). 날짜만 입력하면 {@code 23:59:59}를 붙여 당일을 포함시킨다.</li>
* <li>{@link #getConectIdLike()} 등 — 전방일치 검색. 종전 완전일치는 ID 전체를 정확히 알아야 해서
* SFR-004-6(조회·검색)의 실효가 없었다. 전방일치는 {@code IDX_PDAL_01(CONECT_ID, CONECT_DT)}
* 인덱스를 그대로 탄다(중간일치 {@code %x%}는 인덱스를 못 써서 채택하지 않았다).</li>
* </ul>
* <p>화면(JSP)은 본 작업 범위 밖이다 — 백엔드까지 구현. (TODO: 화면 #47 연계)</p>
*
* @author arko-privacy-auditlog (Fork B - 5차)
* @since 2026-07-21
@ -93,74 +81,4 @@ public class PersonalDataAccessLogSearchVO implements Serializable {
public int getTotalRecordCount() { return totalRecordCount; }
public void setTotalRecordCount(int totalRecordCount) { this.totalRecordCount = totalRecordCount; }
// =====================================================================
// SQL 바인딩용 파생값 (2026-08-07) — setter 없음(읽기 전용).
// 원본 필드는 화면 재표시용으로 건드리지 않는다.
// =====================================================================
/** 날짜만 입력된 값인지(yyyy-MM-dd). */
private boolean isDateOnly(String v) {
return v != null && v.trim().length() == 10;
}
/**
* 조회 시작일시 바인딩값. 날짜만 입력하면 그날 {@code 00:00:00}부터.
* (시작 경계는 문자열 비교로도 동일하지만, 종료와 대칭을 맞춰 의도를 드러낸다.)
*/
public String getFromDtParam() {
if (fromDt == null) {
return null;
}
String v = fromDt.trim();
return isDateOnly(v) ? v + " 00:00:00" : v;
}
/**
* 조회 종료일시 바인딩값. 날짜만 입력하면 그날 {@code 23:59:59}까지 포함한다.
*
* <p>이 보정이 없으면 종료일 당일 기록이 전부 빠진다 — 화면 안내가 {@code yyyy-MM-dd} 입력을
* 권장하므로 반드시 밟게 되는 함정이었다.</p>
*/
public String getToDtParam() {
if (toDt == null) {
return null;
}
String v = toDt.trim();
return isDateOnly(v) ? v + " 23:59:59" : v;
}
/** LIKE 이스케이프 문자. SQL 의 {@code ESCAPE '!'} 와 반드시 짝을 이룬다. */
private static final String LIKE_ESCAPE = "!";
/**
* LIKE 전방일치 패턴으로 변환한다. 사용자가 입력한 {@code %}/{@code _}는 와일드카드가 아니라
* 문자 그대로 찾도록 이스케이프한다 — 안 하면 {@code %} 한 글자로 전건이 조회된다.
*
* <p>이스케이프 문자로 백슬래시가 아닌 {@code !}를 쓴다. MySQL 문자열 리터럴에서 {@code '\'}는
* 뒤따르는 따옴표를 이스케이프해 SQL 자체가 깨지므로 {@code ESCAPE '\'}를 쓸 수 없고,
* MySQL만 {@code '\\'}로 적으면 Oracle 쌍과 표현이 갈린다. {@code !}는 두 방언 모두 동일하다.</p>
*/
private String toPrefixLike(String v) {
if (v == null) {
return null;
}
String s = v.trim();
if (s.length() == 0) {
return null;
}
s = s.replace(LIKE_ESCAPE, LIKE_ESCAPE + LIKE_ESCAPE)
.replace("%", LIKE_ESCAPE + "%")
.replace("_", LIKE_ESCAPE + "_");
return s + "%";
}
/** 접속자ID 전방일치 패턴. */
public String getConectIdLike() { return toPrefixLike(conectId); }
/** 처리대상 식별자 전방일치 패턴. */
public String getTrgetIdLike() { return toPrefixLike(trgetId); }
/** 접속IP 전방일치 패턴 — 대역 검색용(예: {@code 192.168.} 입력 시 해당 대역 전체). */
public String getConectIpLike() { return toPrefixLike(conectIp); }
}

32
src/main/java/egovframework/com/cmm/privacy/auditlog/PersonalDataLogAspect.java
View File

@ -23,16 +23,6 @@ import egovframework.com.cmm.LoginVO;
/**
* 개인정보 접속기록 수집 Aspect (개발항목 #31, SFR-004 / DBR-001 / SER-002).
*
* <p><b>[2026-08-07 사용 중단]</b> 이 Aspect 는 더 이상 적용되지 않는다.
* {@code context-syslogaop.xml}의 {@code <aop:config>}가 주석 처리됐고, 접속기록 수집은
* {@code egovframework.com.cmm.privacy.interceptor.MenuAccessLogInterceptor}가 담당한다.
* <b>중단 사유:</b> 서비스 impl 을 가로채는 방식은 관리자 화면과 프론트 화면이 같은 서비스
* 메서드를 공유하는 구조에서 호출 화면을 구분하지 못한다. 그 결과 무인증 프론트 방문이
* 접속자ID {@code ANONYMOUS}, 수행업무 "재능나눔 회원관리"로 적재됐다. 요구사항(SFR-004)은
* "개인정보<u>취급자</u>가 무슨 업무를 처리했는지"이므로, 요청 URL 로 관리자 화면을 식별하고
* 메뉴명을 수행업무로 남기는 인터셉터 방식으로 전환했다.
* 클래스는 판단 근거·복원 경로 보존을 위해 남겨둔다(빈은 등록되나 어떤 pointcut 에도 걸리지 않음).</p>
*
* <p><b>한정 수집:</b> {@code COMTNSYSLOG}의 select* 전 서비스 대상 방식이 아니라,
* 개인정보 처리 서비스로 한정한 pointcut(스키마 기반 {@code <aop:config>}, context-syslogaop.xml)에만
* 적용된다. 가로챈 메서드는 업무유형 매핑 테이블({@link JobMappingResolver}, #32)로 업무코드를 얻고,
@ -42,16 +32,6 @@ import egovframework.com.cmm.LoginVO;
* <p><b>본문 미적재 원칙:</b> 처리 파라미터(개인정보 본문)는 로그에 담지 않는다. 식별자(TRGET_ID)만
* 베스트에포트로 취득한다(#36).</p>
*
* <p><b>로그인 세션 한정(2026-08-07):</b> 세션에 {@code loginVO}가 없는 요청은 <b>수집하지 않는다</b>.
* 종전에는 접속자ID를 {@code ANONYMOUS}로 적재했다. 근거는 두 가지다.
* ① 제안요청서(붙임2) SFR-004 정의가 "개인정보<u>취급자</u> 접속 및 업무처리 기록 관리"이고
* 세부내용 첫 항목도 "개인정보취급자의 접속기록을 저장·관리"로, 비로그인 상태(정보주체 본인의
* 가입·실명확인 등)는 대상이 아니다(SER-002·안전성 확보조치 기준 제8조도 동일 기준).
* ② 비정상접근 탐지(#35)가 {@code GROUP BY CONECT_ID} 기반이라, 모든 익명 요청이
* {@code ANONYMOUS} 한 계정으로 뭉쳐 계정공유의심(상이 IP 다수)·대량조회에 상시 오탐을 만든다.
* 제외되는 대표 경로: 회원가입({@code insert*}), 실명확인({@code MberSsnServiceImpl}),
* 휴면해제, 계정잠금 해제, 인증번호 발송. 이 경로들의 추적은 인증 실패 이력(#22)이 담당한다.</p>
*
* <p><b>수집 범위(#36):</b> 회원·업체 2개 지점 한정에서 전 개인정보 처리 서비스로 확장.
* pointcut 대상은 {@code context-syslogaop.xml}에 개인정보 취급 서비스 impl만 열거(과수집 방지).
* 신규 화면 추가 시에는 이 pointcut(또는 대상 서비스에 편입)과 업무유형 매핑({@link JobMappingResolver})만
@ -76,6 +56,7 @@ public class PersonalDataLogAspect {
private static final Log LOG = LogFactory.getLog(PersonalDataLogAspect.class);
private static final String DT_FORMAT = "yyyy-MM-dd HH:mm:ss";
private static final String ANONYMOUS = "ANONYMOUS";
@Resource(name = "jobMappingResolver")
private JobMappingResolver jobMappingResolver;
@ -114,13 +95,6 @@ public class PersonalDataLogAspect {
return;
}
// 로그인 세션이 없는 요청은 취급자 접속기록이 아니므로 수집하지 않는다(사유는 클래스 Javadoc).
// 매핑 조회보다 먼저 판정해 불필요한 작업을 하지 않는다.
LoginVO login = currentLogin(request);
if (login == null || !notBlank(login.getId())) {
return;
}
String targetSimpleName = pjp.getTarget().getClass().getSimpleName();
String methodName = pjp.getSignature().getName();
@ -142,8 +116,10 @@ public class PersonalDataLogAspect {
dmlGubun = JobMappingResolver.deriveDmlGubun(methodName);
}
LoginVO login = currentLogin(request);
PersonalDataAccessLogVO vo = new PersonalDataAccessLogVO();
vo.setConectId(login.getId());
vo.setConectId(login != null && notBlank(login.getId()) ? login.getId() : ANONYMOUS);
vo.setConectDt(new SimpleDateFormat(DT_FORMAT).format(new Date()));
vo.setConectIp(safeIp(request));
vo.setJobSeCode(jobSeCode);

4
src/main/java/egovframework/com/cmm/privacy/author/AuthorChangeHistoryVO.java
View File

@ -20,8 +20,6 @@ public class AuthorChangeHistoryVO implements Serializable {
private String trgetUniqId;
/** 변경 대상자 계정ID */
private String trgetId;
/** 변경 대상자 성명 — COMTNEMPLYRINFO 조인 표기용(비영속) */
private String trgetNm;
/** 변경구분 G:부여 R:회수 M:변경 */
private String chgSeCode;
private String beforeAuthor;
@ -56,8 +54,6 @@ public class AuthorChangeHistoryVO implements Serializable {
public void setTrgetUniqId(String trgetUniqId) { this.trgetUniqId = trgetUniqId; }
public String getTrgetId() { return trgetId; }
public void setTrgetId(String trgetId) { this.trgetId = trgetId; }
public String getTrgetNm() { return trgetNm; }
public void setTrgetNm(String trgetNm) { this.trgetNm = trgetNm; }
public String getChgSeCode() { return chgSeCode; }
public void setChgSeCode(String chgSeCode) { this.chgSeCode = chgSeCode; }
public String getBeforeAuthor() { return beforeAuthor; }

85
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistDownloadJobDAO.java
View File

@ -1,85 +0,0 @@
package egovframework.com.cmm.privacy.author;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 권한변경 이력 CSV 비동기 다운로드 작업(AUTHOR_HIST_DOWNLOAD_JOB) DAO.
*
* <p>개인정보보호 기능개선 사업(SFR-001 / 개발항목 #6). statement 는
* {@code PrivacyAuthorHistDownloadJob_SQL_Mysql.xml}
* (namespace {@code AuthorHistDownloadJobDAO}). 신규 sqlMap 이므로
* {@code sql-map-config-mysql-0-site.xml} 등록이 필요하다.</p>
*
* @since 2026-08-10
*/
@Repository("authorHistDownloadJobDAO")
public class AuthorHistDownloadJobDAO extends EgovComAbstractDAO {
/** 요청 등록. 채번된 JOB_ID 는 selectKey 로 vo.jobId 에 채워진다. */
public long insertJob(AuthorHistDownloadJobVO vo) {
insert("AuthorHistDownloadJobDAO.insertJob", vo);
return vo.getJobId();
}
public AuthorHistDownloadJobVO selectJob(long jobId) {
return (AuthorHistDownloadJobVO) selectByPk("AuthorHistDownloadJobDAO.selectJob", Long.valueOf(jobId));
}
/** 요청자 본인의 최근 작업 목록. */
@SuppressWarnings("unchecked")
public List<AuthorHistDownloadJobVO> selectJobListByRequester(String requesterId, int limitCnt) {
Map<String, Object> param = new HashMap<String, Object>();
param.put("requesterId", requesterId);
param.put("limitCnt", Integer.valueOf(limitCnt));
return list("AuthorHistDownloadJobDAO.selectJobListByRequester", param);
}
/** 대기 상태의 가장 오래된 작업 ID. 없으면 null. */
public Long selectNextWaitingJobId() {
return (Long) selectByPk("AuthorHistDownloadJobDAO.selectNextWaitingJobId", null);
}
/**
* 대기건 선점. 영향행수 1이면 이 워커가 소유권을 얻은 것이다.
* (WHERE 에 STATUS='W' 가 걸려 있어 동시 선점 시 한쪽만 성공한다.)
*/
public boolean claimJob(long jobId) {
return update("AuthorHistDownloadJobDAO.claimJob", Long.valueOf(jobId)) == 1;
}
public void updateProgress(AuthorHistDownloadJobVO vo) {
update("AuthorHistDownloadJobDAO.updateProgress", vo);
}
public void updateSuccess(AuthorHistDownloadJobVO vo) {
update("AuthorHistDownloadJobDAO.updateSuccess", vo);
}
public void updateFail(AuthorHistDownloadJobVO vo) {
update("AuthorHistDownloadJobDAO.updateFail", vo);
}
public void updateDownloaded(long jobId) {
update("AuthorHistDownloadJobDAO.updateDownloaded", Long.valueOf(jobId));
}
@SuppressWarnings("unchecked")
public List<AuthorHistDownloadJobVO> selectExpiredJobs() {
return list("AuthorHistDownloadJobDAO.selectExpiredJobs", null);
}
public void updatePurged(long jobId) {
update("AuthorHistDownloadJobDAO.updatePurged", Long.valueOf(jobId));
}
/** WAS 비정상 종료로 'R' 에 멈춘 작업을 대기로 되돌린다(기동 시 1회). */
public int resetRunningJobs() {
return update("AuthorHistDownloadJobDAO.resetRunningJobs", null);
}
}

38
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistDownloadJobService.java
View File

@ -1,38 +0,0 @@
package egovframework.com.cmm.privacy.author;
import java.util.List;
/**
* 권한변경 이력 CSV 비동기 다운로드 작업 서비스 (SFR-001 / 개발항목 #6).
*
* <p>요청은 작업만 등록하고 즉시 반환한다. 파일 생성은
* {@link AuthorHistDownloadJobWorker} 가 백그라운드에서 맡는다.</p>
*
* @since 2026-08-10
*/
public interface AuthorHistDownloadJobService {
/**
* 다운로드 요청 등록.
*
* @param requesterId 요청자 계정ID
* @param requesterIp 요청 IP
* @param reason 다운로드 사유(필수 — 없으면 IllegalArgumentException)
* @param searchVO 다운로드 대상 검색조건
* @return 채번된 작업 ID
*/
long requestJob(String requesterId, String requesterIp, String reason,
AuthorChangeHistoryVO searchVO) throws Exception;
/** 요청자 본인의 최근 작업 목록. */
List<AuthorHistDownloadJobVO> selectMyJobs(String requesterId, int limitCnt) throws Exception;
/** 내려받기 가능한 작업 조회. 본인 것이 아니거나 미완료/파일 없음이면 null. */
AuthorHistDownloadJobVO selectDownloadableJob(long jobId, String requesterId) throws Exception;
/** 내려받은 횟수·일시 기록. */
void markDownloaded(long jobId) throws Exception;
/** 만료 파일 파기(배치). 파일 삭제 + 상태 X. */
int purgeExpiredJobs() throws Exception;
}

169
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistDownloadJobServiceImpl.java
View File

@ -1,169 +0,0 @@
package egovframework.com.cmm.privacy.author;
import java.io.File;
import java.util.List;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* 권한변경 이력 CSV 비동기 다운로드 작업 서비스 구현 (SFR-001 / 개발항목 #6).
*
* <p><b>보관 최소화:</b> 생성 파일은 취급자 권한 변동 내역이 담긴 개인정보 파일이라 오래 두지 않는다.
* {@link #expireDays}(기본 3일) 경과분은 파기 배치가 파일을 지우고 상태를 X 로 바꾼다.
* 권한이력 본체의 보관기간(기본 1,095일)과는 무관한 '내려받기용 사본'의 수명이다.</p>
*
* <p><b>권한 재검증:</b> 내려받기는 <u>요청자 본인만</u> 가능하다. 작업ID는 연속 정수라
* 추측이 쉬우므로, 조회 단계에서 요청자ID 일치를 확인하지 않으면 남의 파일이 새어나간다.</p>
*
* @since 2026-08-10
*/
@Service("authorHistDownloadJobService")
public class AuthorHistDownloadJobServiceImpl implements AuthorHistDownloadJobService {
private static final Log LOG = LogFactory.getLog(AuthorHistDownloadJobServiceImpl.class);
@Resource(name = "authorHistDownloadJobDAO")
private AuthorHistDownloadJobDAO jobDAO;
/** 생성 파일 보관일수. 접속기록 비동기 다운로드와 같은 설정값을 공유한다(기본 3일). */
@Value("${Globals.privacyDownloadExpireDays:3}")
private int expireDays = 3;
@Override
public long requestJob(String requesterId, String requesterIp, String reason,
AuthorChangeHistoryVO searchVO) throws Exception {
// 사유 필수 — 종전 동기 다운로드와 동일한 차단 기준을 유지한다.
if (reason == null || reason.trim().length() == 0) {
throw new IllegalArgumentException("다운로드 사유는 필수입니다.");
}
if (requesterId == null || requesterId.trim().length() == 0) {
throw new IllegalArgumentException("요청자를 확인할 수 없습니다.");
}
if (searchVO == null) {
searchVO = new AuthorChangeHistoryVO();
}
AuthorHistDownloadJobVO job = new AuthorHistDownloadJobVO();
job.setRequesterId(requesterId);
job.setRequesterIp(requesterIp);
job.setDlReason(cut(reason.trim(), 500));
job.setSearchCond(cut(summarizeCond(searchVO), 1000));
job.setCondTrgetId(searchVO.getSearchTrgetId());
job.setCondChangerId(searchVO.getSearchChangerId());
job.setCondChgSeCode(searchVO.getSearchChgSeCode());
job.setCondFromDt(searchVO.getFromDt());
job.setCondToDt(searchVO.getToDt());
job.setExpireDays(expireDays < 1 ? 3 : expireDays);
long jobId = jobDAO.insertJob(job);
LOG.info("[개인정보/SFR-001-6] 권한이력 다운로드 작업 등록 — jobId=" + jobId + ", 요청자=" + requesterId
+ ", 조건=" + job.getSearchCond());
return jobId;
}
@Override
public List<AuthorHistDownloadJobVO> selectMyJobs(String requesterId, int limitCnt) throws Exception {
if (requesterId == null || requesterId.trim().length() == 0) {
return java.util.Collections.emptyList();
}
return jobDAO.selectJobListByRequester(requesterId, limitCnt < 1 ? 10 : limitCnt);
}
@Override
public AuthorHistDownloadJobVO selectDownloadableJob(long jobId, String requesterId) throws Exception {
AuthorHistDownloadJobVO job = jobDAO.selectJob(jobId);
if (job == null) {
return null;
}
// 본인 확인 — 작업ID 추측으로 남의 파일을 가져가는 것을 막는다.
if (requesterId == null || !requesterId.equals(job.getRequesterId())) {
LOG.warn("[개인정보/SFR-001-6] 타인 다운로드 시도 차단 — jobId=" + jobId
+ ", 소유자=" + job.getRequesterId() + ", 요청자=" + requesterId);
return null;
}
if (!job.isDownloadable()) {
return null;
}
File f = new File(job.getFilePath());
if (!f.exists() || !f.isFile()) {
LOG.warn("[개인정보/SFR-001-6] 파일 없음(파기됐거나 유실) — jobId=" + jobId);
return null;
}
return job;
}
@Override
public void markDownloaded(long jobId) throws Exception {
jobDAO.updateDownloaded(jobId);
}
@Override
public int purgeExpiredJobs() throws Exception {
List<AuthorHistDownloadJobVO> expired = jobDAO.selectExpiredJobs();
int purged = 0;
if (expired != null) {
for (int i = 0; i < expired.size(); i++) {
AuthorHistDownloadJobVO job = expired.get(i);
String path = job.getFilePath();
if (path != null && path.length() > 0) {
try {
File f = new File(path);
if (f.exists() && !f.delete()) {
// 삭제 실패는 개인정보 파일이 남는다는 뜻이라 조용히 넘기지 않는다.
LOG.error("[개인정보/SFR-001-6] 다운로드 파일 삭제 실패 — jobId=" + job.getJobId()
+ ", path=" + path + " (수동 삭제 필요)");
continue;
}
} catch (Exception e) {
LOG.error("[개인정보/SFR-001-6] 다운로드 파일 삭제 중 예외 — jobId=" + job.getJobId(), e);
continue;
}
}
jobDAO.updatePurged(job.getJobId());
purged++;
}
}
LOG.info("[개인정보/SFR-001-6] 만료 권한이력 다운로드 파일 파기 완료 — " + purged + "건(보관 " + expireDays + "일)");
return purged;
}
/** 검색조건을 요약(표시용). */
private String summarizeCond(AuthorChangeHistoryVO vo) {
StringBuilder sb = new StringBuilder();
appendCond(sb, "대상자", vo.getSearchTrgetId());
appendCond(sb, "변경자", vo.getSearchChangerId());
appendCond(sb, "변경구분", chgSeLabel(vo.getSearchChgSeCode()));
appendCond(sb, "시작일", vo.getFromDt());
appendCond(sb, "종료일", vo.getToDt());
return sb.length() == 0 ? "(전체)" : sb.toString();
}
private void appendCond(StringBuilder sb, String key, String val) {
if (val != null && val.trim().length() > 0) {
if (sb.length() > 0) {
sb.append(", ");
}
sb.append(key).append("=").append(val.trim());
}
}
private String chgSeLabel(String code) {
if ("G".equals(code)) return "부여";
if ("R".equals(code)) return "회수";
if ("M".equals(code)) return "변경";
return code;
}
private static String cut(String s, int max) {
if (s == null) {
return null;
}
return (s.length() > max) ? s.substring(0, max) : s;
}
}

148
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistDownloadJobVO.java
View File

@ -1,148 +0,0 @@
package egovframework.com.cmm.privacy.author;
import java.io.Serializable;
/**
* 권한변경 이력 CSV 비동기 다운로드 작업(AUTHOR_HIST_DOWNLOAD_JOB) VO.
*
* <p>개인정보보호 기능개선 사업(SFR-001 / 개발항목 #6) — 대용량 다운로드를 요청 즉시 응답하고
* 백그라운드에서 파일을 만들기 위한 작업 한 건. 접속기록 쪽
* {@code AccessLogDownloadJobVO} 와 같은 패턴이며 검색조건 필드만 다르다.</p>
*
* <p><b>검색조건을 컬럼으로 보존하는 이유:</b> 백그라운드 워커는 요청 세션이 끝난 뒤 실행되므로
* 조건을 스스로 재현해야 한다. 담는 값은 식별자·코드·기간뿐이다.</p>
*
* @since 2026-08-10
*/
public class AuthorHistDownloadJobVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 상태: 대기 */
public static final String ST_WAIT = "W";
/** 상태: 생성중 */
public static final String ST_RUNNING = "R";
/** 상태: 완료(내려받기 가능) */
public static final String ST_SUCCESS = "S";
/** 상태: 실패 */
public static final String ST_FAIL = "F";
/** 상태: 파기(파일 삭제됨) */
public static final String ST_PURGED = "X";
private long jobId;
private String requesterId;
private String requesterIp;
private String dlReason;
private String searchCond;
// 조건 재현용. 프로퍼티명을 cond* 로 둔다 — getFTrgetId 처럼 '대문자1자+대문자' 형태면
// JavaBeans 인트로스펙션이 프로퍼티를 다르게 해석해 iBatis 바인딩이 조용히 실패한다.
private String condTrgetId;
private String condChangerId;
private String condChgSeCode;
private String condFromDt;
private String condToDt;
private String status;
private int totalCnt;
private int doneCnt;
private String fileNm;
private String filePath;
private long fileSize;
private String errMsg;
private int downloadCnt;
private String lastDlDt;
private String regDt;
private String startDt;
private String endDt;
private String expireDt;
/** 만료일(일). 서비스가 EXPIRE_DT 계산에 쓰는 값을 전달하기 위한 비영속 필드. */
private int expireDays;
public long getJobId() { return jobId; }
public void setJobId(long jobId) { this.jobId = jobId; }
public String getRequesterId() { return requesterId; }
public void setRequesterId(String requesterId) { this.requesterId = requesterId; }
public String getRequesterIp() { return requesterIp; }
public void setRequesterIp(String requesterIp) { this.requesterIp = requesterIp; }
public String getDlReason() { return dlReason; }
public void setDlReason(String dlReason) { this.dlReason = dlReason; }
public String getSearchCond() { return searchCond; }
public void setSearchCond(String searchCond) { this.searchCond = searchCond; }
public String getCondTrgetId() { return condTrgetId; }
public void setCondTrgetId(String condTrgetId) { this.condTrgetId = condTrgetId; }
public String getCondChangerId() { return condChangerId; }
public void setCondChangerId(String condChangerId) { this.condChangerId = condChangerId; }
public String getCondChgSeCode() { return condChgSeCode; }
public void setCondChgSeCode(String condChgSeCode) { this.condChgSeCode = condChgSeCode; }
public String getCondFromDt() { return condFromDt; }
public void setCondFromDt(String condFromDt) { this.condFromDt = condFromDt; }
public String getCondToDt() { return condToDt; }
public void setCondToDt(String condToDt) { this.condToDt = condToDt; }
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }
public int getTotalCnt() { return totalCnt; }
public void setTotalCnt(int totalCnt) { this.totalCnt = totalCnt; }
public int getDoneCnt() { return doneCnt; }
public void setDoneCnt(int doneCnt) { this.doneCnt = doneCnt; }
public String getFileNm() { return fileNm; }
public void setFileNm(String fileNm) { this.fileNm = fileNm; }
public String getFilePath() { return filePath; }
public void setFilePath(String filePath) { this.filePath = filePath; }
public long getFileSize() { return fileSize; }
public void setFileSize(long fileSize) { this.fileSize = fileSize; }
public String getErrMsg() { return errMsg; }
public void setErrMsg(String errMsg) { this.errMsg = errMsg; }
public int getDownloadCnt() { return downloadCnt; }
public void setDownloadCnt(int downloadCnt) { this.downloadCnt = downloadCnt; }
public String getLastDlDt() { return lastDlDt; }
public void setLastDlDt(String lastDlDt) { this.lastDlDt = lastDlDt; }
public String getRegDt() { return regDt; }
public void setRegDt(String regDt) { this.regDt = regDt; }
public String getStartDt() { return startDt; }
public void setStartDt(String startDt) { this.startDt = startDt; }
public String getEndDt() { return endDt; }
public void setEndDt(String endDt) { this.endDt = endDt; }
public String getExpireDt() { return expireDt; }
public void setExpireDt(String expireDt) { this.expireDt = expireDt; }
public int getExpireDays() { return expireDays; }
public void setExpireDays(int expireDays) { this.expireDays = expireDays; }
/** 진행률(%). 총건수 미확정이면 0. */
public int getProgressPct() {
if (totalCnt <= 0) {
return ST_SUCCESS.equals(status) ? 100 : 0;
}
long pct = (long) doneCnt * 100L / totalCnt;
return (pct > 100L) ? 100 : (int) pct;
}
/** 내려받기 가능 여부(완료 + 파일 보유). */
public boolean isDownloadable() {
return ST_SUCCESS.equals(status) && filePath != null && filePath.length() > 0;
}
}

338
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistDownloadJobWorker.java
View File

@ -1,338 +0,0 @@
package egovframework.com.cmm.privacy.author;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import egovframework.com.utl.sim.service.EgovFileScrty;
/**
* 권한변경 이력 CSV 비동기 다운로드 워커 (SFR-001 / 개발항목 #6).
*
* <p>대기(W) 작업을 하나씩 집어 CSV 파일을 만든다. <b>단일 워커 스레드</b>다 —
* 대량 조회가 동시에 여러 건 돌면 DB 부하가 그대로 서비스 지연이 되기 때문이다.
* 접속기록 워커({@code AccessLogDownloadJobWorker})와 같은 구조이며 조회 대상만 다르다.</p>
*
* <p><b>메모리를 쓰지 않는 방식:</b> 전체를 List 로 올리지 않고 {@link #CHUNK_ROWS}건씩
* 끊어 조회하며 곧바로 파일에 쓴다. 종전 동기 다운로드(전량 추출)의 OOM 위험을 없앤다.</p>
*
* <p><b>파일은 암호화해 둔다:</b> 취급자 권한 변동 내역이 담긴 개인정보 파일이라 평문 CSV 를
* 디스크에 남기지 않는다. {@link EgovFileScrty#encryptFile}로 암호화한 뒤 평문 임시파일을 지우고,
* 내려받을 때 복호화해 스트리밍한다. 저장 위치는 반드시 <b>웹 루트 밖</b>이어야 한다.</p>
*
* <p><b>기동 시 고아 복구:</b> 파일 생성 중 WAS 가 죽으면 작업이 R 로 굳는다. 기동 시
* R → W 로 되돌려 재시도한다(화면에 '생성중'이 영원히 멈춰 보이는 것 방지).</p>
*
* @since 2026-08-10
*/
@Component("authorHistDownloadJobWorker")
public class AuthorHistDownloadJobWorker {
private static final Log LOG = LogFactory.getLog(AuthorHistDownloadJobWorker.class);
/** 한 번에 조회·기록할 행 수. 메모리 상주량을 결정한다. */
private static final int CHUNK_ROWS = 2000;
/** 대기 작업이 없을 때 다음 확인까지 쉬는 시간(ms). */
private static final long IDLE_SLEEP_MS = 3000L;
/** 예외 발생 후 폭주 방지 대기(ms). */
private static final long ERROR_SLEEP_MS = 10000L;
/** 화면 열 구성과 맞춘다(대상자명·변경자IP 포함). */
private static final String CSV_HEADER =
"변경일시,대상자ID,대상자명,변경구분,변경전권한,변경후권한,변경사유,승인자,변경자ID,변경자IP";
@Resource(name = "authorHistDownloadJobDAO")
private AuthorHistDownloadJobDAO jobDAO;
@Resource(name = "authorHistoryService")
private AuthorHistoryService authorHistoryService;
/**
* 생성 파일 저장 디렉터리. <b>반드시 웹 루트(webapps) 밖</b>이어야 한다.
* 접속기록 비동기 다운로드와 같은 설정값을 공유한다. 미설정 시 기동 로그에 경고를 남기고
* 워커를 띄우지 않는다 — 임의 경로에 개인정보 파일을 만드는 것보다 기능을 멈추는 편이 안전하다.
*/
@Value("${Globals.privacyDownloadPath:}")
private String downloadPath;
private volatile boolean running = false;
private volatile Thread worker;
@PostConstruct
public void start() {
// 저장경로가 없거나 만들 수 없어도 워커는 띄운다(접속기록 워커와 동일한 이유).
// 종전에는 여기서 return 해 워커가 아예 안 돌았고, 작업이 '대기'로 영원히 굳었다.
// 지금은 작업마다 경로를 확인해 확보 불가면 그 작업을 '실패'로 확정한다.
try {
ensureDir();
LOG.info("[개인정보/SFR-001-6] 저장경로 확인 완료 — " + downloadPath);
} catch (Exception e) {
LOG.error("[개인정보/SFR-001-6] 저장경로를 확보하지 못했다 — " + e.getMessage()
+ " 워커는 기동하되, 경로가 확보될 때까지 접수된 작업은 '실패'로 처리한다. "
+ "웹 루트 밖 경로를 지정·생성할 것(예: /app/egovframework/privacy-download/).");
}
try {
int reset = jobDAO.resetRunningJobs();
if (reset > 0) {
LOG.warn("[개인정보/SFR-001-6] 이전 기동에서 생성 중이던 작업 " + reset + "건을 대기로 되돌려 재시도한다.");
}
} catch (Exception e) {
LOG.error("[개인정보/SFR-001-6] 고아 작업 복구 실패(계속 진행)", e);
}
running = true;
Thread t = new Thread(new Runnable() {
public void run() {
loop();
}
}, "author-hist-download-worker");
t.setDaemon(true);
worker = t;
t.start();
LOG.info("[개인정보/SFR-001-6] 권한이력 비동기 다운로드 워커 기동 — 저장경로=" + downloadPath
+ ", 청크=" + CHUNK_ROWS + "행");
}
@PreDestroy
public void stop() {
running = false;
Thread t = worker;
if (t != null) {
t.interrupt();
}
}
/** 워커 루프 — 대기건을 하나씩 선점해 처리한다. Throwable 까지 흡수해 스스로 죽지 않는다. */
private void loop() {
while (running) {
try {
Long jobId = jobDAO.selectNextWaitingJobId();
if (jobId == null) {
Thread.sleep(IDLE_SLEEP_MS);
continue;
}
if (!jobDAO.claimJob(jobId.longValue())) {
// 다른 워커/재시도와 경합해 선점 실패 — 즉시 다음 것을 본다.
continue;
}
process(jobId.longValue());
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
break;
} catch (Throwable t) {
LOG.error("[개인정보/SFR-001-6] 워커 루프 예외(계속)", t);
try {
Thread.sleep(ERROR_SLEEP_MS);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
break;
}
}
}
LOG.info("[개인정보/SFR-001-6] 권한이력 비동기 다운로드 워커 종료.");
}
/** 작업 1건 처리 — 청크 조회 → CSV 기록 → 암호화 → 완료 확정. */
private void process(long jobId) {
AuthorHistDownloadJobVO job = null;
File plain = null;
File enc = null;
try {
job = jobDAO.selectJob(jobId);
if (job == null) {
return;
}
AuthorChangeHistoryVO searchVO = toSearchVO(job);
int total = authorHistoryService.selectHistoryListCount(searchVO);
job.setTotalCnt(total);
job.setDoneCnt(0);
jobDAO.updateProgress(job);
// 작업마다 저장경로를 확인한다 — 기동 후 경로가 생겼다면 재기동 없이 여기서 살아난다.
File dir = ensureDir();
String stamp = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
String baseNm = "권한변경이력_" + stamp + "_" + jobId;
plain = new File(dir, baseNm + ".csv.tmp");
enc = new File(dir, baseNm + ".csv.enc");
int written = writeCsv(plain, searchVO, total, job);
// 평문 CSV 를 디스크에 남기지 않는다 — 암호화 후 즉시 삭제.
if (!EgovFileScrty.encryptFile(plain.getAbsolutePath(), enc.getAbsolutePath())) {
throw new IllegalStateException("파일 암호화 실패");
}
deleteQuietly(plain);
plain = null;
job.setDoneCnt(written);
job.setTotalCnt(total);
job.setFileNm(baseNm + ".csv");
job.setFilePath(enc.getAbsolutePath());
job.setFileSize(enc.length());
jobDAO.updateSuccess(job);
LOG.info("[개인정보/SFR-001-6] 권한이력 다운로드 파일 생성 완료 — jobId=" + jobId + ", " + written + "행, "
+ enc.length() + "byte");
} catch (Throwable t) {
LOG.error("[개인정보/SFR-001-6] 권한이력 다운로드 파일 생성 실패 — jobId=" + jobId, t);
deleteQuietly(plain);
deleteQuietly(enc);
try {
AuthorHistDownloadJobVO fail = (job != null) ? job : new AuthorHistDownloadJobVO();
fail.setJobId(jobId);
fail.setErrMsg(cut(String.valueOf(t.getMessage()), 500));
jobDAO.updateFail(fail);
} catch (Exception e) {
LOG.error("[개인정보/SFR-001-6] 실패 상태 기록마저 실패 — jobId=" + jobId, e);
}
}
}
/**
* 청크 단위로 조회하며 곧바로 파일에 기록한다(전체를 메모리에 올리지 않는다).
*
* @return 기록한 행 수
*/
private int writeCsv(File target, AuthorChangeHistoryVO searchVO, int total,
AuthorHistDownloadJobVO job) throws Exception {
BufferedWriter w = null;
int written = 0;
try {
FileOutputStream fos = new FileOutputStream(target);
// UTF-8 BOM — 엑셀에서 한글이 깨지지 않게 한다(기존 동기 다운로드와 동일).
fos.write(0xEF); fos.write(0xBB); fos.write(0xBF);
w = new BufferedWriter(new OutputStreamWriter(fos, "UTF-8"));
w.write(CSV_HEADER);
w.newLine();
int page = 1;
while (written < total) {
searchVO.setPageIndex(page);
searchVO.setRecordCountPerPage(CHUNK_ROWS);
List<AuthorChangeHistoryVO> chunk = authorHistoryService.selectHistoryList(searchVO);
if (chunk == null || chunk.isEmpty()) {
break;
}
for (int i = 0; i < chunk.size(); i++) {
w.write(toCsvLine(chunk.get(i)));
w.newLine();
written++;
}
w.flush();
// 진행률 갱신 — 화면 폴링이 실제로 움직이는 값을 보게 한다.
job.setDoneCnt(written);
job.setTotalCnt(total);
try {
jobDAO.updateProgress(job);
} catch (Exception e) {
// 진행률은 부가정보다 — 실패해도 생성은 계속한다.
LOG.warn("[개인정보/SFR-001-6] 진행률 갱신 실패(무시) — jobId=" + job.getJobId());
}
page++;
}
w.flush();
} finally {
if (w != null) {
try { w.close(); } catch (Exception ignore) { /* 닫기 실패는 무시 */ }
}
}
return written;
}
private String toCsvLine(AuthorChangeHistoryVO v) {
StringBuilder sb = new StringBuilder(256);
sb.append(csv(v.getChgDt())).append(',')
.append(csv(v.getTrgetId())).append(',')
.append(csv(v.getTrgetNm())).append(',')
.append(csv(chgSeLabel(v.getChgSeCode()))).append(',')
.append(csv(v.getBeforeAuthor())).append(',')
.append(csv(v.getAfterAuthor())).append(',')
.append(csv(v.getChgResn())).append(',')
.append(csv(v.getAprovlId())).append(',')
.append(csv(v.getChangerId())).append(',')
.append(csv(v.getChangerIp()));
return sb.toString();
}
private AuthorChangeHistoryVO toSearchVO(AuthorHistDownloadJobVO job) {
AuthorChangeHistoryVO vo = new AuthorChangeHistoryVO();
vo.setSearchTrgetId(job.getCondTrgetId());
vo.setSearchChangerId(job.getCondChangerId());
vo.setSearchChgSeCode(job.getCondChgSeCode());
vo.setFromDt(job.getCondFromDt());
vo.setToDt(job.getCondToDt());
return vo;
}
/**
* 저장 디렉터리를 확보한다(없으면 생성). 실패는 예외로 알린다 —
* 메시지가 그대로 작업 실패사유(ERR_MSG)로 화면에 노출된다.
*/
private File ensureDir() {
if (downloadPath == null || downloadPath.trim().length() == 0) {
throw new IllegalStateException("다운로드 저장경로 미설정(Globals.privacyDownloadPath)");
}
File dir = new File(downloadPath.trim());
if (!dir.exists() && !dir.mkdirs()) {
throw new IllegalStateException("다운로드 저장경로 생성 실패 — " + dir.getAbsolutePath());
}
if (!dir.isDirectory()) {
throw new IllegalStateException("다운로드 저장경로가 디렉터리가 아님 — " + dir.getAbsolutePath());
}
if (!dir.canWrite()) {
throw new IllegalStateException("다운로드 저장경로에 쓸 수 없음(WAS 계정 권한 확인) — " + dir.getAbsolutePath());
}
return dir;
}
private void deleteQuietly(File f) {
if (f != null && f.exists()) {
try {
if (!f.delete()) {
LOG.warn("[개인정보/SFR-001-6] 임시파일 삭제 실패(수동 확인 필요) — " + f.getAbsolutePath());
}
} catch (Exception ignore) {
LOG.warn("[개인정보/SFR-001-6] 임시파일 삭제 중 예외 — " + f.getAbsolutePath());
}
}
}
/** CSV 셀 이스케이프(구분자·따옴표·개행 방어). */
private String csv(String v) {
if (v == null) {
return "";
}
String s = v.replace("\"", "\"\"");
return "\"" + s.replace("\r", " ").replace("\n", " ") + "\"";
}
private String chgSeLabel(String code) {
if ("G".equals(code)) return "부여";
if ("R".equals(code)) return "회수";
if ("M".equals(code)) return "변경";
return code;
}
private static String cut(String s, int max) {
if (s == null) {
return null;
}
return (s.length() > max) ? s.substring(0, max) : s;
}
}

14
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistoryService.java
View File

@ -21,18 +21,4 @@ public interface AuthorHistoryService {
* @return 추출된 이력 목록(파일 생성은 화면/컨트롤러 계층에서)
*/
List<AuthorChangeHistoryVO> downloadHistory(AuthorChangeHistoryVO searchVo, AuthorHistDownloadVO download) throws Exception;
/**
* 다운로드 증빙 이력만 적재. 비동기 다운로드는 파일 생성과 실제 내려받기 시점이 달라
* '내려받은 시점'에 이 메서드로 증빙을 남긴다(사유·건수 증빙을 동기 경로와 일원화).
*
* @param downloaderId 다운로드자 계정ID
* @param downloaderUniqId 다운로드자 고유식별자
* @param downloaderIp 다운로드자 IP
* @param reason 다운로드 사유(요청 시 입력값)
* @param searchCond 검색조건 요약
* @param cnt 내려받은 건수
*/
void recordDownloadHistory(String downloaderId, String downloaderUniqId, String downloaderIp,
String reason, String searchCond, int cnt) throws Exception;
}

13
src/main/java/egovframework/com/cmm/privacy/author/AuthorHistoryServiceImpl.java
View File

@ -48,17 +48,4 @@ public class AuthorHistoryServiceImpl implements AuthorHistoryService {
return list;
}
@Override
public void recordDownloadHistory(String downloaderId, String downloaderUniqId, String downloaderIp,
String reason, String searchCond, int cnt) throws Exception {
AuthorHistDownloadVO dl = new AuthorHistDownloadVO();
dl.setDownloaderId(downloaderId);
dl.setDownloaderUniqId(downloaderUniqId);
dl.setDownloaderIp(downloaderIp);
dl.setDwldResn(reason);
dl.setSearchCond(searchCond);
dl.setDwldCnt(cnt);
authorHistoryDAO.insertDownloadHistory(dl);
}
}

272
src/main/java/egovframework/com/cmm/privacy/author/AuthorWorkflowController.java
View File

@ -1,20 +1,14 @@
package egovframework.com.cmm.privacy.author;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URLEncoder;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.privacy.auditlog.ClientIpResolver;
@ -24,8 +18,8 @@ import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
* 권한 신청·승인 워크플로 + 권한이력 조회·다운로드 컨트롤러
* (개인정보보호 SFR-001 / #3·#6).
*
* <p>취급자 영역(/mnt) 백엔드 엔드포인트. 처리자/신청자 식별자와 IP는
* 세션 loginVO·ClientIpResolver(#34)에서 취득한다.</p>
* <p>취급자 영역(/mnt) 백엔드 엔드포인트. 응답은 jsonView(화면 JSP는 #46 후속).
* 처리자/신청자 식별자와 IP는 세션 loginVO·ClientIpResolver(#34)에서 취득한다.</p>
*/
@Controller
public class AuthorWorkflowController {
@ -38,38 +32,38 @@ public class AuthorWorkflowController {
@Resource(name = "authorHistoryService")
private AuthorHistoryService authorHistoryService;
/** 권한이력 CSV 비동기 다운로드 작업(#6) */
@Resource(name = "authorHistDownloadJobService")
private AuthorHistDownloadJobService authorHistDownloadJobService;
private LoginVO loginUser(HttpServletRequest request) {
Object o = request.getSession().getAttribute("loginVO");
return (o instanceof LoginVO) ? (LoginVO) o : null;
}
/** 권한 변경 신청 목록 (AJAX/JSON) */
@RequestMapping(value = "/mnt/sec/authorRequest/list.do")
public String requestList(AuthorChangeRequestVO searchVO, ModelMap model) throws Exception {
List<AuthorChangeRequestVO> list = authorWorkflowService.selectRequestList(searchVO);
model.addAttribute("resultList", list);
model.addAttribute("totalCount", searchVO.getTotalRecordCount());
return JSON;
}
/**
* 개인정보취급자 권한 관리 목록 화면(서버 렌더링) — 메뉴 진입점.
* 취급자 1인 = 1행. 소속기관/변경 전 역할/변경 후 역할/접근범위/권한상태/최근변경일/관리 열을 제공하고,
* 승인대기 행에서는 이 화면에서 바로 승인·반려한다.
* 권한 변경 신청 목록·승인·반려 화면(서버 렌더링).
* 뷰: /WEB-INF/jsp/site/mnt/sec/authorRequest/list.jsp
*/
@RequestMapping(value = "/mnt/sec/authorRequest/listView.do")
public String userAuthorListView(@ModelAttribute("privacyUserAuthorVO") PrivacyUserAuthorVO searchVO,
ModelMap model) throws Exception {
public String requestListView(@ModelAttribute("authorChangeRequestVO") AuthorChangeRequestVO searchVO,
ModelMap model) throws Exception {
PaginationInfo paginationInfo = new PaginationInfo();
paginationInfo.setCurrentPageNo(searchVO.getPageIndex());
paginationInfo.setRecordCountPerPage(searchVO.getRecordCountPerPage() < 1 ? 10 : searchVO.getRecordCountPerPage());
paginationInfo.setPageSize(10);
// selectUserAuthorList 내부에서 firstIndex/totalRecordCount 를 세팅한다.
List<PrivacyUserAuthorVO> list = authorWorkflowService.selectUserAuthorList(searchVO);
// selectRequestList 내부에서 firstIndex/totalRecordCount 를 세팅한다.
List<AuthorChangeRequestVO> list = authorWorkflowService.selectRequestList(searchVO);
paginationInfo.setTotalRecordCount(searchVO.getTotalRecordCount());
model.addAttribute("resultList", list);
model.addAttribute("paginationInfo", paginationInfo);
model.addAttribute("orgnztList", authorWorkflowService.selectOrgnztList());
model.addAttribute("authorityList", authorWorkflowService.selectAuthorityList());
model.addAttribute("pendingCount", Integer.valueOf(authorWorkflowService.selectPendingRequestCount()));
return "site/mnt/sec/authorRequest/list";
}
@ -148,7 +142,7 @@ public class AuthorWorkflowController {
return JSON;
}
/** 권한 변경 이력 조회(대상자·변경자 양방향 검색 + 페이징, AJAX/JSON) */
/** 권한 변경 이력 조회(대상자·변경자 양방향 검색 + 페이징) */
@RequestMapping(value = "/mnt/sec/authorHistory/list.do")
public String historyList(AuthorChangeHistoryVO searchVO, ModelMap model) throws Exception {
List<AuthorChangeHistoryVO> list = authorHistoryService.selectHistoryList(searchVO);
@ -157,188 +151,11 @@ public class AuthorWorkflowController {
return JSON;
}
/**
* 권한 변경 이력 조회·검색 화면(서버 렌더링).
* 뷰: /WEB-INF/jsp/site/mnt/sec/authorHistory/list.jsp
*/
@RequestMapping(value = "/mnt/sec/authorHistory/listView.do")
public String historyListView(@ModelAttribute("authorChangeHistoryVO") AuthorChangeHistoryVO searchVO,
HttpServletRequest request, ModelMap model) throws Exception {
PaginationInfo paginationInfo = new PaginationInfo();
paginationInfo.setCurrentPageNo(searchVO.getPageIndex());
paginationInfo.setRecordCountPerPage(searchVO.getRecordCountPerPage() < 1 ? 10 : searchVO.getRecordCountPerPage());
paginationInfo.setPageSize(10);
// selectHistoryList 내부에서 firstIndex/totalRecordCount 를 세팅한다.
List<AuthorChangeHistoryVO> list = authorHistoryService.selectHistoryList(searchVO);
paginationInfo.setTotalRecordCount(searchVO.getTotalRecordCount());
model.addAttribute("resultList", list);
model.addAttribute("paginationInfo", paginationInfo);
// 내 다운로드 작업 목록(비동기) — 상태·진행률 확인 및 내려받기
model.addAttribute("dlJobList", selectMyDownloadJobs(request));
return "site/mnt/sec/authorHistory/list";
}
/**
* 내 권한이력 다운로드 작업의 <b>상태만</b> 돌려주는 폴링 전용 엔드포인트.
*
* <p>접속기록 화면과 같은 이유다 — 진행률을 보려고 목록 화면을 5초마다 다시 열면
* 이 화면이 접속기록 수집 화이트리스트({@code /mnt/sec/**}) 안이라 <u>새로고침마다 감사로그 1행</u>이
* 쌓인다. 상태 조회를 별도 경로로 빼고 {@code excludePatterns} 로 수집에서 제외한다.
* 본문에는 작업ID·상태·진행률·건수·실패사유만 담으며 본인 작업으로 한정한다.</p>
*/
@RequestMapping(value = "/mnt/sec/authorHistory/jobStatus.do")
public void historyJobStatus(HttpServletRequest request, HttpServletResponse response) throws Exception {
response.setContentType("text/plain; charset=UTF-8");
response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
response.setHeader("Pragma", "no-cache");
LoginVO user = loginUser(request);
if (user == null) {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
return;
}
StringBuilder sb = new StringBuilder(256);
List<AuthorHistDownloadJobVO> list = authorHistDownloadJobService.selectMyJobs(user.getId(), 10);
if (list != null) {
for (AuthorHistDownloadJobVO j : list) {
sb.append(j.getJobId()).append('|')
.append(j.getStatus() == null ? "" : j.getStatus()).append('|')
.append(j.getProgressPct()).append('|')
.append(j.getDoneCnt()).append('|')
.append(j.getTotalCnt()).append('|')
.append(jobStatusOneLine(j.getErrMsg())).append('\n');
}
}
response.getWriter().write(sb.toString());
response.getWriter().flush();
}
/** 구분자·개행이 섞이면 화면 파싱이 깨지므로 한 줄로 눌러 담는다. */
private String jobStatusOneLine(String v) {
if (v == null) {
return "";
}
return v.replace('|', '/').replace('\r', ' ').replace('\n', ' ');
}
/**
* 권한이력 다운로드 <b>요청</b>(비동기) — 작업만 등록하고 즉시 목록으로 돌아온다.
*
* <p>종전 동기 방식({@link #historyDownload})은 조건 전체를 List 로 메모리에 올려
* OOM·요청 타임아웃 위험이 있었다. 파일 생성은 백그라운드 워커가 맡는다.
* 사유는 여기서도 필수이며, 미입력이면 작업을 만들지 않는다.</p>
*/
@RequestMapping(value = "/mnt/sec/authorHistory/downloadRequest.do")
public String historyDownloadRequest(@ModelAttribute("authorChangeHistoryVO") AuthorChangeHistoryVO searchVO,
@RequestParam(value = "dwldResn", required = false) String dwldResn,
HttpServletRequest request, ModelMap model) throws Exception {
LoginVO user = loginUser(request);
try {
if (user == null) {
throw new IllegalArgumentException("로그인 정보를 확인할 수 없습니다.");
}
authorHistDownloadJobService.requestJob(user.getId(),
ClientIpResolver.getClientIp(request), dwldResn, searchVO);
} catch (IllegalArgumentException e) {
model.addAttribute("dlMessage", e.getMessage());
} catch (Exception e) {
model.addAttribute("dlMessage", "다운로드 요청 중 오류가 발생했습니다.");
}
// 검색조건을 유지한 채 목록으로 — 요청 직후 작업 목록에서 진행상태를 볼 수 있다.
return historyListView(searchVO, request, model);
}
/**
* 완료된 권한이력 다운로드 파일 내려받기 — <b>요청자 본인만</b> 가능하다.
*
* <p>저장 파일은 암호화돼 있어 복호화 후 스트리밍한다. 임시 복호화본은 전송 직후 지운다.
* 실제 내려받은 시점의 사유·건수 이력은 기존 {@code AUTHOR_HIST_DOWNLOAD_HISTORY} 에 적재한다.</p>
*/
@RequestMapping(value = "/mnt/sec/authorHistory/downloadFile.do")
public void historyDownloadFile(@RequestParam("jobId") long jobId,
HttpServletRequest request, HttpServletResponse response) throws Exception {
LoginVO user = loginUser(request);
if (user == null) {
response.sendError(HttpServletResponse.SC_FORBIDDEN, "접근 권한이 없습니다.");
return;
}
AuthorHistDownloadJobVO job = authorHistDownloadJobService.selectDownloadableJob(jobId, user.getId());
if (job == null) {
// 존재/소유/완료 여부를 구분해 알리지 않는다(작업ID 탐색 방지).
response.sendError(HttpServletResponse.SC_NOT_FOUND, "내려받을 수 있는 파일이 없습니다.");
return;
}
java.io.File plain = java.io.File.createTempFile("author-hist-dl-", ".csv");
try {
if (!egovframework.com.utl.sim.service.EgovFileScrty.decryptFile(
job.getFilePath(), plain.getAbsolutePath())) {
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "파일을 열 수 없습니다.");
return;
}
String fileName = URLEncoder.encode(job.getFileNm(), "UTF-8");
response.setContentType("text/csv; charset=UTF-8");
response.setHeader("Content-Disposition",
"attachment; filename=\"" + fileName + "\"; filename*=UTF-8''" + fileName);
response.setHeader("Content-Transfer-Encoding", "binary");
response.setHeader("Content-Length", String.valueOf(plain.length()));
java.io.FileInputStream in = null;
OutputStream os = response.getOutputStream();
try {
in = new java.io.FileInputStream(plain);
byte[] buf = new byte[8192];
int len;
while ((len = in.read(buf)) > 0) {
os.write(buf, 0, len);
}
os.flush();
} finally {
if (in != null) {
try { in.close(); } catch (Exception ignore) { /* 무시 */ }
}
}
authorHistDownloadJobService.markDownloaded(jobId);
// 내려받은 사실을 기존 다운로드 이력에도 남긴다(사유·건수 증빙 일원화).
authorHistoryService.recordDownloadHistory(user.getId(), user.getUniqId(),
ClientIpResolver.getClientIp(request), job.getDlReason(), job.getSearchCond(), job.getDoneCnt());
} finally {
// 복호화 임시본을 남기지 않는다.
if (plain.exists() && !plain.delete()) {
plain.deleteOnExit();
}
}
}
/** 내 다운로드 작업 목록(최근 10건). 조회 실패해도 화면은 떠야 하므로 빈 목록으로 fail-safe. */
private List<AuthorHistDownloadJobVO> selectMyDownloadJobs(HttpServletRequest request) {
try {
LoginVO user = loginUser(request);
if (user == null) {
return new java.util.ArrayList<AuthorHistDownloadJobVO>();
}
List<AuthorHistDownloadJobVO> list = authorHistDownloadJobService.selectMyJobs(user.getId(), 10);
return (list == null) ? new java.util.ArrayList<AuthorHistDownloadJobVO>() : list;
} catch (Exception e) {
return new java.util.ArrayList<AuthorHistDownloadJobVO>();
}
}
/**
* 권한 변경 이력 다운로드 — 동기 방식(기존). 사유 필수 + 다운로드 이력 적재 + CSV 파일 스트리밍.
*
* <p><b>주의:</b> 조건 전체를 메모리에 올린다. 화면은 위 {@link #historyDownloadRequest}
* 비동기 경로를 쓴다. 이 엔드포인트는 소량 즉시 다운로드와 기존 링크 호환을 위해 남겨둔다.</p>
*/
/** 권한 변경 이력 다운로드 — 사유 필수 + 다운로드 이력 적재 */
@RequestMapping(value = "/mnt/sec/authorHistory/download.do")
public void historyDownload(AuthorChangeHistoryVO searchVO,
@RequestParam(value = "dwldResn", required = false) String dwldResn,
HttpServletRequest request, HttpServletResponse response) throws Exception {
public String historyDownload(AuthorChangeHistoryVO searchVO,
@org.springframework.web.bind.annotation.RequestParam(value = "dwldResn", required = false) String dwldResn,
HttpServletRequest request, ModelMap model) throws Exception {
LoginVO user = loginUser(request);
AuthorHistDownloadVO dl = new AuthorHistDownloadVO();
dl.setDwldResn(dwldResn);
@ -349,48 +166,15 @@ public class AuthorWorkflowController {
dl.setDownloaderIp(ClientIpResolver.getClientIp(request));
dl.setSearchCond("trget=" + searchVO.getSearchTrgetId() + ",changer=" + searchVO.getSearchChangerId()
+ ",se=" + searchVO.getSearchChgSeCode() + ",from=" + searchVO.getFromDt() + ",to=" + searchVO.getToDt());
List<AuthorChangeHistoryVO> list;
try {
list = authorHistoryService.downloadHistory(searchVO, dl);
List<AuthorChangeHistoryVO> list = authorHistoryService.downloadHistory(searchVO, dl);
model.addAttribute("resultList", list);
model.addAttribute("result", "success");
// TODO: 화면 #46 — 실제 파일(CSV/XLS) 스트리밍은 프론트/뷰 계층에서 처리
} catch (IllegalArgumentException e) {
// 사유 미입력 등 차단 — 다운로드를 열지 않고 오류만 응답
response.sendError(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
return;
model.addAttribute("result", "fail");
model.addAttribute("message", e.getMessage()); // 사유 미입력 차단
}
String fileName = URLEncoder.encode("권한변경이력_" + new java.text.SimpleDateFormat("yyyyMMddHHmmss").format(new java.util.Date()) + ".csv", "UTF-8");
response.setContentType("text/csv; charset=UTF-8");
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"; filename*=UTF-8''" + fileName);
response.setHeader("Content-Transfer-Encoding", "binary");
OutputStream os = response.getOutputStream();
os.write(0xEF); os.write(0xBB); os.write(0xBF); // UTF-8 BOM (엑셀 한글 호환)
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
// 열 구성은 비동기 워커(AuthorHistDownloadJobWorker.CSV_HEADER)와 동일하게 유지한다.
pw.println("변경일시,대상자ID,대상자명,변경구분,변경전권한,변경후권한,변경사유,승인자,변경자ID,변경자IP");
if (list != null) {
for (AuthorChangeHistoryVO h : list) {
pw.println(csv(h.getChgDt()) + "," + csv(h.getTrgetId()) + "," + csv(h.getTrgetNm())
+ "," + csv(chgSeLabel(h.getChgSeCode()))
+ "," + csv(h.getBeforeAuthor()) + "," + csv(h.getAfterAuthor()) + "," + csv(h.getChgResn())
+ "," + csv(h.getAprovlId()) + "," + csv(h.getChangerId()) + "," + csv(h.getChangerIp()));
}
}
pw.flush();
}
private String chgSeLabel(String code) {
if ("G".equals(code)) return "부여";
if ("R".equals(code)) return "회수";
if ("M".equals(code)) return "변경";
return code;
}
/** CSV 필드 이스케이프(쉼표/따옴표/개행 포함 시 큰따옴표로 감싸고 내부 따옴표는 두 배로) */
private String csv(String value) {
if (value == null) return "";
String escaped = value.replace("\"", "\"\"");
return "\"" + escaped + "\"";
return JSON;
}
}

36
src/main/java/egovframework/com/cmm/privacy/author/AuthorWorkflowDAO.java
View File

@ -30,6 +30,18 @@ public class AuthorWorkflowDAO extends EgovComAbstractDAO {
return (AuthorChangeRequestVO) selectByPk("AuthorWorkflowDAO.selectRequest", Long.valueOf(requestId));
}
/** 신청 목록 조회(상태/대상 검색 + 페이징) */
@SuppressWarnings("unchecked")
public List<AuthorChangeRequestVO> selectRequestList(AuthorChangeRequestVO vo) {
return list("AuthorWorkflowDAO.selectRequestList", vo);
}
/** 신청 목록 전체 건수 */
public int selectRequestListCount(AuthorChangeRequestVO vo) {
Object cnt = selectByPk("AuthorWorkflowDAO.selectRequestListCount", vo);
return cnt == null ? 0 : ((Integer) cnt).intValue();
}
/** 신청 상태 갱신(승인 A / 반려 J) */
public void updateRequestStatus(AuthorChangeRequestVO vo) {
update("AuthorWorkflowDAO.updateRequestStatus", vo);
@ -65,28 +77,4 @@ public class AuthorWorkflowDAO extends EgovComAbstractDAO {
public egovframework.rte.psl.dataaccess.util.EgovMap selectTargetByLoginId(String trgetId) {
return (egovframework.rte.psl.dataaccess.util.EgovMap) selectByPk("AuthorWorkflowDAO.selectTargetByLoginId", trgetId);
}
/** 개인정보취급자 권한 목록(소속기관·역할·접근범위·권한상태·최근변경일 + 페이징) */
@SuppressWarnings("unchecked")
public List<PrivacyUserAuthorVO> selectUserAuthorList(PrivacyUserAuthorVO vo) {
return list("AuthorWorkflowDAO.selectUserAuthorList", vo);
}
/** 개인정보취급자 권한 목록 전체 건수 */
public int selectUserAuthorListCount(PrivacyUserAuthorVO vo) {
Object cnt = selectByPk("AuthorWorkflowDAO.selectUserAuthorListCount", vo);
return cnt == null ? 0 : ((Integer) cnt).intValue();
}
/** 목록 상단 요약용 전체 승인대기 건수(검색조건 무관) */
public int selectPendingRequestCount() {
Object cnt = selectByPk("AuthorWorkflowDAO.selectPendingRequestCount", null);
return cnt == null ? 0 : ((Integer) cnt).intValue();
}
/** 검색조건 드롭다운용 소속기관 목록 */
@SuppressWarnings("unchecked")
public List<egovframework.rte.psl.dataaccess.util.EgovMap> selectOrgnztList() {
return list("AuthorWorkflowDAO.selectOrgnztList", null);
}
}

15
src/main/java/egovframework/com/cmm/privacy/author/AuthorWorkflowService.java
View File

@ -10,6 +10,12 @@ public interface AuthorWorkflowService {
/** 권한 변경 신청 등록(상태 R) */
void submitRequest(AuthorChangeRequestVO vo) throws Exception;
/** 신청 목록 조회 */
List<AuthorChangeRequestVO> selectRequestList(AuthorChangeRequestVO vo) throws Exception;
/** 신청 목록 건수 */
int selectRequestListCount(AuthorChangeRequestVO vo) throws Exception;
/**
* 승인(A) — 권한 반영(COMTNEMPLYRSCRTYESTBS)과 이력 적재(AUTHOR_CHANGE_HISTORY)를
* 단일 트랜잭션으로 처리한다.
@ -28,13 +34,4 @@ public interface AuthorWorkflowService {
/** 대상자 계정ID → 고유식별자·성명 자동조회 (없으면 null) */
egovframework.rte.psl.dataaccess.util.EgovMap selectTargetByLoginId(String trgetId) throws Exception;
/** 개인정보취급자 권한 목록 조회 — firstIndex/totalRecordCount 를 vo 에 세팅한다 */
List<PrivacyUserAuthorVO> selectUserAuthorList(PrivacyUserAuthorVO vo) throws Exception;
/** 목록 상단 요약용 전체 승인대기 건수 */
int selectPendingRequestCount() throws Exception;
/** 검색조건 드롭다운용 소속기관 목록 */
List<egovframework.rte.psl.dataaccess.util.EgovMap> selectOrgnztList() throws Exception;
}

35
src/main/java/egovframework/com/cmm/privacy/author/AuthorWorkflowServiceImpl.java
View File

@ -31,6 +31,21 @@ public class AuthorWorkflowServiceImpl implements AuthorWorkflowService {
authorWorkflowDAO.insertRequest(vo);
}
@Override
public List<AuthorChangeRequestVO> selectRequestList(AuthorChangeRequestVO vo) throws Exception {
int pageIndex = vo.getPageIndex() < 1 ? 1 : vo.getPageIndex();
int perPage = vo.getRecordCountPerPage() < 1 ? 10 : vo.getRecordCountPerPage();
vo.setFirstIndex((pageIndex - 1) * perPage);
vo.setRecordCountPerPage(perPage);
vo.setTotalRecordCount(authorWorkflowDAO.selectRequestListCount(vo));
return authorWorkflowDAO.selectRequestList(vo);
}
@Override
public int selectRequestListCount(AuthorChangeRequestVO vo) throws Exception {
return authorWorkflowDAO.selectRequestListCount(vo);
}
@Override
public void approveRequest(long requestId, String confmId, String confmUniqId, String confmIp) throws Exception {
AuthorChangeRequestVO req = authorWorkflowDAO.selectRequest(requestId);
@ -104,26 +119,6 @@ public class AuthorWorkflowServiceImpl implements AuthorWorkflowService {
return authorWorkflowDAO.selectTargetByLoginId(trgetId.trim());
}
@Override
public List<PrivacyUserAuthorVO> selectUserAuthorList(PrivacyUserAuthorVO vo) throws Exception {
int pageIndex = vo.getPageIndex() < 1 ? 1 : vo.getPageIndex();
int perPage = vo.getRecordCountPerPage() < 1 ? 10 : vo.getRecordCountPerPage();
vo.setFirstIndex((pageIndex - 1) * perPage);
vo.setRecordCountPerPage(perPage);
vo.setTotalRecordCount(authorWorkflowDAO.selectUserAuthorListCount(vo));
return authorWorkflowDAO.selectUserAuthorList(vo);
}
@Override
public int selectPendingRequestCount() throws Exception {
return authorWorkflowDAO.selectPendingRequestCount();
}
@Override
public List<egovframework.rte.psl.dataaccess.util.EgovMap> selectOrgnztList() throws Exception {
return authorWorkflowDAO.selectOrgnztList();
}
/** 신청구분(N/C/R) → 이력 변경구분(G:부여/M:변경/R:회수) */
private String mapChgSeCode(String requestSe) {
if ("R".equals(requestSe)) {

116
src/main/java/egovframework/com/cmm/privacy/author/PrivacyUserAuthorVO.java
View File

@ -1,116 +0,0 @@
package egovframework.com.cmm.privacy.author;
import java.io.Serializable;
/**
* 개인정보취급자 권한 관리 목록 VO (개인정보보호 SFR-001 / #3 화면 #46).
*
* <p>취급자(COMTNEMPLYRINFO) 1행 = 목록 1행. 소속기관(COMTNORGNZTINFO),
* 역할·접근범위(COMTNEMPLYRSCRTYESTBS + COMTNAUTHORINFO), 권한상태(대기신청/권한유무),
* 최근변경일(AUTHOR_CHANGE_HISTORY)을 조인해 한 화면에 제공한다.</p>
*
* <pre>
* 개정이력
* 2026.08.07 URP 최초 생성 — 신청목록 화면을 취급자 권한현황 화면으로 재구성
* </pre>
*/
public class PrivacyUserAuthorVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 취급자 계정ID (COMTNEMPLYRINFO.EMPLYR_ID) */
private String emplyrId;
/** 취급자 고유식별자 (ESNTL_ID) */
private String uniqId;
/** 취급자명 */
private String userNm;
/** 소속기관 ID */
private String orgnztId;
/** 소속기관명 */
private String orgnztNm;
/** 역할 권한코드 */
private String authorCode;
/** 역할명(Role) */
private String authorNm;
/** 변경 전 역할명 — 승인대기 신청이 있으면 그 신청의 변경전권한, 없으면 최근 이력의 변경전권한 */
private String beforeAuthorNm;
/** 변경 후 역할명 — 승인대기 신청이 있으면 신청 목표권한, 없으면 현재 역할(=최근 이력의 변경후권한) */
private String afterAuthorNm;
/** 처리대기 신청구분 N:신설 C:변경 R:회수 (대기 신청 없으면 null) */
private String pendingRequestSe;
/** 접근범위 — 권한설명 없으면 허용 메뉴 수로 대체 */
private String accessScope;
/** 권한상태 N:정상 W:승인대기 R:말소 */
private String authorSttus;
/** 최근변경일 (yyyy-MM-dd) */
private String lastChgDt;
/** 처리대기 신청 일련번호 — 승인/반려 버튼용(없으면 0) */
private long pendingRequestId;
/** 계정상태 코드 P:사용 A:승인대기 S:사용중지 D:말소 */
private String emplyrSttusCode;
// --- 검색조건 ---
/** 소속기관 */
private String searchOrgnztId;
/** 역할(권한코드) */
private String searchAuthorCode;
/** 권한상태 N/W/R */
private String searchAuthorSttus;
/** 취급자명 또는 계정ID */
private String searchKeyword;
// --- 페이징 ---
private int pageIndex = 1;
private int recordCountPerPage = 10;
private int firstIndex = 0;
private int totalRecordCount = 0;
public String getEmplyrId() { return emplyrId; }
public void setEmplyrId(String emplyrId) { this.emplyrId = emplyrId; }
public String getUniqId() { return uniqId; }
public void setUniqId(String uniqId) { this.uniqId = uniqId; }
public String getUserNm() { return userNm; }
public void setUserNm(String userNm) { this.userNm = userNm; }
public String getOrgnztId() { return orgnztId; }
public void setOrgnztId(String orgnztId) { this.orgnztId = orgnztId; }
public String getOrgnztNm() { return orgnztNm; }
public void setOrgnztNm(String orgnztNm) { this.orgnztNm = orgnztNm; }
public String getAuthorCode() { return authorCode; }
public void setAuthorCode(String authorCode) { this.authorCode = authorCode; }
public String getAuthorNm() { return authorNm; }
public void setAuthorNm(String authorNm) { this.authorNm = authorNm; }
public String getBeforeAuthorNm() { return beforeAuthorNm; }
public void setBeforeAuthorNm(String beforeAuthorNm) { this.beforeAuthorNm = beforeAuthorNm; }
public String getAfterAuthorNm() { return afterAuthorNm; }
public void setAfterAuthorNm(String afterAuthorNm) { this.afterAuthorNm = afterAuthorNm; }
public String getPendingRequestSe() { return pendingRequestSe; }
public void setPendingRequestSe(String pendingRequestSe) { this.pendingRequestSe = pendingRequestSe; }
public String getAccessScope() { return accessScope; }
public void setAccessScope(String accessScope) { this.accessScope = accessScope; }
public String getAuthorSttus() { return authorSttus; }
public void setAuthorSttus(String authorSttus) { this.authorSttus = authorSttus; }
public String getLastChgDt() { return lastChgDt; }
public void setLastChgDt(String lastChgDt) { this.lastChgDt = lastChgDt; }
public long getPendingRequestId() { return pendingRequestId; }
public void setPendingRequestId(long pendingRequestId) { this.pendingRequestId = pendingRequestId; }
public String getEmplyrSttusCode() { return emplyrSttusCode; }
public void setEmplyrSttusCode(String emplyrSttusCode) { this.emplyrSttusCode = emplyrSttusCode; }
public String getSearchOrgnztId() { return searchOrgnztId; }
public void setSearchOrgnztId(String searchOrgnztId) { this.searchOrgnztId = searchOrgnztId; }
public String getSearchAuthorCode() { return searchAuthorCode; }
public void setSearchAuthorCode(String searchAuthorCode) { this.searchAuthorCode = searchAuthorCode; }
public String getSearchAuthorSttus() { return searchAuthorSttus; }
public void setSearchAuthorSttus(String searchAuthorSttus) { this.searchAuthorSttus = searchAuthorSttus; }
public String getSearchKeyword() { return searchKeyword; }
public void setSearchKeyword(String searchKeyword) { this.searchKeyword = searchKeyword; }
public int getPageIndex() { return pageIndex; }
public void setPageIndex(int pageIndex) { this.pageIndex = pageIndex; }
public int getRecordCountPerPage() { return recordCountPerPage; }
public void setRecordCountPerPage(int recordCountPerPage) { this.recordCountPerPage = recordCountPerPage; }
public int getFirstIndex() { return firstIndex; }
public void setFirstIndex(int firstIndex) { this.firstIndex = firstIndex; }
public int getTotalRecordCount() { return totalRecordCount; }
public void setTotalRecordCount(int totalRecordCount) { this.totalRecordCount = totalRecordCount; }
}

194
src/main/java/egovframework/com/cmm/privacy/conect/ConectLogController.java
View File

@ -1,194 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.privacy.auditlog.ClientIpResolver;
import egovframework.com.cmm.util.EgovUserDetailsHelper;
import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
/**
* 로그인·로그아웃 접속기록 조회·다운로드 컨트롤러 — 개인정보보호 기능개선 사업(#62).
*
* <p>{@code COMTNLOGINLOG} 적재분(접속ID·접속일시·접속IP·접속위치)을 조건별로 검색하고
* CSV 로 내려받는다. 화면: {@code /WEB-INF/jsp/site/mnt/sec/conectLog/list.jsp}</p>
*
* <p><b>다운로드:</b> 사유 입력이 필수이며 미입력 시 400 으로 차단하고 파일을 열지 않는다.
* 다운로드자·일시·IP·사유·건수는 {@code PDAL_DOWNLOAD_HISTORY}(#42 재사용)에 적재된다.</p>
*
* <p><b>접근통제:</b> 인터셉터 3단 중 ①인증판정이 비활성이고 ②③은 fail-open 이라
* /mnt 하위라도 무인증 노출이 가능하므로, {@link #handlerUser()} 로 화면·엔드포인트
* 단에서 직접 판정한다(PersonalDataAccessLogController 와 동일 방식).</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 #62)
* </pre>
*/
@Controller
public class ConectLogController {
private static final String LOGIN_REDIRECT = "redirect:/uat/uia/egovLoginUsr.do";
@Resource(name = "conectLogService")
private ConectLogService conectLogService;
/**
* 로그인·로그아웃 접속기록 조회 화면(서버 렌더링).
* 뷰: /WEB-INF/jsp/site/mnt/sec/conectLog/list.jsp
*/
@RequestMapping(value = "/mnt/sec/conectLog/listView.do")
public String listView(@ModelAttribute("conectLogVO") ConectLogVO searchVO,
ModelMap model) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
// selectConectLogList 내부에서 firstIndex/totalRecordCount 를 세팅한다.
List<ConectLogVO> list = conectLogService.selectConectLogList(searchVO);
PaginationInfo paginationInfo = new PaginationInfo();
paginationInfo.setCurrentPageNo(searchVO.getPageIndex());
paginationInfo.setRecordCountPerPage(searchVO.getRecordCountPerPage());
paginationInfo.setPageSize(10);
paginationInfo.setTotalRecordCount(searchVO.getTotalRecordCount());
model.addAttribute("resultList", list);
model.addAttribute("paginationInfo", paginationInfo);
model.addAttribute("conectLcList", selectConectLcList());
return "site/mnt/sec/conectLog/list";
}
/** 접속기록 목록(AJAX/JSON). */
@RequestMapping(value = "/mnt/privacy/conectLogList.do")
public String selectList(@ModelAttribute("searchVO") ConectLogVO searchVO,
ModelMap model) throws Exception {
if (handlerUser() == null) {
model.addAttribute("result", "fail");
model.addAttribute("message", "접근 권한이 없습니다. 관리자 계정으로 로그인 후 이용하세요.");
return "jsonView";
}
model.addAttribute("resultList", conectLogService.selectConectLogList(searchVO));
model.addAttribute("totalCount", Integer.valueOf(searchVO.getTotalRecordCount()));
return "jsonView";
}
/**
* 접속기록 다운로드(CSV) — 사유 필수 + 다운로드 이력 적재.
* 사유 미입력·차단 시 파일을 열지 않고 400 으로 응답한다.
*/
@RequestMapping(value = "/mnt/sec/conectLog/download.do")
public void download(@ModelAttribute("conectLogVO") ConectLogVO searchVO,
@RequestParam(value = "dlReason", required = false) String dlReason,
HttpServletRequest request, HttpServletResponse response) throws Exception {
LoginVO user = handlerUser();
if (user == null) {
response.sendError(HttpServletResponse.SC_FORBIDDEN, "접근 권한이 없습니다.");
return;
}
List<ConectLogVO> list;
try {
list = conectLogService.downloadConectLog(user.getId(),
ClientIpResolver.getClientIp(request), dlReason, searchVO);
} catch (IllegalArgumentException e) {
// 사유 미입력 등 차단 — 다운로드를 열지 않고 오류만 응답
response.sendError(HttpServletResponse.SC_BAD_REQUEST, e.getMessage());
return;
}
String fileName = URLEncoder.encode(
"로그인접속기록_" + new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + ".csv", "UTF-8");
response.setContentType("text/csv; charset=UTF-8");
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"; filename*=UTF-8''" + fileName);
response.setHeader("Content-Transfer-Encoding", "binary");
OutputStream os = response.getOutputStream();
os.write(0xEF); os.write(0xBB); os.write(0xBF); // UTF-8 BOM (엑셀 한글 호환)
PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
pw.println("로그번호,접속일시,접속ID,성명,사용자구분,접속구분,접속IP,접속위치");
if (list != null) {
for (ConectLogVO log : list) {
pw.println(csv(log.getLogId()) + "," + csv(log.getCreatDt())
+ "," + csv(log.getUserId()) + "," + csv(log.getUserNm())
+ "," + csv(userSeLabel(log.getUserSe()))
+ "," + csv(mthdLabel(log.getConectMthd()))
+ "," + csv(log.getConectIp()) + "," + csv(log.getConectLc()));
}
}
pw.flush();
}
/**
* 검색조건 드롭다운용 접속위치 목록.
* 조회 실패해도 화면은 떠야 하므로 빈 목록으로 fail-safe.
*/
private List<String> selectConectLcList() {
try {
List<String> list = conectLogService.selectConectLcList();
return (list == null) ? new ArrayList<String>() : list;
} catch (Exception e) {
return new ArrayList<String>();
}
}
/** CSV 셀 이스케이프(구분자·따옴표·개행 방어). */
private String csv(String v) {
if (v == null) {
return "";
}
String s = v.replace("\"", "\"\"");
return "\"" + s.replace("\r", " ").replace("\n", " ") + "\"";
}
private String mthdLabel(String code) {
if ("I".equals(code)) return "로그인";
if ("O".equals(code)) return "로그아웃";
return code;
}
private String userSeLabel(String code) {
if ("USR".equals(code)) return "업무사용자";
if ("GNR".equals(code)) return "개인";
if ("GRO".equals(code)) return "그룹";
if ("ENT".equals(code)) return "활동처";
return code;
}
/**
* 취급자 영역(/mnt) 인증·구분 판정.
*
* @return 인증된 업무사용자(USR) LoginVO, 그 외에는 null
*/
private LoginVO handlerUser() {
if (!Boolean.TRUE.equals(EgovUserDetailsHelper.isAuthenticated())) {
return null;
}
Object o = EgovUserDetailsHelper.getAuthenticatedUser();
if (!(o instanceof LoginVO)) {
return null;
}
LoginVO loginVO = (LoginVO) o;
return "USR".equals(loginVO.getUserSe()) ? loginVO : null;
}
}

52
src/main/java/egovframework/com/cmm/privacy/conect/ConectLogDAO.java
View File

@ -1,52 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 로그인·로그아웃 접속기록 DAO — 개인정보보호 기능개선 사업(#62).
*
* <p>{@code COMTNLOGINLOG} 조회 전용. 이 화면은 접속기록에 대한 수정·삭제를
* 제공하지 않는다(위·변조 방지) — UPDATE/DELETE statement 를 정의하지 않는다.
* statement 는 {@code PrivacyConectLog_SQL_Mysql.xml}
* (namespace {@code ConectLogDAO}), sql-map-config 등록.</p>
*
* @author URP
* @since 2026-08-07
*/
@Repository("conectLogDAO")
public class ConectLogDAO extends EgovComAbstractDAO {
/** 조건별 목록(페이징). */
@SuppressWarnings("unchecked")
public List<ConectLogVO> selectConectLogList(ConectLogVO searchVO) {
return list("ConectLogDAO.selectConectLogList", searchVO);
}
/** 조건별 총건수. */
public int selectConectLogListCount(ConectLogVO searchVO) {
Object cnt = selectByPk("ConectLogDAO.selectConectLogListCount", searchVO);
return (cnt == null) ? 0 : ((Integer) cnt).intValue();
}
/** 다운로드용 목록(페이징 없음, 상한은 서비스에서 건다). */
@SuppressWarnings("unchecked")
public List<ConectLogVO> selectConectLogListForDownload(ConectLogVO searchVO) {
return list("ConectLogDAO.selectConectLogListForDownload", searchVO);
}
/**
* 검색조건 드롭다운용 접속위치 목록.
*
* <p>설정 대역(CONECT_IP_LOCATION)과 <b>실제 적재된 값</b>(COMTNLOGINLOG DISTINCT)을
* 합친다. #32-1 에서 겪은 함정 — 매핑 테이블만 보면 실제 적재값과 어긋난 선택지가 떠
* 검색 결과가 항상 0건이 된다 — 을 피하기 위한 것이다.</p>
*/
@SuppressWarnings("unchecked")
public List<String> selectConectLcList() {
return list("ConectLogDAO.selectConectLcList", null);
}
}

31
src/main/java/egovframework/com/cmm/privacy/conect/ConectLogService.java
View File

@ -1,31 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.util.List;
/**
* 로그인·로그아웃 접속기록 조회·다운로드 서비스 — 개인정보보호 기능개선 사업(#62).
*
* @author URP
* @since 2026-08-07
*/
public interface ConectLogService {
/** 조건별 접속기록 목록(페이징). searchVO 에 firstIndex/totalRecordCount 를 채워 돌려준다. */
List<ConectLogVO> selectConectLogList(ConectLogVO searchVO) throws Exception;
/** 검색조건 드롭다운용 접속위치 목록. */
List<String> selectConectLcList() throws Exception;
/**
* 접속기록 다운로드 — <b>사유 필수</b>.
*
* @param downloaderId 다운로드자 계정ID
* @param downloaderIp 다운로드자 접속 IP
* @param dlReason 다운로드 사유(공백이면 차단)
* @param searchVO 검색조건
* @return 다운로드 대상 목록
* @throws IllegalArgumentException 사유 미입력
*/
List<ConectLogVO> downloadConectLog(String downloaderId, String downloaderIp,
String dlReason, ConectLogVO searchVO) throws Exception;
}

122
src/main/java/egovframework/com/cmm/privacy/conect/ConectLogServiceImpl.java
View File

@ -1,122 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import egovframework.com.cmm.privacy.auditlog.AccessLogDownloadHistoryDAO;
import egovframework.com.cmm.privacy.auditlog.AccessLogDownloadHistoryVO;
/**
* 로그인·로그아웃 접속기록 조회·다운로드 서비스 구현 — 개인정보보호 기능개선 사업(#62).
*
* <p><b>다운로드 이력:</b> 별도 테이블을 만들지 않고 {@code PDAL_DOWNLOAD_HISTORY}(#42)를
* 재사용한다. 어떤 화면에서 받아간 것인지 구분되도록 검색조건 요약 앞에
* {@code [로그인기록]} 을 붙인다. 개인정보 본문은 이력에 남기지 않는다(검색조건 요약만).</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 #62)
* </pre>
*/
@Service("conectLogService")
public class ConectLogServiceImpl implements ConectLogService {
/** 1회 다운로드 상한(건). 무제한 반출·OOM 방지. */
private static final int DOWNLOAD_LIMIT = 100000;
/** 다운로드 이력 구분 표식(PDAL_DOWNLOAD_HISTORY 공용 사용). */
private static final String DL_TAG = "[로그인기록] ";
@Resource(name = "conectLogDAO")
private ConectLogDAO conectLogDAO;
@Resource(name = "accessLogDownloadHistoryDAO")
private AccessLogDownloadHistoryDAO accessLogDownloadHistoryDAO;
@Override
public List<ConectLogVO> selectConectLogList(ConectLogVO searchVO) throws Exception {
normalize(searchVO);
searchVO.setFirstIndex((searchVO.getPageIndex() - 1) * searchVO.getRecordCountPerPage());
searchVO.setTotalRecordCount(conectLogDAO.selectConectLogListCount(searchVO));
return conectLogDAO.selectConectLogList(searchVO);
}
@Override
public List<String> selectConectLcList() throws Exception {
List<String> list = conectLogDAO.selectConectLcList();
return (list == null) ? new ArrayList<String>() : list;
}
@Override
public List<ConectLogVO> downloadConectLog(String downloaderId, String downloaderIp,
String dlReason, ConectLogVO searchVO) throws Exception {
// 사유 미입력이면 조회 자체를 하지 않는다 — 이력 없는 반출을 원천 차단.
if (dlReason == null || dlReason.trim().length() == 0) {
throw new IllegalArgumentException("다운로드 사유는 필수입니다.");
}
normalize(searchVO);
searchVO.setFirstIndex(0);
searchVO.setRecordCountPerPage(DOWNLOAD_LIMIT);
List<ConectLogVO> list = conectLogDAO.selectConectLogListForDownload(searchVO);
if (list == null) {
list = new ArrayList<ConectLogVO>();
}
AccessLogDownloadHistoryVO history = new AccessLogDownloadHistoryVO();
history.setDownloaderId(downloaderId);
history.setDownloaderIp(downloaderIp);
history.setDlReason(dlReason.trim());
history.setSearchCond(summarize(searchVO));
history.setResultCnt(list.size());
accessLogDownloadHistoryDAO.insertDownloadHistory(history);
return list;
}
/** 페이징 파라미터 방어(음수·0·과대 요청). */
private void normalize(ConectLogVO searchVO) {
if (searchVO.getPageIndex() < 1) {
searchVO.setPageIndex(1);
}
if (searchVO.getRecordCountPerPage() < 1 || searchVO.getRecordCountPerPage() > 100) {
searchVO.setRecordCountPerPage(10);
}
}
/**
* 검색조건 요약(개인정보 본문 미포함). PDAL_DOWNLOAD_HISTORY.SEARCH_COND 는
* VARCHAR(1000) 이므로 넘치면 자른다.
*/
private String summarize(ConectLogVO vo) {
StringBuilder sb = new StringBuilder(DL_TAG);
append(sb, "접속ID", vo.getSearchUserId());
append(sb, "접속구분", vo.getSearchMthd());
append(sb, "사용자구분", vo.getSearchUserSe());
append(sb, "IP", vo.getSearchIp());
append(sb, "접속위치", vo.getSearchLc());
append(sb, "기간", nvl(vo.getSearchBgnDe()) + "~" + nvl(vo.getSearchEndDe()));
String s = sb.toString();
return (s.length() > 1000) ? s.substring(0, 1000) : s;
}
private void append(StringBuilder sb, String label, String value) {
if (value != null && value.trim().length() > 0 && !"~".equals(value.trim())) {
if (sb.length() > DL_TAG.length()) {
sb.append(", ");
}
sb.append(label).append('=').append(value.trim());
}
}
private String nvl(String s) {
return (s == null) ? "" : s.trim();
}
}

115
src/main/java/egovframework/com/cmm/privacy/conect/ConectLogVO.java
View File

@ -1,115 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.io.Serializable;
/**
* 로그인·로그아웃 접속기록 VO — 개인정보보호 기능개선 사업(#62).
*
* <p>{@code COMTNLOGINLOG} 조회 결과 + 검색조건 + 페이징.</p>
*
* <p><b>접속ID 주의:</b> {@code COMTNLOGINLOG.CONECT_ID}({@link #conectId})는 고유식별자
* 자리인데 실제 적재값이 16자리 hex 라 회원 테이블 어디와도 매칭되지 않는다(2026-08-07
* 373,959행 실측). 그래서 화면의 '접속ID'({@link #userId})는 조인 결과가 아니라 적재 시점에
* 세션 {@code LoginVO.getId()} 를 직접 남긴 {@code CONECT_ACNT_ID} 값이다.
* 2026-08-07 이전 기록은 이 값이 없어 화면이 {@link #conectId} 를 대신 보여준다.</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 #62)
* </pre>
*/
public class ConectLogVO implements Serializable {
private static final long serialVersionUID = 1L;
// ---- 조회 결과 ----
/** 로그 일련번호(COMTNLOGINLOG.LOG_ID). */
private String logId;
/** 접속일시(yyyy-MM-dd HH:mm:ss). */
private String creatDt;
/** 접속구분 I:로그인 O:로그아웃. */
private String conectMthd;
/** 접속 IP. */
private String conectIp;
/** 접속위치명(적재시점 스냅샷). */
private String conectLc;
/** 고유식별자(원본 CONECT_ID). */
private String conectId;
/** 접속ID(계정ID — CONECT_ACNT_ID. 2026-08-07 이전 레거시 기록은 null). */
private String userId;
/** 성명/기관명(표시용 보조 조회 — 탈퇴 등으로 대조 실패 시 null). */
private String userNm;
/** 사용자구분 USR:업무사용자 GNR:개인 GRO:그룹 ENT:활동처. */
private String userSe;
/** 오류발생여부 Y/N. */
private String errOccrrAt;
// ---- 검색조건 ----
/** 접속ID(계정ID, 부분일치). */
private String searchUserId;
/** 접속구분(I/O, 공백=전체). */
private String searchMthd;
/** 사용자구분(USR/GNR/GRO/ENT, 공백=전체). */
private String searchUserSe;
/** 접속 IP(부분일치). */
private String searchIp;
/** 접속위치(완전일치, 공백=전체). */
private String searchLc;
/** 조회 시작일(yyyy-MM-dd). */
private String searchBgnDe;
/** 조회 종료일(yyyy-MM-dd). */
private String searchEndDe;
// ---- 페이징 ----
private int pageIndex = 1;
private int recordCountPerPage = 10;
private int firstIndex = 0;
private int totalRecordCount = 0;
public String getLogId() { return logId; }
public void setLogId(String logId) { this.logId = logId; }
public String getCreatDt() { return creatDt; }
public void setCreatDt(String creatDt) { this.creatDt = creatDt; }
public String getConectMthd() { return conectMthd; }
public void setConectMthd(String conectMthd) { this.conectMthd = conectMthd; }
public String getConectIp() { return conectIp; }
public void setConectIp(String conectIp) { this.conectIp = conectIp; }
public String getConectLc() { return conectLc; }
public void setConectLc(String conectLc) { this.conectLc = conectLc; }
public String getConectId() { return conectId; }
public void setConectId(String conectId) { this.conectId = conectId; }
public String getUserId() { return userId; }
public void setUserId(String userId) { this.userId = userId; }
public String getUserNm() { return userNm; }
public void setUserNm(String userNm) { this.userNm = userNm; }
public String getUserSe() { return userSe; }
public void setUserSe(String userSe) { this.userSe = userSe; }
public String getErrOccrrAt() { return errOccrrAt; }
public void setErrOccrrAt(String errOccrrAt) { this.errOccrrAt = errOccrrAt; }
public String getSearchUserId() { return searchUserId; }
public void setSearchUserId(String searchUserId) { this.searchUserId = searchUserId; }
public String getSearchMthd() { return searchMthd; }
public void setSearchMthd(String searchMthd) { this.searchMthd = searchMthd; }
public String getSearchUserSe() { return searchUserSe; }
public void setSearchUserSe(String searchUserSe) { this.searchUserSe = searchUserSe; }
public String getSearchIp() { return searchIp; }
public void setSearchIp(String searchIp) { this.searchIp = searchIp; }
public String getSearchLc() { return searchLc; }
public void setSearchLc(String searchLc) { this.searchLc = searchLc; }
public String getSearchBgnDe() { return searchBgnDe; }
public void setSearchBgnDe(String searchBgnDe) { this.searchBgnDe = searchBgnDe; }
public String getSearchEndDe() { return searchEndDe; }
public void setSearchEndDe(String searchEndDe) { this.searchEndDe = searchEndDe; }
public int getPageIndex() { return pageIndex; }
public void setPageIndex(int pageIndex) { this.pageIndex = pageIndex; }
public int getRecordCountPerPage() { return recordCountPerPage; }
public void setRecordCountPerPage(int recordCountPerPage) { this.recordCountPerPage = recordCountPerPage; }
public int getFirstIndex() { return firstIndex; }
public void setFirstIndex(int firstIndex) { this.firstIndex = firstIndex; }
public int getTotalRecordCount() { return totalRecordCount; }
public void setTotalRecordCount(int totalRecordCount) { this.totalRecordCount = totalRecordCount; }
}

26
src/main/java/egovframework/com/cmm/privacy/conect/IpLocationDAO.java
View File

@ -1,26 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 접속위치 매핑 DAO — 개인정보보호 기능개선 사업(#62).
*
* <p>statement 는 {@code PrivacyConectLog_SQL_Mysql.xml}
* (namespace {@code ConectLogDAO})에 함께 정의되어 있다.</p>
*
* @author URP
* @since 2026-08-07
*/
@Repository("ipLocationDAO")
public class IpLocationDAO extends EgovComAbstractDAO {
/** 사용중(USE_AT='Y')인 IP 대역 매핑 전체. */
@SuppressWarnings("unchecked")
public List<IpLocationVO> selectUsedLocationList() {
return list("ConectLogDAO.selectUsedLocationList", null);
}
}

189
src/main/java/egovframework/com/cmm/privacy/conect/IpLocationResolver.java
View File

@ -1,189 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
/**
* IP → 접속위치명 판정기 — 개인정보보호 기능개선 사업(#62).
*
* <p>{@code CONECT_IP_LOCATION}(IP 대역 → 위치명)을 캐시해 두고, 접속 IP 가 속하는
* 대역 중 <b>가장 긴 프리픽스</b> 1건의 위치명을 돌려준다. 매칭이 없으면
* 사설/루프백 대역 판정에 따른 내장 폴백을 쓴다 — 테이블이 비어 있어도 동작한다.</p>
*
* <p><b>왜 스냅샷인가:</b> 판정 결과는 적재 시점에
* {@code COMTNLOGINLOG.CONECT_LC} 로 기록된다. 나중에 대역 매핑을 바꿔도 과거
* 기록의 접속위치는 변하지 않아야 감사증빙으로 쓸 수 있다.</p>
*
* <p><b>fail-safe:</b> 이 판정은 로그인/로그아웃 경로에서 호출된다. 어떤 예외도
* 밖으로 던지지 않고 폴백 값을 돌려준다 — 접속위치 때문에 로그인이 막히면 안 된다.</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 #62)
* </pre>
*/
@Component("ipLocationResolver")
public class IpLocationResolver {
/** 매칭 실패 시 기본 위치명. */
public static final String LOC_EXTERNAL = "외부(인터넷)";
/** 사설 대역 폴백. */
public static final String LOC_INTERNAL = "내부망";
/** 루프백 폴백. */
public static final String LOC_LOCAL = "서버 로컬";
/** IP 자체를 못 얻은 경우. */
public static final String LOC_UNKNOWN = "확인불가";
/** 캐시 재적재 주기(ms). 운영 중 대역 행을 추가해도 이 주기 안에 반영된다. */
private static final long RELOAD_INTERVAL_MS = 5L * 60L * 1000L;
@Resource(name = "ipLocationDAO")
private IpLocationDAO ipLocationDAO;
/** 프리픽스 길이 내림차순으로 정렬된 매핑 캐시(가장 긴 것이 먼저 매칭된다). */
private volatile List<IpLocationVO> cache = new ArrayList<IpLocationVO>();
/** 마지막 적재 시각(0 = 미적재). */
private volatile long loadedAt = 0L;
/**
* 접속 IP 의 위치명을 판정한다.
*
* @param ip 점 표기 IPv4(IPv6/불명이면 폴백)
* @return 위치명(항상 비어 있지 않은 문자열)
*/
public String resolve(String ip) {
if (ip == null || ip.trim().length() == 0 || "unknown".equalsIgnoreCase(ip.trim())) {
return LOC_UNKNOWN;
}
String target = ip.trim();
long addr = ipv4ToLong(target);
if (addr < 0L) {
// IPv6 등 — 루프백만 별도로 알아보고 나머지는 외부로 본다.
return ("::1".equals(target) || "0:0:0:0:0:0:0:1".equals(target)) ? LOC_LOCAL : LOC_EXTERNAL;
}
for (IpLocationVO loc : currentCache()) {
if (loc.getPrefixLen() < 0) {
continue; // 파싱 불가 행은 무시(운영자가 잘못 입력해도 판정은 계속된다)
}
long mask = (loc.getPrefixLen() == 0) ? 0L : (0xFFFFFFFFL << (32 - loc.getPrefixLen())) & 0xFFFFFFFFL;
if ((addr & mask) == (loc.getNetwork() & mask)) {
return (loc.getLocNm() == null || loc.getLocNm().length() == 0) ? LOC_EXTERNAL : loc.getLocNm();
}
}
return fallback(addr);
}
/** 매핑 캐시를 즉시 비운다(대역 행을 고친 직후 반영용). */
public void refresh() {
loadedAt = 0L;
}
/** 유효기간이 지났으면 다시 읽고, 실패하면 직전 캐시를 그대로 쓴다. */
private List<IpLocationVO> currentCache() {
long now = System.currentTimeMillis();
if (loadedAt != 0L && (now - loadedAt) < RELOAD_INTERVAL_MS) {
return cache;
}
try {
List<IpLocationVO> loaded = ipLocationDAO.selectUsedLocationList();
if (loaded == null) {
loaded = new ArrayList<IpLocationVO>();
}
for (IpLocationVO loc : loaded) {
parseCidr(loc);
}
Collections.sort(loaded, new Comparator<IpLocationVO>() {
public int compare(IpLocationVO a, IpLocationVO b) {
// 프리픽스가 긴(=더 구체적인) 대역이 먼저 매칭되어야 한다.
return b.getPrefixLen() - a.getPrefixLen();
}
});
cache = loaded;
loadedAt = now;
} catch (Exception e) {
// 테이블 미적용·DB 일시 오류 — 직전 캐시(초기엔 빈 목록)로 계속 판정한다.
loadedAt = now; // 매 요청마다 실패 조회를 반복하지 않도록 주기는 넘긴다
}
return cache;
}
/** "10.0.0.0/8" → network/prefixLen. 형식 오류면 prefixLen = -1(무시 대상). */
private void parseCidr(IpLocationVO loc) {
loc.setNetwork(-1L);
loc.setPrefixLen(-1);
String cidr = loc.getIpCidr();
if (cidr == null) {
return;
}
String trimmed = cidr.trim();
int slash = trimmed.indexOf('/');
String network = (slash < 0) ? trimmed : trimmed.substring(0, slash);
int prefix;
try {
prefix = (slash < 0) ? 32 : Integer.parseInt(trimmed.substring(slash + 1).trim());
} catch (NumberFormatException e) {
return;
}
if (prefix < 0 || prefix > 32) {
return;
}
long net = ipv4ToLong(network);
if (net < 0L) {
return;
}
loc.setNetwork(net);
loc.setPrefixLen(prefix);
}
/** 테이블 매칭이 없을 때의 내장 판정(루프백/사설/그 외). */
private String fallback(long addr) {
if (inCidr(addr, "127.0.0.0", 8)) {
return LOC_LOCAL;
}
if (inCidr(addr, "10.0.0.0", 8) || inCidr(addr, "172.16.0.0", 12) || inCidr(addr, "192.168.0.0", 16)) {
return LOC_INTERNAL;
}
return LOC_EXTERNAL;
}
private boolean inCidr(long addr, String network, int prefix) {
long net = ipv4ToLong(network);
long mask = (0xFFFFFFFFL << (32 - prefix)) & 0xFFFFFFFFL;
return (addr & mask) == (net & mask);
}
/** 점 표기 IPv4 → 부호없는 long. 형식 오류(IPv6 포함) 시 -1. */
private static long ipv4ToLong(String ip) {
if (ip == null) {
return -1L;
}
String[] octets = ip.trim().split("\\.");
if (octets.length != 4) {
return -1L;
}
long result = 0L;
for (String octet : octets) {
int v;
try {
v = Integer.parseInt(octet.trim());
} catch (NumberFormatException e) {
return -1L;
}
if (v < 0 || v > 255) {
return -1L;
}
result = (result << 8) | v;
}
return result & 0xFFFFFFFFL;
}
}

64
src/main/java/egovframework/com/cmm/privacy/conect/IpLocationVO.java
View File

@ -1,64 +0,0 @@
package egovframework.com.cmm.privacy.conect;
import java.io.Serializable;
/**
* 접속위치 매핑 VO — 개인정보보호 기능개선 사업(#62, 로그인·로그아웃 접속기록).
*
* <p>{@code CONECT_IP_LOCATION} 1행. IP 대역(CIDR)과 그 대역에 붙일 위치명이다.
* 접속기록 적재 시점에 {@link IpLocationResolver}가 가장 긴 프리픽스 1건을 골라
* {@code COMTNLOGINLOG.CONECT_LC}에 스냅샷으로 남긴다 — 나중에 매핑을 바꿔도
* 과거 기록의 위치는 변하지 않는다(감사증빙).</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 #62)
* </pre>
*/
public class IpLocationVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 일련번호(PK). */
private long locId;
/** IP 대역(CIDR 표기. 예 "10.0.0.0/8", "203.0.113.7/32"). */
private String ipCidr;
/** 접속위치명. */
private String locNm;
/** 내외부 구분 I:내부망 E:외부. */
private String locSe;
/** 정렬순서. */
private int sortOrdr;
/** 사용여부 Y/N. */
private String useAt;
/** 비고. */
private String remark;
// ---- CIDR 파싱 결과(캐시 적재 시 1회 계산, DB 컬럼 아님) ----
/** 네트워크 주소(부호없는 IPv4). 파싱 실패 시 -1. */
private transient long network = -1L;
/** 프리픽스 길이(0~32). 파싱 실패 시 -1. */
private transient int prefixLen = -1;
public long getLocId() { return locId; }
public void setLocId(long locId) { this.locId = locId; }
public String getIpCidr() { return ipCidr; }
public void setIpCidr(String ipCidr) { this.ipCidr = ipCidr; }
public String getLocNm() { return locNm; }
public void setLocNm(String locNm) { this.locNm = locNm; }
public String getLocSe() { return locSe; }
public void setLocSe(String locSe) { this.locSe = locSe; }
public int getSortOrdr() { return sortOrdr; }
public void setSortOrdr(int sortOrdr) { this.sortOrdr = sortOrdr; }
public String getUseAt() { return useAt; }
public void setUseAt(String useAt) { this.useAt = useAt; }
public String getRemark() { return remark; }
public void setRemark(String remark) { this.remark = remark; }
public long getNetwork() { return network; }
public void setNetwork(long network) { this.network = network; }
public int getPrefixLen() { return prefixLen; }
public void setPrefixLen(int prefixLen) { this.prefixLen = prefixLen; }
}

181
src/main/java/egovframework/com/cmm/privacy/crypto/MemberDataCipher.java
View File

@ -1,181 +0,0 @@
/**
* Class Name : MemberDataCipher.java
* Description : 회원 개인정보 항목 대칭암호(AES-GCM) 헬퍼 — 개인정보보호 기능개선 사업(추가제안 Action4)
*
* Modification Information
*
* 수정일 수정자 수정내용
* ------- -------- ---------------------------
* 2026.08.10 개인정보보호 최초 생성 — 회원 이름(MBER_NM) 암호화 저장
*
* @since 2026. 08. 10
* @version 1.0
*/
package egovframework.com.cmm.privacy.crypto;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
/**
* 회원 개인정보 항목을 <b>가역 암호화(AES-128/GCM)</b>하여 저장하고, 표시 시점에만 복호화한다.
*
* <p><b>대상:</b> 1단계는 일반회원 이름({@code COMTNGNRLMBER.MBER_NM}, 실측 77,053건).
* 이메일·휴대폰·주소는 동일 클래스를 재사용해 후속 단계에서 확장한다.</p>
*
* <p><b>랜덤 IV를 쓰는 이유:</b> 같은 이름이라도 매번 다른 암호문이 나온다. 결정적 암호(고정 IV)를
* 쓰면 암호문만 보고 "이 두 회원은 동명이인"이라는 사실이 새어나가고, 빈도분석으로 흔한 이름부터
* 역추적된다. 대신 <u>검색이 불가능해지므로</u> 완전일치 검색은
* {@link MemberDataHasher}의 해시 컬럼이 전담한다.</p>
*
* <p><b>저장 형식:</b> {@code Base64( IV(12) || ciphertext || GCM tag(16) )}.
* GCM은 무결성 태그를 포함하므로 저장된 암호문이 변조되면 복호화 시 예외가 발생한다 —
* 위·변조 탐지가 덤으로 따라온다.</p>
*
* <p><b>키 관리 — 이 클래스는 개발용 폴백을 두지 않는다.</b>
* 기존 {@code OtpSecretCipher}는 키 미설정 시 소스에 박힌 개발용 키로 폴백하는데, 회원정보에
* 그 방식을 승계하면 "암호화했으나 키가 소스에 있는 상태"가 되어 관리실태 점검 지적이 재발한다.
* 따라서 키가 없으면 {@link IllegalStateException}으로 <b>기동을 실패시킨다</b>. 조용히 약한
* 암호로 돌아가는 것보다 뜨는 편이 안전하다.</p>
*
* <p><b>키 설정:</b> 시스템 프로퍼티 {@code arko.mber.master.key} 또는 환경변수
* {@code ARKO_MBER_MASTER_KEY}에 <b>Base64 인코딩된 16바이트</b> 키를 넣는다.
* WAR 안에 두지 않는다(서버 {@code setenv.sh} 또는 퍼미션 600 키파일).</p>
*
* <pre>
* # 키 생성 예시
* openssl rand -base64 16
* </pre>
*
* <p><b>키 길이가 AES-128인 이유:</b> AES-256은 구형 JDK에서 JCE 무제한 정책 파일을 요구한다.
* 운영 JDK가 8u161 이상이면 무제한이 기본이므로 상향 가능하나, 운영 JDK 확인 전까지는
* {@code OtpSecretCipher}와 동일하게 128로 맞춰 배포 리스크를 없앤다.</p>
*
* <p><b>스레드 안전:</b> {@link Cipher}는 매 호출마다 새로 얻는다(재사용 불가). 이 클래스 자체는
* 불변이므로 싱글턴 빈으로 공유해도 된다.</p>
*/
public class MemberDataCipher {
private static final String TRANSFORMATION = "AES/GCM/NoPadding";
private static final int GCM_TAG_BITS = 128;
private static final int GCM_IV_BYTES = 12;
private static final int KEY_BYTES = 16; // AES-128
/** 마스터 키 시스템 프로퍼티명. */
public static final String MASTER_KEY_PROP = "arko.mber.master.key";
/** 마스터 키 환경변수명. */
public static final String MASTER_KEY_ENV = "ARKO_MBER_MASTER_KEY";
/**
* 현재 키 버전. 암호화한 행의 {@code CRYPTO_KEY_VER}에 함께 적재한다.
* 키를 교체할 때 이 값을 올리고 복호화 측에서 버전별 키를 선택하게 확장한다.
*/
public static final int CURRENT_KEY_VER = 1;
private final byte[] masterKey;
private final SecureRandom random = new SecureRandom();
/** 설정된 마스터 키로 생성한다. 키가 없으면 즉시 실패한다. */
public MemberDataCipher() {
this.masterKey = loadMasterKey();
}
/** 명시적 키 주입(테스트/키 교체용). */
public MemberDataCipher(byte[] key16) {
if (key16 == null || key16.length != KEY_BYTES) {
throw new IllegalArgumentException("AES-128 master key must be " + KEY_BYTES + " bytes");
}
this.masterKey = key16.clone();
}
/**
* 마스터 키를 로드한다.
* <b>폴백 없음</b> — 미설정·형식오류는 예외다.
*/
private static byte[] loadMasterKey() {
String b64 = System.getProperty(MASTER_KEY_PROP);
if (isBlank(b64)) {
b64 = System.getenv(MASTER_KEY_ENV);
}
if (isBlank(b64)) {
throw new IllegalStateException(
"[개인정보/암호화] 회원정보 마스터 키가 설정되지 않았습니다. "
+ "시스템 프로퍼티 " + MASTER_KEY_PROP + " 또는 환경변수 " + MASTER_KEY_ENV
+ " 에 Base64 인코딩된 16바이트 키를 설정하십시오. (생성: openssl rand -base64 16)");
}
byte[] key = Base64.decodeBase64(b64.trim().getBytes());
if (key.length != KEY_BYTES) {
throw new IllegalStateException(
"[개인정보/암호화] 마스터 키 길이가 올바르지 않습니다. 기대 " + KEY_BYTES
+ "바이트, 실제 " + key.length + "바이트. Base64 인코딩된 16바이트 키여야 합니다.");
}
return key;
}
/**
* 평문을 AES-GCM 암호화하여 Base64 문자열로 반환한다.
*
* <p>{@code null}은 {@code null}로, 빈 문자열은 빈 문자열로 그대로 돌려준다.
* arko는 회원 탈퇴 시 개인정보 컬럼을 빈 문자열로 채우는 로직이 있어
* ({@code EgovMberManage_SQL_Mysql.xml}) NULL과 ''를 구분해 보존해야 파기 상태가 뭉개지지 않는다.</p>
*
* @param plain 평문(null/빈문자 허용)
* @return 암호문 Base64. 입력이 null이면 null, 빈문자면 빈문자
*/
public String encrypt(String plain) throws Exception {
if (plain == null) {
return null;
}
if (plain.length() == 0) {
return "";
}
byte[] iv = new byte[GCM_IV_BYTES];
random.nextBytes(iv);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(masterKey, "AES"),
new GCMParameterSpec(GCM_TAG_BITS, iv));
byte[] ct = cipher.doFinal(plain.getBytes("UTF-8"));
byte[] out = new byte[iv.length + ct.length];
System.arraycopy(iv, 0, out, 0, iv.length);
System.arraycopy(ct, 0, out, iv.length, ct.length);
return new String(Base64.encodeBase64(out), "US-ASCII");
}
/**
* {@link #encrypt(String)} 결과를 복호화한다.
*
* <p>암호문이 변조됐거나 다른 키로 만든 것이면 GCM 태그 검증에 실패해 예외가 난다.
* 호출측은 이를 "복호화 실패"로 처리하고 <b>평문을 화면에 대체 출력하지 않는다</b>.</p>
*
* @param encryptedBase64 암호문 Base64(null/빈문자 허용)
* @return 평문. 입력이 null이면 null, 빈문자면 빈문자
*/
public String decrypt(String encryptedBase64) throws Exception {
if (encryptedBase64 == null) {
return null;
}
if (encryptedBase64.length() == 0) {
return "";
}
byte[] all = Base64.decodeBase64(encryptedBase64.getBytes("US-ASCII"));
if (all.length <= GCM_IV_BYTES) {
throw new IllegalArgumentException("암호문 길이가 비정상입니다: " + all.length + "바이트");
}
byte[] iv = new byte[GCM_IV_BYTES];
System.arraycopy(all, 0, iv, 0, GCM_IV_BYTES);
byte[] ct = new byte[all.length - GCM_IV_BYTES];
System.arraycopy(all, GCM_IV_BYTES, ct, 0, ct.length);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(masterKey, "AES"),
new GCMParameterSpec(GCM_TAG_BITS, iv));
return new String(cipher.doFinal(ct), "UTF-8");
}
private static boolean isBlank(String s) {
return s == null || s.trim().length() == 0;
}
}

162
src/main/java/egovframework/com/cmm/privacy/crypto/MemberDataHasher.java
View File

@ -1,162 +0,0 @@
/**
* Class Name : MemberDataHasher.java
* Description : 회원 개인정보 검색용 키드 해시(HMAC-SHA256) — 개인정보보호 기능개선 사업(추가제안 Action4)
*
* Modification Information
*
* 수정일 수정자 수정내용
* ------- -------- ---------------------------
* 2026.08.10 개인정보보호 최초 생성 — 이름 완전일치 검색용 해시
*
* @since 2026. 08. 10
* @version 1.0
*/
package egovframework.com.cmm.privacy.crypto;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
/**
* 암호화된 개인정보 항목의 <b>완전일치 검색</b>을 위한 키드 해시를 만든다.
*
* <p><b>왜 필요한가:</b> {@link MemberDataCipher}는 랜덤 IV라 같은 이름도 매번 다른 암호문이 된다.
* 따라서 암호문으로는 검색할 수 없다. 검색 전용으로 <u>결정적인</u> 값을 별도 컬럼
* ({@code MBER_NM_HASH})에 두고 인덱스를 건다.</p>
*
* <p><b>왜 순수 SHA-256이 아니라 HMAC인가:</b> 제안서 문구는 "SHA-256"이지만, 이름·휴대폰번호는
* 엔트로피가 극히 낮다. 한국인 이름은 사실상 수십만 가지, 휴대폰번호는 1억 미만이라 순수 해시는
* 전수대입 한 번으로 원문이 전부 복원된다 — 해시를 걸어도 평문이나 마찬가지가 된다.
* 비밀 pepper를 섞는 HMAC이면 pepper를 모르는 공격자는 사전을 만들 수 없다.
* <b>제안 범위보다 강화되는 방향</b>이므로 사업상 문제가 없고 점검 대응력이 올라간다.</p>
*
* <p><b>정규화가 해시 일치의 전제다.</b> 같은 값이 다른 해시로 갈리면 검색이 조용히 실패한다.
* 항목별 정규화 규칙을 이 클래스 한 곳에만 두고, 저장 시점과 검색 시점이 <u>반드시 같은
* 메서드</u>를 쓰게 한다.</p>
*
* <p><b>pepper 설정:</b> 시스템 프로퍼티 {@code arko.mber.hash.pepper} 또는 환경변수
* {@code ARKO_MBER_HASH_PEPPER}. 마스터 키와 <b>다른 값</b>이어야 한다(하나가 유출돼도
* 다른 하나는 살아 있게). 미설정 시 폴백 없이 실패한다.</p>
*
* <p><b>pepper는 교체할 수 없다.</b> 바꾸면 저장된 해시 전체를 재계산해야 한다
* (원본 복호화 → 재해시 배치). 처음에 충분히 긴 값으로 정하고 고정한다.</p>
*/
public class MemberDataHasher {
private static final String ALGORITHM = "HmacSHA256";
/** pepper 시스템 프로퍼티명. */
public static final String PEPPER_PROP = "arko.mber.hash.pepper";
/** pepper 환경변수명. */
public static final String PEPPER_ENV = "ARKO_MBER_HASH_PEPPER";
private static final char[] HEX = "0123456789abcdef".toCharArray();
private final byte[] pepper;
public MemberDataHasher() {
this.pepper = loadPepper();
}
/** 명시적 pepper 주입(테스트용). */
public MemberDataHasher(byte[] pepper) {
if (pepper == null || pepper.length == 0) {
throw new IllegalArgumentException("pepper must not be empty");
}
this.pepper = pepper.clone();
}
private static byte[] loadPepper() {
String p = System.getProperty(PEPPER_PROP);
if (p == null || p.trim().length() == 0) {
p = System.getenv(PEPPER_ENV);
}
if (p == null || p.trim().length() == 0) {
throw new IllegalStateException(
"[개인정보/암호화] 검색용 해시 pepper가 설정되지 않았습니다. "
+ "시스템 프로퍼티 " + PEPPER_PROP + " 또는 환경변수 " + PEPPER_ENV + " 를 설정하십시오. "
+ "(마스터 키와 다른 값이어야 합니다. 생성: openssl rand -base64 32)");
}
try {
return p.trim().getBytes("UTF-8");
} catch (Exception e) {
throw new IllegalStateException("pepper 인코딩 실패", e);
}
}
/**
* <b>이름</b> 검색용 해시. 정규화는 앞뒤 공백 제거만 한다.
*
* <p>가운데 공백은 지우지 않는다 — "남궁 민수"와 "남궁민수"는 실제로 다르게 등록된
* 별개 표기이며, 임의로 합치면 저장 시점과 관리자 검색 시점의 정규화가 어긋날 여지가 커진다.
* 소문자화도 하지 않는다(한글에 무의미하고 영문 이름의 대소문자는 유의미할 수 있다).</p>
*
* @param name 평문 이름(null/빈문자 허용)
* @return 소문자 hex 64자. 입력이 null이면 null, 빈문자면 빈문자
*/
public String hashName(String name) {
if (name == null) {
return null;
}
String norm = name.trim();
if (norm.length() == 0) {
return "";
}
return hmacHex(norm);
}
/**
* <b>이메일</b> 검색용 해시. 앞뒤 공백 제거 + 소문자화.
* (후속 단계용 — 이름 단계에서는 사용하지 않는다.)
*/
public String hashEmail(String email) {
if (email == null) {
return null;
}
String norm = email.trim().toLowerCase();
if (norm.length() == 0) {
return "";
}
return hmacHex(norm);
}
/**
* <b>휴대폰번호</b> 검색용 해시. 숫자 이외 문자를 모두 제거한다.
* ({@code 010-1234-5678}, {@code 010 1234 5678} → {@code 01012345678})
* (후속 단계용 — 이름 단계에서는 사용하지 않는다.)
*/
public String hashMobile(String mobile) {
if (mobile == null) {
return null;
}
StringBuilder sb = new StringBuilder(mobile.length());
for (int i = 0; i < mobile.length(); i++) {
char c = mobile.charAt(i);
if (c >= '0' && c <= '9') {
sb.append(c);
}
}
if (sb.length() == 0) {
return "";
}
return hmacHex(sb.toString());
}
/** 정규화가 끝난 문자열의 HMAC-SHA256 소문자 hex(64자). */
private String hmacHex(String normalized) {
try {
Mac mac = Mac.getInstance(ALGORITHM);
mac.init(new SecretKeySpec(pepper, ALGORITHM));
byte[] out = mac.doFinal(normalized.getBytes("UTF-8"));
char[] hex = new char[out.length * 2];
for (int i = 0; i < out.length; i++) {
int v = out[i] & 0xff;
hex[i * 2] = HEX[v >>> 4];
hex[i * 2 + 1] = HEX[v & 0x0f];
}
return new String(hex);
} catch (Exception e) {
// 해시 실패는 검색 불가로 이어지므로 삼키지 않는다.
throw new IllegalStateException("[개인정보/암호화] 검색용 해시 생성 실패", e);
}
}
}

139
src/main/java/egovframework/com/cmm/privacy/crypto/MemberNmCryptoDAO.java
View File

@ -1,139 +0,0 @@
/**
* Class Name : MemberNmCryptoDAO.java
* Description : 회원 이름 암호화 이관 DAO — 개인정보보호 기능개선 사업(추가제안 Action4)
*
* Modification Information
*
* 수정일 수정자 수정내용
* ------- -------- ---------------------------
* 2026.08.10 개인정보보호 최초 생성
*
* @since 2026. 08. 10
* @version 1.0
*/
package egovframework.com.cmm.privacy.crypto;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.orm.ibatis.SqlMapClientCallback;
import org.springframework.stereotype.Repository;
import com.ibatis.sqlmap.client.SqlMapExecutor;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 회원 이름 암호화 백필 배치의 데이터 접근. 청크 조회 → 배치 UPDATE → 진행상태 기록.
*
* <p><b>평문 컬럼은 절대 UPDATE하지 않는다.</b> 이 DAO의 update문은 {@code MBER_NM_ENC} /
* {@code MBER_NM_HASH} / {@code CRYPTO_KEY_VER}만 건드린다. 평문이 그대로 남아 있어야
* ① 재실행 시 미처리 판정이 가능하고 ② 읽기 전환 전까지 롤백 창구가 유지된다.</p>
*
* @author 개인정보보호
* @since 2026-08-10
*/
@Repository("memberNmCryptoDAO")
public class MemberNmCryptoDAO extends EgovComAbstractDAO {
/** 진행상태 테이블의 작업 식별자. */
public static final String JOB_ID = "COMTNGNRLMBER.MBER_NM";
/**
* 커서 이후의 미암호화 행을 청크 크기만큼 조회한다.
*
* @param lastKey 직전 청크의 마지막 MBER_ID. 최초 실행이면 null
* @param chunkSize 청크 크기
*/
@SuppressWarnings("unchecked")
public List<MemberNmCryptoVO> selectChunk(String lastKey, int chunkSize) {
Map<String, Object> param = new HashMap<String, Object>();
param.put("lastKey", lastKey);
param.put("chunkSize", Integer.valueOf(chunkSize));
return list("MemberNmCryptoDAO.selectChunk", param);
}
/**
* 청크 한 덩어리를 <b>단일 배치</b>로 UPDATE한다.
*
* <p>건별 executeUpdate를 77,053번 왕복하면 네트워크 라운드트립이 지배적이 된다.
* iBatis2 배치로 묶으면 한 번의 왕복으로 처리되어 수 분이 수십 초로 줄어든다.</p>
*
* @return 실제 반영 건수
*/
public int updateEncryptedBatch(final List<MemberNmCryptoVO> rows) {
if (rows == null || rows.isEmpty()) {
return 0;
}
Object result = getSqlMapClientTemplate().execute(new SqlMapClientCallback() {
public Object doInSqlMapClient(SqlMapExecutor executor) throws SQLException {
executor.startBatch();
for (int i = 0; i < rows.size(); i++) {
executor.update("MemberNmCryptoDAO.updateEncrypted", rows.get(i));
}
return Integer.valueOf(executor.executeBatch());
}
});
return (result instanceof Integer) ? ((Integer) result).intValue() : 0;
}
/** 아직 암호화되지 않은 잔여 건수. */
public int selectRemainingCount() {
Object v = selectByPk("MemberNmCryptoDAO.selectRemainingCount", null);
return (v instanceof Integer) ? ((Integer) v).intValue() : 0;
}
/** 진행상태 행을 없으면 만든다(재실행 안전). */
public void insertProgressIfAbsent() {
Map<String, Object> param = new HashMap<String, Object>();
param.put("jobId", JOB_ID);
insert("MemberNmCryptoDAO.insertProgressIfAbsent", param);
}
/** 청크 완료 시 커서·누적건수를 갱신한다. */
public void updateProgress(String lastKey, int doneDelta, int errDelta) {
Map<String, Object> param = new HashMap<String, Object>();
param.put("jobId", JOB_ID);
param.put("lastKey", lastKey);
param.put("doneDelta", Integer.valueOf(doneDelta));
param.put("errDelta", Integer.valueOf(errDelta));
update("MemberNmCryptoDAO.updateProgress", param);
}
/** 작업 상태(R/S/C/E)와 비고를 갱신한다. */
public void updateStatus(String status, String remark) {
Map<String, Object> param = new HashMap<String, Object>();
param.put("jobId", JOB_ID);
param.put("jobSttus", status);
param.put("rm", remark);
update("MemberNmCryptoDAO.updateStatus", param);
}
/** 진행상태 1건 조회(화면 표시·중지요청 확인용). */
@SuppressWarnings("unchecked")
public Map<String, Object> selectProgress() {
Map<String, Object> param = new HashMap<String, Object>();
param.put("jobId", JOB_ID);
return (Map<String, Object>) selectByPk("MemberNmCryptoDAO.selectProgress", param);
}
/**
* 검증용 집계 — 평문 보유 건수와 암호문 보유 건수, 그리고 누락 건수.
* 누락(평문 있는데 암호문 없음)이 0이어야 이관 완료다.
*/
@SuppressWarnings("unchecked")
public Map<String, Object> selectVerifyCounts() {
return (Map<String, Object>) selectByPk("MemberNmCryptoDAO.selectVerifyCounts", null);
}
/** 검증용 — 암호화된 행을 커서 기준으로 청크 조회(복호화 대사에 사용). */
@SuppressWarnings("unchecked")
public List<MemberNmCryptoVO> selectVerifyChunk(String lastKey, int chunkSize) {
Map<String, Object> param = new HashMap<String, Object>();
param.put("lastKey", lastKey);
param.put("chunkSize", Integer.valueOf(chunkSize));
return list("MemberNmCryptoDAO.selectVerifyChunk", param);
}
}

105
src/main/java/egovframework/com/cmm/privacy/crypto/MemberNmCryptoVO.java
View File

@ -1,105 +0,0 @@
/**
* Class Name : MemberNmCryptoVO.java
* Description : 회원 이름 암호화 이관 대상 행 VO — 개인정보보호 기능개선 사업(추가제안 Action4)
*
* Modification Information
*
* 수정일 수정자 수정내용
* ------- -------- ---------------------------
* 2026.08.10 개인정보보호 최초 생성
*
* @since 2026. 08. 10
* @version 1.0
*/
package egovframework.com.cmm.privacy.crypto;
import java.io.Serializable;
/**
* 백필 배치가 읽고 쓰는 한 행. {@code COMTNGNRLMBER}의 PK와 이름 관련 컬럼만 담는다.
*
* <p>회원 전체 컬럼(40여 개)을 끌고 오지 않는 이유는 두 가지다. 이관 배치가 다루는 개인정보를
* 최소화해야 하고(필요 최소 수집), 77,053건을 청크로 훑을 때 불필요한 I/O를 줄여야 한다.</p>
*/
public class MemberNmCryptoVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 회원ID — COMTNGNRLMBER의 PK이자 청크 커서 키.
*
* <p><b>실측 주의:</b> 이 컬럼의 DB 타입은 {@code VARCHAR}가 아니라 <b>{@code VARBINARY(32)}</b>이며,
* 77,053건 중 39건(LVMS 연계 계정 {@code ...@lvms})에 비인쇄 바이트가 들어 있다.
* 다만 전건 감사 결과 <b>UTF-8 문자열 왕복이 무손실</b>임을 확인했으므로(왕복 실패 0건)
* String 매핑을 유지한다.</p>
*
* <p>혹시 변환이 어긋나더라도 실패 양상은 안전하다 — UPDATE가 0건이 되어 해당 행의
* {@code MBER_NM_ENC}가 NULL로 남고, 검증 단계의 누락 건수에 그대로 잡힌다.
* 데이터가 잘못 덮어써지는 경우는 발생하지 않는다.</p>
*/
private String mberId;
/** 평문 이름(읽기 전용. 배치는 이 컬럼을 갱신하지 않는다). */
private String mberNm;
/** 이름 암호문 Base64. */
private String mberNmEnc;
/** 이름 검색용 HMAC-SHA256 hex. */
private String mberNmHash;
/** 암호화 키 버전. */
private Integer cryptoKeyVer;
public String getMberId() {
return mberId;
}
public void setMberId(String mberId) {
this.mberId = mberId;
}
public String getMberNm() {
return mberNm;
}
public void setMberNm(String mberNm) {
this.mberNm = mberNm;
}
public String getMberNmEnc() {
return mberNmEnc;
}
public void setMberNmEnc(String mberNmEnc) {
this.mberNmEnc = mberNmEnc;
}
public String getMberNmHash() {
return mberNmHash;
}
public void setMberNmHash(String mberNmHash) {
this.mberNmHash = mberNmHash;
}
public Integer getCryptoKeyVer() {
return cryptoKeyVer;
}
public void setCryptoKeyVer(Integer cryptoKeyVer) {
this.cryptoKeyVer = cryptoKeyVer;
}
/**
* 로그·디버깅용. <b>이름 값은 절대 포함하지 않는다</b> —
* 이관 로그에 평문이 남으면 암호화의 의미가 사라진다.
*/
@Override
public String toString() {
return "MemberNmCryptoVO[mberId=" + mberId
+ ", encSet=" + (mberNmEnc != null)
+ ", hashSet=" + (mberNmHash != null)
+ ", keyVer=" + cryptoKeyVer + "]";
}
}

309
src/main/java/egovframework/com/cmm/privacy/crypto/MemberNmCryptoWorker.java
View File

@ -1,309 +0,0 @@
/**
* Class Name : MemberNmCryptoWorker.java
* Description : 회원 이름 암호화 백필/검증 배치 — 개인정보보호 기능개선 사업(추가제안 Action4)
*
* Modification Information
*
* 수정일 수정자 수정내용
* ------- -------- ---------------------------
* 2026.08.10 개인정보보호 최초 생성
*
* @since 2026. 08. 10
* @version 1.0
*/
package egovframework.com.cmm.privacy.crypto;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* 이미 적재된 회원 이름을 일괄 암호화하는 백필 배치와, 그 결과를 대사하는 검증 배치.
*
* <p><b>대상 규모(2026-08-10 실측):</b> {@code COMTNGNRLMBER} 77,053건 / 39.6MB /
* PK {@code MBER_ID} 단일. 1,000건 청크 기준 78회 순회이며 실측 소요는 수십 초~수 분이다.
* 야간 점검창구가 필요한 규모가 아니다.</p>
*
* <p><b>중단·재개 설계:</b> 청크마다 {@code MIG_CRYPTO_PROGRESS}에 커서를 남긴다. 그러나
* 재개의 진짜 근거는 커서가 아니라 <b>{@code MBER_NM_ENC IS NULL} 조건</b>이다 —
* 진행상태 테이블이 통째로 날아가도 처음부터 다시 돌리면 이미 처리된 행은 건너뛴다.
* 커서는 "다시 훑는 비용"을 줄이는 최적화일 뿐 정합성의 근거가 아니다.</p>
*
* <p><b>왜 상주 스케줄러에 넣지 않는가:</b> 1회성 이관 작업이다. {@code BatchScheduler}에
* 등록하면 이관이 끝난 뒤에도 매 주기 깨어나 빈 조회를 반복하고, 실수로 재실행될 여지가 남는다.
* 관리자가 명시적으로 시작·중지하는 형태가 맞다.</p>
*
* <p><b>평문을 로그에 남기지 않는다.</b> 이 클래스의 모든 로그는 건수·회원ID까지만 남긴다.
* 이관 로그에 이름이 찍히면 암호화를 하고도 평문이 파일로 새어 나간다.</p>
*
* @author 개인정보보호
* @since 2026-08-10
*/
@Component("memberNmCryptoWorker")
public class MemberNmCryptoWorker {
private static final Logger LOG = LoggerFactory.getLogger(MemberNmCryptoWorker.class);
/** 기본 청크 크기. */
public static final int DEFAULT_CHUNK_SIZE = 1000;
/** 청크 간 기본 휴지(ms) — 온라인 트래픽·복제 지연 보호. */
public static final long DEFAULT_SLEEP_MS = 50L;
/** 진행상태 코드. */
private static final String STTUS_RUNNING = "R";
private static final String STTUS_STOP = "S";
private static final String STTUS_DONE = "C";
private static final String STTUS_ERROR = "E";
@Resource(name = "memberNmCryptoDAO")
private MemberNmCryptoDAO dao;
/** 암호·해시 헬퍼는 키를 들고 있으므로 생성 실패 시 기동을 막는다(폴백 없음). */
private MemberDataCipher cipher;
private MemberDataHasher hasher;
/** 실행 중 스레드. null 이면 미실행. */
private volatile Thread runner;
/** 중지 요청 플래그. */
private volatile boolean stopRequested = false;
/** 지연 초기화 — 키 미설정 서버에서 컨텍스트 전체가 죽지 않도록 실행 시점에 만든다. */
private synchronized void ensureCrypto() {
if (cipher == null) {
cipher = new MemberDataCipher();
}
if (hasher == null) {
hasher = new MemberDataHasher();
}
}
/** 현재 실행 중인가. */
public boolean isRunning() {
Thread t = runner;
return t != null && t.isAlive();
}
/** 진행상태 조회(관리자 화면용). */
public Map<String, Object> getProgress() {
return dao.selectProgress();
}
/** 중지 요청. 진행 중인 청크는 마치고 멈춘다(커서는 보존). */
public void requestStop() {
this.stopRequested = true;
LOG.info("[개인정보/암호화] 이름 백필 중지 요청 접수");
}
/**
* 백필을 백그라운드로 시작한다.
*
* @param chunkSize 청크 크기(1 미만이면 기본값)
* @param sleepMs 청크 간 휴지(음수면 기본값)
* @return 시작했으면 true, 이미 실행 중이면 false
*/
public synchronized boolean start(int chunkSize, long sleepMs) {
if (isRunning()) {
LOG.warn("[개인정보/암호화] 이름 백필이 이미 실행 중입니다 — 중복 시작 무시");
return false;
}
final int chunk = (chunkSize < 1) ? DEFAULT_CHUNK_SIZE : chunkSize;
final long sleep = (sleepMs < 0) ? DEFAULT_SLEEP_MS : sleepMs;
this.stopRequested = false;
Thread t = new Thread(new Runnable() {
public void run() {
runBackfill(chunk, sleep);
}
}, "mber-nm-crypto-backfill");
t.setDaemon(true);
this.runner = t;
t.start();
return true;
}
/**
* 백필 본체. 커서 페이징으로 미암호화 행을 청크 단위로 암호화한다.
*
* <p>한 건이 실패해도 청크 전체를 버리지 않는다 — 실패 행만 건너뛰고 계속한다.
* 실패 건은 {@code MBER_NM_ENC}가 NULL로 남으므로 다음 실행에서 자연히 재시도된다.</p>
*/
void runBackfill(int chunkSize, long sleepMs) {
long started = System.currentTimeMillis();
int totalDone = 0;
int totalErr = 0;
try {
ensureCrypto();
dao.insertProgressIfAbsent();
dao.updateStatus(STTUS_RUNNING, "백필 시작 chunk=" + chunkSize);
int remaining = dao.selectRemainingCount();
LOG.info("[개인정보/암호화] 이름 백필 시작 — 대상 {}건, chunk={}, sleep={}ms",
new Object[] { Integer.valueOf(remaining), Integer.valueOf(chunkSize), Long.valueOf(sleepMs) });
String lastKey = null;
while (true) {
if (stopRequested) {
dao.updateStatus(STTUS_STOP, "관리자 중지 요청 — 처리 " + totalDone + "건");
LOG.info("[개인정보/암호화] 이름 백필 중지 — 누적 {}건", Integer.valueOf(totalDone));
return;
}
List<MemberNmCryptoVO> rows = dao.selectChunk(lastKey, chunkSize);
if (rows == null || rows.isEmpty()) {
break;
}
List<MemberNmCryptoVO> ready = new ArrayList<MemberNmCryptoVO>(rows.size());
for (int i = 0; i < rows.size(); i++) {
MemberNmCryptoVO row = rows.get(i);
lastKey = row.getMberId();
try {
// NULL/빈문자 구분 보존은 cipher/hasher가 담당한다.
// arko는 탈퇴 시 개인정보 컬럼을 빈 문자열로 채우므로 ''를 NULL로 뭉개면
// 파기 상태가 사라진다.
row.setMberNmEnc(cipher.encrypt(row.getMberNm()));
row.setMberNmHash(hasher.hashName(row.getMberNm()));
row.setCryptoKeyVer(Integer.valueOf(MemberDataCipher.CURRENT_KEY_VER));
ready.add(row);
} catch (Exception e) {
totalErr++;
// 회원ID만 남긴다 — 이름은 절대 로그에 쓰지 않는다.
LOG.error("[개인정보/암호화] 행 암호화 실패(건너뜀) mberId=" + row.getMberId(), e);
}
}
int updated = 0;
if (!ready.isEmpty()) {
updated = dao.updateEncryptedBatch(ready);
}
totalDone += updated;
dao.updateProgress(lastKey, updated, 0);
if (LOG.isInfoEnabled()) {
LOG.info("[개인정보/암호화] 청크 완료 — 누적 {}건, 실패 {}건, cursor={}",
new Object[] { Integer.valueOf(totalDone), Integer.valueOf(totalErr), lastKey });
}
if (sleepMs > 0) {
try {
Thread.sleep(sleepMs);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
dao.updateStatus(STTUS_STOP, "인터럽트 — 처리 " + totalDone + "건");
return;
}
}
}
long elapsed = System.currentTimeMillis() - started;
String msg = "백필 완료 — 처리 " + totalDone + "건, 실패 " + totalErr + "건, 소요 " + (elapsed / 1000) + "초";
dao.updateStatus(totalErr > 0 ? STTUS_ERROR : STTUS_DONE, msg);
LOG.info("[개인정보/암호화] {}", msg);
} catch (Throwable t) {
String msg = "백필 중단 — " + t.getClass().getSimpleName() + ": " + t.getMessage();
try {
dao.updateStatus(STTUS_ERROR, msg);
} catch (Exception ignore) {
LOG.error("[개인정보/암호화] 진행상태 기록 실패", ignore);
}
LOG.error("[개인정보/암호화] 이름 백필 예외 — 누적 " + totalDone + "건", t);
} finally {
this.runner = null;
}
}
/**
* 이관 검증 — <b>전건</b> 복호화 대사.
*
* <p>77,053건 규모에서 샘플링할 이유가 없다. 전건을 복호화해 평문과 비교하고, 해시를
* 재계산해 저장값과 대조한다. 하나라도 어긋나면 읽기 전환을 해서는 안 된다.</p>
*
* <p>제안서가 요구하는 "이관 전후 건수·값 검증"의 값 검증 부분이며,
* 반환 문자열을 그대로 조치결과보고서 첨부에 쓸 수 있게 구성했다.</p>
*
* @param chunkSize 청크 크기
* @return 검증 결과 요약
*/
public String verify(int chunkSize) {
int chunk = (chunkSize < 1) ? DEFAULT_CHUNK_SIZE : chunkSize;
ensureCrypto();
Map<String, Object> counts = dao.selectVerifyCounts();
long checked = 0;
long decMismatch = 0;
long hashMismatch = 0;
long decError = 0;
String lastKey = null;
while (true) {
List<MemberNmCryptoVO> rows = dao.selectVerifyChunk(lastKey, chunk);
if (rows == null || rows.isEmpty()) {
break;
}
for (int i = 0; i < rows.size(); i++) {
MemberNmCryptoVO row = rows.get(i);
lastKey = row.getMberId();
checked++;
try {
String decrypted = cipher.decrypt(row.getMberNmEnc());
if (!equalsNullable(decrypted, row.getMberNm())) {
decMismatch++;
LOG.error("[개인정보/암호화] 복호화 불일치 mberId={}", row.getMberId());
}
String expected = hasher.hashName(row.getMberNm());
if (!equalsNullable(expected, row.getMberNmHash())) {
hashMismatch++;
LOG.error("[개인정보/암호화] 해시 불일치 mberId={}", row.getMberId());
}
} catch (Exception e) {
decError++;
LOG.error("[개인정보/암호화] 복호화 오류 mberId=" + row.getMberId(), e);
}
}
}
StringBuilder sb = new StringBuilder(400);
sb.append("[회원 이름 암호화 이관 검증]\n");
if (counts != null) {
sb.append(" 총 행수 : ").append(counts.get("TOTAL_CNT")).append('\n');
sb.append(" 평문 보유 : ").append(counts.get("PLAIN_CNT")).append('\n');
sb.append(" 암호문 보유 : ").append(counts.get("ENC_CNT")).append('\n');
sb.append(" 해시 보유 : ").append(counts.get("HASH_CNT")).append('\n');
sb.append(" 누락(미암호) : ").append(counts.get("MISSING_CNT")).append(" <- 0 이어야 함\n");
}
sb.append(" 대사 건수 : ").append(checked).append('\n');
sb.append(" 복호화 불일치: ").append(decMismatch).append(" <- 0 이어야 함\n");
sb.append(" 해시 불일치 : ").append(hashMismatch).append(" <- 0 이어야 함\n");
sb.append(" 복호화 오류 : ").append(decError).append(" <- 0 이어야 함\n");
boolean ok = decMismatch == 0 && hashMismatch == 0 && decError == 0
&& counts != null && isZero(counts.get("MISSING_CNT"));
sb.append(" 판정 : ").append(ok ? "합격 — 읽기 전환 가능" : "불합격 — 읽기 전환 금지");
String report = sb.toString();
LOG.info("[개인정보/암호화] 검증 결과\n{}", report);
return report;
}
private static boolean equalsNullable(String a, String b) {
return (a == null) ? (b == null) : a.equals(b);
}
private static boolean isZero(Object v) {
if (v == null) {
return true;
}
if (v instanceof Number) {
return ((Number) v).longValue() == 0L;
}
return "0".equals(String.valueOf(v));
}
}

105
src/main/java/egovframework/com/cmm/privacy/crypto/MemberNmDecryptSupport.java
View File

@ -1,105 +0,0 @@
/**
* Class Name : MemberNmDecryptSupport.java
* Description : 회원 이름 읽기 전환(복호화) 공용 헬퍼 — 개인정보보호 기능개선 사업(추가제안 Action4)
*
* Modification Information
*
* 수정일 수정자 수정내용
* ------- -------- ---------------------------
* 2026.08.10 개인정보보호 최초 생성 — SELECT MBER_NM 을 MBER_NM_ENC 로 전환하는 DAO들이 공유
*
* @since 2026. 08. 10
* @version 1.0
*/
package egovframework.com.cmm.privacy.crypto;
import java.util.List;
import java.util.Map;
import org.apache.commons.beanutils.PropertyUtils;
/**
* 조회 결과에 담긴 이름 암호문을 평문으로 되돌려 <b>기존 코드가 쓰던 키·필드 이름을 그대로</b>
* 채운다. arko의 조회 SQL은 대부분 {@code resultClass="egovMap"}(Map)이고 일부는 VO다 —
* 이 클래스가 두 형태를 모두 처리해 DAO마다 다른 복호화 코드를 두지 않게 한다.
*
* <p><b>사용 패턴:</b> SQL의 {@code MBER_NM as "userNm"}을 {@code MBER_NM_ENC as "userNm"}으로
* 바꾼 뒤(별칭은 그대로 유지), DAO 메서드가 결과를 반환하기 직전에
* {@code MemberNmDecryptSupport.decryptListInPlace(rows, "userNm")}를 호출한다.
* 같은 키를 입력이자 출력으로 써서 호출부가 한 줄만 늘어나고, 화면·서비스 코드는 전혀
* 건드리지 않는다 — 그 키에 이제 평문이 들어있다는 사실만 달라진다.</p>
*
* <p><b>실패 처리:</b> 복호화에 실패하면 예외를 던진다(평문 대체나 빈 값 대체를 하지 않는다).
* 개인정보 조회 화면이 복호화 실패를 숨기고 빈 이름을 보여주면, "왜 이름이 안 보이지"라는
* 장애가 "키가 바뀌었다/암호문이 깨졌다"는 진짜 원인을 감춘다.</p>
*/
public final class MemberNmDecryptSupport {
private static volatile MemberDataCipher cipher;
private MemberNmDecryptSupport() {
}
private static MemberDataCipher cipher() {
MemberDataCipher c = cipher;
if (c == null) {
synchronized (MemberNmDecryptSupport.class) {
c = cipher;
if (c == null) {
c = new MemberDataCipher();
cipher = c;
}
}
}
return c;
}
/**
* 목록의 각 행에서 {@code key} 위치의 암호문을 복호화해 같은 키에 되돌려 쓴다.
* 행이 {@link Map}이면 {@code put}, 그 외(JavaBean VO)면 리플렉션 setter를 쓴다.
*
* @param rows 조회 결과(egovMap 목록 또는 VO 목록). null이면 아무 것도 하지 않는다.
* @param key 암호문이 들어있고 평문이 들어갈 속성/컬럼 키(예: "userNm", "mberNm")
*/
public static void decryptListInPlace(List<?> rows, String key) {
if (rows == null || rows.isEmpty()) {
return;
}
for (int i = 0; i < rows.size(); i++) {
decryptInPlace(rows.get(i), key);
}
}
/** 단건 조회({@code selectByPk} 반환값 등)용. row가 null이면 아무 것도 하지 않는다. */
public static void decryptInPlace(Object row, String key) {
if (row == null) {
return;
}
try {
String enc;
if (row instanceof Map) {
Object v = ((Map<?, ?>) row).get(key);
enc = (v instanceof String) ? (String) v : null;
} else {
Object v = PropertyUtils.getProperty(row, key);
enc = (v instanceof String) ? (String) v : null;
}
if (enc == null || enc.length() == 0) {
// 탈퇴 등으로 이름이 파기된 행은 암호문도 없다 — 정상, 복호화할 것이 없다.
return;
}
String plain = cipher().decrypt(enc);
if (row instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, Object> m = (Map<String, Object>) row;
m.put(key, plain);
} else {
PropertyUtils.setProperty(row, key, plain);
}
} catch (Exception e) {
throw new IllegalStateException(
"[개인정보/암호화] 이름 복호화 실패(key=" + key + ", rowType="
+ row.getClass().getName() + ")", e);
}
}
}

52
src/main/java/egovframework/com/cmm/privacy/interceptor/AuthorityInterceptor.java
View File

@ -29,10 +29,8 @@ import egovframework.com.cmm.util.EgovUserDetailsHelper;
*
* <p><b>preHandle 판정 순서:</b>
* <ol>
* <li>{@code /mnt/} 외 · 제외패턴 → 통과(기존 유지)</li>
* <li>명시 매핑({@code urlRoleMapping}) 판정을 인증 판정보다 <b>먼저</b> 수행. 매칭 경로는
* 미인증이면 로그인 유도(화면)/401(AJAX)로 차단하고, 인증 상태면 해당 롤을 요구한다.
* 매칭되지 않으면 미인증은 기존과 동일하게 통과(일반 arko 관리화면 동작 불변)</li>
* <li>{@code /mnt/} 외 · 제외패턴 · 미인증(loginVO==null) → 통과(기존 유지)</li>
* <li>명시 매핑({@code urlRoleMapping}) 우선 — 매칭 시 해당 롤 필요(신규 privacy 화면 보호 유지)</li>
* <li>바이패스 롤({@code bypassRoles}, 기본 ROLE_ADMIN/ROLE_ADMINS) 보유자 → 통과(관리자 잠금 방지)</li>
* <li>메뉴권한 판정 — 요청 path(쿼리 제외):
* <ul>
@ -52,20 +50,12 @@ import egovframework.com.cmm.util.EgovUserDetailsHelper;
* ---------- ------ ---------------------------
* 2026.07.21 URP 최초 생성 (개인정보보호 기능개선 사업 SFR-001 / #2)
* 2026.07.22 URP 기존 메뉴권한 DB 기반 URL 접근제어로 개편(요건4) — 캐시/TTL/바이패스/fail-open
* 2026.07.28 URP 명시 매핑 판정을 미인증 판정보다 선행 — privacy 화면 무인증 노출 차단
* </pre>
*/
public class AuthorityInterceptor extends HandlerInterceptorAdapter {
private static final Logger LOG = LoggerFactory.getLogger(AuthorityInterceptor.class);
/** 미인증 화면 진입 시 유도할 로그인 URL(기존 arko 관례). */
private static final String LOGIN_URL = "/uat/uia/egovLoginUsr.do";
/** 미인증 AJAX/JSON 액션 거부 본문(계정 존재 여부 등 부가정보 미노출 — AccountMngController 와 동일 문구). */
private static final String DENY_JSON =
"{\"result\":\"fail\",\"message\":\"접근 권한이 없습니다. 관리자 계정으로 로그인 후 이용하세요.\"}";
/** 적용 경로 접두(개인정보취급자 영역). 기본 /mnt/ */
private String applyPathPrefix = "/mnt/";
@ -119,26 +109,17 @@ public class AuthorityInterceptor extends HandlerInterceptorAdapter {
return true;
}
// 3) 명시 매핑 판정을 미인증 판정보다 먼저 수행한다.
// (authenticInterceptor 가 비활성이라 미인증을 걸러줄 다음 단계가 실제로는 없다.
// 매핑에 걸린 privacy 화면만 여기서 인증을 강제하고, 그 외 /mnt/ 는 기존 동작 유지.)
String requiredRole = resolveRequiredRole(path);
// 3) 미인증은 통과(기존 인증판정 체계가 처리)
LoginVO loginVO = (LoginVO) EgovUserDetailsHelper.getAuthenticatedUser();
if (loginVO == null) {
if (requiredRole == null) {
// 매핑 밖 경로 — 기존과 동일하게 통과(일반 arko 관리화면 동작 변경 없음)
return true;
}
LOG.warn("[개인정보/#2] 미인증 접근 차단: path={}, requiredRole={}", path, requiredRole);
denyUnauthenticated(request, response);
return false;
return true;
}
// 사용자 롤 목록(#1 getAuthorities 활용)
List<String> roles = EgovUserDetailsHelper.getAuthorities();
// 4) 명시 매핑 우선 — 신규 privacy 화면(/mnt/privacy/·/mnt/sec/ → ROLE_ADMIN) 보호
String requiredRole = resolveRequiredRole(path);
if (requiredRole != null) {
if (roles != null && roles.contains(requiredRole)) {
return true;
@ -197,29 +178,6 @@ public class AuthorityInterceptor extends HandlerInterceptorAdapter {
return true;
}
/**
* 미인증 + 명시 매핑 경로에 대한 거부 응답.
* 화면 진입(브라우저 내비게이션)은 로그인 화면으로 유도, AJAX/JSON 액션은 401 + jsonView 동형 본문.
*/
private void denyUnauthenticated(HttpServletRequest request, HttpServletResponse response) throws Exception {
if (isBrowserNavigation(request)) {
response.sendRedirect(request.getContextPath() + LOGIN_URL);
return;
}
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.setContentType("application/json; charset=UTF-8");
response.getWriter().write(DENY_JSON);
}
/** 브라우저 화면 진입 여부. jQuery AJAX(X-Requested-With) 우선 판정 후 Accept 헤더로 보완. */
private boolean isBrowserNavigation(HttpServletRequest request) {
if ("XMLHttpRequest".equalsIgnoreCase(request.getHeader("X-Requested-With"))) {
return false;
}
String accept = request.getHeader("Accept");
return accept == null || accept.indexOf("text/html") >= 0 || "*/*".equals(accept.trim());
}
/** 명시 매핑에서 필요 권한 조회. 매핑 없으면 null. */
private String resolveRequiredRole(String path) {
if (urlRoleMapping == null || urlRoleMapping.isEmpty()) {

763
src/main/java/egovframework/com/cmm/privacy/interceptor/MenuAccessLogInterceptor.java
View File

@ -1,763 +0,0 @@
package egovframework.com.cmm.privacy.interceptor;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import egovframework.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.privacy.auditlog.AccessLogQueue;
import egovframework.com.cmm.privacy.auditlog.ClientIpResolver;
import egovframework.com.cmm.privacy.auditlog.PersonalDataAccessLogVO;
import egovframework.com.cmm.util.EgovUserDetailsHelper;
/**
* 관리자 화면 메뉴 접속기록 인터셉터 — 개인정보보호 기능개선 사업(SFR-004 / DBR-001 / SER-002).
*
* <p><b>무엇을 남기는가:</b> "개인정보취급자가 관리자 화면에서 어떤 메뉴를 열어 무슨 처리를 했는지"
* 1요청 = 1행으로 {@code PERSONAL_DATA_ACCESS_LOG}에 남긴다. 수행업무(JOB_SE_NM)는
* <b>기존 arko 메뉴 테이블의 메뉴명</b>이다 — 별도 매핑 테이블을 관리하지 않아도 메뉴가 늘면
* 접속기록 업무명도 따라 늘어난다.</p>
*
* <p><b>왜 서비스 AOP에서 인터셉터로 바꿨나(2026-08-07):</b> 종전
* {@code PersonalDataLogAspect}는 서비스 impl 메서드를 가로챘다. 서비스는 관리자 화면과
* 프론트 화면이 공유하므로 <u>어느 화면에서 호출됐는지 구분할 수 없었고</u>, 그 결과
* 무인증 프론트 방문이 접속자ID {@code ANONYMOUS}, 수행업무 "재능나눔 회원관리"로 적재됐다
* (예: 공개 재능나눔 상세 {@code /frt/biz/talent/bizTalentView.do} → {@code selectTalentMber}).
* 요청 단위 인터셉터는 URL을 보므로 관리자 화면 요청만 정확히 골라낼 수 있다.</p>
*
* <p><b>기록 대상 판정(3중 조건, 모두 만족해야 기록):</b>
* <ol>
* <li>요청 경로가 {@code includePatterns}(개인정보 취급 화면 <b>화이트리스트</b>)에 걸릴 것.
* 관리자 화면 전체가 아니라 개인정보를 취급하는 화면만 남긴다 — SFR-004의 대상은
* "개인정보 처리" 기록이고, 통계·게시판·코드관리까지 730일 보관 테이블에 쌓으면
* 정기점검·이상탐지 신호가 묻힌다.
* <b>화이트리스트 산출 근거:</b> 개인정보 서비스(구 AOP pointcut 16종)를 실제로 주입·호출하는
* <u>관리자 컨트롤러를 역산</u>해 그 URL 대역을 열거했다. 접두 하드코딩이 아니라 정규식이라
* {@code /uss/umt/} 안에서 부서관리만 빼는 식의 예외도 표현된다.
* 미설정이면 아무것도 기록하지 않는다(설정 누락 → 전 화면 과수집 방지).</li>
* <li>{@code excludePatterns}에 걸리지 않을 것 — 화이트리스트 안에서 빼야 하는 것들이다.
* 프레임(left/top/footer)·공통 include 는 화면 1회 진입마다 동반 호출되므로 제외하지 않으면
* 같은 진입이 4~5행으로 부풀어 통계를 망친다. 부서관리({@code /uss/umt/dpt/})처럼
* 대역 안의 비개인정보 화면도 여기서 뺀다.</li>
* <li>인증된 <b>개인정보취급자</b> 세션 — {@code LoginVO.userSe}가 {@code handlerUserSes}
* (기본 {@code USR})에 속할 것. 비로그인 요청은 기록하지 않는다(SFR-004는 취급자 기록이며,
* 모든 익명 요청이 한 계정으로 뭉치면 계정공유·대량조회 탐지에 상시 오탐이 된다).
* {@code userSe}가 비어 있으면 취급자 기록 누락을 막기 위해 기록한다(fail-safe).</li>
* </ol>
*
* <p><b>화면이 늘면:</b> 개인정보 취급 화면을 새로 만들면 {@code includePatterns}에 한 줄을 더해야
* 수집된다(설정 파일 변경 → 컨텍스트 리로드). 자동 확장이 아닌 것은 의도된 선택이다 —
* 화이트리스트 없이 자동으로 늘리면 과수집을 통제할 지점이 사라진다.</p>
*
* <p><b>메뉴명 해석 순서:</b>
* <ol>
* <li>요청 파라미터 {@code page} — arko 관리자 링크는 {@code ...listView.do?page=9100044}처럼
* 메뉴번호를 달고 다니며 좌측메뉴 활성화 판정에 쓴다. 가장 정확한 단서라 1순위.</li>
* <li>경로 정확 일치 — 메뉴 URL('?' 앞)과 요청 경로가 같을 때.</li>
* <li>같은 디렉터리 내 최장 공통접두 — 목록화면만 메뉴로 등록되고 상세·수정·삭제 액션은
* 메뉴에 없는 것이 arko의 일반형이다. 이들을 소관 메뉴로 귀속시킨다
* (예: {@code /mnt/biz/talent/bizTalentMberView.do} → "재능나눔 회원관리" 메뉴).</li>
* <li>폴백 — 메뉴로 환원되지 않는 경로는 업무코드 {@code MNT_ETC}, 업무명에 경로를 남긴다
* (누락 없이 기록. 어느 메뉴에 붙일지는 운영에서 메뉴 등록으로 해소).</li>
* </ol>
*
* <p><b>처리구분(DML_GUBUN):</b> URL 마지막 세그먼트(.do 파일명)로 유도한다. HTTP 메서드는
* 쓰지 않는다 — 이 레거시는 삭제·수정도 GET 링크로 부르는 곳이 있어 메서드가 실제 행위를
* 대변하지 못한다. {@code ~View}로 끝나면 등록/수정 <u>화면</u>이므로 조회(S)로 판정하는 것이
* 핵심이다({@code EgovMberInsertView} = 등록화면 진입이지 등록이 아니다).</p>
*
* <p><b>처리대상(TRGET_ID):</b> 요청 파라미터에서 <u>식별자만</u> 우선순위로 취득한다. 검색어·
* 개인정보 본문은 담지 않는다(본문 미적재 원칙). 다건 선택(체크박스)이면 첫 값 + 건수를
* TRGET_CN에 남긴다.</p>
*
* <p><b>업무 무영향 보장:</b> {@code afterHandle} 대신 {@code afterCompletion}에서 적재하며
* (처리결과 성공/실패를 알아야 한다), 큐 enqueue만 하고 즉시 반환한다(#33). 이 인터셉터에서
* 발생한 예외는 전부 삼키고 로그만 남긴다 — 접속기록 수집이 업무를 막아서는 안 된다.</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (SFR-004 — 서비스 AOP 수집 → 관리자 화면 메뉴 접속기록 전환)
* </pre>
*/
public class MenuAccessLogInterceptor extends HandlerInterceptorAdapter {
private static final Logger LOG = LoggerFactory.getLogger(MenuAccessLogInterceptor.class);
/** 접속일시 형식 — 해시체인 재검증 시 DB 적재 문자열과 일치해야 한다(#39). */
private static final String DT_FORMAT = "yyyy-MM-dd HH:mm:ss";
/** 메뉴 미해석 경로의 업무코드. */
private static final String ETC_JOB_CODE = "MNT_ETC";
/** 메뉴 기반 업무코드 접두 — JOB_SE_CODE 는 VARCHAR(30). */
private static final String MENU_JOB_CODE_PREFIX = "MENU_";
/** JOB_SE_CODE 컬럼 길이 보호. */
private static final int JOB_SE_CODE_MAX = 30;
/** JOB_SE_NM 컬럼 길이 보호. */
private static final int JOB_SE_NM_MAX = 100;
/** TRGET_ID 컬럼 길이 보호. */
private static final int TRGET_ID_MAX = 50;
/**
* 처리대상 식별자 파라미터 우선순위 — <b>화이트리스트 대상 컨트롤러의 {@code @RequestParam}
* 실측치</b>다(추정 아님). 개인 식별자를 앞에, 단체·일련번호를 뒤에 둬서 한 요청에 여러 개가
* 실려도 "누구의 개인정보인가"가 먼저 잡히게 한다.
*
* <p><b>넣지 않는 것:</b> {@code tmpNm}(이름)·{@code searchKeyword}(검색어)처럼 값 자체가
* 개인정보 본문이거나 본문일 수 있는 파라미터. 접속기록에 본문을 담지 않는다는 원칙 때문이며,
* 식별자만으로 정보주체를 특정할 수 있으므로 추적에 부족하지 않다.</p>
*
* <p>{@code tmpId}(해당 회원ID)·{@code tmpGId}(그룹ID)·{@code tmpAppId}(신청ID)·
* {@code checkedIdForUp}(일괄 수정 대상)은 arko 관용 파라미터명이라 표준 이름만으로는 못 잡는다.
* 이들이 빠지면 신청·활동확인·일괄승인 화면의 처리대상이 통째로 비어버린다.</p>
*/
private static final String[] TRGET_ID_PARAMS = {
// 개인 식별자
"esntlId", "uniqId", "selectedId", "mberId", "tmpId", "user_id", "userId",
"emplyrId", "entrprsId", "toId",
// 다건 선택(체크박스)
"checkedIdForDel", "checkedIdForUp",
// 단체·신청·일련 식별자
"groupId", "tmpGId", "tmpAppId", "tmpSeqId", "sn"
};
/**
* 처리 건수 취득에 쓸 모델 속성 후보(arko 목록·엑셀 화면 관용명).
* 코드목록 같은 부수 리스트를 세지 않도록 <b>명시 후보만</b> 본다.
*/
private static final String[] RESULT_LIST_ATTRS = { "resultList", "excel_data", "mberList" };
/** postHandle → afterCompletion 사이에 처리 건수를 넘기는 request attribute 키. */
private static final String ATTR_TRGET_CN = MenuAccessLogInterceptor.class.getName() + ".TRGET_CN";
/** TRGET_CN 컬럼 길이(VARCHAR(200)) 보호. */
private static final int TRGET_CN_MAX = 200;
// ===================== 설정(주입) =====================
/**
* 기록 대상 화면 정규식 화이트리스트(개인정보 취급 관리자 화면). 여기에 걸리는 요청만 기록한다.
* 미설정이면 아무것도 기록하지 않는다(과수집 방지 기본값).
*/
private List<String> includePatterns;
/** 기록 제외 정규식 패턴(프레임/공통 include 등). contextPath 제외 경로 대상. */
private List<String> excludePatterns;
/** 개인정보취급자로 볼 사용자구분 코드. 기본 {USR}. */
private Set<String> handlerUserSes;
/** 메뉴 캐시 유효시간(초). 기본 600초. */
private int cacheTtlSeconds = 600;
/** 메뉴명 조회 DAO(루트 컨텍스트 @Repository, 자식→부모 가시성으로 주입). */
private PrivacyMenuAuthDAO menuAuthDAO;
/** 비동기 적재 큐(루트 컨텍스트 @Component, 자식→부모 가시성으로 주입). */
private AccessLogQueue accessLogQueue;
// ===================== 캐시 =====================
/** 메뉴번호 → 메뉴 */
private volatile Map<String, MenuNameVO> byMenuNo;
/** 경로('?' 앞) → 메뉴 */
private volatile Map<String, MenuNameVO> byPath;
/** 디렉터리('/' 로 끝남) → 그 디렉터리의 메뉴 목록 */
private volatile Map<String, List<MenuNameVO>> byDir;
/** 캐시 적재 시각(ms) */
private volatile long cacheLoadedAt = 0L;
public void setIncludePatterns(List<String> includePatterns) { this.includePatterns = includePatterns; }
public void setExcludePatterns(List<String> excludePatterns) { this.excludePatterns = excludePatterns; }
public void setHandlerUserSes(Set<String> handlerUserSes) { this.handlerUserSes = handlerUserSes; }
public void setCacheTtlSeconds(int cacheTtlSeconds) { this.cacheTtlSeconds = cacheTtlSeconds; }
public void setMenuAuthDAO(PrivacyMenuAuthDAO menuAuthDAO) { this.menuAuthDAO = menuAuthDAO; }
public void setAccessLogQueue(AccessLogQueue accessLogQueue) { this.accessLogQueue = accessLogQueue; }
/**
* 처리 건수를 확보한다 — "몇 건의 개인정보를 열람·반출했는가".
*
* <p>서비스 AOP 시절에는 반환값이 {@code Collection}이면 크기를 셌다. 요청 인터셉터는 서비스
* 반환값을 볼 수 없으므로, 컨트롤러가 모델에 담은 목록에서 대신 얻는다. 이 값이 없으면
* 명단 조회·<b>엑셀 다운로드</b>가 "처리대상 미상"으로 남아 무엇을 반출했는지 확인할 수 없다.</p>
*
* <p>{@code postHandle}은 앞선 인터셉터가 요청을 차단하면 호출되지 않는다. 그때는 건수가
* 없는 채로 {@code afterCompletion}이 실패(F) 기록을 남긴다 — 차단된 요청에 건수가 없는 것이 옳다.</p>
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView modelAndView) {
try {
String cn = resolveResultCount(modelAndView);
if (cn != null) {
request.setAttribute(ATTR_TRGET_CN, cn);
}
} catch (Throwable t) {
// 건수는 부가정보다 — 취득 실패가 접속기록 자체를 막지 않는다.
LOG.error("[개인정보/SFR-004] 처리 건수 취득 중 예외(무시)", t);
}
}
/**
* 요청 종료 시점에 접속기록 1건을 남긴다.
* 처리결과(성공/실패)를 판정해야 하므로 preHandle 이 아닌 afterCompletion 이다.
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
try {
writeAccessLog(request, response, ex);
} catch (Throwable t) {
// 접속기록 수집은 업무 흐름을 절대 방해하지 않는다.
LOG.error("[개인정보/SFR-004] 메뉴 접속기록 수집 중 예외(무시)", t);
}
}
private void writeAccessLog(HttpServletRequest request, HttpServletResponse response, Exception ex) {
String path = requestPath(request);
// 1) 개인정보 취급 관리자 화면인가(화이트리스트)
if (!isIncluded(path)) {
return;
}
// 2) 화이트리스트 안이지만 빼야 하는 것인가(프레임·부서관리 등)
if (isExcluded(path)) {
return;
}
// 3) 개인정보취급자 세션인가
LoginVO login = handlerLogin();
if (login == null) {
return;
}
MenuNameVO menu = resolveMenu(request, path);
PersonalDataAccessLogVO vo = new PersonalDataAccessLogVO();
vo.setConectId(login.getId());
vo.setConectDt(new SimpleDateFormat(DT_FORMAT).format(new Date()));
vo.setConectIp(safeIp(request));
if (menu != null) {
vo.setJobSeCode(cut(MENU_JOB_CODE_PREFIX + nvl(menu.getMenuNo()), JOB_SE_CODE_MAX));
vo.setJobSeNm(cut(menu.getMenuNm(), JOB_SE_NM_MAX));
} else {
vo.setJobSeCode(ETC_JOB_CODE);
vo.setJobSeNm(cut(path, JOB_SE_NM_MAX));
}
vo.setDmlGubun(deriveDmlGubun(path));
vo.setTrgetId(extractTrgetId(request));
vo.setTrgetCn(extractTrgetCn(request));
vo.setProcessResult(isFailure(response, ex) ? "F" : "S");
vo.setUserSe(login.getUserSe());
if (accessLogQueue == null) {
LOG.error("[개인정보/SFR-004] accessLogQueue 미주입 — 접속기록 적재 불가: path={}", path);
return;
}
// 큐에 적재만 하고 즉시 반환 — 봉인+INSERT 는 단일 컨슈머가 순차 수행(해시체인 순번 보장, #33).
accessLogQueue.enqueue(vo);
}
// ===================== 대상 판정 =====================
/** contextPath 를 제외한 요청 경로(쿼리 없음). */
private String requestPath(HttpServletRequest request) {
String ctx = request.getContextPath();
String uri = request.getRequestURI();
if (uri == null) {
return "";
}
return (ctx != null && ctx.length() > 0 && uri.startsWith(ctx)) ? uri.substring(ctx.length()) : uri;
}
/**
* 개인정보 취급 화면 화이트리스트 판정.
* 미설정이면 아무것도 기록하지 않는다 — 설정 누락이 전 화면 과수집으로 이어지지 않게 하는 기본값이다.
*/
private boolean isIncluded(String path) {
if (includePatterns == null || includePatterns.isEmpty()) {
return false;
}
for (int i = 0; i < includePatterns.size(); i++) {
String p = includePatterns.get(i);
if (p != null && p.length() > 0 && Pattern.matches(p, path)) {
return true;
}
}
return false;
}
private boolean isExcluded(String path) {
if (excludePatterns == null) {
return false;
}
for (int i = 0; i < excludePatterns.size(); i++) {
String p = excludePatterns.get(i);
if (p != null && p.length() > 0 && Pattern.matches(p, path)) {
return true;
}
}
return false;
}
/**
* 인증된 개인정보취급자 로그인 정보. 취급자가 아니거나 미인증이면 null.
* userSe 가 비어 있으면 취급자 기록 누락을 막기 위해 통과시킨다(fail-safe).
*/
private LoginVO handlerLogin() {
if (!Boolean.TRUE.equals(EgovUserDetailsHelper.isAuthenticated())) {
return null;
}
Object o = EgovUserDetailsHelper.getAuthenticatedUser();
if (!(o instanceof LoginVO)) {
return null;
}
LoginVO login = (LoginVO) o;
if (!notBlank(login.getId())) {
return null;
}
String userSe = login.getUserSe();
if (!notBlank(userSe)) {
return login;
}
if (handlerUserSes == null || handlerUserSes.isEmpty()) {
return login;
}
return handlerUserSes.contains(userSe) ? login : null;
}
/**
* 처리결과 실패 판정 — 예외 발생 또는 4xx/5xx 응답.
*
* <p>{@code HttpServletResponse.getStatus()}는 Servlet 3.0부터다. 이 프로젝트는
* Servlet 2.5 API 로 컴파일되므로 직접 호출하면 컴파일되지 않는다. 런타임 컨테이너는
* Tomcat 9(Servlet 4.0)이라 실제로는 존재하므로 리플렉션으로 부르고, 없으면 성공으로 둔다.</p>
*/
private boolean isFailure(HttpServletResponse response, Exception ex) {
if (ex != null) {
return true;
}
if (response == null) {
return false;
}
try {
Method m = response.getClass().getMethod("getStatus");
Object status = m.invoke(response);
return (status instanceof Integer) && ((Integer) status).intValue() >= 400;
} catch (Throwable t) {
// Servlet 2.5 컨테이너/래퍼 등 미지원 — 판정 불가 시 성공으로 둔다.
return false;
}
}
private String safeIp(HttpServletRequest request) {
try {
String ip = ClientIpResolver.getClientIp(request);
return notBlank(ip) ? ip : "-";
} catch (Exception e) {
return "-";
}
}
// ===================== 메뉴명 해석 =====================
/**
* 요청을 메뉴로 해석한다. 해석 순서는 클래스 Javadoc 참조.
*
* @return 매칭된 메뉴. 해석 불가면 null(호출측이 경로 폴백)
*/
private MenuNameVO resolveMenu(HttpServletRequest request, String path) {
Map<String, MenuNameVO> noMap;
Map<String, MenuNameVO> pathMap;
Map<String, List<MenuNameVO>> dirMap;
try {
ensureCache();
noMap = this.byMenuNo;
pathMap = this.byPath;
dirMap = this.byDir;
} catch (Throwable t) {
LOG.error("[개인정보/SFR-004] 메뉴 캐시 로드 실패 — 경로 폴백으로 기록: path=" + path, t);
return null;
}
if (noMap == null || pathMap == null || dirMap == null) {
return null;
}
// 1) page 파라미터(메뉴번호) — arko 관리자 링크의 표준 단서
String page = trim(request.getParameter("page"));
if (notBlank(page)) {
MenuNameVO byNo = noMap.get(page);
if (byNo != null) {
return byNo;
}
}
// 2) 경로 정확 일치
MenuNameVO exact = pathMap.get(path);
if (exact != null) {
return exact;
}
// 3) 같은 디렉터리 내 최장 공통접두 — 메뉴에 없는 하위 액션을 소관 메뉴로 귀속
return resolveByDirectory(dirMap, path);
}
/**
* 같은 디렉터리의 메뉴 중 요청 경로와 공통접두가 가장 긴 것을 고른다.
* 동률이면 메뉴번호가 작은 쪽(상위/기본 화면일 확률이 높다)을 택해 결과를 결정적으로 만든다.
*/
private MenuNameVO resolveByDirectory(Map<String, List<MenuNameVO>> dirMap, String path) {
int slash = path.lastIndexOf('/');
if (slash < 0) {
return null;
}
List<MenuNameVO> candidates = dirMap.get(path.substring(0, slash + 1));
if (candidates == null || candidates.isEmpty()) {
return null;
}
MenuNameVO best = null;
int bestLen = -1;
for (int i = 0; i < candidates.size(); i++) {
MenuNameVO cand = candidates.get(i);
int len = commonPrefixLength(path, stripQuery(cand.getUrl()));
if (len > bestLen || (len == bestLen && best != null && compareMenuNo(cand, best) < 0)) {
best = cand;
bestLen = len;
}
}
return best;
}
private int commonPrefixLength(String a, String b) {
if (a == null || b == null) {
return 0;
}
int max = Math.min(a.length(), b.length());
int i = 0;
while (i < max && a.charAt(i) == b.charAt(i)) {
i++;
}
return i;
}
/** 메뉴번호 비교(숫자 우선, 파싱 불가 시 문자열). */
private int compareMenuNo(MenuNameVO a, MenuNameVO b) {
String x = nvl(a.getMenuNo());
String y = nvl(b.getMenuNo());
try {
return Long.valueOf(Long.parseLong(x)).compareTo(Long.valueOf(Long.parseLong(y)));
} catch (NumberFormatException e) {
return x.compareTo(y);
}
}
/** 캐시가 없거나 TTL 경과 시 메뉴를 재로드한다(더블체크 락). */
private void ensureCache() {
long now = System.currentTimeMillis();
long ttlMs = (long) cacheTtlSeconds * 1000L;
if (byPath != null && (now - cacheLoadedAt) < ttlMs) {
return;
}
synchronized (this) {
now = System.currentTimeMillis();
if (byPath != null && (now - cacheLoadedAt) < ttlMs) {
return;
}
loadCache();
}
}
/** 메뉴 전량 로드 후 캐시 갱신. 실패 시 기존 캐시 보존(로그만). */
private void loadCache() {
if (menuAuthDAO == null) {
LOG.error("[개인정보/SFR-004] menuAuthDAO 미주입 — 메뉴명 캐시 로드 불가(경로 폴백으로 기록)");
return;
}
try {
List<MenuNameVO> rows = menuAuthDAO.selectMenuNames();
Map<String, MenuNameVO> noMap = new HashMap<String, MenuNameVO>();
Map<String, MenuNameVO> pathMap = new HashMap<String, MenuNameVO>();
Map<String, List<MenuNameVO>> dirMap = new HashMap<String, List<MenuNameVO>>();
if (rows != null) {
for (int i = 0; i < rows.size(); i++) {
MenuNameVO row = rows.get(i);
if (row == null || !notBlank(row.getMenuNm())) {
continue;
}
if (notBlank(row.getMenuNo())) {
noMap.put(trim(row.getMenuNo()), row);
}
String p = stripQuery(row.getUrl());
if (!notBlank(p)) {
continue;
}
// 같은 경로에 메뉴가 둘 이상이면 먼저 온 것을 유지(ORDER 없는 조회라 결정성은
// 메뉴번호로 보정하지 않는다 — 실제 중복은 운영에서 메뉴 정리 대상).
if (!pathMap.containsKey(p)) {
pathMap.put(p, row);
}
int slash = p.lastIndexOf('/');
if (slash >= 0) {
String dir = p.substring(0, slash + 1);
List<MenuNameVO> bucket = dirMap.get(dir);
if (bucket == null) {
bucket = new ArrayList<MenuNameVO>();
dirMap.put(dir, bucket);
}
bucket.add(row);
}
}
}
this.byMenuNo = noMap;
this.byPath = pathMap;
this.byDir = dirMap;
this.cacheLoadedAt = System.currentTimeMillis();
if (LOG.isInfoEnabled()) {
LOG.info("[개인정보/SFR-004] 메뉴명 캐시 로드 완료: menus={}, paths={}, dirs={}",
new Object[] { Integer.valueOf(noMap.size()), Integer.valueOf(pathMap.size()),
Integer.valueOf(dirMap.size()) });
}
} catch (Exception e) {
LOG.error("[개인정보/SFR-004] 메뉴명 캐시 로드 실패(기존 캐시 유지)", e);
}
}
// ===================== 처리구분·처리대상 =====================
/**
* URL 마지막 세그먼트(.do 파일명)로 처리구분을 유도한다.
*
* <p>판정 순서가 중요하다.
* <ol>
* <li>{@code ~View}·{@code ~Pop}·{@code ~Form}으로 끝나면 <b>화면 진입</b>이므로 조회(S).
* {@code EgovMberInsertView}(등록화면)를 등록(I)으로 세면 실제 등록 건수가 부풀려진다.</li>
* <li>{@code select~}로 시작하면 조회(S). 이 규칙이 아래 I/U/D 토큰보다 <b>먼저</b>여야 한다 —
* {@code selectProappActivityApprovalList}(승인대상 목록조회)가 'approv' 때문에
* 수정(U)으로 잡히는 것을 막는다.</li>
* <li>삭제 → 등록 → 수정 토큰 순.</li>
* </ol>
* 짧고 흔한 토큰({@code add}·{@code save}·{@code write}·{@code edit}·{@code chang})은
* 부분일치로 쓰면 오판정한다({@code EgovAddress~}의 'add', {@code exchange}의 'chang').
* 이들은 접두 일치로만 본다.</p>
*/
static String deriveDmlGubun(String path) {
String name = lastSegment(path);
if (name == null) {
return "S";
}
String n = name.toLowerCase();
if (n.endsWith(".do")) {
n = n.substring(0, n.length() - 3);
}
// 1) 등록/수정 '화면' 진입은 조회다.
if (n.endsWith("view") || n.endsWith("pop") || n.endsWith("popup") || n.endsWith("form")) {
return "S";
}
// 2) select~ 는 조회 확정 — 뒤의 행위 토큰보다 우선한다.
if (n.startsWith("select")) {
return "S";
}
// 3) 삭제
if (contains(n, "delete") || contains(n, "remov") || n.endsWith("del")) {
return "D";
}
// 4) 등록
if (contains(n, "insert") || contains(n, "regist") || contains(n, "creat")
|| n.startsWith("add") || n.startsWith("save") || n.startsWith("write")) {
return "I";
}
// 5) 수정
if (contains(n, "updt") || contains(n, "update") || contains(n, "modify")
|| contains(n, "approv") || n.startsWith("chang") || n.startsWith("edit")) {
return "U";
}
return "S";
}
/**
* 요청 파라미터에서 처리대상 식별자를 취득한다(우선순위: {@link #TRGET_ID_PARAMS}).
* 검색어·개인정보 본문은 담지 않는다. 다건이면 첫 값만 담고 건수는 TRGET_CN 이 맡는다.
*/
private String extractTrgetId(HttpServletRequest request) {
for (int i = 0; i < TRGET_ID_PARAMS.length; i++) {
String[] values = request.getParameterValues(TRGET_ID_PARAMS[i]);
if (values == null) {
continue;
}
for (int j = 0; j < values.length; j++) {
String v = trim(values[j]);
if (notBlank(v)) {
return cut(v, TRGET_ID_MAX);
}
}
}
return null;
}
/**
* 처리대상 범위(TRGET_CN)를 만든다 — "몇 건을 다뤘는가".
*
* <p>두 출처를 합친다.
* ① 다건 선택(체크박스 파라미터가 여러 값) → "선택 N건"
* ② 모델 목록 건수({@link #postHandle}이 담아둔 값) → "조회 N건" / "조회 N건(전체 M건)"
* 둘 다 있으면 함께 남긴다. 단건 상세는 TRGET_ID 로 특정되므로 비어도 무방하다.</p>
*/
private String extractTrgetCn(HttpServletRequest request) {
String selected = selectedCount(request);
Object fromModel = request.getAttribute(ATTR_TRGET_CN);
String listCn = (fromModel instanceof String) ? (String) fromModel : null;
if (selected != null && listCn != null) {
return cut(selected + ", " + listCn, TRGET_CN_MAX);
}
if (selected != null) {
return cut(selected, TRGET_CN_MAX);
}
return (listCn == null) ? null : cut(listCn, TRGET_CN_MAX);
}
/** 체크박스 등으로 2건 이상을 한 번에 지정했을 때의 건수. 단건이면 null(TRGET_ID 로 충분). */
private String selectedCount(HttpServletRequest request) {
for (int i = 0; i < TRGET_ID_PARAMS.length; i++) {
String[] values = request.getParameterValues(TRGET_ID_PARAMS[i]);
if (values == null) {
continue;
}
int count = 0;
for (int j = 0; j < values.length; j++) {
if (notBlank(values[j])) {
count++;
}
}
if (count > 1) {
return "선택 " + count + "건";
}
if (count == 1) {
// 단일 값이지만 콤마로 여러 ID를 이어 보내는 화면이 있다(checkedIdForDel 관용).
int commas = countChar(values[0], ',');
if (commas > 0) {
return "선택 " + (commas + 1) + "건";
}
return null;
}
}
return null;
}
private static int countChar(String s, char c) {
if (s == null) {
return 0;
}
int n = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == c) {
n++;
}
}
return n;
}
/**
* 모델에서 처리 건수를 뽑는다.
* 목록 크기(실제 열람·반출 건수)와 전체 검색 건수가 다르면 둘 다 남긴다 —
* "이 관리자가 10건을 봤고 검색 범위는 3,412건이었다"가 감사에서 의미가 다르기 때문이다.
*/
private String resolveResultCount(ModelAndView modelAndView) {
if (modelAndView == null) {
return null;
}
Map<String, Object> model = modelAndView.getModel();
if (model == null || model.isEmpty()) {
return null;
}
Integer listSize = null;
for (int i = 0; i < RESULT_LIST_ATTRS.length; i++) {
Object v = model.get(RESULT_LIST_ATTRS[i]);
if (v instanceof Collection) {
listSize = Integer.valueOf(((Collection<?>) v).size());
break;
}
}
Integer total = null;
Object pi = model.get("paginationInfo");
if (pi instanceof PaginationInfo) {
int t = ((PaginationInfo) pi).getTotalRecordCount();
if (t > 0) {
total = Integer.valueOf(t);
}
}
if (listSize == null && total == null) {
return null;
}
if (listSize == null) {
return "전체 " + total + "건";
}
if (total == null || total.intValue() == listSize.intValue()) {
return "조회 " + listSize + "건";
}
return "조회 " + listSize + "건(전체 " + total + "건)";
}
// ===================== 유틸 =====================
private static boolean contains(String s, String token) {
return s.indexOf(token) >= 0;
}
private static String lastSegment(String path) {
if (path == null) {
return null;
}
int slash = path.lastIndexOf('/');
return (slash >= 0) ? path.substring(slash + 1) : path;
}
private static String stripQuery(String url) {
if (url == null) {
return null;
}
int q = url.indexOf('?');
return (q >= 0) ? url.substring(0, q) : url;
}
private static String cut(String s, int max) {
if (s == null) {
return null;
}
String t = s.trim();
return (t.length() > max) ? t.substring(0, max) : t;
}
private static String trim(String s) {
return (s == null) ? null : s.trim();
}
private static String nvl(String s) {
return (s == null) ? "" : s;
}
private static boolean notBlank(String s) {
return s != null && s.trim().length() > 0;
}
}

63
src/main/java/egovframework/com/cmm/privacy/interceptor/MenuNameVO.java
View File

@ -1,63 +0,0 @@
package egovframework.com.cmm.privacy.interceptor;
import java.io.Serializable;
/**
* 메뉴번호 → 메뉴명/URL 매핑 행(row) VO.
*
* <p>개인정보보호 기능개선 사업(SFR-004 접속기록) — {@link MenuAccessLogInterceptor}가
* "관리자 화면에서 어떤 메뉴를 열었는지"를 접속기록의 수행업무로 남기기 위해,
* 기존 arko 메뉴 2테이블(COMTNMENUINFO + COMTNPROGRMLIST)을 조인해 캐싱하는 단일 행 표현.</p>
*
* <ul>
* <li>menuNo : 메뉴번호(COMTNMENUINFO.MENU_NO). arko 관리자 화면은 URL 에 {@code ?page=<메뉴번호>}
* 를 붙여 좌측메뉴 활성화를 판정하므로, 요청 파라미터 {@code page} 로도 직접 매칭된다.</li>
* <li>menuNm : 메뉴명(COMTNMENUINFO.MENU_NM). 접속기록의 수행업무명(JOB_SE_NM)이 된다.</li>
* <li>url : 프로그램 URL(COMTNPROGRMLIST.URL). 쿼리스트링 포함 가능 →
* 인터셉터가 '?' 앞 경로만 취해 캐시에 적재</li>
* </ul>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.07 URP 최초 생성 (개인정보보호 SFR-004 — 관리자 메뉴 접속기록 전환)
* </pre>
*/
public class MenuNameVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 메뉴번호(MENU_NO) */
private String menuNo;
/** 메뉴명(MENU_NM) */
private String menuNm;
/** 프로그램 URL(쿼리스트링 포함 가능) */
private String url;
public String getMenuNo() {
return menuNo;
}
public void setMenuNo(String menuNo) {
this.menuNo = menuNo;
}
public String getMenuNm() {
return menuNm;
}
public void setMenuNm(String menuNm) {
this.menuNm = menuNm;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
}

17
src/main/java/egovframework/com/cmm/privacy/interceptor/PrivacyMenuAuthDAO.java
View File

@ -21,7 +21,6 @@ import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.07.22 URP 최초 생성 (개인정보보호 기능개선 사업 SFR-001 요건4 / #2)
* 2026.08.07 URP selectMenuNames 추가 (SFR-004 — 관리자 메뉴 접속기록 전환)
* </pre>
*/
@Repository("privacyMenuAuthDAO")
@ -38,20 +37,4 @@ public class PrivacyMenuAuthDAO extends EgovComAbstractDAO {
public List<MenuAuthVO> selectMenuUrlRoles() throws Exception {
return list("PrivacyMenuAuthDAO.selectMenuUrlRoles", null);
}
/**
* (메뉴번호, 메뉴명, 프로그램 URL) 전체 목록을 조회한다(파라미터 없음).
*
* <p>{@link MenuAccessLogInterceptor}가 "요청 URL·page 파라미터 → 메뉴명"을 해석하기 위해
* 최초 요청 시 1회 전량 로드해 캐싱한다. 권한 배정(COMTNMENUCREATDTLS)과 무관하게
* <b>메뉴에 연결된 프로그램 전체</b>를 대상으로 한다 — 롤에 배정되지 않은 메뉴로 진입한
* 요청도 기록해야 하기 때문이다(기록 대상 판정은 인터셉터의 경로 접두·취급자 구분이 담당).</p>
*
* @return (menuNo, menuNm, url) 목록. 없으면 빈 목록.
* @throws Exception 조회 오류
*/
@SuppressWarnings("unchecked")
public List<MenuNameVO> selectMenuNames() throws Exception {
return list("PrivacyMenuAuthDAO.selectMenuNames", null);
}
}

164
src/main/java/egovframework/com/cmm/privacy/interceptor/SessionPolicyInterceptor.java
View File

@ -1,164 +0,0 @@
package egovframework.com.cmm.privacy.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import egovframework.com.cmm.privacy.policy.AccessControlPolicyService;
import egovframework.com.cmm.privacy.policy.AccessControlPolicyVO;
/**
* 접근통제 세션 정책 인터셉터 — 개인정보보호 기능개선 사업(SER-001 요건 5, 자동 접속차단).
*
* <p>「개인정보보호강화 파일럿 개발항목」 접근통제 정책 적용(Action2) 시안의
* <b>'미사용 자동 로그아웃'을 web.xml 수정·재배포 없이 관리자 설정값으로 즉시 반영</b>하는 지점이다.
* 2025.9 자료요청 3번 "시간 설정 기능 없음" 지적에 대응한다.</p>
*
* <p><b>하는 일 두 가지</b>
* <ol>
* <li>관리자 화면({@code /mnt/}) 요청마다 로그인 세션의
* {@code maxInactiveInterval} 을 정책값(ACCESS_CONTROL_POLICY.AUTO_LOGOUT_MIN)으로 맞춘다.
* web.xml 의 {@code <session-timeout>} 은 세션 생성 시 기본값일 뿐이며, 여기서 덮어쓴 값이
* 해당 세션의 실제 타임아웃이 된다.</li>
* <li>로그인 시각({@value #ATTR_LOGIN_TIME})을 세션에 도장 찍는다. 관리자 상단(top.jsp)의
* <b>"로그인 후 경과시간"</b> 표시가 이 값을 쓴다.
* <p>로그인 경로가 여럿(actionLogin / EgovSpringSecurityLoginFilter / SSO 필터)이라
* 각 경로를 고쳐 도장을 찍는 대신, 세션에 loginVO 가 생긴 뒤 <b>첫 관리자 요청</b>에서
* 한 번만 찍는다. 로그인 직후 곧바로 관리자 화면으로 이동하므로 실제 오차는 1초 미만이고,
* 인증 경로를 건드리지 않아 회귀 위험이 없다.</p></li>
* </ol>
*
* <p><b>적용 범위</b> — {@code applyPathPrefix}(기본 {@code /mnt/}) 이면서 세션에 loginVO 가 있을 때만
* 동작한다. 무인증 프론트(frt) 세션은 건드리지 않아 일반회원 이용에 영향이 없다.</p>
*
* <p><b>fail-safe</b> — 정책 조회 실패는 화면 접근을 막지 않는다. 서비스가 기본값(30분)을 돌려주며,
* 서비스 미주입 시에는 아무 것도 하지 않고 통과한다(web.xml 기본값이 그대로 유효).</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (접근통제 정책 적용 — 자동 로그아웃 정책값화)
* </pre>
*/
public class SessionPolicyInterceptor extends HandlerInterceptorAdapter {
private static final Logger LOG = LoggerFactory.getLogger(SessionPolicyInterceptor.class);
/** 로그인 시각(ms) 세션 키. top.jsp 경과시간 표시가 참조한다. */
public static final String ATTR_LOGIN_TIME = "PRIVACY_LOGIN_TIME";
/** 적용 중인 자동 로그아웃 시간(초) 세션 키. top.jsp 카운트다운이 참조한다. */
public static final String ATTR_AUTO_LOGOUT_SEC = "PRIVACY_AUTO_LOGOUT_SEC";
/** 만료 임박 안내 시점(초 전) 세션 키. 0이면 안내 미사용. */
public static final String ATTR_EXPIRE_NOTICE_SEC = "PRIVACY_EXPIRE_NOTICE_SEC";
/** 로그인 정보 세션 키. */
private static final String ATTR_LOGIN_VO = "loginVO";
/** 적용 경로 접두사. 기본 관리자 영역. */
private String applyPathPrefix = "/mnt/";
private AccessControlPolicyService accessControlPolicyService;
public void setApplyPathPrefix(String applyPathPrefix) {
this.applyPathPrefix = applyPathPrefix;
}
public void setAccessControlPolicyService(AccessControlPolicyService accessControlPolicyService) {
this.accessControlPolicyService = accessControlPolicyService;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
try {
String uri = request.getRequestURI();
String ctx = request.getContextPath();
if (ctx != null && ctx.length() > 0 && uri.startsWith(ctx)) {
uri = uri.substring(ctx.length());
}
if (applyPathPrefix != null && !uri.startsWith(applyPathPrefix)) {
return true;
}
// 세션을 새로 만들지 않는다 — 무인증 요청까지 세션을 생성하면 불필요한 부하가 된다.
HttpSession session = request.getSession(false);
if (session == null || session.getAttribute(ATTR_LOGIN_VO) == null) {
return true;
}
// 로그인 시각 도장 — 로그인 후 최초 1회만.
if (session.getAttribute(ATTR_LOGIN_TIME) == null) {
session.setAttribute(ATTR_LOGIN_TIME, Long.valueOf(System.currentTimeMillis()));
}
// 자동 로그아웃 시간 적용(정책값). 미주입 시 web.xml 기본값 유지.
if (accessControlPolicyService != null) {
AccessControlPolicyVO policy = accessControlPolicyService.getCachedPolicy();
int timeoutSec = policy.getAutoLogoutSec();
if (timeoutSec > 0 && session.getMaxInactiveInterval() != timeoutSec) {
session.setMaxInactiveInterval(timeoutSec);
}
// 화면(top.jsp)이 스크립틀릿·별도 조회 없이 JSTL 로 읽어 쓰도록 세션에 실어둔다.
session.setAttribute(ATTR_AUTO_LOGOUT_SEC, Integer.valueOf(session.getMaxInactiveInterval()));
session.setAttribute(ATTR_EXPIRE_NOTICE_SEC,
Integer.valueOf(policy.isExpireNoticeUse() ? policy.getExpireNoticeMin() * 60 : 0));
} else {
session.setAttribute(ATTR_AUTO_LOGOUT_SEC, Integer.valueOf(session.getMaxInactiveInterval()));
session.setAttribute(ATTR_EXPIRE_NOTICE_SEC, Integer.valueOf(0));
}
} catch (Exception e) {
// 세션 정책 적용 실패가 화면 진입을 막아서는 안 된다.
LOG.error("[개인정보/접근통제] 세션 정책 적용 오류 - 요청은 계속 진행: {}", e.toString());
}
return true;
}
/**
* 로그인 후 경과 시간(초). 도장이 없으면 세션 생성시각을 대신 쓴다.
*
* @param session 현재 세션(널이면 0)
* @return 경과 초(음수가 나오지 않도록 0 하한)
*/
public static long elapsedLoginSec(HttpSession session) {
if (session == null) {
return 0L;
}
long base;
Object stamped = session.getAttribute(ATTR_LOGIN_TIME);
if (stamped instanceof Long) {
base = ((Long) stamped).longValue();
} else {
base = session.getCreationTime();
}
long elapsed = (System.currentTimeMillis() - base) / 1000L;
return elapsed < 0L ? 0L : elapsed;
}
/**
* 자동 로그아웃까지 남은 시간(초).
*
* <p>세션 타임아웃은 <b>마지막 접근시각</b>부터 흐른다. 이 메서드는 화면 렌더 시점 기준의
* 잔여시간을 돌려주며, 화면 타이머는 이 값에서 카운트다운한다.</p>
*
* @param session 현재 세션(널이거나 타임아웃 미설정이면 0)
* @return 잔여 초(0 하한)
*/
public static long remainSec(HttpSession session) {
if (session == null) {
return 0L;
}
int timeoutSec = session.getMaxInactiveInterval();
if (timeoutSec <= 0) {
return 0L;
}
long idle = (System.currentTimeMillis() - session.getLastAccessedTime()) / 1000L;
long remain = timeoutSec - idle;
return remain < 0L ? 0L : remain;
}
}

13
src/main/java/egovframework/com/cmm/privacy/lock/LoginFailHistoryDAO.java
View File

@ -5,7 +5,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
@ -31,17 +30,7 @@ public class LoginFailHistoryDAO extends EgovComAbstractDAO {
/** 인증 실패 이력 목록(검색·페이징) */
@SuppressWarnings("unchecked")
public List<LoginFailHistoryVO> selectLoginFailHistoryList(LoginFailHistoryVO vo) {
List<LoginFailHistoryVO> result = list("LoginFailHistoryDAO.selectLoginFailHistoryList", vo);
// GNR(일반회원)만 userNm이 암호문이다 — USR(취급자)는 평문이다.
if (result != null) {
for (int i = 0; i < result.size(); i++) {
LoginFailHistoryVO row = result.get(i);
if (row != null && "GNR".equals(row.getGubun())) {
MemberNmDecryptSupport.decryptInPlace(row, "userNm");
}
}
}
return result;
return list("LoginFailHistoryDAO.selectLoginFailHistoryList", vo);
}
/** 인증 실패 이력 전체 건수(페이징) */

346
src/main/java/egovframework/com/cmm/privacy/policy/AccessControlPolicyController.java
View File

@ -1,346 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import egovframework.com.cmm.LoginVO;
import egovframework.com.cmm.privacy.interceptor.SessionPolicyInterceptor;
import egovframework.com.cmm.util.EgovUserDetailsHelper;
/**
* 접근통제 정책 설정 컨트롤러 (SER-001 요건 4·5).
*
* <p>「개인정보보호강화 파일럿 개발항목」 접근통제 정책 적용(Action2) 시안의
* <b>접근통제 정책 설정</b> 화면을 담당한다.</p>
*
* <ul>
* <li>{@code /mnt/sec/accessPolicy/policyView.do} — 정책 설정 화면(서버 렌더링)</li>
* <li>{@code /mnt/privacy/accessPolicyUpdate.do} — 정책 저장(AJAX/JSON)</li>
* <li>{@code /mnt/session/extend.do} — 세션 연장(만료 임박 안내에서 호출)</li>
* <li>{@code /mnt/session/status.do} — 로그인 경과/잔여시간 조회(상단 표시 갱신용)</li>
* <li>{@code /mnt/privacy/lockExempt*.do} — 잠금 예외 계정 조회/등록/해제(#24)</li>
* </ul>
*
* <p><b>경로 선정 근거</b> — 세션 연장·상태 조회는 전체관리자 전용이 아니라
* <b>로그인한 모든 취급자</b>가 써야 한다. {@code /mnt/privacy/*}·{@code /mnt/sec/*} 는
* AuthorityInterceptor 에서 ROLE_ADMIN 전용으로 매핑돼 있어 시도·시군구 관리자가 403 을
* 맞으므로, 별도 대역 {@code /mnt/session/} 을 쓰고 두 판정 인터셉터의 예외에 등록한다.</p>
*
* <pre>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (접근통제 정책 적용 화면)
* </pre>
*/
@Controller
public class AccessControlPolicyController {
private static final String LOGIN_REDIRECT = "redirect:/uat/uia/egovLoginUsr.do";
@Resource(name = "accessControlPolicyService")
private AccessControlPolicyService accessControlPolicyService;
@Resource(name = "loginLockExemptService")
private LoginLockExemptService loginLockExemptService;
// ────────────────────────────────────────────────────────── 정책 화면
/**
* 접근통제 정책 설정 화면.
* 뷰: /WEB-INF/jsp/site/mnt/sec/accessPolicy/policy.jsp
*/
@RequestMapping(value = "/mnt/sec/accessPolicy/policyView.do")
public String accessPolicyView(ModelMap model) throws Exception {
if (handlerUser() == null) {
return LOGIN_REDIRECT;
}
model.addAttribute("policy", accessControlPolicyService.selectPolicy());
return "site/mnt/sec/accessPolicy/policy";
}
/** 접근통제 정책 저장(AJAX). */
@RequestMapping(value = "/mnt/privacy/accessPolicyUpdate.do")
public String updateAccessPolicy(@ModelAttribute("policy") AccessControlPolicyVO policy,
HttpServletRequest request, ModelMap model) throws Exception {
LoginVO loginVO = handlerUser();
if (loginVO == null) {
return denyJson(model);
}
if (!isSameOrigin(request)) {
return failJson(model, "잘못된 요청 경로입니다.");
}
String invalid = validate(policy);
if (invalid != null) {
return failJson(model, invalid);
}
policy.setUpdId(loginVO.getId());
accessControlPolicyService.updatePolicy(policy);
// 저장한 관리자 본인의 현재 세션에도 즉시 반영(다음 요청을 기다리지 않는다).
HttpSession session = request.getSession(false);
if (session != null) {
session.setMaxInactiveInterval(policy.getAutoLogoutSec());
}
model.addAttribute("result", "success");
return "jsonView";
}
/**
* 화면 우회 입력(직접 POST)에 대비한 서버측 범위 검증. 위반 시 사용자 메시지 반환.
*
* <p>상한을 두는 이유: 자동 로그아웃을 사실상 무한대로 늘리거나 잠금 임계값을 크게 잡아
* 안전성 확보조치 기준 제6조를 우회하는 설정을 막는다.</p>
*/
private String validate(AccessControlPolicyVO p) {
if (p.getLockThreshold() < 1 || p.getLockThreshold() > 10) {
return "인증 실패 계정 잠금 횟수는 1~10회 범위로 입력하세요. (기준 권고 5회)";
}
if (!AccessControlPolicyVO.UNLOCK_MODE_HIST.equals(p.getUnlockMode())
&& !AccessControlPolicyVO.UNLOCK_MODE_HIST_RESN.equals(p.getUnlockMode())) {
return "잠금 해제 방식 값이 올바르지 않습니다.";
}
if (p.getAutoLogoutMin() < 5 || p.getAutoLogoutMin() > 120) {
return "미사용 자동 로그아웃 시간은 5~120분 범위로 입력하세요. (기준 권고 30분)";
}
// 체크박스 미전송 시 null → 'N' 보정
p.setExpireNoticeYn(normalizeYn(p.getExpireNoticeYn()));
p.setSessionRegenYn(normalizeYn(p.getSessionRegenYn()));
if (p.getExpireNoticeYn() == null) {
return "만료 임박 안내 사용여부 값이 올바르지 않습니다.";
}
if (p.getSessionRegenYn() == null) {
return "세션 재발급 사용여부 값이 올바르지 않습니다.";
}
// 안내가 꺼져 있으면 시점값을 검증하지 않는다(화면에서도 비활성 입력이라 과거값이 남아 있을 수 있다).
if ("Y".equals(p.getExpireNoticeYn())
&& (p.getExpireNoticeMin() < 1 || p.getExpireNoticeMin() >= p.getAutoLogoutMin())) {
return "만료 임박 안내 시점은 1분 이상이며 자동 로그아웃 시간보다 작아야 합니다.";
}
return null;
}
/** 'Y'/'N' 이외(널·공백 포함)는 'N'. 값이 있으나 Y/N 이 아니면 null(=오류). */
private String normalizeYn(String value) {
if (value == null || value.trim().length() == 0) {
return "N";
}
String v = value.trim();
if ("Y".equals(v) || "N".equals(v)) {
return v;
}
return null;
}
// ────────────────────────────────────────────────────── 잠금 예외 계정(#24)
/**
* 잠금 예외 계정 목록(JSON). 정책 화면의 '잠금 예외 계정' 섹션이 진입 시 호출한다.
*/
@RequestMapping(value = "/mnt/privacy/lockExemptList.do")
public String lockExemptList(ModelMap model) throws Exception {
if (handlerUser() == null) {
return denyJson(model);
}
model.addAttribute("result", "success");
model.addAttribute("list", loginLockExemptService.selectExemptList());
return "jsonView";
}
/**
* 잠금 예외 계정 등록(JSON).
*
* <p>대상 ID 가 취급자(COMTNEMPLYRINFO)로 실존하는지 서버측에서 확인한다 — 오타로
* 존재하지 않는 ID 가 등록되면 "예외를 걸어 뒀다"고 믿는 계정이 실제로는 잠기는
* 상황이 되고, 그 사실은 잠긴 뒤에야 드러난다. 저장되는 ID 는 입력값이 아니라
* 조회된 표기 그대로의 EMPLYR_ID 다(대소문자 불일치로 캐시 비교가 어긋나지 않게).</p>
*/
@RequestMapping(value = "/mnt/privacy/lockExemptAdd.do")
public String lockExemptAdd(@RequestParam(value = "exemptId", required = false) String exemptId,
@RequestParam(value = "exemptResn", required = false) String exemptResn,
HttpServletRequest request, ModelMap model) throws Exception {
LoginVO loginVO = handlerUser();
if (loginVO == null) {
return denyJson(model);
}
if (!isSameOrigin(request)) {
return failJson(model, "잘못된 요청 경로입니다.");
}
String id = exemptId == null ? "" : exemptId.trim();
String resn = exemptResn == null ? "" : exemptResn.trim();
if (id.length() == 0) {
return failJson(model, "예외로 등록할 계정 ID를 입력하세요.");
}
if (id.length() > 20) {
return failJson(model, "계정 ID는 20자 이내로 입력하세요.");
}
if (resn.length() == 0) {
return failJson(model, "예외 등록 사유를 입력하세요. 사유는 감사 대응상 필수입니다.");
}
if (resn.length() > 500) {
return failJson(model, "예외 등록 사유는 500자 이내로 입력하세요.");
}
LoginLockExemptVO found = loginLockExemptService.selectEmplyr(id);
if (found == null) {
return failJson(model, "존재하지 않는 취급자 계정입니다. 계정 ID를 확인하세요.");
}
if (loginLockExemptService.isExempt(found.getExemptId())) {
return failJson(model, "이미 잠금 예외로 등록된 계정입니다.");
}
LoginLockExemptVO vo = new LoginLockExemptVO();
vo.setExemptId(found.getExemptId());
vo.setExemptResn(resn);
vo.setRegId(loginVO.getId());
loginLockExemptService.insertExempt(vo);
model.addAttribute("result", "success");
return "jsonView";
}
/** 잠금 예외 계정 해제(JSON). 해제 즉시 해당 계정은 다시 잠금 판정 대상이 된다. */
@RequestMapping(value = "/mnt/privacy/lockExemptDelete.do")
public String lockExemptDelete(@RequestParam(value = "exemptId", required = false) String exemptId,
HttpServletRequest request, ModelMap model) throws Exception {
if (handlerUser() == null) {
return denyJson(model);
}
if (!isSameOrigin(request)) {
return failJson(model, "잘못된 요청 경로입니다.");
}
String id = exemptId == null ? "" : exemptId.trim();
if (id.length() == 0) {
return failJson(model, "해제할 계정 ID가 없습니다.");
}
loginLockExemptService.deleteExempt(id);
model.addAttribute("result", "success");
return "jsonView";
}
// ────────────────────────────────────────────────────────── 세션 상태·연장
/**
* 세션 상태 조회(JSON). 관리자 상단의 <b>로그인 경과시간·자동 로그아웃 잔여시간</b> 표시가
* 페이지 이동 없이 갱신할 때 쓴다.
*
* <p><b>주의</b> — 이 요청 자체가 세션을 갱신(lastAccessedTime 초기화)하므로,
* 화면 타이머는 이 엔드포인트를 <b>주기 폴링하지 않는다</b>. 그렇게 하면 "미사용 자동
* 로그아웃"이 영원히 오지 않는다. 페이지 진입 시 1회, 그리고 사용자가 연장을 선택했을 때만
* 호출한다.</p>
*/
@RequestMapping(value = "/mnt/session/status.do")
public String sessionStatus(HttpServletRequest request, ModelMap model) throws Exception {
HttpSession session = request.getSession(false);
if (session == null || handlerUser() == null) {
model.addAttribute("result", "expired");
return "jsonView";
}
model.addAttribute("result", "success");
model.addAttribute("elapsedSec", Long.valueOf(SessionPolicyInterceptor.elapsedLoginSec(session)));
model.addAttribute("timeoutSec", Integer.valueOf(session.getMaxInactiveInterval()));
return "jsonView";
}
/**
* 세션 연장(JSON). 만료 임박 안내에서 사용자가 '연장'을 선택하면 호출된다.
*
* <p>연장이라 해도 별도 처리는 필요 없다 — 이 요청이 컨테이너에 도달한 순간
* lastAccessedTime 이 갱신되어 타임아웃이 처음부터 다시 흐른다. 응답으로 갱신된
* 잔여시간을 돌려주어 화면 타이머를 재동기화한다.</p>
*/
@RequestMapping(value = "/mnt/session/extend.do")
public String sessionExtend(HttpServletRequest request, ModelMap model) throws Exception {
HttpSession session = request.getSession(false);
if (session == null || handlerUser() == null) {
model.addAttribute("result", "expired");
return "jsonView";
}
// 정책값을 다시 적용해 두면 연장 직후부터 최신 설정이 반영된다.
session.setMaxInactiveInterval(accessControlPolicyService.getCachedPolicy().getAutoLogoutSec());
model.addAttribute("result", "success");
model.addAttribute("elapsedSec", Long.valueOf(SessionPolicyInterceptor.elapsedLoginSec(session)));
model.addAttribute("timeoutSec", Integer.valueOf(session.getMaxInactiveInterval()));
return "jsonView";
}
// ────────────────────────────────────────────────────────── 공통
/**
* 취급자 영역(/mnt) 인증·구분 판정. 인터셉터 3단만으로는 무인증 노출 가능성이 있어
* 컨트롤러 단에서 직접 판정한다(AccountMngController 와 동일 규약).
*
* @return 인증된 업무사용자(USR) LoginVO, 그 외에는 null
*/
private LoginVO handlerUser() {
if (!Boolean.TRUE.equals(EgovUserDetailsHelper.isAuthenticated())) {
return null;
}
Object o = EgovUserDetailsHelper.getAuthenticatedUser();
if (!(o instanceof LoginVO)) {
return null;
}
LoginVO loginVO = (LoginVO) o;
return "USR".equals(loginVO.getUserSe()) ? loginVO : null;
}
/**
* CSRF 부분 완화. Spring Security 2.0.4 에는 CSRF 토큰 기능이 없으므로,
* Origin/Referer 가 전달된 경우에 한해 요청 호스트와 동일한지 확인한다.
*/
private boolean isSameOrigin(HttpServletRequest request) {
String source = request.getHeader("Origin");
if (source == null) {
source = request.getHeader("Referer");
}
if (source == null) {
return true;
}
String sourceHost = hostOf(source);
String requestHost = hostOf(request.getHeader("Host"));
return sourceHost != null && sourceHost.equalsIgnoreCase(requestHost);
}
/** "https://host:8080/path" · "host:8080" 등에서 호스트명만 추출. */
private String hostOf(String value) {
if (value == null) {
return null;
}
String host = value;
int scheme = host.indexOf("://");
if (scheme >= 0) {
host = host.substring(scheme + 3);
}
int slash = host.indexOf('/');
if (slash >= 0) {
host = host.substring(0, slash);
}
int colon = host.indexOf(':');
if (colon >= 0) {
host = host.substring(0, colon);
}
return host.length() == 0 ? null : host;
}
private String denyJson(ModelMap model) {
return failJson(model, "접근 권한이 없습니다. 관리자 계정으로 로그인 후 이용하세요.");
}
private String failJson(ModelMap model, String message) {
model.addAttribute("result", "fail");
model.addAttribute("message", message);
return "jsonView";
}
}

45
src/main/java/egovframework/com/cmm/privacy/policy/AccessControlPolicyDAO.java
View File

@ -1,45 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 접근통제 정책 DAO (SER-001 요건 4·5).
*
* <p>statement 는 {@code PrivacyAccessControlPolicy_SQL_Mysql.xml}
* (namespace {@code AccessControlPolicyDAO}), sql-map-config 등록.</p>
*
* <p>루트 컨텍스트 {@code @Repository} 빈이므로 자식(servlet) 컨텍스트의
* 인터셉터에서도 참조할 수 있다.</p>
*/
@Repository("accessControlPolicyDAO")
public class AccessControlPolicyDAO extends EgovComAbstractDAO {
/** 정책 단일행 조회. 없으면 null(호출부 기본값 fallback). */
public AccessControlPolicyVO selectPolicy() {
return (AccessControlPolicyVO) selectByPk("AccessControlPolicyDAO.selectPolicy", null);
}
/** 정책 수정. */
public int updatePolicy(AccessControlPolicyVO vo) {
return update("AccessControlPolicyDAO.updatePolicy", vo);
}
/**
* 정책 잠금 임계값을 인증 경로가 읽는 LOGIN_LOCK_COUNT 에 동기화한다.
*
* <p>인증 실패 잠금 판정은 기존 자산({@code loginDAO.selectFailTotalCount} → LOGIN_LOCK_COUNT)을
* 그대로 쓰므로, 정책 저장 시 이 한 줄이 있어야 "설정 즉시 활성 인증 경로에 적용"이 성립한다.</p>
*
* @return 갱신 행 수(0이면 LOGIN_LOCK_COUNT 가 비어 있는 것 — 호출부에서 INSERT 보정)
*/
public int updateLoginLockCount(AccessControlPolicyVO vo) {
return update("AccessControlPolicyDAO.updateLoginLockCount", vo);
}
/** LOGIN_LOCK_COUNT 가 비어 있을 때 임계값 1행을 생성한다. */
public void insertLoginLockCount(AccessControlPolicyVO vo) {
insert("AccessControlPolicyDAO.insertLoginLockCount", vo);
}
}

23
src/main/java/egovframework/com/cmm/privacy/policy/AccessControlPolicyService.java
View File

@ -1,23 +0,0 @@
package egovframework.com.cmm.privacy.policy;
/**
* 접근통제 정책 서비스 (SER-001 요건 4·5).
*
* <p>계정 잠금 임계값·자동 로그아웃 시간·세션 재발급 여부의 조회/수정.
* 인터셉터·인증 컨트롤러가 요청마다 호출하므로 조회는 짧은 TTL 캐시를 둔다.</p>
*/
public interface AccessControlPolicyService {
/** 현재 정책 조회(미설정 시 기본값 VO 반환). DB 직접 조회 — 관리자 화면용. */
AccessControlPolicyVO selectPolicy() throws Exception;
/**
* 현재 정책 조회(TTL 캐시). 인터셉터·인증 경로 등 요청마다 호출되는 지점 전용.
*
* <p>조회 실패 시에도 예외를 던지지 않고 기본값 VO 를 반환한다(사이트 잠금 방지).</p>
*/
AccessControlPolicyVO getCachedPolicy();
/** 정책 수정 + LOGIN_LOCK_COUNT 동기화 + 캐시 무효화. */
void updatePolicy(AccessControlPolicyVO vo) throws Exception;
}

86
src/main/java/egovframework/com/cmm/privacy/policy/AccessControlPolicyServiceImpl.java
View File

@ -1,86 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Service;
/**
* 접근통제 정책 서비스 구현 (SER-001 요건 4·5).
*
* <p><b>캐시</b> — {@code SessionPolicyInterceptor} 가 관리자 화면 요청마다 정책을 읽으므로
* 매 요청 DB 조회를 피하기 위해 짧은 TTL(기본 60초) 캐시를 둔다. 저장 시에는 즉시 무효화하여
* "설정 저장 → 즉시 적용"을 보장한다(시안의 '설정 저장·즉시 적용').</p>
*
* <p><b>fail-safe</b> — 정책 조회 실패(테이블 미생성·DB 오류)는 관리자 화면 접근 자체를
* 막으면 안 된다. {@link #getCachedPolicy()} 는 예외를 삼키고 기본값 VO(잠금 5회·30분)를
* 반환한다. 기본값은 강화된 정책값이라 fail-open 이 아니다.</p>
*
* <pre>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (접근통제 정책 적용 화면)
* </pre>
*/
@Service("accessControlPolicyService")
public class AccessControlPolicyServiceImpl implements AccessControlPolicyService {
private static final Log LOG = LogFactory.getLog(AccessControlPolicyServiceImpl.class);
/** 캐시 수명(ms). 저장 시 즉시 무효화되므로 관리자 체감 지연은 없다. */
private static final long CACHE_TTL_MS = 60 * 1000L;
@Resource(name = "accessControlPolicyDAO")
private AccessControlPolicyDAO accessControlPolicyDAO;
/** 캐시된 정책. volatile 참조 교체만 하므로 락 없이 안전(읽기 다수·쓰기 소수). */
private volatile AccessControlPolicyVO cached;
private volatile long cachedAt;
@Override
public AccessControlPolicyVO selectPolicy() throws Exception {
AccessControlPolicyVO vo = accessControlPolicyDAO.selectPolicy();
// 정책 미설정(시드 미적용) 시 기본값 — 화면이 빈 값으로 뜨지 않게 한다.
return vo != null ? vo : new AccessControlPolicyVO();
}
@Override
public AccessControlPolicyVO getCachedPolicy() {
AccessControlPolicyVO snapshot = cached;
if (snapshot != null && (System.currentTimeMillis() - cachedAt) < CACHE_TTL_MS) {
return snapshot;
}
try {
AccessControlPolicyVO vo = accessControlPolicyDAO.selectPolicy();
if (vo == null) {
vo = new AccessControlPolicyVO();
}
cached = vo;
cachedAt = System.currentTimeMillis();
return vo;
} catch (Exception e) {
// 조회 실패 — 관리자 화면을 막지 않는다. 기본값(잠금 5회·30분)으로 계속 진행.
LOG.error("[개인정보/접근통제] 정책 조회 실패 — 기본값 적용: " + e.getMessage());
AccessControlPolicyVO fallback = snapshot != null ? snapshot : new AccessControlPolicyVO();
cached = fallback;
cachedAt = System.currentTimeMillis();
return fallback;
}
}
@Override
public void updatePolicy(AccessControlPolicyVO vo) throws Exception {
accessControlPolicyDAO.updatePolicy(vo);
// 잠금 임계값은 인증 경로가 LOGIN_LOCK_COUNT 를 읽는다 — 같은 트랜잭션에서 동기화해야
// '저장 즉시 활성 인증 경로에 적용'이 성립한다. 행이 없으면 생성한다.
if (accessControlPolicyDAO.updateLoginLockCount(vo) == 0) {
accessControlPolicyDAO.insertLoginLockCount(vo);
}
// 캐시 무효화 — 다음 요청부터 새 정책(자동 로그아웃 시간 등)이 적용된다.
cached = null;
cachedAt = 0L;
}
}

92
src/main/java/egovframework/com/cmm/privacy/policy/AccessControlPolicyVO.java
View File

@ -1,92 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import java.io.Serializable;
/**
* 접근통제 정책 VO — ACCESS_CONTROL_POLICY(단일행) 매핑.
*
* <p>문화품앗이 개인정보보호 기능개선 사업 — 접근통제 정책 적용(SER-001 요건 4·5).
* 「개인정보보호강화 파일럿 개발항목」 접근통제 정책 적용(Action2) 시안 반영.</p>
*
* <p>계정 잠금 임계값·자동 로그아웃 시간·세션 재발급 여부를 소스/web.xml 하드코딩이 아니라
* 관리자 설정값으로 운영하기 위한 정책 값 묶음이다. 필드 기본값은 정책 미설정(테이블 empty)
* 상황에서도 화면·인터셉터가 안전하게 동작하도록 시안 기준값과 동일하게 둔다.</p>
*
* <pre>
* << 개정이력(Modification Information) >>
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (접근통제 정책 적용 화면)
* </pre>
*/
public class AccessControlPolicyVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 잠금 해제 방식 — 관리자 화면 해제 + 해제 이력 적재. */
public static final String UNLOCK_MODE_HIST = "ADMIN_HIST";
/** 잠금 해제 방식 — 위 + 해제 사유 필수 입력. */
public static final String UNLOCK_MODE_HIST_RESN = "ADMIN_HIST_RESN";
private int policyId = 1;
/** 인증 실패 계정 잠금 임계값(회). 현행 10 → 5. */
private int lockThreshold = 5;
/** 잠금 해제 방식(ADMIN_HIST / ADMIN_HIST_RESN). */
private String unlockMode = UNLOCK_MODE_HIST;
/** 미사용 자동 로그아웃(분). 현행 web.xml 60 → 30. */
private int autoLogoutMin = 30;
/** 세션 만료 임박 안내 사용여부(Y/N). */
private String expireNoticeYn = "Y";
/** 만료 임박 안내 시점(만료 N분 전). */
private int expireNoticeMin = 5;
/** 2차 인증 성공 시 세션 재발급(세션고정 차단) 사용여부(Y/N). */
private String sessionRegenYn = "Y";
private String updId;
private String updDt;
/** 자동 로그아웃 시간(초). 인터셉터가 setMaxInactiveInterval 에 그대로 사용한다. */
public int getAutoLogoutSec() {
return autoLogoutMin * 60;
}
/** 만료 임박 안내 사용 여부. */
public boolean isExpireNoticeUse() {
return "Y".equals(expireNoticeYn);
}
/** 세션 재발급 사용 여부. */
public boolean isSessionRegenUse() {
return "Y".equals(sessionRegenYn);
}
/** 잠금 해제 시 사유 필수 여부. */
public boolean isUnlockResnRequired() {
return UNLOCK_MODE_HIST_RESN.equals(unlockMode);
}
public int getPolicyId() { return policyId; }
public void setPolicyId(int policyId) { this.policyId = policyId; }
public int getLockThreshold() { return lockThreshold; }
public void setLockThreshold(int lockThreshold) { this.lockThreshold = lockThreshold; }
public String getUnlockMode() { return unlockMode; }
public void setUnlockMode(String unlockMode) { this.unlockMode = unlockMode; }
public int getAutoLogoutMin() { return autoLogoutMin; }
public void setAutoLogoutMin(int autoLogoutMin) { this.autoLogoutMin = autoLogoutMin; }
public String getExpireNoticeYn() { return expireNoticeYn; }
public void setExpireNoticeYn(String expireNoticeYn) { this.expireNoticeYn = expireNoticeYn; }
public int getExpireNoticeMin() { return expireNoticeMin; }
public void setExpireNoticeMin(int expireNoticeMin) { this.expireNoticeMin = expireNoticeMin; }
public String getSessionRegenYn() { return sessionRegenYn; }
public void setSessionRegenYn(String sessionRegenYn) { this.sessionRegenYn = sessionRegenYn; }
public String getUpdId() { return updId; }
public void setUpdId(String updId) { this.updId = updId; }
public String getUpdDt() { return updDt; }
public void setUpdDt(String updDt) { this.updDt = updDt; }
}

53
src/main/java/egovframework/com/cmm/privacy/policy/LoginLockExemptDAO.java
View File

@ -1,53 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
/**
* 로그인 실패 계정잠금 예외 DAO (SER-001 / 개발항목 24).
*
* <p>statement 는 {@code PrivacyLoginLockExempt_SQL_Mysql.xml}
* (namespace {@code LoginLockExemptDAO}), sql-map-config 등록.</p>
*
* <p>루트 컨텍스트 {@code @Repository} 빈이므로 자식(servlet) 컨텍스트의
* 인증 컨트롤러에서도 참조할 수 있다.</p>
*/
@Repository("loginLockExemptDAO")
public class LoginLockExemptDAO extends EgovComAbstractDAO {
/** 예외 계정ID 전체 조회 — 캐시 적재용(행 수가 한 자릿수 규모라 전건 조회로 충분). */
@SuppressWarnings("unchecked")
public List<String> selectExemptIds() {
return list("LoginLockExemptDAO.selectExemptIds", null);
}
/** 관리자 화면 목록(사유·등록자·등록일시·대상자 성명 포함). */
@SuppressWarnings("unchecked")
public List<LoginLockExemptVO> selectExemptList() {
return list("LoginLockExemptDAO.selectExemptList", null);
}
/**
* 등록 대상 ID 가 취급자(COMTNEMPLYRINFO)로 실존하는지 확인. 없으면 null.
*
* <p>저장된 표기 그대로의 EMPLYR_ID 와 성명을 돌려준다. 등록 시 이 값을 쓰면
* 관리자가 대소문자를 다르게 입력해도 캐시의 문자열 비교가 어긋나지 않는다
* (MySQL 기본 collation 은 대소문자 무시라 조회는 되지만 자바 비교는 아니다).</p>
*/
public LoginLockExemptVO selectEmplyr(String exemptId) {
return (LoginLockExemptVO) selectByPk("LoginLockExemptDAO.selectEmplyr", exemptId);
}
/** 예외 등록. PK 중복은 호출부에서 사전 확인 후 진입. */
public void insertExempt(LoginLockExemptVO vo) {
insert("LoginLockExemptDAO.insertExempt", vo);
}
/** 예외 해제(행 삭제). */
public int deleteExempt(String exemptId) {
return delete("LoginLockExemptDAO.deleteExempt", exemptId);
}
}

36
src/main/java/egovframework/com/cmm/privacy/policy/LoginLockExemptService.java
View File

@ -1,36 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import java.util.List;
/**
* 로그인 실패 계정잠금 예외 서비스 (SER-001 / 개발항목 24).
*
* <p>지정 계정을 인증 실패 <b>잠금 판정</b>에서만 제외한다. 실패 이력 적재와
* 2차 인증은 예외 계정에도 그대로 적용된다 — 잠금 예외는 인증 예외가 아니다.</p>
*/
public interface LoginLockExemptService {
/**
* 잠금 예외 계정 여부(TTL 캐시). 로그인 시도마다 호출되는 지점 전용.
*
* <p>조회 실패 시 예외를 던지지 않고 {@code false}(예외 아님)를 돌려준다 —
* 판단 불가일 때는 잠금이 정상 동작하는 쪽이 안전하다.</p>
*
* <p>대소문자를 구분하지 않는다(잠금 SQL 의 MySQL collation 과 동일 기준).
* 목록은 취급자(COMTNEMPLYRINFO) ID 만 담으므로, 호출부는 {@code userSe='USR'} 인
* 경우에만 물어야 한다 — 다른 회원구분과 ID 문자열이 겹치면 엉뚱한 계정의 잠금이 풀린다.</p>
*/
boolean isExempt(String loginId);
/** 관리자 화면 목록(사유·등록자·등록일시 포함). DB 직접 조회. */
List<LoginLockExemptVO> selectExemptList() throws Exception;
/** 등록 대상 ID 가 취급자로 실존하는지 확인. 실존하면 저장 표기 그대로의 ID·성명, 없으면 null. */
LoginLockExemptVO selectEmplyr(String exemptId) throws Exception;
/** 예외 등록 + 캐시 무효화. */
void insertExempt(LoginLockExemptVO vo) throws Exception;
/** 예외 해제 + 캐시 무효화. */
void deleteExempt(String exemptId) throws Exception;
}

125
src/main/java/egovframework/com/cmm/privacy/policy/LoginLockExemptServiceImpl.java
View File

@ -1,125 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Service;
/**
* 로그인 실패 계정잠금 예외 서비스 구현 (SER-001 / 개발항목 24).
*
* <p><b>캐시</b> — {@code EgovLoginController.actionLogin()} 이 로그인 시도마다 두 번
* (잠금 선확인·실패 처리) 조회하므로 {@link AccessControlPolicyServiceImpl} 과 동일한
* 짧은 TTL(60초) 캐시를 둔다. 등록·삭제 시 즉시 무효화한다.</p>
*
* <p><b>fail-closed — {@link AccessControlPolicyServiceImpl} 과 반대 방향이다.</b>
* 접근통제 정책 쪽은 조회에 실패해도 기본값(잠금 5회·30분)을 돌려준다. 그 기본값이
* 이미 강화된 값이라 실패가 곧 완화가 아니기 때문이다. 반면 이 화이트리스트는
* <b>있으면 잠금이 면제되는</b> 목록이라, 조회 실패를 관대하게 다루면 그 순간
* 무차별 대입에 대한 잠금이 통째로 풀린다. 따라서 조회 실패 시에는 빈 집합
* (= 예외 계정 없음 = 전 계정 정상 잠금 판정)으로 취급한다. 테이블 미생성 등으로
* 계속 실패하는 상황에서 매 로그인마다 DB를 때리지 않도록, 실패한 빈 집합도
* 동일 TTL 로 캐싱한다(최대 60초 뒤 자동 재시도).</p>
*
* <pre>
* &lt;&lt; 개정이력(Modification Information) &gt;&gt;
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (계정잠금 예외 화이트리스트)
* </pre>
*/
@Service("loginLockExemptService")
public class LoginLockExemptServiceImpl implements LoginLockExemptService {
private static final Log LOG = LogFactory.getLog(LoginLockExemptServiceImpl.class);
/** 캐시 수명(ms). 등록·삭제 시 즉시 무효화되므로 관리자 체감 지연은 없다. */
private static final long CACHE_TTL_MS = 60 * 1000L;
@Resource(name = "loginLockExemptDAO")
private LoginLockExemptDAO loginLockExemptDAO;
/** 캐시된 예외 ID 집합. 불변 집합 참조만 교체하므로 락 없이 안전(읽기 다수·쓰기 소수). */
private volatile Set<String> cachedIds;
private volatile long cachedAt;
@Override
public boolean isExempt(String loginId) {
if (loginId == null || loginId.trim().length() == 0) {
return false;
}
return cachedExemptIds().contains(normalize(loginId));
}
/**
* 잠금 판정 SQL(selectlockCheck·selectFailCount·updateFailLogin)은 모두
* {@code WHERE EMPLYR_ID = #id#} 로 MySQL 기본 collation(대소문자 무시)에 따라 매칭된다.
* 여기서만 자바 문자열을 그대로 비교하면 대소문자를 바꿔 시도하는 것만으로
* 화이트리스트를 우회해 실제 계정에 LOCK_YN='Y' 를 찍을 수 있다 — 이 기능의 존재 이유가 무너진다.
* 잠금 SQL 과 같은 기준으로 맞춘다.
*/
private String normalize(String id) {
return id.trim().toLowerCase(Locale.ENGLISH);
}
private Set<String> cachedExemptIds() {
Set<String> snapshot = cachedIds;
if (snapshot != null && (System.currentTimeMillis() - cachedAt) < CACHE_TTL_MS) {
return snapshot;
}
Set<String> loaded;
try {
List<String> ids = loginLockExemptDAO.selectExemptIds();
loaded = new HashSet<String>();
if (ids != null) {
for (String id : ids) {
if (id != null && id.trim().length() > 0) {
loaded.add(normalize(id));
}
}
}
loaded = Collections.unmodifiableSet(loaded);
} catch (Exception e) {
// fail-closed — 예외 없음으로 취급해 잠금 로직이 정상 동작하게 둔다(위 클래스 주석 참고).
LOG.error("[개인정보/24] 잠금 예외 목록 조회 실패 — 예외 없음(전 계정 잠금 판정)으로 진행: " + e.getMessage());
loaded = Collections.emptySet();
}
cachedIds = loaded;
cachedAt = System.currentTimeMillis();
return loaded;
}
@Override
public List<LoginLockExemptVO> selectExemptList() throws Exception {
return loginLockExemptDAO.selectExemptList();
}
@Override
public LoginLockExemptVO selectEmplyr(String exemptId) throws Exception {
return loginLockExemptDAO.selectEmplyr(exemptId);
}
@Override
public void insertExempt(LoginLockExemptVO vo) throws Exception {
loginLockExemptDAO.insertExempt(vo);
invalidate();
}
@Override
public void deleteExempt(String exemptId) throws Exception {
loginLockExemptDAO.deleteExempt(exemptId);
invalidate();
}
private void invalidate() {
cachedIds = null;
cachedAt = 0L;
}
}

47
src/main/java/egovframework/com/cmm/privacy/policy/LoginLockExemptVO.java
View File

@ -1,47 +0,0 @@
package egovframework.com.cmm.privacy.policy;
import java.io.Serializable;
/**
* 로그인 실패 계정잠금 예외 VO — LOGIN_LOCK_EXEMPT 매핑 (SER-001 / 개발항목 24).
*
* <p>잠금 <b>판정</b>만 면제하는 화이트리스트 한 행이다. 인증 실패 이력(LOGIN_HISTORY)
* 적재와 2차 인증(OTP)은 예외 계정에도 그대로 적용된다.</p>
*
* <pre>
* &lt;&lt; 개정이력(Modification Information) &gt;&gt;
* 수정일 수정자 수정내용
* ---------- ------ ---------------------------
* 2026.08.10 URP 최초 생성 (계정잠금 예외 화이트리스트)
* </pre>
*/
public class LoginLockExemptVO implements Serializable {
private static final long serialVersionUID = 1L;
/** 잠금 예외 대상 계정ID(COMTNEMPLYRINFO.EMPLYR_ID). */
private String exemptId;
/** 예외 등록 사유(필수). */
private String exemptResn;
/** 등록한 관리자 계정ID. */
private String regId;
/** 등록일시(화면 표시용 문자열). */
private String regDt;
/** 대상자 성명 — 목록 조회 시 COMTNEMPLYRINFO 조인 결과. */
private String userNm;
public String getExemptId() { return exemptId; }
public void setExemptId(String exemptId) { this.exemptId = exemptId; }
public String getExemptResn() { return exemptResn; }
public void setExemptResn(String exemptResn) { this.exemptResn = exemptResn; }
public String getRegId() { return regId; }
public void setRegId(String regId) { this.regId = regId; }
public String getRegDt() { return regDt; }
public void setRegDt(String regDt) { this.regDt = regDt; }
public String getUserNm() { return userNm; }
public void setUserNm(String userNm) { this.userNm = userNm; }
}

19
src/main/java/egovframework/com/cmm/privacy/security/SessionRegenerator.java
View File

@ -90,23 +90,4 @@ public final class SessionRegenerator {
}
return newSession;
}
/**
* 세션 재발급 없이 2차 인증 완료 표식만 세팅한다.
*
* <p>접근통제 정책(SER-001 요건4·5)에서 <b>세션 재발급 '미사용'</b>을 선택한 경우에 쓴다.
* 표식까지 빠지면 {@code SecondFactorInterceptor} 가 인증을 통과시키지 않아 무한 리다이렉트가
* 되므로, 재발급을 생략하더라도 표식은 반드시 남긴다.</p>
*
* @param request HTTP 요청
* @return 표식이 세팅된 현재 세션(요청이 널이면 null)
*/
public static HttpSession markSecondFactorDone(HttpServletRequest request) {
if (request == null) {
return null;
}
HttpSession session = request.getSession(true);
session.setAttribute(SECOND_FACTOR_DONE, Boolean.TRUE);
return session;
}
}

40
src/main/java/egovframework/com/cntc/service/impl/CntcDAO.java
View File

@ -6,8 +6,6 @@ import java.util.Map;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberDataHasher;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cntc.service.CntcListVO;
import egovframework.com.cntc.service.CntcRecvVO;
@ -16,26 +14,6 @@ import egovframework.com.cntc.service.CntcSendVO;
@Repository("CntcDAO")
public class CntcDAO extends EgovComAbstractDAO{
/**
* 이름 검색 완전일치 해시 계산(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
* 지연 초기화 — {@link egovframework.com.cmm.privacy.crypto.MemberDataCipher} 정책과 동일.
*/
private MemberDataHasher mberNmHasher;
private void fillSearchKeywordHash(CntcListVO vo) {
if (vo == null || !"name".equals(vo.getSearchCondition()) && !"all".equals(vo.getSearchCondition())) {
return;
}
String kw = vo.getSearchKeyword();
if (kw == null || kw.trim().length() == 0) {
return;
}
if (mberNmHasher == null) {
mberNmHasher = new MemberDataHasher();
}
vo.setSearchKeywordHash(mberNmHasher.hashName(kw));
}
@SuppressWarnings("unchecked")
public List<CntcSendVO> selectSendData(){
return list("CntcDAO.selectSendData", "");
@ -78,14 +56,10 @@ public class CntcDAO extends EgovComAbstractDAO{
}
public List<CntcListVO> selectCntcList(CntcListVO clistvo){
fillSearchKeywordHash(clistvo);
List<CntcListVO> result = list("CntcDAO.selectCntcList", clistvo);
MemberNmDecryptSupport.decryptListInPlace(result, "mberNm");
return result;
return list("CntcDAO.selectCntcList", clistvo);
}
public int selectCntcListTotCnt(CntcListVO clistvo) {
fillSearchKeywordHash(clistvo);
return (Integer)getSqlMapClientTemplate().queryForObject("CntcDAO.selectCntcListTotCnt", clistvo);
}
@ -98,19 +72,11 @@ public class CntcDAO extends EgovComAbstractDAO{
}
public Map<Object, String> selectInDataSendData(Map<String, String> cntcMap) {
Map<Object, String> result = (Map<Object, String>)getSqlMapClientTemplate().queryForObject("CntcDAO.selectInDataSendData", cntcMap);
if (result != null && "GNR".equals(result.get("data11_se"))) {
MemberNmDecryptSupport.decryptInPlace(result, "data11");
}
return result;
return (Map<Object, String>)getSqlMapClientTemplate().queryForObject("CntcDAO.selectInDataSendData", cntcMap);
}
public HashMap<String, String> selectNewInDataSendData(HashMap<String, String> param) {
HashMap<String, String> result = (HashMap<String, String>)getSqlMapClientTemplate().queryForObject("CntcDAO.selectNewInDataSendData", param);
if (result != null && "GNR".equals(result.get("user_nm_se"))) {
MemberNmDecryptSupport.decryptInPlace(result, "user_nm");
}
return result;
return (HashMap<String, String>)getSqlMapClientTemplate().queryForObject("CntcDAO.selectNewInDataSendData", param);
}
public void insertNewSendList(HashMap<String, String> param) {

16
src/main/java/egovframework/com/cop/bbs/service/BoardMasterVO.java
View File

@ -37,21 +37,7 @@ public class BoardMasterVO extends BoardMaster implements Serializable {
/** 정렬순서(DESC,ASC) */
private String sortOrdr = "";
/**
* 최초 등록자 유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
* GNR(일반회원)일 때만 {@code frstRegisterNm}이 암호문이다 — 조건부 복호화 판별용.
*/
private String userSe = "";
public String getUserSe() {
return userSe;
}
public void setUserSe(String userSe) {
this.userSe = userSe;
}
/** 검색사용여부 */
private String searchUseYn = "";

24
src/main/java/egovframework/com/cop/bbs/service/BoardUseInfVO.java
View File

@ -514,30 +514,6 @@ public class BoardUseInfVO extends BoardUseInf implements Serializable {
this.userNm = userNm;
}
/**
* userNm(COMVNUSERMASTER.USER_NM) 출처 회원유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
*/
private String userSe = "";
public String getUserSe() {
return userSe;
}
public void setUserSe(String userSe) {
this.userSe = userSe;
}
/** 이름 검색 완전일치 해시(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10). */
private String searchKeywordHash = "";
public String getSearchKeywordHash() {
return searchKeywordHash;
}
public void setSearchKeywordHash(String searchKeywordHash) {
this.searchKeywordHash = searchKeywordHash;
}
/**
* provdUrl attribute를 리턴한다.
*

11
src/main/java/egovframework/com/cop/bbs/service/BoardVO.java
View File

@ -253,17 +253,6 @@ public class BoardVO extends Board implements Serializable {
this.searchWrd = searchWrd;
}
/** 이름 검색 완전일치 해시(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10). */
private String searchKeywordHash = "";
public String getSearchKeywordHash() {
return searchKeywordHash;
}
public void setSearchKeywordHash(String searchKeywordHash) {
this.searchKeywordHash = searchKeywordHash;
}
/**
* sortOrdr attribute를 리턴한다.
*

13
src/main/java/egovframework/com/cop/bbs/service/Satisfaction.java
View File

@ -243,19 +243,6 @@ public class Satisfaction implements Serializable {
this.frstRegisterNm = frstRegisterNm;
}
/**
* frstRegisterNm(COMVNUSERMASTER.USER_NM) 출처 회원유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
*/
private String userSe = "";
public String getUserSe() {
return userSe;
}
public void setUserSe(String userSe) {
this.userSe = userSe;
}
/**
* frstRegisterPnttm attribute를 리턴한다.
* @return the frstRegisterPnttm

13
src/main/java/egovframework/com/cop/bbs/service/Scrap.java
View File

@ -167,19 +167,6 @@ public class Scrap implements Serializable {
this.frstRegisterNm = frstRegisterNm;
}
/**
* frstRegisterNm(COMVNUSERMASTER.USER_NM) 출처 회원유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
*/
private String userSe = "";
public String getUserSe() {
return userSe;
}
public void setUserSe(String userSe) {
this.userSe = userSe;
}
/**
* frstRegisterPnttm attribute를 리턴한다.
* @return the frstRegisterPnttm

8
src/main/java/egovframework/com/cop/bbs/service/impl/BBSAddedOptionsDAO.java
View File

@ -2,7 +2,6 @@ package egovframework.com.cop.bbs.service.impl;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.bbs.service.BoardMaster;
import egovframework.com.cop.bbs.service.BoardMasterVO;
@ -41,12 +40,7 @@ public class BBSAddedOptionsDAO extends EgovComAbstractDAO {
* @param BoardMasterVO
*/
public BoardMasterVO selectAddedOptionsInf(BoardMaster vo) throws Exception {
BoardMasterVO result = (BoardMasterVO)selectByPk("BBSAddedOptionsDAO.selectAddedOptionsInf", vo);
// GNR(일반회원)만 frstRegisterNm이 암호문이다.
if (result != null && "GNR".equals(result.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(result, "frstRegisterNm");
}
return result;
return (BoardMasterVO)selectByPk("BBSAddedOptionsDAO.selectAddedOptionsInf", vo);
}
/**

4
src/main/java/egovframework/com/cop/bbs/service/impl/BBSLoneMasterDAO.java
View File

@ -51,10 +51,6 @@ public class BBSLoneMasterDAO extends EgovComAbstractDAO {
* @param BoardMasterVO
*/
public BoardMasterVO selectMaster(BoardMaster vo) throws Exception {
// 주의(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10): boardMasterDetail resultMap의
// columnIndex가 이 SQL의 실제 SELECT 컬럼 순서와 기존부터 어긋나 있어(frstRegisterNm이 실제로는
// ATCH_POSBL_FILE_NUMBER 값을 읽음) 여기서 복호화를 걸면 GNR 행에서 암호문이 아닌 값을 복호화
// 시도해 예외가 난다. 이 매핑 자체는 이번 작업 범위 밖의 기존 버그이므로 복호화를 걸지 않는다.
return (BoardMasterVO)selectByPk("BBSLoneMasterDAO.selectMaster", vo);
}

58
src/main/java/egovframework/com/cop/bbs/service/impl/BBSManageDAO.java
View File

@ -7,8 +7,6 @@ import kr.or.arko.mnt.biz.data.service.DataVO;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberDataHasher;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.bbs.service.Board;
import egovframework.com.cop.bbs.service.BoardVO;
@ -32,31 +30,6 @@ import egovframework.com.cop.bbs.service.BoardVO;
@Repository("BBSManageDAO")
public class BBSManageDAO extends EgovComAbstractDAO {
/**
* 이름 검색 전환(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10) 헬퍼. searchCnd='2'일 때만 이름검색이다.
*/
private MemberDataHasher mberNmHasher;
private void fillSearchKeywordHash(BoardVO vo) {
if (vo == null || !"2".equals(vo.getSearchCnd())) {
return;
}
String kw = vo.getSearchWrd();
if (kw == null || kw.trim().length() == 0) {
return;
}
if (mberNmHasher == null) {
mberNmHasher = new MemberDataHasher();
}
vo.setSearchKeywordHash(mberNmHasher.hashName(kw));
}
private void decryptFrstRegisterNmIfGnr(BoardVO vo) {
if (vo != null && "GNR".equals(vo.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(vo, "frstRegisterNm");
}
}
/**
* 게시판에 게시물을 등록 한다.
*
@ -105,9 +78,7 @@ public class BBSManageDAO extends EgovComAbstractDAO {
* @throws Exception
*/
public BoardVO selectBoardArticle(BoardVO boardVO) throws Exception {
BoardVO result = (BoardVO)selectByPk("BBSManageDAO.selectBoardArticle", boardVO);
decryptFrstRegisterNmIfGnr(result);
return result;
return (BoardVO)selectByPk("BBSManageDAO.selectBoardArticle", boardVO);
}
/**
@ -163,22 +134,12 @@ public class BBSManageDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<BoardVO> selectBoardArticleList(BoardVO boardVO) throws Exception {
fillSearchKeywordHash(boardVO);
List<BoardVO> result = list("BBSManageDAO.selectBoardArticleList", boardVO);
for (BoardVO row : result) {
decryptFrstRegisterNmIfGnr(row);
}
return result;
return list("BBSManageDAO.selectBoardArticleList", boardVO);
}
@SuppressWarnings("unchecked")
public List<BoardVO> selectBoardArticleTopList(BoardVO boardVO) throws Exception {
fillSearchKeywordHash(boardVO);
List<BoardVO> result = list("BBSManageDAO.selectBoardArticleTopList", boardVO);
for (BoardVO row : result) {
decryptFrstRegisterNmIfGnr(row);
}
return result;
return list("BBSManageDAO.selectBoardArticleTopList", boardVO);
}
/**
@ -237,7 +198,6 @@ public class BBSManageDAO extends EgovComAbstractDAO {
* @throws Exception
*/
public int selectBoardArticleListCnt(BoardVO boardVO) throws Exception {
fillSearchKeywordHash(boardVO);
return (Integer)getSqlMapClientTemplate().queryForObject("BBSManageDAO.selectBoardArticleListCnt", boardVO);
}
@ -383,11 +343,7 @@ public class BBSManageDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<BoardVO> selectGuestList(BoardVO boardVO) throws Exception {
List<BoardVO> result = list("BBSManageDAO.selectGuestList", boardVO);
for (BoardVO row : result) {
decryptFrstRegisterNmIfGnr(row);
}
return result;
return list("BBSManageDAO.selectGuestList", boardVO);
}
/**
@ -587,11 +543,7 @@ public class BBSManageDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<BoardVO> selectBoardReplyArticleList(BoardVO boardVO) throws Exception {
List<BoardVO> result = list("BBSManageDAO.selectBoardReplyArticleList", boardVO);
for (BoardVO row : result) {
decryptFrstRegisterNmIfGnr(row);
}
return result;
return list("BBSManageDAO.selectBoardReplyArticleList", boardVO);
}
/**

31
src/main/java/egovframework/com/cop/bbs/service/impl/BBSUseInfoManageDAO.java
View File

@ -4,8 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberDataHasher;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.bbs.service.BoardUseInf;
import egovframework.com.cop.bbs.service.BoardUseInfVO;
@ -30,25 +28,6 @@ import egovframework.com.cop.bbs.service.BoardUseInfVO;
@Repository("BBSUseInfoManageDAO")
public class BBSUseInfoManageDAO extends EgovComAbstractDAO {
/**
* 이름 검색 전환(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10) 헬퍼. searchCnd='0'일 때만 이름검색이다.
*/
private MemberDataHasher mberNmHasher;
private void fillSearchKeywordHash(BoardUseInfVO vo) {
if (vo == null || !"0".equals(vo.getSearchCnd())) {
return;
}
String kw = vo.getSearchWrd();
if (kw == null || kw.trim().length() == 0) {
return;
}
if (mberNmHasher == null) {
mberNmHasher = new MemberDataHasher();
}
vo.setSearchKeywordHash(mberNmHasher.hashName(kw));
}
/**
* 게시판 사용 정보를 삭제한다.
*
@ -131,14 +110,7 @@ public class BBSUseInfoManageDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<BoardUseInfVO> selectBBSUseInfsByTrget(BoardUseInfVO bdUseVO) throws Exception {
fillSearchKeywordHash(bdUseVO);
List<BoardUseInfVO> result = list("BBSUseInfoManageDAO.selectBBSUseInfsByTrget", bdUseVO);
for (BoardUseInfVO row : result) {
if (row != null && "GNR".equals(row.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(row, "userNm");
}
}
return result;
return list("BBSUseInfoManageDAO.selectBBSUseInfsByTrget", bdUseVO);
}
/**
@ -149,7 +121,6 @@ public class BBSUseInfoManageDAO extends EgovComAbstractDAO {
* @throws Exception
*/
public int selectBBSUseInfsCntByTrget(BoardUseInfVO bdUseVO) throws Exception {
fillSearchKeywordHash(bdUseVO);
return (Integer)getSqlMapClientTemplate().queryForObject("BBSUseInfoManageDAO.selectBBSUseInfsCntByTrget", bdUseVO);
}

21
src/main/java/egovframework/com/cop/cmt/service/impl/BBSCommentDAO.java
View File

@ -4,7 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.bbs.service.BoardVO;
import egovframework.com.cop.bbs.service.Comment;
@ -29,22 +28,6 @@ import egovframework.com.cop.bbs.service.CommentVO;
@Repository("BBSCommentDAO")
public class BBSCommentDAO extends EgovComAbstractDAO {
/**
* GNR(일반회원)만 frstRegisterNm이 암호문이다(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
* ENT/USR/GRO 는 각자 다른 테이블의 평문이므로 무조건 복호화하면 예외가 난다.
*/
private void decryptGnrRowsInPlace(List<CommentVO> rows) {
if (rows == null) {
return;
}
for (int i = 0; i < rows.size(); i++) {
CommentVO row = rows.get(i);
if (row != null && "GNR".equals(row.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(row, "frstRegisterNm");
}
}
}
/**
* 댓글에 대한 목록을 조회 한다.
*
@ -54,9 +37,7 @@ public class BBSCommentDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<CommentVO> selectCommentList(CommentVO commentVO) throws Exception {
List<CommentVO> result = list("BBSCommentDAO.selectCommentList", commentVO);
decryptGnrRowsInPlace(result);
return result;
return list("BBSCommentDAO.selectCommentList", commentVO);
}
/**

24
src/main/java/egovframework/com/cop/com/service/UserInfVO.java
View File

@ -153,30 +153,6 @@ public class UserInfVO implements Serializable {
this.userNm = userNm;
}
/**
* userNm(COMVNUSERMASTER.USER_NM) 출처 회원유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
*/
private String userNmSe = "";
public String getUserNmSe() {
return userNmSe;
}
public void setUserNmSe(String userNmSe) {
this.userNmSe = userNmSe;
}
/** 이름 검색 완전일치 해시(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10). */
private String searchKeywordHash = "";
public String getSearchKeywordHash() {
return searchKeywordHash;
}
public void setSearchKeywordHash(String searchKeywordHash) {
this.searchKeywordHash = searchKeywordHash;
}
/**
* userZip attribute를 리턴한다.
*

82
src/main/java/egovframework/com/cop/com/service/impl/EgovUserInfManageDAO.java
View File

@ -4,8 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberDataHasher;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.com.service.UserInfVO;
@ -28,168 +26,118 @@ import egovframework.com.cop.com.service.UserInfVO;
@Repository("EgovUserInfManageDAO")
public class EgovUserInfManageDAO extends EgovComAbstractDAO {
/**
* 이름 검색 전환(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10) 헬퍼.
*/
private MemberDataHasher mberNmHasher;
private void fillSearchKeywordHash(UserInfVO vo) {
if (vo == null || !"0".equals(vo.getSearchCnd())) {
return;
}
String kw = vo.getSearchWrd();
if (kw == null || kw.trim().length() == 0) {
return;
}
if (mberNmHasher == null) {
mberNmHasher = new MemberDataHasher();
}
vo.setSearchKeywordHash(mberNmHasher.hashName(kw));
}
private void decryptListIfGnr(List<UserInfVO> rows) {
if (rows == null) {
return;
}
for (UserInfVO row : rows) {
if (row != null && "GNR".equals(row.getUserNmSe())) {
MemberNmDecryptSupport.decryptInPlace(row, "userNm");
}
}
}
/**
* 사용자 정보에 대한 목록을 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
public List<UserInfVO> selectUserList(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
List<UserInfVO> result = list("EgovUserInfManageDAO.selectUserList", userVO);
decryptListIfGnr(result);
return result;
return list("EgovUserInfManageDAO.selectUserList", userVO);
}
/**
* 사용자 정보에 대한 목록 전체 건수를 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
public int selectUserListCnt(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
return (Integer)getSqlMapClientTemplate().queryForObject("EgovUserInfManageDAO.selectUserListCnt", userVO);
}
/**
* 커뮤니티 사용자 목록을 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
public List<UserInfVO> selectCmmntyUserList(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
List<UserInfVO> result = list("EgovUserInfManageDAO.selectCmmntyUserList", userVO);
decryptListIfGnr(result);
return result;
return list("EgovUserInfManageDAO.selectCmmntyUserList", userVO);
}
/**
* 커뮤니티 사용자 목록에 대한 전체 건수를 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
public int selectCmmntyUserListCnt(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
return (Integer)getSqlMapClientTemplate().queryForObject("EgovUserInfManageDAO.selectCmmntyUserListCnt", userVO);
}
/**
* 커뮤니티 관리자 목록을 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
public List<UserInfVO> selectCmmntyMngrList(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
List<UserInfVO> result = list("EgovUserInfManageDAO.selectCmmntyMngrList", userVO);
decryptListIfGnr(result);
return result;
return list("EgovUserInfManageDAO.selectCmmntyMngrList", userVO);
}
/**
* 커뮤니티 관리자 목록에 대한 전체 건수를 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
public int selectCmmntyMngrListCnt(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
return (Integer)getSqlMapClientTemplate().queryForObject("EgovUserInfManageDAO.selectCmmntyMngrListCnt", userVO);
}
/**
* 동호회 사용자 목록을 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
public List<UserInfVO> selectClubUserList(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
List<UserInfVO> result = list("EgovUserInfManageDAO.selectClubUserList", userVO);
decryptListIfGnr(result);
return result;
return list("EgovUserInfManageDAO.selectClubUserList", userVO);
}
/**
* 동호회 사용자 목록에 대한 전체 건수를 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
public int selectClubUserListCnt(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
return (Integer)getSqlMapClientTemplate().queryForObject("EgovUserInfManageDAO.selectClubUserListCnt", userVO);
}
/**
* 동호회 운영자 목록을 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
public List<UserInfVO> selectClubOprtrList(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
List<UserInfVO> result = list("EgovUserInfManageDAO.selectClubOprtrList", userVO);
decryptListIfGnr(result);
return result;
return list("EgovUserInfManageDAO.selectClubOprtrList", userVO);
}
/**
* 동호회 운영자 목록에 대한 전체 건수를 조회한다.
*
*
* @param userVO
* @return
* @throws Exception
*/
public int selectClubOprtrListCnt(UserInfVO userVO) throws Exception {
fillSearchKeywordHash(userVO);
return (Integer)getSqlMapClientTemplate().queryForObject("EgovUserInfManageDAO.selectClubOprtrListCnt", userVO);
}

15
src/main/java/egovframework/com/cop/scp/service/impl/BBSScrapDAO.java
View File

@ -4,7 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.bbs.service.Scrap;
import egovframework.com.cop.bbs.service.ScrapVO;
@ -37,13 +36,7 @@ public class BBSScrapDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<ScrapVO> selectScrapList(ScrapVO scrapVO) throws Exception {
List<ScrapVO> result = list("BBSScrapDAO.selectScrapList", scrapVO);
for (ScrapVO row : result) {
if (row != null && "GNR".equals(row.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(row, "frstRegisterNm");
}
}
return result;
return list("BBSScrapDAO.selectScrapList", scrapVO);
}
/**
@ -85,11 +78,7 @@ public class BBSScrapDAO extends EgovComAbstractDAO {
* @throws Exception
*/
public Scrap selectScrap(ScrapVO scrapVO) throws Exception {
Scrap result = (Scrap)selectByPk("BBSScrapDAO.selectScrap", scrapVO);
if (result != null && "GNR".equals(result.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(result, "frstRegisterNm");
}
return result;
return (Scrap)selectByPk("BBSScrapDAO.selectScrap", scrapVO);
}
/**

13
src/main/java/egovframework/com/cop/sms/service/Sms.java
View File

@ -134,19 +134,6 @@ public class Sms implements Serializable {
this.frstRegisterNm = frstRegisterNm;
}
/**
* frstRegisterNm(COMVNUSERMASTER.USER_NM) 출처 회원유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
*/
private String userSe = "";
public String getUserSe() {
return userSe;
}
public void setUserSe(String userSe) {
this.userSe = userSe;
}
/**
* frstRegisterPnttm attribute를 리턴한다.
* @return the frstRegisterPnttm

7
src/main/java/egovframework/com/cop/sms/service/impl/SmsDAO.java
View File

@ -4,7 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.sms.service.Sms;
import egovframework.com.cop.sms.service.SmsRecptn;
@ -77,11 +76,7 @@ public class SmsDAO extends EgovComAbstractDAO {
* @return
*/
public SmsVO selectSmsInf(SmsVO searchVO) {
SmsVO result = (SmsVO)selectByPk("SmsDAO.selectSmsInf", searchVO);
if (result != null && "GNR".equals(result.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(result, "frstRegisterNm");
}
return result;
return (SmsVO)selectByPk("SmsDAO.selectSmsInf", searchVO);
}
/**

15
src/main/java/egovframework/com/cop/stf/service/impl/BBSSatisfactionDAO.java
View File

@ -4,7 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.bbs.service.Satisfaction;
import egovframework.com.cop.bbs.service.SatisfactionVO;
@ -37,13 +36,7 @@ public class BBSSatisfactionDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<SatisfactionVO> selectSatisfactionList(SatisfactionVO satisfactionVO) throws Exception {
List<SatisfactionVO> result = list("BBSSatisfactionDAO.selectSatisfactionList", satisfactionVO);
for (SatisfactionVO row : result) {
if (row != null && "GNR".equals(row.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(row, "frstRegisterNm");
}
}
return result;
return list("BBSSatisfactionDAO.selectSatisfactionList", satisfactionVO);
}
/**
@ -85,11 +78,7 @@ public class BBSSatisfactionDAO extends EgovComAbstractDAO {
* @throws Exception
*/
public Satisfaction selectSatisfaction(SatisfactionVO satisfactionVO) throws Exception {
Satisfaction result = (Satisfaction)selectByPk("BBSSatisfactionDAO.selectSatisfaction", satisfactionVO);
if (result != null && "GNR".equals(result.getUserSe())) {
MemberNmDecryptSupport.decryptInPlace(result, "frstRegisterNm");
}
return result;
return (Satisfaction)selectByPk("BBSSatisfactionDAO.selectSatisfaction", satisfactionVO);
}
/**

13
src/main/java/egovframework/com/cop/tpl/service/TemplateInfVO.java
View File

@ -94,19 +94,6 @@ public class TemplateInfVO extends TemplateInf implements Serializable {
this.frstRegisterNm = frstRegisterNm;
}
/**
* frstRegisterNm(COMVNUSERMASTER.USER_NM) 출처 회원유형(GNR/USR/ENT/GRO, 개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10).
*/
private String frstRegisterNmSe = "";
public String getFrstRegisterNmSe() {
return frstRegisterNmSe;
}
public void setFrstRegisterNmSe(String frstRegisterNmSe) {
this.frstRegisterNmSe = frstRegisterNmSe;
}
/**
* lastUpdusrNm attribute를 리턴한다.
*

8
src/main/java/egovframework/com/cop/tpl/service/impl/TemplateManageDAO.java
View File

@ -4,7 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.cop.tpl.service.TemplateInf;
import egovframework.com.cop.tpl.service.TemplateInfVO;
@ -89,11 +88,8 @@ public class TemplateManageDAO extends EgovComAbstractDAO {
* @throws Exception
*/
public TemplateInfVO selectTemplateInf(TemplateInfVO tmplatInfVO) throws Exception {
TemplateInfVO result = (TemplateInfVO)selectByPk("TemplateManageDAO.selectTemplateInf", tmplatInfVO);
if (result != null && "GNR".equals(result.getFrstRegisterNmSe())) {
MemberNmDecryptSupport.decryptInPlace(result, "frstRegisterNm");
}
return result;
return (TemplateInfVO)selectByPk("TemplateManageDAO.selectTemplateInf", tmplatInfVO);
}
/**

44
src/main/java/egovframework/com/sec/rgm/service/impl/AuthorGroupDAO.java
View File

@ -4,8 +4,6 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import egovframework.com.cmm.privacy.crypto.MemberDataHasher;
import egovframework.com.cmm.privacy.crypto.MemberNmDecryptSupport;
import egovframework.com.cmm.service.impl.EgovComAbstractDAO;
import egovframework.com.sec.rgm.service.AuthorGroup;
import egovframework.com.sec.rgm.service.AuthorGroupVO;
@ -30,42 +28,6 @@ import egovframework.com.sec.rgm.service.AuthorGroupVO;
@Repository("authorGroupDAO")
public class AuthorGroupDAO extends EgovComAbstractDAO {
/**
* 이름 읽기전환/검색 전환(개인정보보호 기능개선 사업 추가제안 Action4, 2026-08-10) 헬퍼.
* 지연 초기화 — {@link egovframework.com.cmm.privacy.crypto.MemberDataCipher} 정책과 동일.
*/
private MemberDataHasher mberNmHasher;
private void fillSearchKeywordHash(AuthorGroupVO vo) {
if (vo == null || !"2".equals(vo.getSearchCondition())) {
return;
}
String kw = vo.getSearchKeyword();
if (kw == null || kw.trim().length() == 0) {
return;
}
if (mberNmHasher == null) {
mberNmHasher = new MemberDataHasher();
}
vo.setSearchKeywordHash(mberNmHasher.hashName(kw));
}
/**
* USR01(일반회원) 행만 userNm이 암호문이다. USR02(단체)/USR03(취급자)는 각자 다른
* 테이블의 평문이므로 무조건 복호화하면 예외가 난다.
*/
private void decryptGnrRowsInPlace(List<AuthorGroupVO> rows) {
if (rows == null) {
return;
}
for (int i = 0; i < rows.size(); i++) {
AuthorGroupVO row = rows.get(i);
if (row != null && "USR01".equals(row.getMberTyCode())) {
MemberNmDecryptSupport.decryptInPlace(row, "userNm");
}
}
}
/**
* 그룹별 할당된 권한 목록 조회
* @param authorGroupVO AuthorGroupVO
@ -74,10 +36,7 @@ public class AuthorGroupDAO extends EgovComAbstractDAO {
*/
@SuppressWarnings("unchecked")
public List<AuthorGroupVO> selectAuthorGroupList(AuthorGroupVO authorGroupVO) throws Exception {
fillSearchKeywordHash(authorGroupVO);
List<AuthorGroupVO> result = list("authorGroupDAO.selectAuthorGroupList", authorGroupVO);
decryptGnrRowsInPlace(result);
return result;
return list("authorGroupDAO.selectAuthorGroupList", authorGroupVO);
}
/**
@ -114,7 +73,6 @@ public class AuthorGroupDAO extends EgovComAbstractDAO {
* @exception Exception
*/
public int selectAuthorGroupListTotCnt(AuthorGroupVO authorGroupVO) throws Exception {
fillSearchKeywordHash(authorGroupVO);
return (Integer)getSqlMapClientTemplate().queryForObject("authorGroupDAO.selectAuthorGroupListTotCnt", authorGroupVO);
}

6
src/main/java/egovframework/com/sec/security/filter/EgovSpringSecurityLoginFilter.java
View File

@ -244,11 +244,7 @@ private FilterConfig config;
if(loginVO != null && loginVO.getId() != null && !loginVO.getId().equals(""))
{
// 2026-08-05 [개인정보/SER-003] 평문 비밀번호 로그 출력 제거.
// 종전: println("1필터액션::["+id+"]["+password+"]") — 로그인 성공 전건의
// 평문 비밀번호가 catalina.out 에 누적되어 로그 파일 자체가 유출원이 되었다.
// 인증정보(비밀번호/해시/OTP비밀키)는 어떤 형태로도 로그에 남기지 않는다.
System.out.println("1필터액션::[" + loginVO.getId()+"]");
System.out.println("1필터액션::[" + loginVO.getId()+"]["+password+"]");
// ip filtering
String myIp = ((HttpServletRequest)request).getRemoteAddr();

Some files were not shown because too many files have changed in this diff Show More