# Spring Boot + Jasypt：同時使用兩組加解密設定（舊／新）實作指南
> 語言：繁體中文
> 目的：同一個 Spring Boot 專案中，同時支援 **舊**（`PBEWithMD5AndDES`、無 IV）與 **新**（`PBEWithHmacSHA512AndAES_256`、隨機 IV）兩套 Jasypt 設定。舊組態僅做相容；新資料一律用 AES-256。
---
## 目標
1. 程式碼中可以選擇使用「舊」或「新」加解密。
2. `application.yml` 等組態可同時支援兩種加密字串（便於平滑換代）。
---
## 實作總覽（兩層）
- **A. 程式碼手動加解密**：宣告兩個 `StringEncryptor` Bean，使用 `@Qualifier` 精準注入。
- **B. 組態自動解密**：提供「路由型」解密（支援 `ENC_NEW(...)`、`ENC_OLD(...)` 與相容用 `ENC(...)`）。
---
## A. 程式碼中手動加解密（兩個 Encryptor Bean）
`JasyptEncryptorsConfig.java`：
```java
import org.jasypt.encryption.StringEncryptor;
import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JasyptEncryptorsConfig {
// 舊：僅為相容（弱加密，無 IV）
@Bean("legacyEncryptor")
public StringEncryptor legacyEncryptor(
@Value("${jasypt.encryptor.password}") String legacyPassword) {
PooledPBEStringEncryptor enc = new PooledPBEStringEncryptor();
SimpleStringPBEConfig cfg = new SimpleStringPBEConfig();
cfg.setPassword(legacyPassword);
cfg.setAlgorithm("PBEWithMD5AndDES");
cfg.setIvGeneratorClassName("org.jasypt.iv.NoIvGenerator");
cfg.setPoolSize("1");
cfg.setStringOutputType("base64");
enc.setConfig(cfg);
return enc;
}
// 新：協力商 AES-256 版本（安全組態）
@Bean("encryptorBean")
public StringEncryptor encryptorBean() {
String p1 = System.getProperty("P_ENV_1");
String p2 = System.getProperty("P_ENV_2");
if (p1 == null || p1.isBlank() || "null".equalsIgnoreCase(p1)
|| p2 == null || p2.isBlank() || "null".equalsIgnoreCase(p2)) {
p1 = System.getenv("P_ENV_1");
p2 = System.getenv("P_ENV_2");
}
String salt = (p1 == null ? "" : p1) + (p2 == null ? "" : p2);
PooledPBEStringEncryptor enc = new PooledPBEStringEncryptor();
SimpleStringPBEConfig cfg = new SimpleStringPBEConfig();
cfg.setPassword(salt);
cfg.setAlgorithm("PBEWithHmacSHA512AndAES_256");
cfg.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");
cfg.setKeyObtentionIterations("1000");
cfg.setPoolSize("1");
cfg.setProviderName("SunJCE");
cfg.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
cfg.setStringOutputType("base64");
enc.setConfig(cfg);
return enc;
}
}
```
`CryptoService.java`：
```java
import org.jasypt.encryption.StringEncryptor;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class CryptoService {
private final StringEncryptor legacy;
private final StringEncryptor modern;
public CryptoService(@Qualifier("legacyEncryptor") StringEncryptor legacy,
@Qualifier("encryptorBean") StringEncryptor modern) {
this.legacy = legacy;
this.modern = modern;
}
public String encryptNew(String plain) { return modern.encrypt(plain); }
public String decryptNew(String cipher) { return modern.decrypt(cipher); }
public String decryptLegacy(String cipher) { return legacy.decrypt(cipher); }
// 簡易自動判斷：先試新，不行再回退舊
public String smartDecrypt(String cipher) {
try { return modern.decrypt(cipher); }
catch (Exception ignore) { /* fall through */ }
return legacy.decrypt(cipher);
}
}
```
---
## B. 組態層的自動解密（Routing + 多前綴）
**為何需要？** `ulisesbocchio/jasypt-spring-boot` 預設一次只會用一個 `jasypt.encryptor.bean` 去解 `ENC(...)`。若要同時支援兩種加密格式，建議引入自訂「偵測器/解析器」或「路由 Encryptor」，用**前綴**切換：
- `ENC_NEW(...)` → 用 **新** encryptor（AES-256）。
- `ENC_OLD(...)` → 用 **舊** encryptor（MD5+DES）。
- `ENC(...)` → 相容保留：先試新、再回退舊。
`JasyptRoutingConfig.java`：
```java
import com.ulisesbocchio.jasyptspringboot.detector.EncryptablePropertyDetector;
import com.ulisesbocchio.jasyptspringboot.resolver.EncryptablePropertyResolver;
import org.jasypt.encryption.StringEncryptor;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JasyptRoutingConfig {
@Bean("routingEncryptor")
public StringEncryptor routingEncryptor(
@Qualifier("legacyEncryptor") StringEncryptor legacy,
@Qualifier("encryptorBean") StringEncryptor modern) {
// 供需要時直接注入；Resolver 也會自行分流
return new StringEncryptor() {
@Override public String encrypt(String message) { return modern.encrypt(message); }
@Override public String decrypt(String encryptedMessage) {
try { return modern.decrypt(encryptedMessage); }
catch (Exception ignore) {}
return legacy.decrypt(encryptedMessage);
}
};
}
@Bean
public EncryptablePropertyDetector encryptablePropertyDetector() {
return value -> value != null &&
(value.startsWith("ENC_NEW(") || value.startsWith("ENC_OLD(") || value.startsWith("ENC("));
}
@Bean
public EncryptablePropertyResolver encryptablePropertyResolver(
@Qualifier("legacyEncryptor") StringEncryptor legacy,
@Qualifier("encryptorBean") StringEncryptor modern) {
return value -> {
if (value == null) return null;
if (value.startsWith("ENC_NEW(") && value.endsWith(")")) {
String body = value.substring("ENC_NEW(".length(), value.length() - 1);
return modern.decrypt(body);
}
if (value.startsWith("ENC_OLD(") && value.endsWith(")")) {
String body = value.substring("ENC_OLD(".length(), value.length() - 1);
return legacy.decrypt(body);
}
if (value.startsWith("ENC(") && value.endsWith(")")) {
String body = value.substring("ENC(".length(), value.length() - 1);
try { return modern.decrypt(body); }
catch (Exception ignore) { return legacy.decrypt(body); }
}
return value;
};
}
}
```
`application.yml`：
```yaml
jasypt:
encryptor:
bean: routingEncryptor # 讓 Resolver/Detector 生效，並提供 routing 能力
spring:
datasource:
password: "ENC_NEW(.....)" # 新格式（AES-256）
legacy:
token: "ENC_OLD(.....)" # 舊格式（MD5+DES）
other:
secret: "ENC(.....)" # 歷史相容：未標示新舊者
```
---
## C. 產出與轉換策略（實務）
- **新資料一律用 AES-256（`encryptorBean`）產生**；避免再寫入 MD5+DES。
- 舊資料保留解密能力一段時間（`legacyEncryptor`），逐步轉檔或在讀取時即時以新格式重寫。
- 在組態中改用 `ENC_NEW(...)`；只在必要時保留 `ENC_OLD(...)`。
---
## D. 常見落坑
- 原始片段常見誤植（`sait` → `salt`、`setAlgorithm` 拼寫、全形符號），範例已修正。
- `PBEWithMD5AndDES` + `NoIvGenerator` 安全性很弱；僅限相容期使用。
- `P_ENV_1` / `P_ENV_2` 取自 **JVM 系統屬性** 或 **環境變數** 時，請處理空字串與 `"null"`。
- 舊 JDK 需注意 AES-256 的政策檔；現代 JDK 已預設開啟，但仍建議在所有環境驗證。
---
## E. 最小可用配置清單
1. 宣告 `@Bean("legacyEncryptor")` 與 `@Bean("encryptorBean")`。
2. 若組態要同時解兩種格式：加上自訂 `EncryptablePropertyDetector` / `EncryptablePropertyResolver`，支援 `ENC_NEW(...)`、`ENC_OLD(...)`、`ENC(...)`。
3. 程式碼層以 `@Qualifier` 指定使用哪一組 Encryptor。
---
## F. 簡易測試（產生／驗證密文）
`JasyptQuickTest.java`：
```java
public class JasyptQuickTest {
public static void main(String[] args) {
// 假裝已從 Spring 取出兩個 Bean：legacy 與 modern
var legacy = new org.jasypt.encryption.pbe.StandardPBEStringEncryptor();
legacy.setPassword("vu4wj/3"); // 舊密碼：來自 application 設定
legacy.setAlgorithm("PBEWithMD5AndDES");
var modern = new org.jasypt.encryption.pbe.StandardPBEStringEncryptor();
modern.setPassword(System.getenv("P_ENV_1") + System.getenv("P_ENV_2"));
modern.setAlgorithm("PBEWithHmacSHA512AndAES_256");
String plain = "s3cr3t-P@ss!";
String oldCipher = legacy.encrypt(plain);
String newCipher = modern.encrypt(plain);
System.out.println("ENC_OLD(" + oldCipher + ")");
System.out.println("ENC_NEW(" + newCipher + ")");
// 驗證
System.out.println("legacy -> " + legacy.decrypt(oldCipher));
System.out.println("modern -> " + modern.decrypt(newCipher));
}
}
```
> 提示：正式專案請以 Spring 取得 Bean 進行測試；此處為最小可行示意。
---
## 版控建議
- 先導入「路由」與雙 Encryptor，確保服務可同時解兩種格式。
- 撰寫資料轉換腳本（批次或讀取即轉），逐步消除 `ENC_OLD(...)`。
- 清查完畢後，**移除舊 Encryptor** 與 `ENC_OLD(...)` 支援，降低攻擊面。
---
## 授權與安全
- 本指南僅示範 Jasypt 用法，不包含第三方授權檔。
- 實務上請搭配祕密管理（如 KMS、Vault、Kubernetes Secret）取代硬編碼密鑰。
# Spring Boot + Jasypt：同時使用兩組加解密設定（舊／新）實作指南



> 語言：繁體中文  

> 目的：同一個 Spring Boot 專案中，同時支援 **舊**（`PBEWithMD5AndDES`、無 IV）與 **新**（`PBEWithHmacSHA512AndAES_256`、隨機 IV）兩套 Jasypt 設定。舊組態僅做相容；新資料一律用 AES-256。



---



## 目標

1. 程式碼中可以選擇使用「舊」或「新」加解密。  

2. `application.yml` 等組態可同時支援兩種加密字串（便於平滑換代）。



---



## 實作總覽（兩層）

- **A. 程式碼手動加解密**：宣告兩個 `StringEncryptor` Bean，使用 `@Qualifier` 精準注入。  

- **B. 組態自動解密**：提供「路由型」解密（支援 `ENC_NEW(...)`、`ENC_OLD(...)` 與相容用 `ENC(...)`）。



---



## A. 程式碼中手動加解密（兩個 Encryptor Bean）



`JasyptEncryptorsConfig.java`：



```java

import org.jasypt.encryption.StringEncryptor;

import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;

import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;



@Configuration

public class JasyptEncryptorsConfig {



    // 舊：僅為相容（弱加密，無 IV）

    @Bean("legacyEncryptor")

    public StringEncryptor legacyEncryptor(

            @Value("${jasypt.encryptor.password}") String legacyPassword) {

        PooledPBEStringEncryptor enc = new PooledPBEStringEncryptor();

        SimpleStringPBEConfig cfg = new SimpleStringPBEConfig();

        cfg.setPassword(legacyPassword);

        cfg.setAlgorithm("PBEWithMD5AndDES");

        cfg.setIvGeneratorClassName("org.jasypt.iv.NoIvGenerator");

        cfg.setPoolSize("1");

        cfg.setStringOutputType("base64");

        enc.setConfig(cfg);

        return enc;

    }



    // 新：協力商 AES-256 版本（安全組態）

    @Bean("encryptorBean")

    public StringEncryptor encryptorBean() {

        String p1 = System.getProperty("P_ENV_1");

        String p2 = System.getProperty("P_ENV_2");

        if (p1 == null || p1.isBlank() || "null".equalsIgnoreCase(p1)

         || p2 == null || p2.isBlank() || "null".equalsIgnoreCase(p2)) {

            p1 = System.getenv("P_ENV_1");

            p2 = System.getenv("P_ENV_2");

        }

        String salt = (p1 == null ? "" : p1) + (p2 == null ? "" : p2);



        PooledPBEStringEncryptor enc = new PooledPBEStringEncryptor();

        SimpleStringPBEConfig cfg = new SimpleStringPBEConfig();

        cfg.setPassword(salt);

        cfg.setAlgorithm("PBEWithHmacSHA512AndAES_256");

        cfg.setIvGeneratorClassName("org.jasypt.iv.RandomIvGenerator");

        cfg.setKeyObtentionIterations("1000");

        cfg.setPoolSize("1");

        cfg.setProviderName("SunJCE");

        cfg.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");

        cfg.setStringOutputType("base64");

        enc.setConfig(cfg);

        return enc;

    }

}

```



`CryptoService.java`：



```java

import org.jasypt.encryption.StringEncryptor;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;



@Service

public class CryptoService {



    private final StringEncryptor legacy;

    private final StringEncryptor modern;



    public CryptoService(@Qualifier("legacyEncryptor") StringEncryptor legacy,

                         @Qualifier("encryptorBean") StringEncryptor modern) {

        this.legacy = legacy;

        this.modern = modern;

    }



    public String encryptNew(String plain) { return modern.encrypt(plain); }

    public String decryptNew(String cipher) { return modern.decrypt(cipher); }



    public String decryptLegacy(String cipher) { return legacy.decrypt(cipher); }



    // 簡易自動判斷：先試新，不行再回退舊

    public String smartDecrypt(String cipher) {

        try { return modern.decrypt(cipher); }

        catch (Exception ignore) { /* fall through */ }

        return legacy.decrypt(cipher);

    }

}

```



---



## B. 組態層的自動解密（Routing + 多前綴）

**為何需要？** `ulisesbocchio/jasypt-spring-boot` 預設一次只會用一個 `jasypt.encryptor.bean` 去解 `ENC(...)`。若要同時支援兩種加密格式，建議引入自訂「偵測器/解析器」或「路由 Encryptor」，用**前綴**切換：



- `ENC_NEW(...)` → 用 **新** encryptor（AES-256）。

- `ENC_OLD(...)` → 用 **舊** encryptor（MD5+DES）。

- `ENC(...)` → 相容保留：先試新、再回退舊。



`JasyptRoutingConfig.java`：



```java

import com.ulisesbocchio.jasyptspringboot.detector.EncryptablePropertyDetector;

import com.ulisesbocchio.jasyptspringboot.resolver.EncryptablePropertyResolver;

import org.jasypt.encryption.StringEncryptor;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;



@Configuration

public class JasyptRoutingConfig {



    @Bean("routingEncryptor")

    public StringEncryptor routingEncryptor(

            @Qualifier("legacyEncryptor") StringEncryptor legacy,

            @Qualifier("encryptorBean") StringEncryptor modern) {

        // 供需要時直接注入；Resolver 也會自行分流

        return new StringEncryptor() {

            @Override public String encrypt(String message) { return modern.encrypt(message); }

            @Override public String decrypt(String encryptedMessage) {

                try { return modern.decrypt(encryptedMessage); }

                catch (Exception ignore) {}

                return legacy.decrypt(encryptedMessage);

            }

        };

    }



    @Bean

    public EncryptablePropertyDetector encryptablePropertyDetector() {

        return value -> value != null &&

                (value.startsWith("ENC_NEW(") || value.startsWith("ENC_OLD(") || value.startsWith("ENC("));

    }



    @Bean

    public EncryptablePropertyResolver encryptablePropertyResolver(

            @Qualifier("legacyEncryptor") StringEncryptor legacy,

            @Qualifier("encryptorBean") StringEncryptor modern) {



        return value -> {

            if (value == null) return null;



            if (value.startsWith("ENC_NEW(") && value.endsWith(")")) {

                String body = value.substring("ENC_NEW(".length(), value.length() - 1);

                return modern.decrypt(body);

            }

            if (value.startsWith("ENC_OLD(") && value.endsWith(")")) {

                String body = value.substring("ENC_OLD(".length(), value.length() - 1);

                return legacy.decrypt(body);

            }

            if (value.startsWith("ENC(") && value.endsWith(")")) {

                String body = value.substring("ENC(".length(), value.length() - 1);

                try { return modern.decrypt(body); }

                catch (Exception ignore) { return legacy.decrypt(body); }

            }

            return value;

        };

    }

}

```



`application.yml`：



```yaml

jasypt:

  encryptor:

    bean: routingEncryptor   # 讓 Resolver/Detector 生效，並提供 routing 能力



spring:

  datasource:

    password: "ENC_NEW(.....)"   # 新格式（AES-256）



legacy:

  token: "ENC_OLD(.....)"        # 舊格式（MD5+DES）



other:

  secret: "ENC(.....)"           # 歷史相容：未標示新舊者

```



---



## C. 產出與轉換策略（實務）

- **新資料一律用 AES-256（`encryptorBean`）產生**；避免再寫入 MD5+DES。  

- 舊資料保留解密能力一段時間（`legacyEncryptor`），逐步轉檔或在讀取時即時以新格式重寫。  

- 在組態中改用 `ENC_NEW(...)`；只在必要時保留 `ENC_OLD(...)`。



---



## D. 常見落坑

- 原始片段常見誤植（`sait` → `salt`、`setAlgorithm` 拼寫、全形符號），範例已修正。  

- `PBEWithMD5AndDES` + `NoIvGenerator` 安全性很弱；僅限相容期使用。  

- `P_ENV_1` / `P_ENV_2` 取自 **JVM 系統屬性** 或 **環境變數** 時，請處理空字串與 `"null"`。  

- 舊 JDK 需注意 AES-256 的政策檔；現代 JDK 已預設開啟，但仍建議在所有環境驗證。



---



## E. 最小可用配置清單

1. 宣告 `@Bean("legacyEncryptor")` 與 `@Bean("encryptorBean")`。  

2. 若組態要同時解兩種格式：加上自訂 `EncryptablePropertyDetector` / `EncryptablePropertyResolver`，支援 `ENC_NEW(...)`、`ENC_OLD(...)`、`ENC(...)`。  

3. 程式碼層以 `@Qualifier` 指定使用哪一組 Encryptor。



---



## F. 簡易測試（產生／驗證密文）



`JasyptQuickTest.java`：



```java

public class JasyptQuickTest {



    public static void main(String[] args) {

        // 假裝已從 Spring 取出兩個 Bean：legacy 與 modern

        var legacy = new org.jasypt.encryption.pbe.StandardPBEStringEncryptor();

        legacy.setPassword("vu4wj/3"); // 舊密碼：來自 application 設定

        legacy.setAlgorithm("PBEWithMD5AndDES");



        var modern = new org.jasypt.encryption.pbe.StandardPBEStringEncryptor();

        modern.setPassword(System.getenv("P_ENV_1") + System.getenv("P_ENV_2"));

        modern.setAlgorithm("PBEWithHmacSHA512AndAES_256");



        String plain = "s3cr3t-P@ss!";



        String oldCipher = legacy.encrypt(plain);

        String newCipher = modern.encrypt(plain);



        System.out.println("ENC_OLD(" + oldCipher + ")");

        System.out.println("ENC_NEW(" + newCipher + ")");



        // 驗證

        System.out.println("legacy -> " + legacy.decrypt(oldCipher));

        System.out.println("modern -> " + modern.decrypt(newCipher));

    }

}

```



> 提示：正式專案請以 Spring 取得 Bean 進行測試；此處為最小可行示意。



---



## 版控建議

- 先導入「路由」與雙 Encryptor，確保服務可同時解兩種格式。  

- 撰寫資料轉換腳本（批次或讀取即轉），逐步消除 `ENC_OLD(...)`。  

- 清查完畢後，**移除舊 Encryptor** 與 `ENC_OLD(...)` 支援，降低攻擊面。



---



## 授權與安全

- 本指南僅示範 Jasypt 用法，不包含第三方授權檔。  

- 實務上請搭配祕密管理（如 KMS、Vault、Kubernetes Secret）取代硬編碼密鑰。
