curry772
845 lines
33 KiB
Java
845 lines
33 KiB
Java
package com.eactive.eai.common.hsm;
|
|
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.File;
|
|
import java.io.InputStream;
|
|
import java.lang.reflect.Method;
|
|
import java.nio.file.Files;
|
|
import java.security.AuthProvider;
|
|
import java.security.KeyStore;
|
|
import java.security.KeyStoreException;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.security.Provider;
|
|
import java.security.Security;
|
|
import java.security.UnrecoverableKeyException;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.ScheduledExecutorService;
|
|
import java.util.concurrent.ScheduledFuture;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import javax.crypto.SecretKey;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.springframework.stereotype.Component;
|
|
|
|
import com.eactive.eai.agent.encryption.EncryptionManager;
|
|
import com.eactive.eai.common.exception.ExceptionUtil;
|
|
import com.eactive.eai.common.lifecycle.Lifecycle;
|
|
import com.eactive.eai.common.lifecycle.LifecycleException;
|
|
import com.eactive.eai.common.lifecycle.LifecycleListener;
|
|
import com.eactive.eai.common.lifecycle.LifecycleSupport;
|
|
import com.eactive.eai.common.property.PropGroupVO;
|
|
import com.eactive.eai.common.property.PropManager;
|
|
import com.eactive.eai.common.util.ApplicationContextProvider;
|
|
import com.eactive.eai.common.util.Logger;
|
|
|
|
/**
|
|
* SafeNet ProtectServer HSM 연동 관리자 (JDK 8 / SunPKCS11)
|
|
*
|
|
* PropManager 그룹 "HSM" 에서 읽는 키:
|
|
* PKCS11_CONFIG - primary pkcs11.cfg 파일 내용
|
|
* PIN - primary 슬롯 PIN
|
|
* PKCS11_CONFIG_SECONDARY - secondary pkcs11.cfg 파일 내용 (미설정 시 이중화 비활성)
|
|
* PIN_SECONDARY - secondary 슬롯 PIN (미설정 시 PIN 재사용)
|
|
* RELOAD_INTERVAL_MINUTES - KeyStore 주기적 재로드 간격(분)
|
|
*
|
|
* PKCS11_CONFIG 값 예시 (개행은 \n 으로 입력):
|
|
* name = ProtectServer
|
|
* library = /opt/safenet/protecttoolkit5/ptk/lib/libcryptoki.so
|
|
* slot = 0
|
|
*
|
|
* name = SoftHSM
|
|
* library = C:/SoftHSM2/lib/softhsm2-x64.dll
|
|
* slotListIndex = 0
|
|
*
|
|
* ---------------------------------------------------------------------
|
|
* [설정 이중화 / primary 자동 복귀]
|
|
* 기동(init) 과 재연결 시 항상 primary -> secondary 순서로 연결을 시도하고,
|
|
* 최초로 성공한 설정을 사용한다. secondary 로 절체된 뒤에는 주기적 재로드마다
|
|
* primary 재연결을 먼저 시도하므로 primary 가 복구되면 자동으로 되돌아온다.
|
|
*
|
|
* [세션 누적 방지 / 회로차단 로직]
|
|
* 재로드마다 KeyStore.getInstance(...).load(null, pin) 을 새로 호출하면
|
|
* PKCS11 세션(C_OpenSession)이 계속 누적되고, 결국 HSM 파티션의 최대 세션 수를
|
|
* 초과하면서 reload 가 영구적으로 실패한다. 이를 방지하기 위해:
|
|
* 1) primary 로 동작 중이고 설정도 그대로면 "기존 keyStore 인스턴스"에 다시
|
|
* load() 하여 세션을 재사용한다 (= primary 우선 시도와 동일한 의미)
|
|
* 2) 실제 키 조회(probe)로 세션이 살아있는지 검증
|
|
* 3) 재로드가 실패하거나 프로퍼티가 변경되면 primary -> secondary 순서로
|
|
* Provider 를 완전히 재생성
|
|
* 4) 재생성마저 실패하면 마지막으로 성공한 keyStore 를 유지 (서비스 연속성 우선)
|
|
*
|
|
* [프로퍼티 즉시 반영]
|
|
* PropManager 의 PropertyChangeListener 로 등록되어 있어, 관리 포털에서 HSM 그룹을
|
|
* reload 하면 다음 스케줄을 기다리지 않고 즉시 설정을 다시 읽어 재연결을 시도한다.
|
|
* 이 경우에도 신규 연결이 완전히 성공한 뒤에만 keyStore 멤버변수를 교체한다.
|
|
* ---------------------------------------------------------------------
|
|
*/
|
|
@Component
|
|
public class HsmManager implements Lifecycle, PropertyChangeListener {
|
|
|
|
static Logger logger = Logger.getLogger(Logger.LOGGER_DEFAULT);
|
|
|
|
private static final String GROUP_NAME = "HSM";
|
|
private static final String PROP_CONFIG = "PKCS11_CONFIG";
|
|
private static final String PROP_PIN = "PIN";
|
|
private static final String PROP_CONFIG_SECONDARY = "PKCS11_CONFIG_SECONDARY";
|
|
private static final String PROP_PIN_SECONDARY = "PIN_SECONDARY";
|
|
private static final String PROP_RELOAD_INTERVAL_MINUTES = "RELOAD_INTERVAL_MINUTES";
|
|
|
|
/** 설정 구분자. HSM 상태 조회 API 응답에도 그대로 노출된다. */
|
|
public static final String CONFIG_PRIMARY = "PRIMARY";
|
|
public static final String CONFIG_SECONDARY = "SECONDARY";
|
|
|
|
private static final long DEFAULT_RELOAD_INTERVAL_MINUTES = 10;
|
|
|
|
private Provider pkcs11Provider;
|
|
private volatile KeyStore keyStore;
|
|
private boolean started;
|
|
|
|
private final LifecycleSupport lifecycle = new LifecycleSupport(this);
|
|
|
|
private volatile char[] pin;
|
|
|
|
/** 현재 연결에 사용 중인 설정. 미연결이면 null. */
|
|
private volatile HsmConfig activeConfig;
|
|
|
|
// ---- 모니터링용 상태값 (HsmStatusController 에서 조회) ----
|
|
private volatile long activeSince;
|
|
private volatile long lastReloadAt;
|
|
private volatile String lastReloadResult;
|
|
private volatile String lastErrorMessage;
|
|
private volatile long lastErrorAt;
|
|
private volatile int reloadSuccessCount;
|
|
private volatile int reloadFailCount;
|
|
private volatile int failoverCount;
|
|
|
|
private volatile long reloadIntervalMinutes = DEFAULT_RELOAD_INTERVAL_MINUTES;
|
|
private ScheduledExecutorService scheduler;
|
|
private ScheduledFuture<?> reloadFuture;
|
|
private volatile boolean propListenerRegistered;
|
|
|
|
private HsmManager() {
|
|
}
|
|
|
|
public static HsmManager getInstance() {
|
|
return ApplicationContextProvider.getContext().getBean(HsmManager.class);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 설정 후보 (primary / secondary)
|
|
// -------------------------------------------------------------------------
|
|
|
|
/**
|
|
* 한 번의 연결 시도에 필요한 설정 한 벌. PropManager 에서 읽어 복호화까지 마친 값이다.
|
|
*/
|
|
static final class HsmConfig {
|
|
|
|
final String name;
|
|
final String configContent;
|
|
final char[] pin;
|
|
|
|
HsmConfig(String name, String configContent, char[] pin) {
|
|
this.name = name;
|
|
this.configContent = configContent;
|
|
this.pin = pin;
|
|
}
|
|
|
|
/** PropManager 값이 바뀌었는지 판단하기 위한 비교. */
|
|
boolean sameAs(HsmConfig other) {
|
|
if (other == null) {
|
|
return false;
|
|
}
|
|
return name.equals(other.name)
|
|
&& configContent.equals(other.configContent)
|
|
&& Arrays.equals(pin, other.pin);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 연결 시도 결과. Security 등록 전 상태이며, 완전히 성공한 경우에만
|
|
* applyConnection() 을 통해 멤버변수로 승격된다.
|
|
*/
|
|
private static final class HsmConnection {
|
|
|
|
final HsmConfig config;
|
|
final Provider provider;
|
|
final KeyStore keyStore;
|
|
|
|
HsmConnection(HsmConfig config, Provider provider, KeyStore keyStore) {
|
|
this.config = config;
|
|
this.provider = provider;
|
|
this.keyStore = keyStore;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* PropManager 에서 매번 새로 읽어 primary -> secondary 순서의 연결 후보를 만든다.
|
|
* 스케줄러/프로퍼티 변경 이벤트 모두 이 메서드를 통하므로 변경된 값이 즉시 반영된다.
|
|
* PKCS11_CONFIG 가 비어 있는 후보는 제외한다.
|
|
*/
|
|
private List<HsmConfig> loadConfigCandidates() {
|
|
PropManager propManager = PropManager.getInstance();
|
|
EncryptionManager encManager = EncryptionManager.getInstance();
|
|
|
|
List<HsmConfig> candidates = new ArrayList<>();
|
|
|
|
String primaryConfig = decrypt(encManager, propManager.getProperty(GROUP_NAME, PROP_CONFIG));
|
|
String primaryPin = decrypt(encManager, propManager.getProperty(GROUP_NAME, PROP_PIN));
|
|
if (StringUtils.isNotBlank(primaryConfig)) {
|
|
candidates.add(new HsmConfig(CONFIG_PRIMARY, normalizeConfig(primaryConfig), toPin(primaryPin)));
|
|
}
|
|
|
|
String secondaryConfig = decrypt(encManager, propManager.getProperty(GROUP_NAME, PROP_CONFIG_SECONDARY));
|
|
if (StringUtils.isNotBlank(secondaryConfig)) {
|
|
// PIN_SECONDARY 미설정이면 primary PIN 을 재사용한다 (슬롯만 이중화하는 구성 지원)
|
|
String rawSecondaryPin = propManager.getProperty(GROUP_NAME, PROP_PIN_SECONDARY);
|
|
String secondaryPin = StringUtils.isNotBlank(rawSecondaryPin) ? decrypt(encManager, rawSecondaryPin) : primaryPin;
|
|
candidates.add(new HsmConfig(CONFIG_SECONDARY, normalizeConfig(secondaryConfig), toPin(secondaryPin)));
|
|
}
|
|
|
|
return candidates;
|
|
}
|
|
|
|
private static String decrypt(EncryptionManager encManager, String value) {
|
|
if (value == null) {
|
|
return null;
|
|
}
|
|
return encManager.decryptDBData(value);
|
|
}
|
|
|
|
private static String normalizeConfig(String configContent) {
|
|
return configContent.trim().replace("\\n", "\n");
|
|
}
|
|
|
|
private static char[] toPin(String pinStr) {
|
|
return (pinStr != null) ? pinStr.toCharArray() : null;
|
|
}
|
|
|
|
private static HsmConfig findByName(List<HsmConfig> candidates, String name) {
|
|
if (name == null) {
|
|
return null;
|
|
}
|
|
for (HsmConfig candidate : candidates) {
|
|
if (name.equals(candidate.name)) {
|
|
return candidate;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Lifecycle
|
|
// -------------------------------------------------------------------------
|
|
|
|
@Override
|
|
public void start() throws LifecycleException {
|
|
if (started) {
|
|
throw new LifecycleException("RECEAIHSM001");
|
|
}
|
|
lifecycle.fireLifecycleEvent(STARTING_EVENT, this);
|
|
|
|
try {
|
|
init();
|
|
startReloadScheduler();
|
|
registerPropertyChangeListener();
|
|
} catch (Exception e) {
|
|
throw new LifecycleException(ExceptionUtil.getErrorCode(e, "RECEAIHSM002"));
|
|
}
|
|
|
|
started = true;
|
|
lifecycle.fireLifecycleEvent(STARTED_EVENT, this);
|
|
}
|
|
|
|
private void init() throws Exception {
|
|
|
|
applyReloadInterval();
|
|
|
|
List<HsmConfig> candidates = loadConfigCandidates();
|
|
if (candidates.isEmpty()) {
|
|
logger.warn("HsmManager] PKCS11_CONFIG 가 설정되지 않았습니다. HSM 초기화를 건너뜁니다.");
|
|
return;
|
|
}
|
|
|
|
HsmConnection connection = connectFirstAvailable(candidates);
|
|
applyConnection(connection);
|
|
|
|
logger.warn("HsmManager] 초기화 완료. config=" + connection.config.name
|
|
+ ", Provider=" + connection.provider.getName());
|
|
}
|
|
|
|
/**
|
|
* RELOAD_INTERVAL_MINUTES 를 다시 읽어 적용한다.
|
|
*
|
|
* @return 값이 변경되어 스케줄 재등록이 필요하면 true
|
|
*/
|
|
private boolean applyReloadInterval() {
|
|
long newInterval = reloadIntervalMinutes;
|
|
try {
|
|
String value = PropManager.getInstance().getProperty(GROUP_NAME, PROP_RELOAD_INTERVAL_MINUTES,
|
|
String.valueOf(DEFAULT_RELOAD_INTERVAL_MINUTES));
|
|
if (StringUtils.isNotBlank(value)) {
|
|
newInterval = Long.parseLong(value.trim());
|
|
}
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] " + PROP_RELOAD_INTERVAL_MINUTES + " 값이 올바르지 않아 기존 값("
|
|
+ reloadIntervalMinutes + "분)을 유지합니다: " + e.getMessage());
|
|
return false;
|
|
}
|
|
|
|
if (newInterval <= 0) {
|
|
newInterval = DEFAULT_RELOAD_INTERVAL_MINUTES;
|
|
}
|
|
if (newInterval == reloadIntervalMinutes) {
|
|
return false;
|
|
}
|
|
reloadIntervalMinutes = newInterval;
|
|
return true;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 연결
|
|
// -------------------------------------------------------------------------
|
|
|
|
/**
|
|
* 후보 설정을 primary -> secondary 순서로 시도하여 최초로 성공한 연결을 반환한다.
|
|
* 각 후보는 Provider 생성 + KeyStore.load + 키 목록 조회(probe)까지 모두 성공해야
|
|
* 정상으로 간주한다. 전부 실패하면 마지막 예외를 던진다.
|
|
*/
|
|
private HsmConnection connectFirstAvailable(List<HsmConfig> candidates) throws Exception {
|
|
Exception lastException = null;
|
|
|
|
for (HsmConfig config : candidates) {
|
|
try {
|
|
HsmConnection connection = connect(config);
|
|
logger.warn("HsmManager] HSM 연결 성공. config=" + config.name
|
|
+ ", Provider=" + connection.provider.getName());
|
|
return connection;
|
|
} catch (Exception e) {
|
|
lastException = e;
|
|
recordError(config.name + " 설정 연결 실패: " + e.getMessage());
|
|
logger.warn("HsmManager] HSM 연결 실패. config=" + config.name + " : " + e.getMessage(), e);
|
|
}
|
|
}
|
|
|
|
if (lastException != null) {
|
|
throw lastException;
|
|
}
|
|
throw new HsmException("HSM 연결 후보 설정이 없습니다.");
|
|
}
|
|
|
|
/**
|
|
* 단일 설정으로 Provider/KeyStore 를 새로 생성한다. Security 에는 아직 등록하지 않으므로
|
|
* 여기서 실패해도 현재 사용 중인 Provider/keyStore 는 영향을 받지 않는다.
|
|
*/
|
|
private HsmConnection connect(HsmConfig config) throws Exception {
|
|
Provider provider = createProvider(config.configContent);
|
|
KeyStore ks = KeyStore.getInstance("PKCS11", provider);
|
|
ks.load(null, config.pin);
|
|
logKeyStore(ks);
|
|
return new HsmConnection(config, provider, ks);
|
|
}
|
|
|
|
/**
|
|
* 신규 연결을 멤버변수로 승격한다. 기존 Provider 는 이 시점에서만 logout/제거된다.
|
|
*/
|
|
private void applyConnection(HsmConnection connection) {
|
|
Provider oldProvider = this.pkcs11Provider;
|
|
HsmConfig oldConfig = this.activeConfig;
|
|
|
|
if (oldProvider != null && oldProvider != connection.provider) {
|
|
if (oldProvider instanceof AuthProvider) {
|
|
try {
|
|
((AuthProvider) oldProvider).logout();
|
|
} catch (Exception logoutEx) {
|
|
logger.warn("HsmManager] 기존 세션 logout 실패(무시하고 진행): " + logoutEx.getMessage());
|
|
}
|
|
}
|
|
Security.removeProvider(oldProvider.getName());
|
|
}
|
|
|
|
// 동일 이름으로 이미 등록된 Provider 가 있으면 제거 후 재등록
|
|
Provider registered = Security.getProvider(connection.provider.getName());
|
|
if (registered != null && registered != connection.provider) {
|
|
Security.removeProvider(registered.getName());
|
|
}
|
|
Security.addProvider(connection.provider);
|
|
|
|
this.pkcs11Provider = connection.provider;
|
|
this.keyStore = connection.keyStore;
|
|
this.activeConfig = connection.config;
|
|
this.pin = connection.config.pin;
|
|
this.activeSince = System.currentTimeMillis();
|
|
|
|
if (oldConfig != null && !oldConfig.name.equals(connection.config.name)) {
|
|
failoverCount++;
|
|
logger.warn("HsmManager] HSM 설정 절체: " + oldConfig.name + " -> " + connection.config.name);
|
|
}
|
|
}
|
|
|
|
private void logKeyStore(KeyStore keyStore)
|
|
throws KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {
|
|
java.util.Enumeration<String> aliases = keyStore.aliases();
|
|
StringBuilder aliasList = new StringBuilder();
|
|
while (aliases.hasMoreElements()) {
|
|
if (aliasList.length() > 0) aliasList.append(", ");
|
|
|
|
String alias = aliases.nextElement();
|
|
aliasList.append(alias);
|
|
|
|
java.security.Key key = keyStore.getKey(alias, null);
|
|
if (key instanceof SecretKey) {
|
|
SecretKey secretKey = (SecretKey) key;
|
|
if (secretKey.getEncoded() == null) {
|
|
logger.warn("HsmManager] HSM - secretKey null {} : [{}]", alias, secretKey);
|
|
}
|
|
}
|
|
}
|
|
logger.warn("HsmManager] HSM 키 목록: [" + aliasList + "]");
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 주기적 재로드
|
|
// -------------------------------------------------------------------------
|
|
|
|
/**
|
|
* 별도 스레드에서 주기적으로 KeyStore 를 다시 로드하여
|
|
* HSM 에 새로 생성/추가된 키를 인식하도록 한다.
|
|
*/
|
|
private void startReloadScheduler() {
|
|
scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
|
|
Thread t = new Thread(r, "hsm-keystore-reloader");
|
|
t.setDaemon(true);
|
|
return t;
|
|
});
|
|
|
|
reloadFuture = scheduler.scheduleWithFixedDelay(
|
|
this::reloadKeyStoreSafely,
|
|
reloadIntervalMinutes,
|
|
reloadIntervalMinutes,
|
|
TimeUnit.MINUTES
|
|
);
|
|
|
|
logger.warn("HsmManager] KeyStore 주기적 재로드 스케줄러 시작. interval=" + reloadIntervalMinutes + "분");
|
|
}
|
|
|
|
/** RELOAD_INTERVAL_MINUTES 변경 시 스케줄을 다시 등록한다. */
|
|
private synchronized void rescheduleReload() {
|
|
if (scheduler == null || scheduler.isShutdown()) {
|
|
return;
|
|
}
|
|
if (reloadFuture != null) {
|
|
reloadFuture.cancel(false);
|
|
}
|
|
reloadFuture = scheduler.scheduleWithFixedDelay(
|
|
this::reloadKeyStoreSafely,
|
|
reloadIntervalMinutes,
|
|
reloadIntervalMinutes,
|
|
TimeUnit.MINUTES
|
|
);
|
|
logger.warn("HsmManager] KeyStore 재로드 주기 변경 적용: " + reloadIntervalMinutes + "분");
|
|
}
|
|
|
|
/**
|
|
* 스케줄러에서 호출되는 래퍼. 예외가 스케줄러 스레드를 죽이지 않도록 반드시 catch 한다.
|
|
* (ScheduledExecutorService 는 task 에서 예외가 던져지면 이후 스케줄을 자동으로 중단시킨다)
|
|
*/
|
|
private void reloadKeyStoreSafely() {
|
|
try {
|
|
reloadKeyStoreIfNeeded();
|
|
} catch (Throwable t) {
|
|
logger.warn("HsmManager] KeyStore 주기적 재로드 실패: " + t.getMessage(), t);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* KeyStore 를 다시 로드한다. 외부(getSecretKey 등)에서 키 미스 발생 시
|
|
* 즉시 재시도용으로 직접 호출할 수도 있다.
|
|
*
|
|
* 처리 순서:
|
|
* 1) PropManager 에서 설정을 매번 새로 읽는다 (변경값 즉시 반영)
|
|
* 2) 설정이 변경되었거나 아직 연결이 없으면 primary -> secondary 순으로 전체 재연결
|
|
* 3) 현재 secondary 로 동작 중이면 primary 복귀를 먼저 시도
|
|
* 4) 그 외에는 기존 keyStore 인스턴스에 다시 load() (PKCS11 세션 재사용).
|
|
* 실패하면 primary -> secondary 순으로 전체 재연결
|
|
*
|
|
* 어느 경로든 신규 연결이 완전히 성공한 경우에만 keyStore 멤버변수를 교체한다.
|
|
*/
|
|
public synchronized void reloadKeyStoreIfNeeded() throws Exception {
|
|
|
|
List<HsmConfig> candidates = loadConfigCandidates();
|
|
if (candidates.isEmpty()) {
|
|
logger.warn("HsmManager] PKCS11_CONFIG 가 설정되지 않아 재로드를 건너뜁니다.");
|
|
return;
|
|
}
|
|
|
|
HsmConfig active = this.activeConfig;
|
|
HsmConfig currentCandidate = findByName(candidates, active == null ? null : active.name);
|
|
|
|
// 2) 미연결 상태이거나 현재 사용 중인 설정값 자체가 변경된 경우
|
|
if (active == null || pkcs11Provider == null || currentCandidate == null
|
|
|| !currentCandidate.sameAs(active)) {
|
|
logger.warn("HsmManager] HSM 설정 변경 또는 미연결 상태 감지 → 전체 재연결을 수행합니다.");
|
|
reconnect(candidates);
|
|
return;
|
|
}
|
|
|
|
// 3) secondary 로 동작 중이면 primary 복귀를 우선 시도
|
|
HsmConfig preferred = candidates.get(0);
|
|
if (!preferred.name.equals(active.name)) {
|
|
try {
|
|
HsmConnection connection = connect(preferred);
|
|
applyConnection(connection);
|
|
recordReloadSuccess(preferred.name + " 설정으로 복귀 성공");
|
|
logger.warn("HsmManager] " + preferred.name + " 설정으로 복귀했습니다.");
|
|
return;
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] " + preferred.name + " 복귀 시도 실패. 현재 " + active.name
|
|
+ " 설정을 유지합니다: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
// 4) 현재 연결 유지 재로드 (세션 재사용)
|
|
try {
|
|
if (keyStore != null) {
|
|
keyStore.load(null, pin);
|
|
logKeyStore(keyStore);
|
|
logger.warn("HsmManager] KeyStore 재로드 완료 (config=" + active.name + ", 기존 세션 재사용).");
|
|
} else {
|
|
KeyStore ks = KeyStore.getInstance("PKCS11", pkcs11Provider);
|
|
ks.load(null, pin);
|
|
logKeyStore(ks);
|
|
this.keyStore = ks;
|
|
logger.warn("HsmManager] KeyStore 신규 생성 완료 (config=" + active.name + ").");
|
|
}
|
|
recordReloadSuccess(active.name + " 설정 재로드 성공");
|
|
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] KeyStore 재로드 실패:" + e.getMessage(), e);
|
|
logger.warn("HsmManager] 후보 설정(PRIMARY→SECONDARY) 전체 재연결을 시도합니다.");
|
|
reconnect(candidates);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 세션 누적, 네트워크 단절, 설정 변경 등으로 일반 재로드가 더 이상 복구되지 않을 때
|
|
* primary -> secondary 순서로 Provider 를 완전히 새로 생성한다.
|
|
*
|
|
* 신규 Provider/KeyStore 준비가 완전히 성공한 후에만 기존 Provider 를 제거하고 교체한다.
|
|
* 모든 후보가 실패하면 기존 Provider 와 keyStore 를 그대로 유지한다
|
|
* (서비스 중단보다 마지막 정상 상태 보존을 우선).
|
|
*/
|
|
private void reconnect(List<HsmConfig> candidates) throws Exception {
|
|
try {
|
|
HsmConnection connection = connectFirstAvailable(candidates);
|
|
applyConnection(connection);
|
|
recordReloadSuccess(connection.config.name + " 설정 재연결 성공");
|
|
logger.warn("HsmManager] HSM 재연결 성공. config=" + connection.config.name);
|
|
} catch (Exception e) {
|
|
recordReloadFailure(e.getMessage());
|
|
logger.warn("HsmManager] HSM 재연결 실패. 이전 keyStore 를 그대로 유지합니다: " + e.getMessage(), e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
private void recordReloadSuccess(String detail) {
|
|
lastReloadAt = System.currentTimeMillis();
|
|
lastReloadResult = "SUCCESS - " + detail;
|
|
reloadSuccessCount++;
|
|
}
|
|
|
|
private void recordReloadFailure(String detail) {
|
|
lastReloadAt = System.currentTimeMillis();
|
|
lastReloadResult = "FAIL - " + detail;
|
|
reloadFailCount++;
|
|
recordError(detail);
|
|
}
|
|
|
|
private void recordError(String message) {
|
|
lastErrorMessage = message;
|
|
lastErrorAt = System.currentTimeMillis();
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// PropManager 변경 즉시 반영
|
|
// -------------------------------------------------------------------------
|
|
|
|
private void registerPropertyChangeListener() {
|
|
if (propListenerRegistered) {
|
|
return;
|
|
}
|
|
try {
|
|
PropManager.getInstance().addPropertyChangeListener(this);
|
|
propListenerRegistered = true;
|
|
logger.warn("HsmManager] PropManager PropertyChangeListener 등록 완료");
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] PropManager PropertyChangeListener 등록 실패(주기적 재로드로 대체): "
|
|
+ e.getMessage());
|
|
}
|
|
}
|
|
|
|
private void unregisterPropertyChangeListener() {
|
|
if (!propListenerRegistered) {
|
|
return;
|
|
}
|
|
try {
|
|
PropManager.getInstance().removePropertyChangeListener(this);
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] PropManager PropertyChangeListener 해제 실패(무시): " + e.getMessage());
|
|
}
|
|
propListenerRegistered = false;
|
|
}
|
|
|
|
/**
|
|
* 관리 포털에서 PropManager.reload("HSM") 또는 setProperty 를 호출하면 수신된다.
|
|
* 재로드 자체는 HSM 통신을 수반하므로 호출 스레드를 막지 않도록 스케줄러 스레드에 위임한다.
|
|
*/
|
|
@Override
|
|
public void propertyChange(PropertyChangeEvent evt) {
|
|
if (!isHsmGroupEvent(evt)) {
|
|
return;
|
|
}
|
|
|
|
if (applyReloadInterval()) {
|
|
rescheduleReload();
|
|
}
|
|
|
|
ScheduledExecutorService currentScheduler = this.scheduler;
|
|
if (currentScheduler == null || currentScheduler.isShutdown()) {
|
|
return;
|
|
}
|
|
logger.warn("HsmManager] HSM 프로퍼티 변경 감지 → 설정 재적용을 요청합니다.");
|
|
currentScheduler.execute(this::reloadKeyStoreSafely);
|
|
}
|
|
|
|
/**
|
|
* PropManager 는 reload(group) 시 propertyName 에 그룹명을, setProperty 시 키명을 담고
|
|
* source 에는 항상 해당 그룹의 PropGroupVO 를 담는다. 두 경우를 모두 인식한다.
|
|
*/
|
|
private boolean isHsmGroupEvent(PropertyChangeEvent evt) {
|
|
if (evt == null) {
|
|
return false;
|
|
}
|
|
if (GROUP_NAME.equals(evt.getPropertyName())) {
|
|
return true;
|
|
}
|
|
Object source = evt.getSource();
|
|
return (source instanceof PropGroupVO) && GROUP_NAME.equals(((PropGroupVO) source).getName());
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Provider 생성
|
|
// -------------------------------------------------------------------------
|
|
|
|
/**
|
|
* JDK 버전에 따라 SunPKCS11 Provider 를 생성한다.
|
|
*
|
|
* JDK 8 : SunPKCS11(InputStream) 생성자를 리플렉션으로 호출
|
|
* JDK 9+: Provider.configure(configFilePath) 를 리플렉션으로 호출
|
|
*
|
|
* 두 경로 모두 리플렉션을 사용하므로 컴파일 타임에 JDK 버전 의존성이 없다.
|
|
*/
|
|
static Provider createProvider(String cfgContent) throws Exception {
|
|
String javaVersion = System.getProperty("java.version");
|
|
if (javaVersion.startsWith("1.")) {
|
|
// JDK 8: new SunPKCS11(InputStream)
|
|
InputStream is = new ByteArrayInputStream(cfgContent.getBytes("UTF-8"));
|
|
return (Provider) Class.forName("sun.security.pkcs11.SunPKCS11")
|
|
.getConstructor(InputStream.class)
|
|
.newInstance(is);
|
|
} else {
|
|
// JDK 9+: Security.getProvider("SunPKCS11").configure(configFilePath)
|
|
// configure() 는 JDK 9 에서 추가된 메서드이므로 리플렉션으로 호출
|
|
File tmp = File.createTempFile("pkcs11-hsm-", ".cfg");
|
|
tmp.deleteOnExit();
|
|
Files.write(tmp.toPath(), cfgContent.getBytes("UTF-8"));
|
|
Provider base = Security.getProvider("SunPKCS11");
|
|
Method configure = Provider.class.getMethod("configure", String.class);
|
|
return (Provider) configure.invoke(base, tmp.getAbsolutePath());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void stop() throws LifecycleException {
|
|
if (!started) {
|
|
throw new LifecycleException("RECEAIHSM003");
|
|
}
|
|
lifecycle.fireLifecycleEvent(STOPING_EVENT, this);
|
|
|
|
unregisterPropertyChangeListener();
|
|
|
|
if (reloadFuture != null) {
|
|
reloadFuture.cancel(false);
|
|
}
|
|
if (scheduler != null) {
|
|
scheduler.shutdown();
|
|
}
|
|
|
|
if (pkcs11Provider != null) {
|
|
if (pkcs11Provider instanceof AuthProvider) {
|
|
try {
|
|
((AuthProvider) pkcs11Provider).logout();
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] 종료 시 logout 실패(무시): " + e.getMessage());
|
|
}
|
|
}
|
|
Security.removeProvider(pkcs11Provider.getName());
|
|
}
|
|
pkcs11Provider = null;
|
|
keyStore = null;
|
|
activeConfig = null;
|
|
activeSince = 0;
|
|
started = false;
|
|
|
|
lifecycle.fireLifecycleEvent(STOPPED_EVENT, this);
|
|
}
|
|
|
|
@Override
|
|
public void addLifecycleListener(LifecycleListener listener) {
|
|
lifecycle.addLifecycleListener(listener);
|
|
}
|
|
|
|
@Override
|
|
public LifecycleListener[] findLifecycleListeners() {
|
|
return lifecycle.findLifecycleListeners();
|
|
}
|
|
|
|
@Override
|
|
public void removeLifecycleListener(LifecycleListener listener) {
|
|
lifecycle.removeLifecycleListener(listener);
|
|
}
|
|
|
|
@Override
|
|
public boolean isStarted() {
|
|
return started;
|
|
}
|
|
|
|
public Provider getPkcs11Provider() {
|
|
return pkcs11Provider;
|
|
}
|
|
|
|
public KeyStore getKeyStore() {
|
|
return keyStore;
|
|
}
|
|
|
|
public boolean isReady() {
|
|
return started && pkcs11Provider != null && keyStore != null;
|
|
}
|
|
|
|
/**
|
|
* isReady() 와 달리 실제 HSM 호출로 세션 생존 여부까지 확인하는 헬스체크.
|
|
* 모니터링/헬스체크 엔드포인트에서 사용을 권장한다.
|
|
*/
|
|
public boolean isHealthy() {
|
|
if (!isReady()) {
|
|
return false;
|
|
}
|
|
try {
|
|
logKeyStore(keyStore);
|
|
return true;
|
|
} catch (Exception e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// 모니터링용 조회 (HsmStatusController)
|
|
// -------------------------------------------------------------------------
|
|
|
|
/** 현재 연결에 사용 중인 설정 이름(PRIMARY/SECONDARY). 미연결이면 null. */
|
|
public String getActiveConfigName() {
|
|
HsmConfig config = this.activeConfig;
|
|
return (config == null) ? null : config.name;
|
|
}
|
|
|
|
/** 현재 secondary 설정으로 절체된 상태인지 여부. */
|
|
public boolean isUsingSecondaryConfig() {
|
|
return CONFIG_SECONDARY.equals(getActiveConfigName());
|
|
}
|
|
|
|
/** 현재 연결에 실제로 사용된 pkcs11.cfg 내용. PIN 은 포함되지 않는다. */
|
|
public String getActiveConfigContent() {
|
|
HsmConfig config = this.activeConfig;
|
|
return (config == null) ? null : config.configContent;
|
|
}
|
|
|
|
/**
|
|
* 현재 PropManager 값 기준으로 실제 적용될 pkcs11.cfg 내용을 후보별로 반환한다.
|
|
* PIN 은 포함하지 않는다. (설정이름 -> cfg 내용, primary 우선순)
|
|
*/
|
|
public java.util.Map<String, String> getResolvedConfigContents() {
|
|
java.util.Map<String, String> contents = new java.util.LinkedHashMap<>();
|
|
try {
|
|
for (HsmConfig config : loadConfigCandidates()) {
|
|
contents.put(config.name, config.configContent);
|
|
}
|
|
} catch (Exception e) {
|
|
logger.warn("HsmManager] 연결 후보 설정 조회 실패: " + e.getMessage());
|
|
}
|
|
return contents;
|
|
}
|
|
|
|
/** 현재 KeyStore 의 alias 목록. HSM 통신이 발생한다. */
|
|
public List<String> getKeyAliases() throws Exception {
|
|
KeyStore ks = this.keyStore;
|
|
if (ks == null) {
|
|
return Collections.emptyList();
|
|
}
|
|
List<String> aliases = new ArrayList<>();
|
|
java.util.Enumeration<String> e = ks.aliases();
|
|
while (e.hasMoreElements()) {
|
|
aliases.add(e.nextElement());
|
|
}
|
|
return aliases;
|
|
}
|
|
|
|
public String getProviderName() {
|
|
Provider provider = this.pkcs11Provider;
|
|
return (provider == null) ? null : provider.getName();
|
|
}
|
|
|
|
public long getReloadIntervalMinutes() {
|
|
return reloadIntervalMinutes;
|
|
}
|
|
|
|
/** 현재 설정으로 연결된 시각(epoch millis). 미연결이면 0. */
|
|
public long getActiveSince() {
|
|
return activeSince;
|
|
}
|
|
|
|
public long getLastReloadAt() {
|
|
return lastReloadAt;
|
|
}
|
|
|
|
public String getLastReloadResult() {
|
|
return lastReloadResult;
|
|
}
|
|
|
|
public String getLastErrorMessage() {
|
|
return lastErrorMessage;
|
|
}
|
|
|
|
public long getLastErrorAt() {
|
|
return lastErrorAt;
|
|
}
|
|
|
|
public int getReloadSuccessCount() {
|
|
return reloadSuccessCount;
|
|
}
|
|
|
|
public int getReloadFailCount() {
|
|
return reloadFailCount;
|
|
}
|
|
|
|
/** primary <-> secondary 절체가 발생한 횟수. */
|
|
public int getFailoverCount() {
|
|
return failoverCount;
|
|
}
|
|
}
|